title: 类，对象，文件操作 date: 2025-8-14 00:00:00

类，对象，文件操作

类和对象

1、概念

类：是一种抽象，用于描述一类事物的共性特征和行为；定义了属性（成员变量）和方法（函数）；类本身不能直接使用，需要实例化对象

对象：是类的具体实例，每个对象都有类定义的属性和方法，但属性的值可以不同，对象才是程序实际操作的实体

方法：类中定义的函数

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：定义在方法中的变量，只作用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化：创建一个类的实例，类的具体对象

2、类和对象的关系

对象属于某个类：对象是类的实例 ，因此类包含对象的定义能力；类提供了模板（属性和方法），对象继承了这些模板

类本身不包含对象：类定义了对象的结构，但类本身不会自动生成对象

总结：

类是模板，对象是实例

一个类可以生成多个对象

在单继承情况下，对象只能属于一个类

3、类的专有方法

__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

示例

类对象

#!/usr/bin/python3
 
class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

类的方法

#!/usr/bin/python3
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

继承

#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()

多继承

#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

方法重写

#!/usr/bin/python3
 
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

文件操作

1、打开和关闭文件

# 打开文件
f = open('example.txt', 'r')  # 'r' 表示只读模式
# 关闭文件
f.close()

模式说明

模式	描述
'r'	读取文件（默认）
'w'	写入文件（会覆盖原文件）
'a'	追加内容到文件末尾
'rb'	以二进制读取文件
'wb'	以二进制写入文件

注意：使用文件一定要关闭，推荐使用with自动管理

with open('example.txt', 'r') as f:
    data = f.read()
# 文件自动关闭

2、读取文件内容

# 读取全部内容
with open('example.txt', 'r') as f:
    content = f.read()

# 按行读取
with open('example.txt', 'r') as f:
    lines = f.readlines()  # 返回列表，每行一个元素

# 一行一行读取（节省内存）
with open('example.txt', 'r') as f:
    for line in f:
        print(line.strip())  # strip去掉换行符

3、写入文件内容

# 写入（覆盖）
with open('example.txt', 'w') as f:
    f.write("Hello Python\n")

# 追加
with open('example.txt', 'a') as f:
    f.write("追加内容\n")

4、文件和目录基本操作(使用OS和shutil模块)

import os

# 当前工作目录
print(os.getcwd())

# 列出目录内容
print(os.listdir('.'))

# 创建目录
os.mkdir('new_folder')

# 创建多级目录
os.makedirs('folder/subfolder', exist_ok=True)

# 删除文件
os.remove('example.txt')

# 删除空目录
os.rmdir('new_folder')

# 删除非空目录
import shutil
shutil.rmtree('folder')

5、路径操作

import os

# 拼接路径（推荐使用）
path = os.path.join('folder', 'file.txt')

# 判断路径是否存在
print(os.path.exists(path))

# 判断是文件还是目录
print(os.path.isfile(path))
print(os.path.isdir(path))

6、读写大文件

# 逐行处理大文件
with open('bigfile.txt', 'r') as f:
    for line in f:
        process(line)  # 自定义处理函数

7、读写二进制文件（图片，音频）

# 读取图片
with open('image.png', 'rb') as f:
    data = f.read()

# 写入图片
with open('copy.png', 'wb') as f:
    f.write(data)

8、文件指针操作

with open('example.txt', 'r') as f:
    print(f.read(5))  # 读取前5个字符
    f.seek(0)         # 移动到开头
    print(f.readline())

9、文件内容处理技巧

# 文件按行处理并去重
with open('example.txt', 'r') as f:
    unique_lines = set(line.strip() for line in f)

# 文件排序
with open('example.txt', 'r') as f:
    lines = sorted(line.strip() for line in f)

# 文件批量处理
import glob

for filename in glob.glob('folder/*.txt'):
    with open(filename) as f:
        print(f.read())

10、JSON，CSV等文件操作

# JSON文件
import json

# 读取
with open('data.json', 'r') as f:
    data = json.load(f)

# 写入
with open('data.json', 'w') as f:
    json.dump(data, f, indent=4)

# CSV文件
import csv

# 读取
with open('data.csv', newline='') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 写入
with open('data.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['name', 'age'])
    writer.writerow(['Alice', 30])

11、常见注意事项

文件路径建议使用os.path 或pathlib，避免跨平台问题。

对大文件操作时，尽量使用按行读取，避免一次性读入内存。

写文件时注意w会覆盖，a会追加。

对二进制文件必须使用 'rb'/'wb' 模式。