PyCon-2023-会议笔记-全-

PyCon 2023 会议笔记（全）

001：Python 基础与环境搭建 🐍

在本节课中，我们将要学习 Python 编程语言的基础概念，并完成开发环境的搭建。这是开启 Python 学习之旅的第一步。

什么是 Python？ 🤔

Python 是一种高级、解释型的编程语言。它以其简洁清晰的语法和强大的功能而闻名，非常适合初学者入门，同时也被广泛应用于科学计算、数据分析、人工智能和网络开发等领域。

Python 的设计哲学强调代码的可读性和简洁性。一个核心特点是使用缩进来定义代码块，而不是像其他语言那样使用花括号。

搭建 Python 开发环境 ⚙️

上一节我们介绍了 Python 的基本概念，本节中我们来看看如何准备一个可以编写和运行 Python 代码的环境。

要开始编写 Python 程序，你需要在你的计算机上安装 Python 解释器。解释器是能够读取并执行你写的 Python 代码的程序。

以下是安装 Python 的步骤：

访问官方网站：打开浏览器，访问 Python 的官方网站 python.org。
下载安装包：在网站首页找到下载链接，选择适合你操作系统（如 Windows、macOS 或 Linux）的最新稳定版本进行下载。
运行安装程序：下载完成后，运行安装程序。在安装过程中，请务必勾选 “Add Python to PATH” 这个选项，这能让你在系统的任何地方都能方便地使用 Python。
验证安装：安装完成后，打开命令行工具（在 Windows 上是命令提示符或 PowerShell，在 macOS 或 Linux 上是终端）。输入命令 python --version 并按下回车。如果安装成功，命令行会显示你安装的 Python 版本号，例如 Python 3.9.7。

编写你的第一个 Python 程序 ✨

环境搭建好后，我们就可以尝试编写第一个程序了。我们将从一个经典的“Hello, World!”程序开始。

你可以使用任何文本编辑器来编写代码，但为了更好的体验，推荐使用专为编程设计的编辑器，如 VS Code 或 PyCharm。

创建一个新文件，将其命名为 hello.py。在文件中输入以下代码：

print("Hello, World!")

这行代码使用了 Python 的内置函数 print()，它的作用是将括号内的内容输出到屏幕上。

运行 Python 程序 🚀

代码写好后，我们需要运行它来看到结果。

以下是运行 Python 程序的两种常用方法：

方法一：使用命令行
打开命令行工具，使用 cd 命令切换到你的 hello.py 文件所在的目录。然后输入命令 python hello.py 并按下回车。你将在屏幕上看到输出：Hello, World!。

方法二：使用集成开发环境
如果你使用的是 PyCharm 或 VS Code 等 IDE，通常编辑器内部会有一个“运行”按钮。点击它，程序就会在编辑器集成的终端中执行，并显示结果。

运行成功后，你就完成了第一个 Python 程序的完整流程：编写、保存、执行。

总结 📝

本节课中我们一起学习了 Python 的基础知识和环境搭建。我们了解了 Python 语言的特点，完成了 Python 解释器的安装与验证，并成功编写和运行了第一个程序。

记住，print() 是你向世界输出信息的第一个工具。准备好你的环境是开始任何编程项目的第一步。在接下来的课程中，我们将深入探索变量、数据类型和控制流等更丰富的 Python 知识。

002：使用Python监控政府公开信息 📊

在本节课中，我们将学习如何使用Python获取和分析政府公开数据。这是一个实践性很强的主题，我们将从基础概念入手，逐步构建一个简单的数据监控脚本。

上一节我们介绍了Python编程的基础环境。本节中我们来看看如何利用Python访问网络上的公开数据源。

概述

政府机构、公共组织和新闻媒体通常会通过官方网站或数据门户发布大量信息，如政策文件、统计数据、招标公告等。这些信息是公开的，但手动跟踪效率低下。使用Python可以自动化数据收集过程，帮助我们高效地监控这些变化。

核心概念与工具

在开始编写代码前，需要理解几个核心概念和将要用到的Python库。

网络请求：这是从网站获取数据（通常是HTML代码）的第一步。Python的 requests 库可以完成这个任务。

import requests
response = requests.get('https://example.gov/data')

HTML解析：获取到的网页内容是HTML格式，我们需要从中提取有用的文本或数据。BeautifulSoup 库能帮助我们解析HTML。

from bs4 import BeautifulSoup
soup = BeautifulSoup(response.content, 'html.parser')

数据存储：提取到的数据需要保存下来以供分析。我们可以使用简单的文本文件，或者更结构化的 CSV 文件。

import csv
with open('data.csv', 'w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    writer.writerow(['标题', '发布日期', '链接']) # 写入表头

实践步骤：构建一个简单的监控脚本

以下是构建一个基础监控脚本的主要步骤。

第一步：确定目标与检查合规性

首先，必须明确监控的数据源。务必只针对完全公开、允许访问的网站和数据接口进行操作。在编写任何爬虫前，应仔细阅读目标网站的 robots.txt 文件和服务条款，确保你的行为符合规定。

第二步：分析网页结构

使用浏览器的“开发者工具”（通常按F12键打开）查看目标网页的HTML结构。我们需要找到包含目标信息的HTML标签及其属性（如 class、id）。

例如，新闻标题可能包裹在 <h2 class="news-title"> 这样的标签里。

第三步：编写数据抓取代码

根据分析好的结构，编写Python代码来抓取数据。

以下是抓取一个假设的新闻列表页面的示例代码框架：

import requests
from bs4 import BeautifulSoup
import csv
import time

# 1. 发送网络请求
url = 'https://example.gov/news'
headers = {'User-Agent': 'Your-Bot-Name/1.0'} # 设置一个友好的用户代理
try:
    response = requests.get(url, headers=headers, timeout=10)
    response.raise_for_status() # 检查请求是否成功
except requests.RequestException as e:
    print(f"请求失败: {e}")
    exit()

# 2. 解析HTML内容
soup = BeautifulSoup(response.content, 'html.parser')
news_items = soup.find_all('div', class_='news-item') # 找到所有新闻条目容器

data_to_save = []
for item in news_items:
    # 3. 提取具体信息
    title_tag = item.find('h2', class_='news-title')
    link_tag = item.find('a')
    date_tag = item.find('span', class_='date')

    title = title_tag.get_text(strip=True) if title_tag else 'N/A'
    # 处理相对链接
    link = link_tag['href'] if link_tag and link_tag.has_attr('href') else 'N/A'
    if link and link.startswith('/'):
        link = 'https://example.gov' + link
    date = date_tag.get_text(strip=True) if date_tag else 'N/A'

    data_to_save.append([title, date, link])

# 4. 保存数据到CSV文件
filename = f'gov_news_{time.strftime("%Y%m%d")}.csv'
with open(filename, 'w', newline='', encoding='utf-8-sig') as csvfile:
    writer = csv.writer(csvfile)
    writer.writerow(['标题', '发布日期', '详情链接'])
    writer.writerows(data_to_save)

print(f"数据已保存到 {filename}")

第四步：实现定时与增量抓取

简单的监控需要定期运行。我们可以使用操作系统的定时任务（如Linux的cron或Windows的任务计划程序）来定时执行脚本。

为了实现只抓取新内容，可以在每次运行后记录已抓取条目的唯一标识（如ID或链接），下次运行时跳过已记录的内容。

# 简易的去重逻辑示例
seen_links = set()
# ... 从文件加载之前已抓取的链接到 seen_links ...
new_data = []
for item in news_items:
    link = extract_link(item) # 提取链接的函数
    if link not in seen_links:
        new_data.append(extract_data(item))
        seen_links.add(link)
# ... 保存新数据并更新已见链接记录文件 ...

第五步：数据分析与提醒

获取数据后，可以进行简单的分析。例如，使用 pandas 库统计特定关键词出现的频率。

import pandas as pd
df = pd.read_csv('gov_news_20231027.csv')
keyword = '环保'
# 筛选标题中包含关键词的新闻
filtered_df = df[df['标题'].str.contains(keyword, na=False)]
print(f"今日包含'{keyword}'的新闻有 {len(filtered_df)} 条。")

如果需要紧急提醒，可以集成邮件（smtplib库）或即时通讯工具（如钉钉、企业微信的Webhook）的API，在满足特定条件时发送通知。

注意事项与最佳实践

在实施过程中，请务必遵守以下原则：

遵守法律法规与网站协议：这是最重要的前提。不要尝试抓取非公开、需要登录或明确禁止爬虫访问的数据。
设置友好间隔：在请求间添加延时（如 time.sleep(2)），避免对目标服务器造成过大压力。
处理异常：网络请求可能失败，HTML结构可能变化。代码中应使用 try...except 进行异常处理，增强脚本的健壮性。
尊重版权与隐私：对抓取到的数据的使用，需注意版权和隐私问题，避免滥用。

总结

本节课中我们一起学习了使用Python监控政府公开信息的基本流程。我们从理解网络请求和HTML解析开始，逐步构建了一个能够自动抓取、解析和保存网页数据的脚本框架，并探讨了定时运行、增量抓取以及简单分析的方法。

记住，技术是工具，其使用必须建立在合法、合规和道德的基础之上。利用Python进行公开数据监控，目的是提升信息获取效率，促进数据的有效利用。

003：使用 Pytest 进行单元测试 🧪

在本节课中，我们将要学习如何使用 Pytest 框架为 Python 代码编写和运行单元测试。Pytest 是一个功能强大且易于使用的测试框架，可以帮助我们确保代码的质量和可靠性。

概述

单元测试是软件开发中验证代码最小单元（通常是函数或方法）是否按预期工作的过程。使用 Pytest 可以让我们以简洁的语法编写测试，并轻松地运行和管理它们。

P3：1：安装与基本用法 🔧

首先，我们需要安装 Pytest。可以通过 Python 的包管理工具 pip 来完成安装。

安装命令如下：

pip install pytest

安装完成后，就可以开始编写测试了。Pytest 会自动发现并运行以 test_ 开头的文件或函数。

P3：2：编写第一个测试 ✍️

上一节我们介绍了如何安装 Pytest，本节中我们来看看如何编写一个简单的测试函数。

假设我们有一个计算两个数相加的函数 add，存放在 calculator.py 文件中：

# calculator.py
def add(a, b):
    return a + b

为了测试这个函数，我们创建一个名为 test_calculator.py 的文件。在 Pytest 中，测试函数的名字应以 test_ 开头。

一个基本的测试示例如下：

# test_calculator.py
from calculator import add

def test_add():
    result = add(2, 3)
    assert result == 5

在这个测试中，我们使用 assert 语句来验证 add(2, 3) 的结果是否等于 5。如果断言为真，测试通过；否则，测试失败。

P3：3：运行测试 ▶️

编写好测试后，我们需要运行它来验证代码。运行测试非常简单。

在终端中，切换到测试文件所在的目录，然后执行以下命令：

pytest

Pytest 会自动发现当前目录及其子目录中所有以 test_ 开头的文件和函数，并执行它们。运行结果会显示每个测试是通过还是失败。

P3：4：使用断言验证结果 ✅

assert 语句是 Pytest 测试的核心。它用于检查条件是否为真。如果条件为假，Pytest 会报告测试失败，并显示详细的错误信息。

除了简单的相等断言，Pytest 还支持多种断言方式，用于测试不同的条件。

以下是几种常见的断言示例：

检查相等性： assert func() == expected_value
检查不等性： assert func() != value
检查是否为真： assert condition is True
检查是否包含： assert item in collection
检查是否引发异常： 使用 pytest.raises

例如，测试一个函数是否引发了特定的异常：

import pytest

def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        # 假设 divide 函数在除数为零时会抛出 ZeroDivisionError
        divide(10, 0)

P3：5：测试的组织与标记 🏷️

随着项目规模的增长，测试用例会越来越多。良好的组织和管理测试至关重要。Pytest 提供了测试类和标记（mark）功能来帮助我们。

使用测试类：
可以将相关的测试函数组织在一个类中，类名应以 Test 开头。

class TestCalculator:
    def test_add(self):
        assert add(1, 2) == 3

    def test_multiply(self):
        # 假设有 multiply 函数
        assert multiply(2, 3) == 6

使用标记：
标记（mark）允许我们对测试进行分组，例如标记为“慢速测试”或“集成测试”，然后选择性地运行它们。

首先，在测试函数上使用 @pytest.mark 装饰器：

import pytest

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/a937c5a7ffe7d3c8204383fd3d5b5753_27.png)

@pytest.mark.slow
def test_very_slow_function():
    # 这是一个运行很慢的测试
    result = slow_function()
    assert result is not None

然后，可以只运行带有特定标记的测试：

pytest -m slow

或者，排除带有特定标记的测试：

pytest -m “not slow”

P3：6：使用 Fixture 进行测试准备 🧰

在测试中，我们经常需要一些公共的 setup（准备）和 teardown（清理）代码，例如创建数据库连接、初始化对象等。Pytest 的 Fixture 功能完美地解决了这个问题。

Fixture 是一个函数，用 @pytest.fixture 装饰器标记。它可以在测试函数中被调用，为其提供所需的数据或状态。

定义一个简单的 Fixture：

import pytest

@pytest.fixture
def sample_data():
    # 这个函数会在测试前执行，返回准备的数据
    data = [1, 2, 3, 4, 5]
    return data

在测试中使用 Fixture：
只需将 Fixture 的函数名作为测试函数的参数即可。

def test_sum(sample_data):
    total = sum(sample_data)
    assert total == 15

当运行 test_sum 时，Pytest 会自动调用 sample_data fixture 函数，并将其返回值注入到测试中。

Fixture 还可以设置作用域（如 function， class， module， session），并支持自动清理（通过 yield）。

P3：7：参数化测试 📊

有时我们需要用多组不同的输入数据来测试同一个功能，以验证其在不同情况下的行为。手动为每组数据编写一个测试函数非常繁琐。Pytest 的参数化测试功能可以优雅地解决这个问题。

使用 @pytest.mark.parametrize 装饰器，我们可以向一个测试函数传递多组参数。

参数化测试示例：

import pytest

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/a937c5a7ffe7d3c8204383fd3d5b5753_47.png)

@pytest.mark.parametrize(“input_a, input_b, expected”, [
    (1, 2, 3),
    (5, -1, 4),
    (0, 0, 0),
    (100, 200, 300),
])
def test_add_with_params(input_a, input_b, expected):
    result = add(input_a, input_b)
    assert result == expected

Pytest 会将列表中的每一组参数（如 (1, 2, 3)）依次传递给 test_add_with_params 函数并运行测试。这样，一个测试函数就覆盖了多种测试情况，测试报告也会清晰地显示每一组参数的运行结果。

总结

本节课中我们一起学习了使用 Pytest 进行 Python 单元测试的核心知识。

我们首先介绍了如何安装 Pytest，然后学习了编写和运行简单测试的基本流程。接着，我们深入探讨了如何使用 assert 语句进行各种验证，以及如何通过测试类和标记来更好地组织测试用例。

最后，我们掌握了两个高级功能：Fixture 和 参数化测试。Fixture 帮助我们管理测试的依赖和状态，使测试代码更清晰、可复用。参数化测试则让我们能轻松地用多组数据测试同一逻辑，极大地提高了测试的效率和覆盖率。

通过掌握这些内容，你已经能够为你的 Python 项目构建一个强大、灵活且易于维护的自动化测试套件了。

004：FastAPI简介

概述

在本节课中，我们将要学习FastAPI的基础知识。FastAPI是一个用于构建API的现代、快速（高性能）的Web框架。我们将了解它的核心特性、如何创建第一个API，以及它如何自动处理数据验证和生成文档。

什么是FastAPI？🚀

FastAPI是一个基于Python的Web框架，专门用于构建API。它的设计目标是高性能、易于学习且快速编码。

FastAPI建立在标准Python类型提示之上，这带来了许多优势。

核心特性 ✨

上一节我们介绍了FastAPI的基本概念，本节中我们来看看它的核心特性。

以下是FastAPI的主要优点：

高性能：FastAPI的性能与NodeJS和Go相当，是现有Python框架中最快的之一。
快速开发：编码速度可提高约200%至300%。
更少的Bug：减少约40%的人为错误。
直观：强大的编辑器支持，处处皆可自动补全。
简单：设计易于使用和学习，阅读文档的时间更短。
简洁：最小化代码重复，每个参数声明可提供多重功能。
健壮：生产就绪的代码，带有自动交互式文档。
基于标准：完全兼容API的开放标准（OpenAPI和JSON Schema）。

创建你的第一个API 🛠️

了解了FastAPI的特性后，现在我们来动手创建第一个API。

首先，需要安装FastAPI和一个ASGI服务器，例如uvicorn。

pip install fastapi uvicorn

创建一个名为main.py的文件，并写入以下代码：

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

这段代码创建了一个简单的API，当你访问根路径/时，它会返回一个JSON响应{"Hello": "World"}。

使用以下命令运行服务器：

uvicorn main:app --reload

现在，打开浏览器访问 http://127.0.0.1:8000，你将看到{"Hello": "World"}。

路径参数与查询参数 🔍

在上一节中，我们创建了一个简单的端点。本节中，我们将学习如何通过路径参数和查询参数来接收用户输入。

路径参数

路径参数是URL路径的一部分。例如，在/items/{item_id}中，item_id就是一个路径参数。

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

FastAPI会自动将URL中的item_id转换为整数类型。如果传入的不是整数（如字符串），FastAPI会自动返回一个错误。

查询参数

查询参数是URL中?后面的键值对，例如/items/?skip=0&limit=10。

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

函数参数skip和limit不是路径的一部分，因此它们自动被识别为查询参数。=0和=10是它们的默认值。

请求体与Pydantic模型 📦

我们已经学会了如何通过URL传递参数。但有时我们需要接收更复杂的数据，比如JSON对象，这时就需要使用请求体。

FastAPI使用Pydantic模型来定义请求体的结构，这能确保数据的类型安全并自动生成文档。

以下是定义一个Item模型并用于POST请求的例子：

from pydantic import BaseModel
from typing import Optional, List

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/961f621bdc0577b20c7f2804f8d9d1e3_3.png)

class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None
    tags: List[str] = []  # 定义一个字符串列表

@app.post("/items/")
async def create_item(item: Item):
    return item

当你向/items/发送一个POST请求，并附带一个符合Item模型的JSON数据时，FastAPI会自动：

解析JSON。
转换为相应的类型（如将字符串转为浮点数）。
验证数据。如果数据无效（例如price是字符串”hello”），会返回清晰详细的错误信息。
在交互式API文档中提供JSON模式。

自动交互式API文档 📖

FastAPI最强大的特性之一是自动生成交互式API文档。

运行你的应用后，你可以访问以下两个地址查看文档：

Swagger UI 文档：http://127.0.0.1:8000/docs
ReDoc 文档：http://127.0.0.1:8000/redoc

在这些文档中，你可以：

查看所有已定义的API端点。
看到每个端点所需的参数、请求体模型和响应模型。
直接进行API调用测试，无需使用其他工具如Postman。

文档完全基于你代码中的类型提示和Pydantic模型自动生成，确保了文档与代码的实时同步。

总结 🎯

本节课中我们一起学习了FastAPI的核心内容：

FastAPI是什么：一个高性能、易学易用的现代Python Web API框架。
创建第一个API：如何使用@app.get()装饰器定义端点并运行服务器。
处理输入：如何使用路径参数和查询参数从URL获取数据。
处理复杂数据：如何使用Pydantic模型定义请求体，实现强大的数据验证和类型转换。
自动文档：FastAPI如何基于你的代码自动生成交互式API文档（Swagger UI和ReDoc），极大地提升了开发效率。

FastAPI通过利用Python类型提示，在保持代码简洁的同时，提供了无与伦比的开发体验、运行速度和代码可靠性。它是构建现代API的优秀选择。

005：早期会议与组织的诞生 🐍

在本节课中，我们将跟随Python之父Guido van Rossum的回忆，了解Python社区在诞生初期的故事。我们将看到早期的Python会议是如何从一个小型研讨会起步，以及Python软件基金会（PSF）在成立前经历了哪些尝试与挑战。

从研讨会到国际会议

上一节我们提到了Python社区的萌芽，本节中我们来看看早期的聚会是如何演变成正式会议的。

1994年，由Mike Praz组织，我们举办了第一次Python研讨会。约有二三十人参加，这是一个非常小的事件，但取得了巨大成功。所有参与者都觉得这是一次宝贵的经历，因此我们希望能举办更多类似的活动。

基于第一次研讨会的成功，我们很快开始筹划后续活动。六个月后，由Jim Fulton在USGS（美国地质调查局）组织了第二次研讨会。我们发现，每六个月组织一次活动，对于那些没有旅行预算的参与者来说是个挑战，因为他们的经理可能从未听说过Python。

以下是早期会议发展的几个关键节点：

1994年：第一次Python研讨会，约20-30人参加。
1995年：第二次Python研讨会，由Jim Fulton组织。
1997年：活动升级为“第四届国际Python会议”，由劳伦斯利弗莫尔国家实验室的Paul Dubois组织。他引入了会前教程和专用酒店等创新形式。

这次会议给我留下了非常私人的记忆，其中一个记忆的标题是“你能不能给兔子喷一下”。要了解具体含义，你得在走廊里找到我来解释。

组织会议的挑战与尝试

随着会议规模扩大，组织工作变得愈发艰巨。即使是Paul Dubois这样优秀的志愿者也难以独自承担所有工作。

1997年，会议组织工作转移到了一家小型盈利公司Fortex Seminars手中。他们是CNRI（我的雇主，一个非营利研究实验室）的子公司，拥有组织IETF等大型会议的经验。虽然会议设施质量提升了，但据我所知，Fortex在这方面从未真正盈利。

关于早期会议，我还有一个有趣的记忆。有一次在华盛顿特区的Key Bridge Marriott酒店开会，遇上了大雪。我的车被困住了，一位好心的邻居载了我一程。结果我被大雪困在酒店三天，没带够换洗衣物。幸运的是，酒店礼品店有售，而且Python会议从不缺少T恤。

Python软件协会与财团的构想

在会议蓬勃发展的同时，也有人尝试创建更正式的组织。

早在1995年，华盛顿特区的一群人（与早期研讨会组织者有大量重叠）就想创建一个官方的Python非营利组织，并命名为“Python软件协会”。这个名字很好，但他们的进展仅限于创建一个邮件列表来讨论协会章程，讨论始终没有结果。

幸运的是，我的雇主CNRI提供了一条出路。他们愿意托管Python相关的活动，但这并非一个独立的“协会”，最终它只是一个需要缴纳50美元会员费的邮件列表。令人惊讶的是，当时有很多人愿意付费加入，因为找到Python同好并不容易。高峰期我们约有300名成员。

在研究这次演讲时，我发现会员福利包括获得第四届国际Python会议的注册折扣。这或许是我们拥有众多成员的原因。

我们还进行了一次更雄心勃勃的尝试：创建一个Python联盟。CNRI曾成功发起万维网联盟和X窗口系统联盟，我们设想大公司会愿意付费赞助，以在语言设计方面获得发言权。然而在1997年左右，Python还不够重要，我们未能找到足够的赞助商来启动这个联盟。尽管惠普公司曾表示出兴趣，因为他们正在推出一款基于Python的大型产品，但这仍不足以启动联盟。

Python软件基金会的诞生

时间来到2000年左右，我离开了CNRI去创业。这次离开的方式让CNRI继续托管Python相关事务（如Python软件活动）变得有些尴尬。

此时，我们需要一个新的组织方案。幸运的是，核心开发者Greg Stein（他也是Apache软件基金会的董事会成员）提出了一个绝妙的方案：直接采用Apache软件基金会成熟的章程，然后把“Apache”划掉，用蜡笔写上“Python”。这帮助我们避免了再次陷入规章制度的泥潭。

我们在2000年有过一次错误的启动，但最终在2001年正式成立了Python软件基金会（PSF）。到2003年，PSF已经感觉像是一个真实的组织了：我们拥有了银行账户、邮政信箱，甚至一位兼职管理员。

关于2000年那次错误的启动：我们一群创始成员热情高涨，但作为一群程序员，我们缺乏处理法律文件、开设银行账户等实际事务的技能。一位自愿承担这些工作的成功商人，因事务繁忙未能优先处理。最终，是我的新雇主Elemental Security提供了公司律师的帮助，才在2001年将一切落实。

PyCon的诞生与早期挑战

根据我的笔记，最后一次IPC（国际Python会议）是在2002年。Fortex停止了组织工作，而2003年，O‘Reilly公司在其OSCON开源会议上为Python提供了一个专题轨道。但这感觉像是Perl会议的安慰奖，我们并不完全满意。

转机出现在2002年，我接到一个电话。一位Perl社区的组织者有一个预定好的场地，但因故无法使用。他问我Python社区是否有兴趣在同一周使用那个场地举办自己的社区会议。我立刻答应了。

我们为会议想出了“PyCon”这个名字。这个名字并非完全随机，很多人可能都会为Python会议想到它。剩下的，就成了历史。

因为场地是通过我联系的，而我当时是PSF的主席，我最终成为了主要的组织者。这对我这个程序员来说是全新的挑战。例如，我在餐饮上犯了错，连续三天点了完全一样的三明治——我猜那是菜单上最便宜的选择。有人抱怨了，但这让我学会了授权：第二年，我就让他人负责餐饮谈判。

我们在乔治华盛顿大学成功举办了三次PyCon，之后因为规模增长而更换了场地。

组织第一届PyCon时，注册情况让我们压力很大。我们在python.org和邮件列表上宣传，并设置了早鸟注册截止日期。截止日期前几天，我们只有几十个注册者，而我们已经为大量三明治付了钱。幸运的是，拖延是人之常情。在截止日期最后时刻和会议开始前几天，注册人数激增，会议最终取得了巨大成功。

应对危机与个人感悟

快进到2008年，全球金融危机冲击了所有人，包括PyCon。人们担心工作，软件会议纷纷取消。我们面临艰难抉择：是冒着亏损的风险继续举办，还是取消并损失给酒店的大笔押金？最终，我们决定继续。那一年我们确实亏损了，但幸好PSF一直有谨慎的储备金，帮助我们度过了难关。

我个人也有关于PyCon的压力记忆。有一年，我严重拖延了主题演讲的准备，直到会议开始时仍没有幻灯片。我向一位会议组织者坦白，他找到了Steve Holden帮忙。Steve提出了一个简单的解决方案：进行一场“炉边谈话”。我们在舞台上放了两把舒适的椅子，由Steve采访我。我不需要准备，而Steve可能只需要准备第一个问题。这个形式效果非常好，后来我们还重复使用过。

我至今仍然拖延，这就是为什么我今天最后一个发言。组织会议是我所知压力最大的工作之一。我知道有些组织者因此精疲力尽。虽然现在PyCon员工和PSF员工提供了大量支持，但在早期我们都得自己摸索。我非常敬佩像前主席Emily这样的组织者，她曾在疫情期间做出取消PyCon的艰难决定，也感谢现任主席Mario和她的团队。

本节课中我们一起学习了Python社区早期的成长历程。我们看到了Python会议如何从一个二十多人的小型研讨会，发展成为今天的PyCon。我们也了解了Python软件基金会（PSF）在成立前经历的多次尝试，以及最终如何借鉴Apache的模式成功建立。这段历史告诉我们，成功并非一蹴而就，坚持不懈的尝试和社区成员的共同努力至关重要。

006：主题演讲 - 与Ned Batchelder一起探讨人际互动

概述

在本节课中，我们将学习如何将工程师的思维应用于人际互动。我们将探讨为什么与人沟通有时会充满挑战，以及如何运用一些简单的原则来改善这些互动，使其更顺畅、更有效。核心在于理解，每一次沟通都包含信息和情感两个层面。

开场致辞与社区感谢

感谢马里奥塔。欢迎来到Python世界。我是伊玛，一名软件工程师，在Instagram的前平台团队工作。今天来到这里，帮助大家共同进步。

首先，我想表达我们对成为Python软件基金会（PSF）有远见的赞助商感到自豪。我们也很高兴地宣布，我们已扩大对杰出开发者的支持。特别感谢穆克什。我们很荣幸能为Python社区的成长和发展做出贡献。

Python生态系统对我们至关重要。我们依赖CPython、成千上万的开源库和软件包来驱动Instagram、广泛的AI/ML系统以及众多工具和自动化脚本。我们感谢每一位贡献者：开源维护者、核心开发者和CPython贡献者。我们相信开源驱动创新的力量。我们自己也开源了许多库和框架，欢迎大家在GitHub上查看甚至贡献。

感谢大家的参与。我们迫不及待想听听主讲人的发言。

引入主讲人Ned Batchelder

再次感谢伊玛分享这些信息。

当我被要求选择主题演讲人时，我思考了想邀请谁，想让你们听到谁的声音。我回想起自己刚加入社区时的感受，思考了谁在一直帮助我、我尊敬谁、谁在我的旅程中支持我。我想向你们介绍一位对我影响深远的人。

在我第一次在当地聚会上演讲的前一天，我非常害怕，几乎想取消。我寻求了帮助，所需要的只是一点鼓励。正是那次简单的谈话让我坚持了下来。如果没有那份支持，可能就不会有今天的我。所以，谢谢你。

现在，请大家欢迎Ned Batchelder。

Ned Batchelder的主题演讲：人际互动的“用户指南”

谢谢马里奥塔和PSF的邀请。很荣幸在PyCon诞生20周年之际站在这个舞台上。看到那些老照片，让我想起了PyCon的能量。

在我开始之前，有个问题：大家对PyCon感到兴奋吗？很好。

当我告诉朋友安东尼奥我要做这个演讲时，他提到他参加了2003年的第一届PyCon，并给我发了一张照片。Python最酷的一点是，有些事情二十年来从未改变，但有些事变了。我的第一次PyCon是2007年，当时的主讲人谈论了Python 3.0的计划，他一时忘了“类型注解”这个词，说成了“不是类型的东西，声明”。所以，二十年了，有些事变了，有些没变。

在准备这个演讲时，我思考了自己参与Python社区的多种方式：我的日常工作是在edX，维护着大型开源项目；我维护着coverage.py（那条睡眼惺忪的蛇）；我是波士顿Python聚会的组织者；我写博客很久了；我也活跃在IRC、Slack、Discord等在线社区。

所有这些经历有什么共同点？我决定谈谈“复杂系统中的高不确定性成分”。更简单的说法是：人。

作为工程师，我们常与人互动，但有时我们会像对待技术组件一样对待人，这可能导致互动不顺利。我们可以利用处理复杂技术问题的技能，来改善人际互动。这些常被称为“软技能”或“情商”。

人们有时觉得软技能不那么重要，因为它显得模糊、主观，没有明确的公式。但与人打交道的困难恰恰在于它的“软”和“黏”。如果我们认真对待并做好，人际互动并不可怕。

从工程视角看“人”这个组件

让我们看看一些我们看重的工程品质，以及“人”在这些标准上的表现。

人不标准：每个人都不一样，没有统一规格。
没有文档：认识一个新的人，没有说明书可以参考。
不可预测：人们的行为并不总是线性的。
隐藏状态：就像Python程序中的可变全局变量，人们脑子里在想什么（比如糟糕的早餐、紧的鞋子、对家人的担心）对你来说是隐藏的。
非线性反应：输入一点，可能输出爆炸性的结果。
糟糕的错误信息：当事情出错时，人们可能不会提供清晰的反馈。

你可能会想：既然“人”这个组件这么麻烦，我为什么不选树莓派呢？答案是：你没得选。无论你多内向，都需要与老板、同事、用户打交道。忽略人际互动的这一面，结果往往很糟。如果将其作为一种技能培养，事情会好得多。

况且，人也很棒：

灵活适应：人能完成意想不到的创造性工作。
反射能量：积极的互动能产生正向循环。
是我们做事的原因：你所做的一切，最终都是为了人。

人际互动的核心模型：每条消息都有信息和情感

我不是心理学家，我是工程师。我对人际互动的理解基于自己的经验、调试和复盘。

我认为，每次我向你发送一条信息（无论是说话、邮件还是代码评论），这条信息都由两部分组成：

信息：事实内容。
情感：我对你的感觉。

接收信息的人会不自觉地进行“情感分析”，想知道这条信息是欢迎我（是），还是推开我（否）。这是因为人是社会性、情感性的生物，需要从周围获得反馈来确认自我价值。

如果信息中没有明确的情感，接收者会通过两种方式默认一个：

历史：根据你们过去的互动历史来判断。
相似性：如果你们有相似之处（比如都在PyCon），就更可能是积极的。

如果既无历史也无相似性，默认情感往往是消极的。此外，接收者自身的“隐藏状态”（心情、担忧）也会给信息染上色彩。

伪代码描述这一过程：

def receive_message(sender, message, emotion=None):
    if emotion is None:
        emotion = lookup_history(sender)  # 基于历史判断
    if emotion is None:
        emotion = calculate_similarity(sender)  # 基于相似性判断
    if emotion is None:
        emotion = “否”  # 默认消极
    # 应用接收者自身的隐藏状态（可变全局变量）进行过滤
    emotion = apply_hidden_state(emotion)
    # 记录此次互动，成为未来历史的一部分
    record_history(sender, emotion)
    if emotion == “否”:
        discard_message(message)  # 消极情感下可能忽略信息
    else:
        use_message(message)  # 积极情感下处理信息

这是一个双向过程。你也在对别人进行情感分析。

如何改善沟通：让信息更倾向于“是”

那么，如何提高互动顺利进行的几率呢？以下是五个建议：

上一节我们了解了沟通中的情感维度，本节我们来看看如何主动塑造积极的情感。

1. 说“是”
避免直接否定。用肯定的方式传递正确信息。

反面例子：

新手：如何获取此数组的长度？
助手：这不是数组。
（信息正确，但情感为“否”，新手感到被指责）
正面例子：

新手：如何获取此数组的长度？
助手：该列表的长度可以用 len() 获取。
（提供了正确答案，情感为“是”，新手学到了东西）

2. 多用词语
更多的词语可以提供上下文，软化语气。

反面例子：

我需要帮助。你为什么用 x？
（听起来像在质疑对方的决定）
正面例子：

我在使用 x 时遇到了麻烦。我不确定是不是用法不对。如果你能分享更多关于你如何使用它的上下文，也许我们能找到解决办法。
（表达了困惑和求助的意愿，情感更积极）

3. 注意措辞
使用不确定或开放性的语言，为对话留出空间。

反面例子：

我的程序说 1+2=4，这不对。
（陈述一个封闭的事实）
正面例子：

我的程序说 1+2=4，这听起来不对。
（“听起来”增加了不确定性，邀请对方一起探讨）

4. 保持谦逊
以“我”为主语承担责任，而不是指责对方。

反面例子：

你的问题不清楚。
（指责对方）
正面例子：

我还没完全理解你的问题。
（承担了不理解的责任，鼓励对方进一步解释）

5. 明确表达
使用“三明治反馈法”：正面肯定 + 具体建议 + 正面鼓励。

例子：

我觉得你的项目想法很棒！这部分代码可能有个小问题，我们可以一起看看。总的来说，基础打得非常好！

这听起来像是幼儿园就学过的道理：与人为善，替他人着想。但随着年龄增长，我们更关注技术，忽略了这些。每个人都需要帮助，我们都是试图理解这个混乱世界的人。

技术本身的“怪异”如何影响沟通

我们谈了很多情感，现在让我们谈谈信息本身的技术性难点。

古腾堡发明活字印刷术时，面临许多技术挑战，比如确保每个铅字块高度一致。雕刻师会进行“烟雾测试”（smoke test）来快速检查雕刻效果。这个词沿用至今。

排字工人使用“字盘”（case）工作，大写字母放在上盘（upper case），小写字母放在下盘（lower case）。这就是英文“大小写”（case）的由来。小写字盘的布局符合人体工程学，常用字母在中间。而大写字盘按A-Z排列，但J和U在最后。

为什么J和U在最后？因为在英语中，J和U直到17世纪中叶才被视为独立字母。当它们被加入时，为了保持几个世纪的传统，就被放在了末尾。直到今天，许多印刷店仍沿用此布局。

我想通过这个历史故事让你体验一下作为技术新手的感受：面对大量陌生信息、奇怪的术语（如“烟雾测试”）、看似不合理的设计（J和U在最后）。技术本身会随着时间积累“怪异”，这干扰了我们清晰沟通的能力。

Python也是如此。Lambda关键字可能不易记忆，打包工具可能令人困惑。Python非常成功，这意味着两位Python专家日常使用的术语可能完全不同。例如，你可能熟悉左栏和中栏的词汇，但右栏的词汇呢？

常见Python术语	特定领域术语	你可能不熟悉的术语
List, Dict	ORM, Middleware	PyO3, Mypyc, Pydantic
Function, Class	Async, Decorator	ASGI, Uvicorn, Hypothesis

所有的技术都很“怪异”。我们无法完全消除这种怪异，但需要在沟通中意识到并处理它。

针对不同场景的沟通策略

当有人说“Python很难”时
作为Python爱好者，我们想帮助他。但如果说“不，这很容易”，就是在否定对方的感受。

更好的回应：“一开始可能确实有些难，但我们可以一起让它变得更容易。你具体在哪个部分遇到了困难？”
关键：倾听对方真正的意思——“我在挣扎”，而不是“Python很烂”。

专家也是新手
无论是刚加入Meta面对庞大代码库的新员工，还是需要学习PEP 669新特性的资深开发者，每个人在陌生领域都是初学者。在波士顿Python，我们说：“我们都是初学者，只是有些人练习得更多。”

在快节奏的线上世界
我们被通知淹没。请记住，每个通知背后都是一个人。在急于回复时，可以有意使用一些“软化短语”。我个人甚至设置了键盘宏，快速输入“如果你不介意我问的话，”。

应用“冲刺回顾”到沟通中
就像敏捷开发中的冲刺回顾一样，可以反思你的沟通：

目标：我想通过这次互动实现什么？
评估：进行得怎么样？对方反应如何？
改进：下次怎样可以做得更好？

例如，如果有人说“我的代码很难测试”，回复“你做错了”只会赶走他。反思一下：我的目标是帮助他，我的方法实现目标了吗？下次也许可以说：“测试有时确实棘手。你愿意分享一下代码，我们一起看看有什么办法吗？”

总结与呼吁

本节课中，我们一起学习了如何将工程思维应用于人际沟通。我们探讨了沟通中的信息与情感双重维度，理解了技术本身的“怪异”会给交流带来挑战，并学习了一些改善沟通的具体方法：说“是”、多用词、注意措辞、保持谦逊、明确表达。

归根结底，人很重要。我们与他人的互动至关重要。你可以写出最棒的程序，但如果不能与同事合作、理解用户需求或与上级有效沟通，这些技术的价值将大打折扣。

我的建议与马里奥塔一致：与人交谈。我们来到这里就是为了彼此交流。如果你在走廊看到我，请来和我说话。

最后，分享作家库尔特·冯内古特给儿子的建议。当被问及“我们为什么在这里”时，他的儿子马克回答：“我们在这里就是为了互相帮助，度过难关，不管那难关是什么。”

这就是我给大家的建议：互相帮助，彼此交谈，守望相助。

谢谢大家！

007：欢迎来到 PyCon US 2023 🐍

在本教程中，我们将学习如何参与和充分利用 PyCon US 2023 会议。我们将介绍会议的基本信息、活动安排、社交规则以及重要的健康与安全准则。

概述

本节将概述 PyCon US 2023 会议的基本情况，包括其特殊意义、组织者致辞以及对与会者的欢迎。

大家好，欢迎来到 PyCon US 2023。我们很荣幸在盐湖城举办此次会议。今年我们庆祝 Python 诞生 20 周年，因此计划了许多特别活动来纪念这一时刻。

我本人已多年未参与 PyCon 会议，因此我请求了帮助。我邀请人们分享早期 PyCon 的图标、照片和记忆。感谢所有分享者，我们将这些内容汇编成了一个回顾 Python 二十年历程的视频。我很荣幸在此首次与大家分享这个视频。

会议致谢与欢迎

上一节我们介绍了会议的背景，本节中我们将感谢为会议做出贡献的各方，并对所有与会者表示欢迎。

会议的成功离不开众多志愿者的付出，非常感谢你们。我们也衷心感谢我们的赞助商。尽管今年科技行业面临挑战，但你们依然优先支持 Python 社区，非常感谢。

感谢所有分享知识与专长的演讲者。感谢每一位与会者，无论是亲临现场还是在线参与，这对我们意义重大。你们选择与我们共庆这一特殊时刻，就像一场有两千人参加的20岁生日派对，谢谢你们。

特别欢迎首次参会者。我自己也曾是新手，我的第一次 PyCon 是在2015年的蒙特利尔，当时我默默无闻，多亏了 Python 软件基金会（PSF）的财政援助计划才得以参加。

我从未想过有一天会成为 Python 核心开发者，也从未想过会站在这里欢迎你们。我希望你们也能拥有我在这里找到的机遇和 Python 社区的魔力。你们是社区的一份子，请充分利用这次世界上最大的 Python 会议。希望你们离开时能结识两千位新朋友。

会议活动安排

了解了会议的基本氛围后，我们来看看 PyCon US 2023 的具体活动安排。

会议现已进入第三天。前两天已完成了所有教程和一些峰会。接下来还有许多活动。

在主舞台上，我们将有四位出色的主题演讲嘉宾。James Powell 将在明天发表演讲，Margaret Mitchell 将在周日做闭幕主题演讲，Carol Willing 也将出席。

我们还有几位特别嘉宾。Python 指导委员会 明天将带来关于 Python 的最新动态。我邀请了 Python 的创造者 Guido van Rossum 分享他的 PyCon 回顾。此外，明天指导委员会会议后，我们将举行多样性和包容性小组讨论。Nicholson 将在周日颁发社区服务奖，并提供 Python 软件基金会 的最新消息。

你仍然可以注册 闪电演讲。闪电演讲时长为五分钟，任何人都可以参与，即使是首次参会或从未做过演讲的人。话题几乎可以涉及任何内容。注册台旁边有报名板。进行闪电演讲最酷的一点是，你将站在与我们的主题演讲嘉宾相同的舞台上。

现在，在博览馆，未来三天将提供早餐和午餐。登记处旁边设有咨询台。你也可以前往突击宫、客人服务办公室或失物招领处。如果发现可能属于与会者的物品，请在那里查询。

我们将为所有主题演讲、四人谈、演讲轨道和闪电演讲提供现场字幕。今年的直播也有字幕。请在每个房间寻找字幕屏幕，并坐在该区域以便清晰观看。感谢我们的字幕赞助商。

PyCon US 的走廊轨道是一个独特特色。你还有何时能遇到两千名同样对 Python 充满热情的人？请务必抓住机会与走廊里的人交流。

社交规则：吃豆人规则

为了帮助大家在走廊更好地社交，我们遵循 吃豆人规则。

规则是：当一群人站在一起时，始终为一个人加入你们的小组留出空间。这为新朋友提供了加入的物理空间，是展示包容和欢迎环境的明确方式。

在线互动与健康安全

上一节我们介绍了线下社交，本节我们关注在线互动和至关重要的健康与安全准则。

PyCon US 在推特和 Mastodon 上都有活动。我了解到 Mastodon 的标签是 #PyConUS，现在 Mastodon 上也有一个 PyCon US 群组。如果你在 Chirp 社交网站上提到 PyCon，该账户会自动推广相关内容。关注这个群组，你会看到许多 PyCon US 的内容。

现在我们来谈谈你的健康与安全。在过去一年协助组织会议的过程中，我收到了许多关于是否需要佩戴口罩的询问。

如果你想亲自参加 PyCon US 并与这里出色的 Python 社区互动，我想感谢房间里的每一个人。你们在这里，意味着你们一直在遵循我们的健康与安全指南。你们不仅需要佩戴口罩，而且需要佩戴 N95 或同等规格的口罩。

我昨天听到了与会者的担忧，有人认为我们对这件事不够严格或没有执行。对此我感到抱歉。我们正在认真对待此事。从今天起，我们将开始严格执行。

执行方式如下：如果我或任何工作人员发现您未遵循指南（例如未佩戴口罩，除非在允许的情况下，如在博览会用餐时），我们将扫描您的徽章。这将被记为第一次警告。三次警告后，我们将请您离开。我们可能不会事先警告或通知，也不会有对话、谈判或争论，只会直接扫描您的徽章。

在 PyCon，我们深切致力于为每个人提供安全、积极的体验。为确保这一点，所有工作人员、与会者、演讲者、赞助商和志愿者都必须遵守 行为准则。无人例外。

任何形式的骚扰，无论是言语、身体或歧视性行为，都不会被容忍。这里的每个人都应享有无骚扰的体验，不分性别、外貌、体型、种族、宗教（或无宗教信仰）。

你可以阅读行为准则的完整内容，全文将在会场各处提供，并与事件处理程序和执法政策挂钩。

如果你认为有人违反了 Python 行为准则，无论严重程度如何，都鼓励您随时报告。您可以通过向 report@python.org 发送邮件来提交报告，或者到员工休息室找人协助撰写报告。

个人挑战与总结

既然你已了解 PyCon US，我有个个人挑战给你。

挑战如下：为你自己在 PyCon US 所做的每一件“很酷的事”记一分。我们从周三开始，直到冲刺环节结束。目标是尽可能多地得分。你的奖励是“吹牛的权利”。我知道你在做一件很酷的事，另一个好处是，即使你只做其中一件，也能让另一个人非常开心。

向 Hugo 喊话，他昨天检查说自己已经得了9分。我今天还没检查，但对我自己来说，我想我无意中同意在我夫人在韩国首尔的演讲中做某事。反正，我们看看会怎样。

我知道你现在已经迫不及待想听我们的演讲者了，他很快将再次登上舞台。

我想再次感谢我们的赞助商，我们有远见的赞助商 Meta 来了。

如果你想和我分享几句话，请随时联系。

总结

在本节课中，我们一起学习了如何参与 PyCon US 2023 会议。我们了解了会议的背景与致谢，熟悉了丰富的活动安排，掌握了“吃豆人规则”以更好地社交，明确了必须遵守的健康安全准则和行为准则，并接受了一个有趣的个人挑战。希望你能充分利用这次会议，享受 Python 社区的活力与热情。

008：变量与数据类型

在本节课中，我们将要学习Python编程中最基础的两个概念：变量和数据类型。它们是构建所有程序的基石，就像盖房子需要砖块和水泥一样。理解它们，是开启编程之旅的第一步。

什么是变量？📦

上一节我们提到了变量是编程的基础，本节中我们来看看它的具体定义。你可以把变量想象成一个贴有标签的盒子。这个盒子（变量）可以用来存放数据（比如数字、文字等），而标签（变量名）则帮助我们记住盒子里装的是什么。

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存的是什么类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来实现这些操作。

要查看一个变量的类型，可以使用 type() 函数。

my_variable = 100
print(type(my_variable))  # 输出：<class 'int'>

数据类型之间可以相互转换，以下是三种常见的类型转换操作：

转换为整数：使用 int()。例如，int(3.14) 会得到 3。
转换为浮点数：使用 float()。例如，float(10) 会得到 10.0。
转换为字符串：使用 str()。例如，str(123) 会得到 ‘123’。

动手试一试✍️

理论需要结合实践。让我们通过一个简单的例子，把上面学到的知识串联起来。

# 1. 创建不同类型的变量
score = 95          # 整数
average = 95.5      # 浮点数
course = “Python”   # 字符串

# 2. 打印它们的值和类型
print(“分数：”, score, “， 类型：”, type(score))
print(“平均分：”, average, “， 类型：”, type(average))
print(“课程名：”, course, “， 类型：”, type(course))

# 3. 尝试类型转换
# 将浮点数平均分转换为整数（会舍去小数部分）
int_average = int(average)
print(“整数平均分：”, int_average)

# 将整数分数与字符串课程名拼接
info = “我在” + course + “课程中获得了” + str(score) + “分。”
print(info)

运行这段代码，观察输出结果，体会变量赋值、类型查看和类型转换是如何工作的。

本节课中我们一起学习了Python的变量与数据类型。我们知道了变量是存储数据的容器，并掌握了三种基本数据类型：整数、浮点数和字符串。我们还学会了如何使用 type() 函数查看类型，以及如何使用 int()、float()、str() 函数在类型间进行转换。牢记，为变量选择合适的数据类型，是写出正确、高效程序的关键第一步。

009：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 25，temperature = -10
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 19.99，pi = 3.14159
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存了哪种类型的数据，或者将一种类型转换为另一种类型。Python提供了方便的工具来实现这些操作。

要查看一个变量的数据类型，可以使用 type() 函数。

height = 1.75
print(type(height))  # 输出：<class ‘float’>

数据类型之间可以相互转换，这个过程称为“类型转换”。

以下是三种常见的类型转换函数：

int()：将数据转换为整数。如果是浮点数，会直接去掉小数部分。
```
int(9.9)  # 结果是 9
```
float()：将数据转换为浮点数。
```
float(7)   # 结果是 7.0
```
str()：将数据转换为字符串。
```
str(100)   # 结果是 “100”
```

给变量起个好名字✏️

变量名是盒子的“标签”，一个好的标签应该清晰明了。Python有一些为变量命名的规则和约定。

以下是命名变量时需要遵循的主要规则和建议：

只能包含：字母、数字和下划线 _。
不能以数字开头：1variable 是无效的，variable1 是有效的。
区分大小写：Age 和 age 是两个不同的变量。
建议使用描述性的名字：用 student_name 比用 sn 更好懂。
建议使用小写字母和下划线：这种风格（如 user_age）在Python中很常见。

动手试一试💻

现在，让我们把学到的知识组合起来，写一个简单的程序。这个程序会询问用户的名字和年龄，然后打印一条问候语。

# 获取用户输入，输入的内容会被当作字符串存储
user_name = input(“请输入你的名字：”)
age_str = input(“请输入你的年龄：”)  # 注意：input()得到的是字符串

# 将字符串类型的年龄转换为整数类型，才能进行数学计算
age_int = int(age_str)

# 计算明年年龄
age_next_year = age_int + 1

# 打印结果，用str()确保所有部分都能连接成字符串
print(“你好，” + user_name + “！你明年就” + str(age_next_year) + “岁了。”)

本节课中我们一起学习了Python的变量与数据类型。我们知道了变量是存储数据的容器，认识了整数、浮点数和字符串这三种基本类型，学会了用type()查看类型以及用int(), float(), str()进行类型转换，还了解了给变量命名的规则。记住，变量 = 数据的盒子，而数据类型 = 盒子里东西的种类。掌握这些基础概念，你就能开始用Python表达简单的想法了。

010：谈话 - 阿尔·斯维加特

在本节课中，我们将要学习一段关于Python代码工具发展的谈话内容。这段内容来自阿尔·斯维加特，他分享了对近期Python工具生态变化的观察和思考。我们将整理并解读其中的核心信息，帮助你了解Python社区的发展动态。

概述 🗣️

谈话从一个关于帮助接触航班的场景开始。演讲者（阿尔·斯维加特）在分享近期重要工作时，提到了一个关于“卫星工作航班”的比喻，用以描述Python工具生态的快速迭代。

演讲者为此前的跑题表示歉意。

他继续为能进行这次谈话表示感谢。他原本在谈论近期完成的一些更重要的工作，但在谈话中联想到了自己曾经参与的“卫星工作航班”。这个比喻指的是工具版本回退到1.4，并且几乎完全改变了整个工作流程。目前，社区仍在保持快速的开发节奏和进展。

因此，演讲者必须等待社区的发展速度放缓。之后，工具会达到一个稳定状态。工具达到稳定状态后，用户大约会有两个小时的时间来适应。接着，用户又必须回归到日常的开发工作中。此时，另一件重要的事情发生了：演讲者爱上了一个美丽的陌生人，这个比喻类似于彼得·雷德福的故事。

他在等待这个“陌生人”（可能指代某个新工具或新理念）能够达到成熟阶段。他觉得整个旧的工作流程就像一架人类驾驶的飞机，直到开发者真正理解并接纳了新工具的核心（比喻为“父亲和母亲”），转变才会发生。

随后，新工具迎来了它的“白天”，达到了“山上”的成熟高度。接着，它正式进入了工作流程。演讲者认为，自己也将要进入这个新的工作流程。此后，新工具被反复、大量地应用于各个工作流程中，象征着其被广泛采纳和集成。

这个过程持续进行，新工具不断地被应用到每一个工作环节。

应用过程仍在继续。

工具的应用达到了一个密集的阶段。

随后，工具的应用进入了稳定和重复的周期，标志着它已成为标准流程的一部分。

应用过程持续进行。

最终，工具被完全整合，工作流程达到了新的稳定状态。

工具整合完成。

核心解读 🔍

上一节我们概述了谈话的叙事过程，本节中我们来解读其中的核心比喻和含义。

这段谈话使用了一系列诗意的比喻来描述Python开发工具的演进过程。我们可以将其核心思想总结为以下几点：

以下是谈话中揭示的关键阶段：

快速迭代与破坏性更新：工具生态（“航班”）发展迅猛，版本回退（“回到1.4”）和巨大改变给开发者带来适应压力。
等待与观察：开发者需要等待社区节奏（“人们放慢速度”）放缓，以看清工具的真正价值和稳定状态。
新工具的“诞生”与“成熟”：新工具或理念（“美丽的陌生人”）出现，经历发展期（“到达山上”）后变得成熟可用。
理解与接纳：只有深入理解新工具的设计哲学（“父亲和母亲”），开发者才能完全接纳并实现工作流的转变。
全面集成：新工具被反复、大量地应用到各个场景中，标志着它被社区广泛采纳，并成为新的标准。

这个比喻生动地描绘了开源工具从出现、争议、成熟到最终成为基础设施的过程。

总结 📝

本节课中我们一起学习了阿尔·斯维加特的一段谈话。他通过“卫星工作航班”和“美丽的陌生人”等比喻，形象地描述了Python代码工具生态的快速变化、开发者面临的适应挑战以及新工具最终被广泛集成的工作流程。这段谈话提醒我们，在技术快速演进中，保持耐心、深入理解工具背后的设计思想，是顺利适应变化的关键。

011：如何绕过GIL 🚀

在本节课中，我们将要学习Python并行化中的一个核心挑战——全局解释器锁（GIL），并探讨如何绕过它以实现真正的并行计算。我们将从GIL的基本概念入手，逐步介绍几种实用的并行化策略。

概述

Python因其简洁易用而广受欢迎，但在处理CPU密集型多线程任务时，其性能常受限于全局解释器锁（GIL）。GIL是CPython解释器中的一个机制，它确保同一时刻只有一个线程执行Python字节码。本节课旨在解析GIL的限制，并提供多种绕过GIL、实现Python并行化的方法。

Python并行化：P11-1：理解GIL及其限制 🔒

上一节我们概述了课程目标，本节中我们来看看GIL到底是什么，以及它为何会成为并行计算的瓶颈。

全局解释器锁（GIL）是CPython解释器中的一个互斥锁，它被设计用来保护对Python对象的访问，防止多个线程同时执行Python字节码。其核心作用是简化CPython解释器的实现，并管理内存。

GIL的影响公式可以简化为：
单进程内，多线程无法实现真正的CPU并行计算

GIL的存在意味着，即使在多核CPU上运行多线程Python程序，大多数时候也只有一个核心被用于执行Python代码。这对于I/O密集型任务（如网络请求、文件读写）影响不大，因为线程在等待I/O时会释放GIL。但对于CPU密集型任务（如科学计算、图像处理），GIL会严重限制性能扩展。

Python并行化：P11-2：绕过GIL的主要策略 🛠️

理解了GIL的限制后，本节我们将探讨几种主流的绕过GIL、实现并行化的策略。

以下是几种有效的并行化方案：

使用多进程替代多线程

核心思想：利用multiprocessing库创建多个独立的Python进程。每个进程拥有自己的Python解释器和内存空间，因此也有自己独立的GIL，从而实现多核并行。

代码示例：

from multiprocessing import Pool

def cpu_intensive_task(data):
    # 这里是CPU密集型计算
    return result

if __name__ == '__main__':
    with Pool(processes=4) as pool: # 创建4个进程的池
        results = pool.map(cpu_intensive_task, large_dataset)

使用专为并行计算设计的库
- 核心思想：使用如NumPy、SciPy、Pandas等库的底层函数。这些库的运算核心通常是用C/C++实现的，在执行计算时会释放GIL。
- 代码示例：使用NumPy进行数组运算会自动利用底层优化和并行性。

使用concurrent.futures进程池

核心思想：这是multiprocessing的一个高级接口，提供了更简单的API来执行并行任务。

代码示例：

from concurrent.futures import ProcessPoolExecutor

with ProcessPoolExecutor(max_workers=4) as executor:
    futures = [executor.submit(cpu_intensive_task, item) for item in data_list]
    results = [f.result() for f in futures]

使用Cython或C扩展
- 核心思想：在Cython代码中或自己编写的C扩展中，可以显式地释放GIL，从而允许其他线程运行。
- 代码示例（Cython）：
```
# 在Cython函数中
with nogil:
    # 这里执行不涉及Python对象的C级别操作
    perform_c_operation()
```

使用其他Python实现
- 核心思想：像Jython（基于JVM）或IronPython（基于.NET）这样的Python实现没有GIL。PyPy虽然也有GIL，但其即时编译（JIT）特性可能在某些场景下提供更好的性能。

Python并行化：P11-3：策略选择与最佳实践 📈

上一节我们列举了多种策略，本节中我们来看看如何根据实际场景选择最合适的方法，并了解一些最佳实践。

选择哪种策略取决于你的具体任务类型、开发复杂度和性能需求。

以下是选择策略时需要考虑的关键因素：

任务类型：是CPU密集型（计算为主）还是I/O密集型（等待为主）？
- CPU密集型：优先考虑多进程、专用计算库或C扩展。
- I/O密集型：标准的多线程（threading）通常就足够，因为线程在I/O等待时会释放GIL。
数据共享与通信：
- 多进程间通信（IPC）比多线程间共享内存开销更大。如果需要频繁共享大量数据，需要考虑multiprocessing的Manager、共享内存（Value, Array）或第三方库（如Ray）。
开发与维护成本：
- multiprocessing和concurrent.futures使用相对简单。
- 编写Cython或C扩展性能最高，但开发和调试难度也最大。

最佳实践建议：

先分析瓶颈：使用性能分析工具（如cProfile）确定程序热点。
从高层API开始：优先尝试concurrent.futures或multiprocessing.Pool。
考虑任务粒度：避免创建大量微小的任务，进程/线程创建和通信的开销可能抵消并行收益。
资源管理：使用with语句（上下文管理器）确保进程池或执行器被正确关闭。

总结

本节课中我们一起学习了Python全局解释器锁（GIL）的原理及其对并行计算的限制。我们深入探讨了多种绕过GIL的实用策略，包括使用多进程（multiprocessing）、利用高效的计算库（如NumPy）、使用concurrent.futures高级接口、编写Cython/C扩展以及考虑其他Python实现。

关键在于根据任务性质（CPU密集型 vs I/O密集型）、数据共享需求和开发成本，选择最合适的并行化方案。对于大多数CPU密集型应用，采用多进程模型是平衡效果与复杂度的首选方法。

通过掌握这些方法，你可以有效地突破GIL的限制，让你的Python程序充分利用多核处理器的强大能力。

012：正态分布的陷阱与稳健方法

在本节课中，我们将探讨一个看似正常但可能具有误导性的统计分布，并学习如何使用Python中的稳健统计方法来应对这一挑战。我们将从理解问题开始，逐步介绍解决方案，并通过实际数据演示其应用。

概述

我们常常假设数据服从正态分布，并基于此进行统计分析。然而，现实世界的数据常常偏离这一理想假设。本节课将揭示这种偏离（即“污染”）如何严重影响传统统计检验（如t检验）的结果，并介绍一系列更“稳健”的统计工具来获得更可靠的结论。

第一部分：识别问题——被“污染”的正态分布

上一节我们概述了课程目标，本节中我们来看看核心问题所在：一个看起来正常但实际已被“污染”的分布。

下图展示了一个关键概念：

黄色曲线代表标准的正态分布。
蓝色曲线代表一个被“污染”的分布。它看起来接近正态，但实际上是由主体部分（类似正态）和少量来自另一个不同分布的极端值混合而成。

这种蓝色曲线就是所谓的污染分布。它看起来正常，但本质上包含了不属于主体群体的异常值。这些异常值会导致分布出现轻微的多峰性或厚尾特征。

传统观点认为正态分布是普遍且重要的。然而，在自然界中，纯粹的“正态性”可能并不存在，许多数据都包含这类异常值。因此，完全依赖正态假设的统计方法可能并不稳健。

第二部分：问题的影响与历史视角

上一节我们看到了污染分布的存在，本节中我们来看看它为何成问题，并简单回顾人们对正态分布看法的演变。

如果我从一个被污染的分布（蓝色曲线）中抽样，并与一个纯净的正态分布（黄色曲线）进行比较，使用传统的t检验来检测两组之间的差异，会发生什么？

以下是模拟这一过程的逻辑步骤：

从纯净的正态分布（黄）中抽取一个样本。
从被污染的分布（蓝）中抽取一个样本。
对这两个样本执行t检验，检查是否存在显著差异。
重复此过程多次。

结果表明，在这种污染存在的情况下，t检验发现真实效应的概率（统计功效）可能只有20%左右。这意味着我们很可能无法检测到实际存在的差异，从而导致错误的结论（第二类错误）。

这是一个关于统计功效的生动例子。污染严重降低了我们检测效应的能力。

历史上，人们对正态分布的态度也经历过变化。它曾被视为“上帝的曲线”，是秩序的体现。但随着统计学发展，人们认识到其局限性，特别是在处理小样本或存在偏差的数据时。如今，我们更清楚地知道，虽然正态分布在理论上很方便，但实践中需要更稳健的方法。

第三部分：解决方案——Python中的稳健统计实践

上一节我们讨论了传统方法在污染数据下的失效，本节中我们将使用Python工具来实施稳健的统计方法。

我将使用一个名为 robustats 的Python库（此为示例名称，根据上下文推断）来进行演示。这个库专注于提供稳健的统计估计和检验方法。

首先，我们加载一个真实数据集（例如，一项关于性别态度的研究数据），其中可能包含异常值。

# 示例代码结构：加载数据并进行初步观察
import robustats
import pandas as pd

# 加载数据
data = pd.read_csv(‘attitude_study.csv‘)
print(data.describe())

接下来，我们分别用传统方法和稳健方法比较两组数据（如男性和女性）的差异。

传统t检验：

from scipy import stats
t_stat, p_value_trad = stats.ttest_ind(data[‘male‘], data[‘female‘])
print(f“传统t检验p值： {p_value_trad}“)

结果可能显示p值大于0.05，无法拒绝零假设（即认为两组无差异）。

稳健位置检验（例如，基于中位数或修剪均值的检验）：
```
# 使用robustats库中的稳健检验
robust_result = robustats.location_test(data[‘male‘], data[‘female‘], method=‘trimmed‘)
print(f“稳健检验p值： {robust_result.p_value}“)
print(f“稳健效应量： {robust_result.effect_size}“)
```
稳健方法的结果可能截然不同。它可能仍然无法检测到差异，但它的结论基于更可靠的估计，受异常值影响更小。有时稳健方法的结果会更显著，有时则更保守，这取决于数据的结构。

关键点在于：稳健方法旨在在数据轻微偏离假设（如正态性）时，仍能保持良好的性能。它们不是解决所有问题的银弹，但能提供一层保护。

第四部分：工具演示与模拟平台

上一节我们进行了实际数据分析，本节中我将简要介绍一个用于模拟和教学的工具，它可以帮助你直观理解这些概念。

我开发了一个交互式工具（或Jupyter Notebook），允许你：

自定义生成不同的分布（包括纯净的和被污染的）。
设置样本量、效应大小等参数。
同时运行传统检验（如t检验）和多种稳健检验。
可视化结果，并比较它们的统计功效和第一类错误率控制。

通过这个工具，你可以看到：

当数据完全纯净时，传统t检验表现最优。
当数据存在污染时，许多稳健方法在控制错误率和保持功效方面表现更好。
你可以探索“打破”传统检验需要多少污染量。

这个工具的目的是让复杂的稳健统计概念变得更加可接触和可操作。

总结与最终启示

在本节课中，我们一起学习了：

问题识别：许多真实数据集并不完美服从正态分布，而是包含异常值的“污染分布”。这种污染看似微小，却能极大影响传统统计检验的结论。
影响分析：污染会显著降低统计检验的功效，导致我们无法发现真实存在的效应。
解决方案：稳健统计方法（如基于修剪均值、中位数或M估计量的方法）在对模型假设轻微偏离时更具抵抗力。我们使用Python库演示了如何应用这些方法。
实践工具：通过交互式模拟平台，我们可以直观探索不同条件下各种统计方法的表现。

核心启示是：正态曲线或许并非“糟糕”，但数据并非总是按其预设的方式行为。即使是对正态分布的轻微偏离，也可能对统计分析产生巨大影响。好消息是，稳健统计领域提供了丰富的工具来应对这一挑战。

关键公式/概念强调：

污染分布：数据 = (1 - ε) * 正态分布 + ε * 污染分布，其中ε是一个小比例。
统计功效：当备择假设为真时，正确拒绝零假设的概率。污染会降低功效。
稳健估计：例如修剪均值，在计算平均值前先去除一定比例的最大值和最小值。

最后展示的图片提醒我们重新思考对数据的看法：

（沉默）

013：调和一切 🎤

在本节课中，我们将学习安德鲁·戈德温关于“调和一切”的演讲核心思想。我们将探讨如何通过清晰的结构、有力的论据和有效的表达，将复杂或对立的观点整合成一个连贯、有说服力的整体。

演讲技巧：P13：1：演讲的核心目标 🎯

演讲的核心目标是传递信息并说服听众。为了实现这一目标，演讲者需要将各种元素——包括论点、证据、情感和逻辑——和谐地融合在一起。

上一节我们明确了演讲的目标，本节中我们来看看实现这一目标的具体方法。

演讲技巧：P13：2：构建清晰的结构 🏗️

一个清晰的演讲结构是调和所有内容的基础。它像一张地图，引导听众理解你的思路。

以下是构建演讲结构的三个关键步骤：

开场：吸引注意力，阐明核心主题。
主体：展开核心论点，通常包含2-4个主要分论点，每个分论点由证据和解释支撑。
结尾：总结要点，重申核心信息，并给出有力的结束语。

一个经典的结构公式可以表示为：演讲 = 开场 + (论点1 + 论据1) + (论点2 + 论据2) + ... + 结尾。

演讲技巧：P13：3：整合论点与论据 🔗

仅仅有结构还不够，你需要用有力的内容来填充它。调和一切意味着让你的论点和论据无缝衔接，共同服务于核心主题。

上一节我们搭建了演讲的骨架，本节中我们来看看如何填充血肉。

论据的选择至关重要，它们必须直接支持你的论点。常见的论据类型包括：

数据与事实：提供客观依据。
案例与故事：使内容生动、易于共鸣。
权威引用：借助专家观点增强说服力。

确保每个论据都像拼图一样，精准地嵌入到对应的论点之中。

演讲技巧：P13：4：运用语言与修辞 ✨

语言是调和一切的工具。通过精心选择的词语和修辞手法，你可以强化逻辑，激发情感，让演讲更具感染力。

以下是几种有效的语言调和技巧：

使用过渡词：如“首先”、“然而”、“更重要的是”等，使演讲段落之间流畅连接。
重复核心信息：通过不同的方式重复关键短语或观点，加深听众印象。
运用比喻和类比：将复杂概念与熟悉事物比较，帮助听众理解。

例如，在代码中，一个函数调用可以类比为演讲中的一个论点，而传入的参数就是支撑它的论据：persuade(论点，论据)。

演讲技巧：P13：5：处理矛盾与对立 ⚖️

高水平的演讲常常需要处理看似矛盾的观点或对立的证据。调和这些元素，而不是回避它们，能极大提升演讲的深度和可信度。

你可以通过以下框架来调和矛盾：

承认对立面：表明你了解不同的观点。
提供你的视角：解释为什么你的论点在特定上下文或标准下更合理。
寻求共同基础：指出不同观点之间可能存在的共识，以此作为你论述的起点。

这展示了批判性思维，并使你的最终结论显得更加平衡和深思熟虑。

演讲技巧：P13：6：练习与交付 🚀

所有的调和最终都要通过现场交付来体现。练习是将纸面上的内容转化为生动演讲的关键。

在练习时，请关注以下方面：

节奏与停顿：给听众消化信息的时间。
肢体语言：确保手势、表情与演讲内容一致。
语音语调：通过音量和语调的变化来强调重点。

反复练习直到你对内容了如指掌，这样在台上你就能更专注于与听众的交流，而不是回忆讲稿。

演讲技巧：P13：7：总结与回顾 📝

本节课中我们一起学习了“调和一切”的演讲艺术。

我们首先明确了演讲的核心目标是说服。接着，我们学习了如何通过清晰的结构来搭建框架，并用有力的论点与论据来填充内容。然后，我们探讨了如何运用语言与修辞技巧来增强表达，以及如何高明地处理矛盾来提升演讲深度。最后，我们强调了练习与交付是将所有元素呈现给听众的最终环节。

记住，一次成功的演讲就像指挥一场交响乐，你需要将各个不同的部分——结构、内容、语言和表达——和谐地统一起来，共同演绎出清晰、有力、令人信服的旋律。

014：讲座 - Angana Borah 的思考

在本节课中，我们将学习自然语言处理中公平性与偏见缓解的核心概念。我们将探讨偏见如何产生、如何衡量，以及有哪些方法可以减轻偏见，确保人工智能系统更加公正。

1：引言与背景 🌍

自然语言处理技术正日益融入我们的生活。然而，这些系统可能无意中学习并放大了训练数据中存在的偏见，导致不公平的结果。

上一节我们介绍了课程主题，本节中我们来看看偏见产生的背景。

2：什么是偏见？⚖️

在自然语言处理的语境下，偏见指的是模型对特定社会群体（如基于性别、种族、年龄）产生系统性不公平的预测或表示。

核心的偏见衡量公式可以表示为不同群体间模型性能的差异：

偏见度量 = | 性能(群体A) - 性能(群体B) |

3：偏见的来源 📊

偏见并非凭空产生，它主要来源于训练数据。以下是偏见的主要来源：

数据偏差：训练数据本身未能公平代表现实世界中的多样性。
标注偏差：数据标注者自身的主观看法可能引入偏见。
历史偏差：数据反映了历史上存在的社会不平等现象。
表示偏差：某些群体在数据中的出现频率或描述方式存在偏差。

4：偏见的类型与示例 🧩

偏见可以以多种形式存在。以下是几种常见的偏见类型：

代表性偏见：例如，在职业关联词测试中，“程序员”更可能与“男性”而非“女性”相关联。
评价性偏见：模型可能对描述不同群体的词语赋予不同的情感倾向。
刻板印象：模型可能基于群体身份做出过于简化和不准确的假设。

5：如何衡量偏见？📏

要缓解偏见，首先需要能够量化它。以下是几种常用的偏见衡量方法：

词嵌入关联测试：通过计算词语在向量空间中的距离来衡量关联强度。
情境化词嵌入评估：分析同一个词在不同语境下的含义变化是否因群体而异。
下游任务性能差异：在具体的NLP任务（如分类、生成）中，比较模型对不同群体的表现。

6：偏见缓解策略 🛡️

识别偏见后，下一步是采取措施缓解它。缓解策略可以在机器学习流程的不同阶段实施。

以下是三个主要阶段的缓解策略：

数据层面

对训练数据进行重采样或重新加权，以平衡不同群体的表示。
使用数据增强技术，生成针对 underrepresented 群体的合成数据。

算法层面

在模型的目标函数中添加公平性约束或正则化项。
采用对抗性训练，让模型在完成主任务的同时，无法区分受保护的属性（如性别）。

后处理层面

对训练好的模型输出进行调整，以使其满足预定义的公平性标准。
例如，对分类器的决策阈值进行群体特定的调整。

7：挑战与未来方向 🚀

尽管已有许多研究，但公平性领域仍面临诸多挑战。

未来的研究方向包括开发更鲁棒、可解释的公平性度量标准，以及研究如何在追求公平的同时不显著牺牲模型的核心性能。

8：总结 📝

本节课中我们一起学习了自然语言处理中公平性与偏见缓解的关键知识。我们了解了偏见的定义、来源和类型，学习了如何衡量偏见，并探讨了在数据、算法和后处理阶段缓解偏见的主要策略。构建公平、可信的AI系统是一个持续的过程，需要开发者、研究者和整个社会的共同努力。

015：浏览器中的 CPU

在本节课中，我们将要学习 WebAssembly 的核心概念、工作原理及其在浏览器中的运行机制。我们将探讨二进制格式、运行时环境以及如何将高级语言编译为 WebAssembly 模块。

概述

WebAssembly 是一种为 Web 设计的低级二进制指令格式。它旨在成为高级语言（如 C/C++、Rust）在 Web 上的编译目标，以实现接近原生的性能。本节课程将解析其技术原理。

WebAssembly 揭秘：P15-1：二进制格式与核心概念

让我们探讨 WebAssembly 的基础。WebAssembly 的核心是一种二进制格式，它可能是实现高性能 Web 应用的最佳方式。

具体细节是什么？这可以视为一个存在已久的问题。WebAssembly 本质上是对低级计算问题的一种解决方案。它是一种具有特定属性的二进制格式。

在二进制领域中，存在数百种不同的状态。实际上，你可以运行成千上万个无法直接通过 JavaScript 触及的示例。你可以获得三种无法在传统 Web 中找到的优势。浏览器没有其他方式能提供这种能力。这就是我们讨论 WebAssembly 的原因。

WebAssembly 是一个不同的范式，因此开发社区将能够发掘其潜力。所有现代浏览器都支持 WebAssembly 格式。当我们在开发道路上时，我们将能够找到一种新的“书写”代码的方式，这将带来许多新的可能性。

还有其他独立的运行时环境，它们可以替代浏览器运行。运行时环境有很多种。在 Web 环境中，运行时就是浏览器的样子。实际上，WebAssembly 的意义更在于扩展 Web 的能力边界。能实现的内容会更多。

这在项目成功的初期很重要，原因在于你可以理解其设计原理。它的实现是完整的。你可以看到这是因为有限组件的成本是运行时的一部分。我们可以在后续版本中实现更多功能。

现在，坦白地说。我们不一定准备好将任何事情都视为 WebAssembly 的直接产物。但如果你想理解它，可以认为它的抽象层级稍低一些。你可以使用工具链和不同的公式，以更易读的方式工作。

所有的 WebAssembly 模块都简称为 Wasm。令人惊讶的是，我们能够使用两样东西。WebAssembly 对 Wasm 和宿主环境（如浏览器）是相同的。WebAssembly 有两个主要输出：模块和实例。还有一个是在 WebAssembly 系统接口层面。

我不会深入探讨同事间的交流细节。但如果你在这里应用它的方式，你能看到的是，代码会进入这种二进制格式。还有另一个概念：编排。编排就是你能做的事情。它已经与我们能管理的网络资源建立了联系。

然后你可以编写你能做的事情。你在进行语言层面的工作，而它们被编译成字节码，让你不处于解释执行的劣势。这就是为什么你可以开始更多地了解这门语言。这不过是一种避免过于依赖解释执行的方式。

WebAssembly 揭秘：P15-2：编译与执行模型

上一节我们介绍了二进制格式，本节中我们来看看 WebAssembly 的编译与执行模型。

我们看到了响应式编程的规则及其意义。就像艺术创作一样，最有价值的表达方式是尝试进入其核心机制。你可以将其视为一个单一实体，这与为少数人使用的东西有些不同，而且可能不止于此。这是一件非常重要的事情。

我们可以了解更多，但这取决于我们如何称呼它。在代码中，我们需要运行以加载标准二进制文件，获取值并仅从中运行。我不会讨论其视觉呈现问题。重要的是我们是表达者。二进制代码是编译器需要生成的内容。这是之前由 C/C++ 等语言编译的。

然后我们关联随机模型，得到一些可以从两者出发的东西。所以在这里我们发现，我们可以计算逻辑代码和两者的功能。然后它可以驱动小型任务。我们可以做到这一点。一个更好的例子是在编译器从底层汇编运行之前。但是，这没问题。

同样，它可以运行在本地运行时中。我们进入了 Go 语言环境。如果你有一个运行时，你可以使用之前相同的二进制代码并从 Python 中运行。通常的步行时间，这是许多不同方式之一。这不会让你提前结束。不仅仅是同样的。

但我们可以看到我们有一个非常大的能力，我们可以看到我们可以运行二进制文件。我们可以运作，我们可以测试其中一部分。我的意思是，我想让我非常清楚：你不是在浏览器中直接运行 Python 解释器。我不能让 Python 解释器持续运行。我们必须进行一次性运行。

因为在一次性运行中，没有任何持久状态会工作。但我们可以让它向前推进，抓住正在进行的事情。你可以向下深入。你可以做的是理解为什么每个人都可以进行一次性运行。你也可以做的事情是，包含所有的依赖，进行 50/50 的混合运行。

并使计划者完成指令，仅此而已。默认情况下，你可以让你的任何东西变得更好。以这样的方式完成，你没有问题要问。你可以做任何其他事情。你可以做任何不同的事情。你甚至没有笨拙的事情或计时器。这就是为什么来这里运行是安全的原因。

但这让我思考了很久，因为我们怎么能在这个技术领域转变，以及那里的技术隔离是如此简单。所以，当我声明同样是二进制时，我甚至无法关注家庭细节。我甚至不能声明这是重要功能和程序意图。

输入由主机环境提供。在样本默认设置中，模板在这里。主机是操作系统，和 Web 友好环境。在样本中，有一个用于 Web 友好的 Python 示例。在重要功能中，我由主机提供。最后，有一整块可以处理系统交互。

如果这些人是其中之一。在这个例子中，我们看到如何对世界上发生的事情达成一致。你认为会有什么样的世界？如果你支付家庭以达成共识，你可以来自他们的省份。但是如果你继续前进，第一世界，如果你继续前进，你就无法与第一世界达成一致。

当我们无法达成一致时，我们需要提供一种实现功能的方法。如果我编译它，你知道我即将节省大量时间。你可以看到我们可以尝试那个更创新的方法。现在我不是母亲，为了继续要搁置那件事。我们需要提供来自环境的关键。然后如果我尝试运行它。

我现在不会通过浏览器运行，但你可以在我们所有人中观看。知道这一点。所以如果代码更好，最好在手机上进行。我希望能够达到你可以是二进制的程度。你会看到这不是关键部分，我提供了我们需要的这个功能的重要环境。

我们正在创造我们所拥有的东西。然后做我们想做的事情可能是一件好事。所以我会多放一点进去。因此，我们这里的事情比我们现在要做的要困难得多。当事实上，它是。我失去了计算机的安装。我们想要知道的另一件事是，它可能会更有趣。

硬件信息将会被解释。我们想要记住的另一件事是，驱动程序将会遇到其他事情。我们想做的另一件事是，运行时可以解码并尝试模块化它。我们刚刚遇到了性能问题，因为，你知道，当你处理性能时。

从驱动程序的视角来看，有机会联系你、运行并与模型对话。所以，客户不会认为他必须处理性能问题，所以这不是一个重点。我们应该去做，我不知道我想要进行多长时间。然后，我无法通过这种方式在内存中产生偏差。

然后，我必须说一些将要成为性能瓶颈的东西。然后将它们带到性能优化两年。但它们将妨碍从内存中获取视觉主体，直到我找到正确类型的问题，它就是零。我将把它们带到性能优化。因此，我能够从我的性能优化中拿起球，最后我喜欢这个团队。

WebAssembly 揭秘：P15-3：内存管理与系统交互

上一节讨论了执行模型，本节我们将深入了解 WebAssembly 的内存管理与系统交互。

在驱动程序那里，我有一封清晰的信给第 12 个价格，以及在客户头上的一张便条，正好在那一刻。是的。就是这样。然后，在同样的结果中，我们上次在我之前提到的模块中做了同样的事情。

在这种情况下，一旦事情再次发生，我觉得那是记忆。这一个可以是一些可以来到我们的性能优化并提供很长时间的东西。在发生器中，我可以读取内存，数字的值。那是事情的关键值，然后从底部到顶部，然后它可以是其中的几个。然后最终它可以是的。所以给我一个关键。这个关键在游戏中有时是一个关键值。

在你如何尝试不花钱的视角中，这意味着什么？这又意味着什么呢？提供功能后，这将是你的方式。

有一件事很好，但也很好，我觉得这很好，因为我觉得这很好。但我认为这非常重要，这很好，这是在之前提供的功能。打开你的文件，打开你的文件，把它写入定价，放在纸上。你可以做的是选择热。因为我正在从市场中拿走钱包。

我决定钱包在同一范围内打开。是什么推动了相同的范围。什么购买了组。如果我是作者，我可以把一个钱包扔进钱包里。我可以把它送到市场，钱包可以存储在相同的价格中。或者我可以实现一个完全美丽的位置。

这就是美元发生的事情，我说的就是，口袋里的美元。当你处于高点时，你会有美好的事物。你可以使用不同的定价库，并将它们导入。然后你可以进入功能，选择打开，文件，然后。

在稍后的时间里，你知道，我喜欢在法庭上，出于假设。这通常是你可以在世界某处找到任何可以和你一起做这件事的人。但我不想在我的世界中每次都做所有的工程，因为我正在以新的方式进行。系统内的正常功能，所以我进入应用程序。这通常是。

任何与功能有关的事情，我知道，我进入了其中的某些内容。还有其他的事情可以用这种方式来做。这种系统的实践，涉及到总销售和食品链，围绕议程建立，我认为这是一个很好的部分。你可以像这样思考。

一次在环境中，身体并不只是我们清洁的部分，而不仅仅是交通。因此这是对完整政策和事情的终结。在一种你可以完全参与议程的方式下。如果你仍然是合伙公司，而你仍然是合伙公司，你知道。你开始于政府中所发生的事情，而你并不谈论它。这是件好事。

你可以随时做到这一点，我认为你可以变得脆弱一些。但你可以始终做到这一点。你可以在主要目标上发言。这主要是在政府的新目标背景下，这可以运行。曾经在政府中，那时候没有秩序，但我认为在其他情况下并没有有效。

这大致上是在第二部分。而另一种选择是在底部，基本上是一种可以与标准一起使用的库，随着时间和角度的变化。因此你可以应用到你要去的地方。网络，组织的支持，尽管还有很多关于它的事情。

顺便说一下，涉及运行时的内容实际上是由主体组成的。对于任何运行时，这正是你需要做的，在主体内部。而且这种情况非常少见。底部的同类问题，可能也是同样的问题，这非常简单。但考虑到所有事情，通常并不是那么糟糕。

人们在想与浏览器交互并运行时会使用它，你也能理解。在美国，这正是我们支持的原因。因此我们称之为组织。但请记住，你也可以来到图书馆并在里面运行它。

这并不是你需要参与的事情。这是一个很好地思考我们今天所做事情的方法。我对你说的是，我们支持你并为你提供组织的帮助，并且达到不同的层次。这并不是为了大的呼叫，但这是一个产生变化的好方法。你为什么要包含它？我们无法接触到一个组织，因此你可以决定哪种类型的代码。

你如何做出决定。然后，这只是系统的类型，你知道，涉及到网络或国家。我说的并不是你选择的事情。在互联网中，有很多类型的人被发现，这样更容易了解。所以我说设计就在那儿，而且只是小问题。

小型产品。所以我们尝试做的是可能有用的最小事情。这可能在某种方式上被传播得非常美好。因此它可以被放入这个世界。而现在在这里上面，还有其他新功能，可以在土地的设计中使用，能够在世界上使用，并以某种形式引入。

但我认为我们必须考虑的是我该如何管理土地。这样如果当前情况是家庭为世界人民所做的事情，新的功能将使其成为土地或土地的更好比较目标。因此，例如，你可以想象发生了什么例外情况。

并且支持其他收藏者及其他人。因为这个名字是个好例子。如果其他人悬而未决，我将永远不知道这个家庭是什么。我把它放入我们寻求保护国家内部自由的方式。这个国家，这个国家，这个国家。

我可以想象从底部向上升起的印象，触碰 Python 或其他任何保护个人的语言。然后你得到一点点“我们看到了，所以这非常好。”我们将能够保护这个人，其他人可能会感激，那么我们在土地上可能会遇到问题。

以及这个国家的语言，还有其他人。所以它将为大多数国际人口处理这个国家的技术。我们还没有达到那里，但我们还没有见到世界人民。并且我知道我们还没到那里，但我们将看到这个国家。现在。

有一只狗在大楼里为 Python 制定政策。我们可以站在 Python 的背景下，看看我之前做过的事情。我有 Python，并且在考虑我所有的方式，我可以运行我所能做的所有事情。对每个想要跑的人来说，这太美好了。

因为我们可以运行文章，我们必须让他们开心。然后将它们插入我的应用程序和我的绘图中，这样我们可以让他们开心。我们将能够记录不从这个社区购买的其他方式。可能会涉及一些 Python，但它是个人编译给另外两个家庭的。

所以你可以拿六百块，然后你可以买两个。然后跑进 Python 的建筑中，然后你可以买两个。接着你可以买两个。然后你可以做我们所做的事情，我们所思考的事情。我们谈论围绕我们的 Python，而 Python 库是我们试图建立的建筑的一部分。

如果你是一个 Python 开发者，你可以买两个，然后你可以看到它。然后你可以买两个，然后你可以买两个。最后你可以再买两个。然后你可以买一个指南，叫做个性。在其他领域之上。在一个指南上你有五个领域。你还可以更深入五倍，这是另一个 Python 的实现。叫做 Python。你可以买两个，这稍微多一点。在过去，是一千英尺，在过去。你可以用一点光。

这稍微多一点关于世界将要享受的事情，而且会相当多。是的，我认为它被称为，我们在那儿推出的新服务。我正在做的事情将非常非常简单地推动并且也部署五英尺的教育到世界。顺便说一下，你可以看到，在其生活中，安装会有多困难。通过玩它的一个层面。我知道这个世界能买到什么。我不知道为什么它在身体里很好。如果我能部署它，那就是最后。只是多一点。还有更多关于五个领域的讨论。还有。其中两个在过去。但幸运的是，我们买了视频，所以你可以写下来。看看他们。大约两个小时前，我在听两个，五周的病人。我觉得非常，非常好。老师对发生的事情非常兴奋，当力量超过目标时非常好。我的目标是在这个领域赋予他力量。我认为我也在引导这个会议。好吧。我认为重要的是要说，我认为我会谈论这个会议。然后你有一个非常好的会议。然后，刚好在我问公众讨论之后。我认为过去一年发生的事情，是在来到商店之后，所以我建议。关于主题，什么，来听演讲。顺便说一下，像。可能只是，演讲要持续多久。充满生机，你知道。我们将不得不通过一千来运行，我，我觉得这是一个好主意。

这就像我们曾经是的，所以如果你想看看这真的有多好。

一次。一次。一次。一次。一次。一次。一次。一次。然后有那个，在两者之间，目标，你可以，你可以。我会谈谈它。因为效果很好。我们也有一个真正的策略，针对一种爱好型学生。这并不是，你可以了解动物是否为跑步工作。获取身体的好方法是识别所谓的我们，做得很好，选择跑步。我是说，这通常是好的。这是你想做的时间。你可以展示一个珍贵的骨骼。因此，在这种情况下，我要进入桶阶段，然后我们去 DNA。我想我完成了，所以我会看到五年的范围来回答一些问题。

这些是关于公司的比率的一些方式。它也可以是源代码。这些就像你希望的公司形式的大小。老实说，穿起来并不好。我觉得你希望在盘子上有一些大的东西。我也喜欢把总数放入我的某个问题中。

我认为这就是我如此热衷于此的原因。

总结

本节课中我们一起学习了 WebAssembly 的核心概念。我们探讨了其作为低级二进制格式的本质，了解了它如何通过编译高级语言来获得接近原生的性能。我们分析了其编译与执行模型，看到了代码如何从源语言转换为 Wasm 模块并在浏览器或独立运行时中执行。最后，我们触及了内存管理和与宿主系统交互的复杂性。WebAssembly 为 Web 带来了强大的计算能力，是开发现代高性能 Web 应用的重要工具。

016：慢网络上的跨服务器数据连接 📡

在本节课中，我们将学习如何在网络速度较慢的环境下，高效地连接和处理分布在多个服务器上的数据。我们将探讨数据连接的核心概念，并通过具体的策略和代码示例，帮助你理解如何优化数据传输和处理流程。

概述

随着远程工作和分布式系统的普及，我们经常需要处理位于不同服务器上的数据。在网络带宽有限或延迟较高的情况下，传统的直接连接方法效率低下。本节课将介绍一种策略，通过将“小数据”移动到“大数据”所在的位置，来优化跨服务器数据连接的性能。

P16：1：数据连接的历史背景与挑战 🕰️

我想先谈谈我与数据的关系，以及我所经历的工作。我将从这十年开始。我会谈谈我所称之为错误数据的东西。

在接下来的时代，我将把它带到过去的一两年。显然，我们一直在讨论数据。我们并不在数据科学的工作中，但我们非常重要。我将与朋友们谈谈，这将是非常有帮助的。我会非常二元化。我会花时间在数据上，直到明天，即使那非常微小。

我将点击检查。这将会有点不同，而且将会有些相同。

而且，这会很好。我发现知道这一点是如此简单。这是我们过去没有被允许的情况。那曾经是非常重要的。这让我们思考如何使用数据。你可以真正知道如何下载这首歌。你可以找到你将会看到的地方。你可以随意阅读。

但是你不想下载那首歌。你可以说，你知道，你可以分享，你知道，媒体。新的东西，以及你想要说的事情。从下载中获取。这真的很重要。那时的网站也有一些文档。因此看看吧。这会很棒。那么这里还能做一点更多的事情。

我想学习它。这很有趣。就像这个词“时代”。和这个词“时代”，这个词。那个词，那个词。很有趣。然后你在跟一个副本谈话，或者其他什么的。你可以去检查同一记录。然后你只是需要加载。然后你总是很好。然后你在考虑在一起。

不管我是否在考虑这件事。这是你生活中一个非常重要的部分。即便如此，你将会因为它而消亡。你会变得非常酷。你会变得真的很酷。你会变得酷。好吧。所以这十年是升级到 DSL，电缆模式。速度更快了。这已经好很多了。这个网站非常适合你使用。

他们有很好的时间去理解它，但他们并没有负担太重。他们会申请工作，所有这些。但比工业还要好。你知道，你想做的是获取大量带宽。你可以看看它的等级。你可以得到一点数据。这非常不错。它被称为安全小组。

我在课堂上见过的。这是一个非常棒的游戏。但他们确实想看看，这是可能的。背景真的很不同。我们正在看一个早期的会议。我们可以处理 3200，4200 个视频。我们有一台单反相机，一台 2300，一台 4500，一台 4500。

这就是我认为这是一个好选择的原因。不幸的是，出售它是相当冒险的。现在我们回到了早期的环境，所以叫做停止播放的环境。因此，我们不会做项目，但我们已经开始在家工作。我们会以非常好的方式来做这个。背景，对孩子们来说也是如此。

我们正在改变这些数字。我们会关注其中的一些。因此，我们将进行带宽测试，这变得更加有效。还有我们所有的视频通话。我们将开始在家工作。家里有些人正在解决视频问题。所以我开始了。

我开始构建这个。第一件事是，也许我们的后端接口是我们想做的事情。

上一节我们回顾了数据连接的历史背景和早期挑战。本节中，我们来看看网络环境变化带来的新问题。

P16：2：现代网络环境下的延迟挑战 ⏱️

在此期间，视频变得更加重要。延迟变得更加重要。延迟变得更加重要。延迟变得更加重要。延迟变得更加重要。延迟变得更加家庭网络解决。尽可能好，我们将能够快速给他们看一看。

我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。我们能够在一分钟内完成这个。

我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。我们将能够在一分钟内搞定。

我们将能够在一分钟内搞定。所以我叫伯特·瓦格纳。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。

我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。

因此，我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。我将能够在一分钟内搞定。

我会在一分钟内完成。我会在一分钟内完成。我会在一分钟内完成。我会在一分钟内完成。我会在一分钟内完成。我会在一分钟内完成。我会在一分钟内完成。我会在一分钟内完成。

我会在一分钟内完成。我喜欢这样。我会随时联网。所以，我在谈论把它移开。所以，让我们进入视频的第一部分。这实际上是我最喜欢的解决方案。这是你想要交流的方式。

了解了延迟的重要性后，接下来我们探讨具体的解决方案。核心思想是优化数据传输路径。

P16：3：核心解决方案：移动计算而非数据 🚚

所以，我们对这些的看法是，我们获取我们的 PSB 文件，数据，某些数据。

然后我们移除那个过程。这就是为什么我们处理的是一小块数据。让我们把这个数据用于这个文件。或者更大的数据所在的地方。这被称为将你的小数据移动到更大数据的地方。因此，也许这意味着我们将像一个三维表格。这是因为数据库的原因。

这就是我们要做的。我们将使用一个临时和内存表。这取决于你。你将能够做到这一点。

核心公式：
处理速度 ∝ 1 / 网络传输数据量

换句话说，为了加快处理速度，我们应该尽量减少需要在慢速网络上传输的数据量。策略是将较小的数据集移动到拥有大型数据集的服务器上进行连接操作，而不是反过来。

以下是实现这一策略的关键步骤：

识别数据大小：确定哪个数据集较小（“小数据”），哪个数据集较大（“大数据”）。
建立远程连接：从“小数据”所在的服务器，建立到“大数据”所在服务器的连接。
传输小数据：将较小的数据集整体传输到大数据所在的服务器。
在本地执行连接：在大数据所在的服务器上，使用临时表或内存表存放小数据，然后执行数据连接（JOIN）操作。
返回结果：将连接后的结果集返回给请求方。

上一节介绍了“移动计算而非数据”的核心思想。本节中，我们来看看如何用 Python 代码实现这一策略。

P16：4：Python 实现示例 🐍

假设我们有两台服务器：Server_A 存有小表 small_table，Server_B 存有大表 large_table。我们需要根据某个键（例如 id）连接它们。

以下是一个使用 pandas 和 SQLAlchemy 的简化示例：

import pandas as pd
from sqlalchemy import create_engine

# 1. 从 Server_A 读取小数据
engine_a = create_engine('postgresql://user:pass@server_a:5432/db_a')
small_df = pd.read_sql('SELECT * FROM small_table', engine_a)

# 2. 连接到 Server_B
engine_b = create_engine('postgresql://user:pass@server_b:5432/db_b')

# 3. 将小数据作为临时表上传到 Server_B
# 方法一：使用 pandas 的 to_sql 创建临时表（注意：某些数据库需手动管理临时表生命周期）
small_df.to_sql('temp_small_table', engine_b, if_exists='replace', index=False)

# 4. 在 Server_B 上执行连接查询
query = """
SELECT l.*, s.*
FROM large_table l
JOIN temp_small_table s ON l.id = s.id
"""
result_df = pd.read_sql(query, engine_b)

# 5. （可选）清理 Server_B 上的临时表
with engine_b.connect() as conn:
    conn.execute("DROP TABLE IF EXISTS temp_small_table")

print(result_df.head())

代码说明：

我们首先从源服务器（Server_A）提取整个小数据集到本地内存（small_df）。
然后，我们将这个小数据集（small_df）作为一张临时表（temp_small_table）推送到目标服务器（Server_B）。
最后，在 Server_B 上执行一个本地的高效 JOIN 查询，只将最终的结果集通过网络传回。

这种方法显著减少了网络传输的数据量，因为只传输了一次小数据集和最终的结果集，避免了大表的多次或全部传输。

了解了基本实现后，我们还需要考虑一些优化和注意事项。

P16：5：优化策略与注意事项 ⚙️

然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。

然后你可以完成你的工作。然后你可以完成你的工作。然后你可以做正确类型的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。

然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。然后你可以完成你的工作。

然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。

然后你可以做你的工作。然后你可以做你的工作。（听不清）。这个国家不擅长的一件事是，在你做你的工作之前，你需要带来的前期数据实际上是同样的事情。然后你们都和教会交谈。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。

然后你可以做你的工作。然后你可以做你的工作。然后你可以做你的工作。然后这里的缺点显然更深入这个部分，以达到重点。然后你可以把它放在这一点上。然后你可以把它放在这一点上。然后你可以把它放在这一点上。然后你可以做到这一点。

然后你可以做到这一点。然后你可以做到这一点。然后你可以做到这一点。然后你可以做到这一点。然后你可以做到这一点。然后你可以做到这一点。然后你可以做到这一点。然后你可以做到这一点。

然后你可以在这一点上做到。然后你可以在这一点上做到。然后你可以在这一点上做到。然后你可以在这一点上做到。然后你可以在这一点上做到。然后你可以在这一点上做到。然后你可以在这一点上做到。然后你可以在这一点上做到。

然后你可以在这一点上做到。然后你可以在这一点上做到。所以。我构建了一个存储帽。我正在寻找我们现在拥有的另一个。我被称为跨线程。所以，我们可以安装这个。实际上，我们可以安装这个。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。

然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。然后我们可以只在这一点上安装它。

然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。

然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。但是我们可以在那个点上做到这一点。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。然后我们可以直接在那个点上安装它。

然后我们可以直接在那个点上安装它。

在实施上述方案时，需要注意以下几点以进行优化：

数据量评估：确保“小数据”确实足够小，能够被高效传输。如果小数据也很大，则需要考虑分块传输或使用其他策略。
索引利用：在目标服务器的大表连接键上建立索引，可以极大提升 JOIN 操作的速度。
临时表管理：使用数据库真正的临时表功能（如 CREATE TEMP TABLE），它们通常在会话结束后自动清理，且可能只在内存中处理。
连接池与超时：配置好数据库连接池，并设置合理的查询超时时间，防止慢查询占用过多资源。
错误处理与重试：网络操作容易失败，代码中应包含健壮的错误处理和重试机制。
替代方案：对于更复杂的场景，可以考虑使用专门的分布式数据处理框架，如 Apache Spark，它内置了优化过的跨节点数据移动策略。

总结

本节课中，我们一起学习了在慢速网络环境下进行跨服务器数据连接的高效方法。

我们首先回顾了数据连接面临的网络延迟挑战，然后深入探讨了“移动计算而非数据”的核心策略。该策略通过将较小的数据集传输到拥有大型数据集的服务器上进行本地连接，显著减少了网络传输的数据量，从而提升了整体处理效率。

我们通过 Python 代码示例演示了如何利用 pandas 和 SQLAlchemy 实现这一过程，并讨论了索引优化、临时表管理等重要的注意事项。

掌握这种方法，能帮助你在分布式系统或远程工作场景中，更加游刃有余地处理跨源数据连接任务。

017：将生活融入你的代码库 🧩

在本节课中，我们将学习如何通过插件架构来构建灵活、可扩展的Python应用程序。我们将从一个生活化的类比开始，逐步深入到插件的核心概念、工作原理以及如何在实际项目中实现它们。

概述

软件的现实是，需求会不断变化，用户也会变化。为了应对这种变化，我们需要构建能够灵活适应新功能的系统。插件架构就是一种强大的设计模式，它允许我们在不修改核心代码的情况下，为程序添加新功能。本节课将解释什么是插件，为什么需要它们，并通过一个简单的例子展示如何实现。

1：程序与插件：一个咖啡店的类比 ☕

在深入技术细节之前，让我们用一个类比来理解程序和插件的关系。

想象一个咖啡店。这个咖啡店的核心是制作咖啡。它拥有电源、水源和咖啡豆。这就像是我们的主程序，它提供了基础功能。

现在，假设我们想增加制作冰沙或茶的功能。我们不需要重建整个咖啡店，只需要引入一台新的机器（比如冰沙机或茶壶）。这台新机器可以“插入”到咖啡店现有的电源和水源系统中。这台新机器就是一个插件。

咖啡店（主程序）：提供基础环境（电力、水）和核心服务（制作咖啡）。
冰沙机（插件）：扩展了咖啡店的功能，使其能制作冰沙。
连接点（插件接口）：电源插座和水管接口，允许新机器接入系统。

这个类比说明了插件如何让一个程序在不改变其核心结构的情况下，获得新的能力。

2：理解插件架构的核心概念 ⚙️

上一节我们通过咖啡店了解了插件的概念。本节中，我们来看看插件架构中的几个核心技术概念。

一个插件系统通常包含以下部分：

主机程序：这是应用程序的核心框架。它定义了插件可以接入的接口和规则。
插件：独立的代码模块，用于实现特定的扩展功能。
钩子：主机程序暴露的特定点，插件可以在这些点上“挂接”自己的代码来执行操作。
插件管理器：负责发现、加载、注册和管理所有插件的组件。

它们的关系可以用一个简单的公式表示：
主机程序 + 插件管理器 + (插件1 + 插件2 + …) = 可扩展的应用程序

以下是插件架构的一个工作流程：

主机程序启动，并初始化插件管理器。
插件管理器在指定目录中搜索并发现可用的插件。
插件管理器加载插件，并将插件注册到主机程序的相应钩子上。
当程序运行到某个钩子时，所有注册到该钩子的插件代码都会被依次执行。

3：如何实现一个简单的Python插件 🔧

现在，我们来看一个具体的Python实现例子。我们将创建一个非常简单的插件系统。

首先，我们需要定义主机程序。它包含一个插件管理器和一个简单的钩子。

# host_program.py
class PluginManager:
    def __init__(self):
        self.hooks = {}  # 存储钩子及其对应的插件函数列表

    def register_hook(self, hook_name, plugin_function):
        """将插件函数注册到指定的钩子上"""
        if hook_name not in self.hooks:
            self.hooks[hook_name] = []
        self.hooks[hook_name].append(plugin_function)

    def execute_hook(self, hook_name, *args, **kwargs):
        """执行某个钩子上的所有插件函数"""
        if hook_name in self.hooks:
            for func in self.hooks[hook_name]:
                func(*args, **kwargs)

# 创建一个全局插件管理器实例
plugin_manager = PluginManager()

# 定义一个名为 `greet` 的钩子
def main_program():
    print("主机程序开始运行...")
    # 执行 `greet` 钩子，所有注册到此的插件都会响应
    plugin_manager.execute_hook('greet', user="开发者")
    print("主机程序运行结束。")

if __name__ == "__main__":
    main_program()

接下来，我们创建一个插件。插件就是一个普通的Python模块，它需要在加载时向主机程序注册自己。

# my_plugin.py
from host_program import plugin_manager

def say_hello(user):
    print(f"[插件] 你好，{user}！")

# 当这个模块被导入时，自动将函数注册到 ‘greet’ 钩子
plugin_manager.register_hook('greet', say_hello)

最后，我们需要修改主机程序的启动部分，让它自动发现并加载我们的插件。

# 修改后的 host_program.py 顶部
import importlib
import pkgutil
import os

class PluginManager:
    # ... (同上) ...

    def discover_and_load_plugins(self, plugin_directory):
        """发现并加载指定目录下的所有插件模块"""
        for finder, name, ispkg in pkgutil.iter_modules([plugin_directory]):
            # 动态导入插件模块
            full_name = f"plugins.{name}"  # 假设插件在‘plugins’包内
            importlib.import_module(full_name)
            print(f"已加载插件：{name}")

# 在 main_program 函数开始处添加
plugin_manager.discover_and_load_plugins(‘./plugins’)

将 my_plugin.py 文件放在 ./plugins 目录下。现在运行 host_program.py，你会看到插件被加载并执行。

4：真实世界的例子与环境管理 🌍

我们刚刚构建了一个简单的插件系统。在现实世界的复杂项目中，插件架构常用于构建开发工具和平台。一个典型的例子是环境管理工具（如 virtualenv, conda, pipenv）。

这些工具本身是一个主机程序，其核心功能是创建和管理独立的Python环境。而像 pip（包安装器）、flake8（代码检查器）这样的功能，可以被视为插件或与主程序深度集成的工具链。

它们共同工作：

环境管理器（主机） 创建了一个隔离的工作空间。
包管理器（插件/工具） 在该工作空间中安装依赖。
代码检查器（插件/工具） 对该工作空间中的代码进行质量检查。

这种架构允许开发者根据项目需求，灵活组合不同的工具，而不需要环境管理器本身实现所有功能。这正体现了插件“将生活（各种需求）融入代码库”的思想。

总结

在本节课中，我们一起学习了Python插件开发的核心思想。

我们从类比开始，理解了插件如何像咖啡店里的新机器一样扩展程序功能。
然后我们剖析了核心概念，包括主机程序、插件、钩子和插件管理器。
接着我们动手实现了一个简单的插件系统，看到了代码如何被动态加载和执行。
最后我们联系实际，了解了环境管理工具如何利用类似架构提供强大的灵活性。

插件架构通过解耦核心功能与扩展功能，使你的代码库更具适应性和可维护性。掌握它，你就能构建出能够随着需求“成长”的成熟应用程序。

018：演讲 - 布莱克·雷菲尔德

概述 📚

在本节课中，我们将学习布莱克·雷菲尔德关于PyScript在教育领域应用的演讲核心内容。我们将探讨如何利用PyScript简化编程教学，以及它如何改变学生与教师的学习和教学方式。

章节 1：教育现状与挑战 🏫

当前教育环境中存在大量学生，他们聪明、热情，但学习体验的可持续性有待提高。教育系统需要一种方式，让所有学生都能在其中蓬勃发展。

上一节我们介绍了教育面临的普遍挑战，本节中我们来看看一种可能的解决方案。

章节 2：PyScript的引入与核心理念 ⚙️

PyScript不仅仅是一个工具，它代表了一种新的教学方式。其核心是让学生能够直接在浏览器中运行Python代码，无需复杂的本地环境配置。

核心概念可以用以下简单的代码示例来描述：

<!DOCTYPE html>
<html>
<head>
    <link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />
    <script defer src="https://pyscript.net/latest/pyscript.js"></script>
</head>
<body>
    <py-script>
        print("Hello, PyScript in Education!")
    </py-script>
</body>
</html>

这段代码展示了如何在网页中直接嵌入并执行Python的print语句。

章节 3：PyScript如何赋能教育 ✨

PyScript能够将编程教学的重点从复杂的环境搭建转移到核心概念的理解上。它允许教师和学生专注于“编程”本身，而不是“如何让程序运行起来”。

以下是PyScript为教育带来的几个关键优势：

降低入门门槛：学生无需安装任何软件，只需一个浏览器即可开始编程。
即时反馈：代码修改后能立即看到结果，增强了学习动力。
易于分享：项目可以作为一个简单的网页链接分享，方便协作和展示。
跨平台：在电脑、平板甚至手机上都能获得一致的体验。

章节 4：实践案例与教学场景 🧪

PyScript可以应用于多种教学场景。例如，在数学课上，可以直接用代码演示公式计算；在科学课上，可以模拟实验过程。

让我们看一个简单的数学计算例子：

# 在PyScript环境中计算
result = 5 - 7
print(f“5减去7的结果是：{result}”)

通过这样的互动，抽象的概念变得具体可见。

章节 5：对教师角色的重塑 👨‍🏫

PyScript的出现也改变了教师的角色。教师从知识的单向传授者，转变为学习环境的构建者和学生探索的引导者。

教师可以利用PyScript创建交互式笔记本，将理论、代码和可视化结果结合在一起，提供沉浸式的学习材料。

章节 6：总结与展望 🚀

本节课中我们一起学习了PyScript在教育领域的潜力。我们了解到，PyScript通过其在浏览器中直接运行Python的能力，解决了教学中的环境配置难题，让师生能更专注于编程逻辑和创造性思维。

它不仅仅是一个技术工具，更是一种推动教育更公平、更互动、更以学生为中心的新途径。未来，随着工具的完善，它有望在更多学科和教学场景中发挥巨大作用。

019：演讲内容整理与教程

在本教程中，我们将学习如何利用机器学习技术来提升数据处理管道的效率。我们将基于一次技术演讲的内容，整理出核心概念、实践步骤和架构考量，旨在帮助初学者理解如何构建更智能、更高效的数据工作流。

概述

数据处理管道是现代数据科学和机器学习项目的核心。然而，随着数据量的增长和模型复杂度的提升，传统的管道可能面临效率瓶颈。本节课我们将探讨如何通过引入机器学习模型和自动化策略来优化管道性能，涵盖从模型构建、测试到部署和监控的全过程。

1：核心问题与目标设定 🎯

在开始优化之前，首先需要明确我们面临的核心问题以及优化的目标。

上一节我们概述了课程内容，本节中我们来看看如何定义优化目标。一个低效的管道通常表现为处理速度慢、资源消耗高或结果准确性不稳定。我们的目标是构建一个能够智能调整资源、自动执行测试并持续优化模型性能的管道。

以下是设定目标时需要考虑的几个关键点：

性能指标：明确衡量管道效率的指标，例如处理时间、CPU/内存使用率、模型预测准确率。
可扩展性：确保管道能够应对数据量或任务复杂度的增长。
自动化程度：减少人工干预，实现测试、部署和监控的自动化。

2：构建与集成机器学习模型 🤖

明确了目标后，下一步是构建能够提升管道效率的机器学习模型。

上一节我们讨论了目标设定，本节中我们来看看模型的核心作用。我们可以训练模型来预测任务执行时间、资源需求或结果质量，从而指导资源分配和任务调度。

一个基础的预测模型可以用以下公式表示：
y = f(X)
其中，y 是我们要预测的目标（如任务执行时间），X 是特征向量（如数据大小、任务类型、历史性能数据），f 是我们的机器学习模型（如线性回归、随机森林）。

在实践中，模型构建流程通常包含以下步骤：

数据收集：收集管道运行的历史数据，包括输入特征和对应的结果。
特征工程：从原始数据中提取对预测目标有用的特征。

模型训练：使用机器学习算法（如 scikit-learn 库中的模型）在数据上训练预测模型。

# 示例：使用随机森林回归进行训练
from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor()
model.fit(X_train, y_train)

模型评估：使用测试集评估模型的预测性能。

3：自动化测试与持续集成 ⚙️

模型构建完成后，需要将其无缝集成到现有管道中，并通过自动化测试确保其可靠性。

上一节我们介绍了模型构建，本节中我们来看看如何通过自动化测试来保障管道质量。自动化测试是确保每次代码或模型更新后，管道仍能正确、高效运行的关键。

一个高效的测试框架应包含以下组件：

单元测试：验证管道中单个函数或模块的正确性。
集成测试：验证多个模块组合在一起是否能协同工作。
性能测试：验证管道在负载下的表现，确保其满足性能指标。

我们可以将测试过程自动化，并将其作为持续集成/持续部署流水线的一部分。例如，每当有新的模型或代码提交时，自动触发测试套件。

4：监控、反馈与动态调整 📊

一个智能的管道不仅需要自动化，还需要能够根据运行状态进行动态调整。

上一节我们探讨了自动化测试，本节中我们来看看如何建立监控与反馈循环。通过实时监控管道的运行指标（如延迟、错误率、资源利用率），我们可以及时发现问题。

监控系统可以触发以下动态调整策略：

自动扩缩容：当任务队列积压或资源使用率持续高位时，自动增加处理单元（如Kubernetes Pod）；当负载降低时，自动减少资源以节省成本。
模型重训练：当监控到模型预测性能下降（例如，由于数据分布变化），自动触发模型的重训练流程。
告警与干预：当出现异常时（如错误率飙升），及时通知相关人员或执行预设的补救脚本。

这种“监控-分析-执行”的闭环使得管道具备了自我优化的能力。

5：架构设计与工具选型 🏗️

实现上述智能管道需要一个稳固且灵活的技术架构。

上一节我们介绍了监控与调整机制，本节中我们来看看支撑这些功能的底层架构。一个典型的云原生架构可能包含以下层次：

以下是构建高效管道架构的核心组件：

计算层：使用容器化技术（如Docker）和编排平台（如Kubernetes）来运行管道任务和模型服务，便于管理和扩缩容。
数据层：可靠的数据存储和消息队列（如云存储、Apache Kafka），用于处理输入数据和中间结果。
编排与调度层：工作流编排工具（如Apache Airflow, Kubeflow Pipelines），用于定义、调度和监控复杂的任务依赖关系。
监控与可观测层：集成监控工具（如Prometheus, Datadog），收集指标、日志和追踪信息，为动态调整提供数据支持。

选择合适的工具组合，并确保它们之间能够良好集成，是成功构建智能管道的基石。

总结

在本节课中，我们一起学习了如何利用机器学习提升数据处理管道的效率。我们从定义明确的优化目标开始，逐步深入到构建预测模型、实现自动化测试、建立监控与动态调整机制，最后探讨了支撑这一切的云原生架构与工具选型。

核心在于构建一个具备感知、决策和执行能力的智能系统，使其能够自动适应变化、优化资源利用并保障任务执行的效率与可靠性。通过将机器学习融入管道生命周期的各个环节，我们可以让数据工作流变得更加智能和强大。

020：Python的语法糖

在本节课中，我们将要学习Python中的“语法糖”。语法糖是一种让代码更简洁、更易读的语法特性，它不会增加语言的新功能，但能让编程体验更愉快。我们将通过具体的例子来理解这个概念。

概述：什么是语法糖？🍬

语法糖是编程语言中一种语法上的“甜头”。它让代码写起来更简单，看起来更清晰，但并没有引入新的底层功能。Python中有很多这样的语法糖。

上一节我们介绍了语法糖的基本概念，本节中我们来看看Python中一个经典的语法糖例子：列表推导式。

列表推导式：一个经典例子📝

列表推导式是Python中非常强大且常用的语法糖。它提供了一种简洁的方式来创建列表。

假设我们想创建一个包含0到9数字平方的列表。不使用语法糖的传统写法是使用for循环：

squares = []
for i in range(10):
    squares.append(i * i)

而使用列表推导式这个语法糖，代码可以变得非常简洁：

squares = [i * i for i in range(10)]

这两段代码的功能完全一样，但列表推导式只用一行就完成了任务，代码更紧凑、意图更明确。

以下是列表推导式的基本结构：

[表达式 for 变量 in 可迭代对象]

理解了列表推导式，我们来看看其他几种常见的语法糖。

为什么使用语法糖？🤔

使用语法糖主要有以下几个好处：

提高可读性：代码更简洁，意图更清晰。
减少错误：更少的代码行数意味着出错的机会更少（例如，忘记关闭文件）。
提升开发效率：用更少的代码表达相同的逻辑。

当然，语法糖也需要适度使用。过度使用或嵌套过深的语法糖（如复杂的多层列表推导式）可能会降低代码的可读性。

总结

本节课中我们一起学习了Python中的语法糖。我们了解到语法糖是一种让代码更简洁、更优雅的语法特性，它通过提供更友好的写法来提升开发体验，而不改变语言的核心能力。我们从列表推导式入手，还介绍了赋值表达式、装饰器、上下文管理器和解包等常见例子。记住，合理使用语法糖能让你的代码既漂亮又高效。

021：深入了解特化与自适应解释器 🚀

在本节课中，我们将要学习 CPython 3.11 版本中引入的两项核心性能优化技术：特化与自适应解释器。这些改进旨在让 Python 代码运行得更快，而无需开发者修改代码。我们将通过简单的概念和示例来理解它们的工作原理。

概述 📋

Python 3.11 通过引入“特化”和“自适应解释器”机制，显著提升了字节码的执行效率。简单来说，解释器会观察代码的运行情况，并为高频、特定的操作生成优化后的机器码，从而避免通用逻辑带来的开销。

1：什么是特化？🎯

上一节我们介绍了课程目标，本节中我们来看看第一个核心概念：特化。

特化是指 Python 解释器将通用的字节码指令替换为针对特定数据类型或值优化的专用版本的过程。通用指令为了处理所有可能的情况，包含了许多判断逻辑，这会导致性能损耗。特化通过“猜测”最常见的执行路径，并为其生成快速路径，来提升性能。

特化的工作原理

以下是特化的一个简化工作流程：

监控：解释器在运行时监控每条字节码指令的执行情况。
计数：当某条指令（例如，BINARY_OP 用于加法）被反复执行，且操作数类型（例如，两个整数）相同时，计数器增加。
触发：当计数器超过某个阈值，解释器触发特化。
替换：通用的字节码指令被替换为特化指令（例如，BINARY_OP_ADD_INT）。
执行：后续执行遇到该指令时，直接运行高效的专用逻辑。

特化的好处

以下是特化带来的主要优势：

减少判断：专用指令无需检查操作数类型，直接执行目标操作。
内联常量：对于涉及常量的操作，结果可能被直接计算并缓存。
路径优化：跳过了错误处理等不常用的慢速路径。

一个典型的例子是属性访问。通用指令 LOAD_ATTR 需要查找对象的属性字典。如果多次访问同一个对象的同一个属性，它可能被特化为 LOAD_ATTR_SLOT，直接从已知的内存偏移量读取值。

# 通用指令（伪代码）
def LOAD_ATTR(obj, name):
    if attr in obj.__dict__:
        return obj.__dict__[name]
    elif hasattr(obj, '__getattr__'):
        return obj.__getattr__(name)
    else:
        raise AttributeError

# 特化后指令（伪代码）
def LOAD_ATTR_SLOT(obj, known_offset):
    return obj._slots[known_offset]  # 直接内存访问

2：自适应解释器 🔄

理解了特化如何优化单条指令后，本节我们来看看一个更宏观的机制：自适应解释器。

自适应解释器是驱动特化过程的“大脑”。它不是一个独立的解释器，而是 CPython 3.11 解释器的一种新运行模式。它负责在程序执行期间收集性能数据，并动态地、自适应地应用优化（如特化）。

自适应解释器如何工作

以下是自适应解释器工作的关键步骤：

解释执行：程序开始时，所有代码都通过标准的、通用的字节码解释器执行。
收集数据：解释器为每个字节码位置维护一个“计数器”和“类型/值缓存”。
做出决策：当数据表明某个操作模式（如“总是对两个整数相加”）稳定且高频时，自适应逻辑决定进行特化。
即时优化：在运行时将通用字节码替换为特化字节码。这个过程对开发者完全透明。
降级处理：如果优化假设被打破（例如，突然对整数和字符串进行加法），特化指令会“去优化”，回退到通用指令并重置计数器，重新开始学习。

这种“尝试-监控-优化或回退”的循环，使得解释器能够适应程序的实际运行行为。

3：性能提升示例 📈

上一节我们介绍了自适应解释器的工作原理，本节中我们通过一个具体例子来看看这些优化带来的实际效果。

考虑一个简单的累加循环：

def sum_numbers(numbers):
    total = 0
    for num in numbers:
        total = total + num  # 这行代码将被特化
    return total

# 调用函数
result = sum_numbers([1, 2, 3, 4, 5])

在 Python 3.10 中，循环体内的 total + num 操作每次执行时，字节码指令 BINARY_ADD 都需要检查 total 和 num 的类型（是整数、字符串还是列表？），然后调用对应的加法函数。

在 Python 3.11 的自适应解释器中：

最初几次迭代，BINARY_ADD 正常执行，并记录到操作数总是整数。
经过一定次数（例如，8次）后，自适应解释器将 BINARY_ADD 特化为 BINARY_OP_ADD_INT。
后续的迭代直接执行整数加法指令，跳过了类型检查等步骤，从而显著提速。

根据官方数据，这类微观优化使得 Python 3.11 的整体性能比 Python 3.10 平均提升了 25-30%。

总结 🎉

本节课中我们一起学习了 CPython 3.11 中两项关键的底层优化技术。

特化：通过将通用字节码指令替换为针对特定类型或值优化的专用版本，来减少运行时开销。
自适应解释器：在程序运行时监控字节码执行情况，动态地应用特化等优化，并在假设不成立时安全地回退。

这些改进共同作用，使得 Python 3.11 在无需更改代码的情况下获得了可观的性能提升。它们代表了 Python 向更智能、更高效的运行时系统迈进的重要一步。对于开发者而言，这意味着你写的相同代码，在 3.11 上会运行得更快。

022：重新思考对象 🧠

在本节课中，我们将学习布鲁斯·埃克尔关于“重新思考对象”的核心观点。我们将探讨面向对象编程中一些常见的误解，并理解如何更有效地运用对象这一概念来构建灵活、可维护的软件系统。

上一节我们介绍了课程的主题，本节中我们来看看布鲁斯·埃克尔对传统对象观念的挑战。

他认为，许多程序员对“对象”的理解过于僵化，将其视为数据和方法的简单捆绑。这种理解限制了设计的灵活性。

上一节我们提到了对对象的僵化理解，本节中我们来看看更动态的视角。

一个更强大的视角是将对象视为服务的提供者。对象的核心价值不在于它封装了什么数据，而在于它能为你提供什么服务或行为。

这种视角的转变，意味着设计重心从“有什么”（has-a）转向了“能做什么”（can-do）。

理解了对象作为服务提供者的概念后，我们来看看如何实践这一理念。以下是应用这一理念的几个关键原则：

单一职责原则：一个对象应该只有一个引起它变化的原因。这意味着它只提供一组紧密相关的服务。
接口隔离：客户端不应被迫依赖它们不使用的接口。应定义多个特定的接口，而不是一个庞大通用的接口。

组合优于继承：优先使用对象组合（has-a）来扩展功能，而非依赖继承（is-a）。这能带来更大的灵活性。例如：

// 使用组合
class Engine {
    public void start() { /* 启动逻辑 */ }
}
class Car {
    private Engine engine; // Car 拥有一个 Engine
    public void start() {
        engine.start();
    }
}

在探讨了核心原则后，我们来看看这种思维转变带来的好处。重新思考对象能带来以下主要优势：

更高的内聚性：每个对象专注于一项明确的任务。
更低的耦合性：对象之间通过清晰的接口交互，减少相互依赖。
增强的可测试性：服务明确的对象更容易被单独测试。
更好的可维护性：系统更易于理解、修改和扩展。

本节课中我们一起学习了如何重新思考面向对象编程中的“对象”。核心在于将对象从“数据容器”的刻板印象中解放出来，转而视其为“服务提供者”。我们探讨了单一职责、接口隔离和组合优于继承等实践原则，并了解了这种思维模式如何带来高内聚、低耦合、易测试和好维护的代码设计。记住，对象的价值在于其行为，而非其属性。

023：向 Python 文档的迭代转型 🚀

在本节课中，我们将学习 Python 文档团队如何对其文档系统进行迭代转型。我们将了解转型的背景、面临的挑战、具体的改进措施以及社区在其中扮演的角色。无论你是文档贡献者还是普通用户，都能从中了解如何更好地使用和参与 Python 文档的建设。

概述

Python 文档是社区的重要资产，但其维护和更新面临诸多挑战。本次演讲由文档团队的成员分享，他们介绍了如何通过一系列迭代改进，使文档系统变得更现代化、更易于维护和协作。核心目标是提升文档的可读性、可维护性和社区参与度。

演讲者介绍 👥

上一节我们概述了课程内容，本节我们来认识一下本次分享的演讲者。

我是本次分享的主讲人之一。我的工作主要围绕 Python 文档团队展开，处理补丁和文档维护事宜。我同时也是一名中级程序员，并积极参与本地及全球的 Python 社区活动。

另一位共同主讲人是金。他同样深度参与文档工作，并带来了从开发者角度的宝贵见解。我们二人都致力于改善 Python 的文档体验。

我们的工作离不开整个 Python 社区的支持，特别是核心贡献者如彼得、SBO、六月等人的辛勤付出。

转型背景与挑战 ⚙️

在认识了演讲者之后，我们来看看促使文档转型的背景和主要挑战。

旧的文档系统基于自定义函数构建，虽然功能强大，但维护成本高昂，且难以支持大规模的社区协作。文档的构建流程复杂，从 RST 文件到 HTML 的转换过程不够灵活。

具体而言，我们面临以下核心问题：

维护困难：旧系统结构复杂，更新和修复需要大量手动操作。
协作不畅：缺乏高效的协作工具和环境，阻碍了社区贡献。
用户体验不佳：长篇幅的函数文档难以导航，查找特定信息效率低下。

所有问题的核心，都指向一个自定义函数 legacy_build_system() 的问题，它曾是整个文档生成流程的瓶颈。

核心改进措施 ✨

了解了挑战所在，本节我们将深入探讨文档团队实施的一系列具体改进措施。

1. 引入新的文档构建系统

我们彻底改造了文档构建路径，放弃了旧有的、笨重的自定义流程。新的系统更加模块化和自动化。

例如，新的构建命令更加清晰：

# 旧命令（复杂且难以记忆）
make html SPHINXOPTS="-W"

# 新命令（更简洁直观）
python -m sphinx.cmd.build -b html sourcedir builddir

2. 优化大型函数文档的展示

对于参数众多的大型函数，我们改进了其呈现方式，使其更易于阅读和导航。

改进包括：

参数表格化：将冗长的参数列表以表格形式展示，清晰列出参数名、类型和说明。
添加快速参考：在文档侧边栏或顶部增加该函数的语法和核心用法的快速参考。
嵌入示例代码：在文档中直接嵌入可运行的示例代码块，方便用户理解。

3. 建立开放的文档社区与流程

我们创建了更开放的协作空间，鼓励社区参与。以下是关键的社区资源列表：

文档社区网站：一个集中的平台，用于讨论文档事宜。
月度文档社区会议：定期举行会议，同步进展并收集反馈。
公开的邮件列表和聊天频道：如 docs@python.org 邮件列表和相关的 Discord/Slack 频道，供日常交流。

任何人都可以通过这些渠道加入讨论、报告问题或提交改进建议。

4. 增强搜索与导航功能

新的文档系统提供了更强大的全文搜索和 API 链接跳转功能。用户能更快地找到所需信息，并在相关的类、函数、模块之间轻松跳转。

总结

本节课中，我们一起学习了 Python 文档团队的迭代转型之旅。

我们从转型的背景和挑战出发，了解到旧系统在维护和协作上的不足。接着，我们探讨了四项核心改进：引入现代化的构建系统、优化大型函数文档的展示、建立开放的社区协作流程以及增强搜索与导航功能。这些改进共同使 Python 文档变得更易于使用、维护和贡献。

最后，我们要感谢全球 Python 社区的每一位成员。正是社区的共同努力和宝贵反馈，驱动着文档系统不断向前发展。如果你对文档工作感兴趣，欢迎通过文中提到的各种渠道加入我们。

感谢你的时间。

024：卡尔文·亨德里克斯-帕克演讲解析 🎤

在本节课中，我们将一起学习如何准备和进行一次有效的演讲。我们将通过分析卡尔文·亨德里克斯-帕克的一次演讲，来了解演讲的核心要素、准备流程以及如何与观众建立联系。课程内容将涵盖从前期准备到现场演示的各个环节，旨在帮助初学者掌握基础的演讲技能。

演讲技巧：P24：1：演讲准备与开场 🧭

上一节我们介绍了课程概述，本节中我们来看看演讲的准备工作与开场。

演讲的成功始于充分的准备。你需要规划日程，了解观众，并准备好演示材料。例如，卡尔文提到他会在早上完成准备工作，并与相关人员进行沟通。

以下是演讲准备的关键步骤：

规划日程：将你的演讲时间与个人日程进行比较，确保有充足的时间准备。
了解观众：观察并思考你的观众是谁，他们可能关心什么。
准备材料：确保所有演示材料，如图片、幻灯片等，都已准备就绪。例如，可以拍摄360度全景照片来丰富演示内容。
提前沟通：与活动组织者或相关团队进行对话，确认细节。

一个有力的开场至关重要。它需要吸引观众注意力，并阐明演讲的核心价值。卡尔文指出，演讲的存在是因为观众在寻找特定的解决方案或工具。

演讲技巧：P24：2：演示结构与核心价值 💡

上一节我们探讨了演讲的准备与开场，本节中我们来看看如何构建演示内容并传达核心价值。

演示的结构应该清晰，引导观众从起点走向终点。核心在于向观众展示你所提供的内容能如何解决他们的问题，并带来长远利益。

演示通常遵循一个简单的路径结构，可以用以下伪代码表示：

开始演示()
    展示问题或需求
    呈现解决方案或工具
    阐明核心价值与长远益处
结束演示()

在这个结构中，核心价值是中心。它可能是为某个特定案例提供解决方案，或是提供一个能持续多年产生影响的工具。例如，卡尔文提到，一个合适的工具可能价值数千美元，但它在长远上对用户有帮助。

流程的最后部分，也是最重要的部分，是保持诚实。诚实对待你将要做的事情和你将提供给观众的内容。

演讲技巧：P24：3：互动与用户界面应用 🖥️

上一节我们讨论了演示的结构与价值主张，本节中我们来看看如何通过互动和工具应用来增强演讲效果。

演讲不仅是讲述，更是与观众的互动。你可以邀请观众参与某些环节，或者演示如何使用一个用户界面（UI）来完成特定任务。反复强调工具或界面的可用性，可以加深观众的印象。

卡尔文在演讲中多次强调“你也可以使用你的界面”，这突出了工具的实用性和可操作性。

以下是增强演讲互动性的方法：

邀请参与：设计一些观众可以做的事情，让他们感觉自己是演讲的一部分。
工具演示：现场展示如何使用一个软件界面或工具来解决实际问题。
重复关键点：对于核心功能或优势，通过重复来强化观众的记忆。

通过实际演示界面操作，可以让抽象的概念变得具体可见。例如，展示如何在一个系统中输入指令并获得结果。

持续地展示和说明界面操作，能帮助观众理解工作流程。

演讲技巧：P24：4：深入操作与细节展示 🔍

上一节我们介绍了互动与界面演示，本节中我们将更深入地探讨具体操作和细节展示。

为了使演讲内容扎实可信，需要深入展示工具或方法的操作细节。这包括展示不同的功能模块、处理步骤以及可能的结果输出。

卡尔文通过不断展示“使用你的接口”和呈现相关图示，来详细说明操作过程。这种细致的展示有助于建立专业性和可信度。

深入操作演示可以遵循以下逻辑：

功能分解：将复杂工具分解为多个可管理的功能点。
步骤演示：逐步展示每个功能是如何使用的。
结果验证：展示操作后产生的具体结果或数据。

例如，在演示一个数据处理接口时，可以依次展示：输入数据 -> 调用处理函数 -> 查看输出报告。

对于关键步骤或复杂环节，可以使用图表或示意图进行辅助说明，确保观众能够跟上节奏。

演讲技巧：P24：5：总结与闭环 ✅

上一节我们完成了对操作细节的深入探讨，本节中我们将对整场演讲进行总结与闭环。

演讲的结尾需要有力地总结核心观点，并再次强调它能给观众带来的益处。回顾整个演示路径，从发现问题到提供解决方案，最后落脚于它将如何在未来持续发挥作用。

一个有效的总结公式是：

总结 = 重申核心问题 + 概括解决方案 + 强调长远价值

卡尔文指出，演讲的结束部分是诚实的，并且关乎你将为人们做的事情。这意味着你的承诺和总结必须真实、可信。

最后，可以留下一个清晰的行动号召或思考点，让观众在离开后有所收获。例如，鼓励他们尝试使用演示过的工具，或者思考如何将演讲中的概念应用到自己的领域。

通过完整的演示和总结，确保你的演讲信息形成一个闭环，给观众留下深刻而完整的印象。

本节课中我们一起学习了如何进行一场完整的演讲。我们从前期准备和开场入手，学习了如何了解观众和准备材料。接着，我们探讨了如何构建清晰的演示结构，并传达能解决实际问题的核心价值。然后，我们研究了通过观众互动和界面演示来使演讲更加生动和可信。最后，我们强调了深入展示操作细节的重要性，以及如何做一个有力的总结来闭环整个演讲。记住，成功的演讲在于充分的准备、清晰的结构、实用的价值以及真诚的沟通。

025：尝试不使用GIL 🧪

在本节课中，我们将探讨在Python科学编程中尝试绕过全局解释器锁（GIL）的动机、挑战与实践方法。GIL是Python多线程编程中的一个核心概念，它限制了多线程的并行执行能力。我们将学习为何在某些科学计算场景下需要规避GIL，以及如何通过特定的技术和模式来实现。

概述：为何关注GIL？ 🤔

上一节我们介绍了课程主题，本节中我们来看看GIL为何成为科学编程中的一个关注点。全局解释器锁（GIL）是CPython解释器中的一个机制，它只允许一个线程在同一时刻执行Python字节码。这对于CPU密集型的科学计算任务来说，可能成为一个性能瓶颈。

核心公式：在CPython中，GIL的存在意味着多线程并不总能带来性能提升，尤其是在计算密集型任务中。其影响可以简化为：
有效并行度 ≈ 1（对于纯Python CPU密集型线程）

GIL的工作原理与影响 ⚙️

理解了关注GIL的原因后，我们来深入了解它的工作机制。GIL确保了对Python对象的访问是线程安全的，但它也阻止了多核CPU被多个Python线程充分利用。

以下是GIL带来的主要影响：

限制并行：多个线程无法同时执行Python代码，即使有多个CPU核心。
I/O密集型优势：在等待I/O（如文件读写、网络请求）时，线程可以释放GIL，因此多线程对I/O密集型任务仍有好处。
计算密集型瓶颈：对于纯粹的科学计算，多线程可能无法加速，甚至因锁竞争而变慢。

尝试规避GIL的动机 🎯

既然GIL对并行计算有限制，那么科学家和开发者自然希望找到绕过它的方法。本节我们将探讨尝试不使用GIL的核心动机。

我们想要摆脱GIL，主要是为了释放硬件的全部潜力。在科学计算、机器学习和大规模数据处理中，能够进行真正的并行计算至关重要。这可以显著缩短实验和模型训练的时间。

规避GIL的实践策略 🛠️

明确了动机，接下来我们看看有哪些实际策略可以尝试。这些方法各有优劣，适用于不同场景。

以下是几种常见的规避GIL的策略：

使用多进程（multiprocessing 模块）：创建多个独立的Python解释器进程，每个进程有自己的GIL，从而实现真正的并行。这是最直接、最常用的方法。
```
from multiprocessing import Pool
def compute(data_chunk):
    # 密集型计算
    return result
with Pool(processes=4) as pool:
    results = pool.map(compute, large_dataset)
```
使用替代解释器：如Jython或IronPython，它们没有GIL，但可能不兼容所有C语言扩展。

将关键代码移至C扩展：在C扩展中，可以手动释放GIL，从而允许其他线程运行。这需要C语言编程知识。
```
Py_BEGIN_ALLOW_THREADS
// 执行不涉及Python API的耗时C代码
Py_END_ALLOW_THREADS
```
使用专为并行计算设计的库：例如 NumPy、SciPy 或 TensorFlow/PyTorch 的某些操作，其底层实现是用C/C++编写的，并在内部释放了GIL，因此可以在多线程中高效运行。

探索无GIL的Python分支或未来版本：社区一直在讨论移除GIL的可能性，可以关注相关PEP（Python增强提案）和实验性分支。

案例分析与选择建议 📈

学习了多种策略后，我们通过一个案例来思考如何选择。假设我们有一个计算量巨大的模拟任务。

在这种情况下，使用 multiprocessing 模块通常是首选。它避免了GIL限制，且编程模型与多线程相似。然而，进程间通信（IPC）开销比线程大，且内存占用更高。如果任务涉及大量共享状态，则需要使用 multiprocessing 提供的 Queue、Pipe 或 Manager 来进行进程间通信。

总结与展望 📚

本节课中我们一起学习了Python中全局解释器锁（GIL）在科学编程中的影响以及规避它的方法。

我们了解到，GIL是CPython为简化内存管理而引入的机制，但它限制了多线程的并行计算能力。为了在科学计算中实现真正的并行，我们可以采用多进程、使用特定计算库、或将关键部分移至C扩展等策略。每种方法都需要权衡易用性、性能和开发复杂度。未来，随着Python语言的演进，我们或许能看到GIL被进一步优化或移除的解决方案。

对于初学者而言，从 multiprocessing 模块开始实践是理解并行概念和规避GIL限制的良好起点。

026：从 CSV 文件高效构建 NumPy 数组 🚀

在本教程中，我们将学习如何从 CSV 文件高效地构建 NumPy 数组。我们将探讨传统方法（如 Pandas）的局限性，并深入理解一种基于 Python 标准库 csv 模块核心解析器的高性能解决方案。课程将涵盖核心概念、实现步骤以及性能对比，旨在让初学者掌握构建快速、灵活的数据读取工具的方法。

概述与背景 📖

上一节我们介绍了本课程的目标。本节中，我们来看看演讲者 Christopher 的背景及其项目动机。Christopher 是 RUSCA-CADER 的首席技术官，自 2000 年起使用 Python。他最初用 Python 构建金融系统，并创建了一个基于不可变数据模型的培训网站。本次分享的核心，源于他对 Python 标准库中一个高效但古老的 CSV 解析器 student-in-（实为 csv.reader 的早期核心）的深入理解和改造。

现有工具的挑战 ⚠️

上一节我们了解了项目背景，本节中我们来看看在数据处理中，尤其是从 CSV 读取数据到 NumPy 数组时，常用工具存在哪些挑战。

以下是 Pandas 库在特定场景下的一些局限性：

类型推断开销：Pandas 会自动推断每列的数据类型，这个过程可能带来性能开销。
对象类型泛滥：对于无法立即识别的类型（尤其是字符串），Pandas 会使用 Python 对象（dtype=object）来存储，这非常消耗内存和计算资源。
缺乏细粒度控制：用户难以在读取阶段精细控制每列的类型转换和处理逻辑。
大整数支持：对于超出标准整数范围的数值，支持可能不完善。
非标准类型：对复杂或非标准数据类型（如特定格式的时间、枚举等）的支持有限。

这些限制在处理大型或特殊格式的 CSV 文件时，可能导致性能瓶颈或功能缺失。

核心解决方案：`csv` 模块与类型推断 🧠

上一节我们探讨了现有工具的不足，本节中我们来看看提出的核心解决方案。其灵感来源于 Python 标准库 csv 模块中的高效解析器。该解析器的核心是一个状态机，它逐字符处理文本，性能很高且可配置。

关键思路是复用这个稳健的解析器来获取原始的、分好列的字符串数据，然后绕过 Pandas 的对象系统，直接将这些字符串转换为目标 NumPy 数据类型（C 类型）。这样可以避免创建大量 Python 中间对象。

核心流程可以用以下伪代码描述：

# 伪代码：核心两步流程
1. 使用 csv 模块的核心分词器逐行解析 CSV，将结果存储为字符串列表的列表（或更高效的结构）。
2. 遍历这些字符串，根据每列的目标类型（如 int32, float64, `U10` 等），直接将其转换为对应的 C 类型并填充到预分配的 NumPy 数组中。

实现架构：分词器与缓冲区 🏗️

上一节我们介绍了核心思路，本节中我们来看看具体的实现架构。实现主要分为两个部分：分词器（Tokenizer）和缓冲区管理。

以下是实现中的关键组件：

代码点运行器（Code Point Runner）：这是对 csv.reader 核心状态机的封装。它读取输入（文件或迭代器），按 CSV 方言规则将流分解为一个个字段（字符串）。
代码点网格（Code Point Grid）：这是一个临时的数据结构，用于在解析过程中按列收集字段。它通常包含两个动态数组：
- 缓冲区（Buffer）：一个连续的字符数组，存储所有字段的原始字符数据。
- 偏移量数组（Offset Array）：记录每个字段在缓冲区中的起始位置和长度。
字段访问：通过偏移量数组，可以快速定位和提取任何一个字段的字符串内容，而无需创建单独的 Python 字符串对象，直到必要时。

这种设计使得在解析阶段能够高效地组织数据，为后续的类型转换做好准备。

从文本到 NumPy 数组：转换过程 🔄

上一节我们了解了数据在内存中如何被组织，本节中我们来看看如何将文本数据最终转换为 NumPy 数组。这是性能提升的关键步骤。

转换过程遵循以下步骤：

初始化：确定目标 NumPy 数组的形状（行数、列数）和每列的数据类型。类型可通过自动推断、用户指定或结合两者获得。
预分配数组：根据形状和类型，预先分配好最终的 NumPy 数组（一个二维数组或结构数组）。此时数组内容为空。
逐列填充：
- 对于每一列，从“代码点网格”中获取该列所有字段的字符串视图。
- 使用该列目标数据类型（如 np.int32）的转换函数，直接将字符串批量转换为 C 类型数据。
- 将转换后的数据块直接写入预分配的 NumPy 数组的对应列中。
完成：所有列填充完毕后，即得到最终的 NumPy 数组。整个过程最大限度地减少了 Python 对象的创建和复制。

性能对比与基准测试 📊

上一节我们描述了高效的转换流程，本节中我们通过基准测试来量化其性能优势。测试通常对比三种场景：

完全类型推断：工具自动推断所有列的类型。
无类型推断（全部作为字符串）：所有列均作为 Unicode 字符串（U 类型）读入。
用户指定类型：提前为所有列提供明确的数据类型。

以下是典型的性能发现：

在宽表格（列数很多）和完全类型推断的场景下，该方法的性能通常比 Pandas 的 read_csv 快一个数量级或更多。
当所有数据都作为字符串读入时，由于 NumPy 的 Unicode 字符串类型本身涉及对象开销，性能优势会缩小，但仍可能优于或接近 Pandas。
用户指定类型时，性能最佳，因为它完全避免了类型推断的开销。
性能瓶颈分析显示，在 Pandas 中，将字符串列转换为 Python 对象（dtype=object）是主要的耗时操作之一。而本方法直接转换为 C 类型，避免了这一步。

高级功能与配置 ⚙️

上一节我们看了性能对比，本节中我们来看看该解决方案提供的一些高级配置选项，使其更加灵活。

用户可以通过参数自定义读取行为：

指定列类型：可以为特定列提供精确的 NumPy 数据类型。
自定义转换函数：可以为某一列提供一个函数，该函数接收原始字符串，返回转换后的值。例如，将特定格式的字符串转换为布尔值。
使用自定义分词器：可以传入符合接口的自定义分词器，以处理非标准 CSV 格式。
跳过类型推断：如果已知所有类型，可以关闭类型推断以提升速度。

这些功能使得该工具能够适应各种复杂的数据清洗和预处理需求。

总结与展望 🎯

本节课中我们一起学习了如何构建一个从 CSV 到 NumPy 数组的高性能读取器。我们回顾了现有工具（如 Pandas）的局限性，深入探讨了基于 Python 标准库 csv 模块核心解析器的解决方案架构。我们了解了其通过分词器获取原始文本、使用缓冲区管理数据，并最终高效转换为 C 类型 NumPy 数组的两阶段流程。基准测试表明，该方法在多数场景下，尤其是宽表和数据类型明确时，能带来显著的性能提升。

最后，这种模块化设计也为未来优化打开了大门，例如可以将最终的列转换步骤并行化，以进一步加速处理超大型数据集。通过借鉴并改造历经时间考验的底层代码，我们能够构建出既稳健又高效的现代数据处理工具。

027：使用 Pytest 测试航天器 🚀

概述

在本节课中，我们将探讨在航天器软件开发中，如何使用 Pytest 框架进行有效测试。我们将分析航天软件测试面临的独特挑战，例如高可靠性要求、单次执行特性以及复杂的操作环境，并学习如何构建接近真实生产环境的测试体系来建立信心。

航天软件测试的独特挑战 🛰️

上一节我们介绍了课程概述，本节中我们来看看航天软件测试面临哪些不同于常规网络服务的挑战。

过去20年，软件测试的讨论大多由网络服务主导。网络服务固然重要，但航天软件需要考虑不同的决策和多样性，并更具可持续性。航天系统通常与博物馆、网络服务器、计算机中心或云计算远程相连，它们在通信上非常快速。其测试与发布流程与现代信息丰富的网站相似。

然而，关键区别在于，航天系统感觉像是一种新型网络。真正的一流系统仅在经过基于特定轨道的连接时，才拥有稳定的网络连接，可能只有几次机会。你通常没有物理访问权限去进行调试，具体取决于任务的时间安排。就像一个卫星，没有人可以进去重新配置。而你仍然真的处于一个测试阶段。最终，单个任务的影响，对航天活动而言是非常不同的。

请求量与信用质量 📊

关于软件测试，我们需要思考请求量和信用质量这两个概念。

请求量：指的是你的软件正在执行的操作请求数量。
信用质量：指的是任何一个请求操作的重要性或关键程度。

大多数网络服务在底部运行，具有高请求量和低信用质量。例如，一个网络服务计划可能有成千上万的用户发出数百万次请求。如果生产环境中出现漏洞，它开始让你付出成本。但这通常不是致命问题，因为你处于如此高的容量中，大多数用户甚至可能不知道错误曾经发生过。

航天软件则完全相反，它是低请求量和高信用价值。例如，在一次火箭发射的重入序列中，你只会执行那一次关键操作。这不是日常工作，但在某个时刻它至关重要。

历史教训：软件缺陷的代价 💸

历史案例提醒我们软件缺陷可能带来的巨大代价。例如，某个航天器使用的软件包含一个小的快速对齐例程。在新一代航天器上，虽然不需要这个功能，但遗留的软件基础设施保留了下来。在这个对齐例程中，存在一个从 64 位到 16 位的数据转换错误。

旧型号航天器通过一个特定值得以规避此问题。但新型号更大，软件必须设计更保守的区域以便设备能够工作。他们在一个非常重要的部分上有一个代理来处理这个问题。甚至火箭在测试中也看到了异常，但不知道具体原因。

后来，一个测试单位运行了相同的软件，产生了完全相同的错误效应。这个漏洞导致了巨大的成本，因为它是我们软件中的一个大问题。问题在于，该软件是专门为错误配置进行测试的。

操作环境的重要性 ⚙️

我们可以从案例中带走可用的软件，它就是操作环境。你的软件运行的环境与代码本身同样重要。因为如果你的操作环境与测试和分析的环境不同，你可能会带着错误的信心进入生产阶段。

一个具体的例子是，一个在2015-2020年间发布的航天器，旨在部署一个太阳帆。它应该监测太阳风并调整姿态。然而，在轨运行时，一个持续15秒的信号问题，导致飞行计算机错误地消耗了大量推进剂。状态系统看到了异常并做出响应，最终触发了系统重启。我们能够完成那个任务，结果还算合理。

从这个案例我们学到，为什么软件防御可能随着时间的推移花费数百万？没有真正快速的策略。另一个积极的教训是，你如何知道一个潜伏六年的错误可以被部署。制造成功与服务之间的差异？时间线的水平是关键。

测试策略：跨越“原则”的鸿沟 🧪

我们要从中带走的是，我们可以以一种必须跨越“原则”地方的方式进行测试。这有两个原因：对原则的理解不同，以及原则实施的地点不同。如果没有这样的集成测试，那就是集成在一个仅硬件系统中。

那么对你来说重要的问题是，因为任务是要实现的。你的系统的两分钟表现，但你可能会被测试成可能的原则。如果你做不到，那么你需要进行重叠的集成测试。我在这里非常小心，关于现有系统A和B。同样的测试也必须重叠。否则，你会有一个测试覆盖的缺口。

建立信心：从“绝对不行”到“几乎肯定行” 📈

最终，你提出的问题，确实是你提问的社区方式。当你在生产环境中运行时，你可以看到它。对此有三个可以接受的答案：没有，也许，和可能。是，这不是对这个问题的可接受答案。这不是一个预测，而是一个可证伪的假设。

我们可能知道软件甚至无法编译，所以不可能在生产中运行。但我们永远无法完全确定它如何进入生产，同时仍然保留在生产中。我们剩下的是如何考虑这种情况？我们希望处在一个连续体上，介于“这绝对行不通”和“这几乎肯定行得通”之间。

我们需要获得信心，以便有更多的证据来支持我们的软件。并且更详尽地提供证据。尽管要进行严格的防御，我们在发布之前需要有更多的信心。

关键问题：需要多少信心？⏱️

所以现在我们必须问，真正需要多少信心？这涉及到成本、努力和时间。如果这真的无关紧要，出错了又何妨？那你为什么要花费努力，确保你能做到99%的正确呢？这个问题要如何成功？

对于航天软件，在生产中第一次工作有多关键？这回到我之前所说的个性卷。对于火箭来说，第一次在生产中运行，就是它执行任务的时候。而其他一切都是测试。因此，你需要只做一次。对于网络服务，我们可以采取很多步骤来减少关键性，例如在进入生产前就进行部署。这些技术都很好，它们所讨论的是减少“第一次在操作生产中”的关键性。

两者的成本环境最大程度上有多接近？在地面上模拟微重力、高辐射的真空环境非常困难，且成本高昂。所以我们需要更多的信心来面对，因为我们不知道在那种环境下软件的确切表现。如果我们能频繁地测试，你可以在每次操作中逐渐建立信心。但如果只做一次，而那一次火箭正要发射，我们就需要在发射前建立极高的信心。

监管与审计要求 📝

记住，监管工作并不是为了帮助你，而是一个问题。监管的职责是保护公共资金的价值。他们通过要求你遵循流程来做到这一点，最终会涉及审查软件、系统和将被存储的数据。因此，他们需要能够看到你所说的事情是否得到了执行。

这也涉及到在每次测试中留下审核和编辑的记录，确保你知道你在宣布什么。那么，我们如何避免错误呢？这就是为什么要建立信心。因此，我们对它们进行了定义，例如定义“等待类”供我们观察。我们有两组负责监督的人员，技术含量更高。我们把输入系统放在硬件和集成测试上。但我们确实有单元测试，这对我们的技术和开发信心很有用。

我们定期进行全面的硬件和集成测试。我们尽可能做到这一点。试图辩解不运行测试，因为这会增加报告，是不可取的。我们确实有长期的历史测试覆盖。

构建测试环境：从桌面到“类飞行” 🖥️->🛰️

我们如何在测试环境中模拟飞行环境？我们划分硬件，以及测试场的硬件和测试场域。我们从查看实际的组装开始。测试场的后端是社区的数据，另外两台是社区的，测试场域在后端，总线提供电源。数据需要运行，一切都在操作中，但需要自动化。

更好的测试场域是我们所称的“类飞行控制”，这正是我们的重点。例如，在家里就很好。在那两台不同的计算机上运行，几台不同的计算机是某些接入节点。为了产生不同，这两台计算机可以连接起来，针对不同的外设运行。

一个简单的测试床，你会把所有组件拿出来，把控制台的组件摆放在桌子上。我们会有控制器、GPS和新设备，也连接了手机和桌子。由于计算机无法直接要求，你可以直接看到电力并去操作它们。这个测试服务器是为了共享所有节点，并控制一些开关。这是一个非常好的恢复测试方式。

使用 Pytest 进行自动化测试 🐍

我们进行测试使用 Pytest。我们有许多不同的测试。Pytest 允许我们由测试数据和测试函数定义测试。我们定义一个功能，你可以在某个时刻运行设置步骤，然后执行测试并验证产出。

以下是一个简单的 Pytest 测试示例结构：

def test_something():
    # 设置步骤
    setup_data = do_setup()
    # 执行操作
    result = perform_operation(setup_data)
    # 断言验证
    assert result == expected_value

测试的另一个重要部分是测试数据的依赖和构建顺序。我们定义了它，我们可以依赖它。测试数据可以依赖其他测试数据。这由依赖图定义，决定了测试的执行效率。

我们可以在模块级别运行测试。就像我们想切换一个配置时，我们可以取出电源。并通过该文件中的测试数据运行它。如果你想做一次性测试数据，那么你想切换这些数据。然后通过参数化测试运行。

参数化测试与模拟 🔄

我们可以通过在我们的测试案例中定义三个不同的文件夹来实现参数化测试。一次是整体，一次是平面侧，我们称之为集成测试导向的数据在这个环境中，而在一个总线文件中，我们可以在其中一个文件夹中定义我们的测试案例，然后只需将其导入到另一个中。

这是逻辑发生的地方，我们定义了相同的测试，在三个不同的环境中运行。例如，一个测试是针对所有硬件，另一个测试是针对模拟环境。我们希望处理一个开关，这样我们就能关闭那个真实的开关。然后，我们总是这样做，然后在环境的两侧整合它。

这个过程需要将命令发送到总线。而在底部，我们称之为用户。现在，这个测试变得非常简单。它只需在不同的环境中测试命令。

处理复杂系统：多数投票与参数化 🗳️

在其他情况下，我们需要优先考虑测试。在这些情况下，我们的飞行系统有很多层次的冗余。例如，我们有两个控制器节点。它们都来自不同的接收器，并且是双冗余的。在相同的时间可以单独在测试中发起。在每个节点中，它也在查看三种不同分离情况的多数投票。

所以，有很多组合方式。解决这个问题的方法是对这些测试进行参数化。因为所有这些都是写好的命令。我们可以有不同的测试来运行完整的组合。我们实现了所有组合的乘法。这里只是有不同的参数组，来进行这些测试。它能很好地减少测试代码的重复。

模拟时间与异步操作 ⏲️

有时候这还不够。有时候，我们需要让测试变得更简单。例如，在测试中模拟时间流逝。一个航天器指令可能只是几个请求，但没有像阻塞等待响应那样的东西。所以，我们将进入，并且我们只需等待直到状态改变。我们不想等到真实50小时的时间。

所以，每当有上下文测量时。我们称之为“数量”，然后有上下文，这只是一个模拟器。策略由一位策略引擎收集，运行在一个单独的线程上。现在我们可以提供一个生成器，可以将所有这些问题引导到一个状态函数上。然后，在某些时候，它是非常相关的。我们可以将其包装以便进行处理。

总结 🎯

本节课中我们一起学习了使用 Pytest 测试航天器软件的核心要点。

我们首先认识了航天软件高信用质量、低请求量的独特挑战，这与常规网络服务截然不同。通过历史案例，我们理解了操作环境与生产环境一致的重要性，以及软件缺陷可能带来的巨大代价。

接着，我们探讨了如何通过跨越“原则”的集成测试来填补测试缺口，并讨论了在单次关键任务背景下，建立足够信心的必要性与成本考量。我们还了解了监管与审计对测试流程的要求。

最后，我们深入到了实践环节，学习了如何构建从桌面到“类飞行”的分层测试环境，并详细介绍了如何利用 Pytest 框架进行自动化测试，包括测试定义、数据依赖、参数化测试以覆盖复杂冗余系统，以及模拟时间和异步操作等关键技术。

通过本教程，希望你能够理解航天级软件测试的严谨性，并掌握使用现代测试工具来应对这些挑战的基本方法。

028：突变测试入门指南 🧬

在本节课中，我们将要学习一种名为“突变测试”的高级软件测试技术。我们将了解它的核心思想、工作原理、如何执行以及它的优缺点。通过学习，你将能够理解如何利用突变测试来评估和改进你的测试套件的质量。

什么是突变测试？🤔

上一节我们介绍了课程概述，本节中我们来看看突变测试的基本定义。

突变测试是一种评估测试套件质量的测试方法。它通过故意在源代码中引入小错误（称为“突变”），然后运行现有的测试套件，来检查这些测试是否能发现这些错误。

它的核心思想是：一个好的测试套件应该能够“杀死”绝大多数被故意引入的缺陷。如果测试套件无法检测到某个突变（即突变“存活”了），则说明测试套件存在不足，可能遗漏了某些场景的测试。

突变测试如何工作？⚙️

理解了基本概念后，我们深入了解一下突变测试的具体工作流程。

突变测试的过程可以概括为以下几个步骤：

创建原始程序：从一个被认为是正确的程序开始。
生成突变体：使用“突变算子”自动在原始程序中制造小的、语法正确的变化，从而创建出许多有缺陷的程序版本，每个版本称为一个“突变体”。例如，将 > 改为 <，或将 + 改为 -。
运行测试套件：对每一个生成的突变体，运行你为原始程序编写的测试套件。
分析结果：
- 如果针对某个突变体的测试失败了，则称该突变体被“杀死”。这表明测试套件检测到了这个缺陷。
- 如果针对某个突变体的测试全部通过，则称该突变体“存活”了。这表明测试套件未能发现这个缺陷，存在测试漏洞。

一个测试套件的有效性可以通过突变分数来衡量，其公式为：

突变分数 = (被杀死的突变体数量 / 总突变体数量) * 100%

分数越高，说明测试套件发现缺陷的能力越强。

常见的突变算子 🔧

我们已经知道了突变测试的流程，那么具体有哪些制造缺陷的方法呢？以下是几种常见的突变算子示例：

算术运算符替换：例如，将 + 替换为 -，* 替换为 /。

// 原始代码
result = a + b;
// 突变后代码
result = a - b;

关系运算符替换：例如，将 > 替换为 >=，== 替换为 !=。

// 原始代码
if (x > y) { ... }
// 突变后代码
if (x >= y) { ... }

逻辑运算符替换：例如，将 && 替换为 ||。
常量值修改：例如，将数字 1 改为 0，或将 true 改为 false。
语句删除：直接删除某一行代码。

突变测试的价值与挑战 ⚖️

了解了如何执行突变测试后，我们来客观地分析一下它的优点和面临的挑战。

主要优点

以下是突变测试带来的核心价值：

评估测试有效性：它直接衡量测试套件发现真实缺陷的能力，而不仅仅是代码执行覆盖率。
发现测试用例的盲点：存活的突变体明确指出哪些代码变化未被测试覆盖，帮助开发者编写更有针对性的测试。
提高代码质量意识：促使开发者思考代码的健壮性和各种边界条件。

主要挑战

然而，突变测试也并非完美，以下是它面临的一些挑战：

计算成本高：需要为每个突变体运行整个测试套件，对于大型项目，可能生成成千上万个突变体，非常耗时。
等价突变问题：有些突变体在功能上与原始程序完全等价，导致它们永远无法被杀死，这会干扰分数计算的准确性。
```
// 示例：一个等价突变
// 原始代码
int x = 0;
// 突变后代码 (将 0 改为 1-1，功能等价)
int x = 1 - 1;
```
需要专业的工具支持：需要借助特定的突变测试框架（如 Java 的 PITest，Python 的 MutPy）来自动化整个过程。

总结 📝

本节课中我们一起学习了突变测试的核心知识。我们了解到，突变测试是一种通过故意引入缺陷（突变）来评估测试套件有效性的强大技术。它通过生成突变体、运行测试并计算突变分数来工作，能够有效地揭示测试用例的不足。尽管它存在计算成本高和等价突变等挑战，但它为衡量和提升测试质量提供了一个独特的、以缺陷为中心的视角。将突变测试作为传统测试覆盖率的补充，可以帮助我们构建更可靠、更健壮的软件系统。

029：使用VS Code超级充电你的Python开发环境 🚀

在本节课中，我们将学习如何利用Visual Studio Code的强大功能来配置一个高效、便捷的Python开发环境。我们将从基础设置开始，逐步介绍如何安装必要的扩展、配置调试器、管理虚拟环境以及使用代码片段等功能，帮助你显著提升编码效率。

概述

Visual Studio Code是一款轻量级但功能强大的源代码编辑器，通过安装合适的扩展，它可以变成一个全功能的Python集成开发环境。本节课将指导你完成核心配置步骤。

P29：1：安装与基础配置 ⚙️

首先，你需要从官方网站下载并安装Visual Studio Code。安装完成后，启动VS Code。

接下来，我们需要安装Python扩展。这是VS Code支持Python开发的核心。

以下是安装Python扩展的步骤：

点击左侧活动栏的“扩展”图标（或使用快捷键 Ctrl+Shift+X）。
在搜索框中输入“Python”。
找到由Microsoft发布的“Python”扩展，点击“安装”按钮。

安装完成后，VS Code将具备Python语法高亮、代码补全等基础功能。

P29：2：选择Python解释器 🐍

为了让VS Code知道使用哪个Python环境来运行和调试代码，我们需要设置Python解释器。

上一节我们安装了Python扩展，本节中我们来看看如何选择解释器。

在VS Code底部状态栏，你可以找到一个显示Python版本或“选择Python解释器”的区域。点击它。

以下是选择解释器的步骤：

点击状态栏的Python环境指示器。
VS Code会扫描你系统中所有可用的Python解释器（包括系统安装的、虚拟环境中的、Anaconda环境等）。
从弹出的列表中选择你想要使用的Python解释器。

选择后，状态栏会更新显示当前选中的解释器路径。这个设置是针对当前工作区（文件夹）的。

P29：3：创建与使用虚拟环境 🌐

在Python项目中，使用虚拟环境来隔离依赖是一个最佳实践。VS Code可以方便地创建和管理虚拟环境。

上一节我们配置了Python解释器，本节中我们来看看如何创建虚拟环境。

你可以使用终端在项目文件夹内创建虚拟环境。核心命令是：

python -m venv .venv

这会在当前目录下创建一个名为 .venv 的虚拟环境文件夹。

创建完成后，你需要激活它。在VS Code中，最简单的方法是重新打开命令面板（Ctrl+Shift+P），输入“Python: Select Interpreter”，然后选择刚刚创建的 .venv 环境下的 python.exe。

P29：4：安装与管理包 📦

在激活的虚拟环境中，你可以使用VS Code内置的终端来安装项目所需的Python包。

VS Code的终端会自动继承当前工作区选择的Python环境。这意味着在终端中运行 pip 命令会直接作用于你选中的虚拟环境。

以下是常用的包管理命令：

安装包：pip install package-name
从文件安装：pip install -r requirements.txt
列出已安装包：pip list

你可以通过运行这些命令来管理项目的依赖。

P29：5：运行与调试代码 🐞

VS Code提供了强大的运行和调试功能。你无需离开编辑器即可执行代码并排查错误。

首先，打开一个Python文件（例如 app.py）。要运行它，你可以：

点击右上角的“运行”三角按钮。
在代码编辑区内右键，选择“在终端中运行Python文件”。
使用快捷键 Ctrl+F5（仅运行）。

对于调试，你需要先设置断点。在代码行号的左侧点击，会出现一个红点，这就是断点。

以下是启动调试的步骤：

点击左侧活动栏的“运行和调试”图标（或按 F5）。
首次调试时，VS Code会提示你创建一个 launch.json 调试配置文件。选择“Python File”即可。
配置完成后，再次按 F5，程序会在你设置的断点处暂停。此时你可以查看变量值、单步执行代码。

P29：6：使用代码片段与快捷编辑 ✂️

代码片段是预定义的代码模板，可以快速插入常用代码结构，节省输入时间。

VS Code为Python内置了一些代码片段，例如输入 def 后按Tab键，会自动生成一个函数定义框架。

你还可以安装更多片段扩展，或者自定义自己的代码片段。通过“文件”->“首选项”->“用户片段”，然后选择“python.json”来编辑。

另一个高效功能是“多光标编辑”。按住 Alt 键并用鼠标点击，可以创建多个光标，同时编辑多处文本。这对于批量修改变量名等操作非常有用。

P29：7：探索更多强大扩展 🔌

除了核心的Python扩展，VS Code市场还有许多其他扩展能进一步提升你的开发体验。

上一节我们介绍了代码片段，本节中我们来看看其他有用的扩展。

以下是一些推荐的Python开发相关扩展：

Pylance：微软出品，提供超快的语言服务器支持，拥有卓越的代码补全、类型检查和智能提示功能。
Python Docstring Generator：自动为函数和类生成文档字符串模板。
Python Test Explorer：在侧边栏集成测试运行器，方便运行单元测试。
GitLens：增强VS Code内置的Git功能，可以直观地查看代码作者、历史记录。

你可以在扩展市场中搜索并安装它们。

总结

本节课中我们一起学习了如何使用VS Code配置一个强大的Python开发环境。我们从安装Python扩展开始，逐步设置了Python解释器、创建了虚拟环境，并掌握了运行、调试代码的基本方法。最后，我们还介绍了代码片段和一些能极大提升效率的扩展插件。

通过合理配置VS Code，你可以让Python开发过程变得更加流畅和高效。建议你根据自己的编码习惯，继续探索和定制你的编辑器设置。

030：如何提升整个系统的安全性 🔒

在本节课中，我们将要学习软件安全中的一个核心概念——“滑坡效应”，并探讨如何通过系统性的方法来提升整个软件项目的安全性。我们将从理解问题的重要性开始，逐步深入到具体的实践方法。

概述 📋

软件安全不仅仅是修复漏洞，更是一个需要贯穿整个开发周期的系统性工程。本节课程将引导你理解安全问题的本质，学习如何评估风险，并掌握构建更安全软件的基本策略。

P30：1：为什么软件安全很重要？🤔

首先，我们需要理解软件安全为何至关重要。软件中的安全缺陷可能导致数据泄露、服务中断甚至财务损失。忽视安全问题，就如同在松软的斜坡上建造房屋，微小的疏忽可能导致灾难性的“滑坡”。

一个安全的软件产品是其成功的基础。它能够保护用户数据，维持业务连续性，并建立用户信任。因此，理解安全是什么以及它需要做什么，是我们处理所有后续问题的基础。

P30：2：理解安全风险与“滑坡效应” ⚠️

上一节我们介绍了安全的重要性，本节中我们来看看核心的安全风险模型——“滑坡效应”。这个概念描述了系统中一个微小的、低优先级的漏洞，如何可能像雪球一样滚下山坡，最终引发严重的、高影响的安全事件。

我们可以用一个简单的公式来评估风险：
风险 = 可能性 × 影响

以下是基于此模型的风险分类：

低可能性，低影响：这类问题通常可以稍后处理。
高可能性，低影响：需要关注，可能影响用户体验。
低可能性，高影响：必须高度重视，尽管发生概率低，但后果严重。
高可能性，高影响：最高优先级，需要立即解决。

我们的目标是在问题处于“低可能性、低影响”的早期阶段就识别并处理它们，防止其演变成高风险的“滑坡”。

P30：3：如何系统性提升安全性？ 🛠️

理解了风险模型后，我们来看看如何在实际工作中提升安全性。提升安全性并非一蹴而就，而是需要融入开发流程的每一个环节。

关键在于建立一个共享的技术语言和沟通框架。当团队中的每个人——开发者、测试人员、项目经理——都能使用相同的术语和逻辑来讨论安全问题时，识别和修复漏洞的效率将大大提高。

以下是构建这种系统性安全方法的几个要点：

从小处着手：可以从一个具体的、小的安全改进点开始实践，例如在代码审查中加入安全检查项。
建立通用设计：为常见的安全问题（如输入验证、身份认证）制定团队内通用的解决方案和代码规范。
利用新工具与平台：采用能够提供安全洞察的自动化工具，例如静态代码分析（SAST）或依赖项扫描工具。
持续沟通与教育：在团队内部持续讨论安全问题，将安全视为产品功能的一部分，而非事后补救措施。

通过这种方式，我们可以为我们的问题建立一个强大的技术防御系统。

P30：4：实践：从概念到产品 🚀

上一节我们讨论了系统性的方法，本节我们将关注如何将这些概念落地到具体的产品开发中。将安全思维融入产品生命周期，意味着从项目伊始就考虑安全。

首先，在项目启动阶段，就需要识别可能的安全需求。你可以通过建立一个“威胁模型”来探讨系统可能面临的风险。这有助于在架构设计阶段就做出更安全的选择。

在开发过程中，坚持使用我们建立的共享安全语言和框架。例如，在代码中：

# 不安全的做法：直接拼接用户输入
query = “SELECT * FROM users WHERE id = ” + user_input

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/43f46494448bc315ed4f115bbb4dc1ff_5.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/43f46494448bc315ed4f115bbb4dc1ff_7.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/43f46494448bc315ed4f115bbb4dc1ff_9.png)

# 更安全的做法：使用参数化查询
query = “SELECT * FROM users WHERE id = %s”
cursor.execute(query, (user_input,))

这种实践降低了安全漏洞被引入代码库的可能性。最终，一个安全的软件产品是通过无数个这样的正确决策累积而成的。

总结 🎯

本节课中我们一起学习了软件安全中的“滑坡效应”及其重要性。我们了解到，安全风险可以通过可能性 × 影响的模型进行评估。要提升整个系统的安全性，关键在于建立团队共享的安全语言和系统性的实践方法，包括从小处着手、制定通用设计、利用工具以及持续沟通。

记住，软件安全是一个持续的过程，而非一个最终状态。通过将安全思维融入每一天的开发工作，我们可以有效地防止“滑坡”，构建出更可靠、更值得信赖的软件产品。

031：如何避免机器学习代码出错 🛡️

在本节课中，我们将学习如何避免机器学习代码中常见的错误。我们将探讨从数据准备到模型部署的整个流程中可能遇到的问题，并提供实用的检查清单和最佳实践，帮助你构建更健壮、更可靠的机器学习系统。

数据准备与检查 📊

数据是机器学习项目的基石。错误或不一致的数据会导致模型性能低下甚至完全失败。因此，在开始建模之前，必须对数据进行彻底的检查和预处理。

上一节我们介绍了课程概述，本节中我们来看看数据准备阶段的关键步骤。

以下是数据准备阶段必须执行的核心检查项：

检查数据完整性：确认数据集中没有缺失值。如果存在缺失，需要决定是删除、填充还是采用其他处理方式。
验证数据格式：确保所有特征的数据类型符合预期（例如，数值型、分类型、日期时间型）。
检测异常值：识别并处理那些远离数据主体分布的极端值，它们可能代表录入错误或特殊情况。
确保标签一致性：对于分类任务，检查所有样本的标签都来自预定义的类别集合。

特征工程与选择 🔧

特征工程是将原始数据转化为更能代表预测模型潜在问题的特征的过程。好的特征能够显著提升模型性能。

在确保数据质量之后，我们需要将原始数据转化为有效的特征。本节中我们来看看特征工程中的注意事项。

以下是进行特征工程时需要关注的重点：

避免数据泄露：确保在生成特征时没有使用到未来的信息或测试集的信息。这通常要求严格按时间顺序划分数据或在交叉验证中小心处理。
进行特征缩放：对于基于距离的算法（如SVM、KNN）或使用梯度下降的模型，将特征缩放到相近的范围（如[0, 1]或均值为0，方差为1）非常重要。常用方法包括MinMaxScaler和StandardScaler。
处理分类变量：将非数值的类别变量转换为模型可以理解的数值形式，例如使用独热编码（One-Hot Encoding）或标签编码（Label Encoding）。
评估特征重要性：使用模型（如随机森林）或统计方法评估各个特征对预测的贡献度，并考虑移除不重要的特征以防止过拟合。

模型训练与验证 🧪

模型训练是机器学习流程的核心。在此阶段，我们需要选择合适的算法，调整其参数，并客观地评估其性能。

准备好特征后，下一步就是训练模型。本节中我们来看看如何正确地进行模型训练与验证。

以下是模型训练与验证阶段的关键实践：

划分数据集：始终将数据划分为训练集、验证集和测试集。训练集用于训练模型，验证集用于调整超参数，测试集用于最终评估模型在未见数据上的表现。常用比例是60%/20%/20%或70%/15%/15%。
使用交叉验证：当数据量有限时，使用K折交叉验证（K-Fold Cross Validation）可以更稳健地评估模型性能。它将训练集分成K份，轮流将其中一份作为验证集，其余作为训练集。
监控过拟合与欠拟合：通过观察训练集和验证集上的损失（Loss）或准确率（Accuracy）曲线来判断。如果训练集性能远好于验证集，可能是过拟合；如果两者都很差，可能是欠拟合。
保存随机种子：为了结果的可复现性，在代码开头固定随机种子（Random Seed）。例如在Python中：
```
import numpy as np
import random
import torch
np.random.seed(42)
random.seed(42)
torch.manual_seed(42)
```

代码质量与部署 🚀

写出清晰、可维护的代码并成功部署模型，是项目从实验走向应用的最后一步。

在模型通过验证后，我们需要考虑如何将其转化为可用的产品。本节中我们来看看代码质量与部署的要点。

以下是确保代码质量和顺利部署的建议：

编写模块化代码：将数据加载、预处理、训练、评估等步骤封装成独立的函数或类，提高代码的可读性和复用性。
添加日志与异常处理：在关键步骤记录日志，并捕获可能出现的异常（如文件不存在、网络错误），使调试和监控更容易。
进行单元测试：为数据处理、特征工程和模型推理等核心函数编写测试，确保它们在不同情况下都能正确工作。
版本控制：使用Git等工具对代码、模型和重要的数据集进行版本管理。
模型序列化与加载：使用如pickle、joblib或框架自带的保存方法（如PyTorch的torch.save）将训练好的模型保存到磁盘，并确保在部署环境能正确加载。
考虑线上服务：如果模型需要提供实时预测，可以考虑使用Web框架（如Flask、FastAPI）将其封装成API服务，或使用专门的机器学习部署平台。

总结 📝

本节课中我们一起学习了如何系统性地避免机器学习代码出错。我们从数据准备开始，强调了检查数据质量和一致性的重要性；接着探讨了特征工程，提醒注意数据泄露和特征缩放；然后深入模型训练与验证，讲解了数据集划分、交叉验证和过拟合监控；最后，我们关注了代码质量与部署，包括编写可维护的代码、添加测试以及模型上线的注意事项。

记住，构建可靠的机器学习系统是一个迭代和严谨的过程。遵循这些最佳实践，建立完整的检查清单，将帮助你更早地发现错误，节省调试时间，并最终交付更高质量的模型。

032：每个解释器的GIL与并发并行

概述

在本节课中，我们将要学习Python中一个核心但常被误解的概念——全局解释器锁（GIL）。我们将探讨GIL是什么，它如何影响Python的并发与并行执行，以及“每个解释器一个GIL”这一新特性如何为解决相关问题提供了新的思路。课程内容将力求简单直白，适合初学者理解。

什么是GIL？🔒

全局解释器锁（GIL）是CPython解释器（Python最常用的实现）中的一个机制。它的核心作用是确保同一时刻只有一个线程可以执行Python字节码。

这听起来可能有些限制，它的设计初衷是为了简化CPython的内存管理，因为CPython使用引用计数来管理内存。如果没有GIL，多个线程同时修改同一个对象的引用计数会导致数据竞争和不一致。

我们可以用一个简单的公式来理解GIL的核心约束：

在任意时刻 t，执行中的Python线程数 ≤ 1

这意味着，即使在多核CPU上运行多线程Python程序，这些线程也无法真正地并行执行（即同时利用多个CPU核心）。它们只能并发地执行（即快速切换，看起来像是在同时运行）。

上一节我们介绍了GIL的基本定义，本节中我们来看看它带来的具体影响。

并发 vs. 并行 🏃‍♂️🏃‍♀️

理解GIL的关键在于区分“并发”和“并行”这两个概念。

并发：指系统具有处理多个任务的能力。这些任务在时间上重叠，通过快速切换来执行，但在任一瞬间可能只有一个任务在实际占用CPU。这就像一位厨师同时照看几口锅。
并行：指系统具有同时执行多个任务的能力，这通常需要多个CPU核心。这就像多位厨师同时烹饪不同的菜肴。

在带有GIL的标准CPython中，多线程可以实现并发，但无法实现真正的并行。对于I/O密集型任务（如网络请求、文件读写），线程在等待I/O时会释放GIL，因此多线程依然能显著提升程序效率。但对于CPU密集型任务（如科学计算、图像处理），多线程无法充分利用多核优势，性能提升有限甚至可能因切换开销而下降。

以下是两种任务类型的简单示例：

I/O密集型任务示例（多线程有效）

import threading
import time

def download(url):
    time.sleep(2)  # 模拟网络I/O等待
    print(f"Downloaded {url}")

urls = ["url1", "url2", "url3", "url4"]
threads = []
for url in urls:
    t = threading.Thread(target=download, args=(url,))
    t.start()
    threads.append(t)

for t in threads:
    t.join()
# 四个任务并发执行，总时间约2秒，而非8秒。

CPU密集型任务示例（多线程受GIL限制）

import threading

def calculate():
    sum = 0
    for i in range(100000000):  # 大量计算
        sum += i

threads = []
for _ in range(4):
    t = threading.Thread(target=calculate)
    t.start()
    threads.append(t)

for t in threads:
    t.join()
# 由于GIL存在，四个线程无法并行计算，总执行时间可能接近单线程的4倍。

“每个解释器的GIL”新模型 🆕

传统CPython中，整个进程只有一个GIL，这是多线程并行计算的根本瓶颈。Python 3.12引入了一项重要特性（通过--disable-gil编译标志或C-API）：支持每个子解释器拥有独立的GIL。

这意味着什么呢？我们可以创建多个子解释器，每个子解释器都有自己的GIL和独立运行环境。由于GIL不再共享，绑定在不同子解释器上的线程就可以实现真正的并行执行。

这个概念可以用以下模型表示：

旧模型（单GIL）：
进程（1个GIL） <- 绑定 -> 线程1，线程2，线程3...（串行执行字节码）

新模型（多GIL）：

进程
├── 子解释器1（拥有GIL-1） <- 绑定 -> 线程A（可并行）
├── 子解释器2（拥有GIL-2） <- 绑定 -> 线程B（可并行）
└── 子解释器3（拥有GIL-3） <- 绑定 -> 线程C（可并行）

上一节我们看到了GIL对并行的限制，本节中我们来看看“每个解释器的GIL”如何打开新局面。

如何利用“每个解释器的GIL”

要利用此特性，通常需要使用_xxsubinterpreters模块（或相应的C-API）来创建和管理子解释器。以下是一个高度简化的概念流程：

创建子解释器：在主解释器中，创建多个新的子解释器。每个都是一个隔离的Python运行环境。
在线程中运行：将不同的线程分别绑定到不同的子解释器上。
并行执行：由于每个子解释器有自己的GIL，这些线程现在可以绕过全局GIL的限制，在多个CPU核心上真正并行执行Python代码。
通信：子解释器之间的内存是隔离的，需要通过特殊的通道（Channel）机制来传递数据，不能直接共享对象。

以下是关键步骤的代码示意：

# 注意：此为概念性代码，实际API可能更复杂
import _xxsubinterpreters as interpreters
import threading

def worker(interp_id):
    # 在该子解释器中运行代码
    interpreters.run_string(interp_id, "print('Running in parallel!')")

# 创建两个子解释器
interp1 = interpreters.create()
interp2 = interpreters.create()

# 创建两个线程，分别绑定到不同的解释器
t1 = threading.Thread(target=worker, args=(interp1,))
t2 = threading.Thread(target=worker, args=(interp2,))

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5044493af2e89449757926f881cf4f55_5.png)

t1.start()
t2.start()
t1.join()
t2.join()
# 两个线程中的Python代码可能在不同CPU核心上并行执行。

总结

本节课中我们一起学习了Python全局解释器锁（GIL）的核心机制。我们明确了GIL导致CPython多线程只能实现并发而非并行，尤其影响CPU密集型任务。接着，我们探讨了Python 3.12及以后版本中“每个解释器一个GIL”的新模型，它通过创建多个拥有独立GIL的子解释器，为实现真正的多线程并行计算提供了可能。虽然这需要更复杂的编程模型（隔离内存、显式通信），但它标志着Python在克服历史性瓶颈、拥抱现代多核架构道路上迈出了关键一步。

对于初学者，当前在CPU密集型任务中，使用multiprocessing（多进程）模块仍然是更简单直接的并行化方案。而“每个解释器的GIL”特性则为库开发者和高阶用户提供了新的强大工具。

033：如何用Python支持詹姆斯·韦伯太空望远镜的科学 🚀

在本教程中，我们将学习Python编程语言如何成为詹姆斯·韦伯太空望远镜科学数据处理与分析的核心工具。我们将探讨Python在科学计算领域的优势，并了解其在天文数据处理中的具体应用。

Python与韦伯望远镜科学：P33-1：Python在天文学中的角色 🛰️

Python已成为现代天文学研究不可或缺的工具。其简洁的语法和强大的生态系统，特别是科学计算库，使其非常适合处理韦伯望远镜产生的海量、复杂数据。

上一节我们介绍了Python在天文学中的重要性，本节中我们来看看Python生态系统中的核心科学计算库。

以下是Python科学计算的核心库：

NumPy：提供高性能的多维数组对象和数学函数，是几乎所有科学计算的基础。例如，处理图像数据可以表示为 data = np.array(image_pixels)。
SciPy：建立在NumPy之上，提供更高级的科学计算功能，如积分、优化、信号处理和统计分析。
Astropy：天文学专属的Python库，提供了处理天文数据、坐标、时间、表格和图像的标准方法。它是连接Python与韦伯望远镜数据的关键桥梁。
Matplotlib：用于创建高质量的静态、动态和交互式可视化图表，是展示和分析数据结果的主要工具。

Python与韦伯望远镜科学：P33-2：处理韦伯望远镜数据的工作流 🔭

韦伯望远镜的数据处理是一个多步骤的流程，从原始数据到最终的科学发现。Python在这一流程的每个环节都发挥着作用。

上一节我们了解了Python的基础工具，本节中我们来看看处理韦伯望远镜数据的典型工作流。

以下是数据处理的关键步骤：

数据获取与读取：使用astropy.io.fits模块读取韦伯望远镜传回的FITS格式文件。代码示例如下：

from astropy.io import fits
hdul = fits.open(‘jwst_observation.fits’)
data = hdul[1].data # 假设科学数据在第一个扩展HDU中

数据校准与减除：去除仪器效应，如暗电流、偏置和平场。这通常涉及使用校准文件和numpy进行数组运算，例如 calibrated_data = (raw_data - dark_current) / flat_field。
天文测量：测量天体的位置、亮度和形状。Photutils库（Astropy项目的一部分）常用于进行测光分析。
光谱分析：对于光谱数据，使用specutils库提取、校准和分析光谱线，以研究天体的化学成分、红移和物理状态。
数据可视化与发布：使用Matplotlib或Plotly创建图表，并使用Astropy的模块将结果保存为标准格式或生成报告。

Python与韦伯望远镜科学：P33-3：社区与可重复性研究 👥

Python的开源特性极大地促进了天文学界的协作和科学研究的可重复性。

上一节我们探讨了数据处理的技术流程，本节中我们来看看Python如何支持科学社区的协作。

以下是Python促进科学协作的方式：

共享代码与笔记本：研究者可以通过Jupyter Notebook分享包含代码、图表和文字说明的完整分析流程，使同行能够完全复现其结果。
统一的工具链：Astropy等核心库为天文学提供了标准化的数据处理方法，减少了因使用不同私有软件造成的沟通障碍和错误。
开放科学：结合GitHub等平台，Python项目使得从数据处理到论文撰写的整个研究过程更加透明和开放。

Python与韦伯望远镜科学：P33-4：面向初学者的起点 🎯

对于希望参与韦伯望远镜科学或天文学研究的初学者，可以从以下几个步骤开始。

上一节我们看到了Python对科学社区的贡献，本节中我们为初学者提供一些实用的起步建议。

以下是给初学者的学习路径建议：

学习Python基础：掌握变量、循环、函数和基本数据结构。
熟悉科学计算栈：重点学习NumPy数组操作和Matplotlib绘图。
深入Astropy：通过官方文档和教程，学习如何使用Astropy处理FITS文件、坐标转换和天文表格。
探索实际数据：访问太空望远镜科学研究所等机构的数据档案馆，尝试下载并处理真实的韦伯望远镜公开数据。
参与社区：加入Astropy或相关科学Python社区，通过邮件列表、论坛和教程学习并提问。

本节课中我们一起学习了Python如何作为关键工具支持詹姆斯·韦伯太空望远镜的科学工作。我们从Python在天文学中的核心地位讲起，介绍了其强大的科学计算库生态系统，梳理了处理韦伯望远镜数据的标准工作流，并探讨了Python如何促进开放、可重复的科学协作。最后，为有志于此的初学者规划了一条清晰的学习路径。掌握这些工具，你将有能力探索宇宙最前沿数据中隐藏的奥秘。

034：在浏览器中运行Python的魔力 🪄

在本节课中，我们将学习一个名为PyScript的新技术。它允许我们直接在网页浏览器中编写和运行Python代码，无需服务器或复杂的配置。我们将了解它的基本概念、工作原理以及如何开始使用它。

概述

PyScript是一个开源框架，它让Python能够像JavaScript一样在浏览器中运行。这为Web开发、数据科学教育和交互式应用开辟了全新的可能性。本节课将带你探索PyScript的核心魔力。

PyScript入门：P34-1：什么是PyScript？ 🤔

上一节我们介绍了PyScript的总体概念。本节中，我们来具体看看PyScript到底是什么。

简单来说，PyScript是一个允许你在HTML页面中嵌入并执行Python代码的框架。它通过将Python运行时环境（基于WebAssembly技术）加载到浏览器中来实现这一功能。

它的核心思想可以用以下伪代码表示：

<py-script>
    # 这里是你的Python代码
    print("Hello from the browser!")
</py-script>

当浏览器加载包含上述代码的页面时，它会执行其中的Python代码，并将结果显示在网页上。

PyScript入门：P34-2：PyScript的核心组件 ⚙️

了解了PyScript的基本定义后，我们来看看构成它的几个核心组件。理解这些组件有助于我们更好地使用它。

以下是PyScript的主要组成部分：

<py-script> 标签：这是用于在HTML中包裹Python代码的主要标签。所有希望在浏览器中执行的Python代码都应放在这个标签内。
<py-repl> 标签：这个标签会创建一个交互式的Python REPL（读取-求值-输出循环）环境，类似于Jupyter Notebook的单元格，允许用户直接在浏览器中输入代码并查看结果。
<py-env> 标签：用于指定你的Python代码所依赖的第三方包。PyScript会在运行时自动安装这些包。
Python运行时：一个在浏览器中运行的、完整的Python解释器，这是PyScript魔力的技术基础。

PyScript入门：P34-3：编写你的第一个PyScript程序 🚀

现在我们已经知道了PyScript的核心组件，是时候动手实践了。本节我们将创建一个最简单的“Hello World”程序。

首先，你需要在HTML文件的<head>部分引入PyScript的CSS和JavaScript文件：

<link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />
<script defer src="https://pyscript.net/latest/pyscript.js"></script>

然后，在<body>中，使用<py-script>标签来编写Python代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My First PyScript App</title>
    <link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />
    <script defer src="https://pyscript.net/latest/pyscript.js"></script>
</head>
<body>
    <h1>Testing PyScript</h1>
    <py-script>
        print("Hello, Browser World!")
        # 你甚至可以进行计算
        result = 2023 - 1991
        print(f"The result is: {result}")
    </py-script>
</body>
</html>

将上述代码保存为.html文件，然后用浏览器打开它。稍等片刻（首次加载需要下载运行时），你就能在页面上看到Python代码的输出结果了。

PyScript入门：P34-4：使用外部Python模块 📦

上一个例子展示了内联代码的写法。但在实际项目中，我们经常需要使用像numpy、matplotlib这样的强大库。本节我们来看看如何实现。

PyScript通过<py-env>标签来管理依赖。你需要在<py-script>标签之前，列出所有需要的包。

以下是一个使用numpy生成随机数并计算平均值的例子：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />
    <script defer src="https://pyscript.net/latest/pyscript.js"></script>
</head>
<body>
    <!-- 在py-env中声明依赖 -->
    <py-env>
        - numpy
    </py-env>

    <h2>Using NumPy in the Browser</h2>
    <div id="output"></div>

    <py-script output="output">
        import numpy as np

        # 生成10个随机数
        random_numbers = np.random.randn(10)
        average = np.mean(random_numbers)

        print(f"Random numbers: {random_numbers}")
        print(f"它们的平均值是: {average:.4f}")
    </py-script>
</body>
</html>

注意<py-script>标签中的output属性，它指定了代码的输出应该显示在哪个HTML元素（id=“output”的<div>）中。这是一种更结构化的输出方式。

PyScript入门：P34-5：与HTML元素交互 🖱️

PyScript真正的强大之处在于它能与网页上的其他元素（如按钮、输入框）进行交互。本节我们来探索这个功能。

PyScript提供了pyscript模块，其中的Element类允许我们轻松获取和操作DOM元素。

以下是一个简单的例子：点击按钮，将输入框中的文本显示在页面上。

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />
    <script defer src="https://pyscript.net/latest/pyscript.js"></script>
</head>
<body>
    <input type="text" id="name-input" placeholder="Enter your name">
    <button id="submit-btn" type="submit">Say Hello</button>
    <div id="greeting-output"></div>

    <py-script>
        from pyscript import Element

        def greet(*args):
            input_element = Element("name-input")
            output_element = Element("greeting-output")

            name = input_element.element.value
            if name:
                output_element.element.innerText = f"Hello, {name}!"
            else:
                output_element.element.innerText = "Please enter a name."

        # 为按钮添加点击事件监听器
        Element("submit-btn").element.onclick = greet
    </py-script>
</body>
</html>

在这个例子中，我们定义了一个greet函数，它通过Element(“id”)获取输入框和输出区域元素，然后操作它们的属性（.value和.innerText）来实现交互逻辑。

总结

本节课中我们一起学习了PyScript的基础知识。我们从了解PyScript是什么开始，认识了它的核心组件（<py-script>, <py-env>, <py-repl>）。然后，我们动手编写了第一个在浏览器中运行Python代码的程序，并学习了如何引入外部依赖库（如numpy）。最后，我们探索了PyScript与HTML DOM交互的能力，这使其能够创建动态的、响应式的Web应用。

PyScript降低了在Web中使用Python的门槛，为教育、原型设计、数据可视化等领域带来了新的工具。虽然它仍在发展中，但其展现的潜力令人兴奋。希望本教程能帮助你开启浏览器中Python编程的探索之旅。

035：如何保守秘密 🔐

在本节课中，我们将学习如何在软件开发中安全地管理秘密信息，例如API密钥、密码和令牌。我们将通过一个虚构人物杰夫的故事，了解秘密管理不当可能引发的各种安全问题，并学习构建防御体系的核心原则和实用策略。

概述：安全思维与威胁建模 🎯

上一节我们介绍了课程主题，本节中我们来看看安全思维的基础。安全不仅仅是技术问题，更是一种思维方式。作为开发者或安全工程师，你必须持续思考并假设最坏的情况。攻击者会不断尝试利用各种漏洞。

安全领域非常广泛，本次讨论将聚焦于一种特定的“秘密”：不是护照这类实物，而是软件中使用的数字凭证。保护它们需要特定的知识和实践。

核心安全模型：CIA三元组 🔒

在深入具体方法前，我们需要建立一个核心的安全框架。在信息安全领域，CIA三元组是基础模型，它代表了三个关键目标：

保密性：确保信息不被未授权访问。公式可表示为：信息 I 仅对授权集合 A 可见。
完整性：确保信息在存储或传输过程中不被未授权篡改。
可用性：确保授权用户能在需要时访问信息和资源。

如果你的秘密管理系统不可用，你就无法获取主密码，整个安全链条就会断裂。这三者缺一不可。

常见错误与威胁场景 ⚠️

理解了核心原则后，我们通过杰夫的遭遇来看看常见的错误。以下是开发者常犯的几种危及秘密安全的错误：

使用弱密码或重复使用密码：杰夫为所有账户使用简单密码。攻击者通过一个被泄露的网站密码，接管了他的整个云端基础设施。
将秘密硬编码在源代码中：杰夫将API密钥直接写在源代码文件里并提交到GitHub。自动化扫描工具立即发现了密钥，并被用于挖掘加密货币。
通过不安全的渠道传递秘密：杰夫将重置令牌通过未加密的电子邮件发送。攻击者截获邮件，获得了账户访问权。
日志记录泄露秘密：杰夫的应用程序错误地将包含API密钥的错误信息输出到了日志文件，而日志文件是公开的。
忽视备份的安全性：杰夫加密了笔记本电脑，但将未加密的备份硬盘随意放置，导致硬盘被盗后所有数据泄露。
手动复制粘贴秘密：杰夫从密码管理器中复制密码，然后粘贴到钓鱼网站上。自动填充功能可以避免此类问题。
依赖单一秘密：仅靠一个主密码保护一切。一旦它被泄露或遗忘，就会失去对所有服务的访问。

安全存储与管理策略 🛡️

看到了这么多威胁，我们应该如何防御呢？本节介绍一些保护秘密的核心策略和工具。

使用专用的密码管理器：为所有账户生成并存储强唯一密码。这解决了弱密码和重复使用密码的问题。
利用操作系统的凭证存储：例如 macOS 的 Keychain、Windows 的 Credential Manager 或 Linux 的 libsecret。它们为应用程序提供了安全存储和访问秘密的标准接口。
```
# 示例：使用keyring库（跨平台）
import keyring
keyring.set_password("my_app", "username", "top_secret_api_key")
retrieved_key = keyring.get_password("my_app", "username")
```

使用环境变量：在开发中，通过环境变量传递配置和秘密，避免硬编码。

# 在启动应用前设置环境变量
export API_KEY="your_secret_key_here"
python your_app.py

采用秘密管理服务：对于生产环境，使用如 HashiCorp Vault、AWS Secrets Manager、Azure Key Vault 等服务。它们提供集中管理、访问控制、自动轮换和审计日志。
实施多因素认证：为重要账户（如密码管理器主账户、云服务控制台）启用MFA。即使密码泄露，攻击者仍需第二因素（如手机验证码、硬件安全密钥）才能登录。
遵循最小权限原则：只为应用程序和服务分配其正常运行所必需的最小权限。不要使用拥有过高权限的密钥。

开发与运维最佳实践 ⚙️

策略需要落实到具体行动中。以下是开发和运维过程中应遵循的实践：

进行威胁建模：在项目开始时就思考：我们要保护什么？谁可能攻击我们？他们如何攻击？这有助于提前规划防御。
永远不要将秘密提交到版本控制系统：使用 .gitignore 文件忽略包含秘密的配置文件。考虑使用 git-secrets 等工具进行预提交检查。
秘密的自动扫描与轮换：集成工具自动扫描代码库中意外提交的秘密。定期轮换（更换）API密钥和密码。
安全的备份与加密：确保所有备份（无论是本地还是云端）都经过加密。加密密钥本身也需要安全保管。
谨慎处理用户输入与输出：防止秘密通过错误信息、日志或API响应意外泄露。实施严格的输入验证和输出过滤。

总结与进阶方向 🚀

本节课中，我们一起学习了软件安全中保守秘密的完整框架。

我们从建立安全思维和CIA三元组模型开始，明确了保密性、完整性和可用性的目标。随后，我们通过一系列故事场景，剖析了硬编码秘密、弱密码、不安全传输等常见错误及其严重后果。最后，我们探讨了防御策略，包括使用密码管理器、操作系统凭证库、环境变量、专业的秘密管理服务以及实施多因素认证。

记住，没有绝对的安全，只有不断提升的安全水位。你的目标是增加攻击者的成本和难度，同时确保系统的可用性。对于更复杂的系统，可以进一步探索：

零信任安全模型：从不信任，始终验证。
硬件安全模块（HSM）：为最高级别的秘密提供物理硬件保护。
服务间认证：如使用OAuth 2.0、JWT（JSON Web Tokens）代替长期有效的API密钥。

保护秘密是一场持续的战斗，但通过应用今天学到的原则和实践，你可以显著降低风险，构建更可靠的软件系统。

037：子类化与组合 🧩

在本节课中，我们将要学习面向对象编程中的两个核心概念：子类化和组合。我们将探讨它们各自的含义、优缺点，以及如何在Python中做出合适的选择，以构建更灵活、更易维护的代码。

概述

面向对象编程提供了多种代码复用和构建复杂系统的方式。其中，子类化和组合是两种最常用的技术。理解它们的区别和适用场景，对于设计良好的软件架构至关重要。

P37：1：什么是子类化？🔗

子类化是面向对象编程中实现继承的一种方式。它允许我们创建一个新类（子类），从现有类（父类）那里继承属性和方法。

子类化的核心公式可以表示为：
class SubClass(ParentClass):

这意味着SubClass是ParentClass的一种特殊形式，它自动获得了父类的所有功能，并可以添加或修改自己的行为。

上一节我们介绍了课程主题，本节中我们来看看子类化的具体含义。

子类化的特点

以下是子类化的几个关键特点：

“是一个”关系：子类与父类之间是“是一个”的关系。例如，“狗”是“动物”，“正方形”是“形状”。
代码复用：子类可以直接复用父类的代码，无需重写。
方法重写：子类可以重写父类的方法，以提供特定的实现。
紧密耦合：子类与父类紧密绑定，父类的改动可能会影响所有子类。

P37：2：什么是组合？🧱

组合是另一种代码复用技术，它通过将其他类的实例作为当前类的属性来构建更复杂的对象。它描述的是“有一个”的关系。

组合的核心代码描述如下：

class Engine:
    def start(self):
        print("引擎启动")

class Car:
    def __init__(self):
        self.engine = Engine() # Car 有一个 Engine

    def start(self):
        self.engine.start()
        print("汽车启动")

上一节我们了解了子类化，本节中我们来看看它的替代方案——组合。

组合的特点

以下是组合的几个关键特点：

“有一个”关系：组合描述的是对象之间的“有一个”关系。例如，“汽车”有一个“引擎”，“电脑”有一个“CPU”。
灵活性高：可以动态地更换组成部分。例如，可以轻松地为Car更换不同的Engine。
接口复用：复用的是对象的行为（接口），而非实现。
松耦合：各个组件之间相对独立，修改一个组件对其他部分影响较小。

P37：3：子类化 vs. 组合：如何选择？⚖️

在软件开发中，我们经常面临选择子类化还是组合的决策。这个选择没有绝对的对错，但有一些指导原则可以帮助我们。

上一节我们分别介绍了子类化和组合，本节中我们来比较它们，并学习如何做出选择。

选择指南

以下是一些帮助你做决定的关键考量点：

优先使用组合：这是现代软件设计的一个普遍原则。组合通常能带来更灵活、更松耦合的系统。
检查关系类型：如果两个类之间的关系是“是一个”，可以考虑子类化（例如Manager是Employee）。如果是“有一个”，则应该使用组合（例如Library有多个Book）。
考虑变化频率：如果父类经常变化，使用子类化可能会导致维护困难，因为所有子类都可能需要调整。组合更能适应变化。
避免深度继承：过深的继承层次会使代码难以理解和调试。组合可以帮助构建扁平化的结构。

P37：4：在Python中的实践 🐍

Python语言的设计对这两种模式都提供了良好的支持，并且由于其动态特性，在某些方面为组合提供了便利。

上一节我们讨论了选择策略，本节中我们来看看在Python中的具体实践和注意事项。

Python特有的考量

以下是在Python中使用子类化和组合时需要注意的几点：

多重继承：Python支持多重继承，这增加了子类化的能力，但也带来了“菱形继承”等复杂性，需要谨慎使用。
Mixin类：这是一种利用多重继承来实现代码复用的技术，它通常不独立使用，而是为其他类提供额外功能，可以看作是组合思想在继承体系中的一种应用。
__getattr__方法：通过重写此方法，可以实现一种动态的委托模式，这是实现组合和代理的强大工具。
鸭子类型：Python强调“鸭子类型”（如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子）。这减少了对显式继承的依赖，鼓励基于接口（方法）的设计，天然倾向于组合的思想。

总结

本节课中我们一起学习了面向对象设计中子类化与组合的核心概念。

我们了解到，子类化通过继承建立“是一个”的关系，适合表达明确的分类层次，但可能导致紧耦合。而组合通过包含对象建立“有一个”的关系，提供了更高的灵活性和松耦合性，是现代软件设计更推荐的方式。

在Python中，我们应该优先考虑使用组合，并利用鸭子类型、Mixin等语言特性来构建清晰、可维护的代码结构。记住，没有银弹，最好的设计总是依赖于具体的应用场景。

038：使用 Python 进行可重复的分子模拟 🧪

在本教程中，我们将学习如何使用 Python 实现可重复的分子模拟。我们将探讨确保模拟结果可重复性的核心概念、关键步骤以及实用的代码示例。通过本教程，你将理解如何设置随机种子、管理依赖库版本以及记录实验参数，从而让每一次模拟都能被精确复现。

1：理解可重复性 🔍

在科学研究中，可重复性意味着其他人能够使用相同的输入数据和代码，得到与你完全一致的结果。对于分子模拟而言，这至关重要，因为它确保了研究发现的可靠性和可信度。

上一节我们介绍了可重复性的重要性，本节中我们来看看在分子模拟中，哪些因素会影响结果的可重复性。

以下是影响分子模拟可重复性的几个关键因素：

随机数生成器：许多模拟算法（如蒙特卡洛方法）依赖随机数。如果随机种子不同，结果就会不同。
软件版本：不同版本的模拟软件或依赖库可能产生不同的数值结果。
系统环境：操作系统、编译器甚至硬件架构的细微差异都可能影响浮点数计算。
输入参数：模拟的初始条件、力场参数等必须被完整、准确地记录。

2：设置随机种子 🔢

确保可重复性的第一步是控制随机性。在 Python 中，我们可以通过设置随机数生成器的种子来实现这一点。这能保证每次运行程序时，生成的随机数序列完全相同。

以下是设置随机种子的代码示例，适用于常见的科学计算库：

import random
import numpy as np

# 设置Python内置random模块的种子
random.seed(42)

# 设置NumPy的随机种子
np.random.seed(42)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/7d8bc9306ec00b1bcbd5f2894f10dacb_8.png)

# 如果你使用其他库（如TensorFlow或PyTorch），也需要分别设置
# import torch
# torch.manual_seed(42)

3：管理依赖与环境 📦

仅仅固定随机种子还不够。如果运行代码的软件环境（例如库的版本）发生变化，模拟结果仍可能不同。因此，我们需要精确记录和管理项目依赖。

上一节我们固定了随机种子，本节中我们来看看如何管理项目依赖以确保环境一致性。

以下是管理Python项目依赖的推荐方法：

使用requirements.txt文件：列出所有依赖包及其精确版本。
```
numpy==1.21.0
scipy==1.7.0
mdtraj==1.9.5
```
使用虚拟环境：为每个项目创建独立的Python环境（如venv或conda），避免包冲突。
考虑容器化技术：使用Docker等工具可以将整个操作系统环境（包括库、编译器）打包，实现最高级别的可重复性。

4：记录实验参数与元数据 📝

完整的可重复性要求记录模拟的所有输入参数和条件，这些信息被称为元数据。没有这些记录，即使有代码和固定种子，也无法复现实验。

以下是应该记录的关键元数据示例：

模拟输入文件：初始结构坐标、拓扑文件、配置文件。
力场参数：使用的力场名称、版本及所有修改。
模拟参数：温度、压力、积分步长、模拟时长等。
硬件信息：CPU型号、GPU型号（如果使用）、内存大小（可选，但对性能分析有用）。

一个简单的做法是创建一个metadata.json文件与结果数据一起保存：

import json
import datetime

metadata = {
    "simulation_date": str(datetime.datetime.now()),
    "random_seed": 42,
    "software_versions": {
        "numpy": np.__version__,
        "simulation_package": "1.0.0"
    },
    "parameters": {
        "temperature_k": 300,
        "timestep_fs": 2.0,
        "num_steps": 1000000
    }
}

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/7d8bc9306ec00b1bcbd5f2894f10dacb_18.png)

with open('simulation_metadata.json', 'w') as f:
    json.dump(metadata, f, indent=4)

5：完整的可重复模拟工作流 ⚙️

现在，让我们将以上所有步骤整合到一个完整的工作流中。一个健壮的可重复模拟流程应该像运行一个配方，每次都能产出相同的结果。

以下是实现可重复分子模拟的推荐工作流步骤：

项目初始化：创建虚拟环境，并使用requirements.txt或environment.yml文件安装固定版本的依赖。
参数配置：将所有模拟参数（如温度、步长）写入一个清晰的配置文件（如config.yaml）。
设置种子：在模拟脚本的开头，明确设置所有相关随机数生成器的种子。
运行模拟：执行模拟代码，该代码读取配置文件并运行。
保存结果与元数据：将输出数据（轨迹、能量等）和包含所有输入参数、版本、种子的元数据文件一起保存。

总结 🎯

本节课中我们一起学习了如何使用 Python 实现可重复的分子模拟。我们了解到，可重复性建立在三个支柱之上：控制随机性（通过设置随机种子）、固化环境（通过管理依赖和版本）以及完整记录（通过保存所有输入参数和元数据）。通过遵循本教程中的工作流和最佳实践，你可以确保你的分子模拟研究是可靠、透明且可被他人验证的。

039：谈话 - 黎智英

概述

在本节课中，我们将学习Python大规模静态代码检查的核心概念与实践方法。静态代码检查是一种在不运行程序的情况下分析源代码以发现潜在错误、代码异味或风格问题的技术。这对于维护大型代码库的质量和一致性至关重要。

1：静态代码检查基础

上一节我们介绍了课程概述，本节中我们来看看静态代码检查的基础知识。

静态代码检查通过分析源代码的语法、结构、数据流和控制流来发现问题。它不执行代码，因此可以安全地应用于任何代码库。

以下是静态代码检查的主要优势：

早期发现问题：在代码运行前发现潜在错误。
强制执行代码规范：确保团队遵循统一的编码风格。
发现复杂漏洞：识别安全漏洞、性能瓶颈等深层问题。
提高代码可维护性：通过识别重复代码、过高复杂度等问题。

核心的检查过程可以抽象为以下公式：
静态分析结果 = 分析器(源代码, 规则集)
其中，分析器是检查工具，规则集定义了要检查的问题类型。

2：大规模分析的挑战与工具

上一节我们了解了静态检查的基础，本节中我们来看看当代码库规模变大时会遇到哪些挑战，以及有哪些工具可以应对。

对于拥有成千上万文件的大型项目，直接进行全量分析会非常缓慢，占用大量内存。主要的挑战在于分析速度和资源消耗。

为了解决这些问题，业界发展出了增量分析、分布式分析等技术。在Python生态中，有几个强大的静态分析工具。

以下是三个主流的Python静态分析工具：

Pylint：一个高度可配置的工具，专注于代码质量，能检查编码标准、错误和重构提示。
Flake8：它集成了PyFlakes（逻辑错误检查）、pycodestyle（PEP 8风格检查）和McCabe（循环复杂度检查）的功能。
MyPy：一个可选的静态类型检查器，利用Python的类型注解来检查类型错误。

你可以通过pip安装它们：

pip install pylint flake8 mypy

3：实践流程与集成

上一节我们介绍了核心工具，本节中我们来看看如何将静态检查集成到开发流程中。

一个高效的静态检查流程应该自动化，并尽可能早地介入开发过程。通常，我们将其集成到代码编辑器和持续集成（CI）流水线中。

以下是集成静态检查的推荐步骤：

本地预提交钩子：在提交代码前自动运行检查，防止有问题的代码进入仓库。可以使用pre-commit框架。
编辑器/IDE集成：在编写代码时实时获得反馈。大多数现代编辑器都支持Pylint、Flake8等工具的插件。
持续集成（CI）流水线：在代码合并前，在CI服务器（如Jenkins, GitHub Actions, GitLab CI）上运行全套检查，作为质量门禁。

例如，一个简单的GitHub Actions工作流配置片段如下：

- name: Lint with flake8
  run: |
    flake8 . --count --max-complexity=10 --statistics

4：定制规则与报告

上一节我们讨论了如何集成检查流程，本节中我们来看看如何定制检查规则并理解检查报告。

默认的规则集可能不适合所有项目。大多数工具都允许你通过配置文件来启用、禁用规则或调整其严格程度。

定制通常涉及创建配置文件（如.pylintrc， .flake8），并在其中指定参数。对于MyPy，则使用mypy.ini或pyproject.toml。

理解检查报告是解决问题的关键。报告通常会包含：

问题位置：文件名和行号。
错误代码/类型：如E101（缩进错误），C0114（缺少模块文档字符串）。
问题描述：对具体问题的说明。

面对大量警告时，应优先处理错误（Error）级别的项目，然后是警告（Warning），最后是重构提示（Refactor）。

总结

本节课中我们一起学习了Python大规模静态代码检查的完整知识。我们从静态分析的基础概念出发，探讨了大规模分析面临的挑战及主流工具（Pylint, Flake8, MyPy）。接着，我们研究了如何将检查流程自动化并集成到开发与CI/CD环节中。最后，我们了解了如何通过定制规则来满足项目需求，并学会解读分析报告以有效改进代码。掌握这些技能，将显著提升你维护大型Python项目代码质量与开发效率的能力。

040：使用线性代数和NumPy进行向量化

概述

在本节课中，我们将学习如何利用线性代数和NumPy库对Python代码进行向量化。我们将通过一个具体的机器学习算法——K近邻（KNN）的迭代改进过程，展示如何将缓慢的循环操作替换为高效的向量化运算，从而显著提升代码性能。课程将从基础概念开始，逐步深入到高级优化技巧。

1：向量与矩阵基础

上一节我们介绍了课程概述，本节中我们来看看线性代数的基础单元：向量和矩阵。

线性代数最基本的单元是向量。向量本质上是一个有序的值序列。在机器学习的上下文中，向量被用来表示数据。

例如，我们有一个描述图片物理特征的数据集。数据集中的每一行可以表示为一个向量。向量中的第一个元素可能代表“主访问长度”，第二个元素代表“次要访问长度”。

这些向量在数学上可以看作是n维空间中的坐标。以一个二维空间为例，我们可以用散点图来可视化向量，其中x轴代表第一个特征（如主访问长度），y轴代表第二个特征（如次要访问长度）。数据集中的每个样本点就是这个二维空间中的一个坐标。

虽然我们无法可视化超过三维的空间，但应用于二维向量空间的原理可以扩展到任意高维度。

矩阵则是在同一个向量空间中的一组向量。我们可以将多个向量（即数据集的多个样本）组合成一个矩阵。在NumPy中，向量和矩阵都使用“数组”这一数据结构来表示。

以下是关于NumPy数组维度的说明：

一维数组：表示一个向量。其形状（shape）是一个单元素元组，如(n,)，表示它有n个元素。
二维数组：表示一个矩阵。其形状如(m, n)，表示它有m行n列。
n维数组：可以通过重塑（reshape）一维或二维数组得到，用于表示更复杂的数据结构。例如，一个形状为(2, 3, 4)的三维数组，可以理解为2个矩阵，每个矩阵是3行4列。

2：距离度量与K近邻算法

既然我们已经讨论了向量和矩阵，本节中我们来看看向量空间的一个有用性质以及我们将要优化的算法。

向量空间的一个非常有用的性质是：彼此接近的向量往往相似，而那些距离遥远的向量则不同。测量距离的方法有很多，其中最简单的一种是曼哈顿距离。

曼哈顿距离可以这样理解：想象你在一个网格状的城市（如曼哈顿）中，只能沿着平行于x轴和y轴的道路行走。两点之间的曼哈顿距离就是你需要行走的街区总数。

其计算公式为：
对于两点 p1 = (x1, y1) 和 p2 = (x2, y2)，曼哈顿距离 d = |x1 - x2| + |y1 - y2|。

这个公式可以推广到n维空间。对于两个n维向量 a 和 b，曼哈顿距离是它们每个维度上绝对差值的总和。

公式：
distance = sum(|a_i - b_i|) for i in range(n)

K近邻（KNN） 是一种机器学习算法，用于为未知数据点预测标签。它的工作原理如下：

需要一个已标记的数据集（训练集）和一个未标记的数据集（测试集）。
对于一个测试点，计算它到训练集中每一个点的距离。
找出距离最近的K个训练点（邻居）。
查看这K个邻居的标签，将出现最频繁的标签分配给该测试点。

这个算法的计算成本较高，因为它需要为每个测试点计算到所有训练点的距离。

3：基线实现与性能分析

上一节我们介绍了KNN算法的原理，本节中我们来看看它的一个简单实现并分析其性能。

以下是KNN算法的一个简单Python实现，它使用列表和循环：

def manhattan_distance(a, b):
    """计算两个列表之间的曼哈顿距离。"""
    distance = 0
    for i in range(len(a)):
        distance += abs(a[i] - b[i])
    return distance

def knn_baseline(train_points, train_labels, test_points, k=3):
    """使用嵌套循环的KNN基线实现。"""
    predictions = []
    for test_point in test_points:
        distances = []
        # 计算到每个训练点的距离
        for i, train_point in enumerate(train_points):
            dist = manhattan_distance(test_point, train_point)
            distances.append((dist, train_labels[i]))
        # 按距离排序
        distances.sort(key=lambda x: x[0])
        # 获取前k个邻居的标签
        k_nearest_labels = [label for (_, label) in distances[:k]]
        # 找出最常见的标签
        most_common = max(set(k_nearest_labels), key=k_nearest_labels.count)
        predictions.append(most_common)
    return predictions

我们使用一个豆类特征数据集来测试性能，并将其分为三个子集：

小数据集：3个特征，约4000个观测值。
中数据集：3个特征，约27000个观测值。
大数据集：16个特征，约27000个观测值。

以下是基线实现的运行时间：

小数据集：约15秒
中数据集：约12分钟
大数据集：约40分钟

可以看到，随着数据规模和特征维度的增加，运行时间急剧上升。主要瓶颈在于嵌套循环和顺序计算。

4：第一次优化：向量化距离计算

我们分析了基线实现的性能瓶颈，本节中我们来进行第一次优化：消除计算单个距离时的循环。

核心问题在于manhattan_distance函数中的循环。我们可以利用NumPy的向量化操作来替代它。需要了解两个关键操作：

向量减法：当两个NumPy数组大小相同时，可以直接相减，结果是一个新数组，其中每个元素是对应位置元素的差。
代码：difference = array_a - array_b
元素级函数应用：可以将函数（如abs）直接应用于数组，该函数会自动作用于数组中的每个元素。
代码：abs_difference = np.abs(difference)

结合这两个操作，曼哈顿距离的计算可以向量化为：
代码：distance = np.abs(array_a - array_b).sum()

改进后的距离计算函数如下：

import numpy as np

def manhattan_distance_vectorized(a, b):
    """向量化计算两个NumPy数组间的曼哈顿距离。"""
    return np.abs(a - b).sum()

然后，我们在KNN的主循环中调用这个新函数。虽然主循环仍在，但内部的距离计算已加速。

优化后的性能对比：

小数据集：约8秒（提升约1.9倍）
中数据集：约7分钟（提升约1.7倍）
大数据集：约9分钟（提升约4.4倍）

对于大数据集提升明显，因为特征维度高，向量化收益大。但嵌套循环仍然是主要瓶颈。

5：第二次优化：广播消除嵌套循环

第一次优化后，嵌套循环成了最大的性能瓶颈。本节中我们利用NumPy的“广播”机制来消除它。

嵌套循环的问题在于计算量是测试集大小和训练集大小的乘积。对于我们的数据集，这意味著数百万甚至上亿次顺序计算。

为了同时计算所有测试点与所有训练点之间的距离，我们需要进行“成对减法”。思路如下：

将测试集视为一个矩阵（二维数组）。
将训练集也视为一个矩阵。
我们想用一个测试点减去所有训练点。通过数组重塑和广播，NumPy可以高效地执行这种批量操作。

广播是NumPy的一种机制，当对两个形状不同的数组进行运算时，它会自动将较小的数组“扩展”到与较大数组兼容的形状，而无需实际复制数据。

以下是利用广播向量化整个距离计算过程的代码：

def knn_vectorized_distances(train_points, train_labels, test_points, k=3):
    """使用广播向量化距离计算的KNN实现。"""
    # 将训练点和测试点转换为NumPy二维数组
    train_arr = np.array(train_points)  # 形状: (n_train, n_features)
    test_arr = np.array(test_points)    # 形状: (n_test, n_features)

    # 利用广播计算所有成对距离
    # 重塑test_arr为 (n_test, 1, n_features)，重塑train_arr为 (1, n_train, n_features)
    # 减法时，NumPy会自动广播，得到形状为 (n_test, n_train, n_features) 的差异数组
    differences = test_arr[:, np.newaxis, :] - train_arr[np.newaxis, :, :]

    # 计算曼哈顿距离：对最后一个维度（特征维度）取绝对值后求和
    all_distances = np.abs(differences).sum(axis=2)  # 形状: (n_test, n_train)

    predictions = []
    # 注意：排序和选取邻居的循环仍在
    for i in range(len(test_points)):
        distances = all_distances[i]
        # ... 后续排序和选取标签的代码（仍需优化）
    return predictions

这次优化带来了显著的性能提升：

小数据集：约1.5秒（比基线快10倍）
中数据集：约1分钟（比基线快12倍）
大数据集：约3分钟（比基线快13倍）

现在，计算所有距离的瓶颈已被移除。

6：最终优化：向量化排序与标签选取

距离计算已经高度优化，但算法中仍有顺序处理步骤。本节中我们来看看最后的优化：向量化排序和最近邻标签的选取过程。

剩余的两个主要瓶颈是：

排序：Python内置的list.sort()使用Timsort算法，且是单线程的。NumPy的np.sort()提供了更多算法选择（如快速排序、堆排序），并且针对同质数值数组进行了优化，速度更快。
选取最近邻标签：这本质上是一个顺序查找过程。

优化思路是：将距离和标签组合成一个结构化数组，然后利用NumPy的高级索引和切片一次性完成排序和选取。

以下是最终的向量化实现：

def knn_fully_vectorized(train_points, train_labels, test_points, k=3):
    """完全向量化的KNN实现。"""
    train_arr = np.array(train_points)
    test_arr = np.array(test_points)
    train_labels_arr = np.array(train_labels)

    # 广播计算所有距离
    distances = np.abs(test_arr[:, np.newaxis, :] - train_arr[np.newaxis, :, :]).sum(axis=2)

    predictions = []
    for i in range(len(test_arr)):
        # 获取当前测试点到所有训练点的距离
        current_distances = distances[i]
        # 使用`np.argpartition`高效找到最小的k个距离的索引
        # 它部分排序，只保证前k个是最小的，比完全排序更快
        k_nearest_indices = np.argpartition(current_distances, k)[:k]
        # 通过这些索引直接获取对应的标签
        k_nearest_labels = train_labels_arr[k_nearest_indices]
        # 使用`np.bincount`找出出现最频繁的标签（要求标签是非负整数）
        # 对于其他类型标签，可使用`np.unique(return_counts=True)`
        most_common_label = np.bincount(k_nearest_labels).argmax()
        predictions.append(most_common_label)
    return predictions

最终的性能结果令人震惊：

小数据集：约13毫秒（比基线快约1000倍）
中数据集：约1.5秒
大数据集：约15秒

通过一系列向量化操作，我们实现了性能的巨幅提升。

总结

本节课中我们一起学习了如何使用线性代数和NumPy对Python代码进行向量化。我们以K近邻算法为例，经历了完整的优化过程：

理解基础：复习了向量、矩阵、曼哈顿距离和KNN算法的概念。
建立基线：实现了一个基于列表和循环的简单版本，并认识到其在数据规模增大时的性能瓶颈。
逐步优化：
- 第一次优化：利用NumPy的数组减法和元素级运算，向量化了单个距离的计算。
- 第二次优化：利用NumPy的广播机制，一次性计算了所有测试点与所有训练点之间的距离，消除了嵌套循环。
- 最终优化：使用np.argpartition和np.bincount等向量化函数，优化了排序和最近邻标签选取的过程。

关键收获是：通过将循环操作转换为对整个数组的线性代数运算，可以极大地利用现代CPU的并行计算能力，从而提升代码效率，尤其是在处理大规模数据时。向量化是数据科学和机器学习中一项至关重要的性能优化技术。

041：对连接协议的Python式介绍 🚀

在本教程中，我们将学习MQTT协议的基础知识。MQTT是一种轻量级的消息传输协议，专为物联网设备设计。我们将了解其核心概念、工作原理，并通过Python示例来理解其应用。

概述 📖

MQTT是一种基于发布/订阅模式的轻量级消息传输协议。它设计用于在低带宽、高延迟或不稳定的网络环境中进行高效通信。协议的核心在于一个代理服务器，它负责接收和转发消息。

MQTT的核心概念 💡

发布/订阅模式

MQTT采用发布/订阅模式，而非传统的客户端-服务器模式。在这种模式下，设备不直接相互通信，而是通过一个称为代理的中间服务器。

发布者：向特定主题发送消息的设备。
订阅者：订阅特定主题以接收消息的设备。
代理：接收所有消息，并根据主题将其过滤并分发给相关订阅者的服务器。

这种模式实现了通信双方的解耦，发布者无需知道订阅者的存在，反之亦然。

主题

主题是消息的地址或路由路径。它是一个分层结构的字符串，使用斜杠 / 分隔层级。例如：home/livingroom/temperature。

订阅者可以使用通配符订阅多个主题：

+：单层通配符。例如 home/+/temperature 可以匹配 home/livingroom/temperature 和 home/bedroom/temperature。
#：多层通配符。例如 home/# 可以匹配所有以 home/ 开头的主题。

服务质量

QoS定义了消息传递的可靠性级别，共有三个等级：

QoS 0：最多一次。消息发送一次，不确认，可能丢失。
QoS 1：至少一次。消息确保送达，但可能重复。
QoS 2：恰好一次。消息确保只送达一次，最可靠但开销最大。

MQTT的工作原理 ⚙️

上一节我们介绍了MQTT的核心概念，本节中我们来看看这些概念如何协同工作。

连接建立后，客户端可以发布消息到某个主题，或订阅感兴趣的主题。代理负责将发布到某个主题的消息，转发给所有订阅了该主题的客户端。

以下是MQTT通信的基本流程：

客户端连接到代理服务器。
订阅者向代理订阅一个或多个主题。
发布者向代理的某个主题发布消息。
代理将消息转发给所有订阅了该主题的客户端。

使用Python实践MQTT 🐍

理解了理论之后，让我们通过Python代码来实践。我们将使用流行的 paho-mqtt 库。

首先，需要安装客户端库：

pip install paho-mqtt

发布者示例

以下是一个简单的MQTT发布者代码，它连接到公共代理并向主题发送消息。

import paho.mqtt.client as mqtt

# 定义回调函数
def on_connect(client, userdata, flags, rc):
    print(f"连接结果代码: {rc}")
    # 连接成功后发布消息
    client.publish("test/topic", "Hello MQTT!")

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/68f3a269f6f8c4e90b42d21cb573a94b_15.png)

# 创建客户端实例
client = mqtt.Client()
client.on_connect = on_connect

# 连接到公共MQTT代理（例如：test.mosquitto.org）
client.connect("test.mosquitto.org", 1883, 60)

# 启动网络循环，处理通信
client.loop_forever()

订阅者示例

以下是一个订阅者代码，它订阅相同的主题并打印收到的消息。

import paho.mqtt.client as mqtt

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/68f3a269f6f8c4e90b42d21cb573a94b_17.png)

# 定义连接回调函数
def on_connect(client, userdata, flags, rc):
    print(f"连接结果代码: {rc}")
    # 连接成功后订阅主题
    client.subscribe("test/topic")

# 定义消息接收回调函数
def on_message(client, userdata, msg):
    print(f"主题: {msg.topic}, 消息: {msg.payload.decode()}")

# 创建客户端实例
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

# 连接到公共MQTT代理
client.connect("test.mosquitto.org", 1883, 60)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/68f3a269f6f8c4e90b42d21cb573a94b_19.png)

# 启动网络循环
client.loop_forever()

总结 🎯

本节课中我们一起学习了MQTT协议。我们了解到MQTT是一种基于发布/订阅模式的轻量级消息协议，核心组件包括发布者、订阅者和代理。消息通过主题进行路由，并可以通过服务质量等级来控制传递的可靠性。最后，我们通过Python代码示例演示了如何创建简单的MQTT发布者和订阅者客户端。掌握这些基础知识，你就可以开始构建自己的物联网或消息传递应用了。

042：改进复杂asyncio应用的可调试性 🐛

在本节课中，我们将学习如何改进复杂asyncio应用程序的可调试性。调试异步代码通常比同步代码更具挑战性，因为涉及任务、事件循环和并发执行。我们将探讨常见的调试难点，并介绍一些实用的工具和技巧来简化这一过程。

异步调试的挑战 🤔

上一节我们介绍了课程的主题，本节中我们来看看调试异步代码时面临的主要挑战。异步编程模型引入了并发执行，这使得传统的调试方法（如单步执行）效果不佳，因为多个任务可能同时运行和切换。

以下是调试异步代码时常见的几个难点：

并发性：多个任务交错执行，难以追踪特定任务的执行流程。
非确定性：由于任务切换的时机不确定，错误可能难以稳定复现。
堆栈信息不完整：当任务在await点挂起并稍后恢复时，原始的调用堆栈信息可能丢失，使得追溯错误源头变得困难。
资源竞争与死锁：并发访问共享资源可能导致难以察觉的竞争条件或死锁。

实用的调试工具与技巧 🛠️

了解了挑战之后，我们现在可以探索一些专门用于调试asyncio代码的工具和方法。

1. 使用 asyncio.run() 与调试模式

对于简单的脚本，确保使用asyncio.run()来运行主协程。它可以正确设置和清理事件循环。更重要的是，可以启用调试模式。

import asyncio
import logging

logging.basicConfig(level=logging.DEBUG)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/e51a549fc40cd7270ffb9fb6a33681ca_5.png)

async def main():
    # 你的异步代码
    pass

if __name__ == "__main__":
    # 启用调试模式
    asyncio.run(main(), debug=True)

启用debug=True后，asyncio会执行以下操作：

检查未被await的协程并记录警告。
启用更慢但更安全的默认执行器。
当事件循环运行时间过长时记录信息。

2. 记录与监控任务状态

主动记录任务的生命周期状态是理解程序行为的关键。

以下是监控任务状态的几种方法：

打印当前所有任务：使用asyncio.all_tasks()来获取事件循环中的所有任务。

tasks = asyncio.all_tasks()
for task in tasks:
    print(f"Task: {task.get_name()}, State: {task._state}")

为任务命名：创建任务时使用name参数，使得日志输出更易读。
```
task = asyncio.create_task(my_coro(), name="MyImportantTask")
```
添加回调：使用add_done_callback在任务完成时执行特定操作，如记录结果或异常。

3. 结构化日志记录

使用logging模块而非print语句进行日志记录。为不同的组件设置日志级别，并确保日志中包含时间戳、任务名称等上下文信息。

import logging

logger = logging.getLogger(__name__)

async def fetch_data(url):
    logger.info("开始获取数据: %s", url)
    try:
        # ... 异步操作
        logger.debug("数据获取成功: %s", url)
    except Exception as e:
        logger.error("获取数据失败 %s: %s", url, e, exc_info=True)

4. 利用专门的调试器

一些IDE和外部工具提供了对asyncio的增强调试支持。

Visual Studio Code / PyCharm：现代IDE的调试器通常支持在await语句处挂起，并查看当前所有协程的状态。
aiomonitor：这是一个第三方库，可以为运行中的asyncio应用程序提供一个交互式监控台，允许你查看任务列表、取消任务或执行代码片段。

5. 编写可测试的代码

提高可调试性的根本方法是提高代码的可测试性。这将问题隔离在更小、更可控的范围内。

以下是编写可测试异步代码的建议：

依赖注入：将事件循环或客户端作为参数传递，而不是在函数内部硬编码创建，便于在测试中替换为模拟对象。
分离关注点：将业务逻辑与异步调度逻辑分离。纯业务逻辑的函数更容易进行单元测试。

使用超时：为网络调用或任务执行设置超时，防止因某个任务挂起而导致整个程序停滞。

try:
    await asyncio.wait_for(some_async_operation(), timeout=5.0)
except asyncio.TimeoutError:
    logger.warning("操作超时")

总结 📝

本节课中我们一起学习了如何改进复杂asyncio应用的可调试性。我们首先分析了异步调试的固有挑战，如并发性、非确定性和堆栈信息丢失。接着，我们介绍了一系列实用的工具和技巧，包括启用asyncio调试模式、有效监控任务状态、实施结构化日志记录、利用IDE或aiomonitor等调试工具，以及通过依赖注入和分离关注点来编写可测试的代码。掌握这些方法将帮助你更高效地定位和解决asyncio应用程序中的问题。

043：使用 Python 帮助无家可归者 🏠

在本节课中，我们将学习如何运用 Python 编程技术来解决现实世界中的社会问题，特别是关注如何帮助无家可归者群体。我们将通过一个具体的项目案例，了解数据分析、自动化工具和社区协作在公益项目中的应用。

概述

本次演讲介绍了 Josh Weissbock 和 Sheila Flood 的一个项目，他们利用 Python 技术来分析和改善无家可归者的处境。项目核心在于处理和分析相关数据，以支持更有效的决策和资源分配。

P43：1：项目背景与挑战 🎯

上一节我们概述了课程内容，本节中我们来看看项目发起的背景和面临的核心挑战。

无家可归是一个复杂的社会问题。项目团队发现，在传统的工作流程中，大量关于无家可归者的信息（如服务需求、安置情况）分散在不同的系统和记录中，难以进行整体分析和有效响应。

他们观察到，机构往往需要手动处理这些信息，这个过程效率低下，容易出错，并且无法快速识别趋势或紧急需求。因此，项目目标是创建一个基于 Python 的工具，来自动化数据处理流程，从而更高效地帮助需要援助的人。

P43：2：解决方案设计与 Python 的应用 💡

了解了挑战之后，本节我们将探讨团队如何设计解决方案，并具体介绍 Python 在其中的作用。

团队决定构建一个数据管道，用于聚合、清理和分析来自多个来源的匿名化数据。Python 因其丰富的数据处理库和灵活性被选为核心工具。

以下是项目用到的几个关键 Python 库及其作用：

pandas：用于数据清洗、转换和分析的核心库。例如，合并来自不同庇护所的数据表。

import pandas as pd
# 读取并合并数据
df_shelter_a = pd.read_csv('shelter_a_data.csv')
df_shelter_b = pd.read_csv('shelter_b_data.csv')
combined_df = pd.concat([df_shelter_a, df_shelter_b])

NumPy：提供高效的数值计算，用于处理数据中的数学运算。
Jupyter Notebook：用于交互式地探索数据、分享分析过程和结果，便于团队协作。
自动化脚本：编写 Python 脚本自动从指定源抓取更新的数据文件，并运行清洗流程。

通过应用这些工具，团队能够将杂乱的数据转化为清晰的洞察，例如识别出哪些区域的服务需求最高，或者哪些类型的援助最紧缺。

P43：3：项目实施与社区协作 🤝

上一节我们介绍了技术方案，本节中我们来看看项目是如何具体实施并融入社区协作的。

项目实施并非纯粹的技术工作，它需要与社区机构、社会工作者紧密合作。团队的工作流程可以概括为以下几个步骤：

需求沟通：与前线工作者会谈，理解他们真正的数据需求和痛点。
数据收集与匿名化：在严格遵守隐私法规的前提下，获取脱敏的原始数据。
构建处理管道：使用 Python 编写可重复运行的数据处理脚本。
生成可视化报告：将分析结果以图表形式呈现，便于非技术人员理解。
反馈与迭代：根据使用者的反馈，不断改进分析模型和报告内容。

这个过程强调协作与迭代。例如，社会工作者可能发现报告中的某个分类不符合实际情况，开发团队便会据此调整数据清洗的逻辑。

P43：4：项目影响与未来展望 ✨

在完成了核心构建后，本节我们探讨这个项目带来的实际影响以及未来的发展方向。

该项目带来的最直接改变是提升了效率。原本需要数天手动整理的数据，现在几小时内即可完成分析，让工作人员能将更多时间用于直接服务。

更重要的是，它提供了数据驱动的洞察。通过分析历史数据，机构能够更好地预测未来的服务需求，从而更合理地进行资源规划和预算申请。

展望未来，团队希望从两个方面深化项目：

以下是未来的两个重点方向：

预测模型开发：利用机器学习库（如 scikit-learn）尝试构建模型，预测个体重新获得稳定住所的可能性，以便进行早期、有针对性的干预。

# 示例：使用简单的逻辑回归模型
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# X是特征数据，y是目标变量（如“是否成功安置”）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LogisticRegression()
model.fit(X_train, y_train)

工具普及化：将工具封装得更易于使用，让更多缺乏技术背景的公益组织能够自助进行数据分析。

P43：5：总结与启示 📚

本节课中我们一起学习了如何将 Python 编程技能应用于社会公益项目。

我们从一个帮助无家可归者的具体案例出发，回顾了项目的全过程：

识别问题：发现数据处理效率低下是援助工作的一个瓶颈。
技术选型：选择 Python 及其生态系统（pandas, Jupyter）作为解决方案。
协作实施：与技术团队和领域专家（社会工作者）紧密合作，确保工具实用。
产生价值：通过自动化分析提升决策效率，并规划利用数据智能做更多预测。

这个案例的核心启示是：技术不仅是商业工具，更是推动社会向善的强大力量。掌握 Python 等技能，意味着你拥有了解决复杂社会问题、帮助社区的能力。无论你的专业背景如何，都可以思考如何利用技术为你关心的领域带来积极改变。

044：使用 MicroPython 创建互动游戏 🎮

在本教程中，我们将跟随 Juliana Karoline de Sousa 的演讲，学习如何使用 MicroPython 在 Micro:bit 微控制器上创建互动游戏。我们将从了解硬件开始，逐步学习编程方法，并最终实现三个完整的游戏示例。

演讲者介绍 👩‍💻

我叫 Juliana Karoline de Sousa，来自巴西圣卡洛斯。我拥有圣卡洛斯联邦大学的计算机科学学士学位。我参与了许多技术社区，是本地 Python 用户组的联合创始人。我的职业是软件工程师，业余时间喜欢玩机器人、乐队和我的猫。

以下是我开发过的一些项目：

智能闹钟：一个结合天气预报和谷歌日历事件的闹钟。
游戏机器人：为比赛设计的两个机器人。
避障机器人和摄像头机器人。
最新项目：一个可以用手机地图控制颜色、转动头部和移动的机器人。

这些项目大多使用了 MicroPython，这也是本次演示的核心。

认识 Micro:bit 硬件 🧩

Micro:bit 是一款信用卡大小的微控制器板，由英国 BBC 设计，旨在向学童普及计算机科学和编程。它被免费分发给公立学校的学生。

主要规格

微处理器：控制板载所有组件。
内存：包含 RAM 和闪存。
5x5 LED 点阵：用于显示图像和滚动文本。
两个可编程按钮（A 和 B）。
板载运动传感器（加速度计和磁力计）。
板载扬声器和麦克风。
边缘连接器：提供 20 个可编程的 GPIO（通用输入输出）引脚，用于连接外部设备。设计圆润，考虑到了儿童安全。

GPIO 引脚简介

GPIO 引脚用于与没有标准通信接口（如 I2C、SPI）的设备交互。它们可以处理两种信号：

数字信号：只关心“开”（1/高电平）或“关”（0/低电平）两种状态。
模拟信号：关心连续的电压值（例如 0V, 1.5V, 3.3V），用于测量距离、亮度等。

在 MicroPython 中，我们可以使用 Pin 类来读写这些引脚的值。

游戏手柄扩展板 🕹️

为了创建更丰富的游戏体验，我们可以使用游戏手柄扩展板。它通过边缘连接器与 Micro:bit 连接，无需焊接。

游戏手柄功能

方向摇杆：提供模拟输入。
四个动作按钮（A, B, C, D）。
两个侧边按钮：映射到 Micro:bit 板载的 A、B 按钮。
板载蜂鸣器：用于播放声音。
电池座：支持独立供电。

连接原理

游戏手柄上的每个功能（按钮、摇杆）都连接到 Micro:bit 特定的 GPIO 引脚上。扩展板背面通常有引脚映射表，说明哪个功能对应哪个引脚。例如：

按钮通常是数字输入（按下为 0，释放为 1）。
摇杆是模拟输入，可以读取 X 和 Y 轴上的偏移程度。

MicroPython 编程入门 🐍

Micro:bit 原生支持 MicroPython，这是 Python 3 的一个精简版本，专为微控制器设计。

编程环境

访问 microbit.org 进行编程，有两种主要方式：

块编辑器：适合初学者和儿童，通过拖拽积木块编程。
Python 编辑器：适合有编程基础的用户，提供代码高亮和自动补全。

编辑器内还集成了模拟器，即使没有硬件也可以测试代码。编写完代码后，点击“下载”会得到一个 .hex 文件，将其拖入连接到电脑的 Micro:bit（它像一个U盘）即可运行程序。

基础编程示例

以下是一些 MicroPython 基础操作的代码片段：

显示图像与文本

from microbit import *
# 显示内置表情
display.show(Image.HAPPY)
# 设置特定像素的亮度 (x, y, 亮度值0-9)
display.set_pixel(2, 2, 9)
# 创建自定义图像
my_image = Image(“09090:”
                 “99999:”
                 “09990:”
                 “00900:”
                 “00000”)
display.show(my_image)
# 滚动文本
display.scroll(“Hello!”)

读取按钮输入

from microbit import *
while True:
    if button_a.is_pressed():
        display.show(Image.SAD)
    if button_b.is_pressed():
        display.show(Image.HAPPY)

使用加速度计

from microbit import *
# 获取三轴加速度值
x = accelerometer.get_x()
y = accelerometer.get_y()
z = accelerometer.get_z()
# 检测手势
if accelerometer.is_gesture(“shake”):
    display.show(Image.SURPRISED)

使用 GPIO 引脚（以游戏手柄按钮为例）

from microbit import *
# 初始化引脚（例如，引脚15连接到一个按钮，设置为上拉输入）
button_c = pin15
button_c.set_pull(pin15.PULL_UP) # 默认高电平，按下时拉低

while True:
    # 读取数字输入：按下返回0，释放返回1
    if button_c.read_digital() == 0:
        display.show(“C”)

读取模拟输入（以摇杆为例）

from microbit import *
# 假设摇杆X轴连接引脚0，Y轴连接引脚1
joystick_x = pin0
joystick_y = pin1

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/3e60c1f2601ce67d34abf47e3feeb8a8_15.png)

while True:
    # 读取模拟值（范围约0-1023）
    x_value = joystick_x.read_analog()
    y_value = joystick_y.read_analog()
    # 根据值判断方向
    if x_value < 400:
        display.show(Image.ARROW_W)
    elif x_value > 600:
        display.show(Image.ARROW_E)

游戏开发实战 🎯

上一节我们介绍了 MicroPython 的基础编程。本节中，我们将运用这些知识，来看三个具体的游戏示例，理解其逻辑和代码结构。

游戏一：记忆序列游戏（Genius）

这是一个考验记忆力的游戏。计算机会生成一个随机的方向序列（上、下、左、右），并用箭头和声音提示用户。用户需要按照相同顺序重复这个序列。每轮正确后，序列会加长一步。一旦出错，游戏结束。

核心逻辑流程：

初始化一个空序列。
生成一个随机方向，添加到序列中。
向用户展示当前整个序列（通过LED和声音）。
等待用户输入，并逐个验证其输入是否与序列匹配。
如果全部正确，回到步骤2，延长序列。
如果某一步出错，播放失败音效，显示最终得分（序列长度-1），然后重启游戏。

关键代码思路：

使用列表存储方向序列。
用 random.choice() 从方向列表中随机选取。
用循环依次显示序列中的每个方向。
用 while 循环和 pin.read_digital() 读取游戏手柄上的方向按钮输入。
设置一个变量跟踪用户当前需要输入的是序列中的第几步。

游戏二：追逐光点（Chase the Dot）

玩家控制一个LED光点在5x5的屏幕上追逐另一个随机出现的光点。使用摇杆控制移动方向。如果在1秒内没有捕获到光点，光点会随机跳转到新位置。游戏限时25秒，目标是在时间内获得尽可能多的分数。

核心逻辑流程：

初始化玩家位置（如屏幕中心）和随机生成目标点位置。
开始计时。
循环内：
- 检查是否已过25秒，若是则结束游戏。
- 检查目标点是否已存在超过1秒，若是则将其重置到随机新位置。
- 读取摇杆的模拟输入，转换为移动方向，更新玩家位置。
- 检查玩家位置是否与目标点位置重合（碰撞检测）。
- 若重合，则得分加一，播放成功音效，并在随机新位置生成下一个目标点，同时重置目标点计时器。
刷新屏幕显示。

关键代码思路：

使用 running_time() 函数获取游戏运行时间。
用变量记录目标点生成的时间。
将摇杆的模拟值（0-1023）映射到上下左右和静止几个状态。
玩家和目标的坐标用 (x, y) 元组表示。
碰撞检测即判断两个坐标是否相等。

游戏三：赛车避障（Car Crash）

这是一个简单的纵向卷轴赛车游戏。玩家的汽车位于屏幕底部，只能左右移动。障碍物从屏幕顶部不断向下移动。玩家需要避开障碍物。随着时间推移，游戏速度会加快。碰撞即游戏结束。

核心逻辑流程：

初始化玩家位置、障碍物列表、游戏速度（刷新率）和分数。
游戏主循环：
- 在一个“刷新周期”内，持续读取玩家输入，并允许玩家快速左右移动。
- 周期结束后，进入“更新阶段”：
  - 将所有障碍物向下移动一格。
  - 检查是否有障碍物移动到底部，如果有，则检查是否与玩家碰撞。无论是否碰撞，该障碍物都会被移除，并在顶部生成一个新的随机障碍物。
  - 提高游戏速度（缩短刷新周期），增加难度。
- 使用“缓冲区”方法，将边界、所有障碍物和玩家一次性绘制到LED点阵上，形成完整画面。
如果检测到碰撞，游戏结束，显示最终分数。

关键代码思路：

双缓冲渲染：为了动画流畅，先在内存中创建一个代表整个屏幕的“图像缓冲区”（如一个5x5的亮度值列表），将所有元素（移动的边界、障碍物、玩家）计算好位置填入这个缓冲区，最后用 display.show() 一次性显示。这避免了逐个绘制像素时的闪烁。
游戏速度控制：通过一个 speed 变量控制主循环中“输入处理”阶段的迭代次数。迭代次数越少，障碍物下落得越快。
障碍物管理：使用列表来管理多个障碍物，每个障碍物是一个包含其坐标的对象或元组。

总结与资源 📚

本节课中，我们一起学习了如何使用 MicroPython 和 Micro:bit 硬件平台来创建互动游戏。

我们首先认识了 Micro:bit 的硬件特性和 GPIO 引脚的基本概念。接着，我们介绍了如何通过游戏手柄扩展板来获得更丰富的输入方式。然后，我们步入 MicroPython 编程，学习了显示控制、输入读取等基础操作。最后，我们深入分析了三个游戏实例——记忆序列、追逐光点和赛车避障的核心逻辑与代码结构，涵盖了随机数生成、状态管理、碰撞检测、计时器和双缓冲渲染等关键游戏开发技巧。

Micro:bit 与 MicroPython 的组合是一个强大且有趣的学习工具，非常适合入门嵌入式编程和互动项目开发。

资源链接

本次演讲中演示的完整游戏代码可在我的 GitHub 主页找到：https://github.com/[你的GitHub用户名] （请将 [你的GitHub用户名] 替换为演讲者实际的用户名，例如 julianakaro）。
你可以在 LinkedIn 和 GitHub 上通过我的用户名找到我。
MicroPython 官方文档：https://microbit-micropython.readthedocs.io/
Micro:bit 官方项目网站：https://microbit.org/

希望本教程能激发你动手创造的灵感，享受编程和硬件结合的乐趣！

045：谈话 🗣️

在本节课中，我们将学习如何通过对话推进游戏剧情，并了解对话系统的基本构成与实现逻辑。对话是角色扮演游戏（RPG）中传递信息、塑造角色和推动故事发展的核心手段。

上一节我们介绍了游戏场景的构建，本节中我们来看看如何设计并实现一个有效的对话系统。

对话系统的基本构成

一个典型的游戏对话系统包含几个关键部分。以下是这些核心组成部分：

对话树：对话以树状结构组织，玩家的不同选择会引导对话走向不同的分支。
对话节点：树中的每一个点，代表一句由角色说出的话或一个选项。
对话选项：提供给玩家的选择，通常以列表形式呈现，每个选项指向下一个对话节点。
触发器与条件：决定对话何时开始、结束或转向，例如需要完成某个任务或拥有特定物品。

对话逻辑的实现

对话的核心逻辑可以通过状态机或简单的条件判断来实现。其基本流程可以概括为以下伪代码：

while 对话未结束:
    显示当前对话文本
    if 当前节点有选项:
        显示所有选项
        等待玩家选择
        根据选择，将“当前节点”更新为选中的目标节点
    else:
        # 当前节点为普通陈述句
        等待玩家点击“继续”
        将“当前节点”更新为预设的下一个节点

设计对话的注意事项

设计对话时，需要考虑玩家的体验和故事的连贯性。以下是几个重要的设计原则：

保持角色一致性：角色的对话应与其性格、背景相符。
提供有意义的选择：玩家的选择应该能影响对话走向、角色关系或游戏进程，避免“假选项”。
控制对话节奏：避免大段冗长的独白，适当加入选项让玩家参与。
与游戏机制结合：对话可以用于传授游戏技巧、提供任务线索或展示世界观。

在“恐怖轮船”中的应用实例

在《恐怖轮船》这个场景中，对话被用来营造紧张氛围和揭示背景故事。例如，当玩家与关键NPC“Laszlo Kiss Kollar”交谈时，对话可能按以下结构展开：

初始问候：NPC发出警告或提出疑问。
信息揭示：通过对话逐步透露轮船的恐怖历史或当前危机。
玩家抉择：提供关键选择，例如“相信他并合作”或“怀疑他并独自调查”。
结果分支：根据选择，导向不同的后续剧情（如获得帮助、触发战斗或解锁新区域）。

其逻辑可以表示为：
对话路径 = 初始节点 + ∑(玩家选择 → 后续节点)

本节课中我们一起学习了游戏对话系统的基础知识，包括其构成、实现逻辑和设计原则，并探讨了它在《恐怖轮船》场景中的具体应用。掌握这些知识，你将能为自己的游戏创建出引人入胜的互动叙事体验。

046：使用导入机制优雅管理废弃API 🛠️

在本教程中，我们将学习如何利用 Python 的导入机制来优雅地处理 API 废弃问题。我们将探讨如何在不破坏现有代码的前提下，逐步淘汰旧接口，并向用户提供清晰的迁移指引。

概述 📋

当软件库需要更新时，某些旧的 API（应用程序编程接口）可能会被标记为废弃并计划在未来版本中移除。直接移除这些 API 会导致依赖它们的现有代码突然崩溃。因此，我们需要一种平滑的过渡策略。Python 灵活的导入系统为此提供了强大的工具。

上一节我们介绍了 API 废弃问题的背景，本节中我们来看看如何利用 Python 的导入机制来实现一个稳健的废弃策略。

核心策略：利用 `getattr` 和 `warnings` 模块 🎯

核心思想是拦截对已废弃模块或属性的访问，发出警告，并可能将调用重定向到新的实现。这主要依赖于模块级别的 __getattr__ 函数和标准库的 warnings 模块。

其工作流程可以概括为以下公式：
拦截访问 -> 发出弃用警告 -> 重定向到新实现

实现步骤详解 🛠️

1. 创建包结构

首先，我们需要一个清晰的包结构。假设我们有一个名为 mylib 的库，其中包含一个即将被废弃的旧模块 old_module，其功能已被 new_module 取代。

一个典型的目录结构如下：

mylib/
├── __init__.py
├── old_module.py  # 将被废弃的模块
└── new_module.py  # 新的替代模块

2. 在 `init.py` 中实现拦截逻辑

这是实现废弃机制的核心。我们在包的 __init__.py 文件中使用 __getattr__ 函数。

# mylib/__init__.py
import warnings
import sys

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5389becfdb0c44d353c38d640a36cb5d_31.png)

# 从新模块导入所有内容，作为包的基础功能
from .new_module import *

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5389becfdb0c44d353c38d640a36cb5d_33.png)

# 已废弃的模块名称列表
_DEPRECATED_MODULES = {"old_module"}

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5389becfdb0c44d353c38d640a36cb5d_35.png)

def __getattr__(name):
    """当属性在模块中找不到时被调用。"""
    if name in _DEPRECATED_MODULES:
        # 发出弃用警告
        warnings.warn(
            f"Module 'mylib.{name}' is deprecated and will be removed in a future version. "
            f"Please use 'mylib.new_module' instead.",
            DeprecationWarning,
            stacklevel=2
        )
        # 动态导入并返回旧模块，或重定向到新模块
        # 此处选择导入旧模块，保持其暂时可用
        import importlib
        return importlib.import_module(f".{name}", "mylib")
    # 如果访问的不是已废弃的属性，则抛出标准的 AttributeError
    raise AttributeError(f"module 'mylib' has no attribute '{name}'")

代码解释：

__getattr__ 是一个特殊方法，当尝试访问模块中不存在的属性时，Python 会调用它。
我们检查被访问的属性名（name）是否在我们定义的废弃列表 _DEPRECATED_MODULES 中。
如果是，则使用 warnings.warn() 发出一个 DeprecationWarning。stacklevel=2 参数确保警告信息指向用户调用废弃模块的代码行，而不是 __getattr__ 内部。
然后，我们使用 importlib.import_module 动态导入并返回旧的模块对象，使其暂时仍然可用。

3. 在旧模块中强化警告

为了提供更精确的警告，我们也可以在旧模块 old_module.py 本身的顶层或特定函数中加入警告。

# mylib/old_module.py
import warnings

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5389becfdb0c44d353c38d640a36cb5d_45.png)

warnings.warn(
    "The module 'mylib.old_module' is deprecated. Use 'mylib.new_module'.",
    DeprecationWarning,
    stacklevel=2
)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5389becfdb0c44d353c38d640a36cb5d_47.png)

def old_function():
    """这是一个已废弃的函数。"""
    warnings.warn(
        "'old_function' is deprecated. Use 'new_module.new_function'.",
        DeprecationWarning,
        stacklevel=2
    )
    # ... 旧的实现逻辑或调用新函数
    from .new_module import new_function
    return new_function()

进阶技巧：处理子模块和属性 🔧

上一节我们介绍了拦截整个模块访问的方法，本节中我们来看看如何更精细地处理子模块或模块内的特定属性。

重定向到新的属性

如果只是模块内的某个函数或类被重命名，可以在 __getattr__ 中直接返回新的对象。

# mylib/__init__.py (部分代码)
_DEPRECATED_ATTRIBUTES = {
    "old_func": "new_func",
    "OldClass": "NewClass"
}

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/5389becfdb0c44d353c38d640a36cb5d_57.png)

def __getattr__(name):
    """当属性在模块中找不到时被调用。"""
    # 检查是否为已废弃的属性
    if name in _DEPRECATED_ATTRIBUTES:
        new_name = _DEPRECATED_ATTRIBUTES[name]
        warnings.warn(
            f"Attribute '{name}' is deprecated. Use '{new_name}' instead.",
            DeprecationWarning,
            stacklevel=2
        )
        # 从当前模块（已导入new_module的内容）返回新的属性
        return globals()[new_name]
    # 检查是否为已废弃的模块
    if name in _DEPRECATED_MODULES:
        # ... 同上文的模块处理逻辑
        pass
    raise AttributeError(f"module 'mylib' has no attribute '{name}'")

最佳实践与注意事项 📝

以下是实施 API 废弃策略时需要考虑的几个关键点：

清晰的警告信息：警告信息必须明确指出版本计划、废弃内容以及确切的替代方案。
提供过渡期：在完全移除废弃 API 前，应留出足够长的过渡期（如多个次要版本），让用户有时间迁移代码。
更新文档：在官方文档中明确标记已废弃的 API，并给出迁移指南。
测试警告：确保你的测试套件能够捕获并验证发出的弃用警告，可以使用 pytest 的 deprecated_call 或 warnings.catch_warnings。
最终移除：在计划好的主要版本更新中，彻底移除废弃的代码和 __getattr__ 中的相关逻辑。

总结 🎓

本节课中我们一起学习了如何利用 Python 的动态导入机制和 warnings 模块来优雅地处理 API 废弃。

我们掌握了核心方法：通过在包的 __init__.py 中定义 __getattr__ 函数来拦截对已废弃模块或属性的访问，发出清晰的 DeprecationWarning，并可以选择性地将调用重定向到新的实现。这种方法使得库的维护者能够以对用户友好的方式推动代码库的演进，平衡了创新与稳定性。

记住，良好的废弃策略是尊重用户、维护生态健康的重要体现。

047：使用 asyncio 绕过 GIL

概述

在本节课中，我们将学习如何利用 Python 的 asyncio 库来绕过全局解释器锁的限制，从而高效地处理 I/O 密集型任务和并行计算。我们将从一个简单的串行处理示例开始，逐步引入多进程和共享内存技术，最终实现显著的性能提升。

全局解释器锁的挑战

上一节我们概述了课程目标，本节中我们来看看 Python 并发编程面临的核心挑战：全局解释器锁。

GIL 是 CPython 解释器中的一个机制，它确保在任何时刻只有一个线程执行 Python 字节码。这意味着即使在多核 CPU 上，多线程 Python 程序也无法实现真正的并行计算。

核心概念：GIL 限制了 CPU 密集型任务的并行执行。

虽然 GIL 对单线程程序没有影响，但它使得多线程程序在计算密集型任务上无法有效利用多核优势。因此，社区探索了多种解决方案，例如使用多进程（multiprocessing）模块，每个进程拥有独立的 Python 解释器和内存空间，从而绕开 GIL。

异步编程与 asyncio

上一节我们讨论了 GIL 的限制，本节中我们来看看如何利用异步编程来高效处理 I/O 操作。

asyncio 是 Python 用于编写并发代码的库，使用 async/await 语法。它特别适合处理 I/O 密集型任务，如网络请求或文件读写。其核心思想是：当一个任务等待 I/O 时，事件循环可以切换到其他就绪的任务，从而最大化单个线程的利用率。

一个好的类比是酒吧里的单个调酒师。他一次只能制作一杯饮料，但他可以同时接受多个订单，并在等待某杯饮料混合或倾倒时处理其他订单。

核心模式：事件循环管理多个协程，在它们之间切换以处理并发。

以下是 asyncio 处理多个网络请求的基本模式：

import asyncio

async def fetch_data(url):
    # 模拟网络请求
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    tasks = [fetch_data(f"url_{i}") for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(results)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/b6f49a000732cb2fb7f1f9181935252d_11.png)

asyncio.run(main())

这种方式使得构建高性能的网络服务器（如 Nginx 的工作模式）成为可能。然而，对于纯 CPU 密集型计算，asyncio 本身并不能绕过 GIL。

结合多进程处理 CPU 密集型任务

上一节我们介绍了如何使用 asyncio 处理 I/O，本节中我们来看看如何将其与多进程结合来处理 CPU 密集型任务。

当数据量过大，无法由单个进程在合理时间内处理时，我们需要将任务拆分到多个进程中并行执行。基本模式是“分而治之”：将数据分割成块，分配给多个工作进程处理，最后汇总结果。

我们将通过一个处理大型数据集的例子来演示。假设我们有一个函数 process_data_chunk 用于处理数据块。

以下是使用 multiprocessing 进行并行处理的基本框架：

from multiprocessing import Pool
import numpy as np

def process_data_chunk(chunk):
    # 模拟耗时的 CPU 计算
    return np.sum(chunk ** 2)

def main_serial(data):
    # 串行处理
    results = [process_data_chunk(chunk) for chunk in data]
    return sum(results)

def main_parallel(data, num_workers):
    # 并行处理
    with Pool(num_workers) as pool:
        results = pool.map(process_data_chunk, data)
    return sum(results)

# 假设 `data` 是一个包含多个数据块的列表

然而，简单的多进程会遇到数据序列化和内存复制的开销，这可能成为新的瓶颈。

使用共享内存减少开销

上一节我们遇到了多进程中的数据复制问题，本节中我们来看看如何使用共享内存来优化。

Python 的 multiprocessing 模块提供了共享内存对象（如 Array, Value），允许多个进程直接访问同一块内存区域，而无需复制数据。这对于处理大型数组至关重要。

核心步骤：

在主进程中创建共享内存数组。
将数据填充到共享内存中。
将共享内存的引用（以及必要的元数据如偏移量、大小）传递给工作进程。
工作进程直接操作共享内存中的数据。

以下是修改后的并行处理示例：

from multiprocessing import Pool, Array
import numpy as np

def init_worker(shared_data, shape, dtype):
    # 在工作进程中，将共享内存包装为 numpy 数组
    global np_array
    np_array = np.frombuffer(shared_data.get_obj(), dtype=dtype).reshape(shape)

def process_chunk(args):
    start, end = args
    # 直接操作全局的共享 numpy 数组切片
    chunk = np_array[start:end]
    return np.sum(chunk ** 2)

def main_shared_memory(data, num_workers):
    # 1. 创建共享内存并填充数据
    shared_array = Array('d', data.size) # 'd' 代表双精度浮点数
    np_shared = np.frombuffer(shared_array.get_obj(), dtype=data.dtype).reshape(data.shape)
    np.copyto(np_shared, data)

    # 2. 划分任务（传递索引元数据，而非数据本身）
    chunk_size = len(data) // num_workers
    tasks = [(i * chunk_size, (i + 1) * chunk_size) for i in range(num_workers)]

    # 3. 初始化工作进程并执行
    with Pool(processes=num_workers, initializer=init_worker, initargs=(shared_array, data.shape, data.dtype)) as pool:
        results = pool.map(process_chunk, tasks)

    return sum(results)

通过这种方式，我们避免了将整个数据集序列化并复制到每个工作进程的巨大开销，从而实现了接近线性的性能提升（例如，从 60 秒缩短到约 12 秒）。

错误处理与 asyncio 新特性

上一节我们优化了性能，本节中我们来看看如何确保程序的健壮性，并介绍 asyncio 的相关新特性。

在并发编程中，妥善处理异常非常重要。在 Python 3.11 及更高版本中，asyncio 对任务组（asyncio.TaskGroup）提供了更好的支持，它能够更安全、更直观地管理多个并发任务及其异常。

核心优势：使用 asyncio.TaskGroup 作为上下文管理器，如果组内任何一个任务失败，所有其他任务都会被自动取消，并且异常会被正确传播和聚合。

import asyncio

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/b6f49a000732cb2fb7f1f9181935252d_38.png)

async def worker(name, fail=False):
    await asyncio.sleep(1)
    if fail:
        raise ValueError(f"{name} failed!")
    print(f"{name} succeeded")
    return name

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            task1 = tg.create_task(worker("Task 1"))
            task2 = tg.create_task(worker("Task 2", fail=True))
            task3 = tg.create_task(worker("Task 3"))
        # 所有任务完成后才会执行到这里
        print("All tasks completed successfully")
    except* ValueError as eg: # 使用 except* 处理异常组
        for exc in eg.exceptions:
            print(f"Caught exception: {exc}")
    except ExceptionGroup as eg:
        print(f"Other errors: {eg}")

asyncio.run(main())

这种结构使得并发代码的错误处理更加清晰和可靠，是构建健壮生产应用的推荐方式。

总结

本节课中我们一起学习了如何绕过 Python 的 GIL 来提升程序性能。我们从理解 GIL 的限制开始，引入了 asyncio 来处理 I/O 密集型任务的并发。接着，为了处理 CPU 密集型任务，我们结合使用了多进程 (multiprocessing)。为了克服多进程间数据复制的性能瓶颈，我们深入探讨了共享内存技术，通过让工作进程直接操作主进程创建的内存区域，大幅减少了开销。最后，我们介绍了使用 asyncio.TaskGroup 进行健壮的并发错误处理。

关键要点在于：针对 I/O 瓶颈，使用 asyncio；针对 CPU 瓶颈，使用多进程配合共享内存；并始终使用现代 asyncio 特性（如 TaskGroup）来管理并发任务和异常。通过组合这些技术，你可以构建出既能高效处理 I/O 又能充分利用多核 CPU 的高性能 Python 应用。

048：讲座 - 玛利亚·霍塞·莫利纳·孔特雷拉斯 👩‍🏫

在本节课中，我们将学习机器学习与TinyML的基本概念。课程将介绍机器学习的基础知识，并探讨如何将其应用于资源受限的微型设备，即TinyML。我们将从讲师介绍开始，逐步了解相关背景和核心内容。

讲师介绍与课程背景

大家好，欢迎来到下一节课程。我将与大家讨论计算机科学及相关材料。

我的名字是拉尼·皮斯。我在一家公司的数据科学部门工作，同时也与大学有合作。我专注于数据科学领域，并致力于支持相关的研究与发展。

个人经历与项目历程

这是我过去几年一直在跟进的一个长期项目。从项目启动之初，我就参与其中。

我在这里已经待了相当长的一段时间，持续进行内容创作和学习。这个部分并非我最初计划的主要内容，但我逐渐深入其中。

我曾专注于提升项目的英语内容质量。在这个过程中，我意识到构建一个运转良好的系统至关重要。这项工作从一开始就充满挑战。

核心概念：机器学习与TinyML

上一节我们介绍了讲师的背景和项目历程，本节中我们来看看课程的核心概念。

机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习并改进，而无需进行明确的编程。其核心思想是通过算法解析数据，从中学习，然后对真实世界中的事件做出决策或预测。

一个简单的线性回归模型可以用以下公式表示：
y = wx + b
其中，y是预测值，x是输入特征，w是权重，b是偏差。

TinyML是机器学习的一个新兴领域，旨在在微控制器等资源极其受限的嵌入式设备上部署和运行机器学习模型。这需要模型小型化、低功耗和高效推理。

以下是TinyML的一个简单代码示例框架：

# 导入必要的TinyML库（例如TensorFlow Lite Micro）
import tflite_micro as tflm

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/8abb667ee6943fdedc5d04846aef29f7_75.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/8abb667ee6943fdedc5d04846aef29f7_77.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/8abb667ee6943fdedc5d04846aef29f7_79.png)

# 加载预训练并优化后的微型模型
model = tflm.LoadModel('model.tflite')

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/8abb667ee6943fdedc5d04846aef29f7_81.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/8abb667ee6943fdedc5d04846aef29f7_83.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/8abb667ee6943fdedc5d04846aef29f7_85.png)

# 在设备上进行推理
input_data = get_sensor_data()
output = model.predict(input_data)

课程内容与学习路径

基于以上核心概念，本课程将引导大家建立完整的知识体系。以下是本课程的主要学习模块：

机器学习基础：学习监督学习、非监督学习等基本算法。
模型优化与压缩：了解如何将大型模型裁剪、量化为适合微型设备的格式。
嵌入式系统基础：熟悉微控制器、传感器和低功耗编程。
TinyML框架与工具：学习使用TensorFlow Lite for Microcontrollers等开发工具。
实战项目：完成一个完整的端到端TinyML应用案例。

总结与展望

本节课中我们一起学习了机器学习与TinyML课程的概述。我们认识了讲师拉尼·皮斯及其项目背景，理解了机器学习的基本概念及其在微型设备上应用的挑战与机遇，即TinyML领域。

通过本课程的学习，你将能够理解如何将智能算法部署到日常生活中的小型、低功耗设备上，开启物联网与边缘计算的新可能。接下来的课程将深入每个模块的具体细节。

049：讨论 - 玛丽·罗阿德，英维·马达尔·莫

在本节课中，我们将探讨算法与刺绣艺术结合的创造性过程。我们将了解如何将编程思维应用于传统手工艺，并学习如何通过代码生成独特的刺绣图案。课程将涵盖从概念到实现的基本步骤，并通过简单的示例展示核心思想。

算法刺绣的创造性艺术：P49.1：艺术与算法的结合

上一节我们介绍了课程概述，本节中我们来看看艺术创作与算法编程之间的联系。

当谈论创造性艺术时，我们探讨的是全球性概念与社区艺术之间的联系。问题在于如何将多样化的主题通过代码表达出来，并以一种能够支持多人协作的方式进行。

算法刺绣可以被视为一种游戏化的艺术。我们从一个基础形状（例如一个球体）开始，将其作为一种发展的起点。我们能够以此创造一个新世界。人们喜欢谈论创造这样的东西，但过程可能变得复杂和困难。

因此，我们开始关注编码过程本身。编码在哪里可以找到其用武之地？

我们很高兴能找到一个使用代码的游戏，因为它像一个新三角形，将我们从常规思维中拉出来。当我们了解到通过一个新程序来构建图案时，我们感到更加兴奋。学习建筑（即图案结构）本身的形式是计算机艺术的重要组成部分。在计算机艺术中，所有的学习都发生在使用代码输入时。

算法刺绣的创造性艺术：P49.2：编程与转换

上一节我们讨论了艺术与算法的结合，本节中我们来谈谈编程中的“转换”概念。

那么，编程中的“文章”是什么？你需要确保它比单纯的编程过程更有意义。首先是创新。你可以用这个来推动流程向前发展。这涉及到一个复杂的算法，但也可以像一本简单的比赛建筑书。

在我们的思维碰撞中，我曾以为你是一个特定的机构。这是一个具有竞争性的话题，意味着讨论是具体和有针对性的。

特殊性体现在普通人思考简单几何图形时的表现，这通常是一个标志性案例。或者是一个团队在复杂竞争中脱颖而出。传统是通过一对力量和成本组织而成的。如果你看这个主题，它由这两部分组成，都是基于现实世界的事物。

“黑色作品”是一个常见的部分。如果你简单地做一个“白色凭证”，它会花费你一些时间。这个概念源自德国，有5700年的历史，并在穆斯林人口中普遍存在。它在英国律师中也非常受欢迎。“女士年”的标题部分被写成了“先生的书”的工作。

如果你启动这个项目，你就可以产生那个。你进入的另一种政治类型是“女士城镇”或“Nuriki白色作品”。这是一个非常著名或受欢迎的人物。它一直是同一类政治，最著名的在挪威。

我们有时称之为“seidur”，但它在世界各地都存在，就像这里一样。它只是在发展中出现。我们在这里看到的是，我们考虑的是我们能在全人类中看到的内容。我们认为这充满希望，我们作为程序员对此非常熟悉。这也可能非常暴力和充满变异。在其他情况下。

我们需要欢迎编程进入环境。环境也与变异有关，世界也与“女士城镇”相关，而“女士城镇”又与“Nuriki白色作品”相关。最终的核心概念程序是递归。这是在特定压力下的任何分裂和文化算法。起源也有参与。我们对刺绣很感兴趣。

但我们只是处于这个国家的另一边，那里一点也没有刺激。尤其是一个边界平台。我们对国家的新希望和叙述非常清晰。在这次演讲中，它由更小的话题构成，它们又由更小的话题构成。现在，这只是头部俱乐部的唯一小结构。

整件事与仍在发生的许多人相关。现在。我们只是好奇地观察事物。如果你对任何进入同一实验室的事情感兴趣，那么这是我们推荐的最令人印象深刻的事。而且值得一提的是，在仅有的伟大文学中，微量的刺绣结构也值得关注。

世界上有如此多的精神档案，遍布全球。今天我们可能可以谈论几乎所有事情。因此我们看到的是，我们可以找到一个编程过程。人们在讨论如何让事物看起来像编程，这并不是一种需求。

这是一个问题，但我们十年前就有了，而它并不是根据我们其他计算机艺术家的任何标准创建的。如果我参与其中或考虑艺术，我并没有今天的相同概念。这是一种制作方式。因为我把代码转化为一张空白卡片，转化为一本日记，这样它可以带来新的体验，一种纸板或纸张。

而且我们不能忽视我们的工作。它在更网络化的环境之间建立。我通过一种只在重复中使用的微模式带来了它。这几乎是两件事的方式。就像过期了一样，由当前和数据钳制组成。为此，我取样。通过构建软件或沙砾的重建。

它只提供了一个特定的环境来创造这个，所以这真的是配置部分。继续打开，只是创造这个工作的特定环境。将会在邻近部分周围形成更多的线，因为这就像一个演示。现在。这个特别麻烦的制作，所以即使这四行。

这个想法在许多实体咖啡项目中。

买一个外壳，然后添加一个外壳，和第一个。制作这个作品要容易得多。所以，纸制品的一个特定声明。如果这不是纸质公式。

我真的很喜欢这个。这是非常具体的，它是为此构建的。人们能够创造出由不同的人制作的东西。它与这里到这里的工作非常相似。现在。我们所看到的正是我们在随机中观察各个部分。

创建纸制品和纸制品的过程。还有另一个编程问题。我们无法整合一个产品，这个问题是重复的。要创造其他东西。这里我们可以放弃我的系统，这是一种提议。这个特定的线性化可以使更多的多样性仅仅相似。现在，再次。

我们只是好奇并且容易说。如果你想了解更多关于创造性编码的信息。如果你是一位计算机艺术家，你仍然处于顶端，那么你仍然处于顶端。你仍然处于顶端，你仍然处于顶端，而且你非常，非常有动力。所以。我们可以找到一些我们无法整合的东西。现在，我们可以创建一个人的每个参数。但。

我们相信关于建筑本身的是，我们不能做到这一点。

我们可以创造一条简单的创造力。继续并备份。我们可以在这里使用建筑线，所以我们从重要的思考开始。所以，在线。我们首先创建一个原型，然后叫这个产品。所以。前瞻性思维与熟悉这个产品的人数。

然后我们就创建了一个产品。现在我们将继续叫标题。如果你有几分钟，我们会完成最后期限，所以我们会进入未来。好吧，下一个，我会去下一个，然后我们会运行这段代码。所以。我们可以快速列出我的一行，然后我们可以迅速，但我们可以。

我们可以通过广播真正完成它，我们可以开启一系列问题。所以。让我们使用这个应用程序。然后我们可以提供一些创作的线，通过未来。这样我们可以。我们也可以继续叫这个产品。我们会继续叫这个产品。我们会继续叫这个产品。

我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。

我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将继续称这个产品。我们将能够用我们的空虚画一个圈。

所以我们需要给它 4。0。我们需要用我们的空虚画一个圈。我们需要用我们的空虚画一个圈。所以我们需要用我们的空虚画一个圈。我们需要用我们的空虚画一个圈。我们让我们做一点这个东西。所以我们可以用我们的空虚画一个圈。

我们可以用我们的空虚画一个圈。我们可以用我们的空虚画一个圈。我们还会做一点这个东西。所以我们可以用我们的空虚画一个圈。我们会用我们的空虚画一个圈。所以我们可以用我们的空虚画一个圈。我们可以用我们的空虚画一个圈。我们可以用我们的空虚画一个圈。

我们可以用我们的空虚画一个圈。我们可以用我们的空虚画一个圈。比如说，通过邀请他们参加派对。这是我例子中的一个很好的问题。我们做了一些选项。我们发现了一些这个。我们可以用我们的空虚画一个圈。我们可以用我们的空虚画一个圈。

我们可以画一个空心的圈。所以我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。

然后我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。我们可以画一个空心的圈。

所以我们可以创造，我们可以在转动的瞬间编码。但是我们可以在这个领域里画一个空心的方形。然后从中进入场的源头。

然后我们可以在这个领域里画一个空心的圈。我们可以画一个空心的圈。然后我们可以画一个空心的圈。但是我们可以画一个空心的圈。然后我们可以在里面画一个空心的圈。张开你的嘴。你可以看到在你的空心圈里还有一个圈。

所以我们可以在这个领域里画一个空心的圈。然后我们可以画一个空心的圈。然后我们可以画一个空心的圈。然后我们可以画一个空心的圈。然后我们可以画一个空心的圈。然后我们可以画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。最后。

我们可以画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。

然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。然后我们可以在这个领域里画一个空心的圈。

然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。然后我们可以在田野中用我们的空洞画一个圈。

然后我们可以在田野中用我们的空洞画一个圈。

然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。我们可以在田野中用我们的空虚画一个圈。我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。

然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。

然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。然后我们可以在田野中用我们的空虚画一个圈。

算法刺绣的创造性艺术：P49.3：实践与总结

上一节我们深入探讨了编程转换和具体操作，本节我们将进行总结。

本节课中我们一起学习了算法刺绣的创造性艺术。我们探讨了如何将算法思维与刺绣工艺相结合，通过编程来生成和转换图案。核心在于理解递归等概念，并将其应用于创造过程中。

我们从基础概念出发，讨论了艺术与算法的联系，然后深入到编程中的转换操作，并通过重复绘制基本图形（如圆圈）的示例，展示了如何通过简单的代码逻辑构建复杂的图案。这个过程强调环境配置、线性化思考以及从原型到产品的迭代。

总结来说，算法刺绣是一个将逻辑性与创造性融合的领域。它要求我们既理解代码的结构，又保持对艺术形式的敏感。通过本节的学习，希望你能够开始思考如何用编程工具来拓展你的艺术创作边界。

050：Python应用依赖管理指南 🐍

在本节课中，我们将要学习如何管理Python项目的依赖关系。依赖管理是软件开发中的关键环节，它确保项目能够稳定运行，并且便于团队协作与部署。我们将从基础概念入手，逐步介绍核心工具和最佳实践。

概述

Python应用的构建很大程度上依赖于外部库和包。有效的依赖管理能确保项目在不同环境中的一致性，避免“在我机器上能运行”的问题。本教程将引导你理解并掌握这一过程。

Python依赖管理：P50-1：理解依赖关系与虚拟环境

上一节我们介绍了依赖管理的重要性，本节中我们来看看什么是依赖关系以及为何需要虚拟环境。

一个Python项目通常会使用许多第三方库，这些库就是项目的依赖。例如，一个Web项目可能依赖Flask和requests库。直接在所有项目中共享这些库会导致版本冲突。

为了解决这个问题，我们使用虚拟环境。虚拟环境为每个项目创建一个独立的Python运行环境，包含其专属的Python解释器和包目录。这样，不同项目可以使用同一库的不同版本而互不干扰。

创建虚拟环境的常用命令是：

python -m venv myenv

激活虚拟环境后，所有通过pip安装的包都将只存在于该环境中。

Python依赖管理：P50-2：依赖管理工具与`requirements.txt`

理解了虚拟环境的作用后，我们需要一种方法来记录项目具体依赖了哪些库及其版本。这就是requirements.txt文件的用途。

requirements.txt是一个文本文件，它列出了项目所需的所有第三方包及其版本号。这是一个示例：

Flask==2.3.2
requests>=2.28.0, <3.0.0
pandas

== 指定精确版本。
>= 和 < 指定版本范围。
不写版本号则安装最新版。

你可以使用以下命令将当前环境中已安装的包生成requirements.txt文件：

pip freeze > requirements.txt

当其他人或部署服务器需要搭建环境时，只需运行：

pip install -r requirements.txt

即可一键安装所有指定依赖。

Python依赖管理：P50-3：进阶工具：`pipenv`与`poetry`

虽然requirements.txt是基础工具，但在处理复杂的依赖关系（如下游依赖冲突）或需要区分开发与生产依赖时，它显得力不从心。因此，出现了更强大的工具。

以下是两个主流的现代Python依赖管理工具：

pipenv：由Python官方推荐，它结合了pip和虚拟环境管理，并引入了Pipfile和Pipfile.lock来确保依赖树的确定性。
poetry：一个更全面的工具，它不仅管理依赖，还能帮助你打包、发布项目，并采用pyproject.toml作为配置文件，这是现代Python项目的趋势。

这些工具能自动解析依赖冲突，并生成锁文件，确保在任何地方安装的依赖树都完全一致。

Python依赖管理：P50-4：依赖管理的核心原则与最佳实践

掌握了工具之后，遵循一些核心原则能让依赖管理更加高效可靠。

以下是依赖管理的最佳实践列表：

始终使用虚拟环境：这是隔离项目依赖的基石，避免污染系统全局Python环境。
精确锁定版本：在生产环境中，务必使用锁文件（如Pipfile.lock, poetry.lock）或固定requirements.txt中的版本，以实现可重复的构建。
区分依赖类型：使用工具将仅用于开发（如测试框架、代码检查工具）的依赖与项目运行必需的依赖分开管理。
定期更新依赖：定期检查并更新依赖至新版本，以获取功能改进和安全补丁，但更新后需充分测试。
审查依赖项：了解项目引入了哪些第三方代码，使用安全工具扫描已知漏洞，避免引入不必要或存在风险的包。

遵循这些实践，你的项目将更加健壮、安全且易于维护。

总结

本节课中我们一起学习了Python应用依赖管理的完整流程。我们从理解依赖关系和虚拟环境开始，介绍了使用requirements.txt记录依赖的基础方法。接着，我们探讨了更强大的现代工具pipenv和poetry。最后，我们总结了确保依赖管理有效的五项核心最佳实践。良好的依赖管理是专业Python开发的标志，它能显著提升项目的稳定性和团队协作效率。

051：谈话 - 马克·香农 _ 我们如何让 CPython 更快。过去，现在和未来

概述

在本教程中，我们将跟随马克·香农的分享，了解CPython性能优化的历程、当前策略与未来方向。我们将探讨提升Python解释器速度的核心思路与技术，内容将尽可能简单直白，适合初学者理解。

章节一：性能优化的起点与挑战

提升CPython的速度是一个持续的目标。过去，这项工作面临诸多挑战。

性能优化并非总能找到最佳时机。可行的优化次数越多，达成目标的可能性就越大。这本身就是一项需要持续投入的工作。

章节二：历史尝试与经验教训

上一节我们提到了性能优化的挑战，本节中我们来看看过去的一些尝试。

有些方法从未被采用，或者即将被采用时又被放弃。关键在于，不要只给出第一个想到的方案，而是需要召集更多人，共同审视并形成一份清晰的规划。

章节三：当前的问题识别

识别问题是优化的第一步。我们当前面临的核心问题是什么？

这没关系，我们不必立刻解决所有问题。关键在于识别出“那是个问题”，并明确“这是一个点”。我们得到了问题，接下来就是思考“如何”解决。

你在看这个。

章节四：方法论与未来方向

基于对问题的识别，我们形成了具体的优化方法论，并规划了未来方向。

以下是优化工作的几个核心思路：

增量改进：性能提升依赖于持续、微小的改进累积，而非一次性的巨大变革。
协作规划：需要团队协作，制定清晰的路线图，而不是依赖个人灵光一现。
聚焦关键点：优先解决那些被明确识别出的、影响全局性能的关键瓶颈。

总结

本节课中我们一起学习了CPython性能优化的核心思想。我们回顾了优化工作的起点与挑战，总结了历史经验，学习了如何识别当前的关键问题，并了解了基于协作与聚焦的持续优化方法论。让CPython更快是一个结合了技术、协作与长期规划的持续过程。

052：用 Python 创建 USB 小工具

在本节课中，我们将学习如何使用 Python 将一台树莓派或类似的 Linux 单板计算机配置成一个 USB 小工具。这意味着你的设备可以模拟成键盘、鼠标、存储设备等，并通过 USB 接口与主机电脑进行交互。我们将从核心概念讲起，逐步完成配置和代码编写。

概述

USB 小工具功能允许一个 USB 设备（如树莓派）模拟成多种 USB 设备类别。Linux 内核通过 configfs 文件系统提供了动态配置 USB 小工具的能力。我们将使用 Python 来编写脚本，自动化这一配置过程，并实现一个简单的键盘输入功能。

上一节我们介绍了课程目标，本节中我们来看看实现 USB 小工具需要理解的核心概念。

USB 小工具核心概念

理解以下概念对后续操作至关重要：

USB Gadget（小工具）：指能够通过 USB 连接扮演特定角色（如键盘、鼠标）的设备。
ConfigFS：一个位于 /sys/kernel/config 的虚拟文件系统，用于在用户空间动态配置内核对象，包括 USB 小工具。
Function（功能）：指小设备所模拟的具体功能，例如 hid（人机接口设备，用于键盘/鼠标）。
Configuration（配置）：一组功能的集合，一个小工具可以拥有多个配置，但一次只能激活一个。

其核心关系可以表示为：一个 Gadget 包含一个或多个 Configuration，每个 Configuration 包含一个或多个 Function。

接下来，我们将进入实践环节，了解具体的环境准备步骤。

环境准备

在开始编写代码前，需要确保你的 Linux 系统（以树莓派为例）满足以下条件。

以下是需要检查或启用的项目列表：

内核支持：内核必须编译了 USB Gadget 功能。通常树莓派 OS 已包含。
启用模块：需要加载 libcomposite 内核模块。执行 sudo modprobe libcomposite 来加载。
Python 3：确保系统已安装 Python 3。
权限：操作 /sys/kernel/config 下的文件需要 root 权限，因此我们的脚本需要使用 sudo 运行。

准备工作完成后，我们就可以开始设计并编写主要的配置脚本了。

编写配置脚本

我们将创建一个 Python 脚本，用于自动设置一个模拟键盘的 USB 小工具。脚本的核心任务是操作 configfs 中的目录和文件。

以下是脚本的关键步骤和对应代码：

定义基础路径和 Gadget 名称：
```
import os

CONFIGFS_PATH = "/sys/kernel/config/usb_gadget"
GADGET_NAME = "my_keyboard"
```
这段代码定义了 configfs 的路径和我们即将创建的小工具名称。

创建 Gadget 目录并设置基础属性：

gadget_path = os.path.join(CONFIGFS_PATH, GADGET_NAME)
os.makedirs(gadget_path, exist_ok=True)

# 设置 USB 厂商ID和产品ID (例如，0x1d6b 是 Linux Foundation)
with open(os.path.join(gadget_path, "idVendor"), "w") as f:
    f.write("0x1d6b")
with open(os.path.join(gadget_path, "idProduct"), "w") as f:
    f.write("0x0104")

这里创建了小工具目录，并为其设置了标识符。0x1d6b 和 0x0104 是一个示例ID。

创建字符串描述符：

strings_path = os.path.join(gadget_path, "strings", "0x409")
os.makedirs(strings_path, exist_ok=True)
with open(os.path.join(strings_path, "serialnumber"), "w") as f:
    f.write("1234567890")
with open(os.path.join(strings_path, "manufacturer"), "w") as f:
    f.write("My Company")
with open(os.path.join(strings_path, "product"), "w") as f:
    f.write("Python USB Keyboard")

这部分代码创建了在主机端显示的设备信息，如制造商和产品名称。

创建 HID 功能（Function）：

# 创建功能目录
function_path = os.path.join(gadget_path, "functions", "hid.usb0")
os.makedirs(function_path, exist_ok=True)

# 设置协议类型（1 为键盘）和报告描述符长度
with open(os.path.join(function_path, "protocol"), "w") as f:
    f.write("1")  # 1 代表键盘
with open(os.path.join(function_path, "subclass"), "w") as f:
    f.write("1")
with open(os.path.join(function_path, "report_length"), "w") as f:
    f.write("8")  # 键盘报告描述符的长度

# 写入一个简单的键盘报告描述符
report_desc = bytes([0x05, 0x01, 0x09, 0x06, 0xA1, 0x01, 0x05, 0x07, 0x19, 0xE0, 0x29, 0xE7, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x08, 0x81, 0x02, 0x95, 0x01, 0x75, 0x08, 0x81, 0x01, 0x95, 0x05, 0x75, 0x01, 0x05, 0x08, 0x19, 0x01, 0x29, 0x05, 0x91, 0x02, 0x95, 0x01, 0x75, 0x03, 0x91, 0x01, 0xC0])
with open(os.path.join(function_path, "report_desc"), "wb") as f:
    f.write(report_desc)

这是最关键的一步，我们创建了一个 hid 功能，并将其配置为键盘，同时写入了一个标准的键盘报告描述符。

创建配置（Configuration）并关联功能：

# 创建配置目录
config_path = os.path.join(gadget_path, "configs", "c.1")
os.makedirs(config_path, exist_ok=True)
config_strings_path = os.path.join(config_path, "strings", "0x409")
os.makedirs(config_strings_path, exist_ok=True)
with open(os.path.join(config_strings_path, "configuration"), "w") as f:
    f.write("Keyboard Config")

# 将 HID 功能符号链接到配置中
os.symlink(function_path, os.path.join(config_path, function_path.split("/")[-1]))

我们将之前创建的 hid.usb0 功能添加到了名为 c.1 的配置中。

绑定到 UDC（USB设备控制器）：

# 查找可用的 UDC 控制器
udc_driver = ""
with open("/sys/class/udc/udc0/uevent", "r") as f: # 路径可能不同，如 /sys/class/udc/*/uevent
    for line in f:
        if line.startswith("UDC_NAME="):
            udc_driver = line.strip().split("=")[1]
            break

if udc_driver:
    with open(os.path.join(gadget_path, "UDC"), "w") as f:
        f.write(udc_driver)
    print("USB Gadget activated.")
else:
    print("No UDC driver found.")

最后一步是将我们配置好的小工具绑定到实际的硬件 USB 接口上，使其生效。

脚本编写完成后，我们需要知道如何运行和使用它。

运行与测试

保存上述代码到一个文件，例如 setup_keyboard.py。

使用 root 权限运行脚本：sudo python3 setup_keyboard.py。
此时，将树莓派通过 USB 线连接到另一台电脑（确保连接的是数据口，而非仅供电口）。
主机电脑应该会识别出一个新的 USB 键盘设备。
要测试键盘输入，你需要向 /dev/hidg0 设备文件写入键盘扫描码。可以编写另一个简单的 Python 脚本来发送按键（例如，按下并释放 ‘a’ 键）。

一个发送 ‘a’ 键的示例代码片段如下：

# send_key.py
with open("/dev/hidg0", "wb") as hid:
    # 按下 ‘a’ 键
    hid.write(b'\x00\x00\x04\x00\x00\x00\x00\x00')
    # 释放所有按键
    hid.write(b'\x00\x00\x00\x00\x00\x00\x00\x00')

使用 sudo python3 send_key.py 运行，观察主机电脑是否输入了字母 ‘a’。

总结

本节课中我们一起学习了如何利用 Linux 的 configfs 接口和 Python 脚本，将树莓派配置成一个 USB 键盘小工具。我们涵盖了从核心概念、环境准备、脚本分步编写到最终测试的完整流程。通过操作虚拟文件系统，我们动态创建了小工具、功能、配置并将其激活。掌握这个方法后，你可以进一步探索模拟鼠标、存储设备或复合设备，为你的嵌入式项目增添强大的 USB 交互能力。

053：Pydantic V2 如何利用 Rust 的超能力 🚀

在本节课中，我们将学习 Pydantic V2 如何通过集成 Rust 编程语言的核心能力，实现了性能的飞跃。我们将探讨其背后的动机、具体的技术实现以及带来的显著优势。

概述

Pydantic 是一个用于 Python 的数据验证和设置管理的库。在 V2 版本中，其核心部分使用 Rust 重写，这带来了巨大的性能提升和更强大的功能。本节课将解析这一技术变革的关键点。

上一节我们概述了 Pydantic V2 的核心变革。本节中，我们来看看促使团队决定使用 Rust 进行重写的根本原因。

动机：为何选择 Rust？

Pydantic V1 完全由 Python 编写。虽然功能强大，但在处理复杂数据验证时，性能可能成为瓶颈。Rust 语言以其内存安全、零成本抽象和高性能而闻名。通过将性能关键的部分用 Rust 重写，Pydantic V2 旨在突破这些限制。

具体来说，主要动机包括：

提升速度：Rust 能编译成高效的机器码，显著快于纯 Python 解释执行。
减少内存占用：Rust 对内存的精细控制有助于降低库的内存开销。
增强健壮性：Rust 的所有权和借用系统可以在编译时防止许多常见的内存错误，使核心逻辑更可靠。
更好的并发支持：为未来利用多核能力打下基础。

了解了使用 Rust 的动机后，接下来我们深入探讨 Pydantic V2 具体是如何实现这一技术融合的。

技术实现：Rust 与 Python 的协同

Pydantic V2 并非完全用 Rust 重写，而是采用了混合架构。其核心的验证逻辑和数据处理引擎由 Rust 实现，同时保留了 Python 层友好的 API。这种协同工作通过 PyO3 等工具实现。

以下是关键的技术实现要点：

核心引擎 Rust 化：数据解析、验证、序列化等计算密集型任务被迁移到 Rust 模块中。
Python 绑定：通过 PyO3 库创建 Python 可调用的 Rust 代码接口，使得 Python 代码能够无缝调用高性能的 Rust 函数。
保留 Python API：对于终端用户而言，使用方式与 V1 基本保持一致，无需学习新语法即可享受性能红利。例如，定义一个模型仍然很简单：
```
from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int
```
类型处理：Rust 端需要能够理解和处理 Python 的类型提示（如 List[int], Optional[str]），这需要精心的类型映射和转换设计。

现在我们已经明白了 Pydantic V2 的混合架构。本节中，我们来看看这种架构为开发者和应用程序带来了哪些具体的、可衡量的好处。

性能优势与效果

采用 Rust 带来的性能提升是立竿见影的。以下是一些关键的改进领域：

验证速度大幅提升：常见操作的性能提升可达 5倍到50倍，具体取决于数据结构的复杂度。
更低的内存开销：Rust 的高效内存管理减少了在验证大量数据时的内存占用。
启动时间优化：由于核心逻辑已预编译为本地代码，减少了运行时解释的开销。

一个直观的对比是，过去可能需要优化或缓存来缓解性能压力的场景，现在使用 Pydantic V2 可以轻松应对。

性能的提升是最直接的收益。最后，我们来总结一下 Pydantic V2 这一变革的深远影响。

总结与展望

本节课中，我们一起学习了 Pydantic V2 如何通过利用 Rust 语言的超能力实现革新。

我们了解到，其动机源于对极致性能和更高可靠性的追求。技术实现上，它巧妙地通过 PyO3 将 Rust 高性能核心与 Python 友好 API 相结合，形成了混合架构。最终，这带来了验证速度数量级的提升和资源消耗的降低。

Pydantic V2 的成功实践为 Python 生态提供了一个范例：通过将性能关键组件用 Rust 等系统级语言重写，可以在不牺牲开发者体验的前提下，为库注入巨大的性能潜力。这不仅是 Pydantic 本身的升级，也代表了高性能 Python 工具开发的一个趋势。

054：使用 Python 进行开源策略管理 🔐

在本教程中，我们将学习如何使用 Python 来管理和提升软件供应链（SCM）的安全性。我们将探讨开源策略管理的基本概念，并了解如何通过自动化工具来确保依赖项的安全合规。

概述 📋

软件供应链安全是现代软件开发的关键环节。它涉及管理项目所依赖的所有外部代码库（即开源包），以防止引入漏洞或恶意代码。手动管理这些依赖项既繁琐又容易出错。因此，利用 Python 进行自动化管理成为一种高效且可靠的解决方案。

上一节我们介绍了供应链安全的重要性，本节中我们来看看如何利用 Python 工具来实现开源策略的自动化管理。

核心概念与工具 🛠️

在深入实践之前，我们需要理解几个核心概念和将要用到的工具。

供应链（SCM）：指软件从开发到交付过程中涉及的所有组件、库、工具和流程。

开源策略：指一个组织关于如何使用、选择、审核和更新开源软件的一套规则和标准。

我们将主要使用 Python 包管理器 pip 和依赖分析工具。一个基础的依赖检查可以通过以下命令实现：

pip list --outdated

实施步骤 📝

以下是实施自动化开源策略管理的关键步骤。

1. 依赖项清单生成

首先，需要生成项目所有依赖项的完整清单。这可以通过 pip 轻松完成。

pip freeze > requirements.txt

生成的文件 requirements.txt 列出了所有已安装包及其精确版本。

2. 漏洞扫描

生成清单后，下一步是扫描这些依赖项是否存在已知的安全漏洞。我们可以使用像 safety 这样的工具。

# 安装 safety
pip install safety

# 扫描 requirements.txt 文件
safety check -r requirements.txt

该命令会检查依赖包是否包含在公共漏洞数据库中，并报告发现的问题。

3. 策略合规性检查

除了安全漏洞，还需要确保依赖项符合内部的开源使用策略（例如，许可证限制）。我们可以编写自定义的 Python 脚本来进行校验。

以下是一个简单的示例脚本框架，用于检查许可证：

import pkg_resources

def check_licenses(requirements_file):
    with open(requirements_file, 'r') as f:
        packages = [line.strip().split('==')[0] for line in f]
    
    for dist in pkg_resources.working_set:
        if dist.project_name in packages:
            # 此处应接入实际的许可证检查逻辑
            print(f"{dist.project_name}: {dist._provider.license}")

4. 集成与自动化

最后，将上述步骤集成到持续集成/持续部署（CI/CD）流水线中。这样，每次代码提交或构建时都会自动执行安全检查，确保问题能被及早发现。

例如，可以在 .gitlab-ci.yml 或 GitHub Actions 配置中添加一个安全扫描阶段。

总结 🎯

本节课中我们一起学习了如何使用 Python 来管理软件供应链安全。我们从生成依赖清单开始，接着进行漏洞扫描和策略合规性检查，最后探讨了如何将这些流程自动化集成到开发工作流中。

通过自动化这些任务，团队可以显著降低因使用不安全或不合规的开源组件而带来的风险，从而构建更可靠、更安全的软件。

记住，供应链安全是一个持续的过程，需要定期更新依赖项并重新评估策略。

055：深入解析现代Python项目配置 🐍

在本教程中，我们将学习现代Python项目打包的核心工具——pyproject.toml文件。我们将了解它的结构、优势以及如何利用它来简化项目配置和依赖管理。

概述 📋

pyproject.toml是Python社区推出的一个标准配置文件，旨在统一项目构建、打包和依赖管理的配置方式。它取代了传统的setup.py、setup.cfg、requirements.txt等多个文件，将所有配置集中在一个地方。

为什么选择 `pyproject.toml`？ 🤔

上一节我们介绍了pyproject.toml的基本概念，本节中我们来看看它相比传统配置方式的优势。

使用pyproject.toml的主要好处是简化了配置过程。你不再需要维护多个分散的配置文件。

以下是pyproject.toml的几个核心优势：

统一配置：将项目元数据、构建系统要求和工具配置集中在一个文件中。
工具无关性：支持多种构建后端（如setuptools、flit、poetry），不锁定特定工具。
声明式语法：使用TOML格式，清晰易读，易于编写和维护。
更好的互操作性：被现代Python工具链（如pip、build、twine）广泛支持。

`pyproject.toml` 文件结构解析 🏗️

了解了其优势后，我们来看看一个典型的pyproject.toml文件包含哪些部分。

一个基本的pyproject.toml文件主要包含两个部分：[build-system]和[project]。

以下是各部分的详细说明：

[build-system]：指定构建项目所需的工具。
```
[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"
```
这段代码定义了构建依赖和使用的构建后端。

[project]：定义项目的核心元数据。

[project]
name = "my-awesome-package"
version = "0.1.0"
authors = [
  {name = "Your Name", email = "you@example.com"},
]
description = "一个非常棒的Python包"
readme = "README.md"
license = {text = "MIT"}
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
]
dependencies = [
    "requests>=2.25.0",
    "numpy>=1.20.0",
]

这里定义了包名、版本、作者、依赖等关键信息。

定义入口点与脚本 🚪

配置好项目基本信息后，我们还需要定义如何执行我们的代码。这就是入口点的作用。

入口点允许你将包中的特定函数注册为命令行工具或插件。

以下是定义入口点的示例：

[project.scripts]
my-cli-tool = "mypackage.module:main_function"

[project.gui-scripts]
my-gui-app = "mypackage.gui:launch"

[project.entry-points."some_plugin_group"]
my-plugin = "mypackage.plugin:initialize"

project.scripts 创建命令行脚本。
project.gui-scripts 创建图形界面脚本（较少使用）。
project.entry-points 用于插件系统，允许其他工具发现并使用你的模块。

使用工具特定配置 ⚙️

pyproject.toml的强大之处还在于它能配置各种开发工具，保持项目环境的一致性。

你可以为black、isort、pytest、mypy等工具添加配置节。

以下是配置代码格式化和测试工具的示例：

# 配置 Black 代码格式化工具
[tool.black]
line-length = 88
target-version = ['py311']

# 配置 isort 导入排序工具
[tool.isort]
profile = "black"
line_length = 88

# 配置 pytest 测试框架
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-v --strict-markers"

通过这种方式，所有开发者都能使用相同的工具设置，确保代码风格统一。

项目布局与打包实践 📁

正确的项目布局对于打包至关重要。一个清晰的结构能让工具更容易地找到和包含你的代码。

建议将你的Python源代码放在一个以项目名命名的目录中（即src/布局或扁平布局）。

以下是两种常见的项目布局示例：

src/ 布局（推荐，避免导入混淆）：

my_project/
├── pyproject.toml
├── README.md
├── src/
│   └── my_package/
│       ├── __init__.py
│       └── module.py
└── tests/

扁平布局：

my_project/
├── pyproject.toml
├── README.md
├── my_package/
│   ├── __init__.py
│   └── module.py
└── tests/

在pyproject.toml中，你可以使用tool.setuptools来明确指定包目录：

[tool.setuptools]
packages = ["my_package"]

构建与发布你的包 🚀

所有配置完成后，最后一步就是构建并发布你的包。

现代Python打包使用build和twine工具，它们能很好地与pyproject.toml协同工作。

以下是构建和发布包的步骤：

安装构建工具：
```
pip install build twine
```

构建分发包：
```
python -m build
```
这个命令会在dist/目录下生成.tar.gz和.whl文件。
上传到PyPI：
```
twine upload dist/*
```
首次上传需要配置PyPI认证信息。

总结 🎯

本节课中我们一起学习了现代Python项目配置的核心——pyproject.toml文件。

我们探讨了它的优势、基本结构、如何定义项目元数据和依赖、配置入口点以及集成各种开发工具。通过采用pyproject.toml，你可以创建一个更简洁、更标准化且易于维护的Python项目，与整个Python生态系统无缝集成。记住，从新项目开始就使用它是一个最佳实践。

056：利用Python增强用户体验 🚀

在本节课中，我们将探讨人工智能与用户体验设计的交叉领域。我们将学习如何利用AI的力量来增强产品体验，理解用户体验的重要性，并了解如何通过数据驱动的方法来优化产品布局、数据管理和组织。

P56：1：项目启动与资金到位 💰

资金已经到位。现在我们有一个新项目。我们将交付最重要的部分。

这就是项目如何按年度规划的。你会得到一个固定的成本。

P56：2：演讲开场与主题介绍 🎤

非常感谢。早上好。本次演讲的主题是人工智能与用户体验的交集。我们不必去发现AI的力量，而是可以直接利用它。在演示中，我们将讨论用户体验的重要性。

产品的显示布局和所有产品空间都至关重要。在产品的背景下，我们需要综合考虑这些方面，包括数据管理和组织优化。

P56：3：用户体验的重要性 🎯

上一节我们介绍了演讲主题，本节中我们来看看为什么用户体验如此关键。

用户体验在理解用户需求、满足最终用户目标方面至关重要。它可以帮助我们实现以下目标：

以下是用户体验带来的核心益处：

使产品更个性化。
为用户提供进入公司组织的切入点。
有助于留住用户。

首先，我们需要理解这个过程。我将用户体验的过程标准化。我们合作推进了数字化进程，所有信息仍在从不同的产品资源中收集。我们将把这些数据用于任务或其他用途。

一旦我们拥有大量数据，我们就可以为任何业务定义产品。

P56：4：从想法到解决方案 🛠️

理解了用户体验的价值后，我们现在需要一个具体的例子来解决问题。

我们现在有一个具体的例子，需要在第一部分解决一个问题。我们需要为这个引擎规划一个使命。因此，我们去探索我们所创造的想法。

我们想知道两个成员的事情。但是用户体验工作已经完成。它不断驱动着不同类型的操作。因此，产品可以采用某种构建方式。然后，建筑产品也来源于这两者。

如果我制造一个解决方案，一个产品，那么用户将是受益者，他们能够有所作为。

P56：5：AI与UX的共同框架 🤝

如果我们使用一个新的API并进行操作，我们会看到新的用户体验支持与该产品中的信息之间存在一个共同框架。

我们可以看到有些东西超出了我们通常监督和使用的范围。当产品是新的时，了解用户如何接近产品是相当困难的，用户可能正在从网站获取信息。

所有超出讨论内容的信息都可以在几分钟内整合到产品中。因此，通过对话，我们可以制作更多由用户需求驱动的产品，并为特定用户创造个性化的体验。

人们可能会争论并告知他人，我们可以开始进行处理。我们可以制作正确的音频，我们可以听到即将发送给每个人的用户体验过程。因此，这非常关键。

有一个云端可以识别特定用户的网站，以及他们如何使用产品及其反馈。然后我们可以利用这一点在特定实例中开始使用该案例。

这是一种对人们假设的知识，他们不会参与讨论。但曾经使用该网站的社区成员，常常会寻找特定工具来解释来自不同网站的其他信息。我在获取信息，但这些信息是为我的特定网站所做的。

我们不称自己为考虑共同特征的人。对于参与产品的用户，他们为其他用户使用相同的模式。因此，这个人通常要做的第二件事是在用户中保留这些内容。这些内容不会被视为会员模式的一部分。

因此，我们可以利用这些不同的研讨会和一些细节来弄清楚社区项目中的模式及其差异。

P56：6：数据模式与个性化创新 📊

例如，凭借数据经验，我们很难按照用户的模式来处理数据。然后我们可以写下这些内容，并利用用户与您产品的互动方式。

我们可以做一些不同的事情，比如定义所需的数据模式，以及我们如何进行创新。接着我们可以做一些不同的事情。

无论是人类的那些，所以这不是问题。只是因为您可能会看到世界上有几个人。您可以利用实验来实现这一点，在这个过程中，您可以使用世界或社区中的人，并请他们在社区中执行此操作。

所有为那些没有障碍而回归工作的人而做的工作，以及那些真正使用过数据的人。但请查找数据的社会成本比率，您可以利用它来了解如何使用产品，因为它们可以被用于迎合主体或整个模型的副产品。

然后，基于我们希望实现的愿景，我们使用您的工作，您可以制作我们习惯的产品。

因此，如果您之前提到过，您是无法做到的。而且您不能将其制作成我们可以说的产品，如果您关注用户，您会需要它。而且想与社区合作的人，因为您不想轻易成为产品。如果您开始接触像您这样的人。

这就像是AI在看如何使用产品，还有需要这个产品的用户，他们为此做工作，因为他们正在经历他们所思考的事情，或者很快就像是，“哦，有一个人需要用户问他们在做什么。”

所以，例如。我们会像，“哦，这仍然是画廊，我正在经过画廊，但这里没有。”我们就像是那些我们建立的主题，它们被称为，并说，“哦。我们听说这仍然是我们正在经历的地方。我们过去谈论今天正在经历的事情，而你不使用客户。而且你不使用这个产品，但你并不直接进入空间。而且这不是我们今天要经历的地方。”

我们认为有很多人能够理解这一点。我们不在乎我们是否正在经历这个产品，而这不是我们正在经历的地方。而且这不是我们正在经历的地方，今天也不是。

但是在我们的第一次迭代中，我们可以使用四个独立站点，这两者都是其中的一部分，真的可以扩展一些。如果你不喜欢音乐，这就是我们的玩法。这里应该是做更多事情的地方。我们需要做我们拥有的事情的最佳方法，而我们没有一种广告来制作音乐。这将是其中的一部分。

我们正在经历很多事情。

P56：7：数据内容与用户视角 🔄

假如你正在做任何事情，我将要回顾数据内容。这就像一个正在发生的过程，像是在一些更大的部分内部。然后你必须提到更具体的事情。你可以看到有更多不同类型的其他部分在这里。

我会否认这里的事情，但人们常常使用它们。所以他们做的数据可以在其他事物上进行构建。我们将要查看的事情，我们都同意我们正在经历一个非常好的资源。因为这叫做用户，基于我们造成这些片段的过程。我们也不知道为什么我们要这样做，但与我们称之为的那些人合作是非常重要的。

因为它包含很多东西，特别是为了找到我们称之为“你是一个人”的东西。以及他们如何实际上在下一代中创造不同的部分。我认为还有一件事情是一个快速的主题，这对观众来说是过程的20%。这种质量绝对使用不同的人。

所以，如果有一个小用户能够让他们想到“你是一个人”。这提供了个性化体验，可以从用户的角度出发。带着“你是一个人”。我们使用的所有东西都是像 a + a 的研究，关于我们正在经历的所有事情，然后我们将为这一点设定理由。

但在政策历史中这是一个历史。我们将根据这个图表的上下文给你提供数据，这基于系统。然后我们可以问这个问题，“这是一种特定类型吗？”而这个问题是基于他们的政治和政治相似性。

因为它基于政治话语，所以它不是一个叫做“问题”的非常不同的社区。但它是基于政治和政治世界的拥有历史。它只是一种多样性。

因此，我们可以说目标是我们可以制作个性化内容。我们可以让它针对单一用户，甚至可以跟踪它，你可以以这种方式维护它。我们可以使用一些特定产品的“给予”，但我们不想制造出非常迅速的东西。我们不想像大多数目标那样，而是希望创造出更可持续的东西。我们想要使用可以用于人类的“给予”。在这个时刻。我们想要自己阐明这些内容。

顺便说一下，我们可以使用我们预测的价值。

我们可以和我们认为在另一边的“给予”出去，这就是我们如何识别它的，我们无法将其用于问题。问题在于人们习惯于被放置在其中。这也有帮助，例如，在政治环境中，它是关于某种产品的。

这里最重要的事情是你可以用它来解决问题。因为这是你必须使用的东西，就像我们为问题使用的“给予”，你可以逐个使用它。

然后你可以放入我们为逐个使用而做的“给予”。然后你可以逐个使用它，接着你可以逐个使用它。

然后你可以逐个使用它。

P56：8：维度管理与实践应用 📐

然后最后一件事是维度管理。我们将进一步使用，并且我们找到了在特定法律下工作的地方。具体来说是玩游戏，但这不是一个游戏网站。

我们知道这不是一个特定的播放列表，但我们将要外出。通过我们自己的计划，所以我们确保我认为，我们可以做到这件事。我们不会陷入困境，因为，例如，如果你在和银行打交道。这不是一回事，我们不会陷入困境，因为，例如。

如果你在和银行打交道，那是一回事，而你上学时可以逐个使用。你可以逐个使用，也可以在学校里使用一些东西。你更有可能去一个能花更多钱的学校。如果你在使用东西，我会在银行里得到很多东西。

如果这些社区很昂贵，这对你们来说应该没问题。比如，我去过的国家越多，我确实认为，你所做的就像。你在跨越同一个D.E.R，而D.E.R并不重要，但基本上。我们的愿景最终被称为报告，这意味着这并不重要。我认为。

只要思考，你就会明白，这是一个我刚才提到的陈述。你可能，我不想再更多的，但。使用几千个片段，这是一个奇怪的片段。你需要去除它，使用报告，对E.R.的使用。

关键是，原则的，E.R.的原则不是一个，E.R.的原则是。

E.R.的原则不是一个。

总结 📝

本节课中我们一起学习了如何将人工智能应用于用户体验设计。我们从项目启动开始，探讨了UX在理解用户和实现产品目标中的核心重要性。我们深入了解了从数据收集、模式分析到构建个性化体验的完整过程，并强调了在AI辅助下，通过与社区合作和迭代开发来创造可持续、以用户为中心的产品的重要性。最后，我们提到了维度管理等实践应用概念。关键在于利用数据和AI工具，始终从“用户是一个人”的视角出发，打造真正有意义的体验。

057：为自己构建一个PyScript应用 🚀

在本节课中，我们将学习如何利用PyScript框架，在网页中直接运行Python代码。我们将从基础概念开始，逐步构建一个简单的交互式应用，理解PyScript的核心工作原理。

概述

PyScript是一个允许开发者在HTML中嵌入并运行Python代码的框架。它使得在浏览器中创建丰富的数据可视化、机器学习应用等成为可能，而无需复杂的服务器端设置。

PyScript入门：P57-1：PyScript基础概念 💡

上一节我们介绍了PyScript的总体目标。本节中，我们来看看它的核心概念和基本用法。

PyScript的核心是允许你在HTML文件中编写Python代码，并通过浏览器执行。这主要通过引入特定的JavaScript库来实现。

一个最基本的PyScript页面结构如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="https://pyscript.net/latest/pyscript.css" />
    <script defer src="https://pyscript.net/latest/pyscript.js"></script>
</head>
<body>
    <py-script>
        print("Hello, PyScript!")
    </py-script>
</body>
</html>

在这个例子中，<py-script> 标签内的Python代码会在页面加载时执行，并将结果输出到页面上。

PyScript入门：P57-2：配置与依赖管理 ⚙️

理解了基础用法后，我们需要了解如何配置PyScript环境以及管理项目依赖。

PyScript允许你指定需要使用的Python包。这通过 <py-config> 标签完成。以下是配置依赖的示例：

<py-config>
    packages = ["numpy", "matplotlib"]
</py-config>

这个配置告诉PyScript运行时，需要预先加载 numpy 和 matplotlib 这两个库。

PyScript入门：P57-3：与HTML元素交互 🖱️

一个强大的功能是让Python代码与网页上的HTML元素进行交互。这包括读取输入框的值、更新页面内容等。

我们可以使用 Element 类来获取和操作DOM元素。以下是一个简单的交互示例：

<input type="text" id="name-input" placeholder="输入你的名字">
<button id="greet-btn" py-click="greet()">打招呼</button>
<div id="output"></div>

<py-script>
    from js import document
    from pyodide.ffi import create_proxy

    def greet():
        name = document.getElementById("name-input").value
        if name:
            document.getElementById("output").innerHTML = f"你好，{name}！"
        else:
            document.getElementById("output").innerHTML = "请输入名字。"

    # 为按钮创建事件代理
    button = document.getElementById("greet-btn")
    button.addEventListener("click", create_proxy(greet))
</py-script>

在这个例子中，Python函数 greet() 会读取输入框的内容，并将问候语输出到 id 为 output 的 div 元素中。

PyScript入门：P57-4：处理数据与可视化 📊

PyScript非常适合进行数据分析和可视化。结合像 pandas 和 matplotlib 这样的库，可以直接在浏览器中生成图表。

以下是一个使用 matplotlib 绘制简单折线图的例子：

<py-config>
    packages = ["matplotlib"]
</py-config>

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/548c987fd70e9bb7b4ecfaf6842d326e_27.png)

<div id="plot"></div>

<py-script>
    import matplotlib.pyplot as plt
    import numpy as np

    # 生成数据
    x = np.linspace(0, 10, 100)
    y = np.sin(x)

    # 创建图形
    fig, ax = plt.subplots()
    ax.plot(x, y)
    ax.set_title("正弦波图")

    # 将图形显示到指定div中
    pyscript.write("plot", fig)
</py-script>

代码首先生成一组数据，然后使用 matplotlib 创建图表，最后通过 pyscript.write() 函数将图表插入到指定的HTML元素中。

PyScript入门：P57-5：应用部署与注意事项 🚢

构建完应用后，最后一步是部署。由于PyScript完全在客户端运行，你可以像部署任何静态网站一样部署它。

以下是部署时需要注意的几个关键点：

性能：首次加载需要下载PyScript运行时代码和Python包，页面加载时间可能较长。考虑使用CDN并优化包列表。
兼容性：确保用户的浏览器支持WebAssembly（现代浏览器基本都支持）。
静态托管：可以将整个项目（HTML、CSS、JS文件）托管在GitHub Pages、Netlify、Vercel等静态网站托管服务上。

总结

本节课中我们一起学习了PyScript的核心知识。我们从基础概念入手，学会了如何在HTML中嵌入并运行Python代码。接着，我们探索了如何配置环境、管理依赖，并实现了Python与HTML元素的动态交互。最后，我们使用 matplotlib 进行了数据可视化，并讨论了部署应用时的注意事项。

通过PyScript，你可以将Python的强大功能直接带到网页前端，为构建交互式数据应用和原型提供了全新的可能性。

058：你为什么应该关心开源供应链安全 🔒

在本节课中，我们将学习开源软件供应链安全的基本概念。我们将探讨什么是软件供应链，为什么它容易受到攻击，以及作为开发者或用户，你可以采取哪些措施来保护自己。理解这些知识对于构建和维护安全的软件至关重要。

概述

现代软件开发严重依赖开源组件。一个应用程序可能由数十甚至数百个开源库和框架构建而成。这条从原始开发者到最终用户的复杂链条，就是软件供应链。本节课将解释这条供应链中的安全风险，并说明为什么每个人都应该关注它。

1. 什么是软件供应链？ ⛓️

软件供应链是指软件从开发到交付给最终用户所经历的全部过程和组件。这包括：

上游依赖：你的项目直接使用的开源库。
间接依赖：你的上游依赖所依赖的其他库（也称为传递依赖）。
构建工具与流程：用于编译、测试和打包软件的系统和脚本。
分发渠道：如应用商店、包管理器（npm, PyPI, Docker Hub等）。

一个简单的依赖关系可以表示为：

你的项目 -> 开源库A -> 开源库B -> 开源库C

在这个链条中，开源库C 就是你的一个间接依赖。

上一节我们介绍了软件供应链的构成，它像一张复杂的网。本节中我们来看看，这张网为何会变得脆弱。

2. 供应链为何成为攻击目标？ 🎯

软件供应链之所以吸引攻击者，是因为它具有“一次入侵，广泛影响”的特点。攻击者不再需要逐个攻击成千上万的最终用户或企业。

以下是供应链攻击的主要优势：

影响范围广：入侵一个被广泛使用的开源库，可以潜在影响所有使用它的应用程序和用户。
隐蔽性强：恶意代码可以隐藏在合法的更新中，难以被传统安全工具发现。
信任被利用：开发者通常信任来自官方仓库的知名包，这种信任会被攻击者滥用。
防御难度大：企业很难审查其软件中每一个间接依赖的源代码和安全性。

理解了攻击者的动机后，接下来我们看看攻击具体是如何发生的。

3. 常见的供应链攻击类型 ⚔️

攻击者会利用供应链中的多个环节进行破坏。以下是几种常见的攻击手法：

依赖混淆攻击：攻击者向公共包仓库发布一个与公司内部私有包同名的恶意版本。构建系统可能会错误地下载这个恶意公共包。
劫持维护者账户：通过窃取密码或利用漏洞，控制一个流行开源项目的维护者账户，然后发布带有后门的更新。
投毒官方仓库：直接入侵如 npm、PyPI 等官方包仓库，篡改热门软件包。
破坏构建过程：入侵用于自动化构建和发布的持续集成/持续部署（CI/CD）系统，在软件编译过程中注入恶意代码。
替换依赖：通过篡改项目配置文件（如 package.json, requirements.txt），将依赖指向一个恶意仓库的版本。

面对这些威胁，我们并非无能为力。下一节将介绍一些个人可以采取的基础防护措施。

4. 个人可以采取的防护措施 🛡️

作为开发者或用户，你可以通过以下实践来提升安全性：

以下是保护自己的几个关键步骤：

锁定依赖版本：使用锁文件（如 package-lock.json, Pipfile.lock）或精确指定版本号，避免自动更新到可能包含恶意代码的最新版。

// 在 package.json 中，避免使用过于宽泛的版本范围
"dependencies": {
  "useful-library": "1.4.2" // 好：精确版本
  // "useful-library": "^1.4.0" // 有风险：允许自动更新小版本
}

定期更新与审查：定期更新依赖以获取安全补丁，同时关注所依赖项目的安全公告和动态。
使用可信来源：始终从官方或经过验证的仓库下载软件包。
实施代码审查：对项目引入的新依赖，特别是权限较高的依赖，进行基本的代码审查或查看其流行度和维护状况。
利用安全工具：使用像 npm audit, snyk, dependabot 这样的工具，自动扫描项目依赖中的已知漏洞。

个人的努力很重要，但维护整个生态系统的安全需要更广泛的协作。本节将探讨社区和生态层面的行动。

5. 社区与生态系统的责任 🤝

保障开源供应链安全是整个社区的共同责任。

以下是关键参与者可以做的事情：

维护者：启用双因素认证（2FA）保护账户；对关键贡献进行仔细审查；及时响应安全漏洞报告。
基金会与公司：为关键开源项目提供资金和安全审计支持；建立漏洞披露和应急响应流程。
包仓库管理者：加强账户安全策略；推广2FA；对上传的包进行恶意软件扫描。
所有贡献者：以安全的方式编写代码；负责任地披露发现的漏洞。

总结

本节课中我们一起学习了开源供应链安全的核心内容。我们首先定义了软件供应链，并解释了它因其广泛性和信任基础而成为高价值攻击目标。接着，我们分析了依赖混淆、账户劫持等常见的供应链攻击手法。最后，我们从个人和社区两个层面，探讨了如何通过锁定版本、使用安全工具、加强账户安全等具体措施来防御这些风险。

记住，在开源的世界里，安全是所有人的共同责任。关注你的依赖，就是保护你的项目和用户的第一步。

059：内存分析器如何工作

在本节课中，我们将学习内存分析器的基本工作原理。我们将从内存分配的基础概念开始，逐步深入到分析器如何跟踪和管理内存，最终理解内存泄漏等问题的检测机制。

内存分配基础

程序运行时，会向操作系统申请内存。内存分配器负责管理这些申请，将可用的内存块分配给程序使用。

上一节我们介绍了内存分配的基本概念，本节中我们来看看内存分配器是如何工作的。

内存分配器的作用

内存分配器的主要职责是管理堆内存。它需要高效地处理程序的内存申请和释放请求。

以下是内存分配器需要完成的核心任务：

分配内存：当程序调用如 malloc 或 new 的函数时，分配器需要找到一块足够大的空闲内存并返回其地址。
释放内存：当程序调用如 free 或 delete 的函数时，分配器需要将这块内存标记为空闲，以便后续重用。
管理空闲内存：分配器需要跟踪所有空闲的内存块，通常使用链表等数据结构来组织它们。

内存块的结构

为了管理内存，分配器会在分配给用户的内存块前后添加一些额外的信息，称为“头部”和“尾部”。

一个典型的内存块结构可以用以下伪代码描述：

struct memory_block {
    size_t size;          // 用户可用的内存大小
    bool is_free;         // 该块当前是否空闲
    memory_block* next;   // 指向链表中下一个块的指针
    memory_block* prev;   // 指向链表中上一个块的指针
    // ... 可能还有其他元数据
    char user_data[];     // 实际分配给用户的内存区域
};

公式：用户请求大小 + 元数据大小 = 实际分配的内存块总大小。

内存分析器如何工作

理解了内存分配的基础后，我们现在可以探讨内存分析器了。内存分析器是一种工具，它通过拦截程序的内存操作来监控和分析内存使用情况。

分析器的核心机制

内存分析器工作的核心是“拦截”或“钩子”技术。它会在程序运行时，替换掉标准的内存分配和释放函数。

以下是内存分析器实现监控的关键步骤：

替换内存函数：分析器用自己的实现（例如 my_malloc、my_free）替换掉标准的 malloc 和 free。
记录分配信息：当 my_malloc 被调用时，它不仅分配内存，还会记录这次分配的详细信息，如大小、返回的地址、调用处的代码位置（如堆栈跟踪）。
记录释放信息：当 my_free 被调用时，它释放内存，并记录此次释放操作，将对应的分配记录标记为已释放。
维护全局状态：分析器维护一个全局表（如哈希表），将分配的内存地址与其详细信息关联起来。

检测内存泄漏

内存泄漏是指程序分配了内存但未能释放。分析器通过对比分配记录和释放记录，可以轻松识别出泄漏。

上一节我们介绍了分析器如何记录内存操作，本节中我们来看看它如何利用这些记录检测问题。

分析器检测内存泄漏的逻辑非常简单：

在程序运行结束时（或特定时刻），分析器检查其维护的全局分配表。
任何仍然处于“已分配”状态且未被标记为“已释放”的记录，都对应着一块泄漏的内存。
分析器可以报告这些泄漏内存的大小和分配时的调用堆栈，帮助开发者定位问题根源。

代码：泄漏检测的简化逻辑可以表示为：

for (allocation in allocation_table) {
    if (allocation.is_freed == false) {
        printf("Memory leak detected!\n");
        printf("Size: %zu\n", allocation.size);
        print_stack_trace(allocation.stack_trace);
    }
}

其他分析功能

除了检测泄漏，内存分析器还能提供许多其他有用信息：

内存使用概况：显示程序在运行过程中内存使用量的峰值和趋势。
分配热点：识别哪些代码路径分配了最多的内存。
非法内存访问：有些高级分析器可以检测对已释放内存的访问（Use-After-Free）或缓冲区溢出。

总结

本节课中我们一起学习了内存分析器的工作原理。我们从内存分配的基础知识开始，了解了分配器如何管理内存块。接着，我们深入探讨了内存分析器的核心机制，即通过拦截内存函数来记录每一次分配和释放操作。最后，我们明白了分析器如何通过对比这些记录来有效地检测内存泄漏等常见问题。掌握这些原理，有助于我们更好地使用工具来优化程序性能和稳定性。

060：演讲 - Pandy Knight_ 我该用什么框架进行网页测试 _ - VikingDen7 - BV1114y1o7c5

在本教程中，我们将学习如何为网页测试选择合适的框架。我们将探讨测试的基本概念、不同类型的测试框架，以及如何根据项目需求做出明智的选择。

网页测试基础：P60：1：什么是网页测试？🧐

网页测试是确保网站或Web应用按预期工作的过程。它涉及检查功能、性能、兼容性和安全性等方面。

上一节我们介绍了本教程的目标，本节中我们来看看网页测试的基础知识。

网页测试的核心目标是验证软件质量。它帮助开发者发现并修复问题，确保最终用户获得良好的体验。

测试类型：P60：2：测试有哪些类型？🔍

测试可以根据其范围和目的分为不同类型。理解这些类型有助于我们选择正确的工具。

以下是几种主要的网页测试类型：

单元测试：测试最小的代码单元，如单个函数或组件。
集成测试：测试多个单元或模块如何协同工作。
端到端测试：模拟真实用户操作，测试整个应用流程。
性能测试：评估应用在不同负载下的响应速度和稳定性。
兼容性测试：确保应用在不同浏览器、设备和操作系统上正常工作。

测试框架概览：P60：3：有哪些流行的测试框架？📦

市场上有许多测试框架，各有侧重。了解它们的特点是我们做出选择的第一步。

以下是几个广泛使用的网页测试框架：

Jest：一个专注于单元测试的JavaScript测试框架，以其简单性和速度著称。它通常与React等库配合使用。
- 核心概念示例：expect(sum(1, 2)).toBe(3);
Cypress：一个强大的端到端测试框架，提供实时的测试运行和调试体验。它直接在浏览器中运行。
Selenium：一个用于自动化Web浏览器的老牌工具，支持多种编程语言，常用于端到端测试和兼容性测试。
- 核心概念示例（Python）：
```
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("http://www.example.com")
```
Puppeteer：一个由Google Chrome团队提供的Node库，用于通过DevTools协议控制Chrome或Chromium，常用于自动化和测试。
Playwright：一个较新的测试框架，支持多种浏览器（Chromium, Firefox, WebKit），并提供了强大的自动化能力。

如何选择框架：P60：4：我该如何选择？🤔

选择框架没有唯一正确答案，但可以遵循一些关键原则来缩小范围。

上一节我们介绍了主流框架，本节中我们来看看如何根据实际情况进行选择。

决策应基于你的具体需求。以下是需要考虑的主要因素：

测试类型：你主要需要进行单元测试、集成测试还是端到端测试？
技术栈：你的项目使用什么前端框架（React, Vue, Angular）和后端语言？
团队熟悉度：团队对哪种框架或编程语言更熟悉？
开发体验：框架是否提供良好的调试工具、报告和文档？
社区与生态：框架是否活跃，是否有丰富的插件和社区支持？
执行速度：测试套件的运行速度对开发流程是否关键？

总结与建议：P60：5：总结📝

本节课中我们一起学习了网页测试的基础知识、不同类型以及主流框架的特点。

对于初学者或新项目，可以遵循以下路径：

从单元测试开始：使用 Jest 或类似框架为你的核心函数和组件编写测试。
引入端到端测试：当应用流程变得复杂时，引入 Cypress 或 Playwright 来保障关键用户路径。
按需扩展：根据项目需要，考虑加入性能测试（如Lighthouse）或兼容性测试（如BrowserStack）。

记住，最好的框架是那个最适合你当前团队和项目的框架。开始比完美更重要，你可以从一个框架入手，在实践中逐步调整和完善你的测试策略。

061：你希望你不知道的一切 🕐

在本节课中，我们将学习与时区相关的基础概念、常见陷阱以及如何在编程中正确处理它们。我们将从时间的基本定义开始，逐步深入到时区的复杂性，并探讨一些实用的编程模型。

时间的基础概念

上一节我们介绍了课程概述，本节中我们来看看时间的基础概念。时间是连续的，但我们在计算机中测量和表示时间时，通常使用离散的选项。这些选项大多是以下三者之一。

时间本身不能包含指令，但我们对时间的表示和操作确实依赖于指令。这是一个非常重要的区别。当你不再是编程新手时，理解这一点至关重要。

时区与偏移量的区别

另一个核心概念是时区与偏移量之间的区别。偏移量是指当地时间与协调世界时之间的差值，通常以小时表示，例如 UTC-5 表示比 UTC 晚 5 小时。

时区则是一套更复杂的规则，它定义了某个地理区域在历史上和未来所有不同时间点应使用的偏移量。时区规则会因夏令时、政策变化等因素而改变。

时区规则的复杂性

并非所有时区都恰好偏离 UTC 整数小时。有些时区有 30 分钟或 45 分钟的偏移。例如，印度标准时间是 UTC+5:30，尼泊尔时间是 UTC+5:45。

时区规则也会频繁更改。一个地区可能决定永久采用夏令时，或者改变其标准时间的偏移量。这些更改通常由政府立法决定，并且生效日期可能非常突然。

模糊时间与不存在的时间

处理时区时，会遇到两个特殊问题：模糊时间和不存在的时间。

模糊时间：在夏令时切换回标准时间的那个秋季夜晚，时钟会从凌晨 1:59 跳回凌晨 1:00。因此，凌晨 1:30 这个时间会出现两次。在代码中，这被称为模糊时间。
不存在的时间：在春季切换到夏令时的那天，时钟会从凌晨 1:59 直接跳到凌晨 3:00。因此，凌晨 2:30 这个时间在现实中不存在。在代码中，这被称为不存在的时间。

以下是处理这些情况的通用逻辑：

# 伪代码：处理模糊或不存在的时间
if is_ambiguous(timestamp, timezone):
    # 需要决定使用第一次还是第二次出现
    resolved_time = resolve_ambiguity(timestamp, timezone, which=‘first‘)
elif not exists(timestamp, timezone):
    # 时间不存在，需要向前或向后调整到有效时间
    adjusted_time = adjust_to_valid(timestamp, timezone, direction=‘forward‘)

编程中的时区模型

在软件中处理时区时，通常有三种模型：

仅使用 UTC：在系统内部，所有时间都存储为 UTC。只在需要向用户展示时，才转换为本地时间。这是最推荐的做法，公式可以表示为：本地时间 = UTC 时间 + 偏移量。
使用本地时间加时区信息：存储一个本地时间戳，并附带其所属的时区标识符（如 “America/New_York”）。这允许你准确还原时间点，但计算和比较更复杂。
使用带偏移量的时间：存储一个时间戳和其当前的固定偏移量（如 2023-10-01T10:00:00-04:00）。这丢失了时区规则信息，如果该地区的偏移量未来发生变化，此时间点的含义可能会变得不准确。

总结

本节课中我们一起学习了时区编程的核心知识。我们明确了时间、偏移量和时区的区别，了解了时区规则的复杂性和动态变化特性。我们探讨了模糊时间和不存在时间这两个关键问题及其处理思路。最后，我们比较了编程中处理时区的几种常见模型，其中在系统内部坚持使用 UTC 是最简单、最不容易出错的方法。记住，时区是关于政治和地理的规则，而不仅仅是关于时间的数学。

062：无需运行代码捕获张量形状错误 🔍

在本节课中，我们将学习一种在深度学习模型开发中至关重要的调试技巧：如何在不实际运行代码的情况下，提前发现并修正张量形状不匹配的错误。这种方法能显著提高开发效率，避免因运行时错误而浪费大量时间。

张量形状错误概述

在深度学习中，张量是存储和操作数据的基本单元。每个张量都有一个形状，它定义了张量在每个维度上的大小。例如，一个形状为 (batch_size, channels, height, width) 的图像张量。

当我们在神经网络中进行运算（如矩阵乘法、卷积、拼接等）时，参与运算的张量必须满足特定的形状兼容规则。如果形状不匹配，就会引发运行时错误。例如，试图将一个形状为 (64, 10) 的矩阵与一个形状为 (20, 10) 的矩阵相乘，由于第一个矩阵的列数（10）与第二个矩阵的行数（20）不相等，操作无法进行。

静态形状分析原理

上一节我们介绍了张量形状错误的基本概念。本节中我们来看看如何在不运行代码的情况下捕获这些错误，其核心思想是静态形状分析。

静态形状分析是指在代码执行前，仅通过分析代码逻辑和张量的已知形状信息，来推断和验证所有张量运算的形状兼容性。这类似于在数学中提前检查公式的维度是否匹配。

其核心依据是每个张量运算都有明确的形状传播规则。以下是一些常见运算的规则：

矩阵乘法：对于 A @ B，要求 A.shape[1] == B.shape[0]。结果的形状为 (A.shape[0], B.shape[1])。
- 公式：(m, n) @ (n, p) -> (m, p)
逐元素运算：如加法、乘法，要求两个张量的形状完全相同。
- 规则：shape_A == shape_B
广播运算：允许形状在某些维度上不同，但必须满足广播规则（例如，维度大小为1的轴可以扩展）。
卷积运算：输出形状由输入形状、卷积核大小、步长和填充决定。
- 公式（简化）：output_size = (input_size - kernel_size + 2*padding) / stride + 1

通过手动或借助工具跟踪这些规则，我们可以从已知的输入形状（如数据加载器输出的批次形状）开始，逐步推导出网络中每一层输出的张量形状。

手动推导形状的步骤

以下是进行手动静态形状分析的步骤：

确定输入形状：明确你的模型输入数据的形状。例如，对于图像分类任务，输入形状可能是 (batch_size, 3, 224, 224)。
逐层推导：从输入层开始，根据每一层的类型（全连接层、卷积层、池化层等）及其参数（如神经元数量、卷积核大小、步长），应用对应的形状变换规则，计算出该层的输出形状。
记录与验证：将每一层的输入和输出形状记录下来。在推导到下一层时，确保上一层的输出形状与当前层期望的输入形状匹配。
检查最终输出：确保网络最终的输出形状与你任务要求的形状一致（例如，分类任务中输出层形状应为 (batch_size, num_classes)）。

实践示例：一个简单网络

让我们通过一个简单的全连接神经网络示例来实践一下。

假设我们有一个批次数据，形状为 (batch_size, 784)，代表 batch_size 张 28x28 的扁平化图像。我们构建一个两层网络：

第一层：线性层，输入特征 784，输出特征 256。
第二层：线性层，输入特征 256，输出特征 10（对应10个类别）。

现在，我们进行形状推导：

输入层：shape_input = (batch_size, 784)
第一层（线性层）：
- 权重矩阵形状应为 (784, 256)。
- 进行矩阵乘法：(batch_size, 784) @ (784, 256)。根据矩阵乘法规则，中间维度 784 匹配，因此输出形状为 (batch_size, 256)。
第二层（线性层）：
- 将第一层的输出 (batch_size, 256) 作为输入。
- 第二层权重矩阵形状应为 (256, 10)。
- 进行矩阵乘法：(batch_size, 256) @ (256, 10)。中间维度 256 匹配，因此最终输出形状为 (batch_size, 10)。

推导完成。整个过程没有运行任何代码，但我们确信只要权重矩阵定义正确，前向传播过程中不会出现形状错误。

利用现代框架的特性

现代深度学习框架（如 PyTorch、TensorFlow）提供了强大的工具来辅助静态形状分析。

模型摘要：使用如 torchsummary 库或框架内置的 .summary() 方法，可以直接打印出模型中每一层的输入/输出形状。
```
# PyTorch 示例 (使用 torchsummary)
from torchsummary import summary
summary(your_model, input_size=(3, 224, 224))
```
类型检查与Lint工具：一些IDE或静态分析工具能对张量运算进行初步的类型（形状）检查，提示可能的不匹配。

单元测试：为你的模型前向传播函数编写单元测试，使用随机的模拟输入（dummy input）来验证形状是否如预期。

# 单元测试示例
def test_model_shapes():
    dummy_input = torch.randn(4, 3, 224, 224) # batch_size=4
    model = YourCNNModel()
    output = model(dummy_input)
    assert output.shape == (4, 10), f"Expected shape (4, 10), got {output.shape}"

总结

本节课中我们一起学习了如何在不运行代码的情况下捕获张量形状错误。我们首先理解了张量形状错误的本质，然后掌握了静态形状分析的核心原理，即跟踪每一层运算的形状传播规则。通过手动推导一个简单网络的示例，我们实践了这一方法。最后，我们了解到可以借助现代深度学习框架提供的模型摘要和单元测试等工具，使这一过程更加高效和可靠。掌握这项技能能让你在构建复杂神经网络时更加自信，并节省大量调试时间。

063：生成器、协程与微服务 🚀

在本节课中，我们将学习Python中的三个高级概念：生成器、协程以及它们如何应用于微服务架构。我们将从基础概念入手，逐步探讨它们的工作原理和实际应用。

概述 📋

生成器是一种特殊的迭代器，允许你按需生成值，而不是一次性计算并存储所有值。协程是生成器的扩展，支持双向通信，常用于异步编程。微服务是一种将应用程序构建为一组小型、独立服务的方法。理解生成器和协程是掌握现代Python异步编程和构建高效微服务的基础。

生成器：按需生成数据 🔄

上一节我们概述了本课程的核心主题。本节中，我们来看看生成器的基本概念。

生成器函数使用 yield 关键字来返回一个值，并暂停其状态。当再次调用时，它会从上次暂停的地方继续执行。

生成器函数示例：

def simple_generator():
    yield 1
    yield 2
    yield 3

# 使用生成器
gen = simple_generator()
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2
print(next(gen))  # 输出: 3

与返回列表的函数相比，生成器更节省内存，因为它不会一次性生成所有数据。

从生成器到协程 🤝

上一节我们介绍了生成器如何按需产生值。本节中，我们将探讨生成器如何演变为更强大的协程。

协程是生成器的泛化。它不仅可以通过 yield 产生值，还可以通过 .send(value) 方法接收外部传入的值，实现了双向数据流。

一个简单的协程示例：

def simple_coroutine():
    print("协程启动")
    x = yield  # 暂停，等待接收值
    print(f"接收到值: {x}")

coro = simple_coroutine()
next(coro)      # 启动协程，执行到第一个yield处暂停
coro.send(42)   # 向协程发送值42，协程恢复执行并打印

这使得函数可以在多个入口点暂停和恢复，成为管理并发任务的强大工具。

协程在异步编程中的应用 ⚡

上一节我们看到了协程的基本用法。本节中，我们来看看协程如何应用于异步编程，以提高I/O密集型程序的效率。

在异步编程中，当一个协程等待I/O操作（如网络请求）时，它可以主动让出控制权，让事件循环去执行其他就绪的协程，从而避免阻塞。

以下是使用 asyncio 库的异步协程示例：

import asyncio

async def fetch_data():
    print("开始获取数据")
    await asyncio.sleep(2)  # 模拟一个耗时的I/O操作
    print("数据获取完成")
    return {"data": 123}

async def main():
    task = asyncio.create_task(fetch_data())
    print("主程序可以继续做其他事情")
    result = await task
    print(f"收到结果: {result}")

asyncio.run(main())

这种模式使得单线程也能高效处理大量并发连接，是构建高性能微服务的关键。

构建微服务：概念与优势 🏗️

上一节我们探讨了协程如何助力异步编程。本节中，我们来看看如何将这些概念应用于微服务架构。

微服务架构将大型单体应用拆分为一组小型、松散耦合的服务。每个服务都围绕特定业务功能构建，并可以独立开发、部署和扩展。

以下是微服务的一些核心优势：

技术异构性：每个服务可以使用最适合其需求的技术栈。
弹性：一个服务的故障不会导致整个系统崩溃。
可扩展性：可以单独扩展负载高的服务。
易于部署：单个服务的更新无需重新部署整个应用。
组织结构匹配：服务结构可以更好地映射到开发团队的组织结构。

结合协程构建高效微服务 🌐

上一节我们介绍了微服务的优势。本节中，我们来看看如何结合异步协程来构建高效的微服务。

使用Python的异步框架（如 FastAPI、aiohttp），我们可以用协程轻松构建非阻塞的HTTP微服务。这种服务可以同时处理成千上万的客户端连接。

一个使用FastAPI的简单微服务示例：

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/247edc32e6dbd26bcc3acbc43868145c_5.png)

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    # 模拟异步数据库查询
    await asyncio.sleep(0.1)
    return {"item_id": item_id, "q": q}

在这个服务中，每个路由处理函数都是一个异步协程。当处理请求时，如果遇到 await（如等待数据库查询），事件循环就会去处理其他请求，极大提升了资源利用率和吞吐量。

总结 🎯

本节课中我们一起学习了Python中生成器、协程和微服务的核心知识。

我们首先了解了生成器如何通过 yield 关键字实现惰性求值，节省内存。接着，我们探讨了协程如何扩展生成器的概念，通过 .send() 方法实现双向通信，并成为Python异步编程的基石。最后，我们看到了如何利用异步协程构建高并发、高性能的微服务，并介绍了微服务架构的主要优势。

掌握这些概念，将帮助你编写出更高效、更易维护的现代Python应用程序。

064：将 Jupyter Notebook 转换为可重复的管道 📊

在本节课中，我们将学习如何将探索性的 Jupyter Notebook 代码，转化为一个结构清晰、可重复执行的数据处理或分析管道。这对于确保分析结果的可复现性和项目协作至关重要。

概述

大家好。感谢参加本次分享。本次演讲基于一次技术访谈，核心内容是探讨如何将 Jupyter Notebook 中的代码转换为可重复的、生产就绪的管道。我们将讨论这一过程中的关键工作和技术要点。

核心挑战与目标

上一节我们介绍了课程主题，本节中我们来看看转换工作的核心目标。Jupyter Notebook 非常适合交互式探索和快速原型开发，但其线性执行和混合代码、文本、输出的特性，使其难以进行版本控制、自动化测试和规模化部署。我们的目标是解决这些问题。

以下是转换工作的主要目标列表：

确保分析过程可以一键复现。
提高代码的可维护性和模块化程度。
便于团队协作与代码审查。
为自动化执行和集成到更大系统做准备。

转换策略与方法

理解了目标后，我们来看看具体的转换策略。关键在于将 Notebook 中混杂的代码逻辑进行解耦和重组。

我们将讨论正在进行的工作。核心思路是将 Notebook 分解为独立的、功能单一的脚本或模块。

我们将讨论正在进行的工作。这通常包括数据加载、数据清洗、特征工程、模型训练、评估和结果输出等步骤。

我们将讨论正在进行的工作。每个步骤都可以封装为一个函数或一个类，并保存在单独的 .py 文件中。

我们将讨论正在进行的工作。然后，使用一个主脚本或工作流管理工具（如 Makefile, Airflow, Prefect, Luigi）来定义和编排这些步骤的执行顺序与依赖关系。

关键实践步骤

上一节我们介绍了宏观策略，本节中我们深入探讨具体的实践步骤。这是一个从 Notebook 到管道的典型重构过程。

以下是实施转换的关键步骤列表：

代码提取与模块化：将 Notebook 中的代码单元格分类，提取出可重用的函数，放入独立的 Python 模块中。例如，一个数据清洗函数可以这样定义：

# data_cleaning.py
def clean_raw_data(input_path, output_path):
    df = pd.read_csv(input_path)
    # 执行清洗操作，如处理缺失值、去重等
    df_clean = df.dropna().drop_duplicates()
    df_clean.to_csv(output_path, index=False)
    return df_clean

参数化配置：将硬编码的文件路径、数据库连接信息、模型参数等提取到配置文件（如 config.yaml 或 .env 文件）中，使流程易于在不同环境（开发、测试、生产）中配置。
创建主执行脚本：编写一个 main.py 或 pipeline.py 脚本，按顺序调用各个模块函数，并传递配置参数。这定义了管道的执行逻辑。
依赖管理：使用 requirements.txt 或 Pipfile 明确列出项目依赖，确保环境一致性。核心概念是记录所有包及其版本。
```
# requirements.txt
pandas==1.5.0
scikit-learn==1.2.0
```
添加日志与错误处理：在关键步骤添加日志记录，并实现适当的异常捕获和处理，使管道运行状态更透明、更健壮。

总结

本节课中我们一起学习了将 Jupyter Notebook 转换为可重复管道的完整思路。我们从 Notebook 在协作和部署上的局限性出发，明确了转换的目标，并详细介绍了通过代码模块化、参数化配置和创建主执行脚本等核心步骤来实现这一目标的方法。掌握这一技能，能显著提升你的数据分析项目的专业性、可维护性和团队协作效率。

065：如何使用 OpenTelemetry 监控和故障排除应用程序 🔍

在本节课中，我们将学习如何使用 OpenTelemetry 来监控和排查应用程序中的问题。OpenTelemetry 是一个开源的可观测性框架，它可以帮助我们收集应用程序的追踪、指标和日志数据，从而更好地理解系统的运行状态和性能瓶颈。

1：什么是可观测性？ 📊

在深入 OpenTelemetry 之前，我们首先需要理解“可观测性”这个概念。可观测性是指通过系统外部输出的数据（如日志、指标、追踪）来理解其内部状态的能力。它与传统监控的区别在于，监控通常关注已知的问题和预设的指标，而可观测性更侧重于探索未知的问题和复杂的系统行为。

一个具备良好可观测性的系统，其内部状态可以通过三个核心支柱来推断：日志、指标和追踪。

2：OpenTelemetry 的核心概念 🧩

上一节我们介绍了可观测性的重要性，本节中我们来看看 OpenTelemetry 是如何实现它的。OpenTelemetry 提供了一套与供应商无关的 API、SDK 和工具，用于生成、收集和导出遥测数据。

以下是 OpenTelemetry 架构中的几个关键组件：

API：定义了一组接口，供应用程序代码调用以生成遥测数据（如创建 Span）。
SDK：实现了 API，负责处理数据（如采样、处理）并将其发送到导出器。
导出器：将处理后的数据发送到不同的后端系统，如 Jaeger、Prometheus 或云服务商的控制台。
收集器：一个独立的代理，可以接收、处理和导出遥测数据，通常部署在应用侧或作为一个中心化的服务。

其核心数据模型围绕 Trace 和 Span 构建。一个 Trace 代表一个完整的请求链路，而一个 Span 则代表该链路中的一个独立操作单元。它们的关系可以表示为：

一个 Trace = Span1 -> Span2 -> Span3 ...

3：如何集成 OpenTelemetry 🛠️

了解了核心概念后，我们来看看如何将 OpenTelemetry 集成到你的应用程序中。集成过程主要分为自动化和手动两种方式。

以下是集成 OpenTelemetry 的基本步骤：

选择并安装 SDK：根据你的编程语言（如 Java, Go, Python, JS），安装对应的 OpenTelemetry SDK。
```
# 以 Node.js 为例
npm install @opentelemetry/api
npm install @opentelemetry/sdk-node
```
配置自动检测（可选）：对于许多常见框架和库（如 Express, gRPC, HTTP），OpenTelemetry 提供了自动检测工具，可以无侵入式地收集数据。

手动插桩：在关键的业务逻辑处手动创建 Span，以记录自定义的操作和属性。

const span = tracer.startSpan('my_operation');
span.setAttribute('user.id', userId);
// ... 执行操作 ...
span.end();

配置导出器：设置将数据发送到哪里，例如控制台、Jaeger 或 OTLP 收集器。
部署收集器（可选）：如果你需要更复杂的数据处理或路由，可以部署 OpenTelemetry Collector。

4：故障排除实战 🐛

现在，我们已经将 OpenTelemetry 集成到了应用中，本节中我们通过一个模拟场景来看看如何利用它进行故障排除。

假设一个用户请求失败，我们通过查看追踪数据来定位问题。在 Jaeger 或类似的可视化界面中，你可以看到完整的请求链路图。一个失败的请求，其链路中通常会有一个标记为错误的 Span。

以下是利用 OpenTelemetry 数据进行故障排查的典型流程：

发现异常：通过监控仪表盘或告警，发现错误率上升或延迟增加。
查询追踪：根据出错的时间、服务或用户 ID 筛选出相关的 Trace。
分析链路：展开出错的 Trace，查看每个 Span 的详细信息，包括开始/结束时间、标签、日志事件以及可能关联的错误堆栈。
定位根因：通过对比成功和失败的 Trace，或者分析耗时异常的 Span，定位到出问题的具体服务、数据库查询或外部 API 调用。
验证修复：在修复问题后，继续观察相关指标和追踪，确认问题已解决。

总结 📝

本节课中我们一起学习了 OpenTelemetry 的基础知识与应用。我们从可观测性的概念出发，了解了 OpenTelemetry 作为统一标准的优势。接着，我们探讨了其核心架构与数据模型，特别是 Trace 和 Span 的概念。然后，我们一步步介绍了如何将 OpenTelemetry 集成到应用程序中，包括自动检测和手动插桩。最后，我们通过一个实战场景，演示了如何利用收集到的遥测数据快速定位和解决系统故障。掌握 OpenTelemetry 能显著提升你对复杂分布式系统的洞察力和排障效率。

066：打包你的Python代码 - 随身携带的艺术 🚀

在本节课中，我们将学习如何将Python代码打包成可分发、可安装的格式。这个过程让你能够轻松地与他人分享你的项目，或者将其部署到不同的环境中。我们将从基础概念开始，逐步介绍打包的核心工具和步骤。

打包基础概念 📦

上一节我们介绍了打包的目的，本节中我们来看看打包涉及的核心概念。理解这些概念是成功打包项目的关键。

包是包含Python模块和其他支持文件的目录。一个标准的包目录通常包含一个特殊的 __init__.py 文件。

分发是指打包后的存档文件（如 .tar.gz 或 .whl 文件），它包含了你的包以及元数据，可以被上传到PyPI（Python包索引）供他人安装。

核心的打包元数据通过 setup.py 或 pyproject.toml 文件来定义。一个最简单的 setup.py 文件示例如下：

from setuptools import setup, find_packages

setup(
    name="your_package_name",
    version="0.1.0",
    packages=find_packages(),
)

项目结构与关键文件 🗂️

了解了基础概念后，我们需要构建一个标准的项目结构。一个组织良好的项目结构是打包成功的前提。

以下是创建一个可打包Python项目的基本文件和目录结构：

your_package/: 这是你的主包目录，里面存放你的Python模块（.py文件）。
setup.py 或 pyproject.toml: 这是打包的配置文件，定义了项目的名称、版本、依赖等元数据。
README.md: 项目的说明文档。
LICENSE: 项目的开源许可证文件。
tests/: 存放测试代码的目录。

使用Setuptools进行打包 🔧

上一节我们规划了项目结构，本节中我们来看看如何使用Setuptools这个最常用的工具来执行打包操作。

首先，确保你安装了最新版的setuptools和wheel：

pip install --upgrade setuptools wheel

接下来，在项目根目录下运行打包命令：

python setup.py sdist bdist_wheel

这个命令会生成两种分发格式：

sdist (Source Distribution): 在 dist/ 目录下生成一个 .tar.gz 源码归档文件。
bdist_wheel (Built Distribution): 在 dist/ 目录下生成一个 .whl 二进制轮子文件。这是一种更现代的格式，安装速度更快。

上传到PyPI 🌐

我们已经成功在本地创建了分发包，本节中我们来看看如何将其分享给全世界——上传到PyPI。

首先，你需要注册PyPI的账户。然后，安装上传工具Twine：

pip install --upgrade twine

使用Twine上传你在 dist/ 目录下生成的包文件：

twine upload dist/*

系统会提示你输入PyPI的用户名和密码。上传成功后，其他人就可以通过 pip install your_package_name 来安装你的包了。

现代打包配置：pyproject.toml ⚙️

除了传统的 setup.py，现代Python打包更推荐使用 pyproject.toml 文件。它提供了更清晰、更标准的配置方式。

以下是一个 pyproject.toml 的示例配置：

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "your_package_name"
version = "0.1.0"
authors = [{name = "Your Name", email = "your.email@example.com"}]
description = "A brief description of your package"
readme = "README.md"
license = {text = "MIT"}
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
]
dependencies = [
    "requests>=2.25.0",
    "numpy>=1.20.0"
]

[project.optional-dependencies]
dev = ["pytest>=6.0", "black"]

[project.urls]
Homepage = "https://github.com/you/your_package"

使用 pyproject.toml 时，你可以直接使用 pip 来构建和安装项目：

pip install .

或者构建分发包：

pip install build
python -m build

总结 📝

本节课中我们一起学习了Python代码打包与分发的完整流程。我们从打包的核心概念和项目结构讲起，详细介绍了如何使用Setuptools和setup.py进行传统打包，以及如何用Twine将包上传到PyPI。最后，我们还探讨了更现代的pyproject.toml配置方式。掌握这些技能，你就能将自己的Python项目变成可以轻松分享和安装的软件包，真正做到“随身携带”。

067：课程概述与准备 🗺️

![我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。我会来这里。

在本节课中，我们将要学习如何使用 Python 和 PyQGIS 来制作专业且美观的地图。PyQGIS 是 QGIS 地理信息系统的 Python 接口，它允许我们通过编写脚本来自动化地图制作流程，实现复杂的地图样式和布局。

课程概述

本节课是系列课程的开始，主要目标是介绍课程的整体框架，并指导大家完成学习前的准备工作。我们将确保开发环境配置正确，为后续的实际操作打下基础。

上一节我们介绍了课程的整体目标，本节中我们来看看开始学习前需要做哪些具体准备。

准备工作

为了顺利进行后续的编程和地图制作，我们需要提前准备好相应的软件和工具。以下是开始学习前必须完成的几个步骤。

安装 QGIS：访问 QGIS 官方网站下载并安装最新稳定版本的 QGIS 软件。
配置 Python 环境：确保系统中安装了 Python，并且版本与 PyQGIS 兼容。通常 QGIS 会自带 Python 环境。
设置代码编辑器：选择一个你熟悉的代码编辑器或集成开发环境（IDE），例如 VS Code 或 PyCharm，并配置好与 QGIS Python 解释器的连接。
了解基本概念：对 GIS（地理信息系统）的基本概念，如矢量数据、栅格数据、坐标系等，有初步了解会更有帮助。

核心工具与概念

在 PyQGIS 编程中，最核心的是 QgsProject 和 QgsVectorLayer 等类。它们是我们操作地图数据和项目的基础。

例如，加载一个矢量图层到当前项目的代码如下：

# 定义图层路径
layer_path = “path/to/your/shapefile.shp”
# 创建矢量图层对象
layer = QgsVectorLayer(layer_path, “layer_name”, “ogr”)
# 将图层添加到当前项目
QgsProject.instance().addMapLayer(layer)

总结

本节课中我们一起学习了本系列课程的目标和开始前的准备工作。我们概述了将使用 Python 和 PyQGIS 来自动化地图制作，并列出了安装软件、配置环境等必要的准备步骤。确保完成这些准备，我们就能在接下来的课程中顺利开始编写代码，创建酷炫的地图。

068：一个带有Rust运行时的异步Python网络框架 🚀

在本节课中，我们将要学习一个名为 Robyn 的异步Python网络框架。这个框架的特殊之处在于它使用Rust语言编写的运行时，旨在为Python提供高性能的异步网络处理能力。我们将探讨其核心概念、优势以及基本使用方法。

概述

Robyn是一个新兴的异步网络框架，它通过集成Rust运行时来提升Python在I/O密集型任务中的性能。传统的Python异步框架（如asyncio）虽然有效，但在某些高性能场景下可能遇到瓶颈。Robyn的设计目标就是解决这一问题。

核心架构与优势

上一节我们介绍了Robyn的基本定位，本节中我们来看看它的核心架构和主要优势。

Robyn的核心思想是将高性能的Rust运行时与易用的Python API相结合。其架构可以简化为以下模型：

框架架构 ≈ Python应用层 + Rust运行时层

这种设计带来了几个关键优势：

以下是Robyn框架的主要优势列表：

高性能：利用Rust的高效并发模型处理网络I/O，性能通常优于纯Python实现。
易于使用：开发者使用熟悉的Python语法编写业务逻辑，无需深入学习Rust。
异步支持：原生支持异步编程范式，适合处理大量并发连接。
内存安全：底层运行时由内存安全的Rust语言保证，减少了某些类型错误的风险。

安装与快速开始

了解了Robyn的优势后，我们现在可以开始实践。本节将指导你如何安装Robyn并创建一个简单的“Hello World”应用。

首先，你需要使用pip包管理器来安装Robyn。

pip install robyn

安装完成后，你可以创建一个新的Python文件（例如 main.py）并写入以下代码：

from robyn import Robyn

app = Robyn(__file__)

@app.get("/")
async def hello(request):
    return "Hello, World!"

app.start(port=8080, url="0.0.0.0")

这段代码创建了一个简单的Web服务器。它定义了一个路由，当用户访问网站根路径（“/”）时，服务器会返回“Hello, World!”。

核心概念详解

在快速体验之后，我们来深入理解一下代码中涉及的核心概念。

1. 应用实例
代码 app = Robyn(__file__) 创建了一个Robyn应用的核心实例。这是所有路由和配置的起点。

2. 路由装饰器
@app.get("/") 是一个装饰器。它告诉框架：将接下来的函数（hello）与HTTP GET方法和特定的URL路径（“/”）绑定。Robyn也支持 @app.post、@app.put 等其他HTTP方法。

3. 异步处理函数
处理函数 hello 被定义为 async def。这意味着它是一个异步函数，可以在其中使用 await 关键字来调用其他异步操作（如数据库查询），而不会阻塞整个服务器。

4. 启动服务器
app.start() 方法是启动Web服务器的命令。port 参数指定监听端口，url 参数指定绑定的主机地址。

总结

本节课中我们一起学习了Robyn框架。我们了解到Robyn是一个通过集成Rust运行时来提升性能的异步Python网络框架。我们探讨了其高性能和易用性的优势，完成了从安装到编写第一个“Hello World”应用的实践步骤，并详细解释了应用实例、路由装饰器、异步处理函数等核心概念。

通过结合Python的简洁和Rust的性能，Robyn为开发者构建高效的网络服务提供了一个有吸引力的新选择。

069：测试中自毁的10种方式 🧨

在本节课中，我们将学习Shai Geva在演讲中总结的、测试人员在工作中可能无意中“自毁”的10种常见方式。这些行为会降低测试效率、损害团队信任，并最终影响产品质量。我们将逐一分析这些行为，并提供避免它们的建议。

概述

有效的软件测试是确保产品质量的关键环节。然而，测试人员自身的一些习惯和行为可能会阻碍测试工作的顺利进行，甚至导致测试失败。本节内容基于Shai Geva的经验，旨在帮助测试人员识别并避免这些“自毁”行为。

P69：1：缺乏明确目标 🎯

从某种意义上说，我们可以生活。从另一个角度来看，感谢你们的到来。今天我将讨论一下决策时代。但是，这与项目的背景有些不符。

所以，潜在的是要让它签署，我将为你带来相同的内容，时间不长。主要是在区域方面，我们将讨论区域的整体右侧。开发者的情况也是如此，根据右侧的情况。因此，那些重要的人以及考虑影响的人，开发者的情况也是相同的。

核心问题：测试工作没有清晰、一致的目标，与项目整体目标脱节。

避免方法：在测试开始前，与项目团队（特别是开发者）共同明确测试范围和验收标准。确保测试活动始终围绕项目核心目标展开。

上一节我们介绍了缺乏明确目标的问题。接下来，我们来看看沟通不畅如何导致测试失效。

P69：2：沟通不畅与假设 🤐

这有点问题。我马上要谈论这个问题。我以为这是又一次的演讲，因为我必须达到一个非常高的标准。这个工作非常有趣。我将讨论这个地区的背景，因为我认为人们是快乐的。你只需要做出一个更普遍的决定。或者更具体一点。

核心问题：测试人员基于个人假设进行测试和报告，而不是基于事实和明确的沟通。

避免方法：主动沟通，澄清所有疑问。使用明确的、可验证的语言编写测试用例和报告Bug。公式可以表示为：有效沟通 = 事实 + 清晰表述。

沟通问题往往源于对信息真实性的忽视。下面，我们将探讨另一个关键问题：忽视事实。

P69：3：忽视或否认事实 ❌

还有一个原因是这将不是真的。因为这将不是真的。这不是真的，但这将不是真的。这不是真的。这不是真的。这不是真的。这不是真的。这不是真的。这不是真的。这不是真的。这不是真的。

核心问题：选择性忽略测试证据，或否认不符合预期的测试结果。

避免方法：坚持客观性。所有测试结果，无论是否符合预期，都应被忠实记录和分析。测试报告应基于数据，而非个人愿望。

在确认了事实的重要性后，我们需要审视测试人员的专业定位。错误的自我定位是另一种“自毁”方式。

P69：4：错误的自我定位 👨‍🔬

而且我不是科学家，我认为我像是科学家。我不是科学家。我似乎有很多事情要讨论。我不是一位插图科学家。我不是科学家。但我不是制作人。我是一名监督员。我是一名科学家。我是一名教授。一个教授。我是一个教授，一个教授。我是一个教授，一个教授，一个教授。我是一个护士。一个研究员。我是一个教授，一个学者，一个院长，但我不是一个老师。我是一个学者，一个老师。我需要从中学习。我需要向我的同行学习。并说“最佳”“最佳”“最佳的”“最佳”。然后就是话题视频的结束。

核心问题：测试人员对自身角色认知模糊，试图扮演开发者、经理或架构师的角色，而非专注于测试本身。

避免方法：明确测试人员的核心职责是发现风险和信息。与开发团队协作，但保持测试活动的独立性和客观性。

定位清晰后，测试执行过程本身也可能出现问题。例如，测试不彻底或过快。

P69：5：测试不彻底与过快 🏃

然而它仍然无法回应与你的对话。通常，如果它没有做对，那可能会变得糟糕。其他的反对时，它会说得非常快，但有点不太准确。某一天，它会提出一个界限。因为它没有停下来，这可能会更困难，所以会变得糟糕。然后会给你一点一点更多，这不会花太久。

核心问题：为了追求速度而进行肤浅的测试，遗漏深层次的缺陷。

避免方法：平衡速度与深度。采用基于风险的测试策略，对核心功能进行深入测试。代码示例：在自动化测试中，除了happy path，也要编写edge case和negative test。

# 示例：一个不彻底的测试（只测了正常情况）
def test_login_success():
    result = login(“valid_user”, “valid_pass”)
    assert result == True

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/7dd90960b52298bfeb8cd30ec95b4f07_13.png)

# 改进：更全面的测试
def test_login_failure_invalid_user():
    result = login(“invalid_user”, “valid_pass”)
    assert result == False

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/pycon-2023/img/7dd90960b52298bfeb8cd30ec95b4f07_15.png)

def test_login_failure_invalid_pass():
    result = login(“valid_user”, “invalid_pass”)
    assert result == False

def test_login_failure_empty_input():
    result = login(“”, “”)
    assert result == False

测试的深度也取决于我们设定的目标。模糊或错误的目标会直接导致测试失败。

P69：6：目标模糊或错误 🎯

所以对于，我所说的。这些我们使用的，任何都取决于怎么说。当然，在我们的互动中，它将会完成。因此，解决方案本身的目标是，首先。我们要特别谈谈这个，在此之前它们并不重要，我之前做过。但这确实是一件特别的事情。而且，尽管有语言的问题，我们希望在结论中语言能更具体。要看到我们所看到的时间示例，我认为它破裂了，然后是一般的。我认为，要理解，我们必须担心我们想去的地方。

核心问题：测试目标不具体、不可衡量，或者目标本身就是错误的（例如，追求100%无Bug）。

避免方法：设定SMART测试目标（具体的、可衡量的、可实现的、相关的、有时限的）。例如，“在本轮测试中，对支付模块的核心流程完成100%的路径覆盖，并将高优先级缺陷的发现率提高20%”。

即使目标正确，实现过程也可能因为缺乏计划而变得混乱漫长。

P69：7：过程混乱且缺乏计划 📝

似乎在我们收集之前需要做一些工作。通常如此，但那种成长从未发生。这是我们想要达到的目标。所以，这非常，非常漫长。这也是更好的。它并不是最具体的。我在其中有一个问题。这比任何人都更具体。非常混乱，我假设，我们对此并不确定。但是无论如何，这都不会是真的。所以，这并不完全准确。然后。那就是目标，那就是目标。

核心问题：测试活动没有计划，随机、混乱地进行，导致效率低下和资源浪费。

避免方法：制定详细的测试计划，包括测试范围、资源、进度、风险和退出标准。并使用看板或任务列表来跟踪执行情况。

清晰的计划需要明确的交付物定义。对测试产出物的错误认知是下一个陷阱。

P69：8：对产出物的错误认知 📄

这不会是一个事实，或者在任何社区，它不是一本书。这是针对特定语言的建议。这是一种不是语言的语言。这是我们需要实现的目标。这是我们需要实现的目标。这就是我们人们的目标或指南，或者说是我们家庭的目标。例如。我认为我们在使用这个标题，但我们必须转向不同的标题。所以，在课程的开始，我们将放弃我们的标题。然后我们将继续放弃我们的标题。我们必须把这留给你。我是说。无论标题的最佳部分是什么，重要的是要知道它是正确的。我们不会总结并查看它。

核心问题：认为测试报告、Bug列表等是最终“产品”，而忘记了测试的真正产出是质量评估信息和风险洞察。

避免方法：关注报告背后的信息和价值。测试报告应服务于决策（如是否可以发布），而不仅仅是记录活动。

测试工作不是在真空中进行的，它受到组织和社会环境的影响。忽视这一点是危险的。

P69：9：忽视组织与社会背景 🏛️

这非常，非常慢。社会健康，你知道。政府应该做些什么？这是政府形态的一个背景。而这并不是你无法避免的。因此，很多时候你会提起，也许这只是我--。这是一项商业，您认为，好的。政府非常关注。但是法案是地方性的。而且——除非您担心——法案是地方性的。而且——她没有发现——。法案是可判断的。不，不——如果是地方性的，她仍然是斗狗斗狗。而这一点至少在一般情况下是如此，我的意思是，太多人在——。

核心问题：忽略项目所处的商业目标、公司文化、法规政策等外部环境，导致测试建议不切实际。

避免方法：理解业务。测试应始终围绕商业价值和用户需求展开，并考虑合规性等约束条件。

最后，即使意识到所有问题，不采取行动或给出不切实际的建议，也会让测试工作前功尽弃。

P69：10：不行动与不切实际的建议 🛑

事情发生得太快了。要谈三小时，实际上可能会有五小时。不会有五小时的。所以，我的建议是，尽量试试——我会稍微提出一个想法。我会一个，一个，继续下去。现在我会工作，但仍然——事情仍然存在。这就是问题所在。我们就这样处理——这就是我能做到的。这只是我的责任。只是这样——，只是这样——，你只能下订单，或者四处跑。如果你想跑，你可能会碰到像这样的事情。我想说的就是，我会坚持我之前说过的。别——，就是不要这么做。你是全职的，而你正在进行第 24 天。因为你正在进行第 24 天，因为这不过是个 3-3-3。我是说。你不需要接触我的身体。事情会变得非常，非常、非常糟糕。

核心问题：1. 只发现问题而不推动解决。2. 提出在现有时间、资源或技术条件下无法实现的“完美”建议。

避免方法：1. 积极跟进，推动缺陷修复和流程改进。2. 提出渐进式和可落地的改进建议。例如，与其要求“重写整个系统架构”，不如建议“在下个迭代中，为模块X增加单元测试覆盖”。

（示意图：从混乱到有序的改进过程）

总结

在本节课中，我们一起学习了Shai Geva提出的测试人员可能“自毁”的10种方式：

缺乏明确目标：测试与项目目标脱节。
沟通不畅与假设：基于假设而非事实沟通。
忽视或否认事实：不客观对待测试结果。
错误的自我定位：角色认知模糊，越俎代庖。
测试不彻底与过快：追求速度牺牲深度。
目标模糊或错误：设定不切实际或模糊的目标。
过程混乱且缺乏计划：测试活动无章法。
对产出物的错误认知：把报告当目的，而非手段。
忽视组织与社会背景：脱离业务和现实环境。
不行动与不切实际的建议：只提问题不解决，或建议无法落地。

避免这些陷阱的关键在于保持专业性、客观性、沟通意识和业务聚焦。优秀的测试人员不仅是技术的践行者，更是团队协作的促进者和项目风险的清晰报告者。

071：让复杂想法变得简单 📊

在本节课中，我们将学习一种被称为“失落的图表艺术”的数据可视化方法。这种方法旨在通过巧妙的图表设计，将复杂的数据和想法转化为清晰、直观的视觉呈现，从而帮助观众快速理解核心信息。

概述

数据可视化不仅仅是绘制图表，更是一种沟通艺术。传统的图表有时难以有效传达复杂关系或深层洞见。本节课将介绍一系列超越常规的图表类型和设计原则，它们曾一度被忽视，但能极大地提升信息传达的效率和效果。

上一节我们概述了图表艺术的目标，本节中我们来看看图表设计的核心挑战与解决思路。

P71：1：图表设计的核心挑战

现代数据呈现常面临信息过载的问题。图表元素过多或关系复杂时，观众难以快速抓住重点。

解决这一挑战的关键在于简化与聚焦。图表设计的首要任务是突出核心数据关系，过滤次要信息。

理解了核心挑战后，我们来探讨实现简化与聚焦的具体设计原则。

P71：2：核心设计原则

以下是实现有效可视化的几个关键原则：

减少认知负荷：设计应让观众用最少的脑力理解最多的信息。避免使用需要复杂解读的视觉编码。
突出对比：利用颜色、大小、位置等视觉变量，清晰区分数据的不同类别或重要程度。
讲述故事：图表应有一个清晰的叙事逻辑，引导观众的视线和思维，而不仅仅是数据的堆砌。
选择合适的图表类型：不同的数据关系和传达目的，对应不同的最佳图表形式。

掌握了设计原则，我们就可以深入了解一些具体且强大的“失落”图表类型了。

P71：3：强大的“失落”图表类型

上一节我们介绍了通用原则，本节中我们来看看几种特别有效的特定图表。

斜率图

斜率图专注于展示两个时间点或状态之间数据的变化趋势和排名更迭。

核心价值：清晰显示谁在进步、谁在退步，以及变化的幅度。

例如，比较公司各部门在两个季度的绩效排名变化，斜率图能一目了然地显示哪些部门排名上升（正斜率），哪些下降（负斜率）。

哑铃图

哑铃图用于比较同一项目在两个不同组别、时间点或条件下的数值。

核心价值：精准对比两组数据间的差异。

它由一条线段连接两个数据点构成，线段长度直观代表了差异的大小。常用于展示A/B测试结果、前后测对比等。

单元图

单元图将总体划分为若干个小单元（如小方块、圆圈），每个单元代表一个统计单位（如1%的人口，一个病人）。

核心价值：将抽象比例具象化，增强情感共鸣和直观理解。

当你说“这个治疗方案对30%的患者有效”时，听众可能无感。但展示一个由100个小方块组成、其中30个被涂色的网格，冲击力更强。公式上，它实现了：
抽象比例 -> 具体可数的单元集合

除了上述类型，还有一种图表能优雅地揭示数据分布与组成。

P71：4：展示分布与组成

小提琴图

小提琴图是箱形图与密度图的结合。它展示了数据的完整分布形态，包括中位数、四分位数以及任意位置的密度。

核心价值：揭示数据分布的多模态、偏态和异常值，信息量远大于简单的平均值或中位数。

在代码分析中，比较不同算法运行时间的分布时，小提琴图可以清晰显示算法A是否稳定（图形瘦高），而算法B是否偶尔有极端耗时（图形底部有长尾）。

最后，我们来学习如何将多个简单图表组合起来，讲述更复杂的数据故事。

P71：5：组合图表与叙事

复杂的想法往往需要多角度呈现。通过将多个简单的图表（如折线图、条形图、散点图）以逻辑顺序排列在同一视图中，可以构建一个逐步深入的叙事。

核心方法：

设定场景：用第一个图表展示整体背景或趋势。
深入细节：用后续图表分解整体，展示关键组成部分或影响因素。
揭示关系：用散点图等展示变量间的相关性。
总结洞见：用最简明的图表（如突出关键数字的大字报）重申核心结论。

这种“小 multiples”或“仪表板”式的设计，能引导观众像阅读故事一样理解数据。

总结

本节课中我们一起学习了“失落的图表艺术”。我们从图表设计的核心挑战出发，探讨了简化与聚焦的原则。接着，我们深入了解了斜率图、哑铃图、单元图和小提琴图这几种强大而未被充分利用的图表类型，它们分别擅长展示变化、对比、比例和分布。最后，我们学习了如何通过组合图表来构建数据叙事。记住，优秀的可视化目标是让复杂想法变得简单直观，而不仅仅是制作一个“正确”的图表。掌握这些工具，你将能更有效地用数据沟通和说服。

072：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存了哪种类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来实现这些操作。

使用 type() 函数可以查看任何变量的数据类型。

height = 1.75
print(type(height))  # 输出：<class ‘float’>

如果你需要转换类型，可以使用特定的转换函数。

以下是常用的类型转换方法：

转换为整数：使用 int()。例如，int(3.14) 会得到 3。
转换为浮点数：使用 float()。例如，float(10) 会得到 10.0。
转换为字符串：使用 str()。例如，str(100) 会得到 ‘100’。

注意：不是所有转换都能成功。例如，尝试 int(“你好”) 将无法进行，因为文字不能直接变成数字。

动手试一试：一个简单例子✍️

现在，让我们把学到的知识组合起来，创建一个简单的个人信息卡片程序。

# 1. 使用变量存储信息
name = “张伟”
age = 25
height = 1.80

# 2. 将年龄（整数）转换为字符串，以便与其他字符串连接
age_str = str(age)

# 3. 打印出组合好的信息
print(“姓名：” + name)
print(“年龄：” + age_str + “岁”)
print(“身高：” + str(height) + “米”)

运行这段代码，你将在屏幕上看到格式整齐的个人信息。通过这个例子，你实践了如何定义变量、理解不同数据类型，并在需要时进行类型转换。

本节课中我们一起学习了Python的变量与数据类型。我们知道了变量是存储数据的容器，并认识了整数、浮点数和字符串这三种基础数据类型。同时，我们也掌握了使用 type() 查看类型，以及使用 int(), float(), str() 进行类型转换的方法。掌握这些概念，你已经为学习更复杂的Python操作打下了坚实的基础。下一章，我们将探索如何让这些数据“动”起来，进行基本的运算。

073：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存的是什么类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来完成这些操作。

要查看一个变量的类型，可以使用 type() 函数。

my_variable = 100
print(type(my_variable))  # 输出：<class 'int'>

数据类型之间可以相互转换，但必须符合逻辑。例如，可以把数字“123”转换成字符串，但很难把字符串“你好”转换成一个整数。

以下是三种常见的类型转换函数：

int()：将数据转换为整数。例如 int(“123”) 会得到整数 123；int(3.14) 会得到整数 3（直接去掉小数部分）。
float()：将数据转换为浮点数。例如 float(“3.14”) 会得到浮点数 3.14；float(10) 会得到浮点数 10.0。
str()：将数据转换为字符串。几乎任何数据都能转换。例如 str(100) 会得到字符串 “100”。

给变量起个好名字✏️

变量名就像盒子的标签，一个好名字能让你的代码更容易被理解（包括未来的你自己）。Python为变量命名制定了一些规则和约定。

以下是命名变量时需要遵守的规则和建议：

规则（必须遵守）：
1. 变量名只能包含字母、数字和下划线 _。
2. 变量名不能以数字开头。
3. 变量名不能是Python的保留关键字（如 if， for， print等）。
约定（建议遵守）：
1. 使用描述性的名称，让人一眼就知道变量用途（如用 student_name 而不是 sn）。
2. Python习惯使用小写字母和下划线来分隔单词，这种风格称为“蛇形命名法”。例如：user_age， total_price。

动手试一试💻

现在，让我们把学到的知识组合起来，写一个简单的程序。这个程序会收集用户信息，并进行简单的处理和输出。

# 1. 获取用户输入（输入的内容默认是字符串类型）
user_name = input("请输入你的名字：")
user_age_input = input("请输入你的年龄：")

# 2. 转换数据类型：将字符串类型的年龄转换为整数，以便进行数学计算
user_age = int(user_age_input)

# 3. 进行计算：计算明年年龄
next_year_age = user_age + 1

# 4. 组合信息并输出
# 注意：打印时需要用str()将数字转换回字符串，才能和其他字符串连接
greeting = user_name + "，你好！你明年就" + str(next_year_age) + "岁了。"
print(greeting)

本节课中我们一起学习了Python编程的起点：变量与数据类型。我们知道了变量是存储数据的容器，并了解了整数、浮点数和字符串这三种基本数据类型。我们还学会了如何使用 type() 函数查看类型，以及如何使用 int()， float()， str() 进行类型转换。最后，我们掌握了为变量命名的规则与最佳实践，并完成了一个综合性的练习。牢固掌握这些概念，将为后续学习更复杂的编程知识打下坚实的基础。

074：变量与数据类型

在本节课中，我们将要学习Python编程中最基础的两个概念：变量和数据类型。理解它们是编写任何程序的第一步。

什么是变量？🤔

变量是计算机内存中用于存储数据的“容器”或“标签”。你可以把变量想象成一个盒子，盒子上贴着一个名字标签，盒子里可以存放各种东西。

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。等号左边是变量名，右边是你想存储的值。

# 创建一个名为 message 的变量，并将字符串“你好，世界！”存储进去
message = "你好，世界！"

上一节我们介绍了变量的基本概念，本节中我们来看看如何给变量命名。

变量命名规则 📝

给变量起名字需要遵循一些特定的规则，以下是Python中变量命名的核心规则：

变量名只能包含字母、数字和下划线（_）。
变量名不能以数字开头。
变量名不能是Python的保留关键字（如 if、for、while等）。
变量名是区分大小写的（例如，age 和 Age 是两个不同的变量）。

了解了如何创建和命名变量后，接下来我们看看变量中可以存放哪些不同类型的数据。

基本数据类型 🔢

数据类型定义了变量中存储的数据的种类。Python有一些内置的基本数据类型，最常见的有以下几种：

整数 (int)
整数是没有小数部分的数字，可以是正数、负数或零。
```
age = 25
temperature = -10
count = 0
```
浮点数 (float)
浮点数是带有小数点的数字，用于表示实数。
```
price = 19.99
pi = 3.14159
height = 1.75
```
字符串 (str)
字符串是由一系列字符组成的文本。在Python中，字符串需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
```
name = "小明"
greeting = ‘Hello’
address = “北京市朝阳区”
```
布尔值 (bool)
布尔值只有两种可能：True（真）或 False（假）。它们通常用于逻辑判断。
```
is_student = True
has_passed = False
```

我们已经认识了不同的数据类型，那么如何查看一个变量的类型呢？

使用 `type()` 函数查看类型 🔍

Python提供了一个内置函数 type()，可以返回任何变量或值的数据类型。这在调试和了解数据时非常有用。

# 定义几个不同类型的变量
score = 95
average = 95.5
course = “Python”
is_enrolled = True

# 使用 type() 函数查看它们的类型
print(type(score))      # 输出：<class ‘int’>
print(type(average))    # 输出：<class ‘float’>
print(type(course))     # 输出：<class ‘str’>
print(type(is_enrolled))# 输出：<class ‘bool’>

变量的重新赋值与动态类型 🔄

Python中的变量是“动态类型”的，这意味着同一个变量可以在程序运行过程中被重新赋值为不同类型的数据。

# 变量 x 最初被赋值为整数
x = 10
print(x)         # 输出：10
print(type(x))   # 输出：<class ‘int’>

# 之后，可以将 x 重新赋值为一个字符串
x = “现在我是文本了”
print(x)         # 输出：现在我是文本了
print(type(x))   # 输出：<class ‘str’>

总结 📚

本节课中我们一起学习了Python编程的基石：变量和数据类型。

变量是存储数据的命名容器，通过 = 赋值。
变量命名需遵循特定规则（字母、数字、下划线，不以数字开头）。
基本数据类型包括用于整数的 int、用于小数的 float、用于文本的 str 和用于真假的 bool。
可以使用 type() 函数来检查任何值或变量的数据类型。
Python的变量是动态类型的，可以随时被重新赋值为新的、不同类型的数据。

掌握这些概念是后续学习更复杂的操作（如数学运算、字符串处理和控制流程）的基础。

075：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存的是什么类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来完成这些操作。

type() 函数就像是一个“类型检测仪”，可以告诉我们任何数据的类型。

height = 175.5
print(type(height))  # 输出：<class ‘float’>，表示这是一个浮点数

而在实际编程中，我们经常需要在不同类型间转换。例如，将用户输入的文本（字符串）转换成数字进行计算。

以下是三种常见的类型转换函数：

int()：将数据转换为整数。例如，int(“10”) 得到整数 10，int(9.8) 得到整数 9（直接去掉小数部分）。
float()：将数据转换为浮点数。例如，float(“3.14”) 得到浮点数 3.14，float(7) 得到浮点数 7.0。
str()：将数据转换为字符串。例如，str(100) 得到字符串 “100”。

动手试一试✍️

理论需要结合实践。让我们通过一个简单的例子，把刚才学到的知识用起来。

假设我们要编写一个程序，计算购买苹果的总价。我们知道单价和重量，需要计算总金额。

# 步骤1：定义变量（使用有意义的变量名）
price_per_kg = 8.5  # 苹果单价，浮点数
weight_kg = 2.3     # 苹果重量，浮点数

# 步骤2：进行计算
total_cost = price_per_kg * weight_kg  # 计算总价

# 步骤3：输出结果
# 注意：字符串和数字不能直接相加，需要用str()转换
print(“苹果单价：” + str(price_per_kg) + “元/公斤”)
print(“购买重量：” + str(weight_kg) + “公斤”)
print(“总价是：” + str(total_cost) + “元”)

运行这段代码，你会看到计算出的总价。尝试修改 price_per_kg 和 weight_kg 的值，再次运行，看看结果如何变化。

总结📝

本节课中我们一起学习了Python编程的起点：变量与数据类型。

我们知道了变量是一个存储数据的命名容器，通过 = 来赋值。
我们认识了三种基本数据类型：用于整数的int，用于小数的float，和用于文本的str。
我们学会了使用 type() 函数查看类型，以及使用 int(), float(), str() 函数在类型间进行转换。
最后，我们通过一个计算水果价格的小例子，实践了如何定义变量、进行运算并输出结果。

牢固掌握这些概念，就像打好了地基，接下来我们就可以学习如何使用这些“砖块”来构建更复杂的程序逻辑了。

076：变量与数据类型

在本节课中，我们将要学习Python编程中最基础的两个概念：变量和数据类型。理解它们是编写任何程序的第一步。

什么是变量？🤔

变量是计算机内存中用于存储数据的“容器”或“标签”。你可以把变量想象成一个盒子，盒子上贴着一个名字标签，盒子里可以存放各种东西。

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。等号左边是变量名，右边是你想存储的值。

# 创建一个名为 message 的变量，并将字符串“你好，世界！”存储进去
message = "你好，世界！"

上一节我们介绍了变量的基本概念，本节中我们来看看如何给变量命名。

变量命名规则 📝

给变量起名字需要遵循一些特定的规则，以下是Python中变量命名的核心规则：

变量名只能包含字母、数字和下划线（_）。
变量名不能以数字开头。
变量名不能是Python的保留关键字（如 if、for、while等）。
变量名是区分大小写的（例如，age 和 Age 是两个不同的变量）。

了解了如何命名变量后，接下来我们看看变量里可以存放哪些不同类型的数据。

基本数据类型 🔢

Python中内置了几种基本的数据类型，用于表示不同种类的数据。最常见的有以下几种：

整数
整数是没有小数部分的数字，可以是正数、负数或零。
```
age = 25
temperature = -10
count = 0
```
浮点数
浮点数是带有小数点的数字，用于表示实数。
```
price = 19.99
pi = 3.14159
height = 1.75
```
字符串
字符串是由一系列字符组成的文本。在Python中，字符串需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
```
name = "小明"
greeting = ‘Hello‘
address = “中国北京”
```
布尔值
布尔值只有两种可能：True（真）或 False（假）。它们通常用于逻辑判断。
```
is_student = True
has_finished = False
```

我们已经认识了不同的数据类型，那么如何查看一个变量的类型呢？

使用 `type()` 函数

Python提供了一个内置函数 type()，可以用来检查任何变量或值的数据类型。

# 定义几个不同类型的变量
my_integer = 42
my_float = 3.14
my_string = “Python”
my_bool = True

# 使用 type() 函数查看它们的类型
print(type(my_integer))  # 输出：<class ‘int‘>
print(type(my_float))    # 输出：<class ‘float‘>
print(type(my_string))   # 输出：<class ‘str‘>
print(type(my_bool))     # 输出：<class ‘bool‘>

变量的重新赋值与动态类型 🔄

Python中的变量是“动态类型”的，这意味着同一个变量可以在程序运行过程中被重新赋值为不同类型的数据。

# 变量 x 最初被赋值为一个整数
x = 10
print(x)          # 输出：10
print(type(x))    # 输出：<class ‘int‘>

# 之后，可以将 x 重新赋值为一个字符串
x = “现在我是字符串了”
print(x)          # 输出：现在我是字符串了
print(type(x))    # 输出：<class ‘str‘>

本节课中我们一起学习了Python编程的基石：变量和数据类型。我们了解了变量是存储数据的命名容器，学习了如何为变量命名，并认识了四种基本数据类型：整数、浮点数、字符串和布尔值。我们还掌握了使用 type() 函数来检查数据类型，并理解了Python变量动态类型的特性。掌握这些概念是后续学习更复杂编程操作的基础。

077：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

查看与理解数据类型🔍

有时，你可能不确定一个变量里存放的是什么类型的数据。Python提供了一个非常方便的函数 type() 来查看。

# 定义几个不同类型的变量
my_integer = 100
my_float = 3.14
my_string = “Python”

# 使用type()函数查看它们的数据类型
print(type(my_integer)) # 输出：<class ‘int’>
print(type(my_float))   # 输出：<class ‘float’>
print(type(my_string))  # 输出：<class ‘str’>

这里的 int 代表整数，float 代表浮点数，str 代表字符串。了解数据类型很重要，因为它决定了你能对这个变量进行哪些操作。例如，数字可以进行加减乘除，而字符串通常可以进行拼接。

变量的命名规则与建议📝

为了让我们和计算机都能清晰地理解变量的用途，给变量起一个好名字至关重要。这需要遵循一些规则和最佳实践。

以下是命名变量时需要遵守的规则和建议：

规则（必须遵守）：
1. 变量名只能包含字母、数字和下划线。
2. 变量名不能以数字开头。
3. 变量名不能是Python的关键字（如 if， for， while等）。
建议（良好习惯）：
1. 使用描述性的名称，让人一眼就能明白变量的用途（例如用 student_name 而不是 sn）。
2. Python通常使用小写字母和下划线来分隔单词，这种风格称为“蛇形命名法”。
3. 避免使用单个字符（如 l， O， I），除非是简单的循环计数器。

动手试一试：一个简单示例✍️

现在，让我们把以上知识结合起来，写一个简单的程序。这个程序会存储一些信息，然后打印出一条完整的句子。

# 1. 创建变量并赋值
user_name = “张伟”
user_age = 25
user_height = 1.75

# 2. 打印这些变量的值
print(“姓名：”, user_name)
print(“年龄：”, user_age)
print(“身高：”, user_height)

# 3. 尝试组合信息（字符串拼接）
introduction = user_name + “今年” + str(user_age) + “岁，身高” + str(user_height) + “米。”
print(introduction)

注意：在最后一行拼接字符串时，我们使用了 str() 函数将数字（user_age 和 user_height）转换成了字符串格式，因为Python不允许直接使用 + 号连接字符串和数字。

本节课中我们一起学习了Python编程的起点：变量与数据类型。我们知道了变量就像存放数据的带标签盒子，并认识了三种基本数据类型：整数、浮点数和字符串。我们还学会了如何查看数据类型、如何为变量命名，并动手编写了一个综合运用这些知识的小程序。掌握这些内容是理解后续更复杂概念的关键。

078：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18， temperature = -5， count = 0
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99， pi = 3.14159， height = 1.75
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”， greeting = ‘Hello’

使用变量进行计算🧮

了解了数据类型后，我们就可以让变量参与运算了。对于数字类型（整数和浮点数），可以直接进行数学计算。

# 定义两个变量
apples = 5
oranges = 3

# 进行加法运算，将结果存入新变量“total_fruit”
total_fruit = apples + oranges  # total_fruit 现在的值是 8

# 进行更复杂的运算
price_per_apple = 2.5
total_price = apples * price_per_apple  # total_price 现在的值是 12.5

对于字符串，最常用的操作是“拼接”，也就是把两段文字连接起来。

first_name = “张”
last_name = “三”
full_name = first_name + last_name  # full_name 现在的值是 “张三”

greeting = “你好，”
personal_greeting = greeting + full_name  # personal_greeting 现在的值是 “你好，张三”

查看与转换类型🔄

有时我们需要知道一个变量里到底存的是什么类型的数据，或者将一种类型转换成另一种类型。

使用 type() 函数可以查看变量的数据类型。

score = 95
print(type(score))  # 输出：<class ‘int’>， 表示这是一个整数

name = “李华”
print(type(name))   # 输出：<class ‘str’>， 表示这是一个字符串

不同的数据类型之间有时可以相互转换。例如，把数字转换成字符串以便拼接，或者把字符串数字转换成真正的数字以便计算。

以下是常用的类型转换函数：

int()：将数据转换为整数。
- 示例：int(“123”) 得到整数 123；int(3.14) 得到整数 3（直接去掉小数部分）。
float()：将数据转换为浮点数。
- 示例：float(“3.14”) 得到浮点数 3.14；float(7) 得到浮点数 7.0。
str()：将数据转换为字符串。
- 示例：str(100) 得到字符串 “100”。

# 转换示例：计算字符串数字的和
num1 = “10”
num2 = “20”
# 错误做法：total = num1 + num2， 这会把它们拼接成 “1020”
# 正确做法：先转换成整数再相加
total = int(num1) + int(num2)  # total 的值是整数 30

# 转换示例：将数字嵌入到消息中
score = 90
# 错误做法：message = “我的分数是：” + score （字符串不能直接和数字相加）
# 正确做法：将数字转换为字符串
message = “我的分数是：” + str(score)  # message 的值是 “我的分数是：90”

总结📝

本节课中我们一起学习了Python编程的起点：变量与数据类型。

我们知道了变量就像一个贴有名字标签的盒子，用于存储数据。我们介绍了三种基本数据类型：用于整数的整数、用于小数的浮点数和用于文本的字符串。我们学会了如何让变量进行数学运算和字符串拼接，也掌握了使用 type() 查看类型，以及使用 int(), float(), str() 在不同类型间进行转换的方法。

牢记这些概念，你已经打下了坚实的第一步。在下一章，我们将学习如何使用这些数据做出判断和选择，让程序变得更加“聪明”。

079：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存了哪种类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来实现这些操作。

使用 type() 函数可以查看任何变量的数据类型。

height = 1.75
print(type(height))  # 输出：<class ‘float’>

以下是两种常见的类型转换方法：

转换为整数：使用 int()。例如，int(3.14) 会得到 3。
转换为字符串：使用 str()。例如，str(100) 会得到字符串 ‘100’。

注意：将文字字符串（如“一百”）转换为数字会引发错误。类型转换必须在逻辑合理的情况下进行。

动手试一试✍️

理论需要结合实践。让我们通过一个简单的例子，把上面学到的知识串联起来。

# 1. 创建变量
name = “张三”
score = 95.5

# 2. 查看类型
print(type(name))   # 输出：<class ‘str’>
print(type(score))  # 输出：<class ‘float’>

# 3. 类型转换与拼接
# 将浮点数score转换为字符串，才能和其他字符串连接
score_str = str(score)
report = name + “的分数是：” + score_str
print(report)  # 输出：张三的分数是：95.5

# 4. 转换回整数（小数部分会被舍去）
score_int = int(score)
print(score_int)  # 输出：95

本节课中我们一起学习了Python的变量与数据类型。我们知道了变量是存储数据的容器，并认识了整数、浮点数和字符串这三种基本数据类型。同时，我们还掌握了如何使用 type() 函数查看类型，以及如何使用 int() 和 str() 进行基本的类型转换。熟练掌握这些概念，将为后续学习更复杂的编程操作打下坚实的基础。

080：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 25，temperature = -10
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 19.99，pi = 3.14159
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’

使用变量进行计算🧮

了解了数据类型后，我们就可以让变量参与运算了。这就像把盒子里的东西拿出来进行加工。

数字类型（整数和浮点数）的变量可以直接进行数学运算。

# 定义两个变量
apples = 5
oranges = 3

# 进行加法运算，将结果存入新变量“total_fruit”
total_fruit = apples + oranges  # total_fruit 的值现在是 8

# 进行更复杂的运算
price_per_apple = 2.5
total_price = apples * price_per_apple  # total_price 的值现在是 12.5

对于字符串，我们则可以进行连接操作。

first_name = “张”
last_name = “三”
full_name = first_name + last_name  # full_name 的值现在是 “张三”

请注意，数字和字符串是不同类型的数据，不能直接混合运算。例如 “价格是：” + 100 会导致错误。

查看与理解类型🔍

有时我们不确定一个变量里装的是什么类型的数据，这时可以使用 type() 函数来查看。

# 定义几个不同类型的变量
score = 100
average = 96.5
student_name = “李华”

# 使用 type() 函数查看它们的类型
print(type(score))        # 输出：<class ‘int’>，表示整数类型
print(type(average))      # 输出：<class ‘float’>，表示浮点数类型
print(type(student_name)) # 输出：<class ‘str’>，表示字符串类型

这个功能在调试程序或处理不确定来源的数据时非常有用。

变量的命名规则📝

给变量起名字就像给盒子贴标签，有一些重要的规则和好习惯需要遵守。

以下是变量命名的核心规则与建议：

规则一：名称只能包含字母、数字和下划线，且不能以数字开头。
- 合法示例：my_variable，var1，_value
- 非法示例：2nd_place（以数字开头），my-var（包含减号）
规则二：不能使用Python的保留字。保留字是Python语言自己已经占用的单词，比如 if， for， while 等。
建议：使用描述性的名称。名字应该能让人一眼看出这个变量是做什么的。
- 好例子：user_age，file_path，is_valid
- 坏例子：a， x1， temp（除非在非常简单的临时计算中）
建议：遵循命名惯例。Python社区通常使用小写字母和下划线来分隔单词，这种风格称为“蛇形命名法”。
- 例如：first_name，total_amount，calculate_average

本节课中我们一起学习了Python编程的起点：变量与数据类型。我们知道了变量是存储数据的容器，并通过赋值符号 = 来使用。我们认识了三种基本数据类型：整数、浮点数和字符串。我们还学会了如何让变量参与运算，如何使用 type() 函数检查类型，以及如何为变量起一个清晰合法的好名字。掌握这些内容，你就已经打下了坚实的第一步，可以尝试用变量来表达和计算一些简单的信息了。

081：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存的是什么类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来完成这些操作。

要查看一个变量的数据类型，可以使用 type() 函数。

height = 175.5
print(type(height))  # 输出：<class ‘float’>，表示height是浮点数

数据类型之间可以相互转换，但必须符合逻辑。例如，可以把字符串“123”转换成整数123，但不能把字符串“你好”转换成整数。

以下是三种常见的类型转换函数：

int()：将数据转换为整数。如果是浮点数，会去掉小数部分；如果是数字字符串，则转换成对应整数。
- 示例：int(3.14) 得到 3，int(“100”) 得到 100。
float()：将数据转换为浮点数。
- 示例：float(10) 得到 10.0，float(“3.14”) 得到 3.14。
str()：将数据转换为字符串。几乎任何类型都能转换成字符串。
- 示例：str(100) 得到 ‘100’，str(True) 得到 ‘True’。

动手试一试✍️

理论需要结合实践。让我们通过一个简单的例子，综合运用刚才学到的知识。

假设我们要编写一个程序，接收用户输入的名字和年龄，然后生成一句问候语。

# 1. 获取用户输入（输入的内容默认是字符串类型）
user_name = input(“请输入你的名字：”)
age_input = input(“请输入你的年龄：”)  # 此时age_input是字符串，如“20”

# 2. 转换数据类型
# 为了进行数学计算（比如计算明年年龄），需要将年龄转换为整数
age = int(age_input)

# 3. 进行计算
next_year_age = age + 1

# 4. 组合信息并输出
# 注意：打印时需要用str()将数字转换回字符串，才能与其他字符串连接
greeting = user_name + “，你好！你明年就” + str(next_year_age) + “岁了。”
print(greeting)

运行这个程序，输入“小明”和“20”，你会看到输出：“小明，你好！你明年就21岁了。”

本节课中我们一起学习了Python编程的起点：变量与数据类型。我们知道了变量是存储数据的容器，认识了整数、浮点数和字符串这三种基本类型，并学会了如何使用type()查看类型以及使用int()、float()、str()进行类型转换。掌握这些概念，你就已经打下了坚实的第一步，可以开始用代码表达简单的想法了。

082：变量与数据类型

什么是变量？📦

在Python中，创建一个变量并给它赋值非常简单，只需要使用等号 =。

# 创建一个名为“message”的变量，并存入一段文字
message = "你好，世界！"
# 创建一个名为“number”的变量，并存入一个数字
number = 42

当你运行 print(message) 时，计算机会找到名为“message”的盒子，取出里面的内容“你好，世界！”并显示出来。

基本数据类型🔢

变量这个“盒子”里可以放不同种类的东西，这些东西的“种类”就是数据类型。Python有几种内置的基本数据类型，最常用的有三种。

以下是三种最基础的数据类型介绍：

整数
- 表示没有小数部分的数字，可以是正数、负数或零。
- 代码示例：age = 18，temperature = -5。
浮点数
- 表示带有小数点的数字，用于更精确的数值计算。
- 代码示例：price = 9.99，pi = 3.14159。
字符串
- 表示文本信息，需要用单引号 ‘ ’ 或双引号 “ ” 括起来。
- 代码示例：name = “小明”，greeting = ‘Hello’。

如何查看和转换类型？🔄

有时我们需要知道一个变量里到底存了哪种类型的数据，或者将一种类型转换成另一种类型。Python提供了方便的工具来实现这些操作。

使用 type() 函数可以查看任何变量的数据类型。

height = 1.75
print(type(height))  # 输出：<class ‘float’>

如果你需要转换类型，可以使用特定的转换函数。

以下是常用的类型转换函数：

int()：将数据转换为整数。例如 int(3.14) 得到 3。
float()：将数据转换为浮点数。例如 float(7) 得到 7.0。
str()：将数据转换为字符串。例如 str(100) 得到 ‘100’。

注意：不是所有转换都能成功。例如，你不能把像 “你好” 这样的文字字符串直接转换成整数。

给变量起个好名字🏷️

变量名是盒子的“标签”，一个好的标签应该清晰易懂。Python有一些为变量命名的规则和约定。

以下是命名变量的主要规则和良好习惯：

只能包含：字母、数字和下划线 _。
不能以数字开头：2nd_place 是无效的，second_place 是有效的。
区分大小写：Age、age 和 AGE 是三个不同的变量。
使用描述性的名字：用 student_name 而不是 sn，这样代码更易读。
推荐使用小写字母和下划线：这种风格称为“蛇形命名法”，如 user_age、total_count。

动手试一试✍️

现在，让我们把以上知识结合起来，完成一个简单的练习。我们将创建一个程序，记录并打印一本书的信息。

# 1. 创建变量存储书籍信息
book_title = “Python编程从入门到实践”
book_price = 89.50
pages = 560

# 2. 打印这些信息
print(“书名：”, book_title)
print(“价格：”, book_price)
print(“页数：”, pages)

# 3. 尝试类型转换
# 将价格（浮点数）转换为字符串，以便与其他文字连接
price_str = str(book_price)
print(“这本书的价格是” + price_str + “元。”)

# 查看页数的数据类型
print(“变量pages的类型是：”, type(pages))

你可以尝试运行这段代码，并修改其中的值，观察输出结果有什么变化。

本节课中我们一起学习了Python的变量与数据类型。我们知道了变量是存储数据的容器，并了解了三种基本数据类型：整数、浮点数和字符串。同时，我们还学会了如何使用 type() 查看类型、如何进行简单的类型转换，以及如何为变量起一个规范且清晰的名字。掌握这些内容是编写更复杂程序的重要基础。

posted @ 2026-03-29 09:24 布客飞龙II 阅读(2) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

人最大的痛苦就是说一些自己都不相信的话。

PyCon-2023-会议笔记-全-

PyCon 2023 会议笔记（全）

001：Python 基础与环境搭建 🐍

什么是 Python？ 🤔

搭建 Python 开发环境 ⚙️

编写你的第一个 Python 程序 ✨

运行 Python 程序 🚀

总结 📝

002：使用Python监控政府公开信息 📊

概述

核心概念与工具

实践步骤：构建一个简单的监控脚本

第一步：确定目标与检查合规性

第二步：分析网页结构

第三步：编写数据抓取代码

第四步：实现定时与增量抓取

第五步：数据分析与提醒

注意事项与最佳实践

总结

003：使用 Pytest 进行单元测试 🧪

概述

P3：1：安装与基本用法 🔧

P3：2：编写第一个测试 ✍️

P3：3：运行测试 ▶️

P3：4：使用断言验证结果 ✅

P3：5：测试的组织与标记 🏷️

P3：6：使用 Fixture 进行测试准备 🧰

P3：7：参数化测试 📊

总结

004：FastAPI简介

概述

什么是FastAPI？🚀

核心特性 ✨

创建你的第一个API 🛠️

路径参数与查询参数 🔍

路径参数

查询参数

请求体与Pydantic模型 📦

自动交互式API文档 📖

总结 🎯

005：早期会议与组织的诞生 🐍

从研讨会到国际会议

组织会议的挑战与尝试

Python软件协会与财团的构想

Python软件基金会的诞生

PyCon的诞生与早期挑战

应对危机与个人感悟

006：主题演讲 - 与Ned Batchelder一起探讨人际互动

概述

开场致辞与社区感谢

引入主讲人Ned Batchelder

Ned Batchelder的主题演讲：人际互动的“用户指南”

从工程视角看“人”这个组件

人际互动的核心模型：每条消息都有信息和情感

如何改善沟通：让信息更倾向于“是”

技术本身的“怪异”如何影响沟通

针对不同场景的沟通策略

总结与呼吁

007：欢迎来到 PyCon US 2023 🐍

概述

会议致谢与欢迎

会议活动安排

社交规则：吃豆人规则

在线互动与健康安全

个人挑战与总结

总结

008：变量与数据类型

什么是变量？📦

基本数据类型🔢

如何查看和转换类型？🔄

动手试一试✍️

009：变量与数据类型

什么是变量？📦

基本数据类型🔢

如何查看和转换类型？🔄

给变量起个好名字✏️

动手试一试💻

010：谈话 - 阿尔·斯维加特