<html lang="zh-CN">

<meta charset="utf-8">

<meta name="viewport" content="width=device-width, initial-scale=1">

<meta name="description" content="CodeClub - 10.3. 继承和多态">

<meta name="author" content="Jackson">

<title>10.3. 继承和多态 - CodeClub</title>

<link rel="icon" type="image/x-icon" href="../../img/logo.png">

<link rel="preconnect" href="https://fonts.googleapis.com">

<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>

<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css" crossorigin="anonymous" referrerpolicy="no-referrer" />

<link rel="stylesheet" href="../../css/main.css">

<link rel="stylesheet" href="../../css/dark-mode.css">

<link rel="stylesheet" href="../../css/mobile-optimizations.css">

<link rel="stylesheet" href="../../css/tutorial.css">

<style>

.tutorial-container { max-width: 960px; margin: 70px auto 40px; padding: 0 20px; }

.tutorial-sidebar { position: fixed; top: 70px; left: 20px; width: 260px; max-height: calc(100vh - 90px); overflow-y: auto; background: var(--bg-secondary, #fff); border-radius: 8px; padding: 16px; box-shadow: 0 2px 8px rgba(0,0,0,0.08); }

.tutorial-sidebar h3 { font-size: 16px; margin-bottom: 12px; color: var(--text-primary, #1a1a2e); }

.tutorial-sidebar a { display: block; padding: 6px 10px; color: var(--text-secondary, #666); text-decoration: none; font-size: 14px; border-radius: 4px; }

.tutorial-sidebar a:hover, .tutorial-sidebar a.active { background: var(--primary, #3b82f6); color: #fff; }

.tutorial-sidebar .sub-link { padding-left: 24px; font-size: 13px; }

.tutorial-content { margin-left: 300px; background: var(--bg-secondary, #fff); border-radius: 8px; padding: 32px; box-shadow: 0 2px 8px rgba(0,0,0,0.08); }

.tutorial-content h1 { font-size: 28px; margin-bottom: 20px; color: var(--text-primary, #1a1a2e); border-bottom: 2px solid var(--primary, #3b82f6); padding-bottom: 12px; }

.tutorial-content h2 { font-size: 22px; margin: 24px 0 16px; color: var(--text-primary, #1a1a2e); }

.tutorial-content h3 { font-size: 18px; margin: 20px 0 12px; }

.tutorial-content p { line-height: 1.8; margin: 12px 0; color: var(--text-secondary, #333); }

.tutorial-content pre { background: #1e1e2e; color: #cdd6f4; padding: 16px; border-radius: 8px; overflow-x: auto; margin: 16px 0; }

.tutorial-content code { font-family: 'Fira Code', 'Cascadia Code', monospace; font-size: 14px; }

.tutorial-content p code { background: #f1f5f9; padding: 2px 6px; border-radius: 4px; color: #e83e8c; }

.tutorial-content blockquote { border-left: 4px solid var(--primary, #3b82f6); padding: 12px 20px; margin: 16px 0; background: #f8fafc; border-radius: 0 8px 8px 0; }

.tutorial-content ul, .tutorial-content ol { padding-left: 24px; margin: 12px 0; }

.tutorial-content li { margin: 6px 0; line-height: 1.7; }

.tutorial-content img { max-width: 100%; border-radius: 8px; margin: 16px 0; }

.tutorial-nav { display: flex; justify-content: space-between; margin-top: 32px; padding-top: 20px; border-top: 1px solid var(--border, #e5e7eb); }

.tutorial-nav a { color: var(--primary, #3b82f6); text-decoration: none; font-weight: 500; }

.tutorial-nav a:hover { text-decoration: underline; }

.tutorial-index { max-width: 960px; margin: 70px auto 40px; padding: 0 20px; }

.tutorial-card { background: var(--bg-secondary, #fff); border-radius: 12px; padding: 24px; margin: 16px 0; box-shadow: 0 2px 8px rgba(0,0,0,0.08); transition: transform 0.2s; }

.tutorial-card:hover { transform: translateY(-2px); }

.tutorial-card h3 { margin: 0 0 8px; color: var(--text-primary, #1a1a2e); }

.tutorial-card p { color: var(--text-secondary, #666); margin: 0 0 12px; }

.tutorial-card .badge { display: inline-block; padding: 4px 10px; border-radius: 20px; font-size: 12px; font-weight: 600; margin-right: 8px; }

.badge-python { background: #3b82f6; color: #fff; }

.badge-git { background: #f97316; color: #fff; }

.badge-ai { background: #8b5cf6; color: #fff; }

@media (max-width: 768px) {

.tutorial-sidebar { display: none; }

.tutorial-content { margin-left: 0; }

}

</style>

<nav class="navbar">

<div class="navbar-container">

<a class="navbar-brand" href="../../index.html">

<img src="../../img/logo.png" alt="CodeClub" width="32" height="32">

<span>CodeClub</span>

</a>

<button class="mobile-menu-toggle" aria-label="切换导航菜单">

<span></span><span></span><span></span>

</button>

<ul class="navbar-nav">

<li><a class="nav-link" href="../../index.html">首页</a></li>

<li><a class="nav-link" href="../../nav.html">网址导航</a></li>

<li><a class="nav-link" href="../../blog/">博客</a></li>

<li><a class="nav-link" href="../../wiki/index.html" target="_blank">WiKi</a></li>

<li><a class="nav-link active" href="../../tutorials/index.html">教程</a></li>

<li><a class="nav-link" href="../../book.html">图书</a></li>

<li><a class="nav-link" href="../../contact.html">联系我</a></li>

<li><a class="nav-link" href="../../about.html">关于我</a></li>

</ul>

</div>

</nav>

<div class="tutorial-container" style="max-width: 960px; margin: 80px auto 40px; padding: 0 20px;"><div class="tutorial-sidebar"><h3>目录</h3><a href="0.html">1. 简介</a><a href="1.html">2. Python历史</a><a href="2.html">3. 安装Python</a><a href="3.html">3.1. Python解释器</a><a href="4.html">4. 第一个Python程序</a><a href="5.html">4.1. 使用文本编辑器</a><a href="6.html">4.2. 输入和输出</a><a href="7.html">5. Python基础</a><a href="8.html">5.1. 数据类型和变量</a><a href="9.html">5.2. 字符串和编码</a><a href="10.html">5.3. 使用list和tuple</a><a href="11.html">5.4. 条件判断</a><a href="12.html">5.5. 模式匹配</a><a href="13.html">5.6. 循环</a><a href="14.html">5.7. 使用dict和set</a><a href="15.html">6. 函数</a><a href="16.html">6.1. 调用函数</a><a href="17.html">6.2. 定义函数</a><a href="18.html">6.3. 函数的参数</a><a href="19.html">6.4. 递归函数</a><a href="20.html">7. 高级特性</a><a href="21.html">7.1. 切片</a><a href="22.html">7.2. 迭代</a><a href="23.html">7.3. 列表生成式</a><a href="24.html">7.4. 生成器</a><a href="25.html">7.5. 迭代器</a><a href="26.html">8. 函数式编程</a><a href="27.html">8.1. 高阶函数</a><a href="28.html">8.1.1. map/reduce</a><a href="29.html">8.1.2. filter</a><a href="30.html">8.1.3. sorted</a><a href="31.html">8.2. 返回函数</a><a href="32.html">8.3. 匿名函数</a><a href="33.html">8.4. 装饰器</a><a href="34.html">8.5. 偏函数</a><a href="35.html">9. 模块</a><a href="36.html">9.1. 使用模块</a><a href="37.html">9.2. 安装第三方模块</a><a href="38.html">10. 面向对象编程</a><a href="39.html">10.1. 类和实例</a><a href="40.html">10.2. 访问限制</a><a href="41.html">10.3. 继承和多态</a><a href="42.html">10.4. 获取对象信息</a><a href="43.html">10.5. 实例属性和类属性</a><a href="44.html">11. 面向对象高级编程</a><a href="45.html">11.1. 使用__slots__</a><a href="46.html">11.2. 使用@property</a><a href="47.html">11.3. 多重继承</a><a href="48.html">11.4. 定制类</a><a href="49.html">11.5. 使用枚举类</a><a href="50.html">11.6. 使用元类</a><a href="51.html">12. 错误、调试和测试</a><a href="52.html">12.1. 错误处理</a><a href="53.html">12.2. 调试</a><a href="54.html">12.3. 单元测试</a><a href="55.html">12.4. 文档测试</a><a href="56.html">13. IO编程</a><a href="57.html">13.1. 文件读写</a><a href="58.html">13.2. StringIO和BytesIO</a><a href="59.html">13.3. 操作文件和目录</a><a href="60.html">13.4. 序列化</a><a href="61.html">14. 进程和线程</a><a href="62.html">14.1. 多进程</a><a href="63.html">14.2. 多线程</a><a href="64.html">14.3. ThreadLocal</a><a href="65.html">14.4. 进程 vs. 线程</a><a href="66.html">14.5. 分布式进程</a><a href="67.html">15. 正则表达式</a><a href="68.html">16. 常用内建模块</a><a href="69.html">16.1. datetime</a><a href="70.html">16.2. collections</a><a href="71.html">16.3. argparse</a><a href="72.html">16.4. base64</a><a href="73.html">16.5. struct</a><a href="74.html">16.6. hashlib</a><a href="75.html">16.7. hmac</a><a href="76.html">16.8. itertools</a><a href="77.html">16.9. contextlib</a><a href="78.html">16.10. urllib</a><a href="79.html">16.11. XML</a><a href="80.html">16.12. HTMLParser</a><a href="81.html">16.13. venv</a><a href="82.html">17. 常用第三方模块</a><a href="83.html">17.1. Pillow</a><a href="84.html">17.2. requests</a><a href="85.html">17.3. chardet</a><a href="86.html">17.4. psutil</a><a href="87.html">18. 图形界面</a><a href="88.html">18.1. 海龟绘图</a><a href="89.html">19. 网络编程</a><a href="90.html">19.1. TCP/IP简介</a><a href="91.html">19.2. TCP编程</a><a href="92.html">19.3. UDP编程</a><a href="93.html">20. 电子邮件</a><a href="94.html">20.1. SMTP发送邮件</a><a href="95.html">20.2. POP3收取邮件</a><a href="96.html">21. 访问数据库</a><a href="97.html">21.1. 使用SQLite</a><a href="98.html">21.2. 使用MySQL</a><a href="99.html">21.3. 使用SQLAlchemy</a><a href="100.html">22. Web开发</a><a href="101.html">22.1. HTTP协议简介</a><a href="102.html">22.2. HTML简介</a><a href="103.html">22.3. WSGI接口</a><a href="104.html">22.4. 使用Web框架</a><a href="105.html">22.5. 使用模板</a><a href="106.html">23. 异步IO</a><a href="107.html">23.1. 协程</a><a href="108.html">23.2. 使用asyncio</a><a href="109.html">23.3. 使用aiohttp</a><a href="110.html">24. FAQ</a><a href="111.html">25. 期末总结</a></div><div class="tutorial-content"><h1>10.3. 继承和多态</h1><div class="tutorial-body"><p>比如，我们已经编写了一个名为<code>Animal</code>的class，有一个<code>run()</code>方法可以直接打印：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Animal</span>(<span class="hljs-title class_ inherited__">object</span>):

<span class="hljs-keyword">def</span> <span class="hljs-title function_">run</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Animal is running...&#x27;</span>)

<p>当我们需要编写<code>Dog</code>和<code>Cat</code>类时，就可以直接从<code>Animal</code>类继承：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Dog</span>(<span class="hljs-title class_ inherited__">Animal</span>):

<span class="hljs-keyword">pass</span>

<span class="hljs-keyword">class</span> <span class="hljs-title class_">Cat</span>(<span class="hljs-title class_ inherited__">Animal</span>):

<span class="hljs-keyword">pass</span>

<p>对于<code>Dog</code>来说，<code>Animal</code>就是它的父类，对于<code>Animal</code>来说，<code>Dog</code>就是它的子类。<code>Cat</code>和<code>Dog</code>类似。</p>

<p>继承有什么好处？最大的好处是子类获得了父类的全部功能。由于<code>Animal</code>实现了<code>run()</code>方法，因此，<code>Dog</code>和<code>Cat</code>作为它的子类，什么事也没干，就自动拥有了<code>run()</code>方法：</p>

<pre class="hljs"><code class="language-python">dog = Dog()

dog.run()

cat = Cat()

cat.run()

<p>运行结果如下：</p>

<pre class="hljs"><code class="language-plain">Animal is running...

Animal is running...

<p>当然，也可以对子类增加一些方法，比如Dog类：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Dog</span>(<span class="hljs-title class_ inherited__">Animal</span>):

<span class="hljs-keyword">def</span> <span class="hljs-title function_">run</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Dog is running...&#x27;</span>)

<span class="hljs-keyword">def</span> <span class="hljs-title function_">eat</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Eating meat...&#x27;</span>)

<p>继承的第二个好处需要我们对代码做一点改进。你看到了，无论是<code>Dog</code>还是<code>Cat</code>，它们<code>run()</code>的时候，显示的都是<code>Animal is running...</code>，符合逻辑的做法是分别显示<code>Dog is running...</code>和<code>Cat is running...</code>，因此，对<code>Dog</code>和<code>Cat</code>类改进如下：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Dog</span>(<span class="hljs-title class_ inherited__">Animal</span>):

<span class="hljs-keyword">def</span> <span class="hljs-title function_">run</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Dog is running...&#x27;</span>)

<span class="hljs-keyword">class</span> <span class="hljs-title class_">Cat</span>(<span class="hljs-title class_ inherited__">Animal</span>):

<span class="hljs-keyword">def</span> <span class="hljs-title function_">run</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Cat is running...&#x27;</span>)

<p>再次运行，结果如下：</p>

<pre class="hljs"><code class="language-plain">Dog is running...

Cat is running...

<p>当子类和父类都存在相同的<code>run()</code>方法时，我们说，子类的<code>run()</code>覆盖了父类的<code>run()</code>，在代码运行的时候，总是会调用子类的<code>run()</code>。这样，我们就获得了继承的另一个好处：多态。</p>

<p>要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：</p>

<pre class="hljs"><code class="language-python">a = <span class="hljs-built_in">list</span>() <span class="hljs-comment"># a是list类型</span>

b = Animal() <span class="hljs-comment"># b是Animal类型</span>

c = Dog() <span class="hljs-comment"># c是Dog类型</span>

<p>判断一个变量是否是某个类型可以用<code>isinstance()</code>判断：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; isinstance(a, list)

True

&gt;&gt;&gt; isinstance(b, Animal)

True

&gt;&gt;&gt; isinstance(c, Dog)

True

<p>看来<code>a</code>、<code>b</code>、<code>c</code>确实对应着<code>list</code>、<code>Animal</code>、<code>Dog</code>这3种类型。</p>

<p>但是等等，试试：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; isinstance(c, Animal)

True

<p>看来<code>c</code>不仅仅是<code>Dog</code>，<code>c</code>还是<code>Animal</code>！</p>

<p>不过仔细想想，这是有道理的，因为<code>Dog</code>是从<code>Animal</code>继承下来的，当我们创建了一个<code>Dog</code>的实例<code>c</code>时，我们认为<code>c</code>的数据类型是<code>Dog</code>没错，但<code>c</code>同时也是<code>Animal</code>也没错，<code>Dog</code>本来就是<code>Animal</code>的一种！</p>

<p>所以，在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。但是，反过来就不行：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; b = Animal()

&gt;&gt;&gt; isinstance(b, Dog)

False

<p><code>Dog</code>可以看成<code>Animal</code>，但<code>Animal</code>不可以看成<code>Dog</code>。</p>

<p>要理解多态的好处，我们还需要再编写一个函数，这个函数接受一个<code>Animal</code>类型的变量：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">def</span> <span class="hljs-title function_">run_twice</span>(<span class="hljs-params">animal</span>):

animal.run()

animal.run()

<p>当我们传入<code>Animal</code>的实例时，<code>run_twice()</code>就打印出：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; run_twice(Animal())

Animal is running...

Animal is running...

<p>当我们传入<code>Dog</code>的实例时，<code>run_twice()</code>就打印出：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; run_twice(Dog())

Dog is running...

Dog is running...

<p>当我们传入<code>Cat</code>的实例时，<code>run_twice()</code>就打印出：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; run_twice(Cat())

Cat is running...

Cat is running...

<p>看上去没啥意思，但是仔细想想，现在，如果我们再定义一个<code>Tortoise</code>类型，也从<code>Animal</code>派生：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Tortoise</span>(<span class="hljs-title class_ inherited__">Animal</span>):

<span class="hljs-keyword">def</span> <span class="hljs-title function_">run</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Tortoise is running slowly...&#x27;</span>)

<p>当我们调用<code>run_twice()</code>时，传入<code>Tortoise</code>的实例：</p>

<pre class="hljs"><code class="language-plain">&gt;&gt;&gt; run_twice(Tortoise())

Tortoise is running slowly...

Tortoise is running slowly...

<p>你会发现，新增一个<code>Animal</code>的子类，不必对<code>run_twice()</code>做任何修改，实际上，任何依赖<code>Animal</code>作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。</p>

<p>多态的好处就是，当我们需要传入<code>Dog</code>、<code>Cat</code>、<code>Tortoise</code>……时，我们只需要接收<code>Animal</code>类型就可以了，因为<code>Dog</code>、<code>Cat</code>、<code>Tortoise</code>……都是<code>Animal</code>类型，然后，按照<code>Animal</code>类型进行操作即可。由于<code>Animal</code>类型有<code>run()</code>方法，因此，传入的任意类型，只要是<code>Animal</code>类或者子类，就会自动调用实际类型的<code>run()</code>方法，这就是多态的意思：</p>

<p>对于一个变量，我们只需要知道它是<code>Animal</code>类型，无需确切地知道它的子类型，就可以放心地调用<code>run()</code>方法，而具体调用的<code>run()</code>方法是作用在<code>Animal</code>、<code>Dog</code>、<code>Cat</code>还是<code>Tortoise</code>对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种<code>Animal</code>的子类时，只要确保<code>run()</code>方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：</p>

<p>对扩展开放：允许新增<code>Animal</code>子类；</p>

<p>对修改封闭：不需要修改依赖<code>Animal</code>类型的<code>run_twice()</code>等函数。</p>

<p>继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树。比如如下的继承树：</p>

<pre class="ascii"><code> ┌───────────────┐

│ object │

└───────────────┘

│

┌────────────┴────────────┐

│ │

▼ ▼

┌─────────────┐ ┌─────────────┐

│ Animal │ │ Plant │

└─────────────┘ └─────────────┘

│ │

┌─────┴──────┐ ┌─────┴──────┐

│ │ │ │

▼ ▼ ▼ ▼

┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐

│ Dog │ │ Cat │ │ Tree │ │ Flower │

└─────────┘ └─────────┘ └─────────┘ └─────────┘

<h3>静态语言 vs 动态语言</h3>

<p>对于静态语言（例如Java）来说，如果需要传入<code>Animal</code>类型，则传入的对象必须是<code>Animal</code>类型或者它的子类，否则，将无法调用<code>run()</code>方法。</p>

<p>对于Python这样的动态语言来说，则不一定需要传入<code>Animal</code>类型。我们只需要保证传入的对象有一个<code>run()</code>方法就可以了：</p>

<pre class="hljs"><code class="language-python"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Timer</span>(<span class="hljs-title class_ inherited__">object</span>):

<span class="hljs-keyword">def</span> <span class="hljs-title function_">run</span>(<span class="hljs-params">self</span>):

<span class="hljs-built_in">print</span>(<span class="hljs-string">&#x27;Start...&#x27;</span>)

<p>这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。</p>

<p>Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个<code>read()</code>方法，返回其内容。但是，许多对象，只要有<code>read()</code>方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了<code>read()</code>方法的对象。</p>

<h3>小结</h3>

<p>继承可以把父类的所有功能都直接拿过来，这样就不必从零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。</p>

<p>动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。</p>

<h3>参考源码</h3>

<p><a href="animals.py">animals.py</a></p>

<p><a href="get_instance.py">get_instance.py</a></p>

</div>

<hr class="gsc-border">

<div id="gsi-chapter-prev-next" class="flex flex-row mt-4">

<div id="gsi-chapter-prev" class="basis-1/2 mr-2 text-left">

<a href="/books/python/oop/access/index.html"

onclick="gs_load_chapter('/books/python/oop/access/index.html',true);return false;"

class="inline-block my-2">

<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5"

stroke="currentColor">

<path stroke-linecap="round" stroke-linejoin="round"

d="M18.75 19.5l-7.5-7.5 7.5-7.5m-6 15L5.25 12l7.5-7.5" />

</svg>

访问限制

</a>

</div>

<div id="gsi-chapter-next" class="basis-1/2 ml-2 text-right">

<a href="/books/python/oop/attr/index.html"

onclick="gs_load_chapter('/books/python/oop/attr/index.html',true);return false;"

class="inline-block my-2">

获取对象信息

<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5"

stroke="currentColor">

<path stroke-linecap="round" stroke-linejoin="round"

d="M11.25 4.5l7.5 7.5-7.5 7.5m-6-15l7.5 7.5-7.5 7.5" />

</svg>

</a></div><div style="display: flex; justify-content: space-between; margin-top: 32px; padding-top: 20px; border-top: 1px solid var(--border, #e5e7eb);"><a href="40.html" style="color: var(--primary, #3b82f6); text-decoration: none; font-weight: 500;">&larr; 10.2. 访问限制</a><a href="42.html" style="color: var(--primary, #3b82f6); text-decoration: none; font-weight: 500;">10.4. 获取对象信息 &rarr;</a></div><p style="margin-top: 16px; font-size: 13px; color: var(--text-secondary, #999);">原文：<a href="https://liaoxuefeng.com/books/python/oop/extend/index.html" style="color: var(--primary, #3b82f6);">廖雪峰 - 10.3. 继承和多态</a></p></div></div>

<footer class="footer">

<div class="footer-content">

<p>&copy; 2024 CodeClub. All rights reserved.</p>

</div>

</footer>

<script src="../../js/dark-mode.js"></script>

<script src="../../js/mobile-menu.js"></script>