本文还有配套的精品资源，点击获取

简介：Python 3.7.3是Python语言的一个稳定且广泛应用的版本，具有简洁清晰的语法和强大的功能。本官方中文PDF指南全面覆盖了Python的基础语法、面向对象编程、标准库、函数式编程、异常处理、类型注解、异步编程等核心内容，并介绍了如数据类、f-string增强等新特性。适合初学者系统学习，也适合开发者作为权威参考手册使用。通过丰富的示例代码和清晰讲解，帮助用户快速掌握Python 3.7.3编程技巧并应用于实际开发中。

1. Python 3.7.3版本特性概述

Python 3.7.3 是 Python 3.7 系列的一个重要维护版本，主要聚焦于稳定性和安全性的提升。该版本延续了 Python 3.7 引入的新特性，如更精确的类型注解、新增的 contextvars 模块以支持异步上下文变量，以及对 CPython 解释器的性能优化。

在语言层面，Python 3.7.3 保持了对数据类（data class）的支持，通过 @dataclass 装饰器简化类定义逻辑。同时，该版本修复了多个安全漏洞，增强了标准库中网络与文件操作模块的安全性，适用于对稳定性要求较高的生产环境部署。对于开发者而言，Python 3.7.3 是一个兼顾新特性与高稳定性的过渡版本。

2. Python基础语法与核心概念

Python 作为一门简洁、高效的编程语言，其语法设计强调可读性和简洁性，非常适合初学者入门，同时也被广泛用于大型项目开发。本章将深入探讨 Python 3.7.3 中的基础语法结构与核心编程概念，帮助开发者掌握 Python 编程的基石知识。我们将从代码结构、标识符规则、输入输出操作，到脚本与交互式编程的使用方式，逐步展开。

2.1 Python语言的基本结构

Python 的语法结构设计简洁明了，其最显著的特点是使用 缩进 来定义代码块，而不是传统的花括号 {} 。这种设计不仅提高了代码的可读性，也强制开发者保持良好的代码格式习惯。

2.1.1 注释与缩进规则

Python 支持单行注释和多行注释。单行注释以 # 开头：

# 这是一个单行注释
print("Hello, World!")

多行注释可以通过三个引号 ''' 或 """ 来实现：

这是一个
多行注释
print("Hello, World!")

逻辑分析 ：
- 第1~3行是注释部分，Python 解释器会忽略这些内容。
- 第4行是实际执行的代码，输出字符串 “Hello, World!”。

缩进规则 是 Python 的核心语法之一。它使用 空格或 Tab 来表示代码块的层级关系， 同一层级的代码必须具有相同的缩进量 。

例如：

if True:
    print("这是if语句内部的代码")  # 正确缩进
print("这是if语句外部的代码")      # 与if不在同一缩进层级

逻辑分析 ：
- if 语句内的代码必须缩进。
- 如果缩进不一致，解释器将抛出 IndentationError 错误。

2.1.2 代码块与语句分隔

在 Python 中， 代码块通过缩进划分 ，而 语句通过换行分隔 。每条语句通常占据一行，但也可以使用反斜杠 \ 将一行代码拆分为多行：

total = 1 + 2 + \
        3 + 4 + \
        5

也可以使用括号隐式地拆分行：

total = (1 + 2 +
         3 + 4 +
         5)

参数说明 ：
- \ 是显式行连接符，明确表示当前行未结束。
- 使用括号时，无需添加 \ ，Python 自动识别为同一语句。

2.2 标识符与关键字

标识符是程序中变量、函数、类等的名称。Python 对标识符有明确的命名规则，同时也保留了一组关键字用于控制语言结构。

2.2.1 合法命名规则

Python 的标识符命名规则如下：

• 可以由字母、数字、下划线组成；
• 不能以数字开头；
• 区分大小写（如 name 与 Name 是两个不同的变量）；
• 不能使用关键字作为标识符。

合法示例：

name = "Alice"
age_2025 = 30

非法示例：

2nd_place = "Bob"   # 错误：以数字开头
class = "Math"      # 错误：class是关键字

2.2.2 关键字列表及其用途

关键字是 Python 预留的特殊词汇，不能用作变量名。以下是 Python 3.7.3 中的关键字列表（可通过 keyword.kwlist 查看）：

关键字	用途说明
if , elif , else	条件判断语句
for , while	循环语句
def	定义函数
class	定义类
import	导入模块
try , except , finally	异常处理
return	函数返回值
yield	生成器函数
with	上下文管理器
lambda	匿名函数
global , nonlocal	变量作用域控制

2.3 输入与输出操作

Python 提供了简洁的输入输出方式，适用于命令行交互、脚本调试等场景。

2.3.1 使用 input() 和 print() 函数

input() 函数用于从标准输入获取用户输入，返回的是字符串类型：

name = input("请输入您的姓名：")
print("欢迎你，" + name)

逻辑分析 ：
- input() 会暂停程序运行，等待用户输入并按下回车键；
- 返回的值始终为字符串，若需其他类型，需要手动转换，如 int(input()) 。

print() 函数用于输出信息到控制台，支持多个参数，用逗号分隔：

print("姓名：", name, "年龄：", age_2025)

输出结果为：

姓名： Alice 年龄： 30

2.3.2 格式化输出技巧

Python 提供多种格式化输出方式，包括：

• 使用 % 操作符（C风格）：

print("姓名：%s，年龄：%d" % (name, age_2025))

• 使用 str.format() 方法：

print("姓名：{0}，年龄：{1}".format(name, age_2025))

• 使用 f-string（Python 3.6+）：

print(f"姓名：{name}，年龄：{age_2025}")

逻辑分析 ：
- %s 表示字符串， %d 表示整数；
- str.format() 通过索引或名称插入变量；
- f-string 是目前最推荐的方式，简洁高效，支持表达式嵌入。

2.4 脚本与交互式编程

Python 支持两种主要的运行方式： 交互式编程 （REPL）和 脚本编程 。

2.4.1 编写第一个 Python 脚本

创建一个名为 hello.py 的文件，内容如下：

# hello.py
print("Hello, Python 3.7.3!")

在命令行中运行该脚本：

python hello.py

逻辑分析 ：
- .py 是 Python 脚本的标准扩展名；
- 命令 python 后接脚本文件名即可运行；
- Windows 用户可使用 py 命令，Linux/macOS 用户使用 python3 。

2.4.2 Python 交互式解释器的使用方法

在终端中输入 python 或 python3 进入交互式环境：

$ python3
Python 3.7.3 (default, Jul 25 2020, 13:03:44)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.

在 >>> 提示符后输入代码，Python 会立即执行并输出结果：

>>> a = 10
>>> b = 20
>>> a + b
30

交互性说明 ：
- 每行代码独立执行；
- 适合快速测试和调试小段代码；
- 可通过 exit() 或 Ctrl+D 退出交互模式。

小结

本章我们从 Python 的基本语法结构入手，详细讲解了注释与缩进规则、标识符命名与关键字、输入输出操作，以及脚本与交互式编程的使用方式。这些内容构成了 Python 编程的基础，是进一步学习数据类型、控制结构和函数模块的前提。

下一章将深入探讨 Python 中的 数据类型与变量操作 ，包括动态类型机制、常见数据类型如整型、浮点型、字符串、布尔型，以及序列和集合类型的使用技巧。通过本章的学习，读者应能熟练编写结构清晰、逻辑严谨的 Python 程序。

3. 数据类型与变量操作

在Python语言中，数据类型和变量操作是构建程序逻辑的基础。Python作为一门动态类型语言，其变量和数据类型的设计理念使得开发者可以更专注于业务逻辑的实现，而无需过多关注底层内存管理。本章将从变量的定义机制入手，逐步深入讲解Python中的常用数据类型、序列结构操作，以及字典与集合等复杂结构的使用方式。通过丰富的代码示例、流程图和表格对比，帮助读者全面掌握Python中数据类型与变量的核心操作技巧。

3.1 变量的定义与赋值机制

Python的变量定义机制与其动态类型特性紧密相关。理解变量如何在运行时被赋值和使用，是掌握Python语言的关键基础。

3.1.1 动态类型语言的特性

Python是一种动态类型语言，这意味着变量的类型不是在声明时确定的，而是在运行时根据赋值自动推断的。例如：

x = 5         # x 是整数类型
x = "hello"   # x 现在是字符串类型

代码解析：

• 第1行：将整数值5赋给变量 x ，此时 x 的类型为 int 。
• 第2行：将字符串 "hello" 重新赋给 x ，变量 x 的类型随之变为 str 。

这与静态类型语言（如C++或Java）不同，后者在变量声明时就必须指定类型且不能随意更改。

特性	静态类型语言	动态类型语言（如Python）
类型确定时机	编译时	运行时
类型变更	不允许	允许
内存管理	手动控制	自动管理
类型检查	编译器检查	解释器运行时检查

优势与挑战：

• 优势 ：开发效率高、代码简洁。
• 挑战 ：运行时类型错误更难发现，需依赖测试和类型注解工具（如 mypy ）进行类型检查。

3.1.2 多重赋值与变量交换

Python支持简洁的多重赋值语法，极大提升了代码的可读性和简洁性：

a, b = 10, 20

逻辑分析：

• 同时将 10 赋给 a ， 20 赋给 b 。
• 这种方式常用于初始化多个变量，或在函数中返回多个值。

变量交换示例：

a, b = b, a

执行流程：

1. 右边表达式 b, a 生成一个临时元组 (20, 10) 。
2. 左边变量 a, b 依次从元组中取出值赋值。
3. 最终 a=20 ， b=10 。

与传统交换方式相比（如使用临时变量），这种方式无需中间变量，代码更简洁。

graph LR
    A[变量a=10] --> B[变量b=20]
    B --> C[执行a, b = b, a]
    C --> D[a=20, b=10]

3.2 常用数据类型详解

Python支持多种内置数据类型，其中数值类型、字符串类型和布尔类型是最基础的三类。它们构成了Python程序的基本数据单元。

3.2.1 数值类型（int、float、complex）

Python中的数值类型包括：

• int ：整数，如 10 , -5 , 1000000
• float ：浮点数，如 3.14 , -0.001
• complex ：复数，如 1+2j , 3j

a = 10          # int
b = 3.14        # float
c = 1 + 2j      # complex

数值类型转换示例：

int_val = int(3.14)     # 结果为3，向下取整
float_val = float(10)   # 结果为10.0
complex_val = complex(2, 3)  # 结果为 (2+3j)

注意事项：

• int 与 float 之间可以相互转换。
• complex 类型不能转换为 int 或 float ，否则会抛出 TypeError 。

3.2.2 字符串类型与编码处理

字符串在Python中是不可变的序列类型，支持多语言编码（如UTF-8、GBK等）。

s1 = "Hello"
s2 = 'Python'
s3 = """这是一个
多行字符串示例"""

字符串操作示例：

s = "Python"
print(s[0])         # 输出 'P'
print(s[2:5])       # 输出 'tho'
print(len(s))       # 输出 6
print(s.upper())    # 输出 'PYTHON'

字符串编码转换：

bytes_data = "你好".encode("utf-8")
print(bytes_data)   # 输出 b'\xe4\xbd\xa0\xe5\xa5\xbd'

original = bytes_data.decode("utf-8")
print(original)     # 输出 '你好'

字符串格式化方法：

方法	示例	输出
% 格式化	"Name: %s, Age: %d" % ("Alice", 25)	Name: Alice, Age: 25
str.format()	"Name: {0}, Age: {1}".format("Alice", 25)	Name: Alice, Age: 25
f-string（Python 3.6+）	f"Name: {name}, Age: {age}"	Name: Alice, Age: 25

3.2.3 布尔类型与逻辑运算

布尔类型 bool 只有两个值： True 和 False ，常用于条件判断和逻辑运算。

a = True
b = False

逻辑运算符示例：

print(a and b)    # False
print(a or b)     # True
print(not a)      # False

布尔上下文中的真假判断：

数据类型	假值（False）	真值（True）
int	0	非零
float	0.0	非零
str	空字符串	非空字符串
list	空列表	非空列表
dict	空字典	非空字典
None	始终为False	—

if []:
    print("True")
else:
    print("False")  # 输出 False

3.3 序列类型操作

Python中常见的序列类型包括列表（ list ）和元组（ tuple ），它们都支持索引、切片等操作。

3.3.1 列表(list)与元组(tuple)

列表：可变序列

my_list = [1, 2, 3, 4]
my_list.append(5)       # 添加元素
my_list.remove(2)       # 移除元素

元组：不可变序列

my_tuple = (1, 2, 3)

区别对比表：

特性	列表(list)	元组(tuple)
是否可变	是	否
语法	[]	()
性能	插入/删除慢	读取快
适用场景	需要修改的数据集合	固定不变的数据集合（如坐标、配置）

元组作为字典键的示例：

d = {(1, 2): "point"}
print(d[(1, 2)])  # 输出 "point"

列表不能作为字典的键，因为其是可变对象。

3.3.2 切片操作与嵌套结构

切片是Python中非常强大的序列操作方式，用于获取子序列。

s = "Python"
print(s[0:3])     # 输出 'Pyt'
print(s[::2])     # 输出 'Pto'，步长为2

嵌套列表示例：

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix[1][2])  # 输出 6

切片流程图：

graph TD
    A[原始序列] --> B{是否指定起始索引?}
    B -- 是 --> C[从起始索引开始]
    B -- 否 --> D[从索引0开始]
    C --> E{是否指定结束索引?}
    D --> E
    E -- 是 --> F[到结束索引前一位]
    E -- 否 --> G[到末尾]
    F --> H[生成子序列]
    G --> H

3.4 字典与集合类型

字典（ dict ）和集合（ set ）是Python中用于处理键值对和唯一元素集合的高效数据结构。

3.4.1 字典的键值对管理

字典是一种无序的键值对集合，键必须是不可变类型（如字符串、数字、元组）。

person = {
    "name": "Alice",
    "age": 25,
    "city": "Beijing"
}

print(person["name"])  # 输出 Alice

字典常用操作：

person["email"] = "alice@example.com"  # 添加键值对
del person["age"]                      # 删除键值对

get()方法避免KeyError：

print(person.get("gender", "Unknown"))  # 输出 Unknown

字典合并示例：

d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
merged = {**d1, **d2}
print(merged)  # 输出 {'a': 1, 'b': 3, 'c': 4}

3.4.2 集合的运算与去重机制

集合是一个无序且元素唯一的容器，常用于去重和集合运算。

s1 = {1, 2, 3}
s2 = {3, 4, 5}

集合运算：

print(s1 | s2)   # 并集 {1, 2, 3, 4, 5}
print(s1 & s2)   # 交集 {3}
print(s1 - s2)   # 差集 {1, 2}

去重示例：

lst = [1, 2, 2, 3, 4, 4, 5]
unique = list(set(lst))
print(unique)  # 输出 [1, 2, 3, 4, 5]

注意：

• set 是无序的，因此去重后顺序可能与原列表不同。
• 如需保持顺序，可使用 dict.fromkeys() 方法：

ordered_unique = list(dict.fromkeys(lst))
print(ordered_unique)  # 输出 [1, 2, 3, 4, 5]

集合操作流程图：

graph TD
    A[集合A] --> B{操作类型}
    B --> C[并集]
    B --> D[交集]
    B --> E[差集]
    C --> F[A ∪ B]
    D --> G[A ∩ B]
    E --> H[A - B]

本章从变量的动态类型特性入手，深入讲解了Python中常见的数据类型、序列结构以及字典与集合的操作方式。通过代码示例、流程图和表格对比，帮助读者构建了扎实的数据处理基础。下一章将围绕控制结构展开，探讨条件判断、循环机制以及异常处理等程序流程控制的核心内容。

4. 控制结构与程序流程

在 Python 编程中， 控制结构（Control Structures） 是决定程序执行路径的关键机制。Python 提供了多种控制结构，包括条件语句、循环结构、嵌套控制以及异常处理等，这些结构共同构成了程序逻辑的骨架。本章将深入探讨 Python 中的控制流机制，帮助开发者构建结构清晰、逻辑严谨的程序。我们将从基本的条件分支入手，逐步过渡到循环结构、嵌套优化，最后介绍异常处理机制如何影响程序流程。

4.1 条件语句与逻辑分支

条件语句是程序中最基础的逻辑分支工具。Python 使用 if 、 elif 和 else 来实现条件判断，同时支持简洁的三元运算符来优化逻辑表达。

4.1.1 if、elif、else的使用方式

Python 中的条件语句结构如下：

if condition1:
    # 条件1为True时执行
elif condition2:
    # 条件1为False且条件2为True时执行
else:
    # 所有条件均为False时执行

示例代码

score = 85

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 70:
    print("C")
else:
    print("D")

代码逻辑分析

• score = 85 ：定义一个变量用于存储成绩。
• if score >= 90: ：判断是否大于等于90，若成立则打印“A”。
• elif score >= 80: ：若第一个条件不成立，则判断是否大于等于80，成立则打印“B”。
• else: ：所有条件均不成立时，进入最后的分支。

逻辑流程图

graph TD
    A[开始] --> B{score >= 90?}
    B -- 是 --> C[打印"A"]
    B -- 否 --> D{score >= 80?}
    D -- 是 --> E[打印"B"]
    D -- 否 --> F{score >= 70?}
    F -- 是 --> G[打印"C"]
    F -- 否 --> H[打印"D"]

4.1.2 三元运算符的应用

Python 支持简洁的三元条件表达式，语法如下：

value_if_true if condition else value_if_false

示例代码

age = 17
status = "Adult" if age >= 18 else "Minor"
print(status)

代码逻辑分析

• age = 17 ：设置年龄为17岁。
• status = "Adult" if age >= 18 else "Minor" ：使用三元表达式判断年龄是否大于等于18岁，结果赋值给 status 。
• print(status) ：输出判断结果。

三元表达式非常适合简化逻辑判断，尤其是在赋值场景中，可以有效减少代码行数并提升可读性。

4.2 循环结构与迭代控制

循环是控制结构中最重要的部分之一，它允许程序重复执行一段代码。Python 支持两种主要的循环结构： for 循环和 while 循环，并提供 break 、 continue 和 else 等控制语句来增强循环的灵活性。

4.2.1 for循环与迭代器协议

Python 的 for 循环适用于任何可迭代对象（如列表、元组、字符串、字典等），其基本结构如下：

for item in iterable:
    # 执行代码

示例代码

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

代码逻辑分析

• fruits = ["apple", "banana", "cherry"] ：定义一个水果列表。
• for fruit in fruits: ：遍历列表中的每个元素。
• print(fruit) ：每次循环打印当前水果名称。

可迭代对象对比表

数据类型	是否可迭代	说明
list	✅	可迭代，支持索引
tuple	✅	不可变，但可迭代
dict	✅	默认迭代键（key）
str	✅	按字符逐个迭代
set	✅	无序可迭代集合

4.2.2 while循环与break、continue

while 循环用于在条件为 True 时持续执行代码块，其结构如下：

while condition:
    # 执行代码
    if some_condition:
        break
    if another_condition:
        continue

示例代码

count = 0
while count < 5:
    count += 1
    if count == 3:
        continue  # 跳过数字3
    print(count)

代码逻辑分析

• count = 0 ：初始化计数器。
• while count < 5: ：当 count 小于5时循环继续。
• count += 1 ：每次循环增加计数器。
• if count == 3: continue ：当 count 为3时跳过本次循环。
• print(count) ：打印当前计数器值。

输出结果：

1
2
4
5

可以看到，数字3被跳过，因为 continue 跳过了打印步骤。

4.3 控制结构的嵌套与优化

控制结构可以相互嵌套使用，从而实现更复杂的逻辑判断。此外，Python 提供了 else 子句与循环配合使用，以增强程序逻辑的可读性和可维护性。

4.3.1 多层条件与循环的组合

嵌套结构允许在条件语句中包含循环，或在循环中包含条件判断，从而实现复杂逻辑。

示例代码

for i in range(3):
    print(f"Outer loop i={i}")
    for j in range(2):
        print(f"  Inner loop j={j}")

代码逻辑分析

• 外层循环 i 从0到2（不包括3）。
• 内层循环 j 从0到1。
• 每次外层循环执行一次，内层循环完整执行两次。
• 输出显示层级关系，便于理解嵌套逻辑。

输出结果：

Outer loop i=0
  Inner loop j=0
  Inner loop j=1
Outer loop i=1
  Inner loop j=0
  Inner loop j=1
Outer loop i=2
  Inner loop j=0
  Inner loop j=1

4.3.2 循环中的else子句

Python 的 for 和 while 循环都可以搭配 else 子句，表示循环正常结束时执行的代码。

示例代码

numbers = [2, 4, 6, 8]
for num in numbers:
    if num % 2 == 1:
        print("Found an odd number")
        break
else:
    print("All numbers are even")

代码逻辑分析

• 遍历 numbers 列表。
• 如果发现奇数，则打印提示并退出循环。
• 如果循环正常结束（未发现奇数），则执行 else 分支，打印所有数都是偶数。

输出结果：

All numbers are even

如果将 numbers 改为 [2, 4, 5, 6] ，则输出：

Found an odd number

4.4 错误控制与异常跳转

在程序执行过程中，不可避免地会遇到错误。Python 提供了 try...except 结构来捕获和处理异常，从而实现流程的可控跳转。

4.4.1 异常在流程控制中的应用

Python 的异常处理结构如下：

try:
    # 尝试执行的代码
except ExceptionType:
    # 异常发生时的处理
finally:
    # 无论是否异常都会执行

示例代码

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("Cannot divide by zero:", e)
finally:
    print("Execution completed")

代码逻辑分析

• try: ：尝试执行除法操作。
• except ZeroDivisionError as e: ：捕获除以0的错误，并打印提示信息。
• finally: ：无论是否出错，都会执行清理操作。

输出结果：

Cannot divide by zero: division by zero
Execution completed

4.4.2 自定义流程终止条件

除了系统异常外，我们也可以使用 raise 主动抛出异常，用于中断程序流程或实现特定逻辑跳转。

示例代码

def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")
    print("Valid age:", age)

try:
    validate_age(-5)
except ValueError as e:
    print("Error:", e)

代码逻辑分析

• validate_age(age) ：定义一个函数用于验证年龄。
• if age < 0: ：判断年龄是否为负数。
• raise ValueError(...) ：抛出异常并中断程序流程。
• except ValueError as e: ：捕获异常并处理。

输出结果：

Error: Age cannot be negative

通过主动抛出异常，我们可以更灵活地控制程序流程，适用于权限验证、状态检查等场景。

5. 函数与模块化编程

函数与模块化编程是 Python 程序设计中最为关键的两个概念，它们不仅提高了代码的复用性和可维护性，还为大型项目的结构化开发提供了基础。本章将深入探讨 Python 中函数的定义与调用机制、高阶函数的使用、模块的组织结构以及标准库模块的实战应用。通过本章的学习，你将掌握如何编写结构清晰、逻辑严谨的函数代码，并利用模块化思想构建可扩展性强的 Python 应用程序。

5.1 函数的定义与调用机制

函数是将一组可重用的代码封装成一个独立单元的基本方式。Python 中的函数不仅支持基本的参数传递和返回值管理，还具备灵活的作用域控制机制。

5.1.1 参数传递与返回值管理

Python 中函数的参数可以是位置参数、关键字参数、默认参数和可变参数（ *args 和 **kwargs ）。理解这些参数的使用方式对于编写灵活的函数至关重要。

示例代码：

def greet(name, message="Hello", *args, **kwargs):
    print(f"{message}, {name}!")
    if args:
        print("Additional positional arguments:", args)
    if kwargs:
        print("Additional keyword arguments:", kwargs)

greet("Alice")
greet("Bob", "Hi", "age=25", country="USA")

逻辑分析：

• 第1行 ：定义函数 greet ，接收 name （位置参数）、 message （带默认值的关键字参数）、 *args （可变位置参数）和 **kwargs （可变关键字参数）。
• 第2行 ：打印问候语。
• 第3~6行 ：判断 args 和 kwargs 是否有内容，并输出。

参数说明：

参数名	类型	说明
name	str	必填，接收用户名称
message	str	可选，默认值为 “Hello”
*args	tuple	接收任意数量的位置参数
**kwargs	dict	接收任意数量的关键字参数

输出结果：

Hello, Alice!
Hi, Bob!
Additional positional arguments: ('age=25', 'USA')

5.1.2 局部变量与作用域规则

函数内部定义的变量称为 局部变量 ，其作用域仅限于函数内部。而函数外部定义的变量称为 全局变量 ，可以通过 global 关键字在函数内部修改。

示例代码：

x = 10  # 全局变量

def func():
    y = 20  # 局部变量
    global x
    x += 5
    print("Inside func: x =", x, "y =", y)

func()
print("Outside func: x =", x)

逻辑分析：

• 第1行 ：定义全局变量 x 。
• 第4行 ：在函数内部使用 global x 声明对全局变量的引用。
• 第5行 ：修改全局变量 x 。
• 第6~7行 ：打印局部变量 y 和修改后的 x 。
• 第9行 ：调用函数后，再次打印 x ，验证其值是否被修改。

输出结果：

Inside func: x = 15 y = 20
Outside func: x = 15

变量作用域对比表：

变量类型	定义位置	可见范围	是否可修改
全局变量	函数外部	全局可见	是（需声明）
局部变量	函数内部	仅函数内部可见	否（默认）

5.2 高阶函数与函数式编程特性

Python 支持函数式编程范式，允许将函数作为参数传递给其他函数，或作为返回值返回。这使得我们能够使用如 map 、 filter 、 lambda 、闭包和装饰器等高级函数式特性。

5.2.1 map、filter 与 lambda 函数

map 和 filter 是两个常用的高阶函数，常与 lambda 表达式配合使用。

示例代码：

numbers = [1, 2, 3, 4, 5]

# 使用 map 计算平方
squared = list(map(lambda x: x ** 2, numbers))

# 使用 filter 过滤偶数
evens = list(filter(lambda x: x % 2 == 0, numbers))

print("Squared numbers:", squared)
print("Even numbers:", evens)

逻辑分析：

• 第3行 ：使用 map 将 numbers 中的每个元素传入 lambda x: x ** 2 计算平方。
• 第6行 ：使用 filter 过滤出 numbers 中的偶数。
• 第8~9行 ：输出结果。

输出结果：

Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]

高阶函数对比表：

函数名	功能描述	输入类型	输出类型
map	对序列中每个元素执行操作	iterable, func	map object
filter	过滤满足条件的元素	func, iterable	filter object

5.2.2 闭包与装饰器原理

闭包是指函数内部定义的函数能够访问外部函数的变量。装饰器本质上是一个函数，用于增强其他函数的功能而不修改其源码。

示例代码：

def outer_function(msg):
    def inner_function():
        print(msg)
    return inner_function

my_func = outer_function("Hello Closure!")
my_func()

逻辑分析：

• 第1~3行 ：定义 outer_function ，其内部嵌套 inner_function 。
• 第4行 ：返回 inner_function 函数对象。
• 第6行 ：调用闭包函数 my_func() ，输出 "Hello Closure!" 。

输出结果：

Hello Closure!

装饰器示例：

def my_decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@my_decorator
def say_hello():
    print("Hello")

say_hello()

输出结果：

Before function call
Hello
After function call

装饰器执行流程（Mermaid 流程图）：

graph TD
    A[调用 say_hello()] --> B{被装饰器包裹}
    B --> C[执行 wrapper()]
    C --> D[打印 Before]
    C --> E[调用原函数 say_hello()]
    E --> F[打印 Hello]
    C --> G[打印 After]

5.3 模块与包的组织结构

模块是 Python 中组织代码的基本单位，包则是模块的集合。良好的模块与包结构有助于项目管理、代码复用和协作开发。

5.3.1 模块导入机制与命名空间

模块通过 import 语句导入，Python 会搜索模块路径并加载到当前命名空间。

示例代码（模块文件： math_utils.py ）：

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

主程序中使用模块：

import math_utils

result1 = math_utils.add(3, 4)
result2 = math_utils.multiply(3, 4)

print("Add:", result1)
print("Multiply:", result2)

逻辑分析：

• 第1行 ：导入自定义模块 math_utils 。
• 第3~4行 ：调用模块中的函数进行运算。
• 第6~7行 ：输出结果。

输出结果：

Add: 7
Multiply: 12

模块导入方式对比表：

导入方式	语法示例	说明
完整导入	import module	需使用模块名访问函数
指定导入	from module import func	可直接调用函数
导入全部函数	from module import *	不推荐，容易造成命名冲突
别名导入	import module as m	用于简化模块名称或避免冲突

5.3.2 包管理与 __init__.py 文件

包是一个包含多个模块的目录，目录中必须包含 __init__.py 文件（可以为空），以告诉 Python 这是一个包。

目录结构示例：

my_package/
│
├── __init__.py
├── math_utils.py
└── string_utils.py

使用包：

from my_package import math_utils, string_utils

print(math_utils.add(2, 3))
print(string_utils.uppercase("hello"))

输出结果：

5
HELLO

包结构说明：

• __init__.py ：初始化包，可以定义 __all__ 控制导入行为。
• 子模块（如 math_utils ）：定义具体功能函数。
• 主程序中通过 from package import module 引入模块。

5.4 标准库核心模块实战

Python 标准库提供了丰富的模块，可用于系统操作、时间处理、网络通信等任务。本节将介绍 os 、 datetime 和 socket 模块的实战应用。

5.4.1 os 模块与系统操作

os 模块提供了与操作系统交互的功能，如创建目录、获取文件信息、执行命令等。

示例代码：

import os

# 获取当前工作目录
print("Current Directory:", os.getcwd())

# 创建新目录
os.makedirs("test_dir", exist_ok=True)

# 列出目录内容
print("Files in current dir:", os.listdir("."))

输出结果（示例）：

Current Directory: /home/user/projects
Files in current dir: ['test_dir', 'main.py']

os 模块常用方法表：

方法名	功能描述
os.getcwd()	获取当前工作目录
os.listdir()	列出目录内容
os.makedirs()	创建多层目录
os.remove()	删除文件
os.rename()	重命名文件或目录

5.4.2 datetime 模块与时间处理

datetime 模块用于处理日期和时间相关操作。

示例代码：

from datetime import datetime

# 获取当前时间
now = datetime.now()
print("Current Time:", now.strftime("%Y-%m-%d %H:%M:%S"))

# 计算时间差
from datetime import timedelta
future = now + timedelta(days=1)
print("Tomorrow:", future.strftime("%Y-%m-%d %H:%M:%S"))

输出结果（示例）：

Current Time: 2025-04-05 14:30:00
Tomorrow: 2025-04-06 14:30:00

时间格式化说明表：

格式符	含义	示例
%Y	四位年份	2025
%m	月份（01-12）	04
%d	日期（01-31）	05
%H	小时（24小时）	14
%M	分钟	30
%S	秒	00

5.4.3 socket 模块与网络通信

socket 模块支持网络通信，可用于编写客户端-服务器程序。

示例代码（服务器端）：

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("localhost", 12345))
server.listen(1)
print("Server is listening...")

conn, addr = server.accept()
print("Connected by", addr)

data = conn.recv(1024)
print("Received:", data.decode())
conn.close()

示例代码（客户端）：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("localhost", 12345))
client.sendall(b"Hello Server")
client.close()

输出结果（服务器端）：

Server is listening...
Connected by ('127.0.0.1', 12345)
Received: Hello Server

socket 通信流程图（Mermaid）：

graph LR
    A[客户端] --> B[连接服务器]
    B --> C[发送数据]
    C --> D[服务器接收]
    D --> E[服务器处理]
    E --> F[客户端关闭连接]

本章从函数定义、高阶函数、模块结构到标准库实战，系统地讲解了 Python 函数与模块化编程的核心知识。下一章将进入面向对象编程的深入学习，进一步提升你的编程抽象能力与系统设计水平。

6. 面向对象编程与高级特性

6.1 类与对象的基本结构

Python 是一门面向对象的编程语言，类（class）是构建对象（object）的蓝图。类定义了对象的属性和方法，而对象是类的具体实例。

类的定义与实例化

在 Python 中，使用 class 关键字定义一个类。例如：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

• __init__ 是类的构造函数，用于初始化对象的属性。
• self 是类方法的第一个参数，表示对象自身。
• greet() 是一个类方法，用于执行对象的行为。

实例化对象 ：

p = Person("Alice", 30)
p.greet()

输出：

Hello, my name is Alice and I am 30 years old.

属性与方法的封装机制

Python 支持属性的封装，通过使用双下划线 __ 前缀实现属性的私有化：

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

使用私有属性后，外部无法直接访问：

acc = BankAccount("Bob", 1000)
acc.deposit(500)
print(acc.get_balance())  # 输出：1500
print(acc.__balance)      # 抛出 AttributeError

6.2 继承与多态机制

继承是面向对象编程的核心机制之一，允许一个类（子类）继承另一个类（父类）的属性和方法。

父类与子类的关系

以下是一个简单的继承示例：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

方法重写与接口设计

子类可以重写父类的方法以实现不同的行为。多态性允许我们以统一的接口处理不同的对象：

def animal_sound(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出：Woof!
animal_sound(cat)  # 输出：Meow!

该机制使得代码具有良好的扩展性，新增动物类型时无需修改已有逻辑。

6.3 静态类型与类型注解

虽然 Python 是动态类型语言，但 Python 3.5 起引入了类型注解，3.7 中进一步完善，增强了代码可读性和维护性。

类型提示语法与工具支持

函数参数和返回值可以添加类型注解：

def add(a: int, b: int) -> int:
    return a + b

• a: int 表示参数 a 应为整数类型。
• -> int 表示返回值应为整数类型。

变量也可以指定类型：

name: str = "Alice"

mypy 静态类型检查实践

可以使用 mypy 工具进行类型检查：

安装：

pip install mypy

检查代码：

mypy your_script.py

示例：

def greet(name: str) -> None:
    print(f"Hello, {name}")

greet(123)  # mypy 会报错：Argument 1 to "greet" has incompatible type "int"; expected "str"

6.4 异步编程与上下文管理

Python 3.7 对异步编程支持更加完善， asyncio 成为标准库的重要组成部分。

async/await 语法与 asyncio 库

异步函数使用 async def 定义，内部通过 await 调用其他异步函数：

import asyncio

async def count(number):
    for i in range(1, number+1):
        print(i)
        await asyncio.sleep(1)

async def main():
    task1 = asyncio.create_task(count(3))
    task2 = asyncio.create_task(count(3))

    await task1
    await task2

asyncio.run(main())

• async def 定义协程。
• await 用于等待异步任务完成。
• asyncio.run() 是 Python 3.7 新增的启动异步程序的方法。

with 语句与资源自动管理

with 语句用于自动管理资源，如文件、网络连接等：

with open('example.txt', 'w') as f:
    f.write("Hello, Python 3.7!")

with 会自动调用 __enter__ 和 __exit__ 方法，确保资源释放。

6.5 Python 3.7 新增特性详解

Python 3.7 引入了许多新特性，其中 dataclass 和 f-string 的增强是面向对象编程的重要补充。

dataclass 简化类定义

dataclass 是 Python 3.7 新增的标准库模块，用于自动生成类的 __init__ 、 __repr__ 等方法：

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0

p = Product("Apple", 1.2, 10)
print(p)  # 输出：Product(name='Apple', price=1.2, quantity=10)

• 不需要手动编写构造函数。
• 默认支持 __repr__ 、 __eq__ 等方法。
• 可设置默认值（如 quantity ）。

f-string 改进与格式化增强

Python 3.7 支持在 f-string 中直接使用 = 进行变量名和值的输出，便于调试：

x = 3.14
print(f"x={x:.2f}")  # 输出：x=3.14

更实用的是：

name = "Alice"
age = 30
print(f"{name=}, {age=}")  # 输出：name='Alice', age=30

这一特性极大提高了调试效率，特别是在复杂表达式中。

下一节将深入探讨 Python 的元编程特性，包括描述符、元类等高级面向对象机制。

本文还有配套的精品资源，点击获取

简介：Python 3.7.3是Python语言的一个稳定且广泛应用的版本，具有简洁清晰的语法和强大的功能。本官方中文PDF指南全面覆盖了Python的基础语法、面向对象编程、标准库、函数式编程、异常处理、类型注解、异步编程等核心内容，并介绍了如数据类、f-string增强等新特性。适合初学者系统学习，也适合开发者作为权威参考手册使用。通过丰富的示例代码和清晰讲解，帮助用户快速掌握Python 3.7.3编程技巧并应用于实际开发中。

本文还有配套的精品资源，点击获取