Python（第三章）容器

目录

一、列表(List)

1、创建列表

2、访问元素

3、切片

4、列表的相关操作

4.1、append(item)

 4.2、extend(iterable)

4.3、insert(index, item)

4.4、remove(item)

4.5、pop([index])

4.6、index(item[, start[, end]])

4.7、count(item)

4.8、sort()

4.9、reverse()

 5、列表推导式

二、元组 

1、定义元组

2、访问元组元素

3、元组的不可变性

4、元组方法

5、解包元组

6、连接和重复元组

三、集合 

1、创建集合

2、集合的常用操作

3、非变集合（Frozen Set）

四、字典 

1、创建字典以及常用操作

---

一、列表(List)

1、创建列表

语法：
变量 = [值1,值2,...]

示例：

a_list = [1,10.0,"张三",True]
# 一个列表中可以包括多种数据类型

2、访问元素

# 可通过索引访问列表中的元素，Python中的索引从0开始
a = a_list[0]

3、切片

切片（Slicing）是一种访问序列类型（如列表、元组、字符串等）中连续子序列的强大方式。切片允许你提取序列的一部分而无需知道确切的元素个数。就是可以截取你所需要显示的内容输出出来

基本语法：

# sequence[start:stop:step]
# start：从这个索引开始切片。默认为0，如果省略。
# stop：切片会一直持续到这个索引之前停止，但不会包括这个索引处的元素。如果省略，则会一直切到序列的末尾。
# step：每step个元素取一次，用于跳过某些元素。默认为1，如

示例：

# 首先创建一个列表
b_list = [1,2,3,4,5,6,7,8,9]

# 获取前三个元素
print(b_list[:3]) #输出：[1, 2, 3]

# 获取从第二个到最后一个元素
print(b_list[1:]) #输出：[2, 3, 4, 5, 6, 7, 8, 9]

# 获取第二个到第五个元素（但是不包括第五元素）
print(b_list[1:5]) #输出：[2, 3, 4, 5]

# 使用步长
print(b_list[::2]) #输出：[1, 3, 5, 7, 9]

# 反向切片
print(b_list[::-1]) #输出：[9, 8, 7, 6, 5, 4, 3, 2, 1]

# 从倒数第二个元素开始反向每隔一个元素获取
print(b_list[::-2]) #输出：[9, 7, 5, 3, 1]

4、列表的相关操作

4.1、append(item)

在列表末尾添加一个新元素

c_list = [1, 2, 3]
c_list.append(4)
print(c_list)  # 输出: [1, 2, 3, 4

 4.2、extend(iterable)

将另一个序列或迭代器中的元素添加到列表中。

d_list = [1, 2, 3]
d_list.extend([4, 5])
print(d_list)  # 输出: [1, 2, 3, 4, 5]

4.3、insert(index, item)

在指定位置插入一个元素。

e_list = [1, 2, 3]
e_list.insert(1, 'a')
print(e_list)  # 输出: [1, 'a', 2, 3]

4.4、remove(item)

移除列表中第一次出现的指定值。

f_list = [1, 2, 3, 2, 4]
f_list.remove(2)
print(f_list)  # 输出: [1, 3, 2, 4]  注意: 第一个2被移除

4.5、pop([index])

移除并返回指定位置的元素，默认移除并返回最后一个元素。

g_list = [1, 2, 3, 4]
item = g_list.pop()
print(item)  # 输出: 4
print(g_list)  # 输出: [1, 2, 3]

item = g_list.pop(1)
print(item)  # 输出: 2

4.6、index(item[, start[, end]])

返回元素在列表中第一次出现的位置。

h_list = [1, 2, 3, 2, 4]
index = h_list.index(2)
print(index)  # 输出: 1

4.7、count(item)

返回列表中特定元素的出现次数。

i_list = [1, 2, 3, 2, 4]
count = i_list.count(2)
print(count)  # 输出: 2

4.8、sort()

对列表进行排序。

j_list = [3, 1, 4, 1, 5, 9, 2, 6]
j_list.sort()
print(j_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

4.9、reverse()

反转列表中的元素顺序。

k_list = [1, 2, 3, 4]
k_list.reverse()
print(k_list)  # 输出: [4, 3, 2, 1]

 5、列表推导式

基本语法
列表推导式的语法如下：

# new_list = [expression for item in iterable if condition]
# expression 是基于item计算得到的新列表中的元素。
# item 是从iterable中获取的每个元素。
# iterable 是一个可迭代的对象，如列表、元组、字符串等。
# if condition 是可选的，用于过滤iterable中的元素，只有满足条件的元素才会被加入到新列表中。

示例
假设我们有一个列表numbers，并且我们想要创建一个新的列表，其中包含numbers中所有偶数的平方

numbers = [1, 2, 3, 4, 5, 6]
# 这里可以分成几段去理解，首先是for循环，先把列表里的数逐一给num ，再用if判断，符合条件的值才进行操作并输出
squares_of_even = [num ** 2 for num in numbers if num % 2 == 0]
print(squares_of_even)  # 输出: [4, 16, 36]

多重循环
列表推导式还可以包含多个for循环，以处理嵌套的可迭代对象

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
combined = [(x, y) for x in list1 for y in list2]
print(combined)
# combined = [(x, y) for x in list1 for y in list2]等同于
# for x in list1:
#     for y in list2:
#         combined = (x,y)
#         print(combined)
# 输出: [(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]

二、元组 

元组（Tuple）是一种不可变的序列类型。这意味着一旦创建了一个元组，你就不能修改它的内容，例如增加、删除或改变其中的元素。

1、定义元组

使用圆括号 () 来创建元组，例如：my_tuple = (1, 2, 3)
如果元组只有一个元素，需要在元素后面加上逗号 ,，例如：single_element_tuple = (42,)
coordinates = (10, 20, 30)

2、访问元组元素

使用索引访问元组中的元素，例如：first_element = my_tuple[0]
Python中的索引从0开始，负数索引表示从末尾开始计数。

x = coordinates[0]
y = coordinates[1]
z = coordinates[2]

print("X:", x)
print("Y:", y)
print("Z:", z)

3、元组的不可变性

由于元组是不可变的，你不能对它执行如列表那样的修改操作，例如：my_tuple[0] = 5

4、元组方法

元组没有像列表那样的许多内置方法，但你可以使用 len() 函数来获取长度，以及 count() 和 index() 方法来查找元素的出现次数和位置。

# len() 函数来获取长度
print(len(coordinates))
# 结果：3

# count()：
# 这个方法返回元组中某个元素出现的次数。
t = ('apple', 'banana', 'cherry', 'apple')
print(t.count('apple'))  # 输出: 2

# index()：
# index() 方法返回给定元素在元组中第一次出现的索引。如果元素不在元组中，它会引发一个异常。
t1 = ('apple', 'banana', 'cherry')
print(t1.index('banana'))  # 输出: 1

# sorted()：对元组进行排序，但返回的是一个新的列表，因为元组是不可变的。
t2 = ('apple', 'banana', 'cherry')
sorted_t = sorted(t2)
print(sorted_t)  # 输出: ['apple', 'banana', 'cherry']

# min() 和 max()：分别返回元组中的最小和最大元素。
t3 = (1, 3, 2, 5, 4)
print(min(t3))  # 输出: 1
print(max(t3))  # 输出: 5

# any() 和 all()：分别检查元组中是否有任何一个元素为真，和所有元素是否都为真。
t4 = (True, False, True)
print(any(t4))  # 输出: True
print(all(t4))  # 输出: False

5、解包元组

可以将元组中的元素赋给多个变量，例如：a, b, c = my_tuple

a, b, c = coordinates

# 输出解包后的变量
print("A:", a)
print("B:", b)
print("C:", c)
# 结果：
# A: 10
# B: 20
# C: 30

6、连接和重复元组

使用 + 运算符连接两个元组，例如：new_tuple = my_tuple + another_tuple
使用 * 运算符重复元组，例如：repeated_tuple = my_tuple * 3

# 连接元组
new_coordinates = coordinates + (40,)

# 输出新元组
print("New Coordinates:", new_coordinates)
# 输出：New Coordinates: (10, 20, 30, 40)

# 重复元组
repeated_coordinates = coordinates * 2

# 输出重复元组
print("Repeated Coordinates:", repeated_coordinates)
# 输出：
# Repeated Coordinates: (10, 20, 30, 10, 20, 30)

三、集合 

集合（Set）是一种无序的、不重复的数据结构。集合中的元素是唯一的，这意味着集合不允许有重复的元素，而且集合中的元素没有固定的顺序。

1、创建集合

你可以使用大括号 {} 或者 set() 函数来创建一个集合：

# 使用大括号创建集合
my_set = {1, 2, 3, 4}

# 使用 set() 函数创建集合
another_set = set([1, 2, 2, 3, 4, 4])

# 输出集合
print(my_set)  # 输出是 {1, 2, 3, 4}
print(another_set)  # 输出是 {1, 2, 3, 4}
# 注意：我们在列表中包含了重复的元素，但当转换为集合时，重复的元素会被自动去除。

2、集合的常用操作

添加元素：使用 add() 方法
移除元素：使用 remove() 或 discard() 方法
查找元素：使用 in 关键字
求交集：使用 & 运算符或 intersection() 方法
求并集：使用 | 运算符或 union() 方法
求差集：使用 - 运算符或 difference() 方法
求对称差集：使用 ^ 运算符或 symmetric_difference() 方法

# 创建集合
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# 添加元素
set_a.add(5)

# 移除元素
set_a.remove(1)

# 查找元素
print(2 in set_a)  # 输出: True

# 求交集
print(set_a & set_b)  # 输出: {3, 4}  返回的是两个集合共有的元素

# 求并集
print(set_a | set_b)  # 输出: {2, 3, 4, 5, 6} 返回的是所有在 set_a 或者 set_b 中出现过的元素的集合，但是会去除重复的元素。

# 求差集
print(set_a - set_b)  # 输出: {2} 返回的是在 set_a 中存在但在 set_b 中不存在的所有元素。

# 求对称差集
print(set_a ^ set_b)  # 输出: {2, 5, 6}  返回的是在 set_a 或 set_b 中出现过，但不在两个集合都出现过的元素的集合。换句话说，它返回的是 set_a 和 set_b 差集的并集。

3、非变集合（Frozen Set）

除了常规的集合外，Python还提供了 frozenset 类型，它是不可变的集合，这意味着一旦创建就无法更改。

# 创建非变集合
frozen_set = frozenset({1, 2, 3})

# 尝试添加元素（将会抛出异常）
frozen_set.add(4)  # TypeError: 'frozenset' object has no attribute 'add'

四、字典 

字典（dictionary）是一种可变容器模型，它存储键值对，其中键是唯一的且不可变类型，而值可以是任何类型的数据。字典使用花括号 {} 创建，并且键和值之间用冒号 : 分隔。

1、创建字典以及常用操作

# 创建一个字典
my_dict = {'apple': 3, 'banana': 5, 'orange': 2}
print(my_dict)
# 输出：
# {'apple': 3, 'banana': 5, 'orange': 2}

# 访问字典中的值
apple_count = my_dict['apple']
print(apple_count)
# 输出：3

# 修改字典中的值
my_dict['banana'] = 4
print(my_dict)
# 输出：
# {'apple': 3, 'banana': 4, 'orange': 2}

# 添加一个新的键值对
my_dict['grape'] = 7
print(my_dict)
# 输出：{'apple': 3, 'banana': 4, 'orange': 2, 'grape': 7}

# 删除一个键值对
del my_dict['orange']
print(my_dict)
# 输出：{'apple': 3, 'banana': 4, 'grape': 7}

# 检查字典中是否包含某个键
has_grape = 'grape' in my_dict
print(has_grape)
# 输出：
# True

# 获取字典的长度
length = len(my_dict)
print(length)
# 输出：3

# 遍历字典
keys_and_values = [(k, v) for k, v in my_dict.items()]
print(keys_and_values)

# 复制字典
new_dict = my_dict.copy()
print(new_dict)

# 清空字典
my_dict.clear()


# 使用get方法安全地访问字典
# 那么使用get()方法时，如果没有指定默认值，它会返回None
# nonexistent_fruit_count = my_dict.get('orange')
# 如果你希望在'orange'不存在于字典中时返回一个特定的值（比如0）
nonexistent_fruit_count = my_dict.get('apple', 0)  # 如果'orange'不存在，则返回0
print(nonexistent_fruit_count)