目录
2.index(): 返回指定元素在元组中第一次出现的索引。
删除键值对：使用 del 关键字或 pop() 方法删除键值对。
获取所有键或所有值：使用 keys()、values() 方法分别获取所有键或所有值。
获取键值对：使用 items() 方法获取所有键值对，返回一个包含元组的视图。
检查键是否存在：使用 in 关键字检查字典中是否存在指定的键。
删除指定键值对：使用 del 关键字或 pop() 方法删除指定键值对
一. 列表
-
有序性： 列表中的元素是按照它们的插入顺序排列的。这意味着列表中的每个元素都有一个对应的位置，可以通过索引来访问。
-
可变性： 列表是可变的数据类型，这意味着你可以修改列表中的元素、添加新元素或删除元素。与不可变数据类型（如字符串）不同，列表的内容可以被修改。
-
数据类型多样性： 列表可以包含不同类型的数据。这意味着你可以在同一个列表中存储整数、浮点数、字符串、布尔值等不同类型的数据。甚至可以在列表中嵌套其他列表，从而创建多维列表。
-
灵活性： 列表提供了丰富的方法和操作，使得对列表进行各种操作变得简单而灵活。无论是修改列表元素、添加新元素、删除元素还是进行列表之间的操作，Python都提供了相应的方法和语法。
创建列表
在Python中，使用方括号 [] 来创建列表。你可以在创建时初始化列表，也可以在后续操作中添加、修改元素。
# 创建一个空列表
empty_list = []
# 创建包含元素的列表
my_list = [1, 2, "hello", True, 3.14]
访问列表元素
你可以使用索引来访问列表中的元素，索引从0开始递增。也可以使用负数索引从末尾开始访问元素。 （不是从1开始）
my_list = [1, 2, "hello", True, 3.14]
# 访问列表元素
first_element = my_list[0] # 第一个元素
last_element = my_list[-1] # 最后一个元素
print(first_element) # 输出: 1
print(last_element) # 输出: 3.14
修改列表元素
由于列表是可变的，因此你可以通过索引来修改列表中的元素。
my_list = [1, 2, "hello", True, 3.14]
# 修改列表元素
my_list[2] = "world" # 将第三个元素改为"world"
print(my_list) # 输出: [1, 2, 'world', True, 3.14]
列表操作方法
Python提供了许多方法来操作列表，例如添加元素、删除元素、合并列表等。
append() 向列表末尾添加新元素 insert() 在指定位置插入新元素 remove() 删除列表中指定的元素 pop() 弹出并返回指定索引处的元素 extend() 将一个列表的元素添加到另一个列表末尾 clear() 清空列表中的所有元素 index() 返回列表中指定元素第一次出现的索引 count() 返回列表中指定元素的出现次数 reverse() 反转列表中的元素顺序 sort() 对列表中的元素进行排序 copy() 生成一个新的副本 len() 返回列表中元素的个数 以下是一个简单例子， 展示上面的方法，说什么的都不如代码来的实在。
# 创建一个列表 my_list = [1, 2, 3, 4, 5] # append(): 向列表末尾添加新元素 my_list.append(6) # insert(): 在指定位置插入新元素 my_list.insert(0, 0) # remove(): 删除列表中指定的元素 my_list.remove(3) # pop(): 弹出并返回指定索引处的元素 popped_element = my_list.pop(2) # extend(): 将一个列表的元素添加到另一个列表末尾 another_list = [7, 8, 9] my_list.extend(another_list) # clear(): 清空列表中的所有元素 my_list.clear() # index(): 返回列表中指定元素第一次出现的索引 index_of_5 = my_list.index(5) # count(): 返回列表中指定元素的出现次数 count_of_5 = my_list.count(5) # reverse(): 反转列表中的元素顺序 my_list.reverse() # sort(): 对列表中的元素进行排序 my_list.sort() # copy(): 复制列表，生成一个新的副本 copied_list = my_list.copy() # len(): 返回列表中元素的个数 length_of_list = len(my_list) # 输出结果 print("操作后的列表:", my_list) print("被弹出的元素:", popped_element) print("元素 5 的索引:", index_of_5) print("元素 5 的出现次数:", count_of_5) print("复制的列表:", copied_list) print("列表的长度:", length_of_list)
列表切片
切片是 Python 中用于从序列（如列表、元组、字符串等）中获取子序列的一种机制。它允许你通过指定起始索引、结束索引和步长来获取所需的子序列。切片的基本语法是：
sequence[start:stop:step]
start: 切片开始的索引，默认为 0。stop: 切片结束的索引（不包含该索引处的元素）。step: 切片的步长，默认为 1（表示从起始索引到结束索引按顺序获取元素）。切片操作返回一个新的序列，原始序列不受影响。
my_list = [1, 2, 3, 4, 5] # 获取索引1到索引3（不包含）之间的子序列：[2, 3] sub_list = my_list[1:3] # 获取从索引2开始到列表末尾的子序列：[3, 4, 5] sub_list2 = my_list[2:] # 获取从列表开头到索引2（不包含）之间，步长为2的子序列：[1, 3] sub_list3 = my_list[:2:2] # 反转列表 reversed_list = my_list[::-1] print(sub_list) # 输出: [2, 3] print(sub_list2) # 输出: [3, 4, 5] print(sub_list3) # 输出: [1, 3] print(reversed_list) # 输出: [5, 4, 3, 2, 1]
链式索引
链式索引（也称为链式引用）是 Python 中一种常见的语法结构，用于访问嵌套的数据结构（例如列表、元组、字典等）中的深层次元素。链式索引的形式是通过多层次的索引操作来逐层获取嵌套结构中的元素。例如：
data_structure[level1][level2][level3]。# 创建一个嵌套列表 nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # 获取第二个子列表（索引1） sub_list = nested_list[1] # [4, 5, 6] # 获取第二个子列表中的第三个元素（索引2） element = nested_list[1][2] # 6 print(sub_list) # 输出: [4, 5, 6] print(element) # 输出: 6还有一个相对复杂的
ls = [[1, 2], [3, 4, 5], "abcdef"] result = ls[2][-1][0] # 获取字符串 "abcdef" 的第一个字符 "a" print(result) # 输出: a
ls[2]: 首先，从列表ls中取出索引为 2 的元素。假设这个元素是一个列表。[-1]: 然后，从该列表中取出倒数第一个元素。假设这个元素是一个字符串。[0]: 最后，从这个字符串中取出索引为 0 的字符。综合起来，
ls[2][-1][0]就是从一个嵌套列表中获取第三个子列表的最后一个元素（假设是字符串），然后再取这个字符串的第一个字符。
创建数值列表
当你创建数值列表时，可以使用 Python 的
range()函数。range()函数可以生成一个整数序列，你可以将其转换为列表。创建从 0 到 9 的整数列表：
# 使用 range() 函数生成整数序列，并将其转换为列表 numbers = list(range(10)) print(numbers) # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]创建从 1 到 10 的整数列表：
# 使用 range() 函数生成整数序列，并将其转换为列表 numbers = list(range(1, 11)) print(numbers) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]创建从 0 到 20，步长为 2 的整数列表：
# 使用 range() 函数生成整数序列，并将其转换为列表 numbers = list(range(0, 21, 2)) print(numbers) # 输出: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
range（）函数创建列表——简单计算
求和
# 创建一个数值列表 numbers = list(range(1, 11)) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 计算列表中所有元素的和 total = sum(numbers) print("总和:", total) # 输出: 总和: 55最大值
# 创建一个数值列表 numbers = list(range(1, 11)) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 找出列表中的最大值 max_value = max(numbers) print("最大值:", max_value) # 输出: 最大值: 10最小值
# 创建一个数值列表 numbers = list(range(1, 11)) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 找出列表中的最小值 min_value = min(numbers) print("最小值:", min_value) # 输出: 最小值: 1平均值
# 创建一个数值列表 numbers = list(range(1, 11)) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 计算列表中所有元素的平均值 average = sum(numbers) / len(numbers) print("平均值:", average) # 输出: 平均值: 5.5
Python中列表引用的影响
假设我们有一个列表
ls，它包含一些元素。然后我们执行lt = ls，这意味着lt现在指向与ls相同的列表。这并不是创建一个新的列表，而是创建了一个新的引用，指向相同的列表对象。因此，无论我们通过ls还是lt进行操作，都会影响相同的列表对象。ls = [1, 2, 3] lt = ls现在，无论我们通过
ls还是lt对列表进行操作，都会影响相同的列表对象：ls.append(4) print(lt) # 输出 [1, 2, 3, 4] lt.pop(0) print(ls) # 输出 [2, 3, 4]在这个例子中，
ls和lt都指向相同的列表[1, 2, 3, 4]，因此对其中一个的操作会影响另一个。所以要切记这不是两个列表而是一个。
二、集合
集合（Set）在Python中是一种无序、不重复的数据结构。
创建集合
可以使用大括号 {} 或者 set() 函数来创建集合。例如：
my_set = {1, 2, 3}
another_set = set([4, 5, 6])集合特点：
- 集合中的元素是无序的，不支持索引。
- 集合中的元素不重复，重复元素会被自动去重。
访问集合元素：
由于集合是无序的，不能通过索引来访问元素。但可以使用循环或者成员检测来访问集合中的元素。例如：
my_set = {1, 2, 3}
for item in my_set:
print(item)
集合的十个操作符
|：并集操作符，返回两个集合的所有元素，去除重复项。&：交集操作符，返回两个集合共有的元素。-：差集操作符，返回第一个集合中存在但第二个集合中不存在的元素。^：对称差集操作符，返回两个集合中各自独有的元素组成的集合。<=或<=：子集操作符，判断一个集合是否是另一个集合的子集，包括相等的情况。<：真子集操作符，判断一个集合是否是另一个集合的真子集，不包括相等的情况。>=或>=：超集操作符，判断一个集合是否是另一个集合的超集，包括相等的情况。>：真超集操作符，判断一个集合是否是另一个集合的真超集，不包括相等的情况。==：相等操作符，判断两个集合是否包含相同的元素。!=：不相等操作符，判断两个集合是否不相同。
# 定义两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 并集操作符 |
union_set = set1 | set2
print("并集:", union_set) # 输出: 并集: {1, 2, 3, 4, 5, 6, 7, 8}
# 交集操作符 &
intersection_set = set1 & set2
print("交集:", intersection_set) # 输出: 交集: {4, 5}
# 差集操作符 -
difference_set = set1 - set2
print("差集(set1 - set2):", difference_set) # 输出: 差集(set1 - set2): {1, 2, 3}
# 对称差集操作符 ^
symmetric_difference_set = set1 ^ set2
print("对称差集:", symmetric_difference_set) # 输出: 对称差集: {1, 2, 3, 6, 7, 8}
# 子集操作符 <= 或 <=
subset = {1, 2}
print("subset是set1的子集:", subset <= set1) # 输出: subset是set1的子集: True
# 真子集操作符 <
proper_subset = {1, 2, 3}
print("proper_subset是set1的真子集:", proper_subset < set1) # 输出: proper_subset是set1的真子集: True
# 超集操作符 >= 或 >=
superset = {1, 2, 3, 4, 5, 6}
print("superset是set1的超集:", superset >= set1) # 输出: superset是set1的超集: True
# 真超集操作符 >
proper_superset = {1, 2, 3, 4}
print("proper_superset是set1的真超集:", proper_superset > set1) # 输出: proper_superset是set1的真超集: True
# 相等操作符 ==
equal_set = {1, 2, 3, 4, 5}
print("set1与equal_set相等:", set1 == equal_set) # 输出: set1与equal_set相等: True
# 不相等操作符 !=
not_equal_set = {1, 2, 3}
print("set1与not_equal_set不相等:", set1 != not_equal_set) # 输出: set1与not_equal_set不相等: True
十个常用的集合方法及其用法
add(): 向集合添加元素。如果该元素已存在于集合中，则不执行任何操作。
remove(): 从集合中移除指定的元素。如果指定的元素不存在于集合中，则会引发 KeyError 异常。
discard(): 从集合中移除指定的元素。如果指定的元素不存在于集合中，则不执行任何操作。
pop(): 从集合中随机移除并返回一个元素。如果集合为空，则引发 KeyError 异常。
clear(): 移除集合中的所有元素，使其变为空集合。
copy(): 返回集合的一个副本。
update(): 将指定集合中的所有元素添加到原始集合中。
intersection_update(): 修改当前集合，使其只包含与指定集合相交的元素。
difference_update(): 修改当前集合，使其仅包含不在指定集合中的元素。
symmetric_difference_update(): 修改当前集合，使其包含不同时存在于当前集合和指定集合中的元素。
# 创建一个集合
my_set = {1, 2, 3, 4, 5}
# add() 方法：向集合中添加元素
my_set.add(6)
print("add() 方法后的集合:", my_set) # 输出结果: {1, 2, 3, 4, 5, 6}
# remove() 方法：从集合中移除指定的元素
my_set.remove(3)
print("remove() 方法后的集合:", my_set) # 输出结果: {1, 2, 4, 5, 6}
# discard() 方法：从集合中移除指定的元素，如果元素不存在则不做任何操作
my_set.discard(2)
print("discard() 方法后的集合:", my_set) # 输出结果: {1, 4, 5, 6}
# pop() 方法：随机移除并返回一个元素
popped_element = my_set.pop()
print("pop() 方法返回的元素:", popped_element) # 输出结果: popped_element 是被移除的元素，如：1
print("pop() 方法后的集合:", my_set) # 输出结果: {4, 5, 6}
# clear() 方法：移除集合中的所有元素
my_set.clear()
print("clear() 方法后的集合:", my_set) # 输出结果: set()
# 创建一个新集合
my_set2 = {4, 5, 6, 7}
# copy() 方法：返回集合的一个副本
copy_set = my_set2.copy()
print("copy() 方法返回的集合:", copy_set) # 输出结果: {4, 5, 6, 7}
# update() 方法：将指定集合中的所有元素添加到原始集合中
my_set2.update({8, 9})
print("update() 方法后的集合:", my_set2) # 输出结果: {4, 5, 6, 7, 8, 9}
# intersection_update() 方法：修改当前集合，使其只包含与指定集合相交的元素
my_set2.intersection_update({6, 7, 8})
print("intersection_update() 方法后的集合:", my_set2) # 输出结果: {6, 7, 8}
# difference_update() 方法：修改当前集合，使其仅包含不在指定集合中的元素
my_set2.difference_update({6, 7})
print("difference_update() 方法后的集合:", my_set2) # 输出结果: {8}
# symmetric_difference_update() 方法：修改当前集合，使其包含不同时存在于当前集合和指定集合中的元素
my_set2.symmetric_difference_update({8, 9, 10})
print("symmetric_difference_update() 方法后的集合:", my_set2) # 输出结果: {9, 10}
集合的不可变性
集合本身是可变的，但集合中的元素必须是不可变的。因此，集合中不能包含可变对象（如列表），但可以包含不可变对象（如整数、字符串、元组）。
其他操作
len()：返回集合中元素的个数。in：判断元素是否存在于集合中
三、元组
元组（Tuple）是Python中的一种数据结构，类似于列表（List），但具有一些重要的区别。元组是不可变的，意味着一旦创建，其内容就不能被修改、添加或删除。元组使用圆括号 () 来定义，其中的元素通过逗号 , 分隔。
创建元组
my_tuple = (1, 2, 3, 'a', 'b')
访问元组
在元组中，可以包含不同类型的数据，包括数字、字符串等。可以通过索引访问元组中的元素，索引从0开始，例如：
print(my_tuple[0]) # 输出: 1
print(my_tuple[3]) # 输出: 'a'
嵌套元组的定义
可以在一个元组中嵌套另一个元组，形成多层嵌套结构。例如：
nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
nested_tuple 是一个包含了三个元组的元组，每个元组都包含了三个整数
嵌套元组的访问
访问嵌套元组中的元素可以通过多层索引来实现。例如，要访问嵌套元组中的第一个元组的第一个元素，可以使用以下语法：
element = nested_tuple[0][0]
print(element) # 输出: 1
'''如果看懂了列表的这部分内容，你会惊讶的发现，其实差不多的,链式索引
'''嵌套元组的应用
嵌套元组在表示多维数据结构时非常有用，例如表示二维数组、矩阵等。同时，嵌套元组还可以与其他数据类型（如列表、字典等）一起使用，构建更复杂的数据结构。
matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
# 计算矩阵的行数和列数
num_rows = len(matrix)
num_cols = len(matrix[0])
print(f"矩阵的行数为：{num_rows}")
print(f"矩阵的列数为：{num_cols}")
matrix 是一个包含了三个元组的元组，表示一个 3x3 的矩阵。通过嵌套元组，我们可以方便地对矩阵进行操作和处理
切片
元组支持切片操作，可以使用 : 来获取元组的子集，例如：
print(my_tuple[1:4]) # 输出: (2, 3, 'a')
尝试修改元组
元组不可变意味着一旦创建，不能修改其内容，试图修改元组会导致错误：
my_tuple[0] = 10 # TypeError: 'tuple' object does not support item assignment元组的不可变性使其在某些情况下比列表更加安全和高效。通常用于存储固定集合的数据，例如函数返回多个值时，或者作为字典的键值对。
count(): 返回指定元素在元组中出现的次数。my_tuple = (1, 2, 3, 2, 4, 2) print(my_tuple.count(2)) # 输出: 3
2.index(): 返回指定元素在元组中第一次出现的索引。my_tuple = ('a', 'b', 'c', 'b', 'd') print(my_tuple.index('b')) # 输出: 1如果元素不存在，则会引发
ValueError。这就是元组对象的所有方法。虽然元组没有类似于列表的修改方法，但这些方法允许对元组进行一些查询操作。
修改元组
虽然元组是不可变的，但是如果需要修改元组的内容，可以考虑创建一个新的元组，将需要修改的部分替换掉，并重新赋值给原变量。
# 定义原始元组
t8 = ("小lo爱吃棒棒糖", "点赞关注", "点赞关注", "Python")
print(f"原始的t8内容是：{t8}")
# 创建一个新的元组来替换需要修改的部分
new_element = "你好，程序员"
modified_t8 = (new_element,) + t8[1:] # 将原始元组的第一个元素替换为 "你好，程序员"
print(f"修改后的t8内容是：{modified_t8}")
遍历元素所有值
要遍历元组中的所有值，可以使用循环结构，如 for 循环。允许逐个访问元组中的每个元素。
my_tuple = (1, 2, 3, 'a', 'b')
for value in my_tuple:
print(value)
这将输出元组中的每个值：
1
2
3
a
b
value 是循环迭代时的变量名，它会依次获取元组中的每个值。
四、字典
字典是一种无序、可变、有键的集合，它存储的是键值对。我下面会详细讲解字典的用法。这也叫做映射，理解为一一对应。
1. 创建字典
可以使用大括号 {} 或 dict() 构造函数来创建字典。每个键值对用冒号 : 分隔，键与值之间用逗号 , 分隔。
# 使用大括号创建字典
my_dict = {"name": "Alice", "age": 30, "city": "New York"}
# 使用 dict() 构造函数创建字典
another_dict = dict(name="Bob", age=25, city="San Francisco")
映射：使用字典（dictionary）进行映射操作
# 创建一个字典，将一些水果与它们的颜色进行映射
fruit_colors = {
"apple": "red",
"banana": "yellow",
"grape": "purple"
}
# 访问字典中的值
print(fruit_colors["apple"]) # 输出: red
print(fruit_colors["banana"]) # 输出: yellow
# 添加新的映射关系
fruit_colors["orange"] = "orange"
# 打印所有的键-值对
for fruit, color in fruit_colors.items():
print(f"{fruit} is {color}")
2. 字典的基本操作
访问字典中的元素：通过键来访问对应的值。
print(my_dict["name"]) # 输出：Alice
添加新的键值对：直接通过赋值语句添加新的键值对。
my_dict["email"] = "alice@example.com"
删除键值对：使用
del关键字或pop()方法删除键值对。del my_dict["city"] # 删除键为 "city" 的键值对 removed_age = my_dict.pop("age") # 删除键为 "age" 的键值对，并返回对应的值
3.字典的方法
获取所有键或所有值：使用
keys()、values()方法分别获取所有键或所有值。keys = my_dict.keys() # 获取所有键 values = my_dict.values() # 获取所有值
获取键值对：使用
items()方法获取所有键值对，返回一个包含元组的视图。items = my_dict.items() # 获取所有键值对
清空字典：使用
clear()方法清空字典中的所有元素。my_dict.clear() # 清空字典检查键是否存在：使用 in 关键字检查字典中是否存在指定的键。
if "key" in my_dict: print("Key exists in the dictionary")删除指定键值对：使用 del 关键字或 pop() 方法删除指定键值对
del my_dict["key"] # 删除指定键值对 value = my_dict.pop("key") # 删除指定键值对并返回对应的值获取并移除最后一个键值对：使用 popitem() 方法。
last_key, last_value = my_dict.popitem() # 获取并移除最后一个键值对
4. 字典的遍历
可以使用 for 循环遍历字典的键、值或键值对。
# 遍历键
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)
5.字典的嵌套
字典中的值可以是任何数据类型，包括字典本身，从而实现嵌套结构。
nested_dict = {
"person": {
"name": "John",
"age": 30,
"city": "London"
},
"company": {
"name": "XYZ Corp",
"location": "New York"
}
}
6.字典的合并
使用 update() 方法将一个字典的键值对更新到另一个字典中。
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
dict1.update(dict2) # 将 dict2 合并到 dict1 中
print(dict1) # 输出：{'a': 1, 'b': 3, 'c': 4}
7.默认值
使用 get() 方法获取字典中的值，如果键不存在，可以指定默认值。
my_dict = {"name": "Alice", "age": 30}
print(my_dict.get("city", "Unknown")) # 获取键为 "city" 的值，如果不存在返回 "Unknown"
那么，这一期的 大学生python课程自救 —— 06 数据类型 就结束了，后续我会继续更新请大家耐心等待！如果讲的有错或者不懂，欢迎大家评论区讨论！
前面章节可看：
大学生python课程自救 —— 03 控制流-CSDN博客
大学生python课程自救——02 运算符与表达式-CSDN博客
2552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
