上海三凯建设管理咨询有限公司网站,网站开发入门书籍推荐,福州公司排名,快速建立平台网站开发需要多少钱Python-第六天 Python数据容器一、数据容器入门1.数据容器二、数据容器#xff1a;list(列表)1.列表的定义2.列表的下标#xff08;索引#xff09;3.列表的常用操作#xff08;方法#xff09;4.练习案例:常用功能练习5.list#xff08;列表#xff09;的遍历5.1 列表的…
Python-第六天 Python数据容器一、数据容器入门1.数据容器二、数据容器list(列表)1.列表的定义2.列表的下标索引3.列表的常用操作方法4.练习案例:常用功能练习5.list列表的遍历5.1 列表的遍历 - while循环5.2 列表的遍历 - for 循环5.3 while循环和for循环的对比5.4 练习三、数据容器tuple(元组)1.元祖的定义2.元祖的操作3.元祖的特点4.练习案例:元组的基本操作四、数据容器str(字符串)1.再识字符串2.字符串的下标索引3.字符串常用操作汇总4.字符串的遍历5.字符串的特点6.练习案例分割字符串五、数据容器的切片1.序列2.序列的常用操作 - 切片3.练习案例序列的切片实践六、数据容器set(集合)1.定义和基本语法2.常用方法3.集合的特点4.练习案例信息去重七、数据容器dict(字典、映射)1.定义和基本语法2.常用方法3.字典的嵌套3.字典的特点4.案例升职加薪八、数据容器的通用操作1.数据容器对比总结2.通用操作3.字符串比较大小九、综合案例一、数据容器入门
1.数据容器
Python中的数据容器 一种可以容纳多份数据的数据类型容纳的每一份数据称之为1个元素 每一个元素可以是任意类型的数据如字符串、数字、布尔等。
数据容器根据特点的不同如
是否支持重复元素是否可以修改是否有序等
分为5类分别是 列表list、元组tuple、字符串str、集合set、字典dict 我们将一一学习它们
二、数据容器list(列表)
1.列表的定义
基本语法
# 字面量
[元素1,元素2,元素3,元素4,...]# 定义变量
变量名称 [元素1,元素2,元素3,元素4,...]# 定义空列表
变量名称 []
变量名称 list()列表内的每一个数据称之为元素
以 [] 作为标识列表内每一个元素之间用, 逗号隔开注意列表可以一次存储多个数据且可以为不同的数据类型支持嵌套
示例
my_list1 [ithema,itcast,python]
my_list2 [itheima,666,True]
my_list3 [1,2,3,[4,5,6]]
print(f{my_list1} 列表的类型为:{type(my_list1)})
print(f{my_list2} 列表的类型为:{type(my_list2)})
print(f{my_list3} 列表的类型为:{type(my_list3)})2.列表的下标索引
我们可以使用下标索引从列表中取出特定位置的数据 如图列表中的每一个元素都有其位置下标索引从前向后的方向从0开始依次递增 我们只需要按照下标索引即可取得对应位置的元素。
基本语法
# 语法: 列表[下标索引]name_list [Tom,zs,ls]
print(name_list[0]) # 结果 Tom
print(name_list[1]) # 结果 zs
print(name_list[2]) # 结果 ls 或者可以反向索引也就是从后向前从-1开始依次递减-1、-2、-3...... 如图从后向前下标索引为-1、-2、-3依次递减。
如果列表是嵌套的列表同样支持下标索引 如图下标就有2个层级了。
要注意下标索引的取值范围超出范围无法取出元素并且会报错
3.列表的常用操作方法
列表除了可以
定义使用下标索引获取值
以外列表也提供了一系列功能
插入元素删除元素清空列表修改元素统计元素个数
等等功能这些功能我们都称之为列表的方法
示例
# 查询功能 列表.index(元素
my_list [itheima,itcast,python]
print(my_list.index(itcast)) #结果 1# 修改功能# 1.修改特定位置元素的值 列表[下标] 值 正向、反向下标均可
# 1.1正向下标
my_list [1,2,3]
my_list[0] 5
print(my_list) # 结果[5,2,3]
# 1.2.反向下标
my_list [1,2,3]
my_list[-3] 5
print(my_list) # 结果[5,2,3]# 2.插入元素 列表.insert(下标元素 在指定的下标位置插入指定的元素
my_list [1,2,3]
my_list.insert(1,itheima)
print(my_list) # 结果[1,itheima,2,3]# 3.追加元素
# 3.1 列表.append(元素) 将指定元素追加到列表尾部
my_list [1,2,3]
my_list.append([4,5,6])
print(my_list) # 结果[1,2,3,[4,5,6]]
# 3.2 列表.extend(其他数据容器 将其他数据容器的内容取出依次追加到列表尾部
my_list [1,2,3]
my_list.extend([4,5,6])
print(my_list) # 结果[1,2,3,4,5,6]# 4.删除元素
# 4.1 del 列表[下标]
my_list [1,2,3]
del my_list[0]
print(my_list) # 结果[2,3]
# 4.2 列表.pop(下标
my_list [1,2,3]
my_list.pop(0)
print(my_list) # 结果[2,3]
# 4.3 列表.remove(元素) 删除某元素在列表中的第一个匹配项
my_list [1,2,3,2,3]
my_list.remove(2)
print(my_list) # 结果[1,3,2,3]
# 4.4 列表.clear() 清空列表
my_list [1,2,3,2,3]
my_list.clear()
print(my_list) # 结果[]# 列表.count(元素) 统计某元素在列表中的数量
my_list [1,1,3,1,3]
print(my_list.count(1)) # 结果3# len(列表) 统计列表内的元素个数
my_list [1,1,3,1,3]
print(len(my_list)) # 结果5经过上述对列表的学习可以总结出列表有如下特点
可以容纳多个元素上限为2**63-1、9223372036854775807个可以容纳不同类型的元素混装数据是有序存储的有下标序号允许重复数据存在可以修改增加或删除元素等
4.练习案例:常用功能练习
有一个列表内容是[21, 25, 21, 23, 22, 20]记录的是一批学生的年龄
请通过列表的功能方法对其进行
定义这个列表并用变量接收它追加一个数字31到列表的尾部追加一个新列表[29, 33, 30]到列表的尾部取出第一个元素应是21取出最后一个元素应是30查找元素31在列表中的下标位置
# 定义这个列表并用变量接收它
age_list [21, 25, 21, 23, 22, 20]
print(age_list)
# 追加一个数字31到列表的尾部
age_list.append(31)
print(age_list)
# 追加一个新列表[29, 33, 30]到列表的尾部
age_list.extend([29,33,30])
print(age_list)
# 取出第一个元素应是21
print(age_list[0])
# 取出最后一个元素应是30
print(age_list[-1])
# 查找元素31在列表中的下标位置
print(age_list.index(31))5.list列表的遍历
5.1 列表的遍历 - while循环
语法
index 0
while index len(列表):元素 列表[index]对元素处理index 15.2 列表的遍历 - for 循环
语法
for 临时变量 in 数据容器:对临时变量处理5.3 while循环和for循环的对比
while循环和for循环都是循环语句但细节不同
在循环控制上
while循环可以自定循环条件并自行控制for循环不可以自定循环条件只可以一个个从容器内取出数据
在无限循环上
while循环可以通过条件控制做到无限循环for循环理论上不可以因为被遍历的容器容量不是无限的
在使用场景上
while循环适用于任何想要循环的场景for循环适用于遍历数据容器的场景或简单的固定次数循环场景
5.4 练习
定义一个列表内容是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 遍历列表取出列表内的偶数并存入一个新的列表对象中 使用while循环和for循环各操作一次 提示
通过if判断来确认偶数通过列表的append方法来增加元素 定义一个列表内容是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
遍历列表取出列表内的偶数并存入一个新的列表对象中
使用while循环和for循环各操作一次提示
通过if判断来确认偶数
通过列表的append方法来增加元素
my_list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_list []
index 0
#while
while index len(my_list):if my_list[index] % 2 0:even_list.append(my_list[index])index1
print(f通过while循环从列表{my_list}中取出偶数组成新列表{even_list})# for
even_list []
for el in my_list:if el % 2 0:even_list.append(el)
print(f通过for循环从列表{my_list}中取出偶数组成新列表{even_list})三、数据容器tuple(元组)
1.元祖的定义
元组定义定义元组使用小括号且使用逗号隔开各个数据数据可以是不同的数据类型。
语法
# 定义元祖字面量
(元素1,元素2,元素3,元素4,....)
# 定义元祖变量
变量名称 (元素1,元素2,元素3,元素4,....)
# 定义空元祖
变量名称 ()
变量名称 tuple()
# 元祖也支持嵌套
t1 ((1,2,3),(4,5,6))注意
元组一旦定义完成就不可修改.所以当我们需要在程序内封装数据又不希望封装的数据被篡改那么元组就非常合适元祖只有一个数据这个数据后面要加逗号 (元素1,)
2.元祖的操作 示例
t (1,2,hello,3,4,hello,1)
# 根据下标取出数据
print(t[2]) # 结果为 hello
# index() 查找某个数据如果数据存在返回对应的下标否则报错
print(t.index(hello)) # 结果为 2
# count() 统计某个数据在当前元组出现的次数
print(t.count(1)) # 结果为 2
# len(元组) 统计元组内的元素个数
print(len(t)) # 结果为 73.元祖的特点
可以容纳多个数据可以容纳不同类型的数据混装数据是有序存储的下标索引允许重复数据存在不可以修改增加或删除元素等支持for循环
多数特性和list一致不同点在于不可修改的特性。
4.练习案例:元组的基本操作
定义一个元组内容是‘周杰轮’, 11, [‘football’, ‘music’]记录的是一个学生的信息姓名、年龄、爱好
请通过元组的功能方法对其进行
查询其年龄所在的下标位置查询学生的姓名删除学生爱好中的football增加爱好coding到爱好list内
t (周杰轮, 11, [football, music])
print(t.index(11))
print(t[0])
t[-1].remove(football)
print(t)
t[-1].append(coding)
print(t)四、数据容器str(字符串)
1.再识字符串
尽管字符串看起来并不像列表、元组那样一看就是存放了许多数据的容器。 但不可否认的是字符串同样也是数据容器的一员。 字符串是字符的容器一个字符串可以存放任意数量的字符。 如字符串“itheima”
2.字符串的下标索引
和其它容器如列表、元组一样字符串也可以通过下标进行访问
从前向后下标从0开始从后向前下标从-1开始
同元组一样字符串是一个无法修改的数据容器。 所以
修改指定下标的字符 如字符串[0] “a”移除特定下标的字符 如del 字符串[0]、字符串.remove()、字符串.pop()等追加字符等 如字符串.append() 均无法完成。如果必须要做只能得到一个新的字符串旧的字符串是无法修改
3.字符串常用操作汇总 4.字符串的遍历
同列表、元组一样字符串也支持while循环和for循环进行遍历
5.字符串的特点
作为数据容器字符串有如下特点
只可以存储字符串长度任意取决于内存大小支持下标索引允许重复字符串存在不可以修改增加或删除元素等支持for循环
基本和列表、元组相同
不同与列表和元组的在于字符串容器可以容纳的类型是单一的只能是字符串类型。 不同于列表相同于元组的在于字符串不可修改
6.练习案例分割字符串
给定一个字符串“itheima itcast boxuegu”
统计字符串内有多少个it字符将字符串内的空格全部替换为字符“|”并按照|进行字符串分割得到列表 提示 count、replace、split
str itheima itcast boxuegu
print(f字符串{str}中有:{str.count(it)}个it字符)
str1 str.replace( ,|)
print(f字符串{str},被替换空格后结果{str1})
list str1.split(|)
print(f字符串{str1},按照|分隔后结果{list})五、数据容器的切片
1.序列
序列是指内容连续、有序可使用下标索引的一类数据容器 列表、元组、字符串均可以可以视为序列。 如图序列的典型特征就是有序并可用下标索引字符串、元组、列表均满足这个要求
2.序列的常用操作 - 切片
序列支持切片即列表、元组、字符串均支持进行切片操作 切片从一个序列中取出一个子序列
语法
序列[起始下标:结束下标:步长]表示从序列中从指定位置开始依次取出元素到指定位置结束得到一个新序列
起始下标表示从何处开始可以留空留空视作从头开始结束下标不含表示何处结束可以留空留空视作截取到结尾步长表示依次取元素的间隔步长1表示一个个取元素步长2表示每次跳过1个元素取步长N表示每次跳过N-1个元素取步长为负数表示反向取注意起始下标和结束下标也要反向标记
注意此操作不会影响序列本身而是会得到一个新的序列列表、元组、字符串
示例
my_list [1, 2, 3, 4, 5]
new_list my_list[1:4] # 下标1开始下标4不含结束步长1
print(new_list) # 结果[2, 3, 4]my_tuple (1, 2, 3, 4, 5)
new_tuple my_tuple[:] # 从头开始到最后结束步长1
print(new_tuple) # 结果(1, 2, 3, 4, 5)my_list [1, 2, 3, 4, 5]
new_list my_list[::2] # 从头开始到最后结束步长2
print(new_list) # 结果[1, 3, 5]my_str 12345
new_str my_str[:4:2] # 从头开始到下标4不含结束步长2
print(new_str) # 结果13my_str 12345
new_str my_str[::-1] # 从头最后开始到尾结束步长-1倒序
print(new_str) # 结果54321my_list [1, 2, 3, 4, 5]
new_list my_list[3:1:-1] # 从下标3开始到下标1不含结束步长-1倒序
print(new_list) # 结果[4, 3]my_tuple (1, 2, 3, 4, 5)
new_tuple my_tuple[:1:-2] # 从头最后开始到下标1(不含)结束步长-2倒序
print(new_tuple) # 结果(5, 3)3.练习案例序列的切片实践
有字符串“万过薪月员序程马黑来nohtyP学” 请使用学过的任何方式得到黑马程序员
可用方式参考 倒序字符串切片取出或切片取出然后倒序 split分隔 replace替换来为空倒序字符串
str 万过薪月员序程马黑来nohtyP学
print(str[9:4:-1])
print(str[::-1][9:14])
print(str[5:10][::-1])
print(str.split()[1].replace(来,)[::-1])六、数据容器set(集合)
1.定义和基本语法
# 定义集合字面量
{元素,元素,...,元素}
# 定义集合变量
变量名称 {元素,元素,...,元素}
# 定义空集合
变量名称 set()和列表、元组、字符串等定义基本相同
列表使用[]元组使用()字符串使用“”集合使用{}
首先因为集合是无序的所以集合不支持下标索引访问 但是集合和列表一样是允许修改的所以我们来看看集合的修改方法。
2.常用方法 添加新元素 语法集合.add(元素)。将指定元素添加到集合内 结果集合本身被修改添加了新元素 移除元素 语法集合.remove(元素)将指定元素从集合内移除 结果集合本身被修改移除了元素 从集合中随机取出元素 语法集合.pop()功能从集合中随机取出一个元素 结果会得到一个元素的结果。同时集合本身被修改元素被移除 清空集合 语法集合.clear()功能清空集合 结果集合本身被清空 取出2个集合的差集 语法集合1.difference(集合2)功能取出集合1和集合2的差集集合1有而集合2没有的 结果得到一个新集合集合1和集合2不变 消除2个集合的差集 语法集合1.difference_update(集合2) 功能对比集合1和集合2在集合1内删除和集合2相同的元素。 结果集合1被修改集合2不变 2个集合合并 语法集合1.union(集合2) 功能将集合1和集合2组合成新集合 结果得到新集合集合1和集合2不变 查看集合的元素数量 语法len(集合) 功能统计集合内有多少元素 结果得到一个整数结果 集合同样支持使用for循环遍历 要注意集合不支持下标索引所以也就不支持使用while循环。
my_set {Hello,World}
my_set.add(itheima)
print(my_set) # 结果{Hello,World,itheima}my_set {Hello,World,itheima}
my_set.remove(Hello)
print(my_set) # 结果{World,itheima}my_set {Hello, World, itheima}
my_set.clear()
print(my_set) # 结果{}my_set {Hello, World, itheima}
element my_set.pop()
print(my_set) # 结果{itheima,World}
print(element) # 结果 Helloset1 {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} 不变set1 {1, 2, 3}
set2 {1, 5, 6}
set1.difference_update(set2)
print(set1) # 结果 {2,3}
print(set2) # 结果 {1,5,6} 不变set1 {1, 2, 3}
set2 {1, 5, 6}
set3 set1.union(set2) # 得到新集合
print(set3) # 结果 {1,2,3,5,6}
print(set1) # 结果 {1,2,3} 不变
print(set2) # 结果 {1,5,6} 不变set1 {1, 2, 3}
print(len(set1)) # 结果 3set1 {1, 2, 3}
for i in set1:print(i)# 结果# 1# 2# 33.集合的特点
经过上述对集合的学习可以总结出集合有如下特点
可以容纳多个数据可以容纳不同类型的数据混装数据是无序存储的不支持下标索引不允许重复数据存在可以修改增加或删除元素等支持for循环
4.练习案例信息去重
有如下列表对象 my_list [‘黑马程序员’, ‘传智播客’, ‘黑马程序员’, ‘传智播客’, ‘itheima’, ‘itcast’, ‘itheima’, ‘itcast’, ‘best’]
请
定义一个空集合通过for循环遍历列表在for循环中将列表的元素添加至集合最终得到元素去重后的集合对象并打印输出
my_list [黑马程序员, 传智播客, 黑马程序员, 传智播客,itheima, itcast, itheima, itcast, best]
# 方法1
# set1 set(my_list)# 方法2
set1 set()
for i in my_list:set1.add(i)
print(set1)七、数据容器dict(字典、映射)
1.定义和基本语法
字典的定义同样使用{}不过存储的元素是一个个的键值对如下语法
# 定义字典字面量
{key: value, key: value, ..., key: value}
# 定义字典变量
my_dict {key: value, key: value, ..., key: value}
# 定义空自定空字典
my_dict {}
my_dict dict()使用{}存储原始每一个元素是一个键值对每一个键值对包含Key和Value用冒号分隔键值对之间使用逗号分隔Key和Value可以是任意类型的数据key不可为字典Key不可重复重复会对原有数据覆盖
2.常用方法 字典同集合一样不可以使用下标索引 但是字典可以通过Key值来取得对应的Value 字典[Key] 新增元素 语法字典[Key] Value结果字典被修改新增了元素 更新元素 语法字典[Key] Value结果字典被修改元素被更新 注意字典Key不可以重复所以对已存在的Key执行上述操作就是更新Value值 删除元素 语法字典.pop(Key)结果获得指定Key的Value同时字典被修改指定Key的数据被删除 清空字典 语法字典.clear()结果字典被修改元素被清空 获取全部的key 语法字典.keys()结果得到字典中的全部Key 遍历字典 语法for key in 字典.keys()
注意字典不支持下标索引所以同样不可以用while循环遍历
计算字典内的全部元素键值对数量 语法len(字典) 结果得到一个整数表示字典内元素键值对的数量
# 语法 字典[key] 可以取到对应的value
stu_soure {王力宏:99,周杰伦:88,林俊杰:77}
print(stu_soure[王力宏]) # 结果99
print(stu_soure[周杰伦]) # 结果88
print(stu_soure[林俊杰]) # 结果77# 新增元素
# 语法字典[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) # 结果 {周杰伦: 88, 林俊杰: 99}# 清空字典
# 语法字典.clear()结果字典被修改元素被清空
stu_score {王力宏: 77,周杰伦: 88,林俊杰: 99,
}
value stu_score.clear()
print(stu_score) # 结果 {}# 获取全部的key
# 语法字典.keys()结果得到字典中的全部Key
stu_score {王力宏: 77,周杰伦: 88,林俊杰: 99,
}
keys stu_score.keys()
print(keys) # 结果 dict_keys([王力宏, 周杰伦, 林俊杰])# 遍历字典
# 语法for key in 字典.keys()
stu_score {王力宏: 77,周杰伦: 88,林俊杰: 99,
}
for key in stu_score.keys():print(stu_score[key]) # 结果 77 88 99# 注意字典不支持下标索引所以同样不可以用while循环遍历# 计算字典内的全部元素键值对数量
# 语法len(字典)
# 结果得到一个整数表示字典内元素键值对的数量
stu_score {王力宏: 77,周杰伦: 88,林俊杰: 99,
}
print(len(stu_score)) # 结果 33.字典的嵌套
字典的Key和Value可以是任意数据类型Key不可为字典 字典是可以嵌套的
需求如下记录学生各科的考试信息 stu_score {王力宏: {语文: 77, 数学: 66, 英语: 33, }, 周杰伦: {语文: 88, 数学: 86, 英语: 55, }, 林俊杰: {语文: 99, 数学: 96, 英语: 66, }, }# 优化一下可读性可以写成
stu_score {王力宏: {语文: 77, 数学: 66, 英语: 33, },周杰伦: {语文: 88, 数学: 86, 英语: 55, },林俊杰: {语文: 99, 数学: 96, 英语: 66, },
}嵌套字典的内容获取
嵌套字典的内容获取如下所示
stu_score {王力宏: {语文: 77, 数学: 66, 英语: 33, },周杰伦: {语文: 88, 数学: 86, 英语: 55, },林俊杰: {语文: 99, 数学: 96, 英语: 66, },
}
print(stu_score[王力宏]) # 结果 {语文: 77, 数学: 66, 英语: 33 }
print(stu_score[王力宏][语文]) # 结果 77
print(stu_score[周杰伦][数学]) # 结果 86
3.字典的特点
经过上述对字典的学习可以总结出字典有如下特点
可以容纳多个数据可以容纳不同类型的数据每一份数据是KeyValue键值对可以通过Key获取到ValueKey不可重复重复会覆盖不支持下标索引可以修改增加或删除更新元素等支持for循环不支持while循环
4.案例升职加薪
有如下员工信息请使用字典完成数据的记录。 并通过for循环对所有级别为1级的员工级别上升1级薪水增加1000元 运行后输出如下信息
employee_info {王力宏: {部门: 科技部, 工资: 3000, 级别: 1},周杰轮: {部门: 市场部, 工资: 5000, 级别: 2},林俊节: {部门: 市场部, 工资: 7000, 级别: 3},张学油: {部门: 科技部, 工资: 4000, 级别: 1},刘德滑: {部门: 市场部, 工资: 6000, 级别: 2},
}
print(f全体员工当前信息如下\n{employee_info})
for names in employee_info:if employee_info[names][级别] 1:employee_info[names][级别] 1employee_info[names][工资] 1000
print(f全体员工级别为1的员工完成升职加薪操作操作后:\n{employee_info})八、数据容器的通用操作
1.数据容器对比总结
数据容器可以从以下视角进行简单的分类 是否支持下标索引 支持列表、元组、字符串 - 序列类型不支持集合、字典 - 非序列类型 是否支持重复元素 支持列表、元组、字符串 - 序列类型不支持集合、字典 - 非序列类型 是否可以修改 支持列表、集合、字典不支持元组、字符串
基于各类数据容器的特点它们的应用场景如下
列表一批数据可修改、可重复的存储场景元组一批数据不可修改、可重复的存储场景字符串一串字符串的存储场景集合一批数据去重存储场景字典一批数据可用Key检索Value的存储场景
2.通用操作 数据容器的通用操作 - 遍历
5类数据容器都支持for循环遍历列表、元组、字符串支持while循环集合、字典不支持无法下标索引
数据容器的通用统计功能
len(容器) 统计容器的元素个数max(容器) 统计容器的最大元素min(容器) 统计容器的最小元素
# len(容器)
# 统计容器的元素个数
my_list [1, 2, 3]
my_tuple (1, 2, 3, 4, 5)
my_str itiheimaprint(len(my_list)) # 结果3
print(len(my_tuple)) # 结果5
print(len(my_str)) # 结果8# max(容器)
# 统计容器的最大元素
my_list [1, 2, 3]
my_tuple (1, 2, 3, 4, 5)
my_str itiheimaprint(max(my_list)) # 结果3
print(max(my_tuple)) # 结果5
print(max(my_str)) # 结果t# min(容器)
# 统计容器的最小元素
my_list [1, 2, 3]
my_tuple (1, 2, 3, 4, 5)
my_str itiheimaprint(min(my_list)) # 结果1
print(min(my_tuple)) # 结果1
print(min(my_str)) # 结果a数据容器转换功能
list(容器) 将给定容器转换为列表str(容器) 将给定容器转换为字符串tuple(容器) 将给定容器转换为元组set(容器) 将给定容器转换为集合
# 数据容器转换功能
my_list [1, 2, 3, 4, 5]
my_tuple (1, 2, 3, 4, 5)
my_str abcdefg
my_set {1, 2, 3, 4, 5}
my_dict {key1: 1, key2: 2, key3: 3, key4: 4, key5: 5, }
# list(容器)
# 将给定容器转换为列表
print(f列表转换列表的结果是{list(my_list)}) # [1, 2, 3, 4, 5]
print(f元祖转换列表的结果是{list(my_tuple)}) # [1, 2, 3, 4, 5]
print(f字符串转换列表的结果是{list(my_str)}) # [a, b, c, d, e, f, g]
print(f集合转换列表的结果是{list(my_set)}) # [1, 2, 3, 4, 5]
# [key1, key2, key3, key4, key5]
print(f字典转换列表的结果过是{list(my_dict)})# str(容器)
# 将给定容器转换为字符串
print(----------------------)
print(f列表转换字符串的结果是{str(my_list)}) # [1, 2, 3, 4, 5]
print(f元祖转换字符串的结果是{str(my_tuple)}) # (1, 2, 3, 4, 5)
print(f字符串转换字符串的结果是{str(my_str)}) # abcdefg
print(f集合转换字符串的结果是{str(my_set)}) # {1, 2, 3, 4, 5}
# {key1: 1, key2: 2, key3: 3, key4: 4, key5: 5, }
print(f字典转换字符串的结果是{str(my_dict)})# tuple(容器)
# 将给定容器转换为元组
print(----------------------)
print(f列表转换元祖的结果是{tuple(my_list)}) # (1, 2, 3, 4, 5)
print(f元祖转换元祖的结果是{tuple(my_tuple)}) # (1, 2, 3, 4, 5)
print(f字符串转换元祖的结果是{tuple(my_str)}) # (a, b, c, d, e, f, g)
print(f集合转换元祖的结果是{tuple(my_set)}) # (1, 2, 3, 4, 5)
# (key1, key2, key3, key4, key5)
print(f字典转换元祖的结果是{tuple(my_dict)})# set(容器)
# 将给定容器转换为集合
print(----------------------)
print(f列表转换集合的结果是{set(my_list)}) # {1, 2, 3, 4, 5}
print(f元祖转换集合的结果是{set(my_tuple)}) # {1, 2, 3, 4, 5}
print(f字符串转换集合的结果是{set(my_str)}) # {1, 2, 3, 4, 5}
print(f集合转换集合的结果是{set(my_set)}) # {1, 2, 3, 4, 5}
# {key1, key4, key5, key2, key3}
print(f字典转换集合的结果是{set(my_dict)})容器排序功能 sorted(容器, [reverseTrue]) 注意排序后都会得到列表list对象。
# 容器通用排序功能
# sorted(容器, [reverseTrue])
# 将给定容器进行排序
# 数据容器转换功能
my_list [1, 5, 3, 4, 2]
my_tuple (1, 5, 3, 2, 4)
my_str gbdecfa
my_set {1, 5, 2, 4, 3}
my_dict {key1: 1, key3: 3, key4: 4, key2: 2, key5: 5, }print(f列表排序的结果是{sorted(my_list)}) # [1, 2, 3, 4, 5]
print(f元祖排序的结果是{sorted(my_tuple)}) # [1, 2, 3, 4, 5]
print(f字符排序的结果是{sorted(my_str)}) # [a, b, c, d, e, f, g]
print(f集合排序的结果是{sorted(my_set)}) # [1, 2, 3, 4, 5]
# [key1, key2, key3, key4, key5]
print(f字典排序的结果过是{sorted(my_dict)})3.字符串比较大小
在程序中字符串所用的所有字符如
大小写英文单词数字特殊符号(!、\、|、、#、空格等
都有其对应的ASCII码表值
每一个字符都能对应上一个数字的码值 字符串进行比较就是基于数字的码值大小进行比较的。 字符串是按位比较也就是一位位进行对比只要有一位大那么整体就大。 九、综合案例
1 . 幸运数字6输入任意数字如数字8生成nums列表元素值为1~8从中选取幸运数字(能够被6整除)移动到新列表lucky打印nums与lucky。
num int(input(请输入数字:))
nums range(1, num1)
nums list(nums)
lucky []
for i in nums:if i % 6 0:lucky.append(i)
print(f产生的列表nums为:{nums}\n幸运数字列表lucky为:{lucky})2 列表嵌套有3个教室[[],[],[]]8名讲师[‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’]将8名讲师随机分配到3个教室中
import randomrooms [[], [], []]
teachers [A, B, C, D, E, F, G, H]for teacher in teachers:index random.randint(0, 2)rooms[index].append(teacher)print(rooms)i 1
for room in rooms:print(f第{i}个教室中的讲师{room})i 1
