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

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. 继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法，提高代码复用性。

class Animal:
    def __init__(self, species):
        self.species = species

    def speak(self):
        print("动物发出声音")

class Cat(Animal):
    def speak(self):
        print("猫咪喵喵叫")

my_cat = Cat("猫")
my_cat.speak()

重点说明：

• 子类通过在括号内指定父类名来继承，如 class Cat(Animal)。
• 子类可以重写父类的方法，实现特定的行为。

2. 多态

多态指的是不同的类对象对同一方法有不同的实现。

class Circle:
    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle:
    def area(self):
        return self.width * self.height

circle = Circle()
circle.radius = 5
print(f"圆形面积：{circle.area()}")

rectangle = Rectangle()
rectangle.width = 4
rectangle.height = 6
print(f"矩形面积：{rectangle.area()}")

函数功能介绍：

• 虽然 Circle 和 Rectangle 类的 area 方法实现不同，但都可以通过统一的方式调用。

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

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.id

s1 = 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)：定义对象相减的行为，对应 - 运算符。

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

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

v1 = Vector(3, 4)
v2 = Vector(1, 2)
v3 = v1 - v2
print(v3.x, v3.y) 

• __mul__(self, other)、__truediv__(self, other)、__floordiv__(self, other) 等：分别对应 *、/、// 等运算符。

4. 容器相关方法

• __len__(self)：定义对象的长度，对应 len() 函数。

class MyList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)

my_list = MyList([1, 2, 3, 4])
print(len(my_list)) 

• __getitem__(self, key)：定义通过索引或键访问对象元素的行为，对应 obj[key] 操作。

class MyList:
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return self.items[index]

my_list = MyList([1, 2, 3, 4])
print(my_list[2]) 

• __setitem__(self, key, value)：定义通过索引或键设置对象元素的行为，对应 obj[key] = value 操作。
• __delitem__(self, key)：定义通过索引或键删除对象元素的行为，对应 del obj[key] 操作。

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()}")

七、闭坑指南

属性访问错误

• 错误操作：在方法中未通过self访问对象属性，或者访问不存在的属性；混淆类属性和实例属性的访问与修改方式。
• 解决方法：在类的方法中，始终使用 self 来访问属性；在使用属性前，确保其已被正确初始化或动态添加；修改类属性时，通过类名进行操作，避免通过实例名意外创建同名实例属性 。

继承理解错误

• 错误操作：子类继承父类后，未正确调用父类方法，或者重写方法时逻辑错误。
• 解决方法：如果子类需要保留父类方法的部分功能，可以使用super() 调用父类方法；重写方法时，仔细检查逻辑是否符合需求。

魔法方法误用

• 错误操作：随意定义魔法方法，导致与 Python 内置逻辑冲突；未按照魔法方法的规范实现功能。
• 解决方法：在使用魔法方法前，充分了解其用途和参数要求；遵循 Python 的约定，避免自定义不符合规范的魔法方法。

对象生命周期混淆

• 错误操作：在对象已被销毁后，尝试访问其属性或调用方法；不理解对象的创建和销毁时机。
• 解决方法：明确对象的作用域，避免在不合适的地方使用已失效的对象；必要时，可以手动释放资源（虽然 Python 有垃圾回收机制）。

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

• 错误操作：将需要访问实例属性的方法定义为类方法或静态方法；在静态方法中试图访问类属性或实例属性。
• 解决方法：根据方法的功能和对属性的依赖情况，准确选择使用实例方法、类方法或静态方法 。如果方法只涉及类属性，可定义为类方法；若方法与类和实例的状态均无关，则定义为静态方法。

八、总结回顾

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

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