返回探索
指南VibeFix 内容整理更新于 2026年11月22日

把书做成对象,把规矩写进类里:Python 类与对象

类是把数据和规矩打包在一起的办法:一个 Book 类做出每本书自己的状态,方法让对象自己干活,继承让电子书站在纸书肩膀上。本文按 Python 官方教程第 9 章讲清楚:class 与 __init__、self、方法、类变量与实例变量、属性查找、继承与覆盖、super()、下划线私有约定、dataclass、__iter__ 与 __next__,另附虚构晨光书店记账脚本第三个月 100 次翻车的分布。

真实照片:一家独立书店的书架走道,木质书架上摆满了彩色书脊,暖色灯光

先把这篇的边界说清楚。这是「Python 基础」系列第三篇,接着前两篇往下走:第一篇讲了怎么把数、字、清单存进变量,用 if、for、while 让程序自己做决定、自己重复干活;第二篇讲了怎么把重复的活收进函数、把文件拆成模块。这篇讲类:怎么把一堆相关的数据和操作它们的办法打包在一起,做出一个「对象」;怎么让新东西继承旧东西的本事。类和异常处理是两回事:这篇只讲类怎么做对象、怎么继承,异常处理留给下一篇。下面用到的「晨光书店」还是那个虚构的练手项目:一家街边小书店,店主想用 Python 写个记账小脚本。到第二篇结束时,脚本已经能算库存总值、能给贵书打九折,用的都是函数和字典。这篇要解决的新问题是:书越卖越多,字典越写越散,每本书的规矩都得靠人记着,很容易记错。所有关于类与对象的说法,都来自 Python 官方教程第 9 章《Classes》,来源见每篇的 meta 信息与 evidence 记录;本文所有以晨光书店为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。读完这篇,你应该能做到四件事:会写一个带 __init__ 的类,做出能自己存状态的对象;分得清类变量和实例变量,知道共用的东西该放哪;会用继承做出新类,知道方法覆盖是怎么回事;知道下划线私有约定和 dataclass、迭代器这些「顺手工具」该在什么时候用。

第一步:什么时候该用类——字典装得下数据,装不下规矩

先看书店脚本走到哪了。第一篇里一本书是字典:{'title': '三体', 'price': 59.0, 'stock': 7};打折是函数,算库存总值是函数,卖书改库存也是函数。书只有三五本的时候这套办法挺好使,可书一多就出问题:每本书的规矩都散落在各个函数里,打折规则写在 discounted_price() 里,卖书的检查写在 sell() 里,库存不能为负这个规矩又得每个改库存的地方各写一遍。漏写一处,账就错一处。我的判断是:当你发现「这些数据」和「对这些数据的规矩」总是一起出现、形影不离的时候,就该考虑把它们收到一个地方去。这个地方就是类。

官方教程第 9 章开篇第一句就把这件事说清楚了:类是把数据和功能打包在一起的办法。创建一个新类,就是创建一种新的对象类型;每个类的实例都可以带上自己的属性来保存状态,类里定义的方法可以改这些状态。换成人话:类是一张「做法说明书」加一台「出厂机器」,按它做出来的每个东西叫实例;实例各自记得自己的数,方法就是写在说明书里的、每个实例都会的本事。书店的例子:Book 是类,『三体』那本书和『海底两万里』那本书是两个实例;每本书记得自己的书名、价格和库存,打折和卖书是所有书都会的本事。

还有一句官方原话值得先记下:和别的语言比,Python 的类机制只加了最少的新语法和新语义。也就是说类没那么神秘,它就是函数和字典的组合拳:类定义执行时会建一个命名空间,方法就是写在类里的函数,属性就是挂在对象上的名字。学类的难点不在语法,而在什么时候该用、东西该放哪。这一篇的大半篇幅都在讲「放哪」。

第二步:class 与 __init__——先做一把「出厂模具」

写类的语法长这样,官方教程 9.3.1 节给的最简形式:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

和 def 一样,类定义也得先执行才生效;类体里的语句通常是函数定义,但也可以是别的语句。类定义一进去就建一个新的命名空间当局部作用域,定义结束时,一个「类对象」就被造出来,绑到类名上。官方教程里最简单的例子是这样的:

>>> class MyClass:
...     """A simple example class"""
...     i = 12345
...     def f(self):
...         return 'hello world'
...
>>> MyClass.i
12345
>>> MyClass.f
<function MyClass.f at 0x...>

类对象支持两种操作:取属性和实例化。MyClass.i 是 12345,MyClass.f 是一个函数对象,MyClass.__doc__ 是那句文档字符串。实例化用的就是函数调用的样子:x = MyClass(),造出一个新实例交给 x。

光造出空对象还不够用,书店的每本书一出生就该有书名、价格和库存。官方教程管这叫「初始状态」,办法是定义一个特殊方法 __init__:类一实例化,它就会被自动调用。官方例子是复数:

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

Complex(3.0, -4.5) 括号里的参数,原封不动地传给了 __init__,除了第一个参数 self。这是理解类的第一道坎:self 是谁?它是「这个实例自己」。调用 x = Complex(3.0, -4.5) 时,Python 先造出一个空对象,再把这个对象当作 self 传进 __init__;self.r = realpart 就是往这个对象身上挂一个叫 r 的属性。我的判断是:把 self 读成「我自己」就顺了——self.price = price 是「把传进来的价格记在我自己身上」,self.stock 是「我自己的库存」。它只是个约定名字,Python 对这个名字没有任何特殊处理,换成别的名字程序照样跑,但别人读你的代码会很费劲,所以别换。

照这个样子,书店的 Book 类可以这样写:

class Book:
    """书店里的一本书。"""
    def __init__(self, title, price, stock):
        self.title = title
        self.price = price
        self.stock = stock

>>> book1 = Book('三体', 59.0, 7)
>>> book2 = Book('海底两万里', 39.5, 12)
>>> book1.title, book1.price, book1.stock
('三体', 59.0, 7)
>>> book2.title, book2.price, book2.stock
('海底两万里', 39.5, 12)

注意两点。第一,数据属性不用事先声明,第一次赋值就长出来了,官方原话是「像局部变量一样,第一次赋值时才出现」。第二,book1 和 book2 各记各的数,互不干扰:改 book1.stock 不会影响 book2.stock。这正是类要解决的问题——每本书自己管自己的账。

第三步:方法——让对象自己干活

数据有了,规矩还没地方放。打折规则「超过 50 元打九折」、算库存总值、卖书减库存,这些都该写成方法,也就是写在类里的函数。官方教程 9.3.4 节讲方法调用时给了一个关键等式:x.f() 和 MyClass.f(x) 完全等价。调用方法时,实例对象会被自动插到参数列表的最前面,当作第一个参数传进去。所以定义方法时第一个参数写 self,调用时却不用传——Python 已经替你传了。

方法对象还可以先存起来以后再调:xf = x.f 拿到一个方法对象,之后 xf() 和 x.f() 效果一样。这一点在书店脚本里用不上,但它说明了一件事:方法不是什么魔法,它就是「已经绑好了一个实例的函数」。

把规矩写进 Book:

class Book:
    """书店里的一本书。"""
    def __init__(self, title, price, stock):
        self.title = title
        self.price = price
        self.stock = stock

    def total_value(self):
        """这本书的库存总值。"""
        return round(self.price * self.stock, 2)

    def discounted_price(self):
        """超过 50 元打九折,否则原价。"""
        if self.price > 50:
            return round(self.price * 0.9, 2)
        return self.price

    def sell(self, n):
        """卖出 n 本,够卖返回 True,不够返回 False。"""
        if n > self.stock:
            return False
        self.stock -= n
        return True

>>> book1 = Book('三体', 59.0, 7)
>>> book1.total_value()
413.0
>>> book1.discounted_price()
53.1
>>> book1.sell(2)
True
>>> book1.stock
5
>>> book1.sell(99)
False
>>> book1.stock
5

算一下:『三体』59.0 元乘 7 本是 413.0 元;59.0 超过 50,打九折是 53.1 元;卖 2 本剩 5 本;想卖 99 本不够,返回 False,库存还是 5 本,一本都没少。我的判断是:方法里最容易写错的只有一件事,就是忘了 self.——方法里写 price 指的是局部变量,写 self.price 才是「我自己的价格」。官方教程 9.4 节也特意提醒:方法里引用数据属性没有简写,必须写 self.,这反而让方法更好读,扫一眼就知道哪个是实例的、哪个是局部的。

方法之间也可以互相调用,用 self 去调:官方教程里的 Bag 例子就是这样,addtwice 里调两次 self.add(x)。书店也可以加一个「结账」方法,内部调 self.discounted_price() 再乘数量,就不用把打折规则再写一遍。规矩只写一处,改也只改一处,这就是第一步里说的「收起来」的好处。

第四步:类变量与实例变量——全店共用的,和每本书独有的,分开放

类里直接写的赋值,和 __init__ 里 self. 开头的赋值,是两回事。官方教程 9.3.5 节的原话:一般来说,实例变量是每个实例独有的数据,类变量是所有实例共享的属性和方法。官方例子是一条狗:

class Dog:
    kind = 'canine'         # class variable shared by all instances
    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

kind 是类变量,所有狗共用一个『犬科』;name 是实例变量,每条狗自己的名字。书店也一样:店名是全店共用的,书名、价格、库存是每本书独有的。

class Book:
    store = '晨光书店'      # 类变量,全店共用
    def __init__(self, title, price, stock):
        self.title = title
        self.price = price
        self.stock = stock

>>> book1 = Book('三体', 59.0, 7)
>>> book2 = Book('海底两万里', 39.5, 12)
>>> book1.store, book2.store
('晨光书店', '晨光书店')
>>> Book.store
'晨光书店'

类变量既可以从类上取,也可以从实例上取。但这里有个新手最容易踩的大坑,官方教程用同一条狗讲了两遍:千万别把可变对象(比如列表、字典)当类变量。看这段:

class Dog:
    tricks = []             # mistaken use of a class variable
    def __init__(self, name):
        self.name = name
    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']

Fido 只学会了翻跟头,Buddy 只学会了装死,可 d.tricks 里两样都有:因为 tricks 那个列表只有一个,所有狗共用它,谁往里加东西大家都看得见。正确的写法是把列表放进 __init__,每条狗出生时各领一个新空列表:

class Dog:
    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog
    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

书店的版本:每本书的「卖书记录」必须放进 __init__,写成 self.sales = []。要是写成类变量 sales = [],『三体』卖出的记录会跑到『海底两万里』头上,账全乱套。我的判断是:这条规矩可以背成一句话——不变的东西(店名、折扣率、税率)放类变量,可变的东西(列表、字典、每本书自己的数)一律放 __init__ 里用 self. 挂。拿不准的时候,默认放 __init__,错不了。

第五步:属性查找——实例优先,找不到再去类里找

写 book1.store 的时候,Python 到底去哪找?官方教程 9.4 节给了答案:如果同一个属性名在实例和类里同时出现,查找时实例优先。官方例子是个仓库:

>>> class Warehouse:
...    purpose = 'storage'
...    region = 'west'
...
>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
storage east

w2.region = 'east' 并没有改掉类里的 region,它只是在 w2 这个实例身上新建了一个同名属性,把类里的那个「盖住」了;w1.region 还是 'west',类本身的 Warehouse.region 也还是 'west'。书店的例子:

>>> book1 = Book('三体', 59.0, 7)
>>> book2 = Book('海底两万里', 39.5, 12)
>>> book1.store
'晨光书店'
>>> book2.store = '晨光书店·分店'
>>> book1.store
'晨光书店'
>>> book2.store
'晨光书店·分店'
>>> Book.store
'晨光书店'

这条查找规则还解释了方法是怎么被找到的:book1.discounted_price 先在实例身上找,没找到就去 Book 类里找,找到了函数对象,再把实例绑上去变成方法对象。方法查找和属性查找走的是同一条路。

还有两件官方教程点到的事。第一,数据属性可以由任何人读写,Python 里不存在真正锁死的私有数据,类的使用者完全可以直接改实例的属性,改乱了方法维护的规矩也没人拦着——「类不能用来实现纯粹的抽象数据类型,数据隐藏做不到,靠的只是约定」。这句话先记下,第八步会再回来。第二,实例身上随时可以挂新属性:book1.note = '店主推荐' 就能多出一个 note,不影响别的对象,也不影响类。灵活是灵活,但我的判断是:别靠这个功能过日子——属性应该在 __init__ 里一次挂齐,半路挂属性的代码,别人读起来像在猜谜。

第六步:继承——新书种站在旧书种肩膀上

书店要卖电子书了。电子书和纸书一样有书名、价格和库存,一样要算库存总值、一样超过 50 元打折,只是多了个文件大小,而且打折力度不一样:电子书八折。把 Book 再抄一份改改当然能跑,但打折规则以后一改就得改两处,又回到第一步的问题。官方教程 9.5 节的办法是继承:

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

派生类定义执行时,基类会被记住;找属性时,派生类里没有就去基类里找,基类还没有就再往上找,这条规则递归生效。实例化派生类和实例化基类没什么不同:DerivedClassName() 就造出一个派生类的实例。派生类可以覆盖基类的方法——因为 Python 的方法调用没有特殊待遇,基类的方法调同类的另一个方法时,实际跑的可能是派生类覆盖后的版本。官方原话是:对 C++ 程序员来说,Python 里所有的方法实际上都是虚方法。

class EBook(Book):
    """电子书:纸书的规矩全继承,只改打折力度,再加文件大小。"""
    def __init__(self, title, price, stock, file_size_mb):
        super().__init__(title, price, stock)
        self.file_size_mb = file_size_mb

    def discounted_price(self):
        """电子书八折。"""
        return round(self.price * 0.8, 2)

>>> ebook = EBook('三体', 59.0, 7, 12.5)
>>> ebook.title, ebook.file_size_mb
('三体', 12.5)
>>> ebook.total_value()
413.0
>>> ebook.discounted_price()
47.2
>>> ebook.sell(1)
True
>>> ebook.stock
6

算一下:电子书『三体』59.0 元,八折是 47.2 元;total_value() 和 sell() 是从 Book 继承来的,没重写也能用,库存总值还是 413.0 元;卖 1 本剩 6 本。__init__ 里的 super().__init__(title, price, stock) 是在说:「父类那套初始化先帮我跑一遍」,然后我再加自己的 file_size_mb。要是忘了调父类的 __init__,title、price、stock 根本不会被创建,后面一用就报 AttributeError——这是子类最常见的翻车原因之一,第十步的图里有它。

覆盖方法时,有时想「在父类做法的基础上再加一点」,而不是完全替换。官方教程给的办法是直接调父类的方法:BaseClassName.methodname(self, arguments)。比如电子书的打折想写成「先按纸书的九折算,再额外减 5 元」:

class EBookSale(EBook):
    """促销电子书:在纸书九折的基础上再减 5 元。"""
    def discounted_price(self):
        return round(Book.discounted_price(self) - 5, 2)

>>> ebook2 = EBookSale('三体', 59.0, 7, 12.5)
>>> ebook2.discounted_price()
48.1

59.0 打九折是 53.1,再减 5 是 48.1。实际写代码时更常用 super().discounted_price() 这种写法,效果一样,官方教程在多重继承一节讲 super() 的协作调用时提到了它。我的判断是:初学阶段先记住一条——覆盖方法之前先问一句「我是要替换掉父类的做法,还是在它基础上加一点」;是后者就调一次父类的方法,别把父类的逻辑再抄一遍。

最后是两个官方提供的检查工具:isinstance() 查实例的类型,issubclass() 查类的继承关系。官方例子:isinstance(obj, int) 只有当 obj 的类是 int 或 int 的派生类时才为真;issubclass(bool, int) 是 True,因为 bool 是 int 的子类,而 issubclass(float, int) 是 False。书店的例子:

>>> isinstance(ebook, EBook)
True
>>> isinstance(ebook, Book)
True
>>> isinstance(book1, EBook)
False
>>> issubclass(EBook, Book)
True
>>> issubclass(bool, int)
True

电子书既是 EBook 也是 Book,纸书却不是电子书。这句话听起来像绕口令,但它正是继承的意义:子类对象在所有用得上父类的地方都能顶上去。

第七步:多重继承与 super()——先知道有这回事,别急着用

Python 允许一个类继承多个基类,写法是 class DerivedClassName(Base1, Base2, Base3):。官方教程 9.5.1 节说,属性查找大体上是深度优先、从左到右,同一个类不会被重复查;但实际的顺序比这复杂一点,方法解析顺序会动态调整,以支持 super() 的协作调用。我的判断是:基础阶段知道「有这回事、查找是左到右、super() 能让多个父类的初始化协作起来」就够了,真实项目里多重继承用得很少,而且很容易把查找顺序绕晕。书店脚本用不上多重继承,纸书和电子书一条继承链已经够了。如果哪天真要让一个类同时继承两个东西,先画一张继承图,把方法解析顺序用 ClassName.__mro__ 打印出来看一眼,再动手。

倒是 super() 值得单独说一句。第六步里 super().__init__(title, price, stock) 是最常见的用法:子类先请父类把父类那份初始化做完。但 super() 不只是「调父类」的简写,它会顺着方法解析顺序找下一个类,在多重继承里能让每个父类的初始化恰好跑一次、不多不少。单继承时 super().method() 和 BaseClass.method(self) 效果一样;多继承时前者更稳当。初学阶段记住「子类 __init__ 里先调 super().__init__()」这个习惯,基本不会错。

第八步:私有约定——下划线是约定,不是锁

第五步留了个尾巴:Python 里不存在真正锁死的私有变量。官方教程 9.6 节第一句就是这句话,然后给了一个约定:以下划线开头的名(比如 _spam),应该被当作接口里不公开的那部分——函数、方法、数据成员都一样;它是实现细节,随时可能变。换成人话:下划线是挂在门口的「内部使用」牌子,不是锁;你硬要进,门没锁,但出了问题别怪别人。

书店的例子:每本书的进货价不想让外面随便改,可以写成 self._cost_price,再配一个只读的方法 cost_price() 去看它。外面的人看到下划线就知道「别直接改」,真要改也改得了——Python 不拦。

双下划线开头的名字(比如 __spam,至少两个前导下划线、至多一个尾随下划线)还有一层「名字改写」机制:它会被文本替换成 _classname__spam,其中 classname 是当前类名去掉前导下划线。官方教程说,改写是为了避免子类里的同名名字和父类里的撞车,设计目的主要是防意外,不是防人。官方例子是 Mapping 类:

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)
    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)
    __update = update   # private copy of original update() method

class MappingSubclass(Mapping):
    def update(self, keys, values):
        # provides new signature for update()
        # but does not break __init__()
        for item in zip(keys, values):
            self.items_list.append(item)

子类把 update 的签名改了,接收键和值两个参数;但父类 __init__ 里调的是 self.__update,也就是 _Mapping__update,子类改写的是 _MappingSubclass__update,两者不撞车,父类的初始化照样能跑。算一下就明白:

>>> m = Mapping([1, 2, 3])
>>> m.items_list
[1, 2, 3]
>>> s = MappingSubclass([1, 2, 3])
>>> s.items_list
[1, 2, 3]
>>> s.update(['a', 'b'], [10, 20])
>>> s.items_list
[1, 2, 3, ('a', 10), ('b', 20)]

我的判断是:日常写代码只用得到单下划线约定;双下划线改写只在「写会被别人继承的基础类、怕子类同名方法撞车」时才用得上。看见双下划线别慌,它不是什么加密,只是给名字加了个类名前缀。

第九步:dataclass——只装数据的类,别手写 __init__ 了

有些类没什么行为,就是把几个有名的数据绑在一起。官方教程 9.7 节说,这种「像 Pascal 记录、像 C 结构体」的东西,惯用做法是用 dataclasses。官方例子是个员工:

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    dept: str
    salary: int

>>> john = Employee('john', 'computer lab', 1000)
>>> john.dept
'computer lab'
>>> john.salary
1000

一个装饰器 @dataclass,就替你写好了 __init__,还附赠了好看的 repr 和按字段比较的相等判断。书店也可以用它记「一次进货单」:

from dataclasses import dataclass

@dataclass
class Restock:
    title: str
    count: int
    cost: float

>>> order = Restock('三体', 10, 45.0)
>>> order
Restock(title='三体', count=10, cost=45.0)
>>> order.count * order.cost
450.0

10 本乘 45.0 元是 450.0 元。我的判断是:分得清「数据类」和「行为类」是关键——Restock 这种只记数、偶尔算个乘法的,用 dataclass;Book 这种要管打折、卖书、守库存规矩的,老老实实写类和方法。反过来也一样:给 dataclass 硬加一堆方法,或者给普通类手写一长串只存数据的 __init__,都是走错了方向。

第十步:让对象能被 for 循环——__iter__ 与 __next__,以及一张翻车分布图

官方教程 9.8 节讲迭代器:for 循环背后调的是 iter(),拿到一个迭代器对象,再反复调它的 __next__() 一个个取元素;取完了,__next__() 抛一个 StopIteration 异常,for 循环就停了。官方例子是 Reverse 类,倒着遍历一个序列:

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x...>
>>> for char in rev:
...     print(char)
...
m
a
p
s

注意这里出现了一个 raise StopIteration:类里也可以主动抛异常,异常处理是下一篇的内容,这里先看个样子——__next__() 用抛异常来告诉 for 循环「没有下一个了」。书店也可以让「书架」这个类支持 for 循环:

class Shelf:
    """一个书架,装几本书,能被 for 循环一个个拿出来。"""
    def __init__(self, books):
        self.books = books
        self.index = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.index >= len(self.books):
            raise StopIteration
        book = self.books[self.index]
        self.index += 1
        return book

>>> shelf = Shelf([Book('三体', 59.0, 7), Book('海底两万里', 39.5, 12)])
>>> [b.title for b in shelf]
['三体', '海底两万里']

官方教程 9.9 节还提了一句:生成器(yield)能更省事地做出迭代器,__iter__ 和 __next__ 会自动生成。这篇不展开生成器,留给以后——知道「类可以靠两个特殊方法变成能被 for 循环的东西」就够了。顺带一提,__init__、__iter__、__next__ 这些两边各有两个下划线的名字叫「特殊方法」或「魔术方法」,Python 会在特定场合自动调它们;你不用背全表,用到哪个学哪个。

最后是这篇的翻车分布图。示例:虚构晨光书店记账脚本学 Python 第三个月,100 次和类有关的翻车,原因分布如下。图里排第一的两个错,都是「东西放错了地方」:忘了写 self,或者把该放实例的东西放到了类上。

学 Python 第三个月 100 次类与对象翻车的原因分布:忘了写 self 或位置写错 24 次,类变量当实例变量用、列表被所有对象共享 18 次,__init__ 里没给属性赋值、用时报 AttributeError 16 次,子类忘了调父类 __init__ 12 次,方法里直接写属性名、忘了加 self. 11 次,继承后覆盖错方法 10 次,把类当实例用、调用方式搞反 9 次

回头看这篇的十步,其实只讲了三件事。第一,类是把数据和规矩收到一个地方的办法,__init__ 负责让每个实例一出生就有自己的状态,方法是写在类里的、实例都会的本事。第二,东西放哪有讲究:共用的放类变量,独有的放 __init__,可变的列表千万别放类变量;查找时实例优先,找不到再去类里找。第三,继承是「站在旧东西肩膀上」:子类拿走父类的一切,只改不一样的那一点,忘了调父类 __init__ 是最常见的坑。下一篇讲异常处理:程序翻车的时候,怎么接住错、怎么自己喊停、怎么保证收尾一定跑。类和异常是两套互相独立的本事,但下一篇的自定义异常本身就是用类写出来的——到时候你会发现,这两篇其实是一回事的两面。

阅读 1评论 0

评论 (0)

ME
0/1000
评论加载中...

原始来源

浏览项目广场发布你的项目

相关文章

真实照片:一位开发者指着笔记本电脑屏幕上的代码,身后还有两台显示代码的显示器
指南
程序翻车别慌,先把错接住:Python 异常处理

异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。

项目创作Python学习与成长
真实照片:双手在一台笔记本电脑上打字,屏幕上是带 def 语句的 Python 代码,旁边放着蓝色笔记本和眼镜
指南
把重复的活收进函数,把文件拆成模块:Python 函数与模块

函数是把重复的活收进一个名字,模块是把定义装进文件、用 import 拿出来。本文按 Python 官方教程第 4 章 4.8–4.9 节与第 6 章讲清楚:def 与 return、局部与全局、默认参数只算一次、关键字参数、*args 与 **kwargs、/ 与 *、lambda、文档字符串与注解、模块的几种引用、__main__ 守卫、包与搜索路径,另附虚构晨光书店记账脚本第二个月 100 次翻车的分布。

项目创作Python学习与成长
真实照片:一家独立书店的室内,木质书架摆满了书,皮扶手椅旁边的桌上堆着书,暖色吊灯
指南
先把东西放进盒子,再让程序做决定:Python 变量、数据类型与流程控制

变量是放东西的盒子,列表和字典是装一堆东西的盒子,if、for、while 让程序自己做决定、自己重复干活。本文按 Python 官方教程第 3、4、5 章讲清楚:数字的四种除法与浮点数小毛病、字符串的索引与切片、列表的赋值不复制、字典的 get 与 KeyError、真假判断与短路、if/elif/else、for 与 range、while 与 break/continue/循环 else,另附虚构晨光书店记账脚本一个月 100 次翻车的分布。

项目创作Python学习与成长