Python数据容器

数据容器概念

为什么学习数据容器

思考一个问题：如果我想要在程序中，记录5名学生的信息，如姓名。 如何做呢？

学习数据容器，就是为了批量存储或批量使用多份数据

数据容器

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素 每一个元素，可以是任意类型的数据，如字符串、数字、布尔（甚至可以还是容器）等。

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

是否支持重复元素

是否可以修改

是否有序，等

分为5类，分别是：

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

我们将一一学习它们

总结

1. 什么是数据容器？

一种可以存储多个元素的Python数据类型

2. Python有哪些数据容器？

list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

它们各有特点，但都满足可容纳多个元素的特性。

列表list使用

列表的定义

为什么需要列表

思考：有一个人的姓名(TOM)怎么在程序中存储？

答：字符串变量

思考：如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？

答：No，我们使用列表就可以了， 列表一次可以存储多个数据

列表（list）类型，是数据容器的一类，我们来详细学习它。

列表的定义

基本语法：

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

以 \[\] 作为标识

列表内每一个元素之间用, 逗号隔开

列表的定义方式：

嵌套列表的定义

示例：

# 定义空列表
list1 = []
print(list1, type(list1))
list2 = list()
print(list2, type(list2))

# 定义非空列表
list3 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list3, type(list3))

# 定义嵌套列表
list4 = [list1, list2, list3]
print(list4, type(list4))

总结

1. 列表的定义语法

元素1, 元素2, 元素3, ......

2. 什么是元素？

数据容器内的每一份数据，都称之为元素

3. 元素的类型有限制吗？

元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

• 定义空列表：\[\] 或者 list()

• 定义非空列表：元素1, 元素2, ........

列表的下标索引

列表的下标（索引）

如何从列表中取出特定位置的数据呢？

我们可以使用：下标索引

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

我们只需要按照下标索引，即可取得对应位置的元素。

列表的下标（索引） - 反向

或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3......）

如图，从后向前，下标索引为：-1、-2、-3，依次递减。

嵌套列表的下标（索引）

如果列表是嵌套的列表，同样支持下标索引

如图，下标就有2个层级了。

示例：

# 定义空列表
list1 = []
print(list1, type(list1))
list2 = list()
print(list2, type(list2))

# 定义非空列表
list3 = [1, 2, 3, 4, 5, 6]
print(list3, type(list3))

# 定义嵌套列表
list4 = [list1, list2, list3]
print(list4, type(list4))

# 需求查询list3的第一个元素
print(list3[0])
print(list3[-6])

# 需求：查询list3中的最后一个元素
print(list3[5])
print(list3[-1])

# 需求：在list4中查询list3中的倒数第二个元素
# 可以根据列表的长度取元素（从后取），更常用使用场景是遍历列表
# 固定用法取最后一个元素：-1
print(list4[2][4])
print(list4[-1][-2])
print(list4[2][-2])
print(list4[-1][4])

总结

1. 列表的下标索引是什么？

列表的每一个元素，都有编号称之为下标索引

从前向后的方向，编号从0开始递增

从后向前的方向，编号从-1开始递减

2. 如何通过下标索引取出对应位置的元素呢？

列表下标，即可取出

3. 下标索引的注意事项：

要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

可以下标索引取出列表中对应位置的元素：列表下标

列表的常用操作

列表的常用操作（方法）

列表除了可以：

定义

使用下标索引获取值

以外，列表也提供了一系列功能：

插入元素

删除元素

清空列表

修改元素

统计元素个数

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

列表的查询功能（方法）

回忆：函数是一个封装的代码单元，可以提供特定功能。

在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

方法和函数功能一样， 有传入参数，有返回值，只是方法的使用格式不同：

函数的使用：

方法的使用：

关于类和方法的定义，在面向对象章节我们学习，目前我们知道如何使用方法即可。

查找某元素的下标

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

语法：列表.index(元素)

index就是列表对象（变量）内置的方法（函数）

统计列表内，有多少元素

语法：len(列表)

可以得到一个int数字，表示列表内的元素数量

列表的修改功能（方法）

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

语法：列表下标 = 值

可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

插入元素：

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

追加元素：

语法：列表.append(元素)，将指定元素，追加到列表的尾部

追加元素方式2：

语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

删除元素：

语法1： del 列表下标

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

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

语法：列表.remove(元素)

清空列表内容，语法：列表.clear()

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

语法：列表.count(元素)

列表的方法 - 总览

|--------|-------------------|------------------------------|
| 编号 | 使用方式 | 作用 |
| 1 | 列表.append(元素) | 向列表中追加一个元素 |
| 2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
| 4 | del 列表下标 | 删除列表指定下标元素 |
| 5 | 列表.pop(下标) | 删除列表指定下标元素 |
| 6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 7 | 列表.clear() | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表的下标 找不到报错ValueError |
| 10 | len(列表) | 统计容器内有多少元素 |

列表的方法 - 说明

功能方法非常多，同学们不需要硬记下来。

学习编程，不仅仅是Python语言本身，以后根据方向，会学习更多的框架技术。 除了经常用的，大多数是记忆不下来的。

我们要做的是，有一个模糊印象，知晓有这样的用法即可。

需要的时候，随时查阅资料即可。

列表的特点

经过上述对列表的学习，可以总结出列表有如下特点：

可以容纳多个元素（上限为2**63-1、9223372036854775807个）

可以容纳不同类型的元素（混装）

数据是有序存储的（有下标序号）

允许重复数据存在

可以修改（增加或删除元素等）

示例

# 定义一个空列表，用于储存姓名
name_list = []
print(name_list)

"""
增加元素
insert: 插入元素到指定位置
append: 追加1个元素至列表的末尾
extend: 追加多个元素（列表中的元素）至列表的末尾
"""

name_list.insert(0, "李明")
print(name_list)
name_list.append(["张三", "李四"])
print(name_list)
name_list.extend(["赵六", "王五"])
print(name_list)

"""
修改元素
列表[下标] = 新值
"""

name_list[0] = "麻子"
print(name_list)

"""
查询元素
列表[下标]: 根据下标索引查找元素
index: 查找指定元素的下标 注意：如果没有就报错
len: 查询列表中元素的个数（列表的长度）
count: 查询某个元素的个数 注意：如果没有返回0个
"""

print(name_list[0])
print(name_list.index("麻子"))
# 可以根据列表的长度取元素（从后取），更常用使用场景是遍历列表
# 固定用法取最后一个元素：列表[len(列表) - 1]
print(len(name_list))
print(name_list[len(name_list) - 1])

"""
删除元素
del 列表名[下标]: 删除指定位置的元素
pop: 删除指定位置的元素
remove: 直接删除指定的元素
clear: 清空列表（仅删除列表中的所有元素）
del 列表名: 直接删除整个列表
"""
del name_list[0]
print(name_list)

name_list.pop(-1)
print(name_list)

name_list.remove("赵六")
print(name_list)

name_list.clear()
print(name_list)

del name_list
# print(name_list)

总结

1. 列表的常见方法有:

2. 列表有哪些特点？

• 增加元素：

  • append：追加1个元素至列表的末尾

  • extend：扩展多个元素至列表的末尾

  • insert：插入1个元素到列表指定位置（如果指定位置大于当前列表中的最大范围，会直接插入到最后位置，如果插入的是当前列表的中间位置，这个位置后面的所有元素都自动向后移一位）

• 删除元素

  • del 列表名下标：删除指定位置的元素，这个位置后面的所有元素会自动向前移位

  • pop：删除指定位置的元素

  • remove：直接删除指定的元素

  • clear：清空列表，删除列表中所有的元素

  • del 列表名：直接删除列表，列表就不可再被使用了

• 修改元素

  • 列表名下标 = 新值

• 查询元素

  • 列表名下标：根据下标索引查找对应的元素

  • len(列表)：查询列表的元素的个数（列表的长度）

  • 列表名.count(元素)：查询指定元素在列表中的个数 注意：如果没有返回0个

  • 列表名.index(元素)：查询指定元素对应的下标 注意：如果没有就报错

list（列表）的遍历

列表的遍历 - while循环

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

列表的遍历 - for循环

除了while循环外，Python中还有另外一种循环形式：for循环。

对比while，for循环更加适合对列表等数据容器进行遍历。

语法：

表示，从容器内，依次取出元素并赋值到临时变量上。

在每一次的循环中，我们可以对临时变量（元素）进行处理。

每一次循环将列表中的元素取出，赋值到变量i，供操作

while循环和for循环的对比

while循环和for循环，都是循环语句，但细节不同：

在循环控制上：

while循环可以自定循环条件，并自行控制

for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

while循环可以通过条件控制做到无限循环

for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：

while循环适用于任何想要循环的场景

for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

示例

取出列表中的偶数

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 方式一：while循环遍历
# 定义新的列表用于保存偶数
list2 = []

# 定义初始下标变量，从0开始
x = 0
# 使用while循环输出list1中的偶数添加到list2中
while x < len(list1):
    # 循环体
    if list1[x] % 2 == 0:
        list2.append(list1[x])
    # 控制语句
    x += 1
print(list2)


# 方式二：for循环遍历
# 定义新的列表用于保存偶数
list3 = []
# 使用for循环输出list1中的偶数添加到list3中
for i in list1:
    # 循环体
    if i % 2 == 0:
        list3.append(i)
print(list3)

# 定义列表
name_list = ['张三', '李四', 'wangwu', 3, 5, 6, True]

# 方式一while循环遍历列表
# 定义初始下标
x = 0
# 循环判断
while x < len(name_list):
    # 循环体处理列表中的元素
    print(name_list[x])
    # 控制语句
    x += 1

# 方式二
# for循环控制语句
for i in name_list:
    print(i)

总结

• 容器的遍历是指将容器内的元素依次全部并处理

• 遍历列表的方法：

  • while循环：

    • 定义变量作为初始下标，从0开始

    • 循环条件为：下标值 < 列表的元素数量

  • for循环：for 临时变量 in 数据容器：

• for循环对比while循环

  • for循环更简单，while更灵活

  • for循环用于从容器中依次取出元素并处理

  • while用以任何需要循环的场景

元组tuple使用

元组的定义

为什么需要元组

思考：列表是可以修改的。

如果想要传递的信息，不被篡改，列表就不合适了。

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

但最大的不同点在于：

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

所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了

定义元组

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

元组也支持嵌套：

注意：元组只有一个数据，这个数据后面要添加逗号

示例：

# 定义空元组
t1 = ()
print(t1, type(t1))
t2 = tuple()
print(t2, type(t2))

# 定义非空元组
t3 = (10,)  # 如果元组中只有一个元素，必须加逗号
print(t3, type(t3))
t4 = (1, 2, 3, 4, 5)
print(t4, type(t4))
# t4[0] = 5
# TypeError: 'tuple' object does not support item assignment
print(t4[0])

# 定义嵌套元组
t5 = (t1, t2, t3, t4)
print(t5)

总结：

• 定义空元组：()或者tuple()

• 定义非空元组：(元素1, 元素2, 元素3.......)

• 注意：如果元素只有1个，也必须加逗号，元组中可以存储不同类型的数据

元组的操作

元组的相关操作

|--------|---------|---------------------------|
| 编号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |

注意事项：

元组由于不可修改的特性，所以其操作方法非常少。

示例：

# 定义非空元组
name_tuple = ('张三', '李四', '王五', 3)

# 需求：获取元组中的第一个元素
print(name_tuple[0])

# 需求：获取元组中的最后一个元素
print(name_tuple[-1])
print(name_tuple[3])
print(name_tuple[len(name_tuple) - 1])

# 定义嵌套元组
big_tuple = (name_tuple, (10, 20, 30), [10, 20, 30])
print(big_tuple)
print(big_tuple[2][0])
big_tuple[2][0] = 100
print(big_tuple)
# TypeError: 'tuple' object does not support item assignment
# big_tuple[2] = 'hello'

# 定义非空元组
name_tuple = ('张二', '张三', '李四', '王五', 3)

# 查询元组中有多少个元素
print(len(name_tuple))

# 查询 张三 出现的次数
# 如果没有就返回0
print(name_tuple.count('张三'))

# 查询 张三 对应的索引下标
# 如果没有就报错，如果有多个返回第一个元素的索引下标
print(name_tuple.index('张三'))

del name_tuple
# print(name_tuple)

总结：

• 元组的下标索引同列表一样就是元组中每个元素对应的编号

• 注意：元组同列表一样有两套编号

  • 正索引：从0开始从左至右依次递增

  • 负索引：从-1开始从右至左依次递减

• 元组名索引：根据索引下标查找对应的元素

• len(元组)：查询元组中的元素个数

• 元组.count(元素)：查询指定元素在元组中出现的次数，如果没有返回0个

• 元组.index(元素)：查询指定元素对应的索引下标，如果没有就报错

元组的相关操作 - 注意事项

不可以修改元组的内容，否则会直接报错

可以修改元组内的list的内容（修改元素、增加、删除、反转等）

不可以替换list为其它list或其它类型

元组的遍历

同列表一样，元组也可以被遍历。

可以使用while循环和for循环遍历它

示例：

# 定义非空元组
name_tuple = ('张山', '张三', '李四', '王五', 3)

# 方式一：for循环遍历
for i in name_tuple:
    print(i)


print('-' * 30)

# 方式二：while循环遍历
# 定义初始下标索引，从0开始
a = 0
# 根据条件进行循环判断
while a < len(name_tuple):
    print(name_tuple[a])
    # 条件控制语句
    a += 1

总结：

同列表一样可以使用while和for循环进行遍历

元组的特点

经过上述对元组的学习，可以总结出列表有如下特点：

可以容纳多个数据

可以容纳不同类型的数据（混装）

数据是有序存储的（下标索引）

允许重复数据存在

不可以修改（增加或删除元素等）

支持for循环

多数特性和list一致，不同点在于不可修改的特性。

总结

1. 元组的定义方式：

(元素, 元素, 元素, ......)

2. 元组的操作方法：

3. 元组的注意事项：

不可修改内容（可以修改内部list的内部元素）

4. 元组的特点：

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

支持for循环

字符串str使用

再识字符串

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。

但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。

如，字符串："Helloworld"

示例

# 定义空字符串
s1 = ''
s2 = ""
s3 = """"""
s4 = ''''''
s5 = str()
print(s1, s2, s3, s4, s5)
# 定义非空字符串
s6 = 'abcd1234'
print(s6, type(s6))

# 字符串包含双引号和单引号
l1 = ['1', '2']
s7 = "'张三'"
s8 = '"张三"'
s9 = "\"张三"
s10 = "l1"
print(s7, s8, s9, s10)

总结：

• 定义空字符串：'' "" """""" '''''' str()

• 注意：字符串中只能存入字符串

字符串的下标（索引）

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

从前向后，下标从0开始

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

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

所以：

修改指定下标的字符 （如：字符串0 = "a"）

移除特定下标的字符 （如：del 字符串0、字符串.remove()、字符串.pop()等）

追加字符等 （如：字符串.append()）

均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

示例：

# 定义非空字符串
s1 = 'My name is John'
# 查询字符串中第一个字符
print(s1[0])
print(s1[-15])
# 查询字符串的最后一个字符
print(s1[14:15])
print(s1[-1])
print(s1[14])

总结：

• 字符串的下标索引其实就是字符串中每个字符元素的编号

• 注意：

  • 正索引：从0开始从左至右依次递增

  • 负索引：从-1开始从右至左依次递减

字符串的常用操作

查找特定字符串的下标索引值

语法：字符串.index(字符串)

字符串的替换

语法：字符串.replace(字符串1，字符串2）

功能：将字符串内的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串哦

可以看到，字符串name本身并没有发生变化

而是得到了一个新字符串对象

字符串的分割

语法：字符串.split(分隔符字符串）

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

可以看到，字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中。

字符串的规整操作（去前后空格）

语法：字符串.strip()

字符串的规整操作（去前后指定字符串）

语法：字符串.strip(字符串)

注意，传入的是"12" 其实就是："1"和"2"都会移除，是按照单个字符。

统计字符串中某字符串的出现次数

语法：字符串.count(字符串)

统计字符串的长度

语法：len(字符串)

可以看出：

数字（1、2、3...）

字母（abcd、ABCD等）

符号（空格、!、@、#、$等）

中文

均算作1个字符

所以上述代码，结果20

示例：

# 定义非空字符串
s1 = 'My name is John'
# 需求：统计字符'a'字符出现的次数
print(s1.count('a'))
# 需求：统计字符'a'的索引下标
# 注意：如果有多个返回第一个元素的索引下标，如果没有直接报错
print(s1.index('a'))
# 需求：统计字符串中一共有多少个字符
print(len(s1))

print("-" * 30, '字符串特殊操作')

s2 = '你***的, 我###！'
# 需求：使用replace替换字符串中的敏感词：已知字符串"你***的, 我###！"，将其中的敏感词替换成:"你好聪明的，我真佩服！"
s3 = s2.replace('***', '好聪明').replace('###','真佩服') # 可以采用链式编程方式调用多次replace
print(s3)

# 需求：使用split切割字符串，已知字符串："苹果，香蕉，火龙果，西瓜"，要求把各类水果放入到列表中
s4 = "苹果，香蕉，火龙果，西瓜"
# s4.split(字符串) 括号中的字符串就是切割的依据
s4_list = s4.split('，')
print(s4_list)

# 需求：使用join拼接容器中元素
s5 = '123'.join(s4_list)
print(s5, type(s5))

# 需求：去除字符串两端的空白字符，包括空格、制表符、换行符等(去除前后空白包含空格、\t等)
s6 = '   张三，18   '
print(s6.strip())

# 需求：startswith判断是否以指定的字符串开头，判断给定的字符串是否以'it'开头
s7 = "my name is John"
print(s7.startswith('my'))

# 需求：endswith判断是否以指定的字符串结尾，判断给定的字符串是否以'it'结尾
print(s7.endswith('n'))

# 需求：将所有的小写转换大写
print(s7.upper())
# 需求：将所有的大写转换小写
print(s7.lower())

# 需求：查找指定字符在字符串中的索引
# 使用find查找字符如果没有返回-1
# print(s7.index('i'))
print(s7.find('m'))
# rfind是从后往前查找对应字符的索引位置
print(s7.rfind('m'))
s8 = s7.upper()
print(s8.isupper())

字符串常用操作汇总

|--------|----------------------------|----------------------------------------|
| 编号 | 操作 | 说明 |
| 1 | 字符串下标 | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |

字符串的遍历

同列表、元组一样，字符串也支持while循环和for循环进行遍历

while循环

结果：

for循环

结果：

示例：

# 定义非空字符串
s1 = 'abcde'

# 方式一：for循环遍历
for s in s1:
    print(s)

# 方式二：while循环遍历
# 定义初始变量
i = 0
while i < len(s1):
    print(s1[i])
    i += 1

字符串的特点

作为数据容器，字符串有如下特点：

只可以存储字符串

长度任意（取决于内存大小）

支持下标索引

允许重复字符串存在

不可以修改（增加或删除元素等）

支持for循环

基本和列表、元组相同

不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。

不同于列表，相同于元组的在于：字符串不可修改

总结

1. 字符串为什么被称之为数据容器呢？

字符串可以看做是字符的容器，支持下标索引等特性

2. 字符串有哪些常用操作方法？

3. 字符串有哪些特点：

序列的切片

序列

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

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

如图，序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

序列的常用操作 - 切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列起始下标:结束下标:步长

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

步长1表示，一个个取元素

步长2表示，每次跳过1个元素取

步长N表示，每次跳过N-1个元素取

步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

序列的切片演示

可以看到，这个操作对列表、元组、字符串是通用的

同时非常灵活，根据需求，起始位置，结束位置，步长（正反序）都是可以自行控制的

示例

# 定义非空列表
nums = ['a', 'b', 'c', 'd', 'e']

# 需求：取出所有的元素作为新的序列
print(nums)
print(nums[::])
print(nums[::1])
print(nums[0::1])
print(nums[0:len(nums):1])

# 需求：取出a b c
print(nums[:3:])
print(nums[0:3:1])
print(nums[-len(nums):3:1])
print(nums[-len(nums):-2:1])

# 需求：取出 b c
print(nums[1:3:])
print(nums[1:3:1])
print(nums[-4:-2:1])
print(nums[-4:3:1])

# 需求：取出a c e
print(nums[::2])
print(nums[0:5:2])
print(nums[-5:5:2])
print(nums[-5::2])

# 需求： d c
print(nums[-2:-4:-1])
print(nums[3:1:-1])

# 需求：反转字符串
print(nums[::-1])

# 需求：d b
print(nums[-2:-5:-2])
print(nums[-2:0:-2])
print(nums[3:0:-2])

序列的拼接

# 定义字符串
s1 = 'abc'
s2 = 'bcd'
s3 = s1 + s2
print(s3)
print(s3 * 2)

# 定义列表序列
l1 = ['a', 'b', 'c']
l2 = ['b', 'e', 'g']
l3 = l1 + l2
print(l3)
print(l3 * 2)

# 定义元组序列
l1 = ('a', 'b', 'c')
l2 = ('b', 'e', 'g')
l3 = l1 + l2
print(l3)
print(l3 * 2)

总结

1. 什么是序列？

内容连续、有序，支持下标索引的一类数据容器

2. 哪些数据容器可以视为序列？

列表、元组、字符串

3. 序列如何做切片

序列起始:结束:步长

起始可以省略，省略从头开始

结束可以省略，省略到尾结束

步长可以省略，省略步长为1（可以为负数，表示倒序执行）

集合set操作

为什么使用集合

我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。

为何又需要学习新的集合类型呢？

通过特性来分析：

列表可修改、支持重复元素且有序

元组、字符串不可修改、支持重复元素且有序

同学们，有没有看出一些局限？

局限就在于：它们都支持重复元素。

如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。

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

集合的定义

基本语法：

和列表、元组、字符串等定义基本相同：

列表使用：\[\]

元组使用：()

字符串使用：""

集合使用：{}

示例代码：

运行结果：

结果中可见：去重且无序

因为要对元素做去重处理

所以无法保证顺序和创建的时候一致

示例：

# 定义空集合
s1 = set()
s2 = {}

print(s1, type(s1))
print(s2, type(s2))

# 注意{}不能代表空集合只能代表空字典

# 定义非空集合
s3 = {'张三', '李四', '王五', '赵六'}
print(s3, type(s3))

# 定义嵌套非空集合
# set集合去重是根据元素的hash哈希值进行去重
# 嵌套列表和集合不支持，嵌套元组和字符串可以
l1 = ['a', 'b', 2]
t1 = ('a', 'b', 2)
s4 = {t1, '张三', '张三'}
print(s4, type(s4))

总结：

• 定义空集合：set() 因为{}代表空字典

• 定义非空集合：{元素1, 元素2......}

• set集合可以嵌套字符串和元组，不可以嵌套集合和列表

集合的常用操作

集合的常用操作 - 修改

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

但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

添加新元素

语法：集合.add(元素)。将指定元素，添加到集合内

结果：集合本身被修改，添加了新元素

移除元素

语法：集合.remove(元素)，将指定元素，从集合内移除

结果：集合本身被修改，移除了元素

从集合中随机取出元素

语法：集合.pop()，功能，从集合中随机取出一个元素

结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

清空集合

语法：集合.clear()，功能，清空集合

结果：集合本身被清空

取出2个集合的差集

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

功能：取出集合1和集合2的差集（集合1有而集合2没有的）

结果：得到一个新集合，集合1和集合2不变

消除2个集合的差集

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

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

结果：集合1被修改，集合2不变

2个集合合并

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

功能：将集合1和集合2组合成新集合

结果：得到新集合，集合1和集合2不变

集合的常用操作 - 集合长度

查看集合的元素数量

语法：len(集合)

功能：统计集合内有多少元素

结果：得到一个整数结果

集合的常用操作 - for循环遍历

集合同样支持使用for循环遍历

要注意：集合不支持下标索引 ，所以也就不支持使用while循环。

示例：

# 定义空集合
nums = set()
print(nums)
# 增加元素如果重复增加会被自动去重
nums.add(10)
nums.add(11)
nums.add(12)
nums.add(10)
print(nums)

# 查询元素
print(len(nums))

# 遍历集合
for num in nums:
    print(num)
# 修改元素
# 求集合的差集
# difference_update是 Python 中的一个集合操作方法，用于移除一个集合中包含在另一个集合中的所有元素。
# 它与 difference 方法相似，不同的是 difference 方法返回一个新集合，
# 而 difference_update 直接在原集合上进行修改。
new_nums = nums.difference({10, 50})
print(new_nums)
nums.difference_update({10, 12})
print(nums)

# 更新增加元素
nums.update({10, 11})
print(nums)

# 求两个集合的并集
s1 = {1, 2, 3}
s2 = {4, 1, '1'}
s3 = s1.union(s2)
print(s3)
# 移除集合中的数据
print(s3.remove(3))
print(s3)

# 删除元素
print(s3.pop())
print(s3)

print(nums.clear())
print(nums)

del nums
# print(nums)

总结：

• 增

  • add(元素)：把指定的元素添加到集合中（无序）

• 删

  • remove(元素)：删除指定元素

  • pop()：随机删除元素

  • clear()：清空集合中所有元素

  • del 集合名：删除整个集合

• 改

  • 集合1.difference_update(集合2)：将集合1中与集合2中相同的元素从集合1中删除

  • 集合3=集合1.difference(集合2)：将集合1中与集合2中相同的元素从集合1中删除后返回新集合

  • 集合1.update(集合2)：把指定集合中的元素添加到原有集合中

  • 集合3=集合1.union(集合2)：将集合1和集合2中的不同元素合并到一直返回一个新的集合

• 查

  • len(集合)：查看集合的长度

集合常用功能总结

|--------|----------------------------|---------------------------------|
| 编号 | 操作 | 说明 |
| 1 | 集合.add(元素) | 集合内添加一个元素 |
| 2 | 集合.remove(元素) | 移除集合内指定的元素 |
| 3 | 集合.pop() | 从集合中随机取出一个元素 |
| 4 | 集合.clear() | 将集合清空 |
| 5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 |
| 6 | 集合1.difference_update(集合2) | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变 |
| 8 | len(集合) | 得到一个整数，记录了集合的元素数量 |

集合的特点

经过上述对集合的学习，可以总结出集合有如下特点：

可以容纳多个数据

可以容纳不同类型的数据（混装）

数据是无序存储的（不支持下标索引）

不允许重复数据存在

可以修改（增加或删除元素等）

支持for循环

总结

1. 集合有哪些特点

集合内不允许重复元素（去重）

集合内元素是无序的（不支持下标索引）

2. 集合的定义方式：

{元素, 元素, ......, 元素}

3. 集合的常用操作

4. 如何遍历集合元素

可以使用for循环进行变量

不可以使用while循环，因为不支持下标索引

5. 集合的特点

字典dict使用

字典的定义

为什么使用字典

生活中的字典：

通过【字】 就能找到对应的【含义】

所以，我们可以认为，生活中的字典就是记录的一堆：

【字】：【含义】

【字】：【含义】

......

【字】：【含义】

为什么需要字典

Python中字典和生活中字典十分相像：

生活中的字典

【字】：【含义】

【字】：【含义】

可以按【字】找出对应的【含义】

Python中的字典

Key: Value

Key: Value

可以按【Key】找出对应的【Value】

老师有一份名单，记录了学生的姓名和考试总成绩。

现在需要将其通过Python录入至程序中，并可以通过学生姓名检索学生的成绩。

使用字典最为合适：

可以通过Key（学生姓名），取到对应的Value（考试成绩）

所以，为什么使用字典？

因为可以使用字典，实现用key取出Value的操作

字典的定义

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

使用{}存储元素，每一个元素是一个键值对

每一个键值对包含Key和Value（用冒号分隔）

键值对之间使用逗号分隔

Key和Value可以是任意类型的数据（key不可为字典）

Key不可重复，重复会对原有数据覆盖

前文中记录学生成绩的需求，可以如下记录：

字典数据的获取

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value

字典的嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）

那么，就表明，字典是可以嵌套的

需求如下：记录学生各科的考试信息

代码：

优化一下可读性，可以写成：

嵌套字典的内容获取

嵌套字典的内容获取，如下所示：

示例：

# 定义空字典
d1 = {}
print(d1, type(d1))
d2 = dict()
print(d2, type(d2))

# 定义非空字典
# 注意:如果key重复,后面的value就会覆盖前面的value
d3 = {"张三": 100, "李四": 85, "王五": 85, "李明": 56}
print(d3, type(d3))

# 定义嵌套字典
# 注意：字典的key不能是可变数据类型：列表、集合、字典
d4 = {
    "张三": {"语文": 95, "数学": 69, "英语": 89},
    "李四": {"语文": 97, "数学": 79, "英语": 99},
    "王五": {"语文": 77, "数学": 65, "英语": 79}
}

json字符串与字典转换：

import json

# 将json字符串转换为字典
# 定义json字符串

json_str = '{"张三":99,"李四":100,"王五":92,"赵六":95}'
print(json_str, type(json_str))
print(json.loads(json_str))
print("-" * 90)

# 字典转为字符串

s1 = {
    "张三": {"语文": 95, "数学": 79, "英语": 86},
    "李四": {"语文": 98, "数学": 86, "英语": 95},
    "王五": {"语文": 98, "数学": 86, "英语": 95}
}

print(s1, type(s1))
# 中文会转换为字节码
print(json.dumps(s1))

总结

1. 为什么使用字典

字典可以提供基于Key检索Value的场景实现

就像查字典一样

2. 字典的定义语法

• 定义空字典：{} 或者dict()

• 定义非空字典：{k1:v1, k2:v2, k3:v3.........}

• 注意：

  • 键值对的key和value可以是任意数据类型（但是key不能是可变数据类型：列表、集合、字典）

  • 字典内的key不允许重复，如果重复添加相同的key，后面value会自动覆盖前面的value

  • 字典不能使用下标索引，而是通过key检索value

字典的常用操作

字典的常用操作

新增元素

语法：字典Key = Value，结果：字典被修改，新增了元素

更新元素

语法：字典Key = Value，结果：字典被修改，元素被更新

注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

删除元素

语法：字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

清空字典

语法：字典.clear()，结果：字典被修改，元素被清空

获取全部的key

语法：字典.keys()，结果：得到字典中的全部Key

遍历字典

语法：for key in 字典.keys()

运行结果

注意：字典不支持下标索引，所以同样不可以用while循环遍历

计算字典内的全部元素（键值对）数量

语法：len(字典)

结果：得到一个整数，表示字典内元素（键值对）的数量

示例：

# 定义空字典
score_dict = {}
# 添加数据
# 字典名[新的key] = 值
score_dict['张三'] = 100
score_dict['李四'] = 99
print(score_dict)

# 修改数据
# 字典名[已经存在的key] = 值
score_dict['张三'] = 66
print(score_dict)

# 查询数据
# 查询张三的分数
# 方式一：字典名[key] 返回对应的值，当key不存在时会报错
# 方式二：字典名.get(key[, 默认值]) 返回对应的值，
# 当key不存在时会返回默认值（默认是None，可以随意设置），当在语法中看[]时表示参数可选
print(score_dict['张三'])
print(score_dict.get('王五', '阿斯弗'))

# 查询字典的长度
print(len(score_dict))

# 删除数据
print(score_dict.pop('张三'))
print(score_dict)

print(score_dict.clear())
print(score_dict)

del score_dict
# print(score_dict) NameError: name 'score_dict' is not defined

字典的遍历

# 定义非空字典
score_dict = {"张三": 89, "李四": 99, "王五": 91}
print(score_dict)

# 获取所有的key
keys = score_dict.keys()
print(keys, type(keys))

# 方式一:通过keys遍历字典
for key in keys:
    # 根据key查询对应的value
    print(key, score_dict[key])

# 获取所有的value
values = score_dict.values()
print(values, type(values))

# 方式二：通过value遍历字典
for value in values:
    print(value)

# 获取所有的键值对
kvs = score_dict.items()
print(kvs, type(kvs))

# 方式三：可以通过键值对遍历字典，遍历获取到的元素是键值对元组
for kv in kvs:
    print(kv, 'key为：', kv[0], ' 值为：', kv[1])

# 方式四：将键值对拆包遍历
for k, v in score_dict.items():
    print(k, v)

总结：

• 增加数据：字典名新key = 值

• 修改数据：字典名旧key=值

• 删除数据：

  • 字典名.pop(key)：删除指定key对应的键值对

  • 字典名.clear()：清空字典中所有的数据

  • del 字典名：删除整个字典

• 查询数据：

  • 字典名key：根据指定的key返回对应的value值，当key不存在时会报错

  • 字典名.get(key)：根据指定的key返回对应的value值，当key不存在时返回默认值None（可以设置）

• keys()：获取所有的key键

• values()：获取所有的value值

• items()：获取所有的键值对，会把键和值封装成元组

• 可以通过for循环遍历keys、values、items，不能使用while循环

字典的常用操作总结

|--------|-------------------|------------------------------|
| 编号 | 操作 | 说明 |
| 1 | 字典Key | 获取指定Key对应的Value值 |
| 2 | 字典Key = Value | 添加或更新键值对 |
| 3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的元素数量 |

字典的特点

经过上述对字典的学习，可以总结出字典有如下特点：

可以容纳多个数据

可以容纳不同类型的数据

每一份数据是KeyValue键值对

可以通过Key获取到Value，Key不可重复（重复会覆盖）

不支持下标索引

可以修改（增加或删除更新元素等）

支持for循环，不支持while循环

打包和拆包

所有容器都有拆包特性

示例：

# 打包
a = 10
b = 20
c = 30
my_t1 = (a, b, c)
print(my_t1)

# 拆包
x, y, z = my_t1
print(x)
print(y)
print(z)


# 需求：已知x=10和y=20，请替换两个变量的值x=20和y=10
x = 10
y = 20
# 使用第三个变量互换值
# temp = x
# x = y
# y = temp
# print(x, y)

# 使用打包和拆包的方法互换值
x, y = y, x
print(x, y)

总结

1. 字典的常用操作

2. 操作注意

新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）

3. 字典的特点

数据容器总结

数据容器分类

数据容器可以从以下视角进行简单的分类：

是否支持下标索引

支持：列表、元组、字符串 - 序列类型

不支持：集合、字典 - 非序列类型

是否支持重复元素：

支持：列表、元组、字符串 - 序列类型

不支持：集合、字典 - 非序列类型

是否可以修改

支持：列表、集合、字典

不支持：元组、字符串

数据容器特点对比

|------|------------------|-------------------|-----------|-------------|-----------------------------------|
| | 列表 | 元组 | 字符串 | 集合 | 字典 |
| 元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
| 元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key：Value Key：除字典外任意类型 Value：任意类型 |
| 下标索引 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 重复元素 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 可修改性 | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| 数据有序 | 是 | 是 | 是 | 否 | 否 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |

基于各类数据容器的特点，它们的应用场景如下：

列表：一批数据，可修改、可重复的存储场景

元组：一批数据，不可修改、可重复的存储场景

字符串：一串字符串的存储场景

集合：一批数据，去重存储场景

字典：一批数据，可用Key检索Value的存储场景

数据容器的通用操作

数据容器的通用操作 - 遍历

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。

首先，在遍历上：

5类数据容器都支持for循环遍历

列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

尽管遍历的形式各有不同，但是，它们都支持遍历操作。

数据容器的通用统计功能

除了遍历这个共性外，数据容器可以通用非常多的功能方法

len(容器)

统计容器的元素个数

max(容器)

统计容器的最大元素

min(容器)

统计容器的最小元素

同学们可能会疑惑，字符串如何确定大小？

我们下一个小节为同学们解惑。

容器的通用转换功能

除了下标索引这个共性外，还可以通用类型转换

list(容器)

将给定容器转换为列表

str(容器)

将给定容器转换为字符串

tuple(容器)

将给定容器转换为元组

set(容器)

将给定容器转换为集合

容器通用排序功能

通用排序功能

sorted(容器, reverse=True)

将给定容器进行排序

注意，排序后都会得到列表（list）对象。

示例：

# 定义列表
l1 = ['c', 'd', 'a', 'b']
# 定义字符串
str1 = ['c', 'd', 'a', 'b']
# 定义元组
t1 = ('c', 'd', 'a', 'b')
# 定义集合
set1 = {'c', 'd', 'a', 'b'}
# 定义字典
d1 = {'c': 1, 'd': 2, 'a': 3, 'b': 4}

# len()求元素个数
print(len(l1))
print(len(str1))
print(len(t1))
print(len(set1))
print(len(d1))
# 求容器的最大值
print(max(l1))
print(max(str1))
print(max(t1))
print(max(set1))
print(max(d1))
# 求容器的最小值
print(min(l1))
print(min(str1))
print(min(t1))
print(min(set1))
print(min(d1))
# sorted(容器)：对容器中的所有元素进行排序，默认升序排序
print(sorted(l1))
print(sorted(str1))
print(sorted(t1))
print(sorted(set1))
print(sorted(d1))
# reverse默认为False，设置为True反转顺序进行倒序排序
print(sorted(l1, reverse=True))
print(sorted(str1, reverse=True))
print(sorted(t1, reverse=True))
print(sorted(set1, reverse=True))
print(sorted(d1, reverse=True))
# 拓展：列表的reverse()函数
print(sorted(l1))
print(l1.reverse())
print(l1)

容器通用功能总览

|------------------------------|--------------------------------|
| 功能 | 描述 |
| 通用for循环 | 遍历容器（字典是遍历key） |
| max | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列, reverse=True) | 排序，reverse=True表示降序 得到一个排好序的列表 |

字符串大小比较

ASCII码表

在程序中，字符串所用的所有字符如：

大小写英文单词

数字

特殊符号(!、\、|、@、#、空格等）

都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值

字符串进行比较就是基于数字的码值大小进行比较的。

字符串比较

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

总结

1. 字符串如何比较

从头到尾，一位位进行比较，其中一位大，后面就无需比较了。

2. 单个字符之间如何确定大小？

通过ASCII码表，确定字符对应的码值数字来确定大小