python笔记4
目录
1、序列的相关操作
2、序列的索引及切片操作
索引操作：
切片操作：
3、列表
1、列表的创建：
2、列表的基本操作：
3、遍历列表：
4、列表生成式：
5、二维列表：
6、列表的特点：
4、元组
1、元组的创建：
2、元组的基本操作：
3、元组的遍历：
4、元组生成式：
5、二维元组：
6、元组的特点：
5、列表与元组的区别
6、字典
1、字典的创建：
2、字典的基本操作：
3、字典元素的访问：
4、字典的遍历：
5、字典生成式：
7、集合
1、集合的创建
2、集合的操作符：
3、集合的相关操作方法：
4、集合的遍历：
5、集合生成式：
8、列表、元组、字典、集合的区别
1、序列的相关操作
序列在 Python 中是一类非常常见的数据类型，包括字符串（str）、列表（list）、元组（tuple）等。以下是一些序列的常见操作：
-
长度（Length）： 获取序列中元素的个数，可以使用
len()函数。my_string = "Hello, World!" length_of_string = len(my_string) print(length_of_string) # 输出 13 - 成员关系（Membership）： 检查某个元素是否在序列中，使用
in操作符。my_list = [1, 2, 3, 4, 5] print(3 in my_list) # 输出 True - 连接（Concatenation）： 将两个序列连接起来，使用
+操作符。string1 = "Hello" string2 = "World" concatenated_string = string1 + ", " + string2 print(concatenated_string) # 输出 'Hello, World' - 重复（Repetition）： 将序列重复多次，使用
*操作符。my_list = [1, 2, 3] repeated_list = my_list * 3 print(repeated_list) # 输出 [1, 2, 3, 1, 2, 3, 1, 2, 3] - 索引（Indexing）： 获取序列中特定位置的元素，使用方括号和索引值。
my_string = "Python" print(my_string[2]) # 输出 't' - 切片（Slicing）： 获取序列中的子序列，使用方括号和切片的语法。
my_list = [10, 20, 30, 40, 50] sub_list = my_list[1:4] print(sub_list) # 输出 [20, 30, 40] - 迭代（Iteration）： 使用循环遍历序列中的元素。
my_tuple = (1, 2, 3, 4) for item in my_tuple: print(item) - 最大值和最小值： 对于数字序列，可以使用
max()和min()函数找到最大值和最小值。numbers = [5, 2, 8, 1, 7] max_value = max(numbers) min_value = min(numbers) print(max_value, min_value) # 输出 8 1 - 追加（Append）： 仅适用于可变序列（例如列表），将元素添加到序列的末尾。
my_list = [1, 2, 3] my_list.append(4) print(my_list) # 输出 [1, 2, 3, 4] - 插入（Insert）： 仅适用于可变序列，在指定位置插入元素。
my_list = [1, 2, 3] my_list.insert(1, 5) # 在索引 1 处插入值 5 print(my_list) # 输出 [1, 5, 2, 3] - 删除（Remove）： 仅适用于可变序列，删除指定值的第一个匹配项。
my_list = [1, 2, 3, 2, 4] my_list.remove(2) print(my_list) # 输出 [1, 3, 2, 4] - 弹出（Pop）： 仅适用于可变序列，从指定位置移除并返回元素。
my_list = [1, 2, 3] popped_value = my_list.pop(1) # 移除索引 1 处的元素并返回 print(popped_value, my_list) # 输出 2 [1, 3] - 查找元素的索引（Index）： 查找指定值的第一个匹配项的索引。
my_list = [10, 20, 30, 20, 40] index = my_list.index(20) print(index) # 输出 1 - 统计元素出现次数（Count）： 统计指定值在序列中出现的次数。
my_list = [1, 2, 3, 2, 4, 2] count = my_list.count(2) print(count) # 输出 3 - 反转（Reverse）： 仅适用于可变序列，反转序列中的元素顺序。
my_list = [1, 2, 3] my_list.reverse() print(my_list) # 输出 [3, 2, 1] - 排序（Sort）： 仅适用于可变序列，对序列中的元素进行排序。
my_list = [5, 2, 8, 1, 7] my_list.sort() print(my_list) # 输出 [1, 2, 5, 7, 8]
2、序列的索引及切片操作
在 Python 中，序列是一种包含多个元素的数据类型，例如字符串（str）、列表（list）、元组（tuple）等。序列支持索引和切片操作，允许你访问序列中的元素或获取子序列。
索引操作：
索引用于访问序列中的单个元素，索引从 0 开始。例如：
# 创建一个列表
my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 使用索引获取单个元素
print(my_list[2]) # 输出 30负数索引表示从末尾开始，例如 -1 表示最后一个元素，-2 表示倒数第二个元素。
print(my_list[-1]) # 输出 90切片操作：
切片用于获取序列中的子序列，语法为 start:stop:step，其中 start 表示起始索引，stop 表示结束索引（不包含在切片中），step 表示步长。
# 使用切片获取子序列
print(my_list[2:6]) # 输出 [30, 40, 50, 60]
print(my_list[:5]) # 输出 [10, 20, 30, 40, 50]
print(my_list[::2]) # 输出 [10, 30, 50, 70, 90]切片还可以与负数索引一起使用：
# 使用负数索引和负数步长
print(my_list[-3:]) # 输出 [70, 80, 90]
print(my_list[::-1]) # 输出 [90, 80, 70, 60, 50, 40, 30, 20, 10]切片中，如果不提供 start、stop、step 中的某个值，默认使用默认值：start 默认为 0，stop 默认为序列的长度，step 默认为 1。
需要注意的是，切片操作不会修改原始序列，而是返回一个新的序列。
3、列表
1、列表的创建：
在Python中，可以通过以下方式创建列表：
-
直接赋值：
my_list = [1, 2, 3, 4, 5] -
使用
list()构造函数my_list = list([1, 2, 3, 4, 5]) -
使用空列表，然后逐步添加元素：
my_list = [] my_list.append(1) my_list.append(2) my_list.append(3) # 现在 my_list 是 [1, 2, 3] -
使用
range()函数创建数字序列：my_list = list(range(1, 6)) # 等同于 my_list = [1, 2, 3, 4, 5]
2、列表的基本操作：
-
访问元素：
print(my_list[0]) # 输出 1 print(my_list[2]) # 输出 3 -
修改元素：
my_list[1] = 10 print(my_list) # 输出 [1, 10, 3, 4, 5] -
添加元素：
my_list.append(6) print(my_list) # 输出 [1, 10, 3, 4, 5, 6] -
插入元素：
my_list.insert(2, 8) # 在索引 2 处插入值 8 print(my_list) # 输出 [1, 10, 8, 3, 4, 5, 6] -
删除元素：
my_list.remove(4) print(my_list) # 输出 [1, 10, 8, 3, 5, 6] -
弹出元素：
popped_value = my_list.pop(2) # 弹出索引 2 处的元素 print(popped_value, my_list) # 输出 8 [1, 10, 3, 5, 6] -
切片操作：
sub_list = my_list[1:4] print(sub_list) # 输出 [10, 3, 5] -
连接列表：
another_list = [7, 8, 9] combined_list = my_list + another_list print(combined_list) # 输出 [1, 10, 3, 5, 6, 7, 8, 9] -
清空列表：
my_list.clear() print(my_list) # 输出 []
3、遍历列表：
- 使用
for循环遍历：
my_list = [1, 2, 3, 4, 5]
for element in my_list:
print(element)
输出：
1
2
3
4
5
- 使用
range和len遍历索引和元素：
my_list = [1, 2, 3, 4, 5]
for i in range(len(my_list)):
print(f"Index {i}: {my_list[i]}")
输出：
Index 0: 1
Index 1: 2
Index 2: 3
Index 3: 4
Index 4: 5
- 使用
enumerate获取索引和元素：
my_list = [1, 2, 3, 4, 5]
for index, element in enumerate(my_list):
print(f"Index {index}: {element}")
输出与上面相同
- 使用
while循环和索引：
my_list = [1, 2, 3, 4, 5]
index = 0
while index < len(my_list):
print(my_list[index])
index += 1
这些方法中，for循环是最常用的，因为它简洁而直观。
4、列表生成式：
列表生成式是一种简洁而强大的语法，用于创建列表。它允许你通过一行代码生成列表，而不需要使用显式的循环语句。以下是基本的列表生成式语法：
# 基本形式
new_list = [expression for item in iterable]
# 带条件的列表生成式
new_list = [expression for item in iterable if condition]
这里的 expression 是一个用于生成新列表元素的表达式，item 是可迭代对象（如列表、元组、字符串等）中的每个元素，iterable 是可迭代对象，condition 是一个可选的条件，只有当条件为真时才会包含在新列表中。
以下是一些例子：
-
生成平方数列表：
square_numbers = [x**2 for x in range(1, 6)] # square_numbers 是 [1, 4, 9, 16, 25] - 筛选偶数的列表生成式：
even_numbers = [x for x in range(1, 11) if x % 2 == 0] # even_numbers 是 [2, 4, 6, 8, 10] - 字符串处理的列表生成式：
words = ['hello', 'world', 'python'] uppercased_words = [word.upper() for word in words] # uppercased_words 是 ['HELLO', 'WORLD', 'PYTHON'] - 使用条件表达式：
numbers = [1, 2, 3, 4, 5] squared_even_numbers = [x**2 if x % 2 == 0 else x for x in numbers] # squared_even_numbers 是 [1, 4, 3, 16, 5] - 嵌套的列表生成式：
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] flattened_matrix = [element for row in matrix for element in row] # flattened_matrix 是 [1, 2, 3, 4, 5, 6, 7, 8, 9]列表生成式是一种在代码中使用简洁语法创建列表的方式，可以使代码更加清晰和紧凑。
5、二维列表：
在Python中，二维列表是指列表中的元素也是列表，形成了嵌套的结构，从而创建了一个类似于矩阵的数据结构。每个内部列表可以被视为矩阵的行。以下是创建和操作二维列表的一些例子：
-
创建二维列表：
# 使用嵌套列表创建二维列表 matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] -
访问元素：
# 获取第二行第三列的元素 element = matrix[1][2] # 注意索引从0开始 # element 等于 6 -
遍历二维列表：
这将输出：for row in matrix: for element in row: print(element, end=' ') print()1 2 3 4 5 6 7 8 9 - 修改元素：
# 修改第一行第二列的元素 matrix[0][1] = 10 # matrix 现在是 [[1, 10, 3], [4, 5, 6], [7, 8, 9]] - 使用列表生成式创建二维列表：
# 创建一个3x3的零矩阵 zero_matrix = [[0 for _ in range(3)] for _ in range(3)] # zero_matrix 是 [[0, 0, 0], [0, 0, 0], [0, 0, 0]] - 转置二维列表：
# 使用zip(*matrix)进行转置 transposed_matrix = [list(row) for row in zip(*matrix)] # transposed_matrix 是 [[1, 4, 7], [10, 5, 8], [3, 6, 9]]
6、列表的特点：
- 列表是有序的。
- 列表中的元素可以是不同的数据类型，包括数字、字符串、列表等。
- 列表是可变的，可以修改、添加或删除元素。
- 注：在Python中，"可变"（mutable）是指数据结构的内容或状态可以被修改、更改。列表是可变的数据结构，这意味着你可以对列表进行各种操作，如添加、删除、修改元素，而不需要创建一个全新的列表。相反，与之对应的是"不可变"（immutable）数据类型，例如字符串和元组。对于不可变类型的数据结构，一旦创建，其内容就不能被修改。每次对字符串进行操作时，实际上都是创建了一个新的字符串。
4、元组
在Python中，元组（Tuple）是一个不可变的有序序列，类似于列表，但元组的元素不可修改。元组使用圆括号 () 表示，其中的元素可以是不同的数据类型。
1、元组的创建：
创建元组的方式主要有两种：使用圆括号 () 或者直接用逗号 ,。以下是两种方式的示例：
-
使用圆括号
()：my_tuple = (1, 2, 3, 'a', 'b')在圆括号中列出元素，以逗号分隔，就可以创建一个元组。这是最常见和推荐的方式。
-
直接用逗号
,：another_tuple = 4, 5, 6可以省略圆括号，直接用逗号创建元组。这种方式也是有效的。
2、元组的基本操作：
元组是不可变的数据结构，这意味着一旦创建，它的元素不能被修改、添加或删除。然而，你仍然可以执行一些操作和方法来处理元组：
-
访问元素： 使用索引来访问元组中的元素，索引从0开始。
my_tuple = (1, 2, 3, 'a', 'b') element = my_tuple[2] # element 等于 3 -
切片： 类似于列表，你可以使用切片来获取元组的子集。
my_tuple = (1, 2, 3, 'a', 'b') subset = my_tuple[1:4] # subset 是 (2, 3, 'a') -
元组拼接： 你可以使用
+操作符将两个元组拼接成一个新的元组。tuple1 = (1, 2, 3) tuple2 = ('a', 'b', 'c') concatenated_tuple = tuple1 + tuple2 # concatenated_tuple 是 (1, 2, 3, 'a', 'b', 'c') -
元组解包： 将元组的元素解包到多个变量中。
another_tuple = 4, 5, 6 a, b, c = another_tuple # 现在 a 等于 4，b 等于 5，c 等于 6 -
统计元素出现次数： 使用
count()方法来统计指定元素在元组中出现的次数。my_tuple = (1, 2, 2, 3, 4) count_of_2 = my_tuple.count(2) # count_of_2 等于 2这些是一些基本的元组操作。由于元组是不可变的，它们通常用于存储不希望被修改的数据。
3、元组的遍历：
遍历元组的方法与遍历列表类似，你可以使用循环来依次访问元组中的每个元素。以下是几种遍历元组的常用方法：
-
使用 for 循环：
my_tuple = (1, 2, 3, 'a', 'b') for element in my_tuple: print(element)这将输出：
1 2 3 a b -
使用索引和 range： 如果需要同时访问元素和它们的索引，可以使用
range函数和索引来遍历元组。my_tuple = (1, 2, 3, 'a', 'b') for i in range(len(my_tuple)): print(f"Index {i}: {my_tuple[i]}")这将输出：
Index 0: 1 Index 1: 2 Index 2: 3 Index 3: a Index 4: b -
使用 enumerate 函数：
enumerate函数返回元组的索引和对应的元素，使遍历更加方便。my_tuple = (1, 2, 3, 'a', 'b') for index, element in enumerate(my_tuple): print(f"Index {index}: {element}")输出：
Index 0: 1 Index 1: 2 Index 2: 3 Index 3: a Index 4: b
4、元组生成式：
元组生成式（Tuple Comprehension）是一种用简洁的语法创建元组的方式。类似于列表生成式，元组生成式允许你使用一行代码生成元组，并且具有与列表生成式类似的语法结构。以下是一些元组生成式的示例：
-
基本的元组生成式：
my_tuple = tuple(x for x in range(5)) # my_tuple 是 (0, 1, 2, 3, 4)在这个例子中，元组生成式使用
range(5)生成一个包含0到4的整数的元组。 -
带条件的元组生成式：
even_numbers = tuple(x for x in range(10) if x % 2 == 0) # even_numbers 是 (0, 2, 4, 6, 8)在这个例子中，元组生成式仅包含满足条件的偶数。
-
元组生成式与函数：
squares = tuple(x**2 for x in range(3)) # squares 是 (0, 1, 4)在这个例子中，元组生成式使用函数计算每个元素的平方。
元组生成式的语法结构与列表生成式类似，但使用的是圆括号 () 而不是方括号 []。元组生成式提供了一种简洁而清晰的方式来创建元组，并且具有灵活的条件筛选功能。
请注意，与列表生成式相似，元组生成式是在内存中一次性创建整个元组，因此适用于相对较小的数据集。
5、二维元组：
二维元组是包含元组作为其元素的元组，形成了一个类似于矩阵或表格的结构。每个元组代表一行（或列），而其中的元素则代表相应行（或列）的值。以下是一个简单的二维元组示例：
# 二维元组表示一个矩阵
matrix = ((1, 2, 3),
(4, 5, 6),
(7, 8, 9))
# 访问二维元组的元素
element = matrix[1][2] # 获取第二行第三列的值，element 等于 6
在这个示例中，matrix 是一个包含三个元组的元组，每个元组都代表矩阵的一行。你可以使用双重索引来访问特定位置的元素。
二维元组在表示二维数据结构时很有用，例如在处理矩阵、表格或类似结构的数据时。你可以通过嵌套的元组形成更高维度的数据结构，这样就能够表示更复杂的数据关系。
6、元组的特点：
元组是一种有序、不可变的数据结构，具有以下主要特点：
-
不可变性： 元组的元素一旦被赋值，就不能被修改、添加或删除。这使得元组成为一种适合存储不希望被改变的数据的数据类型。
-
有序性： 元组是有序的，即元素按照它们的插入顺序进行存储，你可以通过索引访问元组中的元素。
-
异质性： 元组中的元素可以是不同的数据类型，例如整数、字符串、浮点数等。
-
支持索引和切片： 你可以使用索引来访问元组中的单个元素，并使用切片来获取元组的子集。
-
不可变性的优点： 由于元组是不可变的，它们在某些情况下比列表更有效。在需要确保数据不被修改的情况下，元组是一个更安全的选择。
-
元组生成式： 类似于列表生成式，元组生成式允许你使用简洁的语法创建元组。
-
用途广泛： 元组在很多场景中都很有用，例如在函数返回多个值时、用于不可变的键（例如字典中的键）等。
5、列表与元组的区别
列表（List）和元组（Tuple）是 Python 中两种常见的序列（Sequence）数据类型，它们之间有一些关键的区别。以下是列表和元组的主要区别：
-
可变性（Mutability）：
- 列表： 列表是可变的（Mutable）。这意味着你可以在创建列表后修改它，添加、删除或修改其中的元素。
- 元组： 元组是不可变的（Immutable）。一旦创建了元组，就不能更改其内容，无法添加、删除或修改元组中的元素。
-
语法表示：
- 列表： 使用方括号
[]表示，例如：my_list = [1, 2, 3]。 - 元组： 使用圆括号
()表示，例如：my_tuple = (1, 2, 3)。
- 列表： 使用方括号
-
性能：
- 列表： 由于列表是可变的，它们在涉及插入、删除等操作时可能需要更多的内存和时间。
- 元组： 由于元组是不可变的，它们在一些情况下可能比列表具有更好的性能。
-
使用场景：
- 列表： 适合用于存储可变的数据集，需要频繁地进行插入、删除或修改元素的情况。
- 元组： 适合用于表示不可变的数据集，对数据的读取操作比较频繁，或者在需要确保数据不被修改的情况下使用。
-
函数返回值：
- 列表： 通常用于函数返回多个值时，因为列表是可变的，可以动态地添加元素。
- 元组： 通常用于不希望函数返回的数据被修改的情况，因为元组是不可变的。
在选择使用列表还是元组时，考虑数据的可变性、性能需求以及数据的使用场景。如果需要可变性和灵活性，选择列表；如果需要不可变性和更好的性能，选择元组。
6、字典
字典（Dictionary）是 Python 中的一种无序、可变的数据类型，用于存储键-值对（Key-Value pairs）。字典通过使用键来访问值，而不是使用索引。以下是字典的主要特点：
-
键-值对： 字典中的数据是以键-值对的形式存储的。每个键必须是唯一的，而值可以是任意类型的对象（整数、字符串、列表、字典等）。
-
无序性： 字典中的键-值对没有固定的顺序。与列表和元组不同，字典中的元素不是通过索引来访问的，而是通过键来访问。
-
可变性： 字典是可变的，可以在创建后添加、删除或修改键-值对。
-
用大括号表示： 字典使用大括号
{}表示，键和值之间使用冒号:分隔，键-值对之间使用逗号,分隔。例如：my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} -
访问元素： 使用键来访问字典中的值。
print(my_dict['name']) # 输出 'John' -
键的唯一性： 字典中的键必须是唯一的，如果尝试使用已存在的键添加新的值，将会覆盖原有的值。
-
字典方法： 字典提供了丰富的方法，用于添加、删除、获取键-值对等操作。例如，
dict.keys()返回字典中所有的键，dict.values()返回字典中所有的值。
1、字典的创建：
在 Python 中，有多种方式可以创建字典。以下是一些常见的创建字典的方法：
-
直接赋值： 使用大括号
{}直接指定键-值对。my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} -
dict() 构造函数： 使用
dict()构造函数创建字典，可以传递键-值对或其他字典。my_dict = dict(name='John', age=25, city='New York') -
字典推导式： 类似于列表推导式，可以使用字典推导式创建字典。
my_dict = {key: value for key, value in [('name', 'John'), ('age', 25), ('city', 'New York')]} -
fromkeys() 方法： 使用
fromkeys()方法创建具有指定键的字典，所有的值默认为None或指定的默认值。keys = ['name', 'age', 'city'] default_value = None my_dict = dict.fromkeys(keys, default_value)这些方法中的任何一种都可以根据你的需求选择。直接赋值和使用
dict()构造函数是最常见和简单的方式。字典推导式在需要根据某些条件生成键-值对时非常有用，而fromkeys()方法则用于创建具有相同默认值的字典。
2、字典的基本操作：
- keys()：
keys()是字典对象的方法，用于返回包含字典中所有键的视图对象。这个视图对象是一个类似于集合的结构，其中每个元素都是字典中的一个键。基本语法如下：
dictionary.keys()这会返回一个包含字典中所有键的
dict_keys视图对象。你可以使用这个视图对象进行迭代、转换为列表，或者执行其他与键相关的操作。以下是一个简单的示例：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 获取字典的 keys 视图 keys_view = my_dict.keys() # keys_view 是一个字典视图对象 print(type(keys_view)) # 输出# 遍历字典的键 for key in keys_view: print(f"Key: {key}") 输出：
Key: name Key: age Key: city在这个示例中，
keys()方法返回了一个包含字典my_dict中所有键的视图对象。我们将这个视图对象命名为keys_view，然后通过迭代它，可以访问字典中的所有键。需要注意的是，
dict_keys是一个动态的视图，如果字典发生更改，它会相应地更新。这使得它成为一种方便的方式来迭代字典中的键。 - values()：
values()是字典对象的方法，用于返回包含字典中所有值的视图对象。这个视图对象是一个类似于集合的结构，其中每个元素都是字典中的一个值。基本语法如下：
dictionary.values()这会返回一个包含字典中所有值的
dict_values视图对象。你可以使用这个视图对象进行迭代、转换为列表，或者执行其他与值相关的操作。以下是一个简单的示例：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 获取字典的 values 视图 values_view = my_dict.values() # values_view 是一个字典视图对象 print(type(values_view)) # 输出# 遍历字典的值 for value in values_view: print(f"Value: {value}") 输出：
Value: John Value: 25 Value: New York在这个示例中，
values()方法返回了一个包含字典my_dict中所有值的视图对象。我们将这个视图对象命名为values_view，然后通过迭代它，可以访问字典中的所有值。需要注意的是，
dict_values是一个动态的视图，如果字典发生更改，它会相应地更新。这使得它成为一种方便的方式来迭代字典中的值。 - items()：
items()是字典对象的方法，用于返回包含字典中所有键值对的视图对象。这个视图对象是一个类似于集合的结构，其中每个元素都是一个键-值对的元组。基本语法如下：
dictionary.items()这会返回一个包含字典中所有键值对的
dict_items视图对象。你可以使用这个视图对象进行迭代、转换为列表，或者执行其他与键值对相关的操作。以下是一个简单的示例：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 获取字典的 items 视图 items_view = my_dict.items() # items_view 是一个字典视图对象 print(type(items_view)) # 输出# 遍历字典的键-值对 for key, value in items_view: print(f"Key: {key}, Value: {value}") 输出：
Key: name, Value: John Key: age, Value: 25 Key: city, Value: New York在这个示例中，
items()方法返回了一个包含字典my_dict中所有键值对的视图对象。我们将这个视图对象命名为items_view，然后通过迭代它，可以访问字典中的所有键-值对。需要注意的是，
dict_items是一个动态的视图，如果字典发生更改，它会相应地更新。这使得它成为一种方便的方式来迭代字典中的键-值对。
3、字典元素的访问：
在 Python 中，字典中的元素可以通过键来访问。以下是字典元素访问的几种方式：
-
使用方括号
[]： 通过在字典名称后面加上方括号，并在方括号内指定键来访问字典中的元素。my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 访问 'name' 键对应的值 name_value = my_dict['name'] print(name_value) # 输出 'John' -
get() 方法： 使用
get()方法来获取指定键的值。如果键不存在，get()方法返回默认值（默认为None）而不引发 KeyError。my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 使用 get() 方法获取 'age' 键对应的值 age_value = my_dict.get('age') print(age_value) # 输出 25 -
keys() 方法： 使用
keys()方法获取字典中所有键的视图，然后可以将其转换为列表。my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 获取所有键的视图，并将其转换为列表 all_keys = list(my_dict.keys()) print(all_keys) # 输出 ['name', 'age', 'city'] -
values() 方法： 使用
values()方法获取字典中所有值的视图，然后可以将其转换为列表。my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 获取所有值的视图，并将其转换为列表 all_values = list(my_dict.values()) print(all_values) # 输出 ['John', 25, 'New York'] -
items() 方法： 使用
items()方法获取字典中所有键-值对的视图，然后可以将其转换为列表。my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 获取所有键-值对的视图，并将其转换为列表 all_items = list(my_dict.items()) print(all_items) # 输出 [('name', 'John'), ('age', 25), ('city', 'New York')]
4、字典的遍历：
在 Python 中，有多种方法可以遍历字典的键、值或键-值对。以下是一些常见的遍历字典的方式：
-
遍历键：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 遍历字典的键 for key in my_dict: print(key)输出：
name age city -
遍历值：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 遍历字典的值 for value in my_dict.values(): print(value)输出：
John 25 New York -
遍历键-值对：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'} # 遍历字典的键-值对 for key, value in my_dict.items(): print(f"Key: {key}, Value: {value}")输出：
Key: name, Value: John Key: age, Value: 25 Key: city, Value: New York
5、字典生成式：
字典生成式是一种简洁的语法，用于创建字典的方式。它类似于列表生成式，但使用花括号 {} 来创建字典。字典生成式的基本语法如下：
{key_expression: value_expression for item in iterable}
其中：
key_expression是用于生成字典键的表达式。value_expression是用于生成字典值的表达式。item是可迭代对象中的每个元素。- 字典中的每个键-值对由
key_expression和value_expression生成。
以下是一些字典生成式的示例：
-
基本示例：
# 创建一个字典，包含数字的平方 squares_dict = {x: x**2 for x in range(5)} print(squares_dict)输出：
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16} -
使用条件表达式：
# 创建一个字典，包含偶数的平方 even_squares_dict = {x: x**2 for x in range(10) if x % 2 == 0} print(even_squares_dict)输出：
{0: 0, 2: 4, 4: 16, 6: 36, 8: 64} -
键-值颠倒：
# 创建一个字典，将原字典的键和值颠倒 original_dict = {'a': 1, 'b': 2, 'c': 3} inverted_dict = {value: key for key, value in original_dict.items()} print(inverted_dict)输出：
{1: 'a', 2: 'b', 3: 'c'}
字典生成式提供了一种紧凑而简单的方式来创建字典，特别是在需要对可迭代对象的元素进行转换和过滤时。
7、集合
集合（Set）是 Python 中的一种无序、可变的数据类型，用于存储不重复的元素。集合可以用大括号 {} 或者 set() 构造。
以下是一些关于集合的基本特性和操作：
-
无序性： 集合中的元素没有固定的顺序，你不能通过索引访问集合中的元素。
-
不重复性： 集合中的元素是唯一的，重复的元素会被自动忽略。
-
可变性： 集合是可变的，可以通过添加、删除元素来修改集合。
1、集合的创建
在 Python 中，可以使用多种方式创建集合。以下是一些常见的创建集合的方法：
-
使用大括号
{}： 最简单的方式是使用大括号{}来定义集合，并在大括号内列出元素。my_set = {1, 2, 3, 4, 5}使用空的大括号
{}创建时，解释器会将其视为一个空的字典而不是一个空的集合。 -
使用
set()构造函数： 使用set()构造函数可以将其他可迭代对象（如列表、元组）转换为集合。list_elements = [1, 2, 3, 4, 5] set_from_list = set(list_elements)直接使用
set()创建空集合：empty_set = set() -
使用集合生成式： 可以使用集合生成式在一行代码内创建集合。
my_set = {x for x in range(1, 6)}这将创建一个包含 1 到 5 的整数的集合。
-
复制其他集合： 可以通过复制现有的集合来创建新集合。
original_set = {1, 2, 3} new_set = original_set.copy()或者使用集合的
copy()方法：original_set = {1, 2, 3} new_set = original_set.copy()
2、集合的操作符：
集合支持一系列操作符，用于执行不同的集合运算。以下是一些常见的集合操作符：
- 并集操作符 (
|)：返回两个集合的并集，包含两个集合中的所有不重复元素。set1 = {1, 2, 3} set2 = {3, 4, 5} union_set = set1 | set2 # 结果为 {1, 2, 3, 4, 5} - 交集操作符 (
&)：回两个集合的交集，包含同时存在于两个集合中的元素。set1 = {1, 2, 3} set2 = {3, 4, 5} intersection_set = set1 & set2 # 结果为 {3} - 差集操作符 (
-)：返回属于第一个集合但不属于第二个集合的元素。set1 = {1, 2, 3} set2 = {3, 4, 5} difference_set = set1 - set2 # 结果为 {1, 2} - 对称差集操作符 (
^)：返回两个集合的对称差集，包含只在一个集合中出现的元素。set1 = {1, 2, 3} set2 = {3, 4, 5} symmetric_difference_set = set1 ^ set2 # 结果为 {1, 2, 4, 5}
3、集合的相关操作方法：
集合（Set）在 Python 中提供了多种方法，用于执行各种操作。以下是一些常见的集合操作方法：
-
添加元素：
add(element): 向集合中添加一个元素。my_set = {1, 2, 3} my_set.add(4) # 将元素 4 添加到集合中 -
移除元素：
remove(element): 从集合中移除指定元素，如果元素不存在则抛出 KeyError。discard(element): 从集合中移除指定元素，如果元素不存在则不抛出错误。my_set = {1, 2, 3} my_set.remove(2) # 从集合中移除元素 2 my_set.discard(3) # 从集合中移除元素 3 -
- 清空集合：移除集合中的所有元素，使其变为空集合。
my_set = {1, 2, 3} my_set.clear() # 清空集合 - 集合运算方法：
union(other_set): 返回两个集合的并集。tersection(other_set): 返回两个集合的交集。difference(other_set): 返回属于第一个集合但不属于第二个集合的元素。symmetric_difference(other_set): 返回两个集合的对称差集。set1 = {1, 2, 3} set2 = {3, 4, 5} union_set = set1.union(set2) intersection_set = set1.intersection(set2) difference_set = set1.difference(set2) symmetric_difference_set = set1.symmetric_difference(set2) - 判断子集和超集：
issubset(other_set): 判断当前集合是否是另一个集合的子集。issuperset(other_set): 判断当前集合是否是另一个集合的超集。set1 = {1, 2} set2 = {1, 2, 3, 4} is_subset = set1.issubset(set2) # 返回 True is_superset = set2.issuperset(set1) # 返回 True
4、集合的遍历：
在 Python 中，可以使用迭代来遍历集合的所有元素。有几种方式可以进行集合的遍历：
-
使用 for 循环： 可以使用
for循环来遍历集合的所有元素。my_set = {1, 2, 3, 4, 5} for element in my_set: print(element)这样会依次输出集合中的每个元素。
-
转换为列表后遍历： 你可以将集合转换为列表，然后使用列表的遍历方式。
my_set = {1, 2, 3, 4, 5} list_from_set = list(my_set) for element in list_from_set: print(element)这种方法对于需要在遍历时对集合进行修改时可能更安全，因为你不会直接在迭代中修改集合。
-
使用迭代器： 集合本身就是可迭代的，你可以使用内置的
iter()函数创建一个迭代器并使用next()函数逐个获取元素。my_set = {1, 2, 3, 4, 5} iterator = iter(my_set) while True: try: element = next(iterator) print(element) except StopIteration: break注意：通常情况下，使用
for循环是最简单和推荐的方式。
5、集合生成式：
集合生成式（Set Comprehension）是一种简洁而强大的语法，允许你通过一行代码创建集合。集合生成式的语法类似于列表生成式，但使用大括号 {} 来表示集合。
以下是集合生成式的基本语法：
my_set = {expression for item in iterable if condition}
expression: 对每个元素执行的表达式，用于生成集合中的元素。item: 可迭代对象中的元素。iterable: 可迭代对象，如列表、元组等。condition: （可选）一个条件，用于过滤元素。
下面是一些集合生成式的示例：
- 基本示例： 创建一个包含平方数的集合。
square_set = {x**2 for x in range(1, 6)} # 结果为 {1, 4, 9, 16, 25} - 带条件的示例： 创建一个包含偶数平方数的集合。
even_square_set = {x**2 for x in range(1, 6) if x % 2 == 0} # 结果为 {4, 16} - 字符串处理示例： 创建一个包含字符串长度的集合。
words = {'apple', 'banana', 'orange'} word_length_set = {len(word) for word in words} # 结果为 {5, 6}
8、列表、元组、字典、集合的区别
列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set）是 Python 中常用的四种数据结构，它们有一些重要的区别：
-
列表（List）：
- 有序可变序列，可以包含任意类型的元素。
- 使用方括号
[]定义，元素之间用逗号,分隔。 - 允许修改元素，可以进行增删改查操作。
- 例子：
my_list = [1, 'hello', 3.14, True]
-
元组（Tuple）：
- 有序不可变序列，可以包含任意类型的元素。
- 使用圆括号
()定义，元素之间用逗号,分隔。 - 不允许修改元素，是不可变的。
- 例子：
my_tuple = (1, 'hello', 3.14, True)
-
字典（Dictionary）：
- 无序的键值对集合，可变的。
- 使用花括号
{}定义，键值对之间用冒号:分隔，键值对之间用逗号,分隔。 - 键必须是不可变类型，值可以是任意类型。
- 允许通过键来修改、增加、删除元素，支持通过键进行快速检索。
- 例子：
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
-
集合（Set）：
- 无序的唯一元素集合。
- 使用花括号
{}定义，元素之间用逗号,分隔。 - 不允许重复元素，用于去重。
- 可以进行集合运算（交集、并集、差集等）。
- 允许增加、删除元素。
- 例子：
my_set = {1, 2, 3, 4, 5}
总结：
- 列表和元组都是有序序列，但列表是可变的，而元组是不可变的。
- 字典是键值对的集合，可变，通过键进行操作。
- 集合是唯一元素的无序集合，可变，用于去重和集合运算。
选择使用哪种数据结构取决于的具体需求和操作。