一.文件操作

文件是存储在磁盘上的数据集合。文件可以包含各种类型的数据，如文本、图像、音频等等。

文件系统通过文件名和文件路径来定位和管理文件。文件名通常包含文件的名称和和扩展名。文件路径可以是绝对路径也可以是相对路径。

1.文件的分类

纯文本文件：有统一的编码，可以被看做存储在磁盘上的长字符串。

二进制文件：没有统一的字符编码，由0与1组成。

2.文件的路径

相对路径：从相对路径到指定位置的路径。

绝对路径：从根目录到指定位置的路径。

3.文件的打开和关闭

打开文件

使用open()打开或者创建文件，该方法执行完毕之后返回的是一个file对象

file_object = open(file_path, mode='r', encoding=None)
 

• file_path: 文件路径（绝对或相对路径）
• mode: 打开模式，常见选项：
  • 'r': 只读（默认），文件若不存在不会报错
  • 'w': 写入（覆盖原有内容），文件不存在会创建文件
  • 'a': 追加写入，文件不存在会创建文件
  • 'b': 二进制模式（如 'rb'）
  • '+': 读写模式（如 'r+'），能读能写
  • ‘x’:创建新文件并且写入，文件若存在会报错
• encoding: 指定编码（如 'utf-8'），避免乱码

文件关闭方法

file_object.close()

#建立连接（通过open方式打开文件）
file = open("text.txt","w")

#写入数据
file.write("hello world\n")
file.write("ni hao \n")

#关闭连接
file.close()

文件读取

使用内置函数 open() 打开文件，指定文件路径和模式（如 'r' 表示读取）。通过文件对象的 read() 方法获取内容，操作完成后需调用 close() 关闭文件。

file = open('example.txt', 'r')
content = file.read() #如果read(size)，加了参数size，表示从文件中读取的字符/字节数
file.close()
 

readlines和readline

调用 readlines() 方法时，不需要传递参数。它会返回文件中所有行的列表，每行末尾包含换行符 \n。

with open('example.txt', 'r') as file:
    lines = file.readlines()
 

readlines() 方法支持一个可选参数 hint，用于指定读取的字节数。当读取的字节数达到或超过 hint 时，停止读取。若未指定 hint，则读取整个文件。

with open('example.txt', 'r') as file:
    lines = file.readlines(100)  # 读取大约 100 字节的内容
 

• readline() 每次调用只读取一行，返回一个字符串。
• readlines() 一次性读取所有行，返回一个字符串列表。

与 read() 的区别

• read() 读取整个文件内容，返回一个字符串。
• readlines() 按行分割内容，返回字符串列表。

4.文件操作常用函数

以下是一些常见的文件操作函数及其用途的总结表格：

函数/方法	用途描述
open()	打开文件，返回文件对象。可以指定模式（如读取、写入、追加等）。
close()	关闭文件，释放系统资源。
read()	读取文件内容，可以指定读取的字节数。
readline()	读取文件的一行内容。
readlines()	读取文件的所有行，返回一个列表。
write()	将字符串写入文件。
writelines()	将字符串列表写入文件。
seek()	移动文件指针到指定位置。
tell()	返回文件指针的当前位置。
os.rename()	重命名文件或目录。
os.remove()	删除文件。
os.path.exists()	检查文件或目录是否存在。
os.path.isfile()	检查路径是否为文件。
os.path.isdir()	检查路径是否为目录。
os.path.getsize()	获取文件的大小（字节）。
shutil.copy()	复制文件到指定路径。
shutil.move()	移动文件或目录到指定路径。
shutil.rmtree()	递归删除目录及其内容。

# 打开文件并读取内容
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

# 写入文件
with open('output.txt', 'w') as file:
    file.write('Hello, World!')

# 检查文件是否存在
import os
if os.path.exists('example.txt'):
    print('File exists')
else:
    print('File does not exist')

# 复制文件
import shutil
shutil.copy('example.txt', 'backup.txt')

5.部分函数需要导入os模块

os 模块是 Python 中用于与操作系统交互的核心模块，提供了许多文件与目录操作的函数。以下是一些需要导入 os 模块的常用函数及其用途：

一定要执行 import os

os.remove(): 删除指定文件。

os.remove('file.txt')
 

os.rename(): 重命名文件或目录。

os.rename('old.txt', 'new.txt')
 

os.mkdir(): 创建单层目录。

os.mkdir('new_folder')
 

os.makedirs(): 递归创建多层目录。

os.makedirs('path/to/new_folder')

os.getcwd() 不需要任何参数，直接返回当前工作目录的字符串形式。例如：

import os
current_dir = os.getcwd()
print(current_dir)
 

6.os.walk() 的基本用法

os.walk() 是 Python 中用于递归遍历目录树的函数，返回一个生成器，每次迭代生成一个三元组 (root, dirs, files)。root 是当前遍历的目录路径，dirs是当前目录下的子目录列表，files 是当前目录下的文件列表。

import os

for root, dirs, files in os.walk(os.getcwd()): #os.getcwd()获取文件路径
    print(f"当前目录: {root}")
    print(f"子目录: {dirs}")
    print(f"文件: {files}")
 

7.文件拷贝

def copy_file(src,dest):
    #打开原文件
    src_file = open(src,'rb')
    #打开目标文件
    dest_file = open(dest,'wb')


    content = src_file.read(1024)
    while content:
        dest_file.write(content)
        content = src_file.read(1024)

""" 
简要写法：
    while content := src_file.read(1024)
        dest_file.write(content)
"""

    #关闭源文件
    src_file.close()
    #关闭目标文件
    dest_file.close()


copy_file(src:"d:\\hug.png" , dest:"e:\\hua.png")

二.面向对象之类和对象

面向过程编程（Procedural Programming）以过程（函数）为核心，强调程序的执行流程。代码由一系列函数组成，每个函数完成特定任务，通过函数调用来组织程序逻辑。

特点：

• 程序结构简单直观，适合解决线性问题。
• 数据与操作分离，函数通常处理外部传入的数据。
• 代码复用通过函数调用实现。

面向对象编程（Object-Oriented Programming, OOP）以对象为核心，将数据和方法封装在对象中。主要特性包括封装、继承和多态。

特点：

• 程序由对象组成，对象包含属性和方法。
• 通过类和实例实现代码复用与扩展。
• 更适合复杂系统建模，提高代码可维护性。

核心概念：

• 封装：隐藏对象内部细节，暴露接口。
• 继承：子类继承父类特性，实现代码复用。
• 多态：同一接口在不同条件下表现不同行为。

面向过程举例：

# 定义计算圆面积的函数
def calculate_area(radius):
    return 3.14159 * radius ** 2

# 定义计算圆周长的函数
def calculate_circumference(radius):
    return 2 * 3.14159 * radius

# 主程序
radius = float(input("请输入圆的半径: "))
area = calculate_area(radius)
circumference = calculate_circumference(radius)

print(f"圆的面积: {area:.2f}")
print(f"圆的周长: {circumference:.2f}")
 

面向对象举例：

class Dog:
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

    def bark(self):  # 实例方法
        print(f"{self.name} says: Woof!")
 
my_dog = Dog("Buddy", 3)  # 创建Dog类的实例
print(my_dog.name)        # 输出: Buddy
my_dog.bark()             # 输出: Buddy says: Woof!

1.面向对象相关概念

对象：万物皆对象，在自然界中只要是客观存在的事物都是对象

类：类是对大量对象的共性的抽象（关注有什么---属性，能做什么---方法）；类是创建对象的模板。

2.定义类

通过 class 关键字定义，用于创建对象。类可以包含属性（变量）和方法（函数）。

class Person:
    """人的类"""
    #属性 -- 类属性(所有类创建出来的对象共用)
    home = "earth"

    #方法
    def __init__(self,name,age):
        #属性--实例属性（每个类创建出来的对象独有）
        self.name = name
        self.age = age

    def eat(self):
        print(f"{self.name} is eating")

说明：

类是对大量共性的抽象，其中主要定义了属性和方法

calss是一个关键字，主要用来标记定义类

person是当前类的类名

类名后的：必须要加

缩进后的内容是类体

属性

        类属性：所有类创建出来的对象（实例）共用

        实例属性：每个类创建出来的对象独有

方法

        实例方法

修改类属性的影响

通过类名修改类属性会影响所有未重写该属性的实例。直接修改实例属性仅影响当前实例。

class Dog:
    species = "Canis familiaris"

dog1 = Dog()
dog2 = Dog()
Dog.species = "New species"  # 修改类属性
print(dog1.species)  # 所有实例同步更新
print(dog2.species)
 

3.类的操作：成员引用和实例化

成员引用：直接通过类名访问类中的成员

class MyClass:
    class_var = "Class Variable"  # 类变量
    def __init__(self, value):
        self.instance_var = value  # 实例变量
    def instance_method(self):
        return self.instance_var

# 类成员引用
print(MyClass.class_var)  # 输出: Class Variable

# 实例成员引用
obj = MyClass("Instance Value")
print(obj.instance_var)    # 输出: Instance Value
print(obj.instance_method())  # 输出: Instance Value
 

class Person:
    """人的类"""
    #属性 -- 类属性(所有类创建出来的对象共用)
    home = "earth"

    #方法
    def __init__(self,name,age):
        #属性--实例属性（每个类创建出来的对象独有）
        self.name = name
        self.age = age

    def eat(self):
        print(f"{self.name} is eating")


#类操作
home = Person.home #输出earth
eat_fuc = Person.eat #输出函数<function Person.eat at 0x00002342had22323>
doc = Person.__doc__ #类说明文档

实例化：通过类 创建对象

实例化是创建类的具体对象的过程，通过调用类的构造函数（如 __init__）完成。

• 语法：object_name = Class_name(arguments)，其中 arguments传递给构造函数。
• 关键点：
  • 实例化时会自动调用 __init__ 方法初始化对象。
  • 每个实例拥有独立的实例变量，类变量被所有实例共享。

class Person:
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age

    def eat(self):
        print(f"{self.name} is eating")
# 实例化
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)
print(person1.name)  # 输出: Alice
print(person2.age)   # 输出: 25
person1.eat() #输出Alice is eating

4.__init__方法

在定义类的时候，__init__不是必须的

它主要作用是在创建类的对象时，对对象的属性进行初始化。当你使用类名创建一个新的对象时，python会自动调用它，并将新创建的对象作为第一个参数（通常命名为self）传递给它。

注意：

self：这是一个约定俗成的参数名，它代表类的实例对象本身。在方法内部，通过self可以访问和修改对象的属性。

__init__方法不是必须的。如果类中没有定义，python会使用默认的构造函数，该构造函数不执行任何操作。

__init__方法只能返回none，不能返回其他值。如果尝试返回其他值，会引发typeerror异常

Python 中的 __new__ 和 __init__ 方法

__new__ 和 __init__ 是 Python 中用于对象初始化的两个特殊方法，它们在对象创建过程中扮演不同的角色。

__new__ 方法

__new__ 是一个静态方法，负责创建并返回类的实例。它在 __init__ 之前被调用，通常用于控制实例的创建过程。

class MyClass:
    def __new__(cls, *args, **kwargs):
        print("__new__ called")
        instance = super().__new__(cls)
        return instance

__init__ 方法

__init__ 是一个实例方法，负责初始化新创建的对象。它在 __new__ 返回实例后被调用。

class MyClass:
    def __init__(self, value):
        print("__init__ called")
        self.value = value

• __init__ 的第一个参数是 self，表示当前实例。
• 不需要返回值，默认返回 None。
• 主要用于设置实例的初始属性。

区别对比

特性	__new__	__init__
调用顺序	先调用	后调用
参数	cls	self
返回值	必须返回实例	无返回值
主要用途	控制实例创建	初始化实例属性
是否必须定义	不定义时使用父类的 __new__	可选

5.self

self作为实例穿参。调用实例方法时候，实例对象会作为第一个参数被传入。因此，我们调用p.eat()相当于调用了Person.eat（p）

class Person:
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age

    def eat(self):
        print(f"{self.name} is eating")

p = Person(“liujie”)
p.eat() #和Person.eat(p) 一样

通过self在类中调用类的实例属性和实例方法

实例属性通常在 __init__ 方法中定义，并通过 self访问或修改：

class MyClass:
    def __init__(self, value):
        self.value = value  # 定义实例属性
    
    def show_value(self):
        print(self.value)  # 通过self访问实例属性
 

• self.value 是实例属性，每个实例的 value 可以不同。
• 在类的方法中，通过 self.value 可以读取或修改该属性。

实例方法通过 self 调用其他实例方法：

class MyClass:
    def method1(self):
        print("Method 1 called")
    
    def method2(self):
        self.method1()  # 通过self调用另一个实例方法
        print("Method 2 called")
 

• self.method1() 调用了同一个类中的 method1方法。
• 实例方法必须通过 self 调用，否则会报错。

实例属性可以在任何实例方法中动态修改：

class Counter:
    def __init__(self):
        self.count = 0
    
    def increment(self):
        self.count += 1  # 修改实例属性
    
    def get_count(self):
        return self.count
 

6.类属性

也叫类变量。在类中方法外定义的属性

通过 类名.属性名 或 实例名.属性名 访问

class Person:
    """人的类"""
    #属性 -- 类属性(所有类创建出来的对象共用)
    home = "earth"


print(Person.home)
p1 = Person()
print(p1.home)

通过 类名.属性名 添加与修改类属性

class Person:
    """人的类"""
    #属性 -- 类属性(所有类创建出来的对象共用)
    home = "earth"



print(Person.home) #输出earth
p1 = Person()
print(p1.home) #输出earth

Person.home = "xupu"
print(Person.home) #输出xupu

若用实例名.属性名 则会创建或者修改实例属性，因此不建议类属性和实例属性同名

class Person:
    """人的类"""
    #属性 -- 类属性(所有类创建出来的对象共用)
    home = "earth"



print(Person.home) #输出earth
p1 = Person()
p1.home = "xupu"
print(p1.home) #输出xupu

p2 = Person()
print(p2.home) #输出earth

所有该类的实例共享同一个类属性

class Person:
    """人的类"""
    #属性 -- 类属性(所有类创建出来的对象共用)
    home = "earth"



print(Person.home) #输出earth
p1 = Person()
p1.home = "xupu"
print(p1.home) #输出xupu

p2 = Person()
print(p2.home) #输出earth

Person.home = "mars"
print(p1.home) #输出xupu
print(p2.home) #输出mars

7.实例属性

一般在__init__方法中定义实例属性

class Person
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print(""eating)

person1 = Person("liujie",24)

Python 允许在类外部直接为实例添加新属性：

person1.school = uibe  # 动态添加属性
print(person1.school)  # 输出: uibe
 

使用 del 关键字可删除实例属性：

del person1.school  # 删除属性
 

8.类的方法

三种方法：实例方法、静态方法、类方法

实例方法：在类中定义，第一个参数为self，代表实例本身；实例方法只能被实例对象调用；可以访问实例属性、类属性、类方法。

class Person:
    home = "earth"

    def __init__(self,name)
        self.name = name

    def m2(self):
        print("m2222")

    def m1(self):
        print("self.name")
        print(Person.home)
        self.m2() #等价于Person.m2()

zs = Person("zs")
zs.m1()

类方法

在类中通过@classmethod定义，第一个参数为cls，代表本身类。

类方法可以被类和实例对象调用

可以访问类属性

在不创建实例的情况下调用，通过类名直接调用，非常方便，适合一些和类整体相关的操作

class Person:
    """human beings"""

    home = "earth"

    @classmethod
    def class_method(cls):
        print(cls.home)
        print(cls.__doc__)

zs = Person("zs")
Person.class_method() #通过类名可以直接访问类方法

静态方法

在Python中，静态方法是通过@staticmethod装饰器定义的类方法。静态方法不需要访问类实例（self）或类本身（cls），与普通函数类似，但逻辑上属于类的命名空间。

class MathUtils:
    @staticmethod
    def m1():
        print("niu")

# 通过类调用
result = MathUtils.m1() # 输出 niu

# 通过实例调用（不推荐）
util = MathUtils()
result = util.m1()  # 输出 niu
 

9.在类外定义方法

并非必须在类中进行方法定义，也可以将一个函数对象复制给一个类内局部变量

"""例子1"""
def external_method(self):
    return "This is an external method"

class MyClass:
    pass

# 将外部函数绑定为实例方法
MyClass.external_method = external_method

# 使用
obj = MyClass()
print(obj.external_method())  # 输出: This is an external method
 

"""例子2"""
def m5(self,x,y)
    print(x+y)

class Myc:
    f1 = m5

Myc().f1(1,2) #输出3

10.魔法方法

魔法方法（Magic Methods）是 Python 中一类特殊的方法，以双下划线 __ 开头和结尾。它们用于定义类的行为，例如初始化、运算符重载、对象表示等。

常用魔法方法分类

1. 初始化与构造
__init__(self, ...)：构造函数，在对象创建时调用。
__new__(cls, ...)：创建实例时调用，通常用于不可变类型的定制。
__del__(self)：析构函数，在对象销毁时调用。使用del xxx时候,不会执行__del__

2. 对象表示
__str__(self)：定义对象的字符串表示（str(obj) 或 print(obj)）。
__repr__(self)：定义对象的官方字符串表示（repr(obj)）。
__format__(self, format_spec)：定义对象的格式化输出（format(obj, spec)）。

3. 运算符重载
__add__(self, other)：定义 + 运算符行为。
__eq__(self, other)：定义 == 运算符行为。
__lt__(self, other)：定义 < 运算符行为。
__getitem__(self, key)：定义索引访问 obj[key]。
__setitem__(self, key, value)：定义索引赋值 obj[key] = value。

4. 上下文管理
__enter__(self)：定义 with 语句的入口行为。
__exit__(self, exc_type, exc_val, exc_tb)：定义 with 语句的退出行为。

5. 属性访问
__getattr__(self, name)：访问不存在的属性时调用。
__setattr__(self, name, value)：设置属性时调用。
__delattr__(self, name)：删除属性时调用。

class Vector:
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2  # 隐式调用__add__
 

class Example:
    def __str__(self):
        return "字符串表示"

obj = Example()
print(obj.__str__())  # 可行但不推荐
print(str(obj))       # 正确触发__str__的方式
 

__new__ 是 Python 中用于创建实例的特殊方法，通常用于定制不可变类型或实现单例模式等场景。以下是关于 __new__ 的关键点：

def __new__(cls, *args, **kwargs):
    return super().__new__(cls, *args, **kwargs)
 

• cls 表示当前类，由 Python 自动传入。
• 必须返回一个实例对象（通常是父类的 __new__结果）。

对于不可变类型（如 int, str, tuple），修改行为需在 __new__ 中实现，因为实例创建后无法修改。例如：

class PositiveInt(int):
    def __new__(cls, value):
        if value <= 0:
            raise ValueError("Value must be positive")
        return super().__new__(cls, value)
 

11.动态给实例添加属性与方法

动态给对象添加属性

class MyClass:
    pass

obj = MyClass()
obj.new_attribute = "value"  # 直接赋值添加属性
 

动态给类添加属性

class MyClass:
    pass

obj = MyClass()
obj.new_attr = "value"  # 动态添加实例属性
MyClass.class_attr = "class_value"  # 动态添加类属性
 
print(obj.class_attr) #"class_value" 

给实例添加普通方法

普通方法的第一个参数通常是 self，它代表类的实例。通过 self，方法可以访问实例的属性和其他方法。

class MyClass:
    def my_method(self, arg1, arg2):
        # 方法体
        return arg1 + arg2
 

class Person:
    def __init__(self,name = none):
        self.name = name


def eat():
    print("eating")

p1 = Person("zs")
p1.eat = eat #把函数赋值给p1的eat属性
p1.eat() #打印 eating

给实例添加实例方法

给对象添加的实例方法只绑定在当前对象上，不对其他对象生效，而且需要传入self参数，需要使用types.MethodType（方法名，实例对象）来添加实例方法

import types

class MyClass:
    pass

def custom_method(self, arg1, arg2):
    print(f"实例属性值: {self.attr}, 参数: {arg1}, {arg2}")

obj = MyClass()
obj.attr = "value"  # 添加实例属性
obj.dynamic_method = types.MethodType(custom_method, obj) #动态添加实例方法
obj.custom_method()
 

12.动态给类添加方法

给类添加的方法对他的对象都生效，添加类方法需要传入cls参数，添加静态方法则不需要

class Person:
    home = "earth"

    def __init__(self,name = none):
        self.name = name

#定义类方法
@classmethod
def come_from(cls):
    print(f"来自{cls.home}")

#定义静态方法
@staticmethod
def static_function():
    print("static function")

Person.come_from = come_from
person.static_function = static_function

#调用
Person.come_from()
Person.static_function()

13.动态删除属性和方法

del 对象.属性名

delatter(对象，属性名)

class Person:
    home = "earth"

    def __init__(self,name = none):
        self.name = name

P = Person("zs")
del p.name #此时p的这个name属性会被抹除 即没有name这个属性，p还在
del p #此时p不在了

14.__slots__限制实例属性与实例方法

python允许在定义类的时候，定义一个特殊的__slots__变量，来限制该类的实例能添加的属性。使用__slots__可以限制添加实例属性和实例方法，但类属性、类方法和静态方法还可以添加。__slots__仅对当前类生效，对子类无效。

class Person:
    __slots__ = ['name', 'age']

p = Person()
p.name = 'Alice'  # 允许
p.age = 25       # 允许
p.gender = 'F'   # 报错：AttributeError
 

class Calculator:
    __slots__ = ['value']

    def __init__(self, value):
        self.value = value

c = Calculator(10)
c.add = lambda x: x + c.value  # 报错：AttributeError