数据容器 概述

在Python中，用来存放多个数据的东西，叫做“数据容器”。

数据容器的特点：

• 数据容器，有时也简称为容器。
• 数据容器可以存放多个数据，每个数据也被称为一个元素。
• 数据容器中的元素可以是任意类型。
• 数据容器会给我们提供多种操作元素的的方法。

Python中常用的数据容器：

列表（List）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

下文逐个详细介绍。

什么是列表

列表用来存放一组有序的数据，并且可以对其中的数据进行增删改查。

定义列表

语法格式：使用方括号[]来定义一个列表，不同元素之间,去分隔。

[元素0, 元素1, 元素2, 元素3, 元素4, ......]

示例代码：

# 定义有内容的列表
list1 = [34, 56, 21, 56, 11]
list2 = ['北京', '尚硅谷', '你好啊']
list3 = [23, '尚硅谷', True, None]
list4 = [23, '尚硅谷', True, None, [100, 200, 200]]

# 定义空列表（类表中的数据，后期会通过特定写法填充）
list5 = []
list6 = list()

print(list1, type(list1))
print(list2, type(list2))
print(list3, type(list3))
print(list4, type(list4))
print(list5, type(list5))
print(list6, type(list6))

下标（索引值）

下标又叫索引值，其实就是元素在列表中的“位置编号”，分为：正索引和负索引。

下标最直接的用途就是：从列表中读取元素。

# 定义一个列表
nums = [1, 2, 3, 4, 5]

# 测试正索引
print(nums[0])
print(nums[1])
print(nums[2])
print(nums[3])
print(nums[4])

print() # 换行

# 测试负索引
print(nums[-1])
print(nums[-2])
print(nums[-3])
print(nums[-4])
print(nums[-5])

# 测试错误索引
# print(nums[-6])

# 定义一个嵌套列表
nums2 = [10, 20, ['你好啊', '尚硅谷'], 40, 50]
print(nums2[2])
print(nums2[2][1])

注意：通过下标取值时，下标不要超出范围，否则会报错。

列表的增删改查

新增

列表的新增是指向列表中添加元素，主要有以下三种方式：

• 使用列表.append(元素)，在 列表尾部追加一个元素。
• 使用列表.insert(下标，元素)，在列表指定下标处插入一个元素。
• 使用列表.extend(可迭代对象)，将可迭代对象中的内容依次取出，追加到列表尾部。

示例代码：

nums = [10, 20, 30, 40, 50]
nums.append(60)
nums.insert(2, 25)
nums.extend([100, 200, 300])
nums.extend((range(301, 305)))
nums.extend('远方')
print(nums)
# 输出结果如下：
# [10, 20, 25, 30, 40, 50, 60, 100, 200, 300, 301, 302, 303, 304, '远', '方']

删除

主要有以下四种删除方式：

• 使用列表.pop(下标)，删除指定位置的元素，并将删除的元素返回。
• 使用列表.remove(值)，删除列表中第一次出现的指定值。
• 使用列表.clear()，删除列表中所有的元素（变成一个空列表）。
• 使用del 列表[下标]，删除指定位置的元素。

示例代码：

nums1 = [10, 20, 10, 40, 50]
result = nums1.pop(1)
print(result, nums1) # 20 [10, 10, 40, 50]

nums2 = [10, 20, 10, 40, 50]
nums2.remove(10) # 注意：remove方法只删除列表中第一次出现的指定值
print(nums2) # [20, 10, 40, 50]

nums3 = [10, 20, 10, 40, 50]
nums3.clear()
print(nums3) # []

nums4 = [10, 20, 10, 40, 50]
del nums4[3]
print(nums4) # [10, 20, 10, 50]

修改

修改的操作比较简单，主要是通过下标进行修改，语法为：列表[下标] = 值。示例代码如下：

nums5 = [10, 20, 10, 40, 50]
nums5[2] = 30
print(nums5) # [10, 20, 30, 40, 50]

查询

通过下标进行读取元素，语法为：列表[下标]。示例代码如下：

nums5 = [10, 20, 10, 40, 50]
print(nums5[2]) # 10

列表常用的方法

除了上面的增删改查的方法，列表还有很多其他常用的方法：

使用列表.index(值)，查找指定元素在列表中第一次出现的下标，返回值是元素下标。示例代码如下：

languages = ['Python', 'Java', 'C++']
result = languages.index('Python')
print(result) # 0

使用列表.count(值)，统计某个元素在列表中出现的次数，返回值是：元素出现的次数。示例代码如下：

nums6 = [10, 20, 10, 30, 10, 40, [10, 10, 10]]
result = nums6.count(10)
print(result) # 3

使用列表.reverse()，反转列表（会改变原列表），无需参数，无返回值。示例代码如下：

nums7 = [23, 11, 32, 30, 17, [6, 7, 8, 9]]
nums7.reverse()
print(nums7)

使用列表.sort(reverse=布尔值)，对列表排序（默认从小到大，会改变原列表），reverse 用于控制排序方式（设置为 True 从大到小），无返回值。需要注意如下事项：

• 若列表中的元素：都是数字，则按照数字的大小顺序排序。
• 若列表中的元素：既有数字，又有字符串，就会报错。
• 若列表中的元素：都是字符串，则按照字符串的 Unicode 编码大小进行排序。

示例代码如下：

nums8 = [23, 11, 32, 30, 17]
nums8.sort()
print(nums8) # [11, 17, 23, 30, 32]
nums8.sort(reverse=True)
print(nums8) # [32, 30, 23, 17, 11]

strs = ['太原', '远方', '你好']
strs.sort() # ['你好', '太原', '远方']
print(strs)
print('太', ord('太'), '远', ord('远'), '你', ord('你')) # 太 22826 远 36828 你 20320

特别说明：

所有列表的方法，都只作用于“当前层”的元素（浅层操作），不会自动进入嵌套的“里层”结构中。

列表常用的内置函数

需知：上面列表中的内置函数，不仅只用于列表，而且适用于：所有数据容器。

sorted 对容器排序

sorted(数据容器, reverse=布尔值)，对容器排序（默认从小到大，reverse设置为True为从大到小，不会改变原容器），返回值为经过排序的新容器。

• 若容器中的元素都是数字，则按照数字的大小顺序进行排序。

nums = [23, 11, 32, 30, 17]
result = sorted(nums)
print(result) # [11, 17, 23, 30, 32] 从小到大
print(nums)   # [23, 11, 32, 30, 17]
result = sorted(nums, reverse=True)
print(result) # [32, 30, 23, 17, 11] 从大到小
print(nums)   # [23, 11, 32, 30, 17]

• 若容器中的元素既有数字，又有字符串，那就会报错。

nums = [23, 11, 32, 30, 17, '大龄程序员一枚']
sorted(nums)
# 运行代码报错如下：
# Traceback (most recent call last):
#  File "E:\www.py\basic\chapter04.py", line 115, in <module>
#    sorted(nums)
# TypeError: '<' not supported between instances of 'str' and 'int'

• 若容器中的元素都是字符串，则按照字符串的 Unicode 编码大小进行排序。

msg_list = ['太原', '远方', '你好']
result = sorted(msg_list)
print(result)     # ['你好', '太原', '远方'] 从小到大
print(msg_list)   # ['太原', '远方', '你好']
result = sorted(msg_list, reverse=True)
print(result)     # ['你好', '太原', '远方'] 从大到小
print(msg_list)   # ['太原', '远方', '你好']
print(f'太{ord('太')} 远{ord('远')} 你{ord('你')}')

len 获取容器大小

len(数据容器)，获取容器中元素的总数量，返回值：元素的总数量。

nums = [10, 20, 10, 30, 10, 40, [50, 60, 70]]
result = len(nums)
print(result) # 7

max 获取容器 或 多个值中的最大值

nums = [10, 20, 30, 40]
print(max(nums)) # 40
print(max(10, 20, 30, 40)) # 40

min 获取容器 或 多个值中的最小值

nums = [10, 20, 30, 40]
print(min(nums)) # 10
print(min(10, 20, 30, 40)) # 10

sum 对容器中所有元素求和

nums = [10, 20, 30, 40]
print(sum(nums)) # 100

列表的循环遍历

所谓遍历，就是将列表的每个元素依次取出来进行处理。

使用 while 循环遍历列表

score_list = [62, 50, 60, 48, 80, 20, 95]

index = 0
while index < len(score_list):
    print(score_list[index])
    index += 1

使用 for 循环遍历列表

score_list = [62, 50, 60, 48, 80, 20, 95]

for score in score_list:
    print(score)

for index in range(len(score_list)):
    print(score_list[index])

for 循环的遍历，不需要 index，如果需要，可以借助enumerate这个内置函数，它可以在遍历的时候获取索取索引和值，示例代码如下：

# enumerate 的 start 参数，可以让计数从指定值开始（改变的是循环时的“编号”，不是真正的索引值）
for index, item in enumerate(score_list, start=5):
    print(index, item, score_list[0])
print('最后的打印', score_list[0])

# 打印结果：
# 5        62    62    
# 6        50    62    
# 7        60    62    
# 8        48    62    
# 9        80    62    
# 10    20    62    
# 11    95    62    
# 最后的打印 62

# 不设置 start 参数的，打印结果如下：
# 0        62    62    
# 1        50    62    
# 2        60    62    
# 3        48    62    
# 4        80    62    
# 5        20    62    
# 6        95    62    
# 最后的打印 62

列表的特点总结

• 可存放不同类型的元素。
• 元素是有序存储的（正索引、负索引）。
• 列表中的元素允许重复。
• 元素是允许修改的（增、删、改、查、其他操作）。
• 长度不固定，可以随着操作自动调整大小。

总结：列表是最常用的数据容器，当遇到要“存储一批数据”的场景时，首选列表。