python学习笔记----数据容器（六）

一、数据容器的入门

• python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素。
• 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为5类，分别是：

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

二、列表（list）

2.1 列表的定义

语法：

# 字面量
[元素1, 元素2, 元素3, 元素4, ...]

# 定义变量
变量名 = [元素1, 元素2, 元素3, 元素4, ...]

# 定义空列表
变量名 = []
变量名 = list()

列表内的每一个数据，称之为元素

示例：

# 定义一个列表 list
my_list = ["zhangsan", "lisi", "wangwu"]
print(my_list)

my_list = ["zhangsan", 666, True]
print(my_list)

# 定义一个嵌套列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)

• 元素的数据类型没有任何限制，甚至元素也可以是列表

2.2 列表的下标索引

• 列表的一个重要特性是能够通过下标索引（也称为数组索引）来访问、修改或操作它的元素。
  
• 反向索引
  

示例

假设有一个列表如下：

my_list = ['apple', 'banana', 'cherry', 'date']

• 访问元素：

print(my_list[0])   # 输出 'apple'
print(my_list[3])   # 输出 'date'
print(my_list[-1])  # 输出 'date'（使用反向索引）

• 索引越界：

print(my_list[4])  # IndexError: list index out of range

2.3 嵌套列表的下标索引

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

这个例子可以看作是一个 3x3 的矩阵：

第一行是 [1, 2, 3]
第二行是 [4, 5, 6]
第三行是 [7, 8, 9]

• 访问第一行：

first_row = nested_list[0]
print(first_row)  # 输出: [1, 2, 3]

• 访问第一行的第一个元素

first_item = nested_list[0][0]
print(first_item)  # 输出: 1

• 访问第三行的第三个元素：

last_item = nested_list[2][2]
print(last_item)  # 输出: 9

2.4 列表的常用操作（方法）

列表除了可以：

• 定义
• 使用下标索引

列表也提供了一系列功能：

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数等

这些功能我们都称之为：列表的方法

查询某元素的下标

功能： 查找指定元素在列表里的下标，如果找不到，报错VlaueError

语法：列表.index(元素)

示例：

my_list = ["zhangsan", "lisi", "wangwu"]

index = my_list.index("zhangsan")
print(index)

修改特定位置（索引）的元素值：

语法：列表[下标] = 值

示例：

my_list = ["zhangsan", "lisi", "wangwu"]

my_list[0] = "张三"
print(my_list)

插入元素

• 在指定的下标位置，插入元素

语法：列表.insert(下标, 元素)

示例

my_list = ["zhangsan", "lisi", "wangwu"]

my_list.insert(1,"apple")
print(my_list)

追加元素

• 将元素追加到列表的尾部

语法：列表.append(元素)

示例：

my_list = ["zhangsan", "lisi", "wangwu"]

my_list.append("apple")
print(my_list)

追加元素2

• 追加多个元素到列表尾部

语法：列表.extend(其他数据容器)

示例：

my_list = ["zhangsan", "lisi", "wangwu"]

my_list.extend(["apple", "banana","pear"])
print(my_list)

删除元素

语法1：del 列表[下标]

示例：

my_list = ["zhangsan", "lisi", "wangwu"]

del my_list[0]
print(my_list)

语法2：列表.pop(下标)

• pop可以删除列表中指定位置的元素，并返回被删除的元素

示例：

my_list = ["zhangsan", "lisi", "wangwu"]

element = my_list.pop(0)
print(my_list)
print(element)

删除某元素在列表中的第一个匹配项

语法：列表.remove(元素)

示例：

my_list = ["zhangsan", "lisi", "wangwu", "zhangsan"]

my_list.remove("zhangsan") #从前往后搜索，删除第一个匹配项
print(my_list)

清空列表

语法：列表.clear()

示例：

my_list = ["zhangsan", "lisi", "wangwu", "zhangsan"]

my_list.clear()
print(my_list)

统计某元素在列表内的数量

语法： 列表.count(元素)

示例：

my_list = ["zhangsan", "lisi", "wangwu", "zhangsan"]

count = my_list.count("zhangsan")
print(count)

统计列表内，有多少元素

语法: len(列表)

示例：

my_list = ["zhangsan", "lisi", "wangwu", "zhangsan"]

count = len(my_list)
print(count)

三、tuple（元组）

元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：

• 元组一旦定义完成，就不可修改

3.1 元组的定义语法

# 定义元组字面量
(元素, 元素, ..., 元素)
# 定义元组变量
变量名 = (元素, 元素, ..., 元素)
# 定义空元组
变量名 = ()        # 方式1
变量名 = tuple ()  # 方式2

• 和list基本相同（有序，任意数量元素，允许重复元素），唯一不同在于不可修改
  

四、str（字符串）

4.1 字符串的下标（索引）

和列表、元组一样，字符串也可以通过下标进行访问

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

示例：

my_str = "zhang san"
value1 = my_str[2]
value2 = my_str[-7]
print(value1)
print(value2)

同元组一样，字符串是一个：无法修改的容器。

五、（序列）的切片

序列是指：内容连续、有序、可使用下表索引的一类数据容器

• 列表、元组、字符串，均可视为序列。
  

5.1 序列的常用操作- 切片

• 序列支持切片，即：列表、元组、字符串，均支持进行切片操作
• 切换：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  - 步长1表示，一个个取元素
  - 步长2表示，每次跳过1个元素取
  - 步长N表示，每次跳过N-1个元素取
  - 步长为负数表示，反向取（注意，起始小标和节数下标也要反向标记）

示例：

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]  # 步长默认是1，可以省略不写
print(result1)

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(result2)

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(result3)

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]  # 等同于将序列反转了
print(result4)

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(result5)

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(result6)

六、set（集合）

集合最主要的特点是：不支持元素的重复（自带去重功能）、并且内容无序

语法：

# 定义集合字面量
{元素, 元素, ..., 元素}

# 定义集合变量
变量名 = {元素, 元素, ..., 元素}

# 定义空集合
变量名 = set()

6.1 集合常用操作

• 因为集合是无序的，所以集合不支持下标索引访问。

6.1.1 添加新元素

语法：集合.add(元素)

my_set = {"zhangsan", "lisi", "wangwu"}

my_set.add("apple")
print(my_set)

6.1.2 移除元素

语法：集合.remove(元素)

示例：

my_set = {"zhangsan", "lisi", "wangwu"}

my_set.remove("zhangsan")
print(my_set)

6.1.3 从集合中随机取出元素

• 从集合中随机取出元素，同时集合本身被修改，元素被移除
  语法： 集合.pop()

示例：

my_set = {"zhangsan", "lisi", "wangwu"}

element = my_set.pop()
print(element)  # lisi
print(my_set)   # {'zhangsan', 'wangwu'}

6.1.4 取出两个集合的差集

语法： 集合1.difference(集合2)

• 功能：取出集合1和集合2的差集（集合1有而集合2没有的）
• 结果：得到一个新集合，集合1和集合2不变

示例：

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set3)     # {2, 3}
print(set1)     # {1, 2, 3}
print(set2)     # {1, 2, 3}

6.1.5 消除两个集合的差集

语法：集合1.difference_update(集合2)

• 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
• 结果：集合1被修改，集合2不变

示例：

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)

print(set1)     # {2, 3}
print(set2)     # {1, 5, 6}

6.1.6 两个集合合并

语法： 集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}

set3 = set1.union(set2)
print(set3)     # {1, 2, 3, 5, 6}
print(set1)     # {1, 2, 3}
print(set2)     # {1, 5, 6}

6.1.7 集合的遍历

• 集合不支持下表索引，所以不能用while循环
• 可以用for循环遍历

set1 = {1, 2, 3, 5, 6}

for element in set1:
    print(f"集合的元素有：{element}")

七、dict（字典、映射）

7.1 字典的定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对
语法：

# 定义字典字面量
{key:value, key:value, ..., key:value}

# 定义字典变量
my_dict = {key:value, key:value, ..., key:value}

# 定义空字典
my_dict = {}     # 方式1 
my_dict = dict() # 方式2

• 键（key）必须是唯一的。如果你尝试在字典中使用重复的键定义或添加元素，那么新的值将覆盖原有键对应的值。字典内的每个键只能关联一个值，因此重复的键不会导致错误，而是更新已存在的键对应的值。

示例：

# 定义字典
my_dict1 = {"张三": 100, "李四": 60, "王五": 80}

# 定义空字典
my_dict2 = {}
my_dict3 = dict()

# 定义重复key的字典
my_dict4 = {"张三": 100,"张三": 99, "李四": 60, "王五": 80}
print(my_dict1)     # {'张三': 99, '李四': 60, '王五': 80}

7.2 字典数据的获取

• 字典同集合一样，不可以使用下表索引
• 但是字典可以通过key值来取得对应的value
  语法：字典[key]

示例：

my_dict1 = {"张三": 100, "李四": 60, "王五": 80}

print(my_dict1["张三"])   # 100
print(my_dict1["李四"])   # 60
print(my_dict1["王五"])   # 80

7.3 字典的嵌套

stu_score_dict = {
    "张三": {"语文": 77, "数学": 66, "英语": 88},
    "李四": {"语文": 20, "数学": 30, "英语": 40},
    "王五": {"语文": 30, "数学": 40, "英语": 60},
}
print(f"学生考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 查看张三的语文成绩
print(stu_score_dict["张三"]["语文"])

7.4 字典的常用操作

八、数据容器的特点对比