当前位置：首页 > news >正文

Python中class对象/属性/方法/封装/继承/多态/魔法方法详解

news 来源：原创 2025/6/25 14:57:49

一、基础入门：认识类和对象

1. 类和对象的概念

2. 类的基本结构

3. 创建类和对象

二、属性与方法：深入了解对象特征

1. 属性和方法的分类

2. 实例属性和实例方法

3. 类属性

三、类方法和静态方法：特殊的方法类型

1. 类方法

2. 静态方法

四、封装、继承与多态：提升代码复用性和灵活性

1 封装

2 类的多态

3 类的继承

super函数调用父类的构造方法

重写父类方法

多重继承

五、魔法方法：赋予对象特殊能力

1. 构造和析构方法

2. 比较方法

3. 算术运算方法

4. 容器相关方法

5.字符串表示方法

六、实际案例展示

案例 1：学生管理系统

案例 2：图形绘制模拟

七、闭坑指南

1）属性访问错误

2）继承理解错误

3）魔法方法误用

4）对象生命周期混淆

5）类方法、静态方法使用混淆

八、总结回顾

九、class 对象常用函数与方法汇总

文章略长，需要读者耐心看完，谢谢！

一、基础入门：认识类和对象

1. 类和对象的概念

在 Python 中，类（class）是一种抽象的概念，用于定义对象的属性和行为，而对象（也称为实例）则是类的具体表现。比如，“汽车” 可以是一个类，它有颜色、品牌、速度等属性，也有启动、加速、刹车等行为；而一辆具体的 “红色特斯拉Model3” 就是 “汽车” 类的一个对象。

2. 类的基本结构

class Car:    def __init__(self, color, brand):        self.color = color        self.brand = brand    def start(self):        print(f"{self.brand} {self.color}汽车启动了！")    def accelerate(self):        print("汽车加速中...")

__init__ 方法是构造函数，用于在创建对象时初始化对象的属性，self代表对象本身。

start 和 accelerate是类的方法，用于定义对象的行为。

3. 创建类和对象

class Dog:    def __init__(self, name, age):        self.name = name        self.age = age    def bark(self):        print(f"{self.name}汪汪叫！")#创建Dog类的对象my_dog = Dog("小白", 3)my_dog.bark()
my_dog = Dog("小黑", 4)my_dog.bark()

关键要点：

调用类名并传入参数（如果有），即可创建对象，如 Dog("小白", 3)。通过对象名调用方法，如 my_dog.bark()。

二、属性与方法：深入了解对象特征

1. 属性和方法的分类

类的属性和方法是对象的核心组成部分，属性分为类属性和实例属性，方法分为实例方法、类方法和静态方法。

2. 实例属性和实例方法

实例属性会因为类对象的不同而不同。

class Person:    def __init__(self, name, gender):        self.name = name        self.gender = gender    def introduce(self):        print(f"我叫{self.name}，性别{self.gender}。")
person1 = Person("Alice", "女")person1.introduce()person1.age = 25  # 动态添加属性print(f"{person1.name}的年龄是{person1.age}岁。")#输出为：我叫Alice，性别女。Alice的年龄是25岁。
person1 = Person("Jams", "男")person1.introduce()person1.age = 29  # 动态添加属性print(f"{person1.name}的年龄是{person1.age}岁。")#输出为我叫Jams，性别男。Jams的年龄是29岁。

说明：

实例属性可以在__init__方法中初始化，也可以在创建对象后动态添加。
实例属性可通过self.属性来访问。
实例方法是类中定义的普通的函数，函数中可以使用实例属性。

3. 类属性

类属性是属于类本身的属性，它被类的所有实例共享。

class Company:    company_name = "ABC 公司"  # 类属性
    def __init__(self, employee_name):        self.employee_name = employee_name  # 实例属性
emp1 = Company("张三")emp2 = Company("李四")print(Company.company_name)  # 通过类名访问类属性print(emp1.company_name)  # 通过实例访问类属性print(emp1.employee_name)  # 访问实例属性#输出为：ABC 公司ABC 公司张三
Company.company_name = "XYZ 公司"  # 修改类属性print(emp2.company_name)  # 所有实例的类属性都被修改#输出为：XYZ 公司
emp2.company_name =  "YYY 公司"  # 通过实例修改类属性print(emp2.company_name)print(emp1.company_name)print(Company.company_name) #输出为： 类属性其实没有被修改YYY 公司XYZ 公司XYZ 公司

注意事项：

类属性可以通过类名或实例名访问，但通过实例名修改类属性时，实际上是为该实例创建了一个同名的实例属性，不会影响类属性本身。
类属性常用于定义一些全局的、共享的数据，如配置信息等。

三、类方法和静态方法：特殊的方法类型

1. 类方法

类方法是与类相关联的方法，它不需要实例化对象即可调用，并且只能访问类属性，不能访问实例属性。在定义类方法时，需要使用 @classmethod装饰器，第一个参数通常为cls，代表类本身。

class MathUtils:    pi = 3.1415926    @classmethod    def circle_area(cls, radius):        return cls.pi * radius ** 2
area = MathUtils.circle_area(5)print(f"半径为 5 的圆面积：{area}")

应用场景：

当方法的操作只涉及类属性，不依赖于实例的状态时，适合定义为类方法。
类方法还常用于创建对象的替代构造函数，例如从不同的数据格式中创建对象。

2. 静态方法

静态方法是一种不依赖于类和实例的方法，它不需要传递self或cls参数，相当于定义在类中的普通函数。使用@staticmethod装饰器来定义静态方法。

class StringUtils:    @staticmethod    def reverse_string(s):        return s[::-1]
result = StringUtils.reverse_string("Hello, World!")print(f"反转后的字符串：{result}")

使用特点：

静态方法不能访问类属性和实例属性，也不能调用类方法和实例方法，它仅仅是将函数逻辑与类进行了逻辑上的分组。
当某个功能与类有一定关联，但又不需要访问类或实例的状态时，可定义为静态方法，提高代码的组织性。

四、封装、继承与多态：提升代码复用性和灵活性

1 封装

封装是指将类中的属性或者方法在类中内部实现，不对外暴露，外界只能通过接口调用，而不能修改类中的内部实现。比如在类中定义一个方法返回内部的一些私有属性值。

举例：定义Car类，定义三个私有属性（私有属性以双下划线开头‘__’）,封装一个方法print_property用来打印定义的私有属性。

class Car():  def __init__(self,brand,color,cost_performance):    self.__brand = brand    self.__color = color    self.__cost_performance = cost_performance    def print_property(self):    print(f'汽车品牌：{self.__brand} 颜色:{self.__color } 性价比:{self.__cost_performance}')

类实例化后，执行print_property方法。

Mercedes_Benz = Car('GLC260','black','不高')
Mercedes_Benz.print_property()
结果打印：
汽车品牌：GLC260 颜色:black 性价比:不高

当我们直接访问下私有属性时，会报错：

Mercedes_Benz.__brand
#打印结果：
AttributeError: 'Car' object has no attribute '__brand'

私有属性可以通过“实例名._类名__私有属性”来访问，如下

print(Mercedes_Benz._Car__brand)

2 类的多态

多态指的是同一个对象在不同情况下具有不同的表现形式和功能。一般使用在子类继承父类的时候，重写父类方法，虽然调用了相同方法，但实现了不同的功能。

举例：定义Car类，SuvCar子类和NsuvCar子类继承Car类，子类重写print_property方法。

class Car():  def __init__(self,brand,color,cost_performance):    self.__brand = brand    self.__color = color    self.__cost_performance = cost_performance  def print_property(self):    print(f'汽车品牌：{self.__brand} 颜色:{self.__color } 性价比:{self.__cost_performance}')
class SuvCar(Car):  def __init__(self,brand,color,cost_performance):    super().__init__(brand,color,cost_performance)  def print_property(self):    print(f'{self._Car__brand}汽车是SUV')
class NsuvCar(Car):  def __init__(self,brand,color,cost_performance):    super().__init__(brand,color,cost_performance)  def print_property(self):    print(f'{self._Car__brand}汽车不是SUV')

子类分别进行实例化，并调用print__property方法，发现虽然调用的是相同的方法，但是实现的功能确不相同。

suv = SuvCar('GLC260','black','low')
suv.print_property()
nsuv = NsuvCar('C200','white','high')
nsuv.print_property()
结果：
GLC260汽车是SUV
C200汽车不是SUV

3 类的继承

我们定义新的类称为子类（Subclass），而被继承的类称为基类或父类。子类可自动获得父类的全部变量和方法，省去了重复劳动，同时又可以对父类方法或者属性进行重写，或者追加新的属性或者方法。其语法结构如下：

class xxxx(A, B,C....):

pass

Python支持单继承或者多继承。子类在调用某个方法或属性时，会优先在自己内部查找，如果没有找到，则开始根据继承机制在父类里查找。如果有多个父类，则根据特定的搜索顺序方式逐一查找父类

super函数调用父类的构造方法

继承时，有时我们需要直接调用父类的构造方法，几种方法如下都可使用

类名.__init__(self, args)
super().__init__(args)
super(子类名，子类的实例).__init__(args)

举例：定义Car类，SuvCar子类/BusCar子类/ECar类都继承Car类，子类分别通过上述说明的三种方式的super函数调用父类的构造方法。

class Car():  def __init__(self,brand,color,cost_performance):    print('我是父类')    self.__brand = brand    self.__color = color    self.__cost_performance = cost_performance
class SuvCar(Car):  def __init__(self,brand,color,cost_performance):    print('我是SuvCar类')    Car.__init__(self,brand,color,cost_performance)
class BusCar(Car):  def __init__(self,brand,color,cost_performance):    print('我是BusCar类')    super().__init__(brand,color,cost_performance)
class ECar(Car):  def __init__(self,brand,color,cost_performance):    print('我是ECar类')    super(ECar,self).__init__(brand,color,cost_performance)

类实例化后，结果显示都调用了父类的初始化方法。

SuvCar('宋','black','high')
BusCar('yutong','black','high')
ECar('宋','black','high')
#打印结果：
我是SuvCar类
我是父类
我是BusCar类
我是父类
我是ECar类
我是父类

重写父类方法

举例：定义Car类，SuvCar子类继承Car类，子类重写print_property函数

class Car():  def __init__(self,brand,color,cost_performance):    print('我是父类')    self.__brand = brand    self.__color = color    self.__cost_performance = cost_performance
class SuvCar(Car):  def __init__(self,brand,color,cost_performance):    print('我是SuvCar类')    Car.__init__(self,brand,color,cost_performance)  def print_property(self):    print(f'{self._Car__brand}汽车是SUV')

类实例化后调用print_property方法，结果显示调用的是子类重写的方法。

Suv = SuvCar('宋','black','high')
Suv.print_property()
打印结果如下：
我是SuvCar类
我是父类
宋汽车是SUV

多重继承

多重继承指的是继承多个父类，举例：定义ECar子类，继承父类BusCar,SuvCar。

class Car():  def __init__(self,brand,color,cost_performance):    print('我是父类')    self.__brand = brand    self.__color = color    self.__cost_performance = cost_performance
class SuvCar(Car):  def __init__(self,brand,color,cost_performance):    print('我是SuvCar类')    Car.__init__(self,brand,color,cost_performance)  def print_property(self):    print(f'{self._Car__brand}汽车是SUV')
class BusCar(Car):  def __init__(self,brand,color,cost_performance):    print('我是BusCar类')    super().__init__(brand,color,cost_performance)
class ECar(BusCar,SuvCar):  def __init__(self,brand,color,cost_performance):    print('我是ECar类')    super(ECar,self).__init__(brand,color,cost_performance)

Python的多重继承虽然增强了扩展性，但如果父类和子类中存在同名方法或变量，则在调用过程中会由于版本、初始化方式、搜索顺序等的不同给程序运行结果带来冲突或不确定性，在实际使用过程中要慎重使用。

可以通过mro()函数看下父类的查找顺序，python3版本采用的是从左到右的顺序查找父类。

print(ECar.mro())
结果如下：
[<class'__main__.ECar'>, <class'__main__.BusCar'>, <class'__main__.SuvCar'>, <class'__main__.Car'>, <class'object'>]

实例化后，调用print_property方法
ecar = ECar('宋','black','high')
ecar.print_property()

结果如下：依次调用了父类的初始化方法，print_property方法调用的是SuvCar类的方法。

我是ECar类
我是BusCar类
我是SuvCar类
我是父类
宋汽车是SUV

五、魔法方法：赋予对象特殊能力

Python 中有许多以 __ 开头和结尾的魔法方法，用于实现特殊功能。

1. 构造和析构方法

__init__(self, ...)：前面已经介绍过，它是构造函数，用于在创建对象时初始化对象的属性。

class Point:    def __init__(self, x, y):        self.x = x        self.y = y

__del__(self)：析构函数，当对象被销毁时调用。不过由于Python有垃圾回收机制，此方法的使用场景相对较少。

class Resource:    def __init__(self):        print("资源已创建")    def __del__(self):        print("资源已释放")res = Resource()del res

2. 比较方法

__eq__(self, other)：定义对象相等的比较规则，对应 == 运算符

class Student:    def __init__(self, id):        self.id = id    def __eq__(self, other):        return self.id == other.ids1 = Student(1)s2 = Student(1)print(s1 == s2)

__ne__(self, other)：定义对象不相等的比较规则，对应 !=运算符。通常如果实现了 __eq__，Python 会自动处理 __ne__，但也可以手动实现。
__lt__(self, other)、__le__(self, other)、__gt__(self, other)、__ge__(self, other)：分别对应 <、<=、>、>= 运算符，用于定义对象之间的大小比较规则。

class Rectangle:    def __init__(self, width, height):        self.width = width        self.height = height    def area(self):        return self.width * self.height    def __lt__(self, other):        return self.area() < other.area()r1 = Rectangle(2, 3)r2 = Rectangle(4, 5)print(r1 < r2)

3. 算术运算方法

常用到的算术方法如下：

__add__(self, other)：实现加法+操作。

__sub__(self, other)：实现减法-操作。

__mul__(self, other)：实现乘法*操作。

__floordiv__(self, other)：实现使用//操作符的整数除法。

__div__(self, other)：实现使用/操作符的除法。

__mod__(self, other)：实现%取余操作。

__divmod__(self, other)：实现 divmod 内建函数。__pow__：实现冥运算**操作

__lshift__(self, other)：实现左移位运算符<<。

__rshift__(self, other)：实现右移位运算符>>。

__and__(self, other)：实现按位与运算符&。

__or__(self, other)：实现按位或运算符|。

__xor__(self, other)：实现按位异或运算符^。

举例：定义一个类，初始化时随机生成一个整数。

import randomclass rnum(object):  def __init__(self,num):  	self.num = random.randint(0,num)  def __add__(self,other:int):  	print('使用了__add__')  	return self.num + other  def __sub__(self,other:int):  	print('使用了__sub__')  	return self.num - other  def __mul__(self, other:int):  	print('使用了__mul__')  	return self.num * other  def __floordiv__(self, other:int):  	print('使用了__floordiv__')  	return self.num // other  def __mod__(self,other:int):  	print('使用了__mod__')  	return self.num % other  def __divmod__(self,other:int):  	print('使用了__divmod__')  	return divmod(self.num,other)  def __pow__(self,other:int):  	print('使用了__pow__')  	return self.num ** other  def __lshift__(self,other:int):  	print('使用了__lshift__')  	return self.num << other  def __rshift__(self,other:int):  	print('使用了__rshift__')  	return self.num >> other  def __and__(self,other:int):  	print('使用了__and__')  	return self.num & other  def __or__(self,other:int):  	print('使用了__or__')  	return self.num | other  def __xor__(self,other:int):  	print('使用了__xor__')  	return self.num ^ other

初始化类，并计算如下：

1）按数值计算

newnum = rnum(100)
print(f'newnum.num = {newnum.num}')
print(f'加法： {newnum + 3}')
print(f'减法 ： {newnum - 3}')
print(f'乘法 ： {newnum * 3}')
print(f'//除法 ： {newnum // 3}')
print(f'计算余数 ： {newnum % 3}')
print(f'计算商和余数 ： {divmod(newnum,3)}')
print(f'计算冥次 ： {newnum ** 3}')

#结果

newnum.num=41
使用了__add__
加法：44
使用了__sub__
减法：38
使用了__mul__
乘法：123
使用了__floordiv__
//除法：13
使用了__mod__
计算余数：2
使用了__divmod__
计算商和余数：(13,2)
使用了__pow__
计算冥次：68921

2）按位进行计算：指转换为2进制后的一些计算
print(f'计算左移<< ： {newnum << 3}')
print(f'计算右移>> ： {newnum >> 3}')
print(f'计算位与& ： {newnum & 3}')
print(f'计算位或｜ ： {newnum | 3}')
print(f'计算位异或^ ： {newnum ^ 3}')

#结果

使用了__lshift__
计算左移<<：328
使用了__rshift__
计算右移>>：5
使用了__and__
计算位与&：1
使用了__or__
计算位或｜：43
使用了__xor__
计算位异或^：42

解释按位计算的示例：

print(f'数字41的2进制数：{bin(41)}')
print(f'2进制转为10进制数：{int("0b101001",base=2)}')#0b101001 整体往左移3位变成0b101001000
print(f'2进制转为10进制数：{int("0b101001000",base=2)}')#0b101001 整体往右移3位变成0b101
print(f'2进制转为10进制数：{int("0b101",base=2)}')#0b101001 与数字3（0b11） 做&的运算 得到0b000001
print(f'2进制转为10进制数：{int("0b000001",base=2)}')#0b101001 与数字3（0b11） 做|的运算 得到0b101011
print(f'2进制转为10进制数：{int("0b101011",base=2)}')#0b101001 与数字3（0b000011） 做^的运算 得到0b101010
print(f'2进制转为10进制数：{int("0b101010",base=2)}')

结果：跟上面按位运算的结果一致

数字41的2进制数：:0b101001
2进制转为10进制数：:41
2进制转为10进制数：:328
2进制转为10进制数：:5
2进制转为10进制数：:1
2进制转为10进制数：:43
2进制转为10进制数：:42

补充知识：

按位左移：将一个数的各二进制位全部左移若干位，右边多出的位将用0填充。
按位右移：将一个数的各二进制位全部右移若干位，左边多出的位将用0填充。
按位与：只有当两个对应位都为1时，结果才为1，否则结果为0
按位或：只要有一个对应位为1时，结果就为1，都为0时结果为0
按位异或：相同为0，不同为1：如果两个比较的位相同，则结果为0；如果不同，则结果为1。

4. 容器相关方法

__len__(self)：定义对象的长度，对应len()函数。
__getitem__(self, key)：定义通过索引或键访问对象元素的行为，对应 obj[key] 操作。
__setitem__(self, key, value)：定义通过索引或键设置对象元素的行为，对应 obj[key] = value 操作。
__delitem__(self, key)：定义通过索引或键删除对象元素的行为，对应 del obj[key] 操作

class MyList:    def __init__(self, items):        self.items = items    def __len__(self):        return len(self.items)
    def __getitem__(self, index):        return self.items[index]
    def __setitem__(self, index,value):        self.items[index] = value
    def __delitem__(self, index):        del self.items[index]my_list = MyList([1, 2, 3, 4])
print(my_list[2]) #-> 3print(len(my_list))  #-> 4my_list[2] = 5   #-> [1, 2, 5, 4]del my_list[3]   #-> [1, 2, 5]

5.字符串表示方法

__str__(self)：返回对象的字符串表示，用于 print()函数和str()函数。前面已有示例。
__repr__(self)：返回对象的 “官方” 字符串表示，通常用于调试和开发环境。如果未实现 __str__，print() 也会调用 __repr__。

class Point:    def __init__(self, x, y):        self.x = x        self.y = y    def __repr__(self):        return f"Point({self.x}, {self.y})"p = Point(1, 2)print(repr(p))

六、实际案例展示

案例 1：学生管理系统

class Student:    school_name = "阳光中学"  # 类属性    def __init__(self, name, id_number, grade):        self.name = name        self.id_number = id_number        self.grade = grade    def show_info(self):        print(f"姓名：{self.name}，学号：{self.id_number}，年级：{self.grade}，学校：{self.school_name}")students = [    Student("张三", "2023001", "一年级"),    Student("李四", "2023002", "二年级")]for student in students:    student.show_info()

案例 2：图形绘制模拟

class Shape:    shape_count = 0  # 类属性    def __init__(self):        Shape.shape_count += 1    def draw(self):        print("绘制图形")    @classmethod    def get_shape_count(cls):        return cls.shape_count    @staticmethod    def shape_type():        return "通用图形"
class Triangle(Shape):    def draw(self):        print("绘制三角形")
class Square(Shape):    def draw(self):        print("绘制正方形")
shapes = [    Triangle(),    Square()]
for shape in shapes:    shape.draw()print(f"图形总数：{Shape.get_shape_count()}")print(f"图形类型：{Shape.shape_type()}")

七、闭坑指南

1）属性访问错误

错误操作：在方法中未通过self访问对象属性，或者访问不存在的属性；混淆类属性和实例属性的访问与修改方式。

解决方法：在类的方法中，始终使用 self 来访问属性；在使用属性前，确保其已被正确初始化或动态添加；修改类属性时，通过类名进行操作，避免通过实例名意外创建同名实例属性。

2）继承理解错误

错误操作：子类继承父类后，未正确调用父类方法，或者重写方法时逻辑错误。

解决方法：如果子类需要保留父类方法的部分功能，可以使用super() 调用父类方法；重写方法时，仔细检查逻辑是否符合需求。

3）魔法方法误用

错误操作：随意定义魔法方法，导致与 Python 内置逻辑冲突；未按照魔法方法的规范实现功能。

解决方法：在使用魔法方法前，充分了解其用途和参数要求；遵循 Python 的约定，避免自定义不符合规范的魔法方法。

4）对象生命周期混淆

错误操作：在对象已被销毁后，尝试访问其属性或调用方法；不理解对象的创建和销毁时机。

解决方法：明确对象的作用域，避免在不合适的地方使用已失效的对象；必要时，可以手动释放资源（虽然 Python 有垃圾回收机制）。

5）类方法、静态方法使用混淆

错误操作：将需要访问实例属性的方法定义为类方法或静态方法；在静态方法中试图访问类属性或实例属性。

解决方法：根据方法的功能和对属性的依赖情况，准确选择使用实例方法、类方法或静态方法。如果方法只涉及类属性，可定义为类方法；若方法与类和实例的状态均无关，则定义为静态方法。

八、总结回顾

本章我们学习并掌握了从基础的类和对象创建，到属性、方法的深入运用，再到继承、多态和魔法方法的高级特性，在后续实践中我们要避开常见的 “坑点”，多实践不同案例，在Python编程的世界里搭建出属于自己的精彩程序。

九、class 对象常用函数与方法汇总

函数 / 方法	功能	示例
__init__(self, ...)	构造函数，初始化对象属性	def __init__(self, name, age): self.name = name; self.age = age
self.属性名	访问对象属性	print(self.name)
对象名.方法名()	调用对象方法	my_dog.bark()
super().__init__(...)	在子类中调用父类构造函数	super().__init__(species)
__add__(self, other)	定义对象相加行为	def __add__(self, other): return Point(self.x + other.x, self.y + other.y)
__str__(self)	返回对象的字符串表示	def __str__(self): return f"({self.x}, {self.y})"
类名.类属性	访问类属性	print(Company.company_name)
@classmethod 装饰的方法	定义类方法，可访问类属性	@classmethod<br>def circle_area(cls, radius):<br> return cls.pi * radius ** 2
@staticmethod 装饰的方法	定义静态方法，独立于类和实例	@staticmethod<br>def reverse_string(s):<br> return s[::-1]
__del__(self)	析构函数，对象销毁时调用	def __del__(self): print("对象已销毁")
__eq__(self, other)	定义对象相等比较规则	def __eq__(self, other): return self.id == other.id
__lt__(self, other)	定义对象小于比较规则	def __lt__(self, other): return self.area() < other.area()
__len__(self)	定义对象长度	def __len__(self): return len(self.items)
__getitem__(self, key)	定义通过索引或键访问元素行为	def __getitem__(self, index): return self.items[index]
__repr__(self)	返回对象官方字符串表示	def __repr__(self): return f"Point({self.x}, {self.y})"