Python面向对象核心精讲：从类到继承多态快速掌握

很多人学Python学到函数就觉得差不多了写点小脚本、处理个Excel、爬个网页都没问题。但一旦开始接触稍微正式一点的项目比如写个GUI工具、做一个Web后端、或者去读一些开源框架的源码就总感觉代码乱成一团不知道该从哪儿改起别人写的类更是看得一头雾水。这时候你就会发现面向对象OOP不是一门“选修课”而是Python从入门到进阶之间那道必须跨过去的坎。这篇内容我打算把Python面向对象里最核心、最常用的东西一次讲透。不会堆砌术语而是从“为什么要这么写”的角度带你把类、对象、继承、封装、多态这些概念全部落地到能跑的代码上。不管你是刚学Python没多久的新手还是写过一阵子脚本但没怎么用过类的朋友只要跟着动手敲一遍应该都能建立起一套清晰、可用的面向对象编程思路。1. 面向对象到底解决什么问题先别急着写类我见过不少初学者一听说面向对象很牛上来就到处定义类结果写出来的代码比不写类还难读。这件事得先拧清楚面向对象不是语法规定而是一种组织代码的方式它解决的是“代码变复杂之后怎么维护”的问题。1.1 从模拟现实世界说起类就是图纸对象就是实物如果不用面向对象你要描述一台手机可能得写几个变量phone_brand 华为 phone_color 黑色 phone_price 5999 def call(phone_brand): print(f{phone_brand} 正在打电话...)这样写本身没问题但如果你的程序里有10台手机呢你可能要写phone1_brand、phone2_brand……函数也越写越多最后你自己都分不清哪个函数是针对哪台手机的操作。类的出现就是为了把“属性和行为”打包在一起。属性就是这个东西是什么样的行为就是它能做什么。类是图纸对象是根据图纸造出来的实物。class Phone: def __init__(self, brand, color, price): self.brand brand self.color color self.price price def call(self, number): print(f{self.brand} 正在拨打 {number}) phone1 Phone(华为, 黑色, 5999) phone2 Phone(苹果, 白色, 7999) phone1.call(10086)你只需要定义一次类就可以创建任意多个手机对象每个对象有自己的品牌、颜色和价格而且互不干扰。这就是面向对象最基础也最核心的价值把数据和操作数据的方法绑在一起让代码结构和现实中的事物对应起来。1.2 为什么说面向对象更适合协作和扩展单人写脚本怎么方便怎么来。但一旦项目超过一定规模你写的代码就不只是给自己看了还要给同事看、给未来的自己看。面向对象的三大特性——封装、继承、多态——本质上都是在为“大规模协作”做准备的。打个比方团队里有人负责写“用户模块”有人负责写“订单模块”。如果都用全局函数和全局变量拼在一起改一个就可能崩一片。但用类把各自的逻辑隔离起来每个模块就是一个独立的“黑盒子”别人只需要知道这个类对外提供了哪些方法完全不用关心内部是怎么实现的。这就是面向对象在真实工程里的意义。2. Python类的基础定义、实例化与self理解了“为什么要用”之后我们再来看Python里具体怎么写。Python的类语法在各大语言里算是比较简洁的但有几个关键点必须要弄明白尤其是self这个让无数新手头疼的东西。2.1init方法对象出生的那一刻__init__是Python类的构造方法名字前后各有两个下划线所以也叫“魔法方法”或者“双下方法”。这个方法在创建对象的时候会被自动调用主要用来给对象初始化属性。class Student: def __init__(self, name, age): self.name name self.age age s Student(小明, 18) print(s.name) # 输出小明注意两个细节__init__的第一个参数永远是self而且你调用的时候不需要手动传这个参数。self.name name这句的意思是给这个具体的对象上挂一个叫name的属性。2.2 self 到底是什么一张图看懂self代表的是当前正在被操作的那个对象实例。你可以把它理解成“我自己”。当你调用s.study()的时候Python会自动把s作为第一个参数传进去所以def study(self):里的self实际上就是s。class Student: def __init__(self, name): self.name name def study(self): print(f{self.name} 正在学习) s1 Student(小红) s2 Student(小刚) s1.study() # 小红 正在学习 s2.study() # 小刚 正在学习同一个类创建的两个对象调用同一个方法输出的却是各自的名字。原因就是self分别指向了不同的实例。这也是面向对象“各自独立”这个特性的根源。注意Java和C里也有类似的概念但在Python里self是显式写在参数列表里的。很多从其他语言转过来的朋友刚开始总觉得这个self是在“多此一举”但你写多了会发现其实显式写清楚反而让你的代码更直白。2.3 类属性与实例属性别把它们搞混了新手最容易踩的坑之一就是分不清类属性和实例属性。类属性定义在类里面、方法外面的变量所有实例共享。实例属性在__init__里通过self.xxx定义的属性每个实例各有一份。class Dog: species 犬科 # 类属性 def __init__(self, name): self.name name # 实例属性 d1 Dog(旺财) d2 Dog(来福) print(d1.species) # 犬科 print(d2.species) # 犬科 Dog.species 哺乳动物 # 修改类属性所有实例都会变 print(d1.species) # 哺乳动物那如果你给d1.species赋值呢这时候Python不是去修改类属性而是给d1这个实例创建了一个新的实例属性把原来的类属性“遮住”了。这个细节如果你不清楚排查问题的时候会非常抓狂。d1.species 狼犬 print(d1.species) # 狼犬实例属性覆盖了类属性 print(d2.species) # 哺乳动物还是类属性我的建议是如果某个属性是“所有对象都一样的”比如种族、物种、常量那就用类属性如果每个对象有自己的状态就用实例属性。这两种用对了地方代码会清爽很多。3. 三大特性封装、继承、多态一次讲透封装、继承、多态是面向对象编程的三大支柱。学校里讲这些概念经常用很抽象的语言我换个方式用代码直接说话。3.1 封装把细节藏起来只留必要的接口封装有两个层面的意思第一把数据和操作数据的方法放在同一个类里第二控制外部对内部数据的访问权限。Python用下划线约定来实现“私有”的概念_name受保护属性约定“不要从外部直接访问”但技术上可以。__name私有属性Python会做名称修饰name mangling外部无法直接通过obj.__name访问。class BankAccount: def __init__(self, owner, balance): self.owner owner self.__balance balance # 私有属性 def deposit(self, amount): if amount 0: self.__balance amount print(f存款成功余额{self.__balance}) def get_balance(self): return self.__balance account BankAccount(张三, 1000) account.deposit(500) print(account.get_balance()) # 1500 # print(account.__balance) # 会报错AttributeError为什么要把余额设为私有因为余额这种数据不应该被外部随便改。如果你允许直接account.__balance -99999那你的程序逻辑瞬间就崩了。通过提供deposit方法你可以在方法内部检查金额是否大于0这就叫“把细节藏起来把接口暴露出去”。注意Python的私有只是一个“约定加小技巧”它并不会像Java那样强制拦截。_BankAccount__balance这种写法理论上还是能访问到私有属性的。所以别把Python的私有当做安全机制它更多是“提醒你不要乱动”。3.2 继承站在巨人的肩膀上写代码继承解决的是“多个类有公共逻辑”的问题。如果你有两个类它们的代码有大量重复就应该考虑提取一个父类出来。class Animal: def __init__(self, name): self.name name def eat(self): print(f{self.name} 正在吃东西) class Cat(Animal): def meow(self): print(f{self.name} 喵喵叫) class Dog(Animal): def bark(self): print(f{self.name} 汪汪叫) cat Cat(小花) dog Dog(大黄) cat.eat() # 继承自 Animal cat.meow() # 自己的方法 dog.eat() # 继承自 AnimalCat和Dog都继承了Animal里的__init__和eat方法不需要各自重复写一遍。这就是“复用”的威力。3.3 方法重写与super()不只是套模板子类可以从父类继承方法但如果你觉得父类的方法不合适也可以在子类里重新定义一遍这叫“方法重写”override。重写的时候如果想要调用父类的版本就用super()。class Animal: def __init__(self, name): self.name name def sound(self): print(动物发出声音) class Cat(Animal): def __init__(self, name, color): super().__init__(name) # 调用父类的初始化方法 self.color color def sound(self): # 重写父类的 sound 方法 print(f{self.name} 发出喵喵声) cat Cat(小花, 橘色) cat.sound() # 小花 发出喵喵声super().__init__(name)这句是新手最容易懵的地方。它的意思是先把父类__init__里做的事情做一遍然后在这个基础上再补充子类自己的属性。这比手动写self.name name更规范——如果父类的__init__逻辑很复杂你直接复用它就好了不用关心它内部怎么处理。3.4 多态同一个方法不同的表现多态这个概念听起来高大上其实用起来非常自然。它的核心就是不管对象具体是哪个类只要它实现了某个方法名字调用方就可以统一处理。class Duck: def quack(self): print(鸭子嘎嘎叫) class Person: def quack(self): print(那个人在模仿鸭子叫) def make_quack(thing): thing.quack() d Duck() p Person() make_quack(d) # 鸭子嘎嘎叫 make_quack(p) # 那个人在模仿鸭子叫make_quack函数根本不关心传入的是Duck还是Person只要你有quack方法就能正常工作。这就叫“鸭子类型”Duck Typing是Python多态的核心体现。在实际项目中多态最典型的应用就是“策略模式”或者“统一的接口调用”。比如你有多种支付方式支付宝、微信、银行卡。只要每个类都有pay()方法你就能写一个统一的函数来处理所有支付完全不需if-elif去判断类型。class Alipay: def pay(self, amount): print(f支付宝支付 {amount} 元) class WechatPay: def pay(self, amount): print(f微信支付 {amount} 元) def do_pay(pay_method, amount): pay_method.pay(amount) p1 Alipay() p2 WechatPay() do_pay(p1, 100) do_pay(p2, 100)新增一种支付方式不需要改动do_pay函数只需要新增一个实现了pay方法的类。这就是开闭原则对扩展开放对修改关闭。4. 常用特殊方法让你的类用起来像内置类型Python的类之所以强大很大程度是因为有各种特殊方法魔法方法。它们以双下划线开头和结尾能让你自定义的对象也支持len()、str()、、[]这些操作。4.1str和repr控制对象的打印显示不定义这两个方法直接print(对象)输出的是一串看不懂的内存地址。定义之后就能输出你希望看到的内容。class Book: def __init__(self, title, author): self.title title self.author author def __str__(self): return f《{self.title}》作者{self.author} book Book(Python编程从入门到实践, Eric Matthes) print(book) # 《Python编程从入门到实践》作者Eric Matthes简单来说__str__是给人看的__repr__是给开发者调试用的。如果只写一个推荐写__repr__因为Python在好多场景下会把它作为__str__的兜底。4.2len和getitem让对象支持len()和下标访问如果你的类本质上是一个集合比如自定义一个简化版的学生管理类实现这些方法后就能像操作列表一样操作它。class ClassRoom: def __init__(self, students): self.students students def __len__(self): return len(self.students) def __getitem__(self, index): return self.students[index] c ClassRoom([小明, 小红, 小刚]) print(len(c)) # 3 print(c[1]) # 小红这些东西在你写自己的工具库的时候非常有用。比如你封装了一个配置管理类实现__getitem__之后可以像config[host]这样取值用户用起来非常顺手。4.3 运算符重载让自定义对象支持加减比较在Python里号本质上是在调用对象的__add__方法。所以你可以让自己定义的类支持运算符操作。class Vector: def __init__(self, x, y): self.x x self.y y def __add__(self, other): return Vector(self.x other.x, self.y other.y) def __str__(self): return f({self.x}, {self.y}) v1 Vector(1, 2) v2 Vector(3, 4) print(v1 v2) # (4, 6)这种写法在数学计算、游戏开发、数据处理领域非常常见。你封装了坐标类、矩阵类之后运算符重载能让代码极其优雅。5. 实战从零写一个“图书管理系统”类纸上谈兵再多不如直接把代码敲出来。咱们用一个小案例把前面的知识点串起来。需求很简单一个图书管理系统可以添加书、借书、还书、查看库存。5.1 先设计类的结构根据需求我可以拆出两个类Book表示一本书属性有书名、作者、库存量。Library管理多本书支持添加、借书、还书。class Book: def __init__(self, title, author, count1): self.title title self.author author self.count count def __str__(self): return f《{self.title}》{self.author} 著库存{self.count} class Library: def __init__(self): self.books [] # 存储所有图书对象 def add_book(self, title, author, count1): self.books.append(Book(title, author, count)) print(f添加成功{self.books[-1]}) def borrow_book(self, title): for book in self.books: if book.title title: if book.count 0: book.count - 1 print(f借出成功《{title}》剩余库存{book.count}) else: print(f借阅失败《{title}》库存不足) return print(f借阅失败找不到《{title}》这本书) def return_book(self, title): for book in self.books: if book.title title: book.count 1 print(f归还成功《{title}》剩余库存{book.count}) return print(f归还失败找不到《{title}》这本书) def show_all(self): if not self.books: print(图书馆暂时没有书) for book in self.books: print(book)这段代码有几个地方值得注意Library里的books列表存的是Book对象而不是字典或者元组。这样做的好处是以后要给Book加属性和方法比如加一个ISBN编号不会影响到Library的其他逻辑。borrow_book里用了for...else其实没用到但我故意没写else用的是提前return退出函数。这种写法比“遍历完再判断有没有找到”要清晰得多。面向对象不是“类越多越好”而是“该抽象的地方抽象”。Book是一本书Library是一个容器这两者的职责清清楚楚。写完之后你可以直接测试lib Library() lib.add_book(Python编程, 张三, 5) lib.add_book(Java编程, 李四, 2) lib.show_all() lib.borrow_book(Python编程) lib.borrow_book(Python编程) lib.return_book(Python编程) lib.show_all()5.2 案例分析这个设计还有哪些扩展空间一个小系统的首要目标是跑通功能但你可以想一想如果需求变大这套代码要怎么改如果书多了查找书还要遍历性能会差。可以把books从list换成dict以书名为key。如果两个人同时借同一本书需要考虑并发安全。这就是后面要接触的“多线程加锁”问题了。如果还要记录借书人信息、借书时间就需要再加一个Record类。能看到这些扩展空间说明你的面向对象思维已经建立起来了。写代码不是一次成型而是通过不断演进让结构变好。6. 新手必踩的坑这些错误我当年全犯过6.1 实例方法忘记写 selfclass Test: def method(): # 忘了写 self print(hello) t Test() t.method() # 报错TypeError这个错误发生的原因是你调用t.method()的时候Python会自动把t作为第一个参数传进去但你的method不接收任何参数于是报错。解决办法很简单所有实例方法的第一个参数都写成self。6.2 修改类属性导致所有实例“串数据”前面讲了类属性和实例属性的区别这里再强调一次。如果你在__init__里把列表作为默认参数也会踩一个经典大坑class Bad: def __init__(self, items[]): # 千万不要这么写 self.items items a Bad() a.items.append(1) b Bad() print(b.items) # [1] 出乎意料吧原因是默认参数[]在函数定义的时候就被创建了之后每次调用使用的都是这同一个列表。正确写法是class Good: def __init__(self, itemsNone): self.items items if items is not None else []6.3 继承时 super() 用错导致初始化混乱多层继承的时候super()要谨慎使用。Python的super()不是简单地调用“父类”而是按照MRO方法解析顺序去协调。新手阶段的建议是如果你的继承链比较复杂尽量让每个类的__init__参数保持一致或者干脆少用多层继承。6.4 命名冲突与下划线问题class A: def __init__(self): self._x 1 # 受保护 self.__y 2 # 私有 a A() print(a._x) # 1 还能访问 # print(a.__y) # 报错 print(a._A__y) # 2 通过改名后的名字访问Python的“私有”只是改了变量名并没有真正禁止访问。在团队协作中看到_x表示“请勿直接使用”看到__y表示“这个类内部的东西别碰”。7. 面向对象实战常见问题速查表问题场景错误现象原因分析解决方法方法定义缺selfTypeError: method() takes 0 positional arguments but 1 was given实例调用自动传self所有实例方法第一个参数写self私有属性访问AttributeError: object has no attribute __x名称修饰导致属性名改变用getter/setter不要直接访问列表作为默认参数所有实例共享同一个列表默认参数在定义时创建一次用None作为默认值再初始化修改类属性影响所有实例一个实例改了属性其他实例也变了类属性全局共享用实例属性存储对象独立数据继承后__init__不生效子类的属性没有初始化子类覆盖了__init__且没调super用super().init()先初始化父类打印对象输出内存地址main.Book object at 0x...没定义__str__或__repr__实现__str__方法忘了加括号创建对象拿到的是类对象不是实例误把类当函数调用注意obj MyClass()带括号这张表我建议收藏起来等真正遇到问题的时候再翻出来对照比死记概念有用得多。8. 从类到工程养成面向对象的编程思维写好面向对象代码光记住语法是不够的思维方式的转变才最关键。有几个判断标准你可以用来检查自己写的类到底合不合格。8.1 单一职责原则一个类只干一件事如果有一个类既管用户登录、又管发邮件、还管删除数据库记录一旦出了bug你几乎没法排查。好的类应该只负责一个清晰的概念。比如User就管用户属性和修改资料UserRepository管数据库操作EmailService管发邮件。各管一摊互不干扰。我用过一句话来检验用一句话能说清楚“这个类是干什么的”如果说不清楚说明职责太杂了。8.2 组合优于继承别迷信继承继承虽然方便但滥用会让继承链变得又深又脆。Animals - Mammals - Dogs - Husky这种深层次的继承在现代工程里并不推荐。很多时候组合一个类里包含另一个类的对象更灵活class Engine: def start(self): print(发动机启动) class Car: def __init__(self): self.engine Engine() # 组合 def start(self): self.engine.start() # 委托给Engine类 car Car() car.start() # 发动机启动组合的关系是“有一个”has-a继承的关系是“是一个”is-a。能用“有一个”解决的时候优先用组合。8.3 从脚本到类一个实际的重构案例很多人的第一个程序就是一串从上到下执行的脚本。假设你写了一个爬虫一开始是这样import requests url https://example.com resp requests.get(url) html resp.text title html.split(title)[1].split(/title)[0] print(title)需求变复杂之后脚本越来越长要处理多个URL、要保存结果、要加请求头、要处理异常。这时候就很自然地想要重构。class Crawler: def __init__(self, headersNone): self.headers headers or {} def fetch(self, url): resp requests.get(url, headersself.headers) resp.raise_for_status() return resp.text def parse_title(self, html): start html.find(title) end html.find(/title) if start ! -1 and end ! -1: return html[start7:end] return None crawler Crawler(headers{User-Agent: Mozilla/5.0}) html crawler.fetch(https://example.com) print(crawler.parse_title(html))重构之后fetch管下载parse_title管解析以后想增加save_to_file方法直接在类里加就行。这种“脚本变成了工具”的过程就是面向对象思维慢慢建立起来的过程。学习面向对象没有捷径但有一条最快的路把一个你已经写好的小项目用类的形式重构一遍。重构的过程中你会遇到所有上面提到的坑也会真正理解为什么需要封装、为什么需要继承。代码写多了这些概念不需要背自然就刻在肌肉记忆里了。