目录
一、列表：
在Python中，序列是一种基础且强大的数据结构，用于存储有序的数据集合 。
（1）Python3 列表：
-
序列的基本概念：
- 序列是Python中用于存储有序数据集合的内置数据类型。
- 每个数据项在序列中都有一个唯一的索引，索引从0开始。
-
Python中的序列类型：
- Python有6种序列类型的内置类型，包括列表（list）、元组（tuple）、字符串（str）、字节（bytes）、字节数组（bytearray）和内存视图（memoryview）。
- 最常用的序列类型是列表和元组。
-
列表（list）的特点：
- 列表是可变的，意味着可以在列表中添加、删除或更改元素。
- 列表可以存储不同类型的数据项。
- 列表使用方括号
[]定义，数据项之间用逗号,分隔。
-
列表的操作：
- 索引：通过指定索引值可以访问列表中的单个元素。
- 切片：可以通过切片操作获取列表的一部分。
- 加法：可以使用
+运算符将两个列表连接起来。 - 乘法：可以使用
*运算符重复列表多次。 - 成员检查：可以使用
in关键字检查某个元素是否存在于列表中。
-
内置方法和函数：
len()：返回序列的长度。max()：返回序列中的最大元素。min()：返回序列中的最小元素。
-
列表的创建：
- 创建列表时，只需将不同的数据项用逗号分隔，并用方括号括起来。
-
列表的灵活性：
- 列表的灵活性体现在可以存储不同类型的数据，并且可以随时修改。
-
列表的应用：
- 列表因其灵活性和强大的内置方法，成为Python中使用最广泛的数据类型之一，适用于各种数据处理任务。
（2） 访问列表中的值：
- 在Python中，访问列表中的值通常通过索引来实现。列表的索引从0开始，这意味着列表中第一个元素的索引是0，第二个元素的索引是1，以此类推。
-
基本索引：
# 创建一个列表
my_list = ['apple', 'banana', 'cherry']
# 访问第一个元素
first_item = my_list[0]
print(first_item) # 输出: apple
# 访问第二个元素
second_item = my_list[1]
print(second_item) # 输出: banana-
负数索引：
- Python也支持负数索引，这允许从列表的末尾开始计数。索引-1表示列表的最后一个元素，索引-2表示倒数第二个元素，依此类推。
# 访问最后一个元素
last_item = my_list[-1]
print(last_item) # 输出: cherry
# 访问倒数第二个元素
second_last_item = my_list[-2]
print(second_last_item) # 输出: banana-
切片：
- 切片是访问列表中一系列元素的一种方式。可以使用切片操作符
:来获取列表的一部分。
# 获取从第一个元素到第二个元素的切片（不包括索引2的元素）
slice = my_list[0:2]
print(slice) # 输出: ['apple', 'banana']
# 获取从第二个元素到列表末尾的切片
slice = my_list[1:]
print(slice) # 输出: ['banana', 'cherry']
# 获取从第一个元素到列表末尾的切片
slice = my_list[:2]
print(slice) # 输出: ['apple', 'banana']-
遍历列表：
- 如果想访问列表中的每个元素，可以使用
for循环遍历列表。
# 遍历列表并打印每个元素
for item in my_list:
print(item)-
访问列表长度：
- 要获取列表中元素的数量，可以使用内置的
len()函数。
# 获取列表长度
length = len(my_list)
print(length) # 输出: 3（3）列表更新：
在Python中，列表是可变的数据结构，这意味着你可以在列表中添加、删除或更改元素。
a.修改列表中的元素：
- 可以通过索引直接修改列表中的特定元素：
# 创建一个列表
my_list = ['a', 'b', 'c', 'd']
# 修改第二个元素
my_list[1] = 'B'
print(my_list) # 输出: ['a', 'B', 'c', 'd']b.使用 append() 方法添加元素：
append()方法用于在列表的末尾添加一个新元素：
# 创建一个列表
my_list = ['a', 'b', 'c']
# 使用 append() 方法添加一个新元素
my_list.append('d')
print(my_list) # 输出: ['a', 'b', 'c', 'd']c.使用 extend() 方法添加多个元素：
extend()方法用于将一个列表中的所有元素添加到另一个列表的末尾：
# 创建两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 extend() 方法将 list2 的元素添加到 list1
list1.extend(list2)
print(list1) # 输出: [1, 2, 3, 4, 5, 6]d.使用 insert() 方法插入元素：
insert()方法允许在列表的指定位置插入一个新元素：
# 创建一个列表
my_list = ['a', 'b', 'd']
# 在索引 2 的位置插入元素 'c'
my_list.insert(2, 'c')
print(my_list) # 输出: ['a', 'b', 'c', 'd']e.使用 remove() 方法删除元素：
remove()方法用于删除列表中的第一个匹配元素：
# 创建一个列表
my_list = ['a', 'b', 'c', 'd']
# 删除元素 'b'
my_list.remove('b')
print(my_list) # 输出: ['a', 'c', 'd']f.使用 pop() 方法删除并返回元素：
pop()方法用于删除列表中的指定位置的元素，并返回该元素的值：
# 创建一个列表
my_list = ['a', 'b', 'c', 'd']
# 删除并返回索引 2 的元素
removed_item = my_list.pop(2)
print(removed_item) # 输出: 'c'
print(my_list) # 输出: ['a', 'b', 'd']g.如果不指定索引，pop() 默认删除并返回列表的最后一个元素：
clear()方法用于清空列表中的所有元素：
# 创建一个列表
my_list = ['a', 'b', 'c', 'd']
# 清空列表
my_list.clear()
print(my_list) # 输出: []h.使用 index() 方法查找元素索引：
index()方法用于查找某个元素在列表中首次出现的索引：
# 创建一个列表
my_list = ['a', 'b', 'c', 'd']
# 查找元素 'b' 的索引
index = my_list.index('b')
print(index) # 输出: 1（4）列表元素删除：
在Python中，有多种方法可以删除列表中的元素。
a.使用 del 语句：
del语句可以用来删除列表中的特定元素或切片。
my_list = ['a', 'b', 'c', 'd']
# 删除第三个元素（值 'c'）
del my_list[2]
print(my_list) # 输出: ['a', 'b', 'd']
# 删除从索引 1 开始的两个元素
del my_list[1:3]
print(my_list) # 输出: ['a']b.使用 pop() 方法：
pop()方法用于删除列表中的一个元素，并返回该元素的值。如果不传递任何参数，它默认删除并返回列表的最后一个元素。
my_list = ['a', 'b', 'c', 'd']
# 删除并返回最后一个元素
removed_item = my_list.pop()
print(removed_item) # 输出: 'd'
print(my_list) # 输出: ['a', 'b', 'c']
# 指定索引来删除并返回特定元素
removed_item = my_list.pop(1)
print(removed_item) # 输出: 'b'
print(my_list) # 输出: ['a', 'c']c.使用 remove() 方法：
remove()方法用于删除列表中第一个匹配的元素。
my_list = ['a', 'b', 'c', 'd']
# 删除第一个匹配的元素 'b'
my_list.remove('b')
print(my_list) # 输出: ['a', 'c', 'd']- 如果元素在列表中不存在，
remove()方法会抛出一个ValueError。
d.使用 clear() 方法:
clear()方法用于清空整个列表，即删除列表中的所有元素。
my_list = ['a', 'b', 'c', 'd']
# 清空列表
my_list.clear()
print(my_list) # 输出: []注意事项:
- 删除操作会改变列表的长度和内容，因此在遍历列表时进行删除操作可能会导致意外的行为。
- 如果在删除元素时使用索引，需要确保索引不会越界，否则会抛出
IndexError。 remove()方法和pop()方法在元素不存在时的行为不同：remove()会抛出错误，而pop()在没有指定索引时会默认删除最后一个元素。
（5）列表脚本操作符 ：
在Python中，列表（list）是一种非常灵活的数据结构，支持多种脚本操作符，这些操作符可以用来执行常见的操作，如连接、重复、成员检查等。
a. 连接操作符 +:
- 用于将两个或多个列表连接成一个新列表。
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list) # 输出: [1, 2, 3, 4, 5, 6]b. 重复操作符 *:
- 用于将列表重复多次，创建一个新列表。
list1 = [1, 2, 3]
repeated_list = list1 * 3
print(repeated_list) # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]c. 成员检查操作符 in 和 not in:
- 用于检查列表中是否存在某个元素。
list1 = [1, 2, 3]
print(1 in list1) # 输出: True
print(4 in list1) # 输出: False
print(4 not in list1) # 输出: Trued. 长度操作符 len():
- 用于获取列表的长度，即元素的数量。
list1 = [1, 2, 3]
print(len(list1)) # 输出: 3e. 大小比较操作符:
- 列表支持比较操作符，如
>,<,>=,<=,==, 和!=，用于比较列表的大小。
list1 = [1, 2, 3]
list2 = [1, 2, 3, 4]
print(list1 < list2) # 输出: True
print(list1 == list2) # 输出: Falsef. 索引操作符 []:
- 用于访问列表中的元素或切片。
list1 = ['a', 'b', 'c', 'd']
print(list1[0]) # 输出: 'a'
print(list1[1:3]) # 输出: ['b', 'c']g. 列表推导式:
- 虽然不是传统意义上的操作符，但列表推导式提供了一种优雅的方式来创建或修改列表。
list1 = [1, 2, 3, 4, 5]
squared_list = [x**2 for x in list1]
print(squared_list) # 输出: [1, 4, 9, 16, 25]（6）列表截取与拼接：
在Python中，列表的截取与拼接是两种常用的操作，它们允许你创建新的列表或修改现有的列表。
a.列表截取（Slicing）:
- 列表截取是指从现有列表中提取一部分元素，形成一个新的列表。这可以通过切片操作来实现，切片操作使用方括号
[]并指定起始索引和结束索引。
# 创建一个列表
my_list = ['a', 'b', 'c', 'd', 'e']
# 截取从索引1到索引3的元素（不包括索引3的元素）
sublist = my_list[1:3]
print(sublist) # 输出: ['b', 'c']
# 截取从索引2开始到列表末尾的所有元素
sublist = my_list[2:]
print(sublist) # 输出: ['c', 'd', 'e']
# 截取从列表开始到索引2之前的所有元素
sublist = my_list[:2]
print(sublist) # 输出: ['a', 'b']
# 截取整个列表
sublist = my_list[:]
print(sublist) # 输出: ['a', 'b', 'c', 'd', 'e']
# 使用负数索引截取
sublist = my_list[-3:-1]
print(sublist) # 输出: ['c', 'd']b.列表拼接（Concatenation）:
- 列表拼接是指将两个或多个列表连接起来，形成一个新的列表。这可以通过使用加号
+操作符来实现。
# 创建两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 拼接列表
combined_list = list1 + list2
print(combined_list) # 输出: [1, 2, 3, 4, 5, 6]c.扩展列表（Extending）：
- 除了拼接两个列表并创建一个新列表外，还可以使用
extend()方法将一个列表中的所有元素添加到另一个列表的末尾。
# 创建两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用 extend() 方法扩展 list1
list1.extend(list2)
print(list1) # 输出: [1, 2, 3, 4, 5, 6]- 注意，
extend()方法会修改原始列表，而不是创建一个新的列表。
d.列表重复（Repetition）：
- 使用星号
*操作符，你可以重复整个列表多次。
# 创建一个列表
my_list = ['a', 'b']
# 重复列表两次
repeated_list = my_list * 2
print(repeated_list) # 输出: ['a', 'b', 'a', 'b']（7）嵌套列表：
嵌套列表是包含其他列表的列表，它们可以用来创建多维数组或表格数据结构。嵌套列表在Python中非常灵活，可以用于表示矩阵、执行复杂的数据操作，或者仅仅是存储具有层次结构的数据。
a.创建嵌套列表：
# 创建一个嵌套列表，代表一个 2x3 的矩阵
nested_list = [[1, 2, 3], [4, 5, 6]]
# 创建一个嵌套列表，包含不同长度的子列表
nested_list_mixed = ['a', ['b', 'c'], ['d', 'e', 'f']]b.访问嵌套列表中的元素：
# 访问嵌套列表的第一个子列表
print(nested_list[0]) # 输出: [1, 2, 3]
# 访问嵌套列表的第二个子列表的第二个元素
print(nested_list[1][1]) # 输出: 5
# 访问嵌套列表的第三个元素的第一个字符
print(nested_list_mixed[2][0]) # 输出: 'd'c.修改嵌套列表中的元素：
# 修改嵌套列表中的元素
nested_list[0][1] = 20
print(nested_list) # 输出: [[1, 20, 3], [4, 5, 6]]d.遍历嵌套列表：
# 使用两层循环遍历嵌套列表
for row in nested_list:
for element in row:
print(element, end=' ')
print() # 换行e.列表推导式与嵌套列表：
- 列表推导式也可以用于嵌套列表，创建更复杂的结构。
# 创建一个嵌套列表，包含子列表的平方
squared_nested_list = [[x**2 for x in row] for row in nested_list]
print(squared_nested_list) # 输出: [[1, 400, 9], [16, 25, 36]]f.扩展嵌套列表：
# 向嵌套列表添加新的子列表
nested_list.append([7, 8, 9])
print(nested_list) # 输出: [[1, 20, 3], [4, 5, 6], [7, 8, 9]]d.删除嵌套列表中的元素：
# 删除嵌套列表中的特定子列表
del nested_list[0]
print(nested_list) # 输出: [[4, 5, 6], [7, 8, 9]]（8）列表之间比较：
在Python中，列表之间的比较是基于元素的顺序进行的。你可以使用标准的比较运算符（如 ==, !=, <, >, <=, >=）来比较两个列表。
a.列表比较规则：
- 相等性比较 (
==和!=):- 列表中的所有元素都相同，并且元素的顺序也相同，那么这两个列表被认为是相等的。
- 如果任何一个元素不相同，或者元素的顺序不同，那么这两个列表是不相等的。
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [3, 2, 1]
print(list1 == list2) # 输出: True
print(list1 == list3) # 输出: False
print(list1 != list3) # 输出: True- 大小比较 (
<,>,<=,>=):- 列表的比较是基于字典顺序进行的，这意味着Python会依次比较列表中的每个元素。
- 如果在比较过程中发现某个元素不同，比较将根据这两个元素的大小关系决定整个列表的大小关系。
- 如果所有对应元素都相等，那么较短的列表被视为较小。
list1 = [1, 2, 3]
list2 = [1, 2, 4]
list3 = [1, 2, 3, 4]
print(list1 < list2) # 输出: True
print(list2 > list1) # 输出: True
print(list1 <= list3) # 输出: True
print(list3 >= list2) # 输出: True注意事项:
- 列表比较是基于元素的顺序和大小，而不是基于它们在内存中的物理位置。
- 列表比较是递归的，也就是说，如果列表中包含其他列表，那么嵌套的列表也会被比较。
- 尝试比较不同长度的列表时，Python会从左到右依次比较每个位置的元素，直到找到不同的元素或到达较短列表的末尾。
- 如果列表中包含不可比较的类型（如列表、字典等），则比较可能会抛出
TypeError。
（9）列表函数使用方法：
Python列表（list）提供了多种内置方法来执行常见的操作。
-
append(x)：在列表末尾添加一个元素x。 -
extend(iterable)：将一个可迭代对象（如另一个列表、元组、字符串等）的所有元素添加到列表末尾。 -
insert(i, x)：在指定位置i插入一个元素x。 -
remove(x)：移除列表中第一个值为x的元素。 -
pop([i])：删除列表中指定位置i的元素，并返回该元素。如果不指定位置，默认删除并返回最后一个元素。 -
clear()：清空列表中的所有元素。 -
copy()：返回列表的浅拷贝。 -
sort(key=None, reverse=False)：对列表进行原地排序。key参数指定一个函数，用于在比较元素前先对元素进行转换。reverse参数控制排序顺序。 -
sorted(iterable, key=None, reverse=False)：返回一个新的列表，内容是通过对iterable进行排序得到的。不会更改原列表。 -
index(x[, start[, end]])：返回列表中第一个值为x的元素的索引。可以指定开始和结束位置进行搜索。 -
count(x)：返回列表中值为x的元素出现的次数。 -
reverse()：原地反转列表中的元素。 -
len(list)：返回列表的长度。 -
max(list)：返回列表中的最大值。 -
min(list)：返回列表中的最小值。 -
sum(list)：返回列表中所有元素的和。
二、元组：
在Python 3中，元组（tuple）是一种不可变的序列类型，用于存储不同类型的元素。一旦创建了元组，你就不能更改、添加或删除其中的元素。元组在Python中用于确保数据的安全性（即数据不会被改变），以及作为字典键等场景。
（1）创建元组：
- 元组是由逗号分隔的值序列，可以使用圆括号
()来创建，也可以省略括号。
# 使用圆括号创建元组
my_tuple = (1, 2, 3, 'a', 'b')
# 省略圆括号
my_tuple = 1, 2, 3, 'a', 'b'
# 创建单元素元组（需要在元素后加逗号）
single_element_tuple = (1,)（2）访问元组元素：
- 访问元组中的元素与列表类似，使用索引操作。
# 访问第一个元素
print(my_tuple[0]) # 输出: 1
# 访问最后一个元素
print(my_tuple[-1]) # 输出: 'b'（3）元组切片：
- 元组支持切片操作，可以用于获取元组的一部分。
# 获取元组的一部分
print(my_tuple[1:3]) # 输出: (2, 3)（4）元组拼接：
- 虽然不能直接修改元组，但可以通过拼接来创建一个新的元组。
# 拼接两个元组
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple) # 输出: (1, 2, 3, 4, 5, 6)（5）元组重复：
- 可以使用
*操作符来重复元组。
# 重复元组
repeated_tuple = (1, 2) * 3
print(repeated_tuple) # 输出: (1, 2, 1, 2, 1, 2)（7）元组内置函数：
len(tuple)：返回元组的长度。max(tuple)：返回元组中的最大值。min(tuple)：返回元组中的最小值。tuple(iterable)：将可迭代对象转换为元组。
（8）元组比较：
- 元组支持比较操作符，比较是基于元组中元素的顺序和值。
tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
print(tuple1 < tuple2) # 输出: True（9）注意事项
- 元组是不可变的，尝试修改元组的操作（如
my_tuple[0] = 2）会导致错误。 - 元组可以作为字典的键，因为它们是不可变的。
- 元组可以嵌套，即元组中可以包含其他元组。
三、字典：
在Python 3中，字典（dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是可变的，这意味着可以在创建后修改它们，比如添加、修改或删除键值对。字典在Python中用花括号 {} 定义，或者使用 dict() 函数创建。
（1）创建字典：
# 使用花括号创建字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
# 使用 dict() 函数创建字典
my_dict = dict(name='John', age=30, city='New York')（2）访问字典中的值：
- 可以通过键来访问字典中的值。
# 访问键 'name' 对应的值
print(my_dict['name']) # 输出: John（3）修改字典：
- 可以修改字典中的值，也可以添加新的键值对。
# 修改键 'age' 对应的值
my_dict['age'] = 31
# 添加新的键值对
my_dict['country'] = 'USA'（4）删除字典中的元素：
- 可以使用
del语句或pop()方法来删除字典中的元素。
# 使用 del 语句删除键 'city'
del my_dict['city']
# 使用 pop() 方法删除键 'name' 并返回其值
name = my_dict.pop('name')（5）遍历字典：
- 可以遍历字典的键、值或键值对。
# 遍历字典的键
for key in my_dict:
print(key)
# 遍历字典的值
for value in my_dict.values():
print(value)
# 遍历字典的键值对
for key, value in my_dict.items():
print(key, value)（6）字典的常用方法：
len(dict)：返回字典中键值对的数量。dict[key]：返回指定键的值。dict.get(key, default=None)：返回指定键的值，如果键不存在，则返回默认值。dict.keys()：返回一个包含字典所有键的视图。dict.values()：返回一个包含字典所有值的视图。dict.items()：返回一个包含字典所有键值对的视图。dict.update(other)：将另一个字典的键值对更新到当前字典中。dict.clear()：清空字典中的所有内容。
（7）字典推导式：
- 字典推导式是创建字典的一种简洁方式。
# 创建一个新字典，其中包含原字典键的平方
squared_dict = {key: value**2 for key, value in my_dict.items() if isinstance(value, int)}（8）注意事项：
- 字典的键必须是不可变类型，如字符串、数字或元组。
- 字典的键是唯一的，不能有重复的键。
- 字典是无序的，直到Python 3.7版，字典保持插入顺序。从Python 3.7开始，字典是有序的，并且顺序是按照插入的顺序。
四、集合：
在Python 3中，集合（set）是一个无序的、不包含重复元素的集合数据类型。它支持数学上的集合操作，如并集、交集、差集和对称差分。集合由花括号 {} 定义，或者使用 set() 函数创建。
（1）创建集合：
# 使用花括号创建空集合
my_set = set()
# 使用花括号创建包含元素的集合
my_set = {1, 2, 3}
# 使用 set() 函数创建集合
my_set = set([1, 2, 3])（2）添加元素：
- 使用
add()方法向集合中添加元素。
my_set = {1, 2, 3}
my_set.add(4)
print(my_set) # 输出: {1, 2, 3, 4}（3）删除元素：
- 使用
remove()或discard()方法从集合中删除元素。remove()方法在元素不存在时会抛出错误，而discard()不会。
my_set = {1, 2, 3}
my_set.remove(2)
print(my_set) # 输出: {1, 3}
my_set.discard(3)
print(my_set) # 输出: {1}（4）清空集合：
- 使用
clear()方法清空集合中的所有元素。
my_set = {1, 2, 3}
my_set.clear()
print(my_set) # 输出: set()（5）集合运算：
- Python的集合支持多种集合运算。
- 并集：使用
union()方法或|运算符。 - 交集：使用
intersection()方法或&运算符。 - 差集：使用
difference()方法或-运算符。 - 对称差分：使用
symmetric_difference()方法或^运算符。
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 并集
print(set1 | set2) # 输出: {1, 2, 3, 4, 5}
# 交集
print(set1 & set2) # 输出: {3}
# 差集
print(set1 - set2) # 输出: {1, 2}
# 对称差分
print(set1 ^ set2) # 输出: {1, 2, 4, 5}（6）检查成员资格：
- 使用
in关键字检查元素是否在集合中。
my_set = {1, 2, 3}
print(2 in my_set) # 输出: True
print(4 in my_set) # 输出: False（7）遍历集合：
- 集合是可迭代的，可以使用循环遍历集合中的元素。
my_set = {1, 2, 3}
for element in my_set:
print(element)（8）注意事项：
- 集合中的元素必须是可哈希的，因为集合实际上使用哈希表来存储元素。
- 由于集合是无序的，所以不能索引或切片。
- 集合是不可重复的，添加重复的元素不会有任何效果。
五、 条件控制：
在Python 3中，条件控制语句允许你根据不同的条件执行不同的代码块。主要的条件控制语句包括 if、elif（else if的缩写）、else 和 pass。
（1）if 语句：
if语句用于测试一个条件，如果条件为真（True），则执行if块内的代码。
x = 10
if x > 5:
print("x is greater than 5")（2）elif 语句：
elif语句用于在多个条件之间进行选择。它必须跟在if语句后面，可以有多个elif语句，直到找到第一个为真的条件。
x = 10
if x > 15:
print("x is greater than 15")
elif x > 10:
print("x is greater than 10")
elif x > 5:
print("x is greater than 5")
else:
print("x is less than or equal to 5")（3）else 语句：
else语句用于当所有if和elif条件都不为真时执行。它必须跟在if或elif语句后面。
（4）pass 语句：
pass是一个空操作，当语法上需要一个语句但程序逻辑不需要执行任何操作时，可以使用pass。
if x < 0:
pass # 这里不执行任何操作（5）嵌套条件：
- 可以在
if、elif或else块中嵌套更多的条件语句。
x = 10
y = 5
if x > 5:
if y > 5:
print("Both x and y are greater than 5")
else:
print("x is greater than 5, but y is not")
else:
print("x is less than or equal to 5")（6）条件表达式（三元运算符）：
Python 也支持条件表达式，它允许你在一行内执行条件判断，类似于其他语言中的三元运算符。
x = 10
result = "x is positive" if x > 0 else "x is non-positive"
print(result)（7）match...case语句：
在Python 3.10及以上版本中，引入了新的结构化模式匹配语法，称为“结构化模式匹配”（Structural Pattern Matching），它允许使用 match 和 case 语句来替代复杂的 if-elif-else 链。这种新的语法受到了其他语言（如Haskell的case表达式和Erlang的模式匹配）的启发。
a.基本语法:
value = ...
match value:
case pattern1:
# 代码块1
case pattern2:
# 代码块2
case _:
# 默认代码块match：开始一个模式匹配语句。case：定义一个模式，如果与match表达式的值匹配，则执行该代码块。pattern：一个模式，可以是具体的值、变量名、类型、序列、表达式等。_：表示一个捕获所有情况的通配符，类似于else。
b.示例:
def check_value(x):
match x:
case 1:
print("x is 1")
case 2:
print("x is 2")
case _:
print("x is something else")
check_value(1) # 输出: x is 1
check_value(2) # 输出: x is 2
check_value(3) # 输出: x is something elsec.模式匹配:
- 模式匹配不仅仅是比较值，它还可以解构数据结构，比如元组、列表和字典：
def process_point(p):
match p:
case (0, 0):
print("Origin")
case (0, y):
print(f"On the y-axis at {y}")
case (x, 0):
print(f"On the x-axis at {x}")
case (x, y):
print(f"At ({x}, {y})")
process_point((3, 4)) # 输出: At (3, 4)
process_point((0, 5)) # 输出: On the y-axis at 5
process_point((5, 0)) # 输出: On the x-axis at 5
process_point((0, 0)) # 输出: Origind.类型匹配:
还可以根据类型进行匹配：
def process_value(v):
match v:
case str():
print("Value is a string")
case int():
print("Value is an integer")
case float():
print("Value is a float")
case _:
print("Value is of an unknown type")
process_value("Hello") # 输出: Value is a string
process_value(42) # 输出: Value is an integer
process_value(3.14) # 输出: Value is a float
process_value([1, 2, 3]) # 输出: Value is of an unknown type六、循环语句：
Python 3中的循环语句用于重复执行一段代码，直到满足特定条件。主要有两种类型的循环语句：for 循环和 while 循环。
（1）for 循环：
for循环用于遍历序列（如列表、元组、字典、集合等）或其他可迭代对象。
# 遍历列表
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)
# 遍历字符串（字符串也是可迭代的）
for char in "hello":
print(char)
# 遍历字典（默认遍历字典的键）
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
print(key, my_dict[key])
# 使用 range() 函数进行数值循环
for i in range(5):
print(i)
# 使用 range() 函数的起始和结束值
for i in range(2, 10, 2):
print(i) # 打印 2, 4, 6, 8（2）while 循环：
while循环会一直执行，直到条件变为假（False）。
# 基本的 while 循环
count = 0
while count < 5:
print(count)
count += 1 # 等同于 count = count + 1
# 带有条件表达式的 while 循环
number = 1
while number <= 5:
print(number)
number += 1（3）循环控制语句：
break：用于立即退出循环体，无论for还是while循环。continue：跳过当前循环的剩余部分，直接进行下一次迭代。else：可以与for循环一起使用，当循环正常结束时执行else块（即没有遇到break语句）。
# 使用 break 退出循环
for num in range(1, 10):
if num == 5:
break
print(num)
print("循环结束")
# 使用 continue 跳过迭代
for num in range(1, 10):
if num % 2 == 0:
continue
print(num)
# 使用 for-else 循环
for i in range(1, 5):
if i % 2 == 0:
print("Found an even number", i)
break
else:
print("No even number found")（4）pass 语句：
在Python中，pass 是一个空操作语句，它什么也不做。pass 语句通常用作占位符，当语法上需要一条语句但程序逻辑不需要执行任何操作时，就会使用 pass。
a.作为占位符：
- 在定义类、方法或循环时，如果暂时不想执行任何操作，可以使用
pass。
class MyEmptyClass:
pass
def my_empty_function():
pass
while True:
passb.满足语法要求:
- 在某些情况下，Python语法要求必须写一条语句，但可能还没有准备好实现具体的功能。
if __name__ == "__main__":
passc.在条件语句中:
- 在
if-elif-else语句中，如果只需要在某些条件分支中执行代码，可以在其他分支使用pass。
x = 10
if x > 5:
print("x is greater than 5")
elif x < 5:
pass # 这里暂时不执行任何操作
else:
print("x is equal to 5")d.在循环中:
- 在循环中，如果你只是想循环执行某些操作，而不在每次迭代中做任何事情，可以使用
pass。
for i in range(5):
pass # 这里不执行任何操作e.在异常处理中:
- 在定义异常处理程序时，如果只是想捕获异常而不做任何处理，可以使用
pass。
try:
# 尝试执行一些可能引发异常的代码
except ValueError:
pass # 捕获异常，但不执行任何操作