随着脚本的增长，您最终会在函数之间传递同一组变量，并且很难区分哪些数据属于哪个逻辑。 Python 类和对象 通过将数据和行为捆绑到一个单元中来解决这一问题。

在本教程中，我们将逐步构建一个小型银行帐户，并且仅在每个 OOP 想法解决问题时才添加它。我们在 Python 3.13 上运行了每个示例，显示的输出来自该运行。如果您不熟悉该语言，请先阅读我们的 Python 初学者教程。

什么是类和对象？

类描述了某事物是什么以及它可以做什么。 对象，也称为实例，是根据该描述创建的特定对象。 “Account”是一个类，而Asha的帐户和Ben的帐户是两个对象。

你一直在使用对象。在Python中，字符串、列表甚至函数都是对象，这就是你可以编写"hello".upper()的原因。

你的第一堂课

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ 每当您创建对象时都会自动运行，并设置起始状态。存入a并没有触及b，因为每个对象都有自己的数据。请注意，该方法还可以保护余额免受错误值的影响。我们的 Python 异常处理 指南更深入地解释了 raise。

什么是自我？

self 只是方法正在处理的对象。当您编写 a.deposit(50) 时，Python 会有效地调用 Account.deposit(a, 50)，并将对象作为第一个参数传入。这就是一个方法定义可以服务于每个对象的方式。

名称 self 是一个强约定而不是关键字，但始终使用它。在方法定义中忘记它是初学者最常见的错误，并且它会产生有关参数数量的令人困惑的消息。

类属性与实例属性

直接在类主体中设置的属性由所有对象共享。 self 上的一组仅属于该对象。此示例显示查找的行为方式：

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

最后一行让人们感到惊讶。通过a分配并没有改变共享值。它在 a 上创建了一个新的实例属性，隐藏了类 1。 Python 首先查看对象，然后查看类。

特殊（dunder）方法

带有双下划线的方法使您的对象可以使用 Python 的内置功能。如果没有它们，打印帐户将显示无用的内存地址。添加两个使其成为可读的形式：

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

继承

继承允许新类重用现有类并仅更改不同的部分。这里，Savings 是带有额外设置的 Account：

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super()调用父版本，因此不重复设置逻辑。 deposit 按原样继承，__str__ 被覆盖以添加标签。仅将继承用于真正的“is a”关系。如果一个类仅需要某些东西，例如汽车需要引擎，则将该对象作为属性提供给它。这称为组合，它通常比深度继承链更灵活。

多态性

多态性意味着不同的对象可以以自己的方式响应相同的方法调用。调用代码不需要知道确切的类型：

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

这两个类甚至不共享父类。 Python 只关心对象是否有一个 area 方法，这种方法称为 ducktyping。稍后添加 Triangle 不需要更改循环。

封装和特性

Python 没有真正的私有属性，而是依赖于约定。单个下划线，如 _price 中所示，告诉其他开发人员“这是内部的，请不要触摸”。要在设置值时检查值，请使用 property，它从外部看起来像一个普通属性：

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

这意味着您可以从普通属性开始，然后添加验证，而无需更改使用该类的任何代码。因此，不要像在 Java 中那样出于习惯而编写 get_price() 和 set_price() 方法。这里的@语法是一个装饰器，我们在Python装饰器解释中对此进行了解释。

类方法和静态方法

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

数据类

当一个类主要保存数据时，手写__init__、__repr__和__eq__是很乏味的。 @dataclass 从类型注释生成它们：

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

常见错误

使用可变类属性

这是一个经典的错误。该列表是在类上定义的，因此所有购物车都共享它：

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

在 __init__ 和 self.items = [] 中创建它，以便每个对象都有自己的列表。

其他常见错误

• 忘记self。在方法内部编写self.balance，而不是balance。
• 忘记super().__init__()。 子级会错过父级设置的属性。
• 构建庞大的类。 一个包揽一切的类很难测试。按责任划分。
• 深度继承。 两个级别通常就足够了，并且组合通常更清晰。
• 不编写测试。带有规则的类很容易测试，正如我们的pytest教程所示，使用小推车。

最后的话

面向对象的 Python 归根结底是将数据与保护数据的行为进行分组。从 __init__、方法和 __str__ 开始，然后在遇到它们解决的问题时添加继承和属性。下一步，采用一个脚本，在各处传递相同的几个变量，并将它们变成一个小类。

常见问题

继续学习