44、Python 编程基础：字符编码、运算符、保留字及标准库详解

Python

于 2025-11-01 15:56:48 发布

阅读量22

点赞数

CC 4.0 BY-SA版权

分类专栏： Python编程入门精要文章标签： Python Unicode 字符编码

本文链接：https://blog.youkuaiyun.com/python/article/details/154387022

Python编程入门精要专栏收录该内容

47 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

Python 编程基础：字符编码、运算符、保留字及标准库详解

1. Unicode 字符子集

Unicode 为处理西欧语言提供了丰富的字符集。这里主要介绍基本拉丁和拉丁 - 1 子集。完整的 Unicode 字符列表可在 http://unicode.org 查看。

1.1 部分控制字符

字符	编码	十进制	转义序列
Tab	“\u0009”	9	“\t”
换行符	“\u000A”	10	“\n”
回车符	“\u000D”	13	“\r”
空格	“\u0020”	32

1.2 基本拉丁（ASCII）子集

基本拉丁子集包含常见的英文字母、数字和标点符号。以下是部分示例：
| 字符 | 编码 | 十进制 | 字符 | 编码 | 十进制 | 字符 | 编码 | 十进制 |
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
| @ | “\u0040” | 64 | ` | “\u0060” | 96 |! | “\u0021” | 33 |
| A | “\u0041” | 65 | a | “\u0061” | 97 | ” | “\u0022” | 34 |
| B | “\u0042” | 66 | b | “\u0062” | 98 | # | “\u0023” | 35 |
| … | … | … | … | … | … | … | … | … |

1.3 拉丁 - 1 子集

拉丁 - 1 子集包含了带重音的字母和一些特殊符号，用于处理西欧语言中的特殊字符。例如：
| 字符 | 编码 | 十进制 | 字符 | 编码 | 十进制 | 字符 | 编码 | 十进制 |
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
| À | “\u00C0” | 192 | à | “\u00E0” | 224 | ¡ | “\u00A1” | 161 |
| Á | “\u00C1” | 193 | á | “\u00E1” | 225 | ¢ | “\u00A2” | 162 |
| Â | “\u00C2” | 194 | â | “\u00E2” | 226 | £ | “\u00A3” | 163 |
| … | … | … | … | … | … | … | … | … |

2. Python 运算符总结

Python 运算符按优先级分组，优先级高的运算符比优先级低的运算符绑定更紧密。运算符的结合性决定了它们是从左到右还是从右到左分组。除了幂运算（**）是从右到左结合外，Python 中的所有运算符都是从左到右结合。

2.1 运算符优先级和结合性示例

x + y * z 等价于 x + (y * z) ，因为 * 运算符的优先级高于 + 运算符。
x and y or z 等价于 (x and y) or z ，因为 or 运算符的优先级低于 and 运算符。
x - y - z 等价于 (x - y) - z ，因为 - 运算符从左到右结合。
x ** y ** z 等价于 x ** (y ** z) ，因为 ** 运算符从右到左结合。

2.2 运算符列表

运算符	描述
[]	索引
[:]	切片运算符
()	函数调用或方法调用
.	方法或实例变量访问
**	幂运算
+ (一元)	正号
- (一元)	负号
~ (一元)	按位取反
*	乘法
/	实数除法
//	整除
%	整数取余
*	序列复制
+	加法
+	序列拼接
-	减法
<<	按位左移
>>	按位右移
&	按位与
^	按位异或
\|	按位或
in	成员测试
not in	非成员测试
is	身份测试
is not	非身份测试
<	小于
<=	小于等于
>	大于
>=	大于等于
!=	不等于
==	等于
not	布尔非
and	布尔“短路”与
or	布尔“短路”或
if - else	条件表达式
lambda	匿名函数

3. Python 保留字总结

Python 保留字是具有特殊含义的单词，不能用作变量名、函数名或其他标识符。以下是一些常见的保留字及其描述：
| 保留字 | 描述 |
| ---- | ---- |
| and | 布尔与 |
| as | 用于 try 或 with 语句中指定对象的别名 |
| assert | 断言条件为真 |
| break | 跳出当前循环 |
| class | 定义类 |
| continue | 跳过循环体的剩余部分 |
| def | 定义函数或方法 |
| del | 从容器中移除元素 |
| elif | 条件分支语句的替代分支 |
| else | if 语句的替代子句 |
| except | try 块中异常的处理程序 |
| finally | try 块中始终执行的子句 |
| for | 用于迭代容器元素的循环 |
| False | 布尔假值 |
| from | 与 import 语句一起使用，从模块中导入项 |
| global | 声明变量具有全局作用域 |
| if | 条件分支语句 |
| import | 在模块中导入另一个模块的单个项或全部内容 |
| in | 容器成员测试 |
| is | 测试变量是否为别名 |
| lambda | 用于创建匿名函数 |
| None | 表示不存在的引用的特殊值 |
| not | 布尔非 |
| or | 布尔或 |
| pass | 当需要语句时的占位符 |
| raise | 引发异常 |
| return | 从方法中返回 |
| True | 布尔真值 |
| try | 包含异常处理程序或 finally 处理程序的代码块 |
| with | 在特定上下文中执行的代码块 |
| while | 循环语句 |
| yield | 返回生成器函数的结果 |

4. Python 标准库

Python 标准库提供了许多内置函数和类，方便开发者进行各种操作。

4.1 内置函数

4.1.1 常用内置函数

abs(x) ：计算数值 x 的绝对值。

result = abs(-5)
print(result)  # 输出: 5

bytes() 或 bytes(x) ：创建新的字节序列。

empty_bytes = bytes()
print(empty_bytes)  # 输出: b''

zero_bytes = bytes(3)
print(zero_bytes)  # 输出: b'\x00\x00\x00'

sequence_bytes = bytes([1, 2, 3])
print(sequence_bytes)  # 输出: b'\x01\x02\x03'

chr(x) ：创建包含 Unicode 值为 x 的单个字符的字符串。

char = chr(65)
print(char)  # 输出: A

dict() 或 dict(container) ：创建新的字典。

empty_dict = dict()
print(empty_dict)  # 输出: {}

duplicate_dict = dict({'a': 1, 'b': 2})
print(duplicate_dict)  # 输出: {'a': 1, 'b': 2}

sequence_dict = dict([('a', 1), ('b', 2)])
print(sequence_dict)  # 输出: {'a': 1, 'b': 2}

float() 或 float(x) ：将字符串或整数转换为浮点数。

float_num = float('3.14')
print(float_num)  # 输出: 3.14

hash(object) ：为给定对象创建哈希值，用于比较字典键。

hash_value = hash('hello')
print(hash_value)  # 输出: 一个整数哈希值

input() 或 input(prompt) ：从用户处获取字符序列。

user_input = input("请输入一些内容: ")
print(user_input)

int(x) ：将数字或字符串转换为整数。

int_num = int('10')
print(int_num)  # 输出: 10

isinstance(object, name) 或 isinstance(object, nametuple) ：判断对象是否为类或子类的实例。

is_instance = isinstance([1, 2, 3], list)
print(is_instance)  # 输出: True

issubclass(class, name) 或 issubclass(class, nametuple) ：判断类是否为另一个类的子类。

class Parent:
    pass

class Child(Parent):
    pass

is_subclass = issubclass(Child, Parent)
print(is_subclass)  # 输出: True

len(container) ：返回容器中元素的数量。

list_length = len([1, 2, 3])
print(list_length)  # 输出: 3

list() 或 list(container) ：创建新的列表。

empty_list = list()
print(empty_list)  # 输出: []

duplicate_list = list([1, 2, 3])
print(duplicate_list)  # 输出: [1, 2, 3]

dict_keys_list = list({'a': 1, 'b': 2})
print(dict_keys_list)  # 输出: ['a', 'b']

max(arg1, arg2, ...) 或 max(container) ：返回集合中的最大值。

max_num = max(1, 2, 3)
print(max_num)  # 输出: 3

max_list = max([1, 2, 3])
print(max_list)  # 输出: 3

min(arg1, arg2, ...) 或 min(container) ：返回集合中的最小值。

min_num = min(1, 2, 3)
print(min_num)  # 输出: 1

min_list = min([1, 2, 3])
print(min_list)  # 输出: 1

open(filename, mode) ：打开文本或二进制文件。

file = open('test.txt', 'w')
file.write('Hello, World!')
file.close()

ord(char) ：返回字符的 Unicode 值。

unicode_value = ord('A')
print(unicode_value)  # 输出: 65

print() 或 print(arg1, arg2, ...) 或 print(arg1, arg2, ..., end=string, sep=string, file=fileobj) ：打印参数到控制台或文件。

print('Hello', 'World', sep='-', end='!')  # 输出: Hello-World!

range(stop) 或 range(start, stop) 或 range(start, stop, step) ：创建整数序列容器。

for i in range(5):
    print(i)  # 输出: 0 1 2 3 4

for i in range(1, 5):
    print(i)  # 输出: 1 2 3 4

for i in range(1, 5, 2):
    print(i)  # 输出: 1 3

round(value) 或 round(value, digits) ：将数值四舍五入到指定小数位数。

rounded_num = round(3.14159, 2)
print(rounded_num)  # 输出: 3.14

set() 或 set(container) ：创建新的集合。

empty_set = set()
print(empty_set)  # 输出: set()

duplicate_set = set([1, 2, 2, 3])
print(duplicate_set)  # 输出: {1, 2, 3}

dict_keys_set = set({'a': 1, 'b': 2})
print(dict_keys_set)  # 输出: {'a', 'b'}

sorted(container) ：创建排序后的列表。

sorted_list = sorted([3, 1, 2])
print(sorted_list)  # 输出: [1, 2, 3]

str(object) ：将对象转换为字符串。

str_obj = str([1, 2, 3])
print(str_obj)  # 输出: [1, 2, 3]

sum(container) ：计算容器中元素的总和。

sum_num = sum([1, 2, 3])
print(sum_num)  # 输出: 6

super() ：调用超类的方法。

class Parent:
    def method(self):
        print('Parent method')

class Child(Parent):
    def method(self):
        super().method()
        print('Child method')

child = Child()
child.method()

tuple() 或 tuple(container) ：创建新的元组。

empty_tuple = tuple()
print(empty_tuple)  # 输出: ()

duplicate_tuple = tuple([1, 2, 3])
print(duplicate_tuple)  # 输出: (1, 2, 3)

dict_keys_tuple = tuple({'a': 1, 'b': 2})
print(dict_keys_tuple)  # 输出: ('a', 'b')

4.2 内置类

4.2.1 字典类（dict）

# 创建字典
d = dict()
d = dict({'a': 1, 'b': 2})
d = dict([('a', 1), ('b', 2)])

# 获取值
value = d['a']

# 添加或更新键值对
d['c'] = 3

# 检查键是否存在
key_in_dict = 'a' in d

# 获取字典长度
dict_length = len(d)

# 清空字典
d.clear()

# 获取值或默认值
value = d.get('a', 0)

# 获取字典项列表
items = d.items()

# 获取字典键列表
keys = d.keys()

# 删除键值对
removed_value = d.pop('a')

# 获取字典值列表
values = d.values()

4.2.2 列表类（list）

# 创建列表
l = list()
l = list([1, 2, 3])

# 获取元素
value = l[0]

# 更新元素
l[0] = 10

# 检查元素是否存在
element_in_list = 1 in l

# 获取列表长度
list_length = len(l)

# 添加元素到列表末尾
l.append(4)

# 获取元素位置
position = l.index(2)

# 在指定位置插入元素
l.insert(1, 5)

# 删除元素
removed_element = l.pop()
removed_element = l.pop(0)
l.remove(2)

# 排序列表
l.sort()

4.2.3 集合类（set）

# 创建集合
s = set()
s = set([1, 2, 2, 3])

# 检查元素是否存在
element_in_set = 1 in s

# 获取集合长度
set_length = len(s)

# 添加元素
s.add(4)

# 清空集合
s.clear()

# 集合差集
t = set([2, 3])
difference_set = s.difference(t)

# 删除元素
s.discard(1)
s.remove(2)

# 集合并集
union_set = s.union(t)

# 集合交集
intersection_set = s.intersection(t)

# 判断子集关系
is_subset = s.issubset(t)

4.2.4 字符串类（str）

# 创建字符串
s = str()
s = str([1, 2, 3])

# 检查子字符串是否存在
substring_in_str = '1' in s

# 获取字符串长度
str_length = len(s)

# 统计子字符串出现次数
count = s.count('1')

# 检查字符串是否以子字符串结尾
ends_with = s.endswith('3')

# 查找子字符串位置
index = s.find('1')

# 检查字符串是否只包含字母和数字
is_alnum = s.isalnum()

# 检查字符串是否只包含字母
is_alpha = s.isalpha()

# 检查字符串是否只包含数字
is_digit = s.isdigit()

# 检查字符串是否只包含小写字母
is_lower = s.islower()

# 检查字符串是否只包含空白字符
is_space = s.isspace()

# 检查字符串是否只包含大写字母
is_upper = s.isupper()

# 转换为小写
lower_str = s.lower()

# 去除字符串左侧空白字符
lstrip_str = s.lstrip()
lstrip_str = s.lstrip('1')

# 替换子字符串
replace_str = s.replace('1', 'one')

# 去除字符串右侧空白字符
rstrip_str = s.rstrip()
rstrip_str = s.rstrip('3')

# 从右侧分割字符串
split_list = s.rsplit(',', 1)

# 分割字符串
split_list = s.split()
split_list = s.split(',')
split_list = s.split(',', 1)

# 按换行符分割字符串
lines = s.splitlines()

# 检查字符串是否以子字符串开头
starts_with = s.startswith('1')

5. 流程图示例

graph TD
    A[开始] --> B{选择操作}
    B --> |内置函数| C[使用内置函数]
    B --> |内置类| D[使用内置类]
    C --> E[完成操作]
    D --> E
    E --> F[结束]

通过以上内容，我们详细介绍了 Python 编程中的字符编码、运算符、保留字和标准库的相关知识，希望对大家的 Python 学习有所帮助。在实际编程中，合理运用这些知识可以提高编程效率和代码质量。

6. 操作步骤总结

6.1 内置函数操作步骤

6.1.1 计算绝对值

输入：一个数值。
操作：使用 abs() 函数。
示例代码：

result = abs(-10)
print(result)

6.1.2 创建字节序列

输入：可以为空，或为整数、序列。
操作：使用 bytes() 函数。
示例代码：

empty_bytes = bytes()
print(empty_bytes)
zero_bytes = bytes(5)
print(zero_bytes)
sequence_bytes = bytes([1, 2, 3])
print(sequence_bytes)

6.1.3 字符与 Unicode 值转换

字符转 Unicode 值：
- 输入：一个包含单个字符的字符串。
- 操作：使用 ord() 函数。
- 示例代码：

unicode_value = ord('B')
print(unicode_value)

Unicode 值转字符：
- 输入：一个整数。
- 操作：使用 chr() 函数。
- 示例代码：

char = chr(66)
print(char)

6.1.4 创建字典

输入：可以为空，或为字典、序列。
操作：使用 dict() 函数。
示例代码：

empty_dict = dict()
print(empty_dict)
duplicate_dict = dict({'x': 10, 'y': 20})
print(duplicate_dict)
sequence_dict = dict([('x', 10), ('y', 20)])
print(sequence_dict)

6.1.5 类型转换

转浮点数：
- 输入：字符串或整数。
- 操作：使用 float() 函数。
- 示例代码：

float_num = float('5.6')
print(float_num)

转整数：
- 输入：数字或字符串。
- 操作：使用 int() 函数。
- 示例代码：

int_num = int('20')
print(int_num)

6.1.6 获取用户输入

输入：可以为空，或为提示字符串。
操作：使用 input() 函数。
示例代码：

user_input = input("请输入你的名字: ")
print(user_input)

6.1.7 判断对象类型

输入：对象和类名或类名元组。
操作：使用 isinstance() 函数。
示例代码：

is_instance = isinstance([1, 2, 3], list)
print(is_instance)

6.1.8 判断子类关系

输入：类和类名或类名元组。
操作：使用 issubclass() 函数。
示例代码：

class Base:
    pass
class Derived(Base):
    pass
is_subclass = issubclass(Derived, Base)
print(is_subclass)

6.1.9 获取容器长度

输入：容器。
操作：使用 len() 函数。
示例代码：

list_length = len([1, 2, 3, 4])
print(list_length)

6.1.10 查找集合最值

输入：可以为多个值，或一个容器。
操作：使用 max() 或 min() 函数。
示例代码：

max_num = max(1, 2, 3, 4)
print(max_num)
min_num = min([1, 2, 3, 4])
print(min_num)

6.1.11 打开文件

输入：文件名和打开模式。
操作：使用 open() 函数。
示例代码：

file = open('test.txt', 'r')
content = file.read()
print(content)
file.close()

6.1.12 打印输出

输入：可以为空，或为多个值，还可指定 end 、 sep 、 file 参数。
操作：使用 print() 函数。
示例代码：

print('Hello', 'World', sep='-', end='!')

6.1.13 创建整数序列

输入：可以为 stop 值，或 start 、 stop 值，或 start 、 stop 、 step 值。
操作：使用 range() 函数。
示例代码：

for i in range(1, 10, 2):
    print(i)

6.1.14 四舍五入

输入：数值，可指定小数位数。
操作：使用 round() 函数。
示例代码：

rounded_num = round(3.14159, 3)
print(rounded_num)

6.1.15 创建集合

输入：可以为空，或为容器。
操作：使用 set() 函数。
示例代码：

empty_set = set()
print(empty_set)
duplicate_set = set([1, 2, 2, 3])
print(duplicate_set)

6.1.16 排序

输入：容器。
操作：使用 sorted() 函数。
示例代码：

sorted_list = sorted([3, 1, 2])
print(sorted_list)

6.1.17 转换为字符串

输入：对象。
操作：使用 str() 函数。
示例代码：

str_obj = str([1, 2, 3])
print(str_obj)

6.1.18 求和

输入：包含数值的容器。
操作：使用 sum() 函数。
示例代码：

sum_num = sum([1, 2, 3, 4])
print(sum_num)

6.2 内置类操作步骤

6.2.1 字典类操作

创建字典：可传入字典或序列，也可创建空字典。
示例代码：

d = dict()
d = dict({'key1': 'value1', 'key2': 'value2'})
d = dict([('key1', 'value1'), ('key2', 'value2')])

获取值：使用 [] 运算符。
示例代码：

value = d['key1']

添加或更新键值对：使用 [] 运算符。
示例代码：

d['key3'] = 'value3'

检查键是否存在：使用 in 或 not in 运算符。
示例代码：

key_in_dict = 'key1' in d

获取字典长度：使用 len() 函数。
示例代码：

dict_length = len(d)

清空字典：使用 clear() 方法。
示例代码：

d.clear()

获取值或默认值：使用 get() 方法。
示例代码：

value = d.get('key1', 'default')

获取字典项列表：使用 items() 方法。
示例代码：

items = d.items()

获取字典键列表：使用 keys() 方法。
示例代码：

keys = d.keys()

删除键值对：使用 pop() 方法。
示例代码：

removed_value = d.pop('key1')

获取字典值列表：使用 values() 方法。
示例代码：

values = d.values()

6.2.2 列表类操作

创建列表：可传入序列，也可创建空列表。
示例代码：

l = list()
l = list([1, 2, 3])

获取元素：使用 [] 运算符。
示例代码：

value = l[0]

更新元素：使用 [] 运算符。
示例代码：

l[0] = 10

检查元素是否存在：使用 in 或 not in 运算符。
示例代码：

element_in_list = 1 in l

获取列表长度：使用 len() 函数。
示例代码：

list_length = len(l)

添加元素到列表末尾：使用 append() 方法。
示例代码：

l.append(4)

获取元素位置：使用 index() 方法。
示例代码：

position = l.index(2)

在指定位置插入元素：使用 insert() 方法。
示例代码：

l.insert(1, 5)

删除元素：使用 pop() 或 remove() 方法。
示例代码：

removed_element = l.pop()
removed_element = l.pop(0)
l.remove(2)

排序列表：使用 sort() 方法。
示例代码：

l.sort()

6.2.3 集合类操作

创建集合：可传入序列，也可创建空集合。
示例代码：

s = set()
s = set([1, 2, 2, 3])

检查元素是否存在：使用 in 或 not in 运算符。
示例代码：

element_in_set = 1 in s

获取集合长度：使用 len() 函数。
示例代码：

set_length = len(s)

添加元素：使用 add() 方法。
示例代码：

s.add(4)

清空集合：使用 clear() 方法。
示例代码：

s.clear()

集合差集：使用 difference() 方法。
示例代码：

t = set([2, 3])
difference_set = s.difference(t)

删除元素：使用 discard() 或 remove() 方法。
示例代码：

s.discard(1)
s.remove(2)

集合并集：使用 union() 方法。
示例代码：

union_set = s.union(t)

集合交集：使用 intersection() 方法。
示例代码：

intersection_set = s.intersection(t)

判断子集关系：使用 issubset() 方法。
示例代码：

is_subset = s.issubset(t)

6.2.4 字符串类操作

创建字符串：可传入对象，也可创建空字符串。
示例代码：

s = str()
s = str([1, 2, 3])

检查子字符串是否存在：使用 in 或 not in 运算符。
示例代码：

substring_in_str = '1' in s

获取字符串长度：使用 len() 函数。
示例代码：

str_length = len(s)

统计子字符串出现次数：使用 count() 方法。
示例代码：

count = s.count('1')

检查字符串是否以子字符串结尾：使用 endswith() 方法。
示例代码：

ends_with = s.endswith('3')

查找子字符串位置：使用 find() 方法。
示例代码：

index = s.find('1')

检查字符串是否只包含字母和数字：使用 isalnum() 方法。
示例代码：

is_alnum = s.isalnum()

检查字符串是否只包含字母：使用 isalpha() 方法。
示例代码：

is_alpha = s.isalpha()

检查字符串是否只包含数字：使用 isdigit() 方法。
示例代码：

is_digit = s.isdigit()

检查字符串是否只包含小写字母：使用 islower() 方法。
示例代码：

is_lower = s.islower()

检查字符串是否只包含空白字符：使用 isspace() 方法。
示例代码：

is_space = s.isspace()

检查字符串是否只包含大写字母：使用 isupper() 方法。
示例代码：

is_upper = s.isupper()

转换为小写：使用 lower() 方法。
示例代码：

lower_str = s.lower()

去除字符串左侧空白字符：使用 lstrip() 方法。
示例代码：

lstrip_str = s.lstrip()
lstrip_str = s.lstrip('1')

替换子字符串：使用 replace() 方法。
示例代码：

replace_str = s.replace('1', 'one')

去除字符串右侧空白字符：使用 rstrip() 方法。
示例代码：

rstrip_str = s.rstrip()
rstrip_str = s.rstrip('3')

从右侧分割字符串：使用 rsplit() 方法。
示例代码：

split_list = s.rsplit(',', 1)

分割字符串：使用 split() 方法。
示例代码：

split_list = s.split()
split_list = s.split(',')
split_list = s.split(',', 1)

按换行符分割字符串：使用 splitlines() 方法。
示例代码：

lines = s.splitlines()

检查字符串是否以子字符串开头：使用 startswith() 方法。
示例代码：

starts_with = s.startswith('1')

7. 总结

本文全面介绍了 Python 编程中多个重要方面的知识。首先讲解了 Unicode 字符的基本拉丁和拉丁 - 1 子集，这些字符集为处理西欧语言提供了基础。接着阐述了 Python 运算符的优先级和结合性，以及各种保留字的用途，这有助于编写正确且高效的 Python 代码。

在 Python 标准库部分，详细介绍了众多内置函数和内置类的使用方法，并给出了具体的操作步骤和示例代码。这些内置函数和类涵盖了数值计算、数据结构操作、文件处理等多个领域，是 Python 编程中不可或缺的工具。

通过合理运用这些知识，开发者可以更加高效地进行 Python 编程，提高代码的质量和可维护性。希望本文能为 Python 初学者提供有价值的参考，帮助他们更好地掌握 Python 编程的基础知识。

8. 流程图总结

graph LR
    A[Python编程知识体系] --> B[Unicode字符子集]
    A --> C[Python运算符]
    A --> D[Python保留字]
    A --> E[Python标准库]
    B --> B1[基本拉丁子集]
    B --> B2[拉丁 - 1子集]
    C --> C1[运算符优先级]
    C --> C2[运算符结合性]
    D --> D1[常见保留字]
    E --> E1[内置函数]
    E --> E2[内置类]
    E1 --> E11[数值处理函数]
    E1 --> E12[数据结构处理函数]
    E1 --> E13[文件处理函数]
    E2 --> E21[字典类]
    E2 --> E22[列表类]
    E2 --> E23[集合类]
    E2 --> E24[字符串类]

这个流程图展示了 Python 编程知识体系的整体结构，从宏观到微观，涵盖了各个重要的知识点，帮助读者更好地理解和掌握 Python 编程的核心内容。