python
Python Syntax and Basics
-
课前甜点
-
Python 解释器
2.1. 调用解释器
2.1.1. 传入参数
2.1.2. 交互模式
2.2. 解释器的运行环境
2.2.1. 源文件的字符编码 -
Python 速览
3.1. Python 用作计算器
3.1.1. 数字
3.1.2. 字符串
3.1.3. 列表
3.2. 走向编程的第一步 -
其他流程控制工具
4.1. if 语句
4.2. for 语句
4.3. range() 函数
4.4. 循环中的 break、continue 语句及 else 子句
4.5. pass 语句
4.6. match 语句
4.7. 定义函数
4.8. 函数定义详解
4.8.1. 默认值参数
4.8.2. 关键字参数
4.8.3. 特殊参数
4.8.3.1. 位置或关键字参数
4.8.3.2. 仅位置参数
4.8.3.3. 仅限关键字参数
4.8.3.4. 函数示例
4.8.3.5. 小结
4.8.4. 任意实参列表
4.8.5. 解包实参列表
4.8.6. Lambda 表达式
4.8.7. 文档字符串
4.8.8. 函数注解
4.9. 小插曲：编码风格 -
数据结构
5.1. 列表详解
5.1.1. 用列表实现堆栈
5.1.2. 用列表实现队列
5.1.3. 列表推导式
5.1.4. 嵌套的列表推导式
5.2. del 语句
5.3. 元组和序列
5.4. 集合
5.5. 字典
5.6. 循环的技巧
5.7. 深入条件控制
5.8. 序列和其他类型的比较 -
模块
6.1. 模块详解
6.1.1. 以脚本方式执行模块
6.1.2. 模块搜索路径
6.1.3. “已编译的” Python 文件
6.2. 标准模块
6.3. dir() 函数
6.4. 包
6.4.1. 从包中导入 *
6.4.2. 子包参考
6.4.3. 多目录中的包 -
输入与输出
7.1. 更复杂的输出格式
7.1.1. 格式化字符串字面值
7.1.2. 字符串 format() 方法
7.1.3. 手动格式化字符串
7.1.4. 旧式字符串格式化方法
7.2. 读写文件
7.2.1. 文件对象的方法
7.2.2. 使用 json 保存结构化数据 -
错误和异常
8.1. 句法错误
8.2. 异常
8.3. 异常的处理
8.4. 触发异常
8.5. 异常链
8.6. 用户自定义异常
8.7. 定义清理操作
8.8. 预定义的清理操作
8.9. Raising and Handling Multiple Unrelated Exceptions
8.10. Enriching Exceptions with Notes -
类
9.1. 名称和对象
9.2. Python 作用域和命名空间
9.2.1. 作用域和命名空间示例
9.3. 初探类
9.3.1. 类定义语法
9.3.2. Class 对象
9.3.3. 实例对象
9.3.4. 方法对象
9.3.5. 类和实例变量
9.4. 补充说明
9.5. 继承
9.5.1. 多重继承
9.6. 私有变量
9.7. 杂项说明
9.8. 迭代器
9.9. 生成器
9.10. 生成器表达式 -
标准库简介
10.1. 操作系统接口
10.2. 文件通配符
10.3. 命令行参数
10.4. 错误输出重定向和程序终止
10.5. 字符串模式匹配
10.6. 数学
10.7. 互联网访问
10.8. 日期和时间
10.9. 数据压缩
10.10. 性能测量
10.11. 质量控制
10.12. 自带电池 -
标准库简介 —— 第二部分
11.1. 格式化输出
11.2. 模板
11.3. 使用二进制数据记录格式
11.4. 多线程
11.5. 日志记录
11.6. 弱引用
11.7. 用于操作列表的工具
11.8. 十进制浮点运算 -
虚拟环境和包
12.1. 概述
12.2. 创建虚拟环境
12.3. 使用pip管理包 -
接下来？
-
交互式编辑和编辑历史
14.1. Tab 补全和编辑历史
14.2. 默认交互式解释器的替代品 -
浮点算术：争议和限制
15.1. 表示性错误 -
附录
16.1. 交互模式
16.1.1. 错误处理
16.1.2. 可执行的Python脚本
16.1.3. 交互式启动文件
16.1.4. 定制模块 -
课前甜点
这部分可能是引言或者一些有趣的内容，与Python编程无关。
- Python 解释器
Python解释器是执行Python代码的程序。它可以直接从命令行调用，也可以通过集成开发环境（IDE）等工具使用。
2.1. 调用解释器
可以通过命令行输入python来调用Python解释器。例如：
python
2.1.1. 传入参数
可以在调用解释器时传递参数。例如，可以通过命令行输入以下命令来执行一个Python脚本文件：
python script.py
2.1.2. 交互模式
解释器还支持交互模式，可以在命令行中逐行执行Python代码并立即看到结果。
python
2.2. 解释器的运行环境
解释器在执行Python代码时有一个运行环境。这包括全局变量、导入的模块和其他执行环境相关的内容。
2.2.1. 源文件的字符编码
Python源文件的默认字符编码是UTF-8，但可以在文件开头使用特殊注释来指定不同的编码格式。
# -*- coding: utf-8 -*-
- Python 速览
这部分提供了对Python的基础概念的快速概述。
3.1. Python用作计算器
Python可以作为一个简单的计算器使用，执行数学运算并打印结果。
3.1.1. 数字
可以使用Python进行基本的数学运算，如加法、减法、乘法和除法。
# 加法
result = 2 + 3
print(result) # 输出: 5
# 减法
result = 5 - 2
print(result) # 输出: 3
# 乘法
result = 3 * 4
print(result) # 输出: 12
# 除法
result = 10 / 3
print(result) # 输出: 3.3333333333333335
3.1.2. 字符串
字符串是由字符组成的序列，可以用单引号或双引号括起来。
# 字符串拼接
greeting = "Hello"
name = "Alice"
message = greeting + ", " + name + "!"
print(message) # 输出: Hello, Alice!
3.1.3. 列表
列表是由多个值组成的有序集合，可以包含不同类型的元素。
# 创建列表
fruits = ['apple', 'banana', 'orange']
# 访问列表元素
print(fruits[0]) # 输出: apple
# 列表切片
print(fruits[1:3]) # 输出: ['banana', 'orange']
# 列表长度
print(len(fruits)) # 输出: 3
# 添加元素
fruits.append('grape')
# 循环遍历列表
for fruit in fruits:
print(fruit)
3.2. 走向编程的第一步
这一部分可能涉及一些基本的编程概念和范例，以帮助初学者开始编写Python代码。
- 其他流程控制工具
这部分涵盖了Python中的条件语句、循环语句和其他流程控制工具。
4.1. if语句
if语句用于根据条件的真假执行不同的代码块。
# 根据条件执行代码块
x = 5
if x > 0:
print("x is positive")
elif x < 0:
print("x is negative")
else:
print("x is zero")
4.2. for语句
for语句用于遍历可迭代对象（如列表）中的元素。
# 遍历列表元素
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
print(fruit)
4.3. range()函数
range()函数用于生成一个数字序列，常用于循环中的计数。
# 使用range()生成数字序列
for i in range(5):
print(i) # 输出: 0, 1, 2, 3, 4
# 指定范围的起始值、终止值和步长
for i in range(1, 10, 2):
print(i) # 输出: 1, 3, 5, 7, 9
4.4. 循环中的break、continue语句及else子句
break语句用于提前结束循环，continue语句用于跳过当前迭代，而else子句在循环正常结束时执行。
# 使用break提前结束循环
for i in range(5):
if i == 3:
break
print(i) # 输出: 0, 1, 2
# 使用continue跳过当前迭代
for i in range(5):
if i == 2:
continue
print(i) # 输出: 0, 1, 3, 4
# else子句在循环正常结束时执行
for i in range(5):
print(i)
else:
print("Loop completed") # 输出: Loop completed
4.5. pass语句
pass语句用作占位符，表示不执行任何操作。它通常用于需要语法正确但不需要执行任何代码的情况。
# pass语句的使用
if x > 0:
pass
# 无需执行任何操作，保持语法正确性
4.6. match语句
match语句是Python 3.10中引入的新特性，用于模式匹配和条件分支。
# 使用match语句进行模式匹配
grade = 'B'
match grade:
case 'A':
print("Excellent")
case 'B':
print("Good")
case 'C':
print("Fair")
case _:
print("No grade")
4.7. 定义函数
函数是可重复使用的代码块，可以接受参数并返回结果。
# 定义函数
def greet(name):
print("Hello, " + name + "!")
# 调用函数
greet("Alice") # 输出: Hello, Alice!
4.8. 函数定义详解
这部分提供了关于函数定义的更详细解释，包括默认值参数、关键字参数和特殊参数。
4.8.1. 默认值参数
函数可以定义具有默认值的参数，使得在调用函数时可以省略这些参数。
# 定义具有默认值的参数
def greet(name, greeting="Hello"):
print(greeting + ", " + name + "!")
# 调用函数，使用默认的问候语
greet("Alice") # 输出: Hello, Alice!
# 调用函数，使用自定义的问候语
greet("Bob", "Hi") # 输出: Hi, Bob!
4.8.2. 关键字参数
函数调用时可以使用关键字参数指定参数的值，而不必按照参数定义的顺序。
# 使用关键字参数调用函数
greet(greeting="Hi", name="Alice") # 输出: Hi, Alice!
4.8.3. 特殊参数
Python函数还支持一些特殊的参数形式。
4.8.3.1. 位置或关键字参数
函数可以接受既可以作为位置参数又可以作为关键字参数传递的参数。
# 接受位置或关键字参数的函数
def greet(greeting, name):
print(greeting + ", " + name + "!")
# 调用函数，使用位置参数
greet("Hello", "Alice") # 输出: Hello, Alice!
# 调用函数，使用关键字参数
greet(name="Bob", greeting="Hi") # 输出: Hi, Bob!
4.8.3.2. 仅位置参数
函数可以要求仅接受位置参数，而不能使用关键字参数。
# 仅接受位置参数的函数
def greet(greeting, /, name):
print(greeting + ", " + name + "!")
# 调用函数，只能使用位置参数
greet("Hello", "Alice") # 输出: Hello, Alice!
# 调用函数，使用关键字参数会引发错误
greet(greeting="Hi", name="Bob") # 抛出错误
4.8.3.3. 仅限关键字参数
函数
可以要求仅接受关键字参数，而不能使用位置参数。
# 仅接受关键字参数的函数
def greet(*, greeting, name):
print(greeting + ", " + name + "!")
# 调用函数，只能使用关键字参数
greet(greeting="Hello", name="Alice") # 输出: Hello, Alice!
# 调用函数，使用位置参数会引发错误
greet("Hi", "Bob") # 抛出错误
4.8.3.4. 函数示例
以下是一个演示了各种参数形式的函数示例：
# 演示不同参数形式的函数
def process_data(data, *, algorithm="sha256", iterations=1000):
# 处理数据
print("Processing data using algorithm:", algorithm)
print("Number of iterations:", iterations)
# 调用函数，使用位置参数和默认值参数
process_data("data") # 输出: Processing data using algorithm: sha256, Number of iterations: 1000
# 调用函数，使用关键字参数和默认值参数
process_data(data="data", iterations=5000) # 输出: Processing data using algorithm: sha256, Number of iterations: 5000
4.8.3.5. 小结
这部分概述了函数参数的不同形式和调用方式。在实际编写函数时，可以根据需要选择适当的参数形式。
4.8.4. 任意实参列表
函数可以接受任意数量的参数，这些参数将作为元组传递给函数。
# 接受任意数量参数的函数
def multiply(*numbers):
result = 1
for num in numbers:
result *= num
return result
# 调用函数，传递不同数量的参数
print(multiply(2, 3, 4)) # 输出: 24
print(multiply(5, 6)) # 输出: 30
4.8.5. 解包实参列表
在函数调用时，可以使用解包操作符*将列表或元组中的元素作为独立的参数传递给函数。
# 解包实参列表
numbers = [2, 3, 4]
print(multiply(*numbers)) # 输出: 24
4.8.6. Lambda表达式
Lambda表达式是一种简洁的函数定义形式，用于创建匿名函数。
# 使用lambda创建匿名函数
add = lambda x, y: x + y
print(add(2, 3)) # 输出: 5
4.8.7. 文档字符串
文档字符串是函数定义的第一个语句，用于提供关于函数的描述和使用说明。
# 使用文档字符串注释函数
def greet(name):
"""
打印问候语和姓名。
参数：
name: str，姓名
"""
print("Hello, " + name + "!")
# 查看函数的文档字符串
print(greet.__doc__)
4.8.8. 函数注
解
函数注解是在函数定义中用于提供参数和返回值类型的注释。
# 使用函数注解
def greet(name: str) -> None:
print("Hello, " + name + "!")
# 查看函数的注解
print(greet.__annotations__)
4.9. 小插曲：编码风格
这部分可能介绍Python的编码风格规范，如PEP 8，并提供一些编码风格的指导原则。
- 数据结构
这部分涵盖了Python中常用的数据结构，如列表、元组、集合和字典。
5.1. 列表详解
列表是一个可变的有序序列，可以包含不同类型的元素。
5.1.1. 用列表实现堆栈
堆栈（栈）是一种后进先出（LIFO）的数据结构。可以使用列表的append()和pop()方法来实现堆栈。
# 用列表实现堆栈
stack = []
stack.append(1) # 入栈
stack.append(2)
stack.append(3)
print(stack.pop()) # 出栈，输出: 3
print(stack.pop()) # 出栈，输出: 2
5.1.2. 用列表实现队列
队列是一种先进先出（FIFO）的数据结构。可以使用列表的append()和pop()方法来实现队列，但效率较低。更好的选择是使用collections模块中的deque。
from collections import deque
# 用deque实现队列
queue = deque()
queue.append(1) # 入队
queue.append(2)
queue.append(3)
print(queue.popleft()) # 出队，输出: 1
print(queue.popleft()) # 出队，输出: 2
5.1.3. 列表推导式
列表推导式是一种简洁的创建列表的方式，可以根据一定的规则生成列表。
# 列表推导式的使用
numbers = [1, 2, 3, 4, 5]
squared_numbers = [num**2 for num in numbers]
print(squared_numbers) # 输出: [1, 4, 9, 16, 25]
5.1.4. 嵌套的列表推导式
列表推导式还可以嵌套使用，用于创建嵌套列表。
# 嵌套的列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_matrix = [num for row in matrix for num in row]
print(flattened_matrix) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
5.2. del语句
del语句用于删除列表中的元素或删除整个变量。
# 删除列表元素
fruits = ['apple', 'banana', 'orange']
del fruits
[0] # 删除第一个元素
print(fruits) # 输出: ['banana', 'orange']
# 删除变量
del fruits
5.3. 元组和序列
元组是一个不可变的有序序列，类似于列表，但元组的元素不可修改。
# 创建元组
point = (2, 3)
print(point) # 输出: (2, 3)
# 访问元组元素
x = point[0]
y = point[1]
print(x, y) # 输出: 2 3
5.4. 集合
集合是一个无序的、可变的、不重复的元素集合。
# 创建集合
fruits = {'apple', 'banana', 'orange'}
# 添加元素
fruits.add('grape')
# 遍历集合
for fruit in fruits:
print(fruit)
5.5. 字典
字典是一个无序的键值对集合。
# 创建字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 访问字典元素
print(person['name']) # 输出: Alice
# 修改字典元素
person['age'] = 26
# 遍历字典
for key, value in person.items():
print(key, value)
5.6. 循环的技巧
这部分提供了在循环中处理数据的一些技巧，如使用enumerate()、zip()和reversed()。
# 使用enumerate()获取索引和值
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
print(index, fruit)
# 使用zip()组合多个列表
numbers = [1, 2, 3]
letters = ['A', 'B', 'C']
for number, letter in zip(numbers, letters):
print(number, letter)
# 使用reversed()反向遍历序列
for fruit in reversed(fruits):
print(fruit)
5.7. 深入条件控制
这部分可能介绍一些条件控制的高级技巧，如使用any()和all()函数、条件表达式等。
# 使用any()和all()函数
numbers = [1, 2, 3, 4, 5]
greater_than_two = any(num > 2 for num in numbers)
print(greater_than_two) # 输出: True
all_positive = all(num > 0 for num in numbers)
print(all_positive) # 输出: True
# 条件表达式
x = 5
result = "Positive" if x > 0 else "Negative or zero"
print(result) # 输出: Positive
5.8. 序列和其他类型的比较
可以使用比较运算符（如==、!=、<、>等）比较序列和其他类型的元素。
# 序列和其他类型的比较
numbers = [1, 2, 3]
print(numbers == [1, 2, 3]) # 输出: True
fruits = ['apple', 'banana', 'orange']
print(fruits <
['apple', 'cherry']) # 输出: True
- 模块
模块是一个包含Python定义和语句的文件，可以通过导入模块来重复使用代码。
6.1. 模块详解
这部分涵盖了模块的详细解释，包括如何导入模块、模块搜索路径和模块的执行方式。
6.1.1. 以脚本方式执行模块
模块可以通过直接运行模块文件来执行。
# 以脚本方式执行模块
if __name__ == '__main__':
# 执行模块的代码
pass
6.1.2. 模块搜索路径
当导入模块时，Python会按照一定的搜索路径来查找模块文件。
# 查看模块搜索路径
import sys
print(sys.path)
6.1.3. “已编译的” Python文件
在导入模块时，Python解释器会将源代码编译成字节码，并将字节码保存在以.pyc为扩展名的文件中。
6.2. 标准模块
Python标准库中包含许多有用的模块，可以通过导入这些模块来获得各种功能。
# 导入标准模块
import math
# 使用模块中的功能
print(math.sqrt(16)) # 输出: 4.0
6.3. dir()函数
dir()函数用于获取模块或对象中定义的所有名称列表。
# 获取模块中的所有名称
import math
print(dir(math))
# 获取对象中的所有名称
numbers = [1, 2, 3]
print(dir(numbers))
6.4. 包
包是一种将相关模块组织在一起的方式，可以使用点号来访问包中的模块。
6.4.1. 从包中导入 *
可以使用from package import *的形式从包中导入所有模块。但这种方式不推荐使用，因为会导入大量的名称，可能会引起命名冲突。
6.4.2. 子包参考
可以使用点号语法来引用子包中的模块。
# 引用子包中的模块
import package.subpackage.module
6.4.3. 多目录中的包
包可以位于多个目录中，可以通过在模块中设置__path__变量来实现。
- 输入与输出
这部分涵盖了输入和输出相关的内容，包括格式化输出、文件读写和使用json保存数据。
7.1. 更复杂的输出格式
这部分介绍了一些用于格式化输出的技巧，包括格式化字符串字面值、字符串的format()方法和旧式的字符串格式化方法。
7.1.1. 格式化字符串字面值
格式
化字符串字面值是一种简洁的格式化字符串的方式，可以通过在字符串前加上f前缀来创建。
# 格式化字符串字面值的使用
name = "Alice"
age = 25
message = f"My name is {name} and I'm {age} years old."
print(message) # 输出: My name is Alice and I'm 25 years old.
7.1.2. 字符串format()方法
字符串的format()方法用于格式化字符串，可以在字符串中使用占位符 {} 来表示要插入的值。
# 字符串format()方法的使用
name = "Alice"
age = 25
message = "My name is {} and I'm {} years old.".format(name, age)
print(message) # 输出: My name is Alice and I'm 25 years old.
7.1.3. 手动格式化字符串
可以使用字符串的%运算符来手动格式化字符串，类似于C语言中的printf()函数。
# 手动格式化字符串的使用
name = "Alice"
age = 25
message = "My name is %s and I'm %d years old." % (name, age)
print(message) # 输出: My name is Alice and I'm 25 years old.
7.1.4. 旧式字符串格式化方法
旧式字符串格式化方法使用百分号（%）作为占位符，并且根据值的类型选择合适的格式。
# 旧式字符串格式化方法的使用
name = "Alice"
age = 25
message = "My name is %s and I'm %d years old." % (name, age)
print(message) # 输出: My name is Alice and I'm 25 years old.
7.2. 读写文件
可以使用内置的open()函数来读写文件。读取文件时可以使用read()或readlines()方法，写入文件时可以使用write()方法。
# 读取文件
file = open('data.txt', 'r')
content = file.read()
print(content)
file.close()
# 写入文件
file = open('data.txt', 'w')
file.write("Hello, world!")
file.close()
7.2.1. 文件对象的方法
文件对象具有许多方法，用于读取和写入文件、移动文件指针以及关闭文件。
7.2.2. 使用json保存结构化数据
可以使用json模块将Python数据结构（如字典、列表）转换为JSON格式，并将其保存到文件中。
import json
# 将Python数据结构转换为JSON并保存到文件
data = {'name': 'Alice', 'age': 25}
with open('data.json', 'w') as file:
json.dump(data, file)
# 从文件中加载JSON数据并转换为Python数据结构
with open('data.json', 'r') as file:
loaded_data = json.load(file)
print(loaded_data) # 输出: {'name': 'Alice', 'age': 25}
- 错误和异常
这部分涵盖了Python中的错误和异常
处理机制，包括句法错误、异常的处理方式、触发异常以及用户自定义异常。
8.1. 句法错误
句法错误是指代码不符合Python语法规则，导致解释器无法解析和执行。
8.2. 异常
异常是指在程序运行过程中发生的错误或异常情况。
8.3. 异常的处理
可以使用try-except语句来捕获和处理异常。
# 捕获和处理异常
try:
# 可能引发异常的代码
result = 1 / 0
except ZeroDivisionError:
# 处理异常的代码
print("Division by zero is not allowed")
8.4. 触发异常
可以使用raise语句主动触发异常。
# 触发异常
raise ValueError("Invalid value")
8.5. 异常链
在处理异常时，可以使用from关键字将原始异常链接到新的异常中。
# 异常链
try:
result = 1 / 0
except ZeroDivisionError as e:
raise ValueError("Invalid value") from e
8.6. 用户自定义异常
可以创建自定义的异常类，继承自内置的Exception类或其子类。
# 自定义异常类
class MyException(Exception):
pass
# 触发自定义异常
raise MyException("This is a custom exception")
8.7. 定义清理操作
可以使用try-finally语句来定义在发生异常时必须执行的清理操作。
# 定义清理操作
try:
# 可能引发异常的代码
file = open("data.txt", "r")
content = file.read()
except IOError:
# 处理异常的代码
print("An error occurred while reading the file")
finally:
# 清理操作
file.close()
8.8. 预定义的清理操作
可以使用with语句来自动进行资源的管理和清理操作，如关闭文件。
# 使用with语句自动进行资源管理和清理操作
with open("data.txt", "r") as file:
content = file.read()
print(content)
8.9. Raising and Handling Multiple Unrelated Exceptions
可以同时处理多个不相关的异常，或者在引发异常时处理多个异常类型。
try:
# 可能引发异常的代码
result = 1 / 0
except (ValueError, ZeroDivisionError):
# 处理多个异常的代码
print("An error occurred")
8.10. Enriching Exceptions with Notes
可以在引发异常时添加附加信息，以便更好地理解异常的原因。
try:
# 可能引发异常的代码
result = 1 / 0
except ZeroDivisionError as e:
# 添加附加信息到异常中
raise ZeroDivisionError("Division by zero is not allowed") from e
- 类
这部分涵盖了面向对象编程
的基本概念，包括类的定义、对象的创建和方法的调用。
9.1. 名称和对象
这部分可能解释名称和对象之间的关系，以及如何使用名称来引用对象。
9.2. Python 作用域和命名空间
这部分解释了Python中作用域和命名空间的概念，以及如何访问和使用不同作用域中的名称。
9.2.1. 作用域和命名空间示例
可以通过示例来说明作用域和命名空间的概念，以及全局作用域和局部作用域的区别。
9.3. 初探类
这部分介绍了类的概念和基本语法，包括类的定义、属性和方法。
9.3.1. 类定义语法
类的定义使用class关键字，后面跟着类的名称和冒号，然后是类的主体。
# 类定义的语法
class MyClass:
# 类的主体
pass
9.3.2. Class对象
在Python中，类是对象。可以通过类来创建实例对象，并访问类的属性和方法。
# 创建类的实例对象
my_obj = MyClass()
# 访问对象的属性和方法
my_obj.my_attribute
my_obj.my_method()
9.3.3. 实例对象
实例对象是类的具体实例，每个实例对象都有自己的状态（属性）和行为（方法）。
# 类的定义
class Person:
def __init__(self, name):
self.name = name
def say_hello(self):
print("Hello, " + self.name + "!")
# 创建实例对象
person = Person("Alice")
# 访问实例对象的属性和调用方法
print(person.name) # 输出: Alice
person.say_hello() # 输出: Hello, Alice!
9.3.4. 方法对象
方法对象是类中定义的函数，与普通函数不同，方法需要通过实例对象来调用。
# 类的定义
class Person:
def say_hello(self):
print("Hello!")
# 创建实例对象
person = Person()
# 调用方法对象
person.say_hello() # 输出: Hello!
9.3.5. 类和实例变量
类变量是属于类的属性，所有实例对象共享该变量。实例变量是属于每个实例对象的属性，每个实例对象都有自己的实例变量。
# 类的定义
class Person:
# 类变量
species = "Human"
def __init__(self, name):
# 实例变量
self.name = name
# 创建实例对象
person1 = Person("Alice")
person2 = Person("Bob")
# 访问类变量
print(person1.species) # 输出: Human
print(person2.species) # 输出: Human
# 访问实例变量
print(person1.name) # 输出: Alice
print(person2.name
) # 输出: Bob
9.4. 补充说明
这部分可能提供一些与类相关的额外说明，如访问控制、属性访问器和属性设置器等。
9.5. 继承
继承是面向对象编程的核心概念之一，可以通过继承来创建新的类，并重用现有类的属性和方法。
9.5.1. 多重继承
Python支持多重继承，即一个类可以从多个父类继承属性和方法。
# 类的定义
class Animal:
def breathe(self):
print("Breathing")
class Mammal:
def feed_milk(self):
print("Feeding milk")
class Cat(Animal, Mammal):
def meow(self):
print("Meowing")
# 创建实例对象
cat = Cat()
# 调用继承的方法
cat.breathe() # 输出: Breathing
cat.feed_milk() # 输出: Feeding milk
cat.meow() # 输出: Meowing
9.6. 私有变量
可以使用双下划线__来创建私有变量，私有变量只能在类的内部访问。
# 类的定义
class MyClass:
def __init__(self):
self.__private_var = 10
def __private_method(self):
print("Private method")
def public_method(self):
print("Public method")
self.__private_method()
# 创建实例对象
my_obj = MyClass()
# 访问私有变量和调用私有方法（会引发错误）
print(my_obj.__private_var) # 抛出错误
my_obj.__private_method() # 抛出错误
# 调用公有方法
my_obj.public_method() # 输出: Public method, Private method
9.7. 杂项说明
这部分可能包含一些与类相关的其他概念和注意事项，如静态方法、类方法和属性访问器等。
9.8. 迭代器
迭代器是一种用于遍历可迭代对象的对象，可以通过实现__iter__()和__next__()方法来创建迭代器。
# 迭代器的定义
class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
value = self.data[self.index]
self.index += 1
return value
# 创建迭代器对象
my_iter = MyIterator([1, 2, 3])
# 使用迭代器遍历数据
for num in my_iter:
print(num) # 输出: 1 2 3
9.9. 生成器
生成器是一种特殊的迭代器，可以使用函数和yield语句来创建生成器。
# 生成器的定义
def my_generator():
yield 1
yield 2
yield 3
# 创建生成器对象
gen = my_generator()
# 使用生成器遍历数据
for num in gen:
print(num) # 输出: 1 2 3
9.10. 生成器表达式
生成器表达式是一种简洁的创建生成器的方式，类似于列表推导式。
# 生成器表达式的使用
gen = (num for num in range(1, 4))
# 使用生成器遍历数据
for num in gen:
print(num) # 输出: 1 2 3
- 标准库简介
这部分涵盖了Python标准库中常用的模块和功能的简介。
10.1. 操作系统接口
os模块提供了访问操作系统功能的接口，如文件和目录操作、环境变量和进程管理等。
import os
# 获取当前工作目录
current_dir = os.getcwd()
print(current_dir)
# 创建目录
os.mkdir('new_directory')
# 删除目录
os.rmdir('new_directory')
10.2. 文件通配符
glob模块提供了用于匹配文件路径的通配符模式的函数。
import glob
# 获取所有以.py结尾的文件
py_files = glob.glob('*.py')
print(py_files)
10.3. 命令行参数
sys模块提供了访问命令行参数的功能。
import sys
# 打印命令行参数
for arg in sys.argv:
print(arg)
10.4. 错误输出重定向和程序终止
sys模块还提供了重定向错误输出和程序终止的功能。
import sys
# 重定向错误输出到文件
sys.stderr = open('error.log', 'w')
# 程序终止
sys.exit(1)
10.5. 字符串模式匹配
re模块提供了正则表达式的支持，用于字符串的模式匹配和替换。
import re
# 查找匹配的字符串
pattern = r'\b[A-Z]+\b'
text = 'Hello World'
matches = re.findall(pattern, text)
print(matches)
10.6. 数学
math模块提供了常见的数学函数和常量。
import math
# 计算平方根
sqrt = math.sqrt(16)
print(sqrt)
# 计算正弦值
sin = math.sin(math.radians(30))
print(sin)
10.7. 互联网访问
urllib模块提供了进行互联网访问的功能，如下载文件、发送HTTP请求等。
import urllib.request
# 下载文件
url = 'https://example.com/file.txt'
urllib.request.urlretrieve(url, 'file.txt')
10.8. 日期和时间
datetime模块提供了处理日期和时间的类和函数。
import datetime
# 获取当前日期和时间
now = datetime.datetime.now()
print(now)
# 格
式化日期和时间
formatted = now.strftime('%Y-%m-%d %H:%M:%S')
print(formatted)
10.9. 数据压缩
gzip和zipfile模块提供了对数据进行压缩和解压缩的功能。
import gzip
import zipfile
# 压缩文件
with gzip.open('file.txt.gz', 'wb') as f:
f.write(b'Hello, world!')
# 解压缩文件
with gzip.open('file.txt.gz', 'rb') as f:
content = f.read()
print(content)
10.10. 性能测量
timeit模块提供了测量代码执行时间的功能。
import timeit
# 测量代码执行时间
time = timeit.timeit('x = 1 + 2', number=1000000)
print(time)
10.11. 质量控制
unittest模块提供了编写和运行单元测试的功能。
import unittest
# 定义测试类
class MyTestCase(unittest.TestCase):
def test_addition(self):
self.assertEqual(1 + 2, 3)
# 运行单元测试
unittest.main()
10.12. 自带电池
Python标准库中还包含许多其他功能强大的模块，如collections、random、json、csv、sqlite3等。
- 标准库简介 —— 第二部分
这部分继续介绍Python标准库中的其他模块和功能。
11.1. 格式化输出
string模块提供了用于格式化输出的函数和模板。
import string
# 格式化字符串
template = string.Template('$name is $age years old')
result = template.substitute(name='Alice', age=25)
print(result)
11.2. 模板
template模块提供了一种简单但功能强大的模板替换系统。
from string import Template
# 定义模板
template = Template('$name is $age years old')
# 使用模板替换
result = template.substitute(name='Alice', age=25)
print(result)
11.3. 使用二进制数据记录格式
struct模块提供了一种处理二进制数据的方式，用于读取和写入特定格式的数据。
import struct
# 将整数打包为二进制数据
data = struct.pack('i', 42)
# 从二进制数据中解包出整数
value = struct.unpack('i', data)
print(value)
11.4. 多线程
threading模块提供了多线程编程的功能，可以在单个程序中同时运行多个线程。
import threading
# 定义线程执行的任务
def task():
print("Thread started")
# 创建线程对象
thread = threading.Thread(target=task)
# 启动线程
thread.start()
# 等待线程结束
thread.join()
11.5. 日志记录
logging
模块提供了灵活且可配置的日志记录功能，用于记录程序运行时的信息和错误。
import logging
# 配置日志记录器
logging.basicConfig(level=logging.INFO)
# 记录日志信息
logging.info("This is an info message")
11.6. 弱引用
weakref模块提供了对对象的弱引用的支持，可以避免强引用导致的循环引用问题。
import weakref
# 创建对象
obj = object()
# 创建弱引用
ref = weakref.ref(obj)
# 通过弱引用访问对象
if ref() is None:
print("Object has been garbage collected")
else:
print("Object still exists")
11.7. 用于操作列表的工具
array和deque模块提供了对列表和双端队列的高效操作。
import array
from collections import deque
# 创建数组
my_array = array.array('i', [1, 2, 3])
# 创建双端队列
my_queue = deque([1, 2, 3])
11.8. 十进制浮点运算
decimal模块提供了对十进制浮点运算的支持，可以避免浮点数运算精度问题。
from decimal import Decimal
# 进行十进制浮点运算
result = Decimal('0.1') + Decimal('0.2')
print(result) # 输出: 0.3
- 虚拟环境和包
这部分介绍了虚拟环境的概念和使用，以及如何使用pip来管理包。
12.1. 概述
虚拟环境是一种隔离Python环境的方式，可以在同一台机器上同时运行多个相互独立的Python环境。
12.2. 创建虚拟环境
可以使用venv模块创建虚拟环境。
# 创建虚拟环境
python -m venv myenv
12.3. 使用pip管理包
可以使用pip来安装、升级和卸载Python包。
# 安装包
pip install package
# 升级包
pip install --upgrade package
# 卸载包
pip uninstall package
- 接下来？
这部分可以给出进一步学习Python的建议，如学习更高级的主题、阅读相关文档和书籍等。
- 交互式编辑和编辑历史
这部分介绍了如何在交互式解释器中进行编辑和访问编辑历史。
14.1. Tab补全和编辑历史
交互式解释器支持使用Tab键进行自动补全和访问编辑历史。
14.2. 默认交互式解释器的替代品
可以使用其他替代的交互式解释
器，如IPython和Jupyter Notebook，它们提供了更丰富的功能和更好的用户体验。
- 浮点算术：争议和限制
这部分可能解释浮点数在计算机中的表示方式以及可能引起的精度问题和争议。
15.1. 表示性错误
由于浮点数的有限精度表示，可能会导致一些意外的结果，如舍入误差和比较不一致性。
- 附录
这部分可能提供一些额外的信息和资源，如Python交互模式的错误处理、可执行的Python脚本、交互式启动文件和定制模块的说明。