Python 3 入门与进阶(九):面向对象编程(上)——类与对象

大家好，我是煜道。

今天我们一起来学习 面向对象编程（上）——类与对象。

引言

面向对象编程（Object-Oriented Programming，简称OOP）是一种程序设计范式，它将程序中的数据和操作数据的方法组织在一起，形成"对象"。通过对象之间的交互来完成程序功能。Python从设计之初就是一门面向对象的语言，它全面支持面向对象编程的三大特征：封装、继承和多态。

本文将深入探讨Python面向对象编程的基础知识，包括类的定义、对象的创建、属性和方法的访问控制、构造函数以及类与对象的关系。通过系统学习，我们将能够运用面向对象的思想来设计和实现Python程序。

01 面向对象基础概念

1.1 类与对象的定义

类是创建对象的蓝图或模板，它定义了具有相同属性和行为的对象集合。对象是类的实例，是类的具体实现。

classPerson:"""人类"""pass# 创建类的实例（对象）person1 = Person()person2 = Person()print(type(person1))  # <class '__main__.Person'>print(isinstance(person1, Person))  # True

1.2 类与对象的关系

1.3 类的组成

classPerson:"""人类（示例类）"""# 类变量（所有实例共享）    species = "智人"# 初始化方法（构造函数）def__init__(self, name, age):# 实例变量        self.name = name        self.age = age# 实例方法defgreet(self):"""打招呼"""returnf"Hello, I'm {self.name}"defbirthday(self):"""生日增长"""        self.age += 1

02 属性

2.1 类变量与实例变量

classPerson:# 类变量    species = "智人"    count = 0# 记录创建的实例数量def__init__(self, name, age):# 实例变量        self.name = name        self.age = age        Person.count += 1# 使用类变量print(Person.species)  # 智人print(Person.count)    # 0# 创建实例alice = Person("Alice", 25)print(alice.species)      # 通过实例访问print(alice.name)         # Aliceprint(alice.count)        # 1（类变量被修改）bob = Person("Bob", 30)print(bob.count)          # 2print(Person.count)       # 2

2.2 属性查找顺序

Python首先在实例中查找属性，然后在其类中查找：

classPerson:    species = "智人"# 类变量def__init__(self, name):        self.name = name  # 实例变量alice = Person("Alice")print(alice.name)   # 'Alice'（实例变量）print(alice.species)  # '智人'（类变量）# 修改实例变量不影响类变量alice.species = "人"print(alice.species)    # '人'（实例的）print(Person.species)   # '智人'（类的）# 使用类名修改类变量Person.species = "人"print(Person.species)   # '人'print(alice.species)    # '人'（找到类的）

2.3 dict属性

classPerson:    species = "智人"def__init__(self, name, age):        self.name = name        self.age = agealice = Person("Alice", 25)# 实例的__dict__print(alice.__dict__)# {'name': 'Alice', 'age': 25}# 类的__dict__print(Person.__dict__)# {'__module__': '__main__', 'species': '智人',#  '__init__': <function Person.__init__ at 0x...>,#  '__dict__': <attribute '__dict__' of 'Person' objects>,#  '__weakref__': <attribute '__weakref__' of 'Person' objects>,#  '__doc__': None}

03 方法

3.1 实例方法

实例方法的第一个参数是self，代表类的实例本身：

classCalculator:defadd(self, a, b):"""加法"""return a + bcalc = Calculator()print(calc.add(2, 3))  # 5# 等价于print(Calculator.add(calc, 2, 3))  # 5

3.2 类方法

类方法使用@classmethod装饰器，第一个参数是cls，代表类本身：

classPerson:    count = 0def__init__(self, name):        self.name = name        Person.count += 1    @classmethoddefget_count(cls):return cls.count    @classmethoddefcreate_anonymous(cls):return cls("Anonymous", 0)# 调用类方法print(Person.get_count())    # 0p1 = Person("Alice")print(Person.get_count())    # 1# 通过实例调用（cls仍为类）p2 = Person("Bob")print(p2.get_count())        # 2

3.3 静态方法

静态方法使用@staticmethod装饰器，不需要self或cls参数：

classMathUtils:    @staticmethoddefadd(a, b):return a + b    @staticmethoddefis_even(n):return n % 2 == 0# 调用静态方法print(MathUtils.add(2, 3))       # 5print(MathUtils.is_even(10))     # True# 静态方法也可以通过实例调用m = MathUtils()print(m.add(2, 3))               # 5

3.4 方法的存储

方法作为函数存储在类的__dict__中，实例调用时自动绑定：

classPerson:defgreet(self):returnf"Hello!"p = Person()# 类中的greet是函数print(Person.__dict__['greet'])  # <function greet at 0x...># 实例中的greet是绑定方法print(p.greet)  # <bound method Person.greet of <__main__.Person object>>print(p.greet())  # Hello!

04 构造函数

4.1 init方法

__init__是构造函数，在创建实例时自动调用：

classPerson:def__init__(self, name, age=0):        self.name = name        self.age = agealice = Person("Alice", 25)  # __init__被调用bob = Person("Bob")          # 使用默认值age=0

4.2 new方法

__new__是实际创建实例的方法，__init__负责初始化：

classSingleton:    _instance = Nonedef__new__(cls):if cls._instance isNone:            cls._instance = super().__new__(cls)return cls._instances1 = Singleton()s2 = Singleton()print(s1 is s2)  # True（单例）

05 访问控制

5.1 公有成员

默认情况下，类的成员是公有的：

classPerson:def__init__(self, name):        self.name = name  # 公有p = Person("Alice")print(p.name)  # 可以访问

5.2 保护成员（单下划线）

单下划线前缀表示"保护"成员，约定不应从外部访问：

classPerson:def__init__(self, name, _age):        self.name = name        self._age = _age  # 保护成员p = Person("Alice", 25)print(p._age)  # 仍可访问，但不建议

5.3 私有成员（双下划线）

双下划线前缀会触发名称修饰：

classPerson:def__init__(self, name, age):        self.name = name        self.__age = age  # 私有成员defget_age(self):return self.__agep = Person("Alice", 25)print(p.name)      # Alice（公有）print(p.get_age()) # 25（通过方法访问）# print(p.__age)  # AttributeError# 名称修饰：实际存储为_Person__ageprint(p._Person__age)  # 25（不推荐）

5.4 访问属性的方式

classPerson:def__init__(self, name):        self.name = namedef__str__(self):returnf"Person({self.name})"# __repr__用于调试def__repr__(self):returnf"Person('{self.name}')"p = Person("Alice")print(str(p))     # Person(Alice)print(repr(p))    # Person('Alice')# dir()列出所有属性print(dir(p))

06 特殊方法

6.1 对象生命周期特殊方法

classExample:def__new__(cls, *args, **kwargs):        print("创建实例")return super().__new__(cls)def__init__(self):        print("初始化")def__del__(self):        print("删除实例")e = Example()# 输出：# 创建实例# 初始化# 删除实例（当对象被销毁时）

6.2 比较运算特殊方法

classVector:def__init__(self, x, y):        self.x = x        self.y = ydef__eq__(self, other):return self.x == other.x and self.y == other.ydef__lt__(self, other):return self.x < other.x or (self.x == other.x and self.y < other.y)def__repr__(self):returnf"Vector({self.x}, {self.y})"v1 = Vector(1, 2)v2 = Vector(1, 2)v3 = Vector(0, 1)print(v1 == v2)  # Trueprint(v1 < v3)   # False

6.3 数值运算特殊方法

classNumber:def__init__(self, value):        self.value = valuedef__add__(self, other):return Number(self.value + other.value)def__mul__(self, other):return Number(self.value * other.value)def__str__(self):return str(self.value)n1 = Number(5)n2 = Number(3)n3 = n1 + n2  # 调用 __add__n4 = n1 * n2  # 调用 __mul__print(n3)  # 8print(n4)  # 15

07 面向对象设计原则

7.1 单一职责原则

每个类应该只有一个引起变化的原因：

# 不好的设计：一个类负责多项职责classUser:def__init__(self, name, email):        self.name = name        self.email = emaildefsave(self):# 保存到数据库passdefsend_email(self):# 发送邮件pass# 好的设计：分离职责classUser:def__init__(self, name, email):        self.name = name        self.email = emailclassUserRepository:defsave(self, user):passclassEmailService:defsend(self, user, message):pass

7.2 开放-封闭原则

对扩展开放，对修改封闭：

# 好的设计：通过继承扩展新功能classShape:defarea(self):passclassCircle(Shape):def__init__(self, radius):        self.radius = radiusdefarea(self):return3.14 * self.radius ** 2classRectangle(Shape):def__init__(self, width, height):        self.width = width        self.height = heightdefarea(self):return self.width * self.height

08 小结

本文介绍了Python面向对象编程的基础知识：

1. 类与对象：类是创建对象的蓝图，对象是类的实例。
2. 属性：类变量与实例变量的区别，属性查找顺序。
3. 方法：实例方法、类方法、静态方法的定义和使用。
4. 构造函数：__init__和__new__的作用。
5. 访问控制：公有、保护、私有成员的约定。
6. 特殊方法：对象生命周期、比较运算、数值运算等特殊方法。
7. 设计原则：单一职责、开放-封闭等面向对象设计原则。

面向对象编程是一种强大的程序设计范式，它帮助我们组织代码、复用逻辑、降低复杂度。