数据容器入门

为什么学习数据容器？

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

一、定义5个变量

name1 = '王太利'

name2 = '肖央'

name3 = '林俊杰'

name4 = '刘德华'

name5 = '张学友'

二、一个变量完成

name_list = [ '王太利', '肖央', '林俊杰', '刘德华', '张学友' ]

print(name_list)

这就是数据容器，一个容器可以容纳多份数据。

数据容器的定义

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

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

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

分为5类，分别是：

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

总结

什么事容器？

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

Python有哪些数据容器？

列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)，它们各有特点，但都满足可容纳多个元素的特性。

数据容器：list(列表)

列表的定义

为什么需要列表？

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

答：字符串变量。

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

答：不是，使用列表，列表一次可以存储多个数据。

列表(list)类型，是数据容器的一类。

基本语法

# 字面量

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

# 定义变量

变量名称 = [ 元素1, 元素2, 元素3, 元素4, ... ]

# 定义空列表

变量名称 = []

变量名称 = list()

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

• 以[]作为标识
• 列表内每一个元素之间用, 逗号隔开

列表的定义方式：

案例演示：使用[]的方式定义列表

name_list = [ 'itcainiao', 'itcast', 'python' ]

print(name_list)

print(type(name_list))

my_list = [ 'itcainiao', 666, True ]

print(my_list)

print(type(my_list))

注意事项：

列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。

嵌套列表的定义

my_list = [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]

print(my_list)

print(type(my_list))

总结

列表的定义语法

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

什么是元素？

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

元素的类型有限制吗？

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

列表的下标索引

列表的下标索引是什么

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

可以使用：下标索引

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

如何通过下表索引取出对应位置的元素

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

# 语法，列表[下表索引]

name_list = [ 'Tom', 'Lily', 'Rose' ]

print(name_list[0]) #结果，Tom

print(name_list[1]) #结果，Lily

print(name_list[2]) #结果，Rose

或者，可以反向索引，也就是从后向前，从-1开始，一次递减（-1，-2，-3，……）。

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

# 语法，列表[下表索引]

name_list = [ 'Tom', 'Lily', 'Rose' ]

print(name_list[-3]) #结果，Tom

print(name_list[-2]) #结果，Lily

print(name_list[-1]) #结果，Rose

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

my_list = [['Tom', 'Lily', 'Rose'],[22,33,44]]

print(my_list[0][1])

总结

列表的下标索引是什么？

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

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

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

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

列表[下标]，即可取出。

下标索引的注意事项

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

列表的常用操作

列表的常用操作（方法）

列表除了可以：定义、使用下表索引获取值，以外，列表也提供了一系列功能：

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

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

列表的查询功能（方法）

方法与函数的格式区别

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

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

示例，函数：

def add(x, y):

return x + y

示例，方法：

class Student:

def add(self, x , y):

return x + y

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

函数的使用：num = add(1, 2)

方法的使用：

student = Student()

num = student.add(1, 2)

查找某元素的下标

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

语法：列表.index(元素)

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

my_list = ['itcainiao', 'itcast', 'python']

index = my_list.index('itcainiao')

print(index)

查找某下标的元素

语法：列表[下标]

my_list = ['itcainiao', 'itcast', 'python']

print(my_list[1])

列表的修改功能（方法）

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

语法：列表[下标] = 值

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

# 正向下表索引

my_list = [1, 2, 3, 4, 5]

my_list[1] = 6

print(my_list)

# 反向下表索引

my_list = [1, 2, 3, 4, 5]

my_list[-1] = 7

print(my_list)

插入元素

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

my_list = [1, 2, 3, 4, 5]

my_list.insert(1, 'itcast')

print(my_list)

追加元素方法一

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

my_list = [1, 2, 3, 4, 5]

my_list.append('python')

print(my_list)

my_list = [1, 2, 3, 4, 5]

my_list.append([5, 6, 7, 8, 9])

print(my_list) # 输出结果[1, 2, 3, 4, 5, [5, 6, 7, 8, 9]]

追加元素方法二

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

my_list = [1, 2, 3]

my_list.extend([4, 5, 6])

print(my_list)

删除元素

语法1：del 列表[下标]

my_list = [1, 2, 3]

del my_list[1]

print(my_list)

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

.pop语法是将列表中的元素取出，可以重新赋值给其他变量使用。

my_list = [1, 2, 3]

receive = my_list.pop(2)

print(my_list)

print(receive)

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

语法：列表.remove(元素)

my_list = [1, 2, 3, 1, 2, 3]

my_list.remove(1)

print(my_list)

清空列表内容

语法：列表.clear()

my_list = [1, 2, 3, 1, 2, 3]

my_list.clear()

print(my_list)

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

语法：列表.count(元素)

my_list = [1, 2, 3, 1, 3, 3]

count = my_list.count(3)

print(count)

my_list = [1, 2, 3, 1, 3, 3]

print(my_list.count(3))

统计列表内，有多少元素

语法：len(列表)

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

my_list = [1, 2, 3, 4, 5]

print(len(my_list))

my_list = [1, 2, 3, 4, 5]

count = len(my_list)

print(count)

列表的方法 - 纵览

列表的特点

列表有如下特点：

• 可以容纳多个元素（上限2**63-1、9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

总结

列表的常见方法

列表有哪些特点

列表有如下特点：

• 可以容纳多个元素（上限2**63-1、9223372036854775807个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

练习题 - 常用功能练习

有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄。

请通过列表的功能（方法），对其进行

1、定义这个列表，并用变量接收它

2、追加一个数字31，到列表的尾部

3、追加一个新列表[29, 33, 30]，到列表的尾部

4、取出第一个元素（应是：21）

5、取出最后一个元素（应是：30）

6、查找元素31，在列表中的下标位置

"""

练习题-记录学生年龄

"""

# 定义学生年龄列表，并用变量接收

age = [21, 25, 21, 23, 22, 20]

# 追加一个数字31到列表尾部

age.append(31)

print(f"追加一个数字31到列表的尾部：{age}")

# 追加一个新的列表到列表尾部

age.extend([29, 33, 30])

print(f"追加一个新的列表到列表的尾部：{age}")

# 取出第一个元素

num1 = age[0]

print(f"取出第一个元素的方法一：{num1}")

print(f"取出第一个元素的方法二：{age[0]}")

# 取出最后一个数字

num2 = age[-1]

print(f"取出最后一个元素的方法一：{num2}")

print(f"取出最后一个元素的方法二：{age[-1]}")

# 查找31在列表的下标位置

num3 = age.index(31)

print(f"查找31在列表的下标位置方法一：{num3}")

print(f"查找31在列表的下标位置方法二：{age.index(31)}")

list(列表)的遍历

列表的遍历 - while循环

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

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

如何遍历列表的数据呢？

• 可以使用while循环

如何在循环中取出列表的元素呢？

• 使用列表[下标]的方式取出

循环条件如何控制？

• 定义一个变量表示下标，从0开始
• 循环条件为 下标值 < 列表元素数量

# 定义while循环练习函数

def list_while_func():

"""

使用while循环遍历列表的函数演示

:return: None

"""

# 定义一个列表

my_list = ['cainiao', 'itcat', 66, True]

# 循环控制变量通过下表索引来控制，默认0

# 每一次循环将下表索引变量+1

# 循环条件 下标索引 < 列表的元素数量

# 定义控制变量

index = 0

# while循环遍历列表元素

while index < len(my_list):

element = my_list[index]

print(f"while循环遍历my_list列表的结果是：{element}")

index += 1

list_while_func()

列表遍历 - for循环

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

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

语法：

for 临时变量 in 数据容器:

对临时变量进行处理

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

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

# 定义for循环练习函数

def list_for_func():

"""

使用for循环遍历列表的函数演示

:return: None

"""

# 定义列表

my_list = [111, "itcainiao", False, 13.14]

# for循环遍历列表元素

for i in my_list:

print(f"while循环遍历my_list列表的结果是：{i}")

list_for_func()

while循环和for循环的对比

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

• 在循环控制上：

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

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

• 在无限循环上：

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

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

• 在使用场景上：

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

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

总结

什么是遍历

将容器内的元素依次取出，并处理，称之为遍历操作。

如何遍历列表的元素

可以使用while或for循环。

for循环的语法

for 临时变量 in 数据容器:

对临时变量进行处理

for循环和while循环对比

• for循环更简单，while更灵活。
• for循环用于从容器内依次取出元素并处理，while循环用以任何需要循环的场景

练习题 - 取出列表内的偶数

定义一个列表，内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

• 遍历列表，取出列表内的偶数，并存入一个新的列表对象中
• 使用while循环和for循环各操作一次

提示：

• 通过if判断来确认偶数
• 通过列表的append方法，来增加元素

"""
  取出列表内的偶数
"""

# 定义while循环函数
def list_while_func():
    """
    使用while循环遍历列表并取出偶数赋值到新容器中
    :return:
    """
    # 定义列表
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    # 定义接收遍历取出的元素列表
    user_list = []
    # 定义循环变量
    index = 0
    # while循环遍历列表并将取出偶数增加到user_list列表中
    while index < len(my_list):
        if my_list[index] % 2 == 0:
            user_list.append(my_list[index])

        index += 1
    print(f"while遍历{my_list}列表，并将取出偶数增加到user_list的结果是：{user_list}")

list_while_func()


# 定义for循环函数
def list_for_func():
    """
    使用for循环遍历列表并取出偶数赋值到新容器中
    :return:
    """
    # 定义数据容器（列表）
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    user_list = []
    # for循环遍历列表并将取出偶数增加到user_list列表中
    for i in my_list:
        if i % 2 == 0:
            user_list.append(i)

    print(f"for循环遍历{my_list}列表，取出偶数增加到user_list列表的结果是：{user_list}")

list_for_func()

数据容器：tuple(元组)

为什么需要元组

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

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

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

但最大的不同点在于：

元组一旦定义完成，就不可修改；所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。

定义元组

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

# 定义元组字面量

(元素, 元素, ……, 元素)

# 定义元组变量

变量名称 = (元素, 元素, ……, 元素)

# 定义空元组

变量名称 = ()

变量名称 = tuple()

# 定义元组

t1 = (1, "hellp", True)

t2 = ()

t3 = tuple()

print(f"t1的类型是：{type(t1)}，内容是：{t1}")

print(f"t2的类型是：{type(t2)}，内容是：{t2}")

print(f"t3的类型是：{type(t3)}，内容是：{t3}")

注意事项

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

# 定义3个元素的元组

t1 = (1, "hellp", True)

print(f"t1的类型是：{type(t1)}，内容是：{t1}")

# 定义一个元素的元组

t2 = ('hello', )

print(f"t2的类型是：{type(t2)}，内容是：{t2}")

元组的嵌套

# 元组的嵌套

t1 = ((1, 2, 3), (4, 5, 6))

print(f"t1的类型是：{type(t1)}，内容是：{t1}")

# 元组中可以嵌套列表，嵌套的列表中的数据可以修改

t2 = ((1, 2, 3), [4, 5, 6])

print(f"t2的类型是：{type(t2)}，内容是：{t2}")

下标索引取数据

# 下标索引取数据

t1 = ((1, 2, 3), (4, 5, 6))

num = t1[1][1]

print(f"从嵌套元组中取出的数据是：{num}")

元组的相关操作

# 下标索引取数据

t1 = ((1, 2, 3), (4, 5, 6))

num = t1[1][1]

print(f"从嵌套元组中取出的数据是：{num}")

# 根据index()，查找特定元素的第一个匹配项

t1 = (1, "hellp", True, 1, "hellp", True)

print(f"查找元素1在元组中的下标位置是：{t1.index(1)}")

# 根据count()，查找特定元素在元组中出现的次数

t1 = (2, 'hello', True, 2, 'hello', True)

print(f"查找t1元素True在元组中的出现的次数是：{t1.count(True)}")

# len()统计元组中元素的个数

t1 = (2, 'hello', True, 2, 'hello', True)

print(f"统计t1中元素的个数是：{len(t1)}")

元组的遍历

# while循环实现元组遍历

t1 = (1, 2, 3, 'heihei', 'itcainiao', 'itcast', True, False, 'Python')

count = 0

while count < len(t1):

element = t1[count]

print(f"hile循环实现元组遍历的结果是：{element}")

count += 1

# for循环实现元组的遍历

t1 = (1, 2, 3, 'heihei', 'itcainiao', 'itcast', True, False, 'Python')

for i in t1:

print(f"for循环实现元组的遍历的结果是：{i}")

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

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

# 尝试修改元组内容

t1 = (1, 2, 3)

t1[1] = 'itcainiao'

执行后报错：

TypeError: 'tuple' object does not support item assignment

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

# 尝试修改元组内容

t1 = (1, 2, ['Python', 5, 6])

t1[2][1] = 'itcainiao'

print(f"t1元组中list数据修改后的结果是：{t1}")

元组的特点

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

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下表索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）
• 支持for循环

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

总结

元组的定义方式

(元素, 元素, ……, 元素)

元组的操作方法

元组的注意事项

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

元组的特点

• 和list基本相同（有序、任意数量元素、允许重复元素、支持不同类型数据），唯一不同在于不可修改。
• 支持for循环

练习题 - 元组的基本操作

定义一个元组，内容是：('周杰伦', 11, ['football', 'music'])，记录的是一个学生的信息（姓名、年龄、爱好）。

请通过元组的功能（方法），对其进行

1、查询其年龄所在的下标位置

2、查询学生的姓名

3、删除学生爱好中的football

4、增加爱好：coding到爱好list内

# 定义元组

age = ('周杰伦', 11, ['football', 'music'])

# 查询其年龄所在的下标位置

print(f"学生年龄对应的下标索引是：{age.index(11)}")

# 查询学生的姓名

print(f"元组中学生的名字是：{age[0]}")

# 删除学生爱好中的football

del age[2][0]

print(f"删除学生爱好中的football后的结果是：{age}")

# 增加爱好：coding到爱好list内

age[2].append('coding')

print(f"增加爱好：coding到爱好list内的结果是：{age}")

数据容器：str(字符串)

再识字符串

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

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

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

如，字符串："itcain"

字符串的下表（索引）

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

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

# 通过下标获取特定位置字符

name = "itcain"

print(f"{name}字符串按从前向后的下标位置找出c元素：{name[2]}。按从后向前的下标位置找出c元素：{name[-4]}")

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

所以：

• 修改指定下标的字符 （如：字符串[0] = "a"）
• 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
• 追加字符等 （如：字符串.append()）

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

字符串的常用操作

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

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

my_str = "itcainiao in cainiaojizhongying"

value = my_str.index("in")

print(f"{my_str}中的in其起始下标值是：{value}")

字符串的替换

语法：字符串.replace(字符串1, 字符串2)

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

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

my_str = "itcainiao in cainiaojizhongying"

new_my_str = my_str.replace('it', '叮叮噹')

print(f"{my_str}最后的结果是：{new_my_str}")

结果是：

itcainiao in cainiaojizhongying最后的结果是：叮叮噹cainiao in cainiaojizhongying

字符串的分割

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

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

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

name = "itcainiao in cainiaojizhongying 我是 大大的 菜鸟"

name_list = name.split(" ")

print(f"name字符串使用空格分隔符后的结果是：{name_list}")

输出结果是：

name字符串使用空格分隔符后的结果是：['itcainiao', 'in', 'cainiaojizhongying', '我是', '大大的', '菜鸟']

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

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

语法：字符串.strip()

my_str = " itcainiao in cainiaojizhongying 我是 大大的 菜鸟 "

print(f"my_str规整前的结果是：{my_str}")

new_my_str = my_str.strip()

print(f"my_str规整后的结果是：{new_my_str}")

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

my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"

print(f"my_str规整前的结果是：{my_str}")

new_my_str = my_str.strip('123')

print(f"my_str规整后的结果是：{new_my_str}")

注意，传入的是“123”其实就是：“1”、“2”和“3”都会移除，是按照单个字符。

统计字符串内某字符串的出现次数功能

my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"

count = my_str.count('cainiao')

print(f"cainiao在字符串中出现的次数是：{count}")

统计字符串的字符个数

my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"

num = len(my_str)

print(f"my_str字符串的字符个数是：{num}")

字符串常用操作汇总

字符串的遍历

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

my_str = "cainiaojizhongying"

index = 0

while index < len(my_str):

count = my_str[index]

print(f"while遍历字符串的结果是：{count}")

index += 1

my_str = "cainiaojizhongying"

for i in my_str:

print(f"while遍历字符串的结果是：{i}")

字符串的特点

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

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下表索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

总结

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

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

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

字符串有哪些特点

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下表索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

练习题 - 分割字符串

给定一个字符串：“123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321”

• 统计字符串内有多少个“cainiao”字符
• 将字符串内的空格，全部替换为字符：“|”
• 并按照"|"进行字符串分割，得到列表

提示：

• count、replace、split

"""

练习题 - 分割字符串

123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321

"""

# 定义字符串

my_str = "123itcainiao in cainiaojizhongying 我是 大大的 菜鸟321"

# 统计字符串内有多少个“cainiao”字符

count = my_str.count('cainiao')

print(f"my_str字符串中的cainiao字符个数是：{count}")

# 将字符串内的空格，全部替换为字符：“|”

spt = my_str.replace(" ", "|")

print(f"my_str字符串将空格更换为 | 结果是：{spt}")

# 并按照"|"进行字符串分割，得到列表

my_str1 = "123itcainiao|in|cainiaojizhongying|我是|大大的|菜鸟321"

new_my_str = my_str1.split("|")

print(f"按照|进行字符串分割，得到的列表是：{new_my_str}")

数据容器的切片

序列

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

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

序列的常用操作 - 切片

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

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

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始。
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。
• 步长表示，依次取出元素的间隔：

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

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

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

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

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

"""

数据容器-切片练习

"""

# 对list进行切片，从1开始，4结束，步长1

my_list = [1, 2, 3, 4, 5, 6]

result1 = my_list[1:3:]

print(f"result1的切片结果是：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1

my_tuple = (1, 2, 3, 4, 5, 6)

result2 = my_tuple[::]

print(f"result2的切片结果是：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2

my_str = "0123456789"

result3 = my_str[::2]

print(f"result3的切片结果是：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1

my_str = "0123456789"

result4 = my_str[::-1]

print(f"result4的切片结果是：{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1

my_list = [1, 2, 3, 4, 5, 6]

result5 = my_list[3:1:-1]

print(f"result5的切片结果是：{result5}")

# 对元组进行切片，从头开始，到最后结束，步长-2

my_tuple = (1, 2, 3, 4, 5, 6)

result6 = my_tuple[::-2]

print(f"result6的切片结果是：{result6}")

总结

什么是序列

内容连接、有序，可使用下表索引的一类数据容器。

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

列表、元组、字符串

序列如何做切片

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始。
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。
• 步长表示，依次取出元素的间隔：

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

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

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

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

练习案例 - 序列的切片实践

有字符串："月薪过万, 员序程鸟菜来, nohtyp学"

• 请使用学过的任何方式，得到“菜鸟程序员”

可用方式参考：

• 倒序字符串，切片取出；或切片取出，然后倒序
• split分隔", " replace替换“来”为空，倒序字符串

"""

切片练习题

"月薪过万, 员序程鸟菜来, nohtyp学"

"""

# 定义字符串

my_str = "月薪过万, 员序程鸟菜来, nohtyp学"

# 倒序字符串，切片取出

result1 = my_str[10:5:-1]

print(f"倒序字符串，切片取出的结果是：{result1}")

# 切片取出，然后倒序

result2 = my_str[5:11:][::-1]

print(f"切片取出，然后倒序的结果是：{result2}")

# split分隔", " replace替换“来”为空，倒序字符串

result3 = my_str.split(",")[1].replace("来", "")[::-1]

print(f"split分隔’, ‘ replace替换“来”为空，倒序字符串的结果是：{result3}")

数据容器：set(集合)

为什么使用集合

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

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

通过特性来分析：

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

由上，可以看出列表、元组、字符串存在局限性，就是“支持重复元素且有序“。

如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。而集合，最主要的特点就是不支持元素的重复（自带去重功能）、并且内容无序。

集合的定义

基本语法：

# 定义集合字面量

{元素, 元素, ……, 元素}

# 定义集合变量

变量名称 = {元素, 元素, ……, 元素}

# 定义空集合

变量名称 = set()

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

• 列表使用：[]
• 元组使用：()
• 字符串使用：""
• 集合使用：{}

# 定义集合

my_set1 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}

print(f"my_set1集合的内容是：{my_set1}，类型是：{type(my_set1)}")

输出结果：

my_set1集合的内容是：{'学习Python', 'Hello', '数据容器', 'itcainiao', 'world'}，类型是：

# 定义空集合

my_set2 = set()

print(f"my_set2集合的内容是：{my_set2}，类型是：{type(my_set2)}")

输出结果：

my_set2集合的内容是：set()，类型是：

集合的常用操作 - 修改

首先，因为集合是无序的，所以集合不支持：下表索引访问；但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

添加新元素

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

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

my_set = {"Hello", "world"}

my_set.add("itcainiao")

print(my_set) # 结果{"Hello", "world", "itcainiao"}

# 添加元素

my_set3 = {"Hello", "world", "itcainiao"}

my_set3.add("数据容器")

print(f"my_set3集合的内容是：{my_set3}")

输出结果：

my_set3集合的内容是：{'itcainiao', '数据容器', 'Hello', 'world'}

移除元素

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

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

my_set = {"Hello", "world", "itcainiao"}

my_set.remove("Hello")

print(my_set) # 结果{"world", "itcainiao"}

# 删除元素

my_set4 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}

my_set4.remove("学习Python")

print(f"my_set4集合的内容是：{my_set4}")

输出结果：

my_set4集合的内容是：{'Hello', '数据容器', 'itcainiao', 'world'}

从集合中随机取出元素

语法：集合.pop()

功能：从集合中随机取出一个元素。

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

# 随机取出一个元素

my_set5 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}

element = my_set5.pop()

print(f"my_set5集合随机取出一个元素的结果是：{element}")

输出结果：

my_set5集合随机取出一个元素的结果是：学习Python

清空集合

语法：集合.clear()

功能：清空集合

结果：集合本身被清空。

# 清空集合

my_set6 = {"Hello", "world", "itcainiao", "数据容器", "学习Python"}

my_set6.clear()

print(f"my_set6集合清空的结果是：{my_set6}")

输出结果：

my_set6集合清空的结果是：set()

取出2个集合的差集

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

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

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

# 取2个集合的差集

set1 = {1, 2, 3}

set2 = {1, 5, 6}

set3 = set1.difference(set2)

print(f"取出差集后的结果是：{set3}")

print(f"取出差集后，原有set1的结果是：{set1}")

print(f"取出差集后，原有set2的结果是：{set2}")

输出结果：

取出差集后的结果是：{2, 3}

取出差集后，原有set1的结果是：{1, 2, 3}

取出差集后，原有set2的结果是：{1, 5, 6}

消除2个集合的差集

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

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

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

# 清除2个集合的差集

set1 = {1, 2, 3}

set2 = {1, 5, 6}

set1.difference_update(set2)

print(f"消除差集后，set1的结果是：{set1}")

print(f"消除差集后，set2的结果是：{set2}")

输出结果：

消除差集后，set1的结果是：{2, 3}

消除差集后，set2的结果是：{1, 5, 6}

2个集合合并

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

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

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

# 2个集合合并成1个

set1 = {1, 2, 3}

set2 = {1, 5, 6}

set3 = set1.union(set2)

print(f"2个集合合并的结果是：{set3}")

print(f"2个集合合并后，原有set1的结果是：{set1}")

print(f"2个集合合并后，原有set2的结果是：{set2}")

输出结果：

2个集合合并的结果是：{1, 2, 3, 5, 6}

2个集合合并后，原有set1的结果是：{1, 2, 3}

2个集合合并后，原有set2的结果是：{1, 5, 6}

统计集合元素数量

语法：len(集合)

功能：统计集合内元素的个数

结果：输出统计集合元素个数的结果。

# 统计集合元素数量

set = {1, 2, 3, 4, 5, 6, 7, 8, 9}

count = len(set)

print(f"集合内元素数量是：{count}")

输出结果：

集合内元素数量是：9

集合的遍历

注意：集合不支持下标索引，不能使用while循环。

可以使用for循环：

# 集合的遍历

set = {1, 2, 3, 4, 5,}

for i in set:

print(f"集合遍历的结果是：{i}")

输出结果：

集合遍历的结果是：1

集合遍历的结果是：2

集合遍历的结果是：3

集合遍历的结果是：4

集合遍历的结果是：5

集合常用功能总结

集合的特点

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

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环

总结

集合有哪些特点

• 集合内不允许重复元素（去重）
• 集合内元素是无序的（不支持下标索引）

集合的定义方式

{元素, 元素, ……, 元素}

集合的常用操作

如何遍历集合元素

• 可以使用for循环进行遍历
• 不可以使用while循环，因为不支持下标索引

集合的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环

练习题 - 信息去重

有如下列表对象：

my_list = ["Hello", "world", "itcainiao", "数据容器", "学习Python", "itcast", "itcast", "Hello", "world", "itcainiao"]

请：

• 定义一个空集合
• 通过for循环遍历列表
• 在for循环中将列表的元素添加到集合
• 最终得到元素去重后的集合对象，并打印输出

"""

信息去重

"""

# 定义集合

my_list = ["Hello", "world", "itcainiao", "数据容器", "学习Python", "itcast", "itcast", "Hello", "world", "itcainiao"]

# 定义空集合

my_set = set()

# for循环遍历列表，并添加到集合中

for i in my_list:

my_set.add(i)

print(f"列表的内容是：{my_list}")

print(f"通过for循环后，得到的集合对象是：{my_set}")

数据容器：dict(字典、映射)

字典的定义

为什么使用字典？

生活中的字典，如新华字典，可以通过【字】就能找到对应的【含义】；所以，我们可以认为，生活中的字典就是记录的一堆：

【字】：【含义】

【字】：【含义】

……

【字】：【含义】

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

Key:Value

Key:Value

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

示例

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

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

使用字典最为合适：

{ Key Value

"王力哄":77

"周杰抡":88

"林俊结":99

}

可以通过Key（学生姓名），取到对应的Value（考试成绩）；所以，为什么使用字典？因为可以使用字典，实现用Key取出Value的操作。

字典的定义

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

# 定义字典字面量

{key:value, key:value, ……, key:value}

# 定义字典变量

my_dict = {key:value, key:value, ……, key:value}

# 定义空字典

my_dict = {}

my_dict = dict()

# 定义字典字面量

my_dict1 = {"王力哄":77, "周杰抡":88, "林俊结":99}

# 定义空字典

my_dict2 = {}

my_dict3 = dict()

print(f"字典1的内容是：{my_dict1}，类型是：{type(my_dict1)}")

print(f"字典2的内容是：{my_dict2}，类型是：{type(my_dict2)}")

print(f"字典3的内容是：{my_dict3}，类型是：{type(my_dict3)}")

# 定义重复key的字典

my_dict4 = {"王力哄":77, "王力哄":88, "林俊结":99}

print(f"重复key的字典内容是：{my_dict4}")

输出结果：

重复key的字典内容是：{'王力哄': 88, '林俊结': 99}

有重复key的字典，新的key会刷新前面的key。

字典数据的获取

字典同集合一样，不可以使用下标索引，但是字典可以通过key值来取得对应的value。

语法：字典[key]可以取到对应的value

# 通过key取对应的value

my_dict5 = {"王力哄":77, "周杰抡":88, "林俊结":99}

print(my_dict5["王力哄"])

print(my_dict5["周杰抡"])

print(my_dict5["林俊结"])

输出结果：

77

88

99

字典的嵌套

字典的key和value可以是任意数据类型（key不可为字典），那么，就表明，字典是可以嵌套的。

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

# 使用字典的嵌套，记录学生各科成绩

stu_score_dict = {

"王力哄":{

"语文":77,

"数学":66,

"英语":88

},

"周杰抡":{

"语文":88,

"数学":55,

"英语":77

},

"林俊结": {

"语文":99,

"数学":44,

"英语":66

}

}

print(f"学生的考试信息：{stu_score_dict}")

# 从嵌套字典中取数据

print(stu_score_dict["周杰抡"]["语文"])

score = stu_score_dict["林俊结"]["英语"]

print(f"林俊结的英语成绩是：{score}")

输出结果是：

学生的考试信息：{'王力哄': {'语文': 77, '数学': 66, '英语': 88}, '周杰抡': {'语文': 88, '数学': 55, '英语': 77}, '林俊结': {'语文': 99, '数学': 44, '英语': 66}}

88

林俊结的英语成绩是：66

总结

为什么使用字典？

字典可以提供基于key检索value的场景实现；就像查字典一样。

字典的定义语法

# 定义字典字面量

{key:value, key:value, ……, key:value}

# 定义字典变量

my_dict = {key:value, key:value, ……, key:value}

# 定义空字典

my_dict = {}

my_dict = dict()

字典的注意事项

• 健值对的Key和Value可以是任意类型（Key不可为字典）
• 字典内Key不允许重复，重复添加等同于覆盖原有数据
• 字典不可用下标索引，而是通过Key检索Value

字典的常用操作

新增元素

语法：字典[Key] = Value

结果：字典被修改，新增了元素

# 定义学生成绩字典

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99

}

print(f"学生的成绩是：{stu_score}")

# 新增元素

stu_score["张雪友"] = 100

print(f"新增张雪友后stu_score字典的内容是：{stu_score}")

输出结果：

学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}

新增张雪友后stu_score字典的内容是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99, '张雪友': 100}

更新元素

语法：字典[Key] = Value

结果：字典被修改，元素被更新。

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

# 定义学生成绩字典

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99

}

print(f"学生的成绩是：{stu_score}")

# 更新元素

stu_score["王力哄"] = 96

print(f"更新王力哄成绩后stu_score字典的内容是：{stu_score}")

输出结果：

学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}

更新王力哄成绩后stu_score字典的内容是：{'王力哄': 96, '周杰抡': 88, '林俊结': 99, '张雪友': 100}

删除元素

语法：字典.pop(Key)

结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除。

# 定义学生成绩字典

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99

}

print(f"学生的成绩是：{stu_score}")

# 删除元素

stu_score.pop("周杰抡")

print(f"字典stu_score删除周杰抡后的结果是：{stu_score}")

输出结果：

学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}

字典stu_score删除周杰抡后的结果是：{'王力哄': 96, '林俊结': 99, '张雪友': 100}

清空字典

语法：字典.clear()

结果：字典被修改，元素被清空。

# 定义学生成绩字典

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99

}

print(f"学生的成绩是：{stu_score}")

# 清空字典

stu_score.clear()

print(f"字典stu_score清空后的结果是：{stu_score}")

输出结果：

学生的成绩是：{'王力哄': 77, '周杰抡': 88, '林俊结': 99}

字典stu_score清空后的结果是：{}

获取全部的Key

语法：字典.keys()

结果：得到字典中的全部Key。

# 获取字典中全部的Key

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99,

"张雪友": 100

}

keys1 = stu_score.keys()

print(f"字典str_score全部的Key是：{keys1}")

输出结果：

字典str_score全部的Key是：dict_keys(['王力哄', '周杰抡', '林俊结', '张雪友'])

遍历字典

使用for循环进行遍历，因为字典中元素是无序的，所以无法使用while循环进行遍历。

方式1：通过获取全部的Key，来完成遍历。

# 通过获取全部的Key，来遍历字典

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99,

"张雪友": 100

}

keys = stu_score.keys()

for key in keys:

print(f"字典stu_score的Key是：{key}")

print(f"字典stu_score的Value是：{stu_score[key]}")

输出结果：

字典stu_score的Key是：王力哄

字典stu_score的Value是：77

字典stu_score的Key是：周杰抡

字典stu_score的Value是：88

字典stu_score的Key是：林俊结

字典stu_score的Value是：99

字典stu_score的Key是：张雪友

字典stu_score的Value是：100

方式2：直接对字典进行for循环，每一次循环就是直接得到Key。

# 对字典直接进行for循环，每一次循环都是直接得到Key

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99,

"张雪友": 100

}

for key in stu_score:

print(f"字典stu_score的Key是：{key}")

print(f"字典stu_score的Value是：{stu_score[key]}")

输出结果：

字典stu_score的Key是：王力哄

字典stu_score的Value是：77

字典stu_score的Key是：周杰抡

字典stu_score的Value是：88

字典stu_score的Key是：林俊结

字典stu_score的Value是：99

字典stu_score的Key是：张雪友

字典stu_score的Value是：100

获取字典中元素数量

语法：len(字典)

结果：获得字典元素数量。

# 统计字典中元素的数量

stu_score = {

"王力哄": 77,

"周杰抡": 88,

"林俊结": 99,

"张雪友": 100

}

count = len(stu_score)

print(f"字典stu_score中元素的个数是：{count}")

输出结果：

字典stu_score中元素的个数是：4

字典的常用操作总结

字典的特点

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

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是Key Value健值对
• 可以通过Key获取到Value，Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加、删除或更新元素等）
• 支持for循环，不支持while循环

总结

字典的常用操作

操作注意

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

字典特点

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是Key Value健值对
• 可以通过Key获取到Value，Key不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加、删除或更新元素等）
• 支持for循环，不支持while循环

练习题 - 升职加薪

有如下员工信息，请使用字典完成数据的记录。

并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元。

方法1：循环获取满足条件员工信息，定义新字典接受员工信息，升职加薪后再将员工信息更新到原字典中。

"""

某公司对员工进行升级加薪

"""

# 员工信息

personnel_dict = {

"王力哄": {

"部门": "科技部",

"工资": 3000,

"级别": 1

},

"周杰抡": {

"部门": "市场部",

"工资": 5000,

"级别": 2

},

"林俊结": {

"部门": "市场部",

"工资": 7000,

"级别": 3

},

"张雪友": {

"部门": "科技部",

"工资": 4000,

"级别": 1

},

"刘德花": {

"部门": "市场部",

"工资": 6000,

"级别": 2

}

}

print(f"全体员工当前信息：{personnel_dict}")

# 遍历员工，判断是否满足升职加薪，满足的进行升职加薪

for name in personnel_dict:

if personnel_dict[name]["级别"] == 1:

# 获取满足条件员工的信息字典

employee_personnel_dict = personnel_dict[name]

# 对满足条件的员工进行升职加薪

employee_personnel_dict["级别"] += 1

employee_personnel_dict["工资"] += 1000

# 将员工信息更新回personnel_dict

personnel_dict[name] = employee_personnel_dict

print(f"全体员工级别为1的员工升职加薪后的结果是：{personnel_dict}")

输出结果：

全体员工当前信息：{'王力哄': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}

全体员工级别为1的员工升职加薪后的结果是：{'王力哄': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}

方法2：直接对原字典进行修改

"""

某公司对员工进行升级加薪

"""

# 员工信息

personnel_dict = {

"王力哄": {

"部门": "科技部",

"工资": 3000,

"级别": 1

},

"周杰抡": {

"部门": "市场部",

"工资": 5000,

"级别": 2

},

"林俊结": {

"部门": "市场部",

"工资": 7000,

"级别": 3

},

"张雪友": {

"部门": "科技部",

"工资": 4000,

"级别": 1

},

"刘德花": {

"部门": "市场部",

"工资": 6000,

"级别": 2

}

}

print(f"全体员工当前信息：{personnel_dict}")

# 遍历员工，判断是否满足升职加薪，满足的进行升职加薪

for name in personnel_dict:

if personnel_dict[name]["级别"] == 1:

personnel_dict[name]["级别"] += 1

personnel_dict[name]["工资"] += 1000

print(f"全体员工级别为1的员工升职加薪后的结果是：{personnel_dict}")

输出结果：

全体员工当前信息：{'王力哄': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}

全体员工级别为1的员工升职加薪后的结果是：{'王力哄': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰抡': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊结': {'部门': '市场部', '工资': 7000, '级别': 3}, '张雪友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德花': {'部门': '市场部', '工资': 6000, '级别': 2}}

数据容器的总结对比

数据容器分类

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

• 是否支持下标索引

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

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

• 是否支持重复元素

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

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

• 是否可以修改

- 支持：列表、集合、字典

- 不支持：元组、字符串

数据容器特点对比

总结

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

• 列表：一批数据，可修改，可重复的存储场景
• 元组：一批数据，不可修改，可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用Key检索Value的存储场景

数据容器的通用操作

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

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

首先，在遍历上：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

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

数据容器的通用操作 - 统计功能

统计容器的元素个数

语法：len(容器)

# len统计元素数量

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 元素的个数有：{len(my_list)}")

print(f"元组 元素的个数有：{len(my_tuple)}")

print(f"字符 串元素的个数有：{len(my_str)}")

print(f"集合 元素的个数有：{len(my_set)}")

print(f"字典 元素的个数有：{len(my_dict)}")

输出结果：

列表 元素的个数有：5

元组 元素的个数有：5

字符串 元素的个数有：9

集合 元素的个数有：5

字典 元素的个数有：5

统计容器的最大元素

语法：max(容器)

# max取最大值

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 最大的元素是：{max(my_list)}")

print(f"元组 最大的元素是：{max(my_tuple)}")

print(f"字符串 最大的元素是：{max(my_str)}")

print(f"集合 最大的元素是：{max(my_set)}")

print(f"字典 最大的元素是：{max(my_dict)}")

输出结果：

列表 最大的元素是：5

元组 最大的元素是：5

字符串 最大的元素是：t

集合 最大的元素是：5

字典 最大的元素是：key5

统计容器的最小元素

语法：min(容器)

# min取最小值

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 最小的元素是：{min(my_list)}")

print(f"元组 最小的元素是：{min(my_tuple)}")

print(f"字符串 最小的元素是：{min(my_str)}")

print(f"集合 最小的元素是：{min(my_set)}")

print(f"字典 最小的元素是：{min(my_dict)}")

输出结果：

列表 最小的元素是：1

元组 最小的元素是：1

字符串 最小的元素是：a

集合 最小的元素是：1

字典 最小的元素是：key1

容器的通用操作 - 转换功能

将给定容器转换为列表

语法：list(容器)

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 转换为列表的结果是：{list(my_list)}")

print(f"元组 转换为列表的结果是：{list(my_tuple)}")

print(f"字符串 转换为列表的结果是：{list(my_str)}")

print(f"集合 转换为列表的结果是：{list(my_set)}")

print(f"字典 转换为列表的结果是：{list(my_dict)}")

输出结果：

列表 转换为列表的结果是：[1, 2, 3, 4, 5]

元组 转换为列表的结果是：[1, 2, 3, 4, 5]

字符串 转换为列表的结果是：['i', 't', 'c', 'a', 'i', 'n', 'i', 'a', 'o']

集合 转换为列表的结果是：[1, 2, 3, 4, 5]

字典 转换为列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']

将给定容器转换为元组

语法：tuple(容器)

# 将给定容器转换为元组

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 转换为元组的结果是：{tuple(my_list)}")

print(f"元组 转换为元组的结果是：{tuple(my_tuple)}")

print(f"字符串 转换为元组的结果是：{tuple(my_str)}")

print(f"集合 转换为元组的结果是：{tuple(my_set)}")

print(f"字典 转换为元组的结果是：{tuple(my_dict)}")

输出结果：

列表 转换为元组的结果是：(1, 2, 3, 4, 5)

元组 转换为元组的结果是：(1, 2, 3, 4, 5)

字符串 转换为元组的结果是：('i', 't', 'c', 'a', 'i', 'n', 'i', 'a', 'o')

集合 转换为元组的结果是：(1, 2, 3, 4, 5)

字典 转换为元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')

将给定容器转换为字符串

语法：str(容器)

# 将给定容器转换为字符串

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 转换为字符串的结果是：{str(my_list)}")

print(f"元组 转换为字符串的结果是：{str(my_tuple)}")

print(f"字符串 转换为字符串的结果是：{str(my_str)}")

print(f"集合 转换为字符串的结果是：{str(my_set)}")

print(f"字典 转换为字符串的结果是：{str(my_dict)}")

输出结果：

列表 转换为字符串的结果是：[1, 2, 3, 4, 5]

元组 转换为字符串的结果是：(1, 2, 3, 4, 5)

字符串 转换为字符串的结果是：itcainiao

集合 转换为字符串的结果是：{1, 2, 3, 4, 5}

字典 转换为字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

将给定容器转换为集合

语法：set(容器)

# 将给定容器转换为集合

my_list = [1, 2, 3, 4, 5]

my_tuple = (1, 2, 3, 4, 5)

my_str = "itcainiao"

my_set = {1, 2, 3, 4, 5}

my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(f"列表 转换为集合的结果是：{set(my_list)}")

print(f"元组 转换为集合的结果是：{set(my_tuple)}")

print(f"字符串 转换为集合的结果是：{set(my_str)}")

print(f"集合 转换为集合的结果是：{set(my_set)}")

print(f"字典 转换为集合的结果是：{set(my_dict)}")

输出结果：

列表 转换为集合的结果是：{1, 2, 3, 4, 5}

元组 转换为集合的结果是：{1, 2, 3, 4, 5}

字符串 转换为集合的结果是：{'i', 'a', 'c', 'n', 'o', 't'}

集合 转换为集合的结果是：{1, 2, 3, 4, 5}

字典 转换为集合的结果是：{'key1', 'key3', 'key2', 'key4', 'key5'}

容器通用排序功能

语法：sorted(容器, [reverse=True])

将给定的容器进行排序。

# 将给定的容器进行排序

my_list = [3, 1, 4, 2, 5]

my_tuple = (5, 3, 1, 2, 4)

my_str = "itcainiao"

my_set = {2, 5, 3, 1, 4}

my_dict = {"key5": 1, "key3": 2, "key2": 3, "key1": 4, "key4": 5}

print(f"列表 排序后的结果是：{sorted(my_list)}")

print(f"元组 排序后的结果是：{sorted(my_tuple)}")

print(f"字符串 排序后的结果是：{sorted(my_str)}")

print(f"集合 排序后的结果是：{sorted(my_set)}")

print(f"字典 排序后的结果是：{sorted(my_dict)}")

输出结果：

列表 排序后的结果是：[1, 2, 3, 4, 5]

元组 排序后的结果是：[1, 2, 3, 4, 5]

字符串 排序后的结果是：['a', 'a', 'c', 'i', 'i', 'i', 'n', 'o', 't']

集合 排序后的结果是：[1, 2, 3, 4, 5]

字典 排序后的结果是：['key1', 'key2', 'key3', 'key4', 'key5']

# 将给定的容器进行降序排序

my_list = [3, 1, 4, 2, 5]

my_tuple = (5, 3, 1, 2, 4)

my_str = "itcainiao"

my_set = {2, 5, 3, 1, 4}

my_dict = {"key5": 1, "key3": 2, "key2": 3, "key1": 4, "key4": 5}

print(f"列表 降序排序后的结果是：{sorted(my_list, reverse=True)}")

print(f"元组 降序排序后的结果是：{sorted(my_tuple, reverse=True)}")

print(f"字符串 降序排序后的结果是：{sorted(my_str, reverse=True)}")

print(f"集合 降序排序后的结果是：{sorted(my_set, reverse=True)}")

print(f"字典 降序排序后的结果是：{sorted(my_dict, reverse=True)}")

输出结果：

列表 降序排序后的结果是：[5, 4, 3, 2, 1]

元组 降序排序后的结果是：[5, 4, 3, 2, 1]

字符串 降序排序后的结果是：['t', 'o', 'n', 'i', 'i', 'i', 'c', 'a', 'a']

集合 降序排序后的结果是：[5, 4, 3, 2, 1]

字典 降序排序后的结果是：['key5', 'key4', 'key3', 'key2', 'key1']

容器通用功能总览

字符串大小比较

ASCII码表

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

• 大小写英文单词
• 数字
• 特殊符号(!、\、|、@、#、空格等)

都有其对应的ASCII码表值。

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

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

ASCII编码即美国信息交换标准代码（American Standard Code for Information Interchange）是一套共有128个字符的编码，它基于阿拉丁字母，主要作用是用来表示英语和西欧语言字符。ASCII规范编码第一次公布于1967年，ascii码在1986年完成最后一次更新。ASCII码对照表等同于国际标准 ISO/IEC 646，ASCII码对照表是世界最通用的信息交换标准。

ASCII控制字符对照表

0 - 31，共32个。ASCII码对照表0~31之间的ASCII码常用于控制像打印机一样的外围设备。

ASCII可显示字符对照表

32 - 127，共96个。ASCII码对照表32~127之间的ASCII码表示的符号，在我们的键盘上都可以被找到。其中：32表示空格，127表示删除命令。