More Python for Beginners 进阶指南：从类、文件系统到 async/await 的完整实战教程

• 示例工程
• 教程

本指南以 Channel 9 / YouTube 系列课程More Python for beginners的官方仓库配套文档为核心，系统梳理了第一门 Python 入门课之后应当掌握的进阶特性：类与对象、多重继承与 Mixin、文件系统操作、文件读写、with资源管理以及异步编程。读者学完本指南后，能够搭建出本系列课程的完整开发环境，并对照仓库中的 9 个模块示例代码，亲手运行从格式化工具配置到async/await并发请求的完整实战案例。

系列定位：第一门 Python 课程之后学什么

本仓库（c9-python-getting-started）承载了 Channel 9 与 YouTube 上三个连续的 Python 入门系列课程的示例代码。作为其中的第二门课，more-python-for-beginners/README.md 在开篇就点明了它的诞生背景：

在创建 Python for beginners 时，我们知道无法在一门课里覆盖 Python 的全部内容，因此只聚焦于“开始使用这门语言”所需的核心特性。但自然有一些内容被留在了清单之外——现在我们回来了！

换句话说，第一门课解决的是"从零开始能写出 Python 代码"，而这门进阶课解决的是"作为一个 Python 开发者继续成长"所需的能力。值得注意的是一系列“前沿”特性也被纳入其中，例如async/await异步编程——这正是本课程名字中 “More” 的含义所在。

从仓库根目录的 README.md 可以看到三套课程的完整脉络，本课处于中间衔接位置：

• Python for beginners：零基础起点，涵盖变量、条件、循环、函数、包管理、调用 REST API 与 JSON 处理（对应仓库中的python-for-beginners/目录）；
• More Python for beginners：深入 Python 语法，探索类与 Mixin、文件系统操作，并引入async/await（对应仓库中的more-python-for-beginners/目录）；
• Even more Python for beginners：转向数据科学工具链，上手 Jupyter Notebook、pandas 与 scikit-learn（对应仓库中的even-more-python-for-beginners-data-tools/目录）。

本篇文章的正文完全围绕第二个系列展开，仓库中more-python-for-beginners/目录下的 9 个主题模块（01 - Formatting and linting至09 - Asynchronous programming）即是每个视频课程配套的可运行示例代码。

学习目标与课程边界

本课程覆盖的内容

原文档在 "What you'll learn" 中明确了三大能力目标：

1. 创建类与对象（Creating classes and objects）——包括类定义、构造器、属性、继承与多重继承（Mixin）；
2. 异步开发（Asynchronous development）——基于asyncio标准库的async/await编程模型；
3. 文件系统操作（Working with the filesystem）——基于pathlib与io的路径管理和文件读写。

本课程刻意不覆盖的内容

原文档同时给出了明确的"边界声明"，避免初学者被概念淹没：

• 面向对象设计（object-oriented design）等编程概念：课程只展示"如何在 Python 里写出类"，不深入讲解什么是封装、抽象、SOLID 原则这类设计理论；
• 数据库访问（Database access）：不在本课程范围内。

这一点与仓库根 README.md 的总体假设一致：课程默认读者已经熟悉至少一门其他编程语言和核心编程概念，例如知道什么是布尔表达式，只是需要学习 Python 的语法写法。

前置要求与开发环境搭建

原文档列出了三条硬性前置条件：

• 理解 Git 的基本用法（用于克隆与切换本仓库代码）；
• 理解 Python 基础（建议先完成Python for beginners第一门课）；
• 安装 Visual Studio Code 或其他代码编辑器（课程视频以 VS Code 为主）。

创建虚拟环境

原文档给出的标准步骤是：为每个项目创建独立的虚拟环境，避免污染全局 Python 环境。具体命令因操作系统而异：

# Windows python -m venv venv .\venv\Scripts\activate # Linux or macOS python3 -m venv venv . ./venv/bin/activate

创建后，虚拟环境中的pip会与系统全局隔离，后续安装的依赖都只属于本项目。

安装异步编程所需的依赖包

本课程的异步编程模块需要两个第三方包，它们被集中声明在仓库的 requirements.txt 中：

aiohttp requests

安装命令同样区分操作系统：

# Windows pip install -r requirements.txt # Linux or macOS pip3 install -r requirements.txt

其中requests用于同步 HTTP 请求（sync_demo.py），而aiohttp用于异步 HTTP 请求（async_demo.py）。两行依赖、两个脚本，构成了第 9 课同步与异步性能对比演示的完整基础。

模块 01：代码格式化与 Lint

该模块（01 - Formatting and linting/）的目标是让代码“可读、更易于调试”，这是所有后续模块代码质量的地基。

格式化与文档规范

原文档 01 - Formatting and linting/README.md 强调了两条 Python 官方约定：

• PEP 8：Python 代码的官方编码约定，涵盖缩进（4 空格）、行宽、命名风格（snake_case函数与变量、CamelCase类名）等；
• Docstring（PEP 257）：模块、函数、类或方法的官方文档字符串标准，用于说明其用途。

Lint 工具链

• Pylint：Python 的 linter，用于强制执行编码标准并检查代码错误；
• VS Code 的 Python Linting 支持：可在编辑器中实时高亮格式与规范问题；
• 类型提示（Type hints）：允许部分 IDE 和 linter 强制类型检查，提前暴露类型错误。

源码对照：bad.py 与 good.py

仓库给出了"坏代码"与"好代码"的直观对照。先看 bad.py：

x = 12 if x == 24: print('Is valid') # 缩进不一致：只有 1 个空格 else: print("Not valid") # 引号风格不统一 def helper(name='sample'): # 默认参数 '=' 两侧多出空格 pass def another(name = 'sample'): # 同上，且缩进为 8 空格而非 4 空格 pass

这段代码虽然能运行，但存在三处典型的规范问题：if分支缩进不一致（1 空格 vs 4 空格）、字符串引号混用（单引号与双引号）、默认参数赋值符号两侧多余空格。Pylint 可以自动识别这些问题。

再看规范版本 good.py：

def print_hello(name: str) -> str: """ Greets the user by name Parameters: name (str): The name of the user Returns: str: The greeting """ print('Hello, ' + name)

它演示了完整的"好代码"三要素：统一的 4 空格缩进、函数签名使用类型提示（name: str -> str）、函数体附带符合 PEP 257 的 Docstring（说明参数与返回值）。从源码结构可以看出，本模块的教学逻辑是"先展示坏味道，再展示规范写法"，两者对照即可直观理解格式化的价值。

模块 02：Lambda 匿名函数

原文档 02 - Lambdas/README.md 给出定义：

lambda是一个小型匿名函数，可以接收任意数量的参数，但只能执行一个表达式。

为什么需要 lambda：直接排序失败的场景

仓库通过三个脚本层层递进地讲解。首先是 failed_sort.py：

# 这段代码会报错，因为 sort 方法不知道按哪个字段排序 presenters = [ {'name': 'Susan', 'age': 50}, {'name': 'Christopher', 'age': 47} ] presenters.sort() print(presenters)

当列表元素是字典时，直接调用sort()会抛出TypeError——Python 不知道两个字典之间如何比较大小，必须显式告诉它"按什么键排序"。

三种解决方案对比

方案一：定义具名函数作为 key（method_sorter.py）：

def sorter(item): return item['name'] presenters.sort(key=sorter)

功能正确，但为一次排序单独定义一个函数略显冗长。

方案二：lambda 内联排序（lambda_sorter.py）：

# 按名字字母序 presenters.sort(key=lambda item: item['name']) print('-- alphabetically --') print(presenters) # 按名字长度排序（短到长） presenters.sort(key=lambda item: len(item['name'])) print('-- length --') print(presenters)

一个脚本演示了 lambda 的核心用法：key参数接收一个"输入一个元素、输出一个可比较值"的函数。第一个排序按名字字母序，第二个按名字长度——只需换一行表达式即可切换排序维度，充分体现了"只执行一个表达式"的 lambda 在简单场景下的简洁优势。两次排序的输出分别是Christopher在Susan之后（字母序），以及Susan（5 个字符）排在Christopher（11 个字符）之前（长度序）。

模块 03：类（Classes）

原文档 03 - Classes/README.md 的定义非常凝练：

类定义数据结构与行为，允许你把数据和功能组合在一起。

基础类：构造器与方法

basic_class.py 演示了最核心的三个要素：

class Presenter(): def __init__(self, name): # 构造器 self.name = name def say_hello(self): # 方法 print('Hello, ' + self.name) presenter = Presenter('Chris') presenter.name = 'Christopher' presenter.say_hello()

要点解读：

• __init__是构造器，在Presenter('Chris')实例化时自动调用；
• self指向当前实例，self.name把参数存入实例属性；
• 实例属性是"公开"的，可以直接赋值修改（presenter.name = 'Christopher'），这也为下一个示例埋下了伏笔；
• 实例方法say_hello通过self访问实例状态。

属性（Property）：为赋值加入校验

直接暴露公开属性虽然简单，但无法在赋值时做校验。properties_class.py展示了用@property装饰器把属性访问包装成方法：

class Presenter(): def __init__(self, name): # 构造器 self.name = name @property def name(self): print('Retrieving name...') return self.__name @name.setter def name(self, value): # 在这里做校验 print('Validating name...') self.__name = value presenter = Presenter('Chris') presenter.name = 'Christopher' print(presenter.name)

关键点：

• @property把方法变成"只读属性"，访问presenter.name时实际执行 getter；
• @name.setter提供赋值钩子，注释明确标注"cool validation here"（此处可插入校验逻辑），所有赋值都会先经过这里；
• 真正的数据存放在"名称改写"后的私有属性self.__name中，避免与 property 方法同名冲突。

运行时，presenter.name = 'Christopher'会触发 setter 打印Validating name...，而print(presenter.name)触发 getter 打印Retrieving name...。这就是"在类的数据与行为之间加入受控访问"的 Python 惯用实现。

模块 04：继承（Inheritance）

原文档 04 - Inheritance/README.md 给出了术语定义：

继承允许你定义一个类，它继承另一个类的所有方法与属性。被继承的类称为父类/基类；继承而来的类称为子类/派生类。

源码演示：Person 与 Student

04 - Inheritance/demo.py 完整演示了继承关系：

class Person: def __init__(self, name): self.name = name def say_hello(self): print('Hello, ' + self.name) class Student(Person): def __init__(self, name, school): super().__init__(name) self.school = school def sing_school_song(self): print('Ode to ' + self.school) student = Student('Christopher', 'UVM') student.say_hello() # 继承自 Person 的方法 student.sing_school_song() # Student 自己的方法 # What are you? print(isinstance(student, Student)) # True print(isinstance(student, Person)) # True print(issubclass(Student, Person)) # True

三个值得注意的实践点：

1. super().__init__(name)：子类构造器必须先调用父类构造器，把name初始化交给Person，自己再扩展school属性。super()是访问父类方法的关键入口；
2. 方法复用：Student实例可以直接调用say_hello()（继承而来），同时拥有自己的sing_school_song()，形成"共性上提、特性下放"的层次结构；
3. 类型关系检查：脚本末尾用isinstance/issubclass验证了继承的语义——Student实例同时也是Person实例（isinstance结果为True），Student是Person的子类（issubclass结果为True）。这两个内置函数在后文 Mixin 示例的框架代码中还会再次登场。

模块 05：Mixins（多重继承）

原文档 05 - Mixins/README.md 指出：

Python 允许从多个类继承。虽然技术术语是多重继承，但很多开发者把"多个基类"的用法称为Mixin。这种模式在 Django 等框架中非常常见。

文档同时给出了两个官方参考点：多重继承语法，以及super()用于访问父类方法与属性。

源码演示：可混入的 Loggable 与 Connection

05 - Mixins/demo.py 是一个极具教学价值的组合示例：

class Loggable: def __init__(self): self.title = '' def log(self): print('Log message from ' + self.title) class Connection: def __init__(self): self.server = '' def connect(self): print('Connecting to database on ' + self.server) class SqlDatabase(Connection, Loggable): def __init__(self): super().__init__() self.title = 'Sql Connection Demo' self.server = 'Some_Server' def framework(item): if isinstance(item, Connection): item.connect() if isinstance(item, Loggable): item.log() sql_connection = SqlDatabase() framework(sql_connection)

这段代码的深层含义值得展开：

1. Mixin 的定义方式：Loggable和Connection各自只负责一个横切能力（记录日志、建立连接），它们不单独实例化使用，而是作为"配料"混入最终类；
2. 组合出完整对象：SqlDatabase(Connection, Loggable)同时继承两个能力，构造器中一次super().__init__()沿 MRO（方法解析顺序）初始化各基类属性，然后填充自己的title与server；
3. 面向能力的框架调用：framework()函数并不关心传入对象的具体类型，只通过isinstance检查它"是否具备某项能力"（Connection能力、Loggable能力），再按需调用对应方法。这就是 Mixin 模式在框架（如 Django 的类视图混入认证、缓存等能力）中被广泛使用的根本原因——它让"能力检测 + 能力调用"变得极其灵活。

运行结果会依次打印Connecting to database on Some_Server与Log message from Sql Connection Demo。

模块 06：文件系统管理（pathlib）

原文档 06 - Managing the file system/README.md 一句话点题：

Python 的pathlib提供了访问文件系统中文件与目录的操作和类。

该模块包含三个脚本，分别覆盖路径构造、目录遍历与文件元信息。

路径构造与存在性检查：paths.py

paths.py（要求 Python 3.6+）：

from pathlib import Path # 当前工作目录 cwd = Path.cwd() print('\nCurrent working directory:\n' + str(cwd)) # 用 joinpath 拼接路径与文件名 new_file = Path.joinpath(cwd, 'new_file.txt') print('\nFull path:\n' + str(new_file)) # 检查文件是否存在 print('\nDoes that file exist? ' + str(new_file.exists()) + '\n')

三个 API 分别是：Path.cwd()获取当前工作目录、Path.joinpath(cwd, 'new_file.txt')以平台无关的方式拼接完整路径（比手写os.path.join更直观，且自动处理分隔符差异）、Path.exists()判断路径是否存在。

目录遍历与类型判断：directories.py

directories.py：

from pathlib import Path cwd = Path.cwd() # 获取父目录 parent = cwd.parent # 是目录吗？是文件吗？ print('\nIs this a directory? ' + str(parent.is_dir())) print('\nIs this a file? ' + str(parent.is_file())) # 列出子目录 print('\n-----directory contents-----') for child in parent.iterdir(): if child.is_dir(): print(child)

这里演示了Path.parent（父目录）、is_dir()/is_file()（类型判定）以及iterdir()（遍历目录条目）的组合用法——遍历时用is_dir()过滤，只打印子目录。

文件元信息提取：files.py

files.py 针对仓库自带的 demo.txt 提取四项信息：

from pathlib import Path cwd = Path.cwd() demo_file = Path(Path.joinpath(cwd, 'demo.txt')) print('\nfile name: ' + demo_file.name) # demo.txt print('\nfile suffix: ' + demo_file.suffix) # .txt print('\nfile folder: ' + demo_file.parent.name) # 所在目录名 print('\nfile size: ' + str(demo_file.stat().st_size) + '\n') # 字节数

Path.name返回文件名、Path.suffix返回扩展名、Path.parent.name返回所在目录名、Path.stat().st_size返回文件字节大小——覆盖了日常脚本中最常用的文件元信息查询。

模块 07：读写文件（io）

原文档 07 - Reading and writing files/README.md 点明底层机制：

Python 允许你读写文件。io是提供输入/输出（I/O）能力的模块，包括来自文件的文本 I/O。

读取文件：read.py

read.py 打开仓库自带的 demo.txt（内容为三行文本），演示了open()的文本模式与三种读取方式：

stream = open('./demo.txt', 'rt') print('\nIs this readable? ' + str(stream.readable())) # True print('\nRead one character : ' + stream.read(1)) # 'T' print('\nRead to end of line : ' + stream.readline()) # 读到换行 print('\nRead all lines to end of file :\n' + str(stream.readlines()) + '\n')

模式字符串'rt'中，r表示读取（read）、t表示文本模式（text）；stream.readable()校验流是否可读；read(1)读一个字符、readline()读到行尾、readlines()一次性把剩余所有行读成字符串列表。三种方法从细粒度到整体覆盖了文本读取的全部需求。

写入文件：write.py

write.py 演示写入模式的完整用法：

stream = open('output.txt', 'wt') print('\nCan I write to this file? ' + str(stream.writable()) + '\n') stream.write('H') # 写入单个字符串 stream.writelines(['ello',' ','world']) # 写入一个或多个字符串 stream.write('\n') # 写入换行 names = ['Susan','Christopher'] stream.writelines(names) # 一个实用技巧：用 join 在列表元素之间插入换行 stream.write('\n') # 写入换行 stream.writelines('\n'.join(names)) stream.close() # 冲刷缓冲并关闭

模式'wt'中，w表示写入（write）、t表示文本模式；writable()校验可写性；write()写单个字符串，writelines()批量写字符串序列；最后close()冲刷缓冲并关闭文件。脚本还演示了一个实用技巧：直接writelines(names)会让两个名字连在一起，而先用'\n'.join(names)转换就能在每个名字之间插入换行，最终文件中 Susan 与 Christopher 各占一行。

流指针控制：manage.py

manage.py 进一步演示了文件流的指针控制：

stream = open('manage.txt', 'wt') stream.write('demo!') # 写入 demo! stream.seek(0) # 把指针移回文件开头 stream.write('cool') # 从开头覆盖写入 cool stream.flush() # 把流内容冲刷到文件缓冲区 stream.close() # 冲刷并关闭

seek(0)将读写位置移回文件开头，于是'cool'覆盖了'demo!'的前四个字符，最终文件内容为'cool!'。flush()强制把内存缓冲写入磁盘文件，close()完成最后的冲刷并释放资源。

模块 08：with 语句管理外部资源

原文档 08 - Managing external resources/README.md 点出了with的本质价值：

with语句允许你简化try/finally代码。对于任何支持with的操作，都应优先使用with。

源码对照：try/finally 与 with

08 - Managing external resources/demo.py 给出了两种写法的直接对照：

try: stream = open('output.txt', 'wt') stream.write('Lorem ipsum dolar') finally: stream.close() # THIS IS REALLY IMPORTANT!! # with open('output.txt', 'wt') as stream: # stream.write('Lorem ipsum dolar')

上半部分是手动管理资源的传统写法：必须用finally保证close()一定执行——否则一旦write()抛出异常，文件句柄就会泄漏。源码中的注释 "THIS IS REALLY IMPORTANT!!" 强调了忘记关闭流的严重后果。

下半部分（被注释的with版本）则是等价且更简洁的推荐写法：with语句会在代码块结束时自动调用close()，无论正常结束还是抛出异常，资源都会被可靠释放。这正是原文档"任何支持with的操作都应使用with"这句忠告的由来。文件句柄、网络连接、锁等外部资源都适用这一模式。

模块 09：异步编程（asyncio / async / await）

原文档 09 - Asynchronous programming/README.md 给出了权威定义：

Python 为管理长时间运行的操作提供了多种异步方案。asyncio是支持异步操作的核心库，包括async/await语法。

这也是整个系列中最"前沿"的内容。仓库用两个脚本做了同场景的同步/异步对比。

同步版本：串行等待

sync_demo.py：

from timeit import default_timer import requests def load_data(delay): print(f'Starting {delay} second timer') text = requests.get(f'http://httpbin.org/delay/{delay}').text print(f'Completed {delay} second timer') def run_demo(): start_time = default_timer() two_data = load_data(2) # 先等 2 秒 three_data = load_data(3) # 再等 3 秒 elapsed_time = default_timer() - start_time print(f'The operation took {elapsed_time:.2} seconds') def main(): run_demo() main()

requests.get()是阻塞调用：先请求/delay/2等待约 2 秒返回，然后才发起/delay/3再等约 3 秒。总耗时约5 秒，两个网络请求完全串行，CPU 在等待期间无事可做。

异步版本：并发执行

async_demo.py 用aiohttp+asyncio重写同一场景：

from timeit import default_timer import aiohttp import asyncio async def load_data(session, delay): print(f'Starting {delay} second timer') async with session.get(f'http://httpbin.org/delay/{delay}') as resp: text = await resp.text() print(f'Completed {delay} second timer') return text async def main(): start_time = default_timer() # 创建单个会话 async with aiohttp.ClientSession() as session: # 创建任务并让它们跑起来 two_task = asyncio.create_task(load_data(session, 2)) three_task = asyncio.create_task(load_data(session, 3)) # 模拟其他处理 await asyncio.sleep(1) print('Doing other work') # 取回结果 two_result = await two_task three_result = await three_task elapsed_time = default_timer() - start_time print(f'The operation took {elapsed_time:.2} seconds') asyncio.run(main())

这段代码集中体现了async/await的全部核心机制：

1. async def定义协程：load_data和main都是协程函数，调用它们不会立即执行，而是返回协程对象；
2. asyncio.create_task()并发调度：两个load_data任务被同时创建并投入事件循环，/delay/2与/delay/3两个 HTTP 请求在等待网络时并发进行，而不是串行排队；
3. await让出控制权：await session.get(...)在等待响应时把控制权交还给事件循环，让其他任务得以推进；await asyncio.sleep(1)则模拟了"等待期间做其他工作"（打印Doing other work）的场景——这在同步代码中是不可能的；
4. async with自动管理资源：aiohttp.ClientSession和每个resp都由async with保证异步上下文的正确释放；
5. asyncio.run(main())统一入口：Python 3.7+ 推荐的方式，负责创建事件循环、运行main协程并回收资源。

由于 2 秒和 3 秒的请求并发进行，总耗时约3 秒（以最长的任务为准），相比同步版本节省约 2 秒。这就是异步编程在 I/O 密集场景下的核心收益：把"等待网络的时间"转化为"并行处理的时间"。

仓库示例代码总览

more-python-for-beginners/目录下的完整学习路线与对应文件如下：

建议的实践路径是：克隆仓库后按上文创建虚拟环境并安装依赖，然后按模块编号顺序逐个运行脚本。对于 01、03、05 等纯本地示例直接python xxx.py即可；对于 09 模块，先运行sync_demo.py记录串行耗时，再运行async_demo.py对比并发耗时（需要联网访问httpbin.org）；对于 06、07 模块，请确认demo.txt与脚本位于同一目录后再运行，以便观察文件读取与写入结果。

后续学习路径

原文档在 "Next steps" 中为完成本课程的读者列出了继续深造的官方方向，这些内容也与本仓库其余两个系列形成衔接：

• 面向对象编程（Python）：在本课已经会"写类"的基础上，系统学习类设计的更多组织方式；
• 使用 Python 与 Flask 构建 AI Web 应用：把类、文件操作与网络请求能力整合进真实 Web 服务；
• 使用 Microsoft Graph 构建 Python Django 应用：体验 Mixin 在 Django 框架中的实际应用；
• 在 Azure App Service（Linux）上创建 Python 应用：把本地写好的异步 Web 应用部署上云。

如果希望继续深入数据方向，仓库还提供了第三门课 even-more-python-for-beginners-data-tools/README.md 的完整配套——从 Jupyter Notebook 开始，逐步上手 pandas、NumPy 与 scikit-learn 的机器学习建模流程。至此，"入门语法 → 进阶特性 → 数据工具"三条课程线全部打通，你已经具备跟随任意 Python 官方快速入门教程继续成长的完整基础。

• 示例工程
• 教程