第六章、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码表,确定字符对应的码值数字来确定大小