Python学习笔记04

第六章、Python数据容器

数据容器入门

为什么学习数据容器

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

name1 = '王丽红'

name2 = '周杰轮'

name3 = '林俊节'

name4 = '张学油'

name5 = '刘德滑'

定义五个变量

不高级且低效

name_list = ['王丽红'，'周杰轮'，'林俊节'，'张学油'，'刘德滑']

print(name_list)

运行结果：['王丽红’，‘周杰轮’，‘林俊节’，‘张学油’，‘刘德滑’]

一个变量，记录五份数据

一个变量完成

优雅、高效

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

数据容器

Python中的数据容器：

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

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

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

分为5类，分别是：

列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)我们将一一学习它们

总结

1.什么是数据容器？

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

2.Python有哪些数据容器？

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

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

数据容器：list(列表)

列表的定义

为什么需要列表

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

答：字符串变量

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

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

列表的定义

基本语法：

# 字面量

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

# 定义变量

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

# 定义空列表

变量名称 = [ ]

变量名称 = list()

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

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

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

my_list = ["itheima", "itcast", "python"]

print(my_list)

print(type(my_list))

# 输出结果：['itheima', 'itcast', 'python']

#                   <class 'list'>

my_list = ["itheima", 666 , True]

print(my_list)

print(type(my_list))

# 输出结果：['itheima', 666, True]

#                   <class 'list'>

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

print(my_list)

print(type(my_list))

# 输出结果：[[1,2,3]，[4， 5，6]]

#                   <class 'list'>

注意事项

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

总结

1.列表的定义语法

[元素1，元素2，元素3，……]

2.什么是元素？

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

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

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

列表的下标索引

列表的下标(索引)

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

我们可以使用：下标索引

元素 元素 元素 元素 元素

0         1       2      3      4

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

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

#语法：列表[下标索引]

my_list = ["Tom", "Lily", "Rose"]

print(my_list[0])   # 结果：Tom

print(my_list[1])   # 结果：Lily

print(my_list[2])   # 结果：Rose

列表的下标(索引) - 反向

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

元素 元素 元素 元素 元素

-5       -4      -3     -2    -1

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

# 语法：列表[标号]

my_list = ["Tom", "Lily", "Rose"]

print(my_list[-1])  # 结果：Rose

print(my_list[-2])  #结果：Lily

print(my_list[-3])  #结果：Tom

嵌套列表的下标(索引)

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

元素 元素 元素 元素

0        1       0      1

      0               1

列表(list)  列表（list)

例：

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

print(my_list[1][1])

输出结果：5

总结

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

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

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

元素 元素 元素 元素 元素

0         1       2      3      4

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

元素 元素 元素 元素 元素

-5       -4      -3     -2    -1

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

列表[下标]，即可取出

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

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

列表的常用操作

列表的常用操作(方法)

列表除了可以：

• 定义
• 使用下标索引获取值

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

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

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

列表的查询功能(方法)

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

在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 = ["itheima", "itcast", "python"]

print(my_list.index("itcast"))

输出结果： 1

统计列表内，有多少元素

语法：len(列表)

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

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

print(len(my_list))

输出结果：5

列表的修改功能(方法)

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

语法：列表[下标] = 值

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

# 正向下标

my_list = [1，2，3]

my_list[0] = 5

print(my_list)

输出结果：[5，2，3]

# 反向下标

my_list = [1，2，3]

my_1ist[-3] = 5

print(my_list)

输出结果： [5，2，3]

插入元素：

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

my_list = [1，2，3]

my_list.insert(1, "itheima")

print(my_list)

输出结果： [1, "itheima"，3，4]

追加元素：

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

my_list = [1, 2, 3]

my_list.append(4)

print(my_list)

输出结果： [1，2，3，4]

my_list =[1, 2,3]

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

print(my_list)

输出结果：[1, 2, 3, [4, 5, 6]]

追加元素方式2：

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

my_list =[1,2，3]

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

print(my_list)

输出结果：[1，2，3，4，5，6]

删除元素：

语法1：del 列表[下标]

语法2：列表.pop（下标）

my_list=[1，2，3]

# 方式1

del my_list[0]

print(my_list)

输出结果： [2，3]

# 方式2

my_list.pop(0)

print(my_list)

输出结果： [2，3]

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

语法：列表.remove(元素)

my_list = [1，2，3，2，3]

my_list.remove(2)

print(my_list)

输出结果： [1，3，2，3]

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

my_list = [1, 2,3]

my_list.clearO

print(my_list)

输出结果： [ ]

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

语法：列表.count(元素)

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

print(my_list.count(1))

输出结果：3

列表的方法 - 总览

编号        使用方式                    作用

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个)
• 可以容纳不同类型的元素(混装)
• 数据是有序存储的(有下标序号)
• 允许重复数据存在
• 可以修改(增加或删除元素等)

总结

列表的常见方法有：

编号        使用方式                    作用

1    列表.append(元素)           向列表中追加一个元素

2    列表.extend(容器)            将数据容器的内容依次取出，追加到列表尾部

3    列表.insert(下标，元素） 在指定下标处，插入指定的元素

4    del 列表[下标]                   删除列表指定下标元素

5    列表.pop(下标)                 删除列表指定下标元素

6    列表.remove(元素)           从前向后，删除此元素第一个匹配项

7    列表.clear()                     清空列表

8    列表.count(元素)             统计此元素在列表中出现的次数

9    列表.index(元素)             查找指定元素在列表的下标找不到报错ValueError

10    len(列表)                      统计容器内有多少元素

2.列表有哪些特点？

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

练习

练习案例：常用功能练习

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

请通过列表的功能(方法)，对其进行

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

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

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

4.取出第一个元素(应是：21)

5.查询最后一个元素(应是：30)

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

参考代码：

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

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

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

a.append(31)

print(f"{a}")

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

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

print(f"{a}")

# 取出第一个元素(应是：21)

del a[0]

print(f"{a}")

# 查询最后一个元素(应是：30)

num = a[-1]

print(f"{num}")

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

print(a.index(int("31")))

list(列表)的遍历

列表的遍历 - while循环

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

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

如何遍历列表的元素呢？

• 可以使用前面学过的while循环

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

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

循环条件如何控制？

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

语法：

index

while index < len(列表)：

元素 = 列表[index]

对元素进行处理

index += 1

例：

my_list = ["传智教育", "黑马程序员", "Python"]

# 定义一个变量用来标记列表的下标

index = 0

while index < len(my_list):

    # 通过index变量取出对应下标的元素

    element = my_list[index]

    print(f"列表的元素：{element}")

    # 至关重要 将循坏变量(index)每一次循环都+1

    index += 1

列表的遍历-for循环

除了while循环外，Python中还有另外一种循环形式：for循环。对比while，for循环更加适合对列表等数据容器进行遍历。

语法：

for 临时变量 in 数据容器：

    对临时变量进行处理

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

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

例：

def a():

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

    for element in my_list:

        print(f"列表的元素有：{element}")

a()

while循环和for循环的对比

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

在循环控制上：

• while循环可以自定循环条件，并自行控制
• for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

• while循环可以通过条件控制做到无限循环
• for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：

• while循环适用于任何想要循环的场景
• far循环适用于，遍历数据容器的场景或简单的固定次数循环场

总结

1.什么是遍历？

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

2.如何遍历列表的元素？

可以使用while或for循环

3.for循环的语法：

for 临时变量 in 数据容器：

对临时变量进行处理

4. for循环和while对比

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

练习

练习案例：取出列表内的偶数

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

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

输出示例：

通过while循环，从列表：[1，2，3，4，5，6，7，8，9，10]中取出偶数，组成新列表：[2，4，6，8，10]

通过for循环，从列表：[1，2，3，4，5，6，7，8，9，10]中取出偶数，组成新列表：[2， 4，6，8，10]

提示：

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

参考代码：

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

list_if = [ ]

list_while = [ ]

index = 0

while index < len(list):

    a = list[index]

    if a %2 == 0:

        list_while.append(a)

    index += 1

print(f"通过while循环，从列表：{list}中取出偶数，组成新列表：{list_while}")

for num in list:

    if num %2 == 0:

        list_if.append(num)

print(f"通过for循环，从列表：{list}中取出偶数，组成新列表：{list_if}")

数据容器： tuple(元组)

为什么需要元组

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

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

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

但最大的不同点在于：

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

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

定义元组

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

# 定义元组字面量

(元素，元素，......元素)

# 定义元组变量

变量名称 =（元素，元素， ，元素)

# 定义空元组

变量名称 = ()        # 方式1

变量名称 = tuple() # 方式2

注意事项

# 定义3个元素的元组

t1 = (1,'Hello', True)

# 定义1个元素的元组

t2 = ('Hello',) # 注意，必须带有逗号，否则不是元组类型

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

元组也支持嵌套：

# 定义一个嵌套元组

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

print(t1[0][0])      # 结果：1

元组的相关操作

编号        方法        作用

1            index()     查找某个数据，如果数据存在返回对应的下标，否则报错

2           count()     统计某个数据在当前元组出现的次数

3           len(元组)  统计元组内的元素个数

# 根据下标（索引）取出数据

t1 =(1, 2, 'hello')

print(t1[2])        # 结果：'hello'

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

t1 = (1, 2,'hello',3,4,'hello')

print(t1.index('hello'))  # 结果：2

# 统计某个数据在元组内出现的次数

t1=(1,2,'hello',3,4,'hello')

print(t1.count('hello')) # 结果：2

# 统计元组内的元素个数

t1 = (1,2,3)

print(len(t1)) # 结果：3

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

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的list的内容（修改元素、增加、删除、反转等)

# 尝试修改元组内容

t1=(1, 2, ['itheima','itcast'])

t1[2][1] = 'best'

print(t1)     # 结果：（1，2，['itheima , 'best'])

元组的特点

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

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

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

总结

1.元组的定义方式：

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

2.元组的操作方法：

1 index()      查找某个数据，如果数据存在返回对应的下标，否则报错

2 count()      统计某个数据在当前元组出现的次数

3 len(元组)  统计元组内的元素个数

3.元组的注意事项：

• 不可修改内容(可以修改内部list的内部元素)

4.元组的特点：

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

练习

练习案例：元组的基本操作

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

请通过元组的功能(方法)，对其进行

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

2.查询学生的姓名

3.删除学生爱好中的football

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

参考代码：

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

age = q1.index(11)

print(f'年龄所在下标：{age}')

print(f"姓名：{q1[0]}")

del q1[2][0]

print(f'删掉足球爱好{q1}')

q1[2].insert(0, 'coding')

print(f'添加爱好coding{q1}')

数据容器：str(字符串）

再识字符串

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

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

如，字符串："itheima"

i  t  h  e  i m a

0 1 2 3 4 5 6

字符串的下标(索引)

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

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

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

name = "itheima"

print(name[0]) # 结果i

print(name[-1]) # 结果a

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

所以：

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

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

字符串的常用操作

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

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

my_str = "itcast and itheima"

print(my_str.index("and")) # 结果7

字符串的替换

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

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

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

字符串的分割

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

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

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

name = "传智播客 传智教育 黑马程序员 博学谷"

name_list = name.split(" ")

print(name_list)          # 结果：['传智播客'， '传智教育'，'黑马程序员'，'博学谷']

print(type(name_list)) # 结果：<class 'list'>

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

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

语法：字符串.strip()

my_str = " itheima and itcast "

print(my_str.strip()) # 结果："itheima and itcast"

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

语法：字符串.strip（字符串）

my_str = "12itheima and itcast21"

print(my_str.strip("12")) # 结果："itheima and itcast"

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

字符串常用操作汇总

编号      操作                                             说明

1       字符串[下标]                                   根据下标索引取出特定位置字符

2       字符串.index(字符串)                      查找给定字符的第一个匹配项的下标

3       字符串.replace(字符串1，字符串2) 将字符串内的全部字符串1，替换为字符串2，不会修改原字符串，而是得到一个新的

4       字符串.split(字符串)                         按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表

5       字符串.strip() 字符串.strip(字符串) 移除首尾的空格和换行符或指定字符串

6       字符串.count(字符串)                     统计字符串内某字符串的出现次数

7       len(字符串)                                     统计字符串的字符个数

字符串的遍历

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

while循环：

my_str = "黑马程序员"

index = 0

while index < len(my_str):

    print(my_str[index])

    index += 1

for循环：

my_str = "黑马程序员"

for i in my_str:

    print(i)

输出结果：

黑

马

程

序

员

字符串的特点

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

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

总结

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

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

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

字符串[下标]                                     根据下标索引取出特定位置字符

字符串.index(字符串)                       查找给定字符的第一个匹配项的下标

字符串.replace(字符串1，字符串2) 将字符串内的全部字符串1，替换为字符串2，不会修改原字符串，而是得到一个新的

字符串.split(字符串)                          按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表

字符串.strip() 字符串.strip(字符串)   移除首尾的空格和换行符或指定字符串

字符串.count(字符串)                       统计字符串内某字符串的出现次数

len(字符串)                                       统计字符串的字符个数

3.字符串有哪些特点：

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

练习

练习案例：分割字符串

给定一个字符串："itheima itcast boxuegu"

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

输出示例：

字符串itheima itcast boxuegu中有：2个it字符

字符串itheima itcast boxuegu，被替换空格后，结果：itheima|itcast|boxuegu

字符串itheima|itcast|boxuegu，按照|分隔后，得到：［'itheima'，'itcast'，'boxuegu']

• 提示： count、replace、split

参考代码：

a = "itheima itcast boxuegu"

num = a.count("it")

print(f"字符串{a}中有：{num}个it字符")

new_a = a.replace(" ", "|")

print(f"字符串{a}，被替换空格后，结果：{new_a}")

new_b = new_a.split("|")

print(f"字符串{new_a}，按照|分隔后，得到：{new_b}")

数据容器的切片

序列

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

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

元素1 元素2 元素3 元素4 元素… 元素n

0           1         2       3         ...        n-1     索引(下标)

元素1 元素2 元素3 元素… 元素n-1 元素n

-n       -(n-1)  -(n-2)     ...          -2       -1   索引（下标）

序列的常用操作-切片

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

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

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

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

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

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

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

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

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

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

总结

1.什么是序列？

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

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

列表、元组、字符串

3.序列如何做切片

序列[起始:结束:步长]

• 起始可以省略，省略从头开始
• 结束可以省略，省略到尾结束
• 步长可以省略，省略步长为1(可以为负数，表示倒序执行)

练习

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

有字符串："万过薪月，员序程马黑来，nohtyP学"

• 请使用学过的任何方式，得到"黑马程序员"

可用方式参考：

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

参考代码：

my_str = "万过薪月，员序程马黑来，nohtyP学"

b = my_str[9:4:-1]

print(f"{b}")

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

print(f"{c}")

数据容器：set(集合)

为什么使用集合

我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。为何又需要学习新的集合类型呢？

通过特性来分析：

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

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

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

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

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

集合的定义

基本语法：

# 定义集合字面量

{元素，元素，......， 元素}

# 定义集合变量

变量名称 = {元素，元素，......，元素}

# 定义空集合

变量名称 = set()

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

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

集合的常用操作 - 修改

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

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

添加新元素

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

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

my_set = {"Hello","world"}

my_set.add("itheima")

print(my_set)    # 结果{'Hello', 'itheima', 'world'}

移除元素

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

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

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

my_set.remove("Hello")

print(my_set)     # 结果{'world', 'itheima'}

从集合中随机取出元素

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

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

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

element =my_set.pop()

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

print(element)   # 结果 'Hello'

清空集合

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

结果：集合本身被清空

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

my_set.clear()

print(my_set)    # 结果：set()    空集

取出2个集合的差集

语法：集合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，5，6} 不变

消除2个集合的差集

语法：集合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}

2个集合合并

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

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

结果：得到新集合，集合1和集合2不变 set1 = {1，2，3}

set2 = {1，5，6}

set3 = setl.union(set2)

print(set3) # 结果：{1，2，3，5，6} 新集合

print(set1) # 结果：{1，2，3} set1不变

print(set2) # 结果：{1，5，6} set2不变

集合常用功能总结

编号              操作                            说明

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.集合的常用操作

           集合.add(元素)                    集合内添加一个元素

          集合.remove(元素)               移除集合内指定的元素

              集合.pop()                        从集合中随机取出一个元素

              集合.clear()                       将集合清空

     集合1.difference(集合2)             得到一个新集合，内含2个集合的差集原有的2个集合内容不变

     集合1.difference_update(集合2) 在集合1中，删除集合2中存在的元素集合1被修改，集合2不变

         集合1.union(集合2)                得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变

                   len(集合)                       得到一个整数，记录了集合的元素数量

4.如何遍历集合元素

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

5.集合的特点

可以容纳多个数据

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

练习

信息去重

有如下列表对象：

my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']

要求：

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

输出示例：

有列表：['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']

存入集合后结果：{'itheima', 'best', 'itcast', '传智播客', '黑马程序员'}

参考代码：

my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']

my_set = set()

for b in my_list:

    my_set.add(b)

print(f"有列表：{my_list}")

print(f"存入集合后结果：{my_set}")

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

字典的定义

为什么使用字典

生活中的字典：

通过【字】

就能找到对应的【含义】

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

【字】：【含义】

【字】：【含义】

......

【字】：【含义】

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

Python中的字典：

Key: Value

Key: Value

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

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

姓名 成绩

王力鸿 77

周杰轮 88

林俊节 99

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

使用字典最为合适：

{

"王力鸿"：99，

"周杰轮"：88，

"林俊节"：77

}

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

所以，为什么使用字典？

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

字典的定义

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

# 定义字典字面量

{key: value, key: value,......,key: value}

# 定义字典变量

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

# 定义空字典

my_dict = {}       # 空字典定义方式1

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

字典数据的获取

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

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

# 语法，字典[Key]可以取到对应的Value

stu_score = {"王力鸿"：99，"周杰轮"：88，"林俊节"：77}

print(stu_score["王力鸿"]） # 结果99

print(stu_score["周杰轮"]） # 结果88

print(stu_score["林俊节"]） # 结果77

字典的嵌套

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

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

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

姓名   语文 数学 英语

王力鸿  77    66    33

周杰轮  88    86    55

林俊节   99    96   66

参考代码：

stu_score_dict = {

    "王力鸿": {

        "语文": 77,

        "数学": 66,

        "英语": 33

    }, "周杰轮": {

        "语文": 88,

        "数学": 86,

        "英语": 55

    }, "林俊杰": {

        "语文": 99,

        "数学": 96,

        "英语": 66

    }

}

score = stu_score_dict["周杰轮"]["语文"]

print(f"周杰轮的语文分数是：{score}")

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

print(f"林俊杰的英语分数是：{score}")

总结

1.为什么使用字典

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

就像查字典一样

2.字典的定义语法

# 定义字典字面量

{key: value, key: value,......,key: value}

# 定义字典变量

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

# 定义空字典

my_dict = {}      # 空字典定义方式1

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

3. 字典的注意事项

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

字典的常用操作

字典的常用操作

新增元素

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

stu_score = {

    "王力鸿"：77，

    "周杰轮"：88，

    "林俊节"：99

}

# 新增：张学油的考试成绩

stu_score['张学油'] = 66

print(stu_score) # 结果：{'王力鸿'：77，'周杰轮'：88，'林俊节'：99，'张学油'：66}

更新元素

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

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

stu_score = {

    "王力鸿"：77，

    "周杰轮"：88，

    "林俊节"：99

}

# 更新：王力鸿的考试成绩

stu_score['王力鸿'] = 100

print(stu_score) # 结果：{'王力鸿'：100，'周杰轮'：88，'林俊节'：99}

删除元素

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

stu_score = {

    "王力鸿"：77，

    "周杰轮"：88，

    "林俊节"：99

}

value = stu_score.pop("王力鸿")

print(value)        # 结果：77

print(stu_score) # 结果：{王力鸿'：100，'周杰轮'：88，'林俊节'：99}

清空字典

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

stu_score = {

    "王力鸿"：77，

    "周杰轮"：88，

    "林俊节"：99

}

stu_score.clear()

print(stu_score) # 结果：{ }

获取全部的key

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

stu_score = {

    "王力鸿"：77，

    "周杰轮"：88，

    "林俊节"：99

}

keys = stu_score.keys()

print(keys) # 结果：dick_keys(['王力鸿'，'周杰轮'，'林俊节'])

字典的常用操作总结

编号 操作                 说明

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循环

总结

1.字典的常用操作

字典[Key]           获取指定Key对应的Value值

字典[Key]=Value 添加或更新键值对

字典.pop(Key)    取出Key对应的Value并在字典内删除此Key的键值对

字典.clear()        清空字典

字典.keys()         获取字典的全部Key，可用于for循环遍历字典

len(字典）          计算字典内的元素数量

2.操作注意

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

3.字典的特点

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

练习

升职加薪

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

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

姓名      部门     工资    级别

王力鸿 科技部   3000     1

周杰轮 市场部   5000     2

林俊节 市场部   7000     3

张学油 科技部   4000     1

刘德滑 市场部   6000     2

运行后，输出如下信息：

全体员工当前信息如下：

{'王力鸿': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰轮': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊节': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学油': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德滑': {'部门': '市场部', '工资': 6000, '级别': 2}}

全体员工级别为1的员工完成升职加薪操作，操作后，

{'王力鸿': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰轮': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊节': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学油': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德滑': {'部门': '市场部', '工资': 6000, '级别': 2}}

my_dict = {

    "王力鸿": {

        "部门": "科技部",

         "工资": 3000,

         "级别": 1

    },

    "周杰轮": {

        "部门": "市场部",

        "工资": 5000,

        "级别": 2

    },

    "林俊节": {

        "部门": "市场部",

        "工资": 7000,

        "级别": 3

    },

    "张学油": {

        "部门": "科技部",

        "工资": 4000,

        "级别": 1

    },

    "刘德滑": {

        "部门": "市场部",

        "工资": 6000,

        "级别": 2

    }

}

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

for name in my_dict:

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

        a = my_dict[name]

        a["级别"] = 2

        a["工资"] += 1000

        my_dict[name] = a

print(f"全体员工级别为1的员工完成升职加薪操作，操作后，{my_dict}")

拓展 数据容器对比总结

数据容器分类

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

是否支持下标索引

• 支持：列表、元组、字符串-序列类型
• 不支持：集合、字典-非序列类型

是否支持重复元素：

• 支持：列表、元组、字符串-序列类型
• 不支持：集合、字典-非序列类型

是否可以修改

• 支持：列表、集合、字典
• 不支持：元组、字符串

数据容器特点对比

                 列表        元组        字符串      集合       字典

元素数量 支持多个 支持多个 支持多个 支持多个 支持多个

元素类型    任意        任意       仅字符     任意     Key:Value，Key：除字典外任意类型，Value：任意类型

下标索引     支持       支持        支持       不支持    不支持

重复元素     支持       支持        支持        不支持    不支持

可修改性      支持     不支持     不支持      支持       支持

数据有序        是         是           是             否            否

总结

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

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

数据容器的通用操作

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

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

首先，在遍历上：

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

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

数据容器的通用统计功能

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

len(容器)

统计容器的元素个数

my_list = [1, 2, 3]

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

my_str = "itiheima"

print(len(my list)) # 结果3

print(len(my_tuple)) # 结果5

print(len(my_str)) # 结果7

max(容器)

统计容器的元素个数

my_list = [1, 2, 3]

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

my_str = "itiheima"

print(len(my list)) # 结果3

print(len(my_tuple)) # 结果5

print(len(my_str)) # 结果t

min(容器)

统计容器的元素个数

my_list = [1, 2, 3]

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

my_str = "itiheima"

print(len(my list)) # 结果1

print(len(my_tuple)) # 结果1

print(len(my_str)) # 结果a

容器的通用转换功能

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

list(容器)

将给定容器转换为列表

str(容器)

将给定容器转换为字符串

tuple(容器)

将给定容器转换为元组

set(容器)

将给定容器转换为集合

容器通用排序功能

通用排序功能：

sorted(容器, [reverse=True])

将给定容器进行排序

容器通用功能总览

功能            描述

通用for循环 遍历容器（字典是遍历key）

max             容器内最大元素

min()            容器内最小元素

len()             容器元素个数

list()             转换为列表

tuple()          转换为元组

str()              转换为字符串

set()             转换为集合

sorted(序列，[reverse=True]） 排序，reverse=True表示降序，得到一个排好序的列表

拓展 字符串大小比较

ASCII码表

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

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

都有其对应的ASCII码表值

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

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

字符串比较

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

字符串abc a b c

字符串abd(大) a b d(大)

字符串a a

字符串ab(大) a b(大)

总结

1.字符串如何比较

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

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

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