系列文章目录

python入门(一)——你好python
python入门(二)——python基础语法
python入门(三)——python判断语句
python入门(四)——python循环语句
python入门(五)——python函数
python入门(七)——python函数进阶

---

---

1 数据容器入门

一个变量记录六份数据

name_list = ['王力宏', '周杰伦', '林俊杰', '张学友', '周星驰', '刘德华']
print(name_list)['王力宏', '周杰伦', '林俊杰', '张学友', '周星驰', '刘德华']

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

根据是否支持重复元素、是否可以修改、是否有序等分为五类：列表list、元组tuple、字符串str、集合set、字典dict

2 数据容器：list(列表)

# 字面量
[元素1、元素2、元素3、元素4、...]# 定义变量
变量名称 = [元素1、元素2、元素3、元素4、...]# 定义空列表
变量名称 = []
变量名称 = list()

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

name_list = ['王力宏', 666, 'python', '张学友', '周星驰', '刘德华']
print(name_list)
print(type(name_list))['王力宏', 666, 'python', '张学友', '周星驰', '刘德华']
<class 'list'>

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list)
print(type(name_list))[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
<class 'list'>

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[3])['王力宏', 666, 'python']
张学友
周星驰
刘德华

列表可以反向索引，从后向前依次递减（-1、-2、-3…）

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list[-4])
print(name_list[-3])
print(name_list[-2])
print(name_list[-1])['王力宏', 666, 'python']
张学友
周星驰
刘德华

嵌套列表同样支持下标索引

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list[0][0])
print(name_list[0][1])
print(name_list[0][2])王力宏
666
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)

查询某元素的下标

列表.index(元素)
index是列表对象(变量)内置的方法(函数)

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list.index("张学友"))1

修改特定位置(索引)的元素值

列表[下标] = 值

直接对指定下标的值进行重新赋值(修改)

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list[1] = 888
name_list[-1] = 111
print(name_list)[['王力宏', 666, 'python'], 888, '周星驰', 111]

插入元素

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list.insert(1, "张国荣")
print(name_list)[['王力宏', 666, 'python'], '张国荣', '张学友', '周星驰', '刘德华']

追加元素

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list.append("张国荣")
print(name_list)[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华', '张国荣']

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list.extend(["张国荣", "邓丽君"])
print(name_list)[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华', '张国荣', '邓丽君']name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list2 = ["张国荣", "邓丽君"]
name_list.extend(name_list2)
print(name_list)[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华', '张国荣', '邓丽君']

删除元素

del 列表[下标]

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
del name_list[0]
print(name_list)['张学友', '周星驰', '刘德华']

列表.pop(下标)

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
out_name = name_list.pop(1)
print(name_list)
print(f"取出的元素是：{out_name}")[['王力宏', 666, 'python'], '周星驰', '刘德华']
取出的元素是：张学友

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

num1 = [1, 2, 3, 2, 3]
num1.remove(2)
print(num1)[1, 3, 2, 3]

列表.clear()
清空列表内容

num1 = [1, 2, 3, 2, 3]
num1.clear()
print(num1)[]

统计某个元素的数量

列表.count(元素)
统计某元素在列表内的数量

num1 = [1, 2, 3, 2, 3]
print(num1.count(3))2

统计列表内的元素数量

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

num1 = [1, 2, 3, 2, 3]
print(len(num1))5

总结

列表特点

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

student_age = [21, 25, 21, 23, 22, 20]
student_age.append(31)
student_age.extend([29, 33, 30])
print(f"列表中取出的第一个元素是：{student_age[0]}")
print(f"列表中取出的最后一个元素是：{student_age[-1]}")
print(f"列表中元素31的下标是：{student_age.index(31)}")
print(f"最后的列表内容是：{student_age}")列表中取出的第一个元素是：21
列表中取出的最后一个元素是：30
列表中元素31的下标是：6
最后的列表内容是：[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

3 list(列表)的遍历

while循环遍历

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

index = 0
while index < len(列表):元素 = 列表[index]对元素进行处理index += 1

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
index = 0
while index < len(name_list):name = name_list[index]print(name)index += 1['王力宏', 666, 'python']
张学友
周星驰
刘德华

for循环

for 临时变量 in 数据容器:对临时变量进行处理

从容器内依次取出元素并赋值到临时变量上，在每一次循环中，可以对临时变量（元素）进行处理

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
for name in name_list:print(name)['王力宏', 666, 'python']
张学友
周星驰
刘德华

while循环和for循环比较

循环控制：

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

无限循环：

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

使用场景：

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

总结：

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

new_list = []
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for element in my_list:if element % 2 == 0:new_list.append(element)
print(f"通过for循环，从列表:{my_list}中取出偶数，组成新列表：{new_list}")通过for循环，从列表:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数，组成新列表：[2, 4, 6, 8, 10]new_list = []
element = 0
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
while element < len(my_list):my_element = my_list[element]if my_element % 2 == 0:new_list.append(my_element)element += 1
print(f"通过while循环，从列表:{my_list}中取出偶数，组成新列表：{new_list}")通过while循环，从列表:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数，组成新列表：[2, 4, 6, 8, 10]

4 数据容器：tuple(元祖)

元祖同列表一样，都是可以封装多个、不同类型的元素在内，最大的不同点在于元组一旦定义完成，不可修改

定义元组

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

# 定义元组字面量
(元素, 元素, 元素, ......, 元素)
# 定义元组变量
变量名称 = (元素, 元素, 元素, ......, 元素)
# 定义空元组
变量名称 = ()
变量名称 = tuple()

注意

# 定义3个元素的元组
t1 = tuple(1, "hello", True)
# 定义1个元素的元组
t2 = ("hello", )
# 必须带有逗号，否则不是元组类型

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

t1 = ("hello", )
t2 = ("hello")
print(f"t1类型：{type(t1)}")
print(f"t2类型：{type(t2)}")t1类型：<class 'tuple'>
t2类型：<class 'str'>

元组也支持嵌套：

t1 = ((1, 2, 3), (4, 5, 6))
print(t1)
print(t1[0][1])((1, 2, 3), (4, 5, 6))
2

元组操作

t1 = (1, 2, 3, "hello", 4, 5, "hello", 3)
print(f"元素3的下标：{t1.index(3)}")
print(f"元组中hello元素出现的次数：{t1.count('hello')}")
print(f"元组含有的数量数目：{len(t1)}")元素3的下标：2
元组中hello元素出现的次数：2
元组含有的数量数目：8

遍历的方式跟列表是一样的，for和while遍历

注意：

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

t1 = (1, 2, 3, ["hello", 4, 5], "hello", 3)
t1[3][0] = "world"
print(t1)(1, 2, 3, ['world', 4, 5], 'hello', 3)

元组特点：

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

student = ('周杰伦', 11, ['football', 'music'])
print(f"学生年龄下标位置：{student.index(11)}")
print(f"学生姓名：{student[0]}")
del student[2][0]
student[2].append('coding')
print(f"更改后的学生信息：{student}")学生年龄下标位置：1
学生姓名：周杰伦
更改后的学生信息：('周杰伦', 11, ['music', 'coding'])

5 数据容器：str(字符串)

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

字符串的下标/索引

也可以通过下标进行访问，从前向后下标从0开始，从后向前，下标从-1开始

name = "ithemia"
print(name[0])
print(name[-1])i
a

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

查找下标索引值

字符串.index(字符串)

name = "itheima and itcast"
print(name.index("t"))
print(name.index("and"))1
8

字符串的替换

字符串.replace(字符串1, 字符串2)

将字符串内的全部：字符串1替换为字符串2，不是修改字符串本身，而是得到一个新字符串

name = "itheima and itcast"
new_name = name.replace("and", "or")
print(f"将{name}替换成{new_name}")将itheima and itcast替换成itheima or itcast

字符串的分割

字符串.split(分隔符字符串)

按照指定的分割符字符串，将字符串划分为多个字符串，并存入列表对象中，字符串本身不变，而是得到一个列表对象

name = "itheima and itcast"
new_name = name.split(" ")
print(f"将{name}切割成{new_name}，类型是{type(new_name)}")将itheima and itcast切割成['itheima', 'and', 'itcast']，类型是<class 'list'>

字符串去前后空格

字符串.strip()

不传入参数默认直接去除首尾空格

name = " itheima and itcast "
new_name = name.strip(" ")
print(f"{name}去前后空格变成：{new_name}")itheima and itcast 去前后空格变成：itheima and itcast

name = " itheima and itcast "
new_name = name.strip()
print(f"{name}不传入参数：{new_name}")itheima and itcast 不传入参数：itheima and itcast

字符串去前后制定字符

字符串.strip(字符串)

name = "12itheima and itcast21"
new_name = name.strip("12")
print(f"{name}去strip('12')变成：{new_name}")12itheima and itcast21去strip('12')变成：itheima and itcast

注意：
传入的参数是“12”其实是**“1”和“2”都会被移除**，是按照单个字符串

统计字符串出现次数

字符串.count(字符串1)

name = "12itheima and itcast21"
print(name.count("it"))2

字符串长度

len(字符串)

name = "12itheima and itcast21"
print(len(name))22

常用操作汇总

字符串的遍历同上，用while和for循环
字符串的特点：

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

my_str = "itheima itcast boxuegu"
print(f"字符串{my_str}中有：{my_str.count('it')}个it字符")
new_my_str = my_str.replace(" ", "|")
print(f"字符串{my_str}，被替换空格后，结果：{new_my_str}")
print(f"字符串{new_my_str}，按照|分隔后，得到：{new_my_str.split('|')}")字符串itheima itcast boxuegu中有：2个it字符
字符串itheima itcast boxuegu，被替换空格后，结果：itheima|itcast|boxuegu
字符串itheima|itcast|boxuegu，按照|分隔后，得到：['itheima', 'itcast', 'boxuegu']

6 数据容器(序列)的切片

序列是指内容连续、有序，可使用下标索引的一列数据容器，列表、元组、字符串均可以视为序列

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

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

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

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

切片操作不会影响序列本身，而是产生新的序列

my_str = "园乐堡奇比，到来迎欢"
print(my_str[4:1:-1])
print(my_str[::-1][5:8])比奇堡
比奇堡

7 数据容器：set(集合)

集合特点：不支持元素重复，自带去重功能，并且内容无序

# 定义集合字面量
{元素, 元素, ..., 元素}
# 定义集合变量
变量名称 = {元素, 元素, ..., 元素}
# 定义空集合
变量名称 = set()

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}print(my_set){'章鱼哥', '泡芙老师', '痞老板', '蟹老板', '海绵宝宝', '姗迪', '派大星'}

集合是无序的，所以集合不支持下标索引访问，但是集合和列表是一样允许修改的

添加新元素

集合.add(元素)

将指定元素添加到集合内，集合本身被修改，添加新元素

my_set = {'hello', 'world'}
my_set.add('!')
print(my_set){'hello', '!', 'world'}

移除元素

集合.remove(元素)

将指定元素从集合内一处，集合本身被修改，移除元素

my_set = {'hello', 'world'}
my_set.remove('hello')
print(my_set){'world'}

随机移除一个元素

集合.pop()

从集合中随机取出一个元素，会得到一个元素的结果，同时集合本身被修改，元素被移除

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}
element = my_set.pop()
print(element)
print(my_set)章鱼哥
{'姗迪', '蟹老板', '泡芙老师', '痞老板', '海绵宝宝', '派大星'}

清空集合

集合.clear()

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}
my_set.clear()
print(my_set)set()

取出集合之间的差集

集合1.difference(集合2)

取出集合1和集合2的差集，集合1有的而集合2没有的，得到一个新集合，但是集合1和集合2不变

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = {1, 2, 3}
print(my_set1.difference(my_set2))
print(my_set1)
print(my_set2){'b', 'c', 'a'}
{1, 2, 3, 'c', 'b', 'a'}
{1, 2, 3}

消除集合之间的差集

集合1.difference_update(集合2)

对比集合1和集合2，在集合1内删除和集合2相同的元素，集合1被修改，集合2不变

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = {1, 2, 3}
my_set1.difference_update(my_set2)
print(my_set1)
print(my_set2){'a', 'b', 'c'}
{1, 2, 3}

集合之间合并

集合1.union(集合2)

将集合1和集合2组合成新集合，集合1和集合2不变

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = {1, 2, 3}
my_set3 = my_set1.union(my_set2)
print(my_set1)
print(my_set2)
print(my_set3){1, 2, 3, 'a', 'c', 'b'}
{1, 2, 3}
{1, 2, 3, 'a', 'c', 'b'}

集合元素数量

len(集合)

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}print(len(my_set))7

遍历集合

遍历集合不支持while，因为集合不支持下标索引，但可用for循环遍历

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}for element in my_set:print(element)痞老板
蟹老板
章鱼哥
姗迪
海绵宝宝
泡芙老师
派大星

集合总结

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

my_list = ["姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"]
my_set = set()
for element in my_list:my_set.add(element)print(f"列表：{my_list}")
print(f"存入集合后结果：{my_set}")列表：['姗迪', '海绵宝宝', '派大星', '蟹老板', '章鱼哥', '痞老板', '泡芙老师', '姗迪', '海绵宝宝', '派大星', '蟹老板', '章鱼哥', '痞老板', '泡芙老师']
存入集合后结果：{'蟹老板', '痞老板', '海绵宝宝', '姗迪', '派大星', '章鱼哥', '泡芙老师'}

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

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

字典定义

# 定义字典字面量
{key: value, key: value, ..., key: value}
# 定义字典变量
my_dict = {key: value, key: value, ..., key: value}
# 定义空字典
my_dict = {}
my_dict = dict()

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

my_dict = {"海绵宝宝": 98, "派大星": 54, "章鱼哥": 100}
print(my_dict["海绵宝宝"])
print(my_dict["派大星"])
print(my_dict["章鱼哥"])98
54
100

字典嵌套

字典的key和value可以是任意数据类型(key不可为字典)，可以嵌套

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}
print(f"海绵宝宝的语文成绩：{stu_score_dict['海绵宝宝']['语文']}")
print(f'派大星的各科成绩：{stu_score_dict["派大星"]}')海绵宝宝的语文成绩：77
派大星的各科成绩：{'语文': 88, '数学': 86, '英语': 55}

字典内的key不允许重复，重复添加等同于覆盖原有数据

新增/更新元素

字典[key] = value

字典被修改，value值改变，key存在则更新value，key不存在则增加value

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}stu_score_dict['海绵宝宝']['语文'] = 90
stu_score_dict['海绵宝宝']['体育'] = 95
print(f"海绵宝宝的各科成绩：{stu_score_dict['海绵宝宝']}")海绵宝宝的各科成绩：{'语文': 90, '数学': 66, '英语': 33, '体育': 95}

删除元素

字典.pop(key)

获得指定key的value，同时字典被修改，指定key的数据被删除

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}stu_score_dict.pop("章鱼哥")
print(f"学生的各科成绩：{stu_score_dict}")学生的各科成绩：{'海绵宝宝': {'语文': 77, '数学': 66, '英语': 33}, '派大星': {'语文': 88, '数学': 86, '英语': 55}}

清空字典

字典.clear()

字典被修改，元素被清空

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}stu_score_dict.clear()
print(f"学生的各科成绩：{stu_score_dict}")学生的各科成绩：{}

获取全部key

字典.keys()

得到字典中的全部key

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}print(f"学生姓名：{stu_score_dict.keys()}")学生姓名：dict_keys(['海绵宝宝', '派大星', '章鱼哥'])

遍历字典

方式一

取出所有key的基础上用for循环遍历

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}
keys = stu_score_dict.keys()
for key in keys:print(f"学生姓名:{key}")print(f"学生各科成绩:{stu_score_dict[key]}")学生姓名:海绵宝宝
学生各科成绩:{'语文': 77, '数学': 66, '英语': 33}
学生姓名:派大星
学生各科成绩:{'语文': 88, '数学': 86, '英语': 55}
学生姓名:章鱼哥
学生各科成绩:{'语文': 99, '数学': 96, '英语': 66}

方式二

直接对字典for循环，每一次循环都是直接得到key

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}for key in stu_score_dict:print(f"学生姓名:{key}")print(f"学生各科成绩:{stu_score_dict[key]}")学生姓名:海绵宝宝
学生各科成绩:{'语文': 77, '数学': 66, '英语': 33}
学生姓名:派大星
学生各科成绩:{'语文': 88, '数学': 86, '英语': 55}
学生姓名:章鱼哥
学生各科成绩:{'语文': 99, '数学': 96, '英语': 66}

不支持下标索引，因此不支持while循环

字典元素数量

len(字典)

stu_score_dict = {"海绵宝宝": {"语文": 77,"数学": 66,"英语": 33},"派大星": {"语文": 88,"数学": 86,"英语": 55},"章鱼哥": {"语文": 99,"数学": 96,"英语": 66}}print(len(stu_score_dict))3

操作总结

字典特点：

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

company = {"王力宏": {"部门": "科技部","工资": 3000,"级别": 1},"周杰伦": {"部门": "市场部","工资": 5000,"级别": 2},"林俊杰": {"部门": "市场部","工资": 7000,"级别": 3},"张学友": {"部门": "科技部","工资": 4000,"级别": 1},"刘德华": {"部门": "市场部","工资": 6000,"级别": 2}
}
print(f'全体员工当前信息如下：\n{company}')for employee in company:if company[employee]['级别'] == 1:company[employee]['级别'] += 1company[employee]['工资'] += 1000print(f'全体员工级别为1的员工完成升职加薪操作，操作后：\n{company}')全体员工当前信息如下：
{'王力宏': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}
全体员工级别为1的员工完成升职加薪操作，操作后：
{'王力宏': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}

9 数据容器总结对比

数据容器分类

是否支持下标索引：

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

是否支持重复元素：

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

是否可以修改：

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

各数据容器应用场景：

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

10 数据容器的通用操作

遍历上：

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

尽管遍历形式各不相同，但都支持遍历操作

len(容器)：统计容器的元素个数
max(容器)：统计容器的最大元素
min(容器)：统计容器的最小元素
list(容器)：将给定容器转换为列表
str(容器)：将给定容器转换为字符串
tutple(容器)：将给定容器转换为元组
set(容器)：将给定容器转换为集合
sorted(容器, [reverse = True])：将给定容器进行排序，当需要设置反向排序时，加上中括号的内容

company = {"王力宏": {"部门": "科技部","工资": 3000,"级别": 1},"周杰伦": {"部门": "市场部","工资": 5000,"级别": 2},"林俊杰": {"部门": "市场部","工资": 7000,"级别": 3},"张学友": {"部门": "科技部","工资": 4000,"级别": 1},"刘德华": {"部门": "市场部","工资": 6000,"级别": 2}
}print(list(company))
# 字典转换成列表，只保留key部分，抛弃value
['王力宏', '周杰伦', '林俊杰', '张学友', '刘德华']print(str(company))
# 字典转换成字符串，形式不变，默认输出的双引号不显示
{'王力宏': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}print(sorted(company))
# 从小到大排列
['刘德华', '周杰伦', '张学友', '林俊杰', '王力宏']print(sorted(company, reverse=True))
# 从大到小排列
['王力宏', '林俊杰', '张学友', '周杰伦', '刘德华']

其他类型没有办法转换成字典，因为没有键值对

字符串大小比较

ASCII码表

大小写英文单词、数字、特殊符号（!、\、|、@、#、空格）都有其对应的ASCII码表，字符串的比较就是基于码值大小进行比较

字符串按位比较，只要有一位大，后面就无需比较了

总结

python入门(六)——python数据容器相关推荐

1. 怎么学python入门？python新手学习路线

   怎么学python入门?python新手学习路线,Python入门应该了解一些基本的计算机编程术语.Python 是一个高层次的结合了解释性.编译性.互动性和面向对象的脚本语言,Python 的设计具 ...

2. python三大器,Python 入门之 Python三大器 之 生成器

   Python 入门之 Python三大器 之 生成器 1.生成器 (1)什么是生成器? 核心:生成器的本质就是一个迭代器 迭代器是Python自带的 生成器程序员自己写的一种迭代器 def func( ...

3. Python入门之 Python内置函数

   Python入门之 Python内置函数 函数就是以功能为导向,一个函数封装一个功能,那么Python将一些常用的功能(比如len)给我们封装成了一个一个的函数,供我们使用,他们不仅效率高(底层都是用 ...

4. python入门指南-Python入门指南

   原标题:Python入门指南 python是一门编程语言,本文主要讲述了python入门的基础知识. 目录 一.编程与编程语言 二.编程语言分类 三.主流编程语言介绍 四.python介绍 五.安装p ...

5. python快速编程入门课后简答题答案-编程python入门 编程python入门课后习题

   编程python入门 编程python入门课后习题 米粒妈咪课堂小编整理了填空.选择.判断等一些课后习题答案,供大家参考学习. 第一章 一.填空题 Python是一种面向对象的高级语言. Python ...

6. Python入门：Python基础

   Python入门:Python基础 前言 随着Python的火爆发展,我们都想加入到这个热潮里.我们知道Python是一种面向对象的,解释型的计算机语言,它的特点是语法简介,优雅,简单易学.那么我们就 ...

7. Python入门之Python Colorama模块

   Python入门之Python Colorama模块 Python的Colorama模块,可以跨多终端,显示字体不同的颜色和背景,只需要导入colorama模块即可,不用再每次都像linux一样指定颜 ...

8. [Python爬虫] 六、数据提取之XPath与lxml类库

   往期内容提要: [Python爬虫] 一.爬虫原理之HTTP和HTTPS的请求与响应 [Python爬虫] 二.爬虫原理之定义.分类.流程与编码格式 [Python爬虫] 三.数据抓取之Request ...

9. 【Python入门】Python字符串的45个方法详解

   Python中字符串对象提供了很多方法来操作字符串,功能相当丰富.必须进行全面的了解与学习,后面的代码处理才能更得心应手,编程水平走向新台阶的坚实基础.目前一共有45个方法,给大家分类整理,可以收藏查 ...

最新文章

1. 开发小程序商城必看：社交电商的销售玩法
2. Single-Shot Calibration：基于全景基础设施的多相机和多激光雷达之间的外参标定（IROS2021）...
3. UPS不间断电源常见故障及如何排除故障
4. Activity到底是什么时候显示到屏幕上的呢
5. Java DSL简介（收集整理）
6. InnoDB架构，一幅图秒懂！
7. sass webpack_如何在Visual Studio和Webpack中编译Sass文件
8. esp32 micropython 加密_ESP32 MicroPython教程：使用SHA-256
9. 在软件工程中有两件难事
10. TGARS 2019: What, Where, and How to Transfer in SAR Target Recognition Based on Deep CNNs ——学习笔记
11. mysql 执行查询_MySQL执行一个查询的过程
12. js 日期时间的格式化工具类
13. 手机游戏连接计算机屏幕,手机怎么投屏到电脑？简单几个步骤就能实现，看电影玩游戏爽爆了...
14. java实现手机定位，java实时定位，定位功能，gps定位-适合定位小孩，老人，保护家人安全】
15. Android Canvas绘制丘比特之箭
16. auto.ja 部落冲突01 找图并点击
17. python-模块使用方法
18. 手机触屏事件（jquery）
19. 英文查错系统【浙江工商大学oj 测试点分析】
20. 基于GeoServer的电子地图系统说明

热门文章

1. 计算机系统结构专业学什么,江苏大学专业介绍：计算机系统结构
2. 转 信安之路 CTF初识与深入
3. skylake服务器处理器M系列,详解第6代英特尔酷睿M处理器！
4. 智能可穿戴设备如何跨越监测数据不准的鸿沟？
5. 华硕笔记本X450JB拆机及加装固态硬盘
6. Android DRM框架分析
7. pytest中参数化方法,并且根据执行的命令进行动态参数化
8. 2021 美赛时间安排表
9. PHP 简易聊天室 利用redis的订阅发布功能
10. 计算机专业120分,【哈尔滨工业大学，专业课120分】跟你唠点真情实感。