网站定制化什么意思,彩票网站和app建设,通过模板做网站,一个简单的网页代码带图片文章目录 一.序列1.1list列表定义常用操作列表的遍历 1.2tuple元组定义常见操作元组的遍历 1.3str字符串定义常见操作字符串的遍历 1.4序列常用操作——切片 二.set集合定义常见操作集合的遍历 三.dict字典定义常用操作字典的嵌套 *数据容器对比总结四.数据容器的通用操作4.1通… 文章目录 一.序列1.1list列表定义常用操作列表的遍历 1.2tuple元组定义常见操作元组的遍历 1.3str字符串定义常见操作字符串的遍历 1.4序列常用操作——切片 二.set集合定义常见操作集合的遍历 三.dict字典定义常用操作字典的嵌套 *数据容器对比总结四.数据容器的通用操作4.1通用统计功能4.2通用转换功能4.3通用排序功能 我们首先来思考一个问题如果我想要在程序中记录5名学生的信息如姓名。如何做呢 学习数据容器就是为了批量存储或批量使用多份数据 Python中的数据容器 一种可以容纳多份数据的数据类型容纳的每一份数据称之为一个元素。每一个元素可以是任意类型的数据如字符串、数字、布尔等。 数据容器根据特点的不同如
是否支持重复元素是否可以修改是否有序
等分为5类分别是列表list、元组tuple、字符串str、集合set、字典dict
一.序列
序列是指内容连续、有序可使用下标索引的一类数据容器
列表、元组、字符串均可以可以视为序列。
1.1list列表
定义
列表内的每一个数据称之为元素
以[ ] 作为标识
列表内每一个元素之间用, 逗号隔开
元素的数据类型没有任何限制甚至元素也可以是列表这样就定义了嵌套列表
# 字面量
[元素1,元素2,元素3,元素4, ...]# 定义变量
变量名称 [元素1,元素2,元素3,元素4, ...]# 定义空变量
变量名称 []
变量名称 list()演示代码
# 字符串列表
name_list [green,yello,blue]
print(name_list)
print(type(name_list))# 各种类型列表
name_list [green,666,blue]
print(name_list)
print(type(name_list))# 嵌套列表
name_list [[green],[666],[blue]]
print(name_list)
print(type(name_list))运行结果
[green, yello, blue]
class list
[green, 666, blue]
class list
[[green], [666], [blue]]
class list列表的下标索引 ①如图列表中的每一个元素都有其位置下标索引从前向后的方向从0开始依次递增 我们只需要按照下标索引即可取得对应位置的元素。
②或者可以反向索引如图从后向前下标索引为-1、-2、-3依次递减。 ③如果列表是嵌套的列表同样支持下标索引 演示代码
# 正向索引
name_list [green,yello,blue]
print(name_list[0])
print(name_list[1])
print(name_list[2])# 反向索引
name_list [green,yello,blue]
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])# 嵌套索引
name_list [[1,2,3],[4,5],[6,7,8]]
print(name_list[0][0])
print(name_list[-2][-1])
print(name_list[-3][2])运行结果
green
yello
blue
blue
yello
green
1
5
3要注意下标索引的取值范围超出范围无法取出元素并且会报错。
常用操作 ①查找
【功能】查找指定元素在列表的下标如果找不到报错ValueError
【语法】列表.index(元素)
index就是列表对象变量内置的方法函数
如果被查找的元素不存在会报错
②修改
【功能】修改特定位置索引的元素值
【语法】列表[下标]值
可以使用如上语法直接对指定下标正向反向下标均可的值进行重新赋值
③插入
【功能】在指定的下标位置插入指定的元素
【语法】列表.insert(下标,元素)
④追加
【功能】将指定元素追加到列表的尾部
【语法】列表.append(元素)
追加一批元素-列表.extend(其他数据容器)
⑤索引删除
【语法1】del 列表[下标]
【语法1】列表.pop(下标)同时可以把删除的元素作为返回值去得到
⑥指定内容删除
【语法】列表.remove(元素)
从前到后搜索只能删掉一个指定内容的元素
⑦清空列表
【语法】列表.clear()
⑧统计
【语法】列表.count(元素)
【功能】统计某元素在列表中数量
【语法】len(列表)
【功能】统计列表内有多少元素 代码示例 name_list [green,yello,blue]
# 查找
index name_list.index(yello)
print(fyello在列表中的下标索引值是{index})
# 修改
name_list[0] 修改
print(f列表被修改元素值后输出结果是{name_list})
# 插入
name_list.insert(1,插入)
print(f列表插入元素后结果是{name_list})
# 追加
name_list.append(追加)
print(f列表追加元素后结果是{name_list})
# 追加一批元素
name_list.extend([1,1,3])
print(f列表追加一个新的列表后结果是{name_list})
# 删除
del name_list[0]
print(f列表删除元素后结果是{name_list})
element name_list.pop(0)
print(f通过pop取出元素后结果是{name_list}取出的元素是{element})
# 指定内容删除
name_list.remove(追加)
print(f列表删除指定内容元素后结果是{name_list})
# 统计
count name_list.count(1)
print(f列表中1的数量是{count})
num len(name_list)
print(f列表中的元素数量是{num})
# 清空
name_list.clear()
print(f列表被清空了结果是{name_list})运行结果
yello在列表中的下标索引值是1
列表被修改元素值后输出结果是[修改, yello, blue]
列表插入元素后结果是[修改, 插入, yello, blue]
列表追加元素后结果是[修改, 插入, yello, blue, 追加]
列表追加一个新的列表后结果是[修改, 插入, yello, blue, 追加, 1, 1, 3]
列表删除元素后结果是[插入, yello, blue, 追加, 1, 1, 3]
通过pop取出元素后结果是[yello, blue, 追加, 1, 1, 3]取出的元素是插入
列表删除指定内容元素后结果是[yello, blue, 1, 1, 3]
列表中1的数量是2
列表中的元素数量是5
列表被清空了结果是[]Process finished with exit code 0总结列表的特点
可以容纳多个元素上限为 2**63-1 、9223372036854775807个可以容纳不同类型的元素混装数据是有序存储的有下标序号允许重复数据存在可以修改增加或删除元素等
列表的遍历
既然数据容器可以存储多个元素那么就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为称之为遍历、迭代。
while循环
# 定义一个变量来标记列表的下标
index 0 # 初始值为0
while index len(列表): # 循环条件为下标值列表的元素数量元素 列表[index]对元素进行处理index 1for循环
对比whilefor循环更加适合对列表等数据容器进行遍历。
for 临时变量 in 数据容器 :对临时变量进行处理for循环和while对比 while循环和for循环都是循环语句但细节不同: 在循环控制上: ·white循环可以自定循环条件并自行控制 ·for循环不可以自定循环条件只可以一个个从容器内取出数据 在无限循环上: ·while福环可以通过条件控制做到无限循环 ·for循环理伦上不可以因为被遍历的容器容量不是无限的 在使用场景上: while循环适用于任何想要循环的场景 for循环适用于遍历数据容器的场景或简单的因定次数循环场景 【代码示例】
# 使用while循环遍历列表
def list_while_func():my_list [blue, yello, green]# 定义一个变量来标记列表的下标index 0 # 初始值为0while index len(my_list):# 通过index变量取出对应下标的元素element my_list[index]print(f列表的元素{element})index 1
list_while_func()#使用for循环遍历列表
def list_for_func():my_list [1,2,3,4,5]for element in my_list:print(f列表元素有{element})
list_for_func()运行结果
列表的元素blue
列表的元素yello
列表的元素green
列表元素有1
列表元素有2
列表元素有3
列表元素有4
列表元素有5列表是可以修改的如果想要传递的信息不被纂改那么元组来啦~
1.2tuple元组
定义
元组一旦定义完成就不可修改
元组定义定义元组使用小括号且使用逗号隔开各个数据数据可以是不同的数据类型。
#定义元组字面量
(元素元素......元素)#定义元组数变量
变量名称 (元素元素...... 元素)#定义空元组
变量名称 () #方式一
变量名称 tuple() #方式二注
1、元组只有一个数据时这个数据后面要添加逗号否则不是元组类型
2、元组也支持嵌套
代码示例
t1 (1,Hello,True)
t2 ()
t3 tuple ()
t4 (1,)
t5 ((4,5,6),(8,9))
print(ft1的类型是{type(t1)},内容是{t1})
print(ft2的类型是{type(t2)},内容是{t2})
print(ft3的类型是{type(t3)},内容是{t3})
print(ft4的类型是{type(t4)},内容是{t4})
print(ft5的类型是{type(t5)},内容是{t5})运行结果
t1的类型是class tuple,内容是(1, Hello, True)
t2的类型是class tuple,内容是()
t3的类型是class tuple,内容是()
t4的类型是class tuple,内容是(1,)
t5的类型是class tuple,内容是((4, 5, 6), (8, 9))元组的下标索引 同列表示例
t5 ((4,5,6),(8,9))
num t5[1][0]
运行结果
8常见操作 元组由于不可修改的特性所以其操作方法非常少。
元组的三种方法和列表相对应的这三种方法操作一致。
元组的遍历
元组同样支持while循环和for循环的遍历操作
用法和列表遍历一致 总结元组的特点 • 可以容纳多个数据
• 可以容纳不同类型的数据混装
• 数据是有序存储的下标索引
• 允许重复数据存在
• 不可以修改 增加或删除元素等但如果元组中嵌套的有列表那么列表中的元素可以修改列表list的本质没有改变所以不违背元组不可以修改的原则
• 支持for循环
1.3str字符串
定义
字符串是字符的容器一个字符串可以存放任意数量的字符。 字符串的下标索引 和其它容器如列表、元组一样字符串也可以通过下标进行访问
• 从前向后下标从 0 开始
• 从后向前下标从 -1 开始
【代码示例】
my_str abcdefg
value1 my_str[2]
value2 my_str[-3]
print(f从字符串中取下标为2的元素值是{value1},下标为-3的元素值是{value2})运行结果
从字符串中取下标为2的元素值是c,下标为-3的元素值是e常见操作 同元组一样字符串是一个无法修改的数据容器。
①字符串的替换
【功能】将字符串内的全部字符串1替换为字符串2
【语法】字符串.replace(字符串1字符串2)
注意不是修改字符串本身而是得到了一个新字符串
②字符串的分割
【功能】按照指定的分隔符字符串将字符串划分为多个字符串并存入列表对象中
【语法】字符串.split(分隔符字符串)
注意字符串本身不变而是得到了一个列表对象
③字符串的规整操作
【功能】去前后空格
【语法】字符串.strip()
【功能】去前后指定字符串
【语法】字符串.strip(字符串)
注意传入的是12其实就是1和2都会移除是按照单个字符
④查找
【功能】查找给定字符的第一个匹配项的下标
【语法】字符串.index(字符串) 代码示例 # 查找
str mountain and sea
value str.index(and)
print(f在字符串{str}中查找“and”其起始下标是{value})# 替换
str itmountain and itsea
new_str str.replace(it,程序)
print(f将字符串 {str}进行替换得到 {new_str})# 分割
my_str hello python itCSDN itlove
my_str_list my_str.split( )
print(f将字符串{my_str}进行split切分后得到{my_str_list}, 类型是{type(my_str_list)})# 规整操作
my_str itCSDN and itlove
new_my_str my_str.strip() # 不传入参数去除首尾空格
print(f字符串{my_str}被strip后结果{new_my_str})
my_str 12itCSDN and itlove21
new_my_str my_str.strip(12)
print(f字符串{my_str}被strip(12)后结果{new_my_str})# 统计
my_str itCSDN and itlove
count my_str.count(it)
print(f字符串{my_str}中it出现的次数是{count})
my_str itCSDN and itlove
num len(my_str)
print(f字符串{my_str}的长度是{num})运行结果
在字符串mountain and sea中查找“and”其起始下标是9
将字符串 itmountain and itsea进行替换得到 程序mountain and 程序sea
将字符串hello python itCSDN itlove进行split切分后得到[hello, python, itCSDN, itlove], 类型是class list
字符串 itCSDN and itlove 被strip后结果itCSDN and itlove
字符串12itCSDN and itlove21被strip(12)后结果itCSDN and itlove
字符串itCSDN and itlove中it出现的次数是2
字符串itCSDN and itlove的长度是17字符串的遍历
同列表元组一样 总结元组的特点 作为数据容器字符串有如下特点
• 只可以存储字符串
• 长度任意取决于内存大小
• 支持下标索引
• 允许重复字符串存在
• 不可以修改 增加或删除元素等
• 支持for循环
1.4序列常用操作——切片
序列支持切片即列表、元组、字符串均支持进行切片操作
切片从一个序列中取出一个子序列
【语法】序列[起始下标:结束下标:步长]
表示从序列中从指定位置开始依次取出元素到指定位置结束得到一个新序列
• 起始下标表示从何处开始可以留空留空视作从头开始
• 结束下标不含表示何处结束可以留空留空视作截取到结尾
• 步长表示依次取元素的间隔默认为1步长 1 表示一个个取元素步长 2 表示每次跳过1个元素取步长 N表示每次跳过N-1 个元素取
• 步长为负数表示反向取注意起始下标和结束下标也要反向标记
注意. 此操作不会影响序列本身而是会得到一个新的序列列表、元组、字符串
# 对List进行切片从1开始4结束步长1
my_List [0,1,2,3,4,5,6]
result1 my_List[1:4] # 步长默认是1所以可以省略不写
print(f结果1{result1})
result6 my_List[3:1:-1] # 步长默认是1所以可以省略不写
print(f结果6{result6})# 对tuple进行切片从头开始到最后结束步长1
my_tuple (0,1,2,3,4,5,6)
result2 my_tuple[:] # 起始和结束不写表示从头到尾步长为1可以省略
print(f结果2{result2})
result5 my_tuple[::-2]
print(f结果5{result5})# 对str进行切片从头开始到最后结束步长2
my_str 01234567
result3 my_str[::2]
print(f结果3{result3})
result4 my_str[::-1]
print(f结果4{result4})运行结果
结果1[1, 2, 3]
结果6[3, 2]
结果2(0, 1, 2, 3, 4, 5, 6)
结果5(6, 4, 2, 0)
结果30246
结果476543210总结
列表可修改支持重复元素且有序元组字符串不可修改支持重复元素且有序
序列这三种数据容器基本可以满足大多数使用场景但是它们存在局限都支持重复元素。如果场景需要对内容做去重处理就不方便了那么集合来啦~
二.set集合
定义
• 集合内不允许重复元素去重
• 集合内元素是无序的不支持下标索引
# 定义集合字面量
{元素元素.... 元素}
# 定义集合变量
变量名称 {元素元素.... 元素}
# 定义空集合
变量名称 set()结合集合特点进行代码演示
my_set_empty set() # 定义空集合
print(fmy_set_empty的内容是{my_set_empty}, 类型是{type(my_set_empty)})
my_set {CSDN程序员社区, CSDN灌水乐园, itCSDN, CSDN灌水乐园, CSDN程序员社区, itCSDN}
print(fmy_set的内容是{my_set}, 类型是{type(my_set)})运行结果
my_set_empty的内容是set(), 类型是class set
my_set的内容是{itCSDN, CSDN灌水乐园, CSDN程序员社区}, 类型是class set常见操作
首先因为集合是无序的所以集合不支持下标索引访问
但是结合和列表一样是允许修改的所以我们来看看集合的修改方法—— ①添加新元素
【语法】集合.add(元素)将指定元素添加到集合内
结果结合本身被修改添加了新元素
②移除元素
【语法】集合.remove(元素)将指定元素从集合内移除
结果集合本身被修改移除了元素
③随机取出元素
【语法】集合.pop()从集合中随机取出一个元素
结果会得到一个元素的结果同时集合本身被修改元素被移除
④清空集合
【语法】集合.clear()清空集合
结果集合本身被清空
⑤取出两个集合的差集
【语法】集合1.difference(集合2)取出集合1和集合2的差集集合1有二集合2没有的
结果得到一个新集合集合1和集合2不变
⑥消除差集
【语法】集合1.difference_update(集合2)对比集合1和集合2相同的元素
结果集合1被修改集合2不变
⑦两个集合合并
【语法】集合1.union(集合2)将集合1和集合2组合成新集合
结果得到新集合集合1和集合2不变
【代码示例】
# 添加新元素
my_set {blue, green, pink}
my_set.add(purple)
my_set.add(pink)
print(fmy_set添加元素后结果是{my_set})# 移除元素
my_set.remove(green)
print(fmy_set移除green后结果是{my_set})# 随机取出元素
my_set.pop()
print(fmy_set随机取出元素后结果是{my_set})# 清空集合
my_set.clear()
print(fmy_set清空集合后结果是{my_set})# 取两个集合的差集
set1 {1,2,3}
set2 {1,4,5,6}
set3 set1.difference(set2)
print(f取差集后原有set1的内容{set1})
print(f取差集后原有set2的内容{set2})# 消除差集
set1 {1,2,3}
set2 {1,4,5,6}
set3 set1.difference_update(set2)
print(f消除差集后原有set1的内容{set1})
print(f消除差集后原有set2的内容{set2})
print(f消除差集后的集合3是{set3})# 两个集合合并
set1 {1,2,3}
set2 {1,4,5,6}
set3 set1.union(set2)
print(f合并后原有set1的内容{set1})
print(f合并后原有set2的内容{set2})
print(f合并后的集合3是{set3})# 统计集合的元素数量
set1 {1,2,3}
set2 {1,2,3,1,2,3}
num1 len(set1)
num2 len(set2)
print(f集合1内的元素数量有{num1}个)
print(f集合2内的元素数量有{num2}个)运行结果
my_set添加元素后结果是{pink, purple, green, blue}
my_set移除green后结果是{pink, purple, blue}
my_set随机取出元素后结果是{purple, blue}
my_set清空集合后结果是set()
取差集后原有set1的内容{1, 2, 3}
取差集后原有set2的内容{1, 4, 5, 6}
消除差集后原有set1的内容{2, 3}
消除差集后原有set2的内容{1, 4, 5, 6}
消除差集后的集合3是None
合并后原有set1的内容{1, 2, 3}
合并后原有set2的内容{1, 4, 5, 6}
合并后的集合3是{1, 2, 3, 4, 5, 6}
集合1内的元素数量有3个
集合2内的元素数量有3个集合的遍历
因为集合是无序的不支持下标索引所以不可以使用while循环遍历用for循环遍历
# 集合的遍历
set1 {1,2,3,4,5}
for element in set1:print(f集合的元素有{element})运行结果
集合的元素有1
集合的元素有2
集合的元素有3
集合的元素有4
集合的元素有5总结集合的特点 • 可以容纳多个数据
• 可以容纳不同类型的数据混装
• 数据是无序存储的不支持下标索引
• 不允许重复数据存在
• 可以修改 增加或删除元素等
• 支持for循环
三.dict字典
定义
通过 key 找出对应的 value qa4tRBmD-1736684061659)
字典的定义同样使用{}不过存储的元素是一个个的键值对keyvalue三者结合被称为键值对如下语法
# 定义字典字面量
{key : value , key value : value ,....,key : value}
# 定义字典字面量
my_dict {key : value , key :value , ....,key :value}
# 定义空字典
my_dict {} # 空字典定义方式1
my_dict dict() # 空字典定义方式2• 使用 {} 存储原始每一个元素是一个键值对
• 每一个键值对包含 Key 和 Value 用冒号分隔
• 键值对之间使用逗号分隔
• Key 和 Value 可以是任意类型的数据 key 不可为字典
• Key 不可重复重复会对原有数据覆盖
•字典不可用下标索引而是通过Key检索Value
【代码示例】
# 定义字典
my_dict1 {王力鸿: 99, 周杰轮: 88, 林俊节: 77}
# 定义空字典
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)})运行结果
字典1的内容是{王力鸿: 99, 周杰轮: 88, 林俊节: 77}, 类型class dict
字典2的内容是{}, 类型class dict
字典3的内容是{}, 类型class dict常用操作
字典同集合一样不可以使用下标索引
但是字典可以通过Key值来取得对应的Value
【代码示例】
# 从字典中基于Key获取Value
my_dict1 {王力鸿: 99, 周杰轮: 88, 林俊节: 77}
score my_dict1[王力鸿]
print(f王力鸿的考试分数是{score})
score my_dict1[周杰轮]
print(f周杰轮的考试分数是{score})运行结果
王力鸿的考试分数是99
周杰轮的考试分数是88①新增元素
【语法】字典[Key] Value
结果字典被修改新增了元素
②更新元素
【语法】字典[Key] Value
结果字典被修改元素被更新
注意字典Key不可以重复所以对已存在的Key执行上述操作就是更新Value值
③删除元素
【语法】字典.pop(Key)
结果获得指定Key的Value同时字典被修改指定Key的数据被删除
④清空字典
【语法】字典.clear()
结果字典被修改元素被清空
⑤获取全部Key
【语法】字典.Keys()
结果得到字典中全部的Key
⑥计算字典中元素数量
【语法】len.(字典) 【代码示例】
# 从字典中基于Key获取Value
my_dict {王力鸿: 99, 周杰轮: 88, 林俊节: 77}
score my_dict[王力鸿]
print(f王力鸿的考试分数是{score})
score my_dict[周杰轮]
print(f周杰轮的考试分数是{score})# 新增元素
my_dict[张信哲] 66
print(f字典经过新增元素后结果{my_dict})
#更新元素
my_dict[周杰轮] 33
print(f字典经过更新后结果{my_dict})# 删除元素
my_dict {周杰轮: 99, 林俊节: 88, 张学油: 77}
score my_dict.pop(周杰轮)
print(f字典中被移除了一个元素结果{my_dict}, 周杰轮的考试分数是{score})# 清空字典
my_dict {周杰轮: 99, 林俊节: 88, 张学油: 77}
my_dict.clear()
print(f字典被清空了内容是{my_dict})# 获取字典中全部的Key
my_dict {周杰轮: 99, 林俊节: 88, 张学油: 77}
keys my_dict.keys()
print(f字典的全部keys是{keys})
# 遍历字典
# 方式1通过获取到全部的key来完成遍历
for key in keys:print(f字典的key是:{key})print(f字典的value是{my_dict[key]})# 计算字典中的元素数量
my_dict {周杰轮: 99, 林俊节: 88, 张学油: 77}
num len(my_dict)
print(f字典中的元素数量有{num}个)运行结果
王力鸿的考试分数是99
周杰轮的考试分数是88
字典经过新增元素后结果{王力鸿: 99, 周杰轮: 88, 林俊节: 77, 张信哲: 66}
字典经过更新后结果{王力鸿: 99, 周杰轮: 33, 林俊节: 77, 张信哲: 66}
字典中被移除了一个元素结果{林俊节: 88, 张学油: 77}, 周杰轮的考试分数是99
字典被清空了内容是{}
字典的全部keys是dict_keys([周杰轮, 林俊节, 张学油])
字典的key是:周杰轮
字典的value是99
字典的key是:林俊节
字典的value是88
字典的key是:张学油
字典的value是77
字典中的元素数量有3个字典的嵌套
字典的Key和Value可以是任意数据类型Key不可为字典
那么就表明字典是可以嵌套的。
方法①通过获取到全部的key来遍历完成
my_dict {周杰轮: 99, 林俊节: 88, 张学油: 77}
keys my_dict.keys()
print(f字典的全部keys是{keys})
# 遍历字典
# 方式1通过获取到全部的key来完成遍历
for key in keys:print(f字典的key是:{key})print(f字典的value是{my_dict[key]})运行结果
字典的全部keys是dict_keys([周杰轮, 林俊节, 张学油])
字典的key是:周杰轮
字典的value是99
字典的key是:林俊节
字典的value是88
字典的key是:张学油
字典的value是77方法②直接对字典进行for循环每一次循环都是直接得到key
my_dict {周杰轮: 99, 林俊节: 88, 张学油: 77}
for key in my_dict:print(f字典的key是:{key})print(f字典的value是{my_dict[key]})运行结果
字典的key是:周杰轮
字典的value是99
字典的key是:林俊节
字典的value是88
字典的key是:张学油
字典的value是77总结字典的特点 • 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是 KeyValue 键值对
• 可以通过 Key 获取到 Value Key 不可重复重复会覆盖
• 不支持下标索引
• 可以修改 增加或删除更新元素等
• 支持for循环不支持 while 循环
*数据容器对比总结 • 列表使用 []
• 元组使用 ()
• 字符串使用“”
• 集合使用 {}
•字典使用{}和键值对
遍历方式不同
5类数据容器都支持for循环遍历列表元组字符串支持while循环集合字典不支持无法下标索引
四.数据容器的通用操作
4.1通用统计功能 【代码示例】
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}# len元素个数
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)})# max最大元素
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)})# min最小元素
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)})运行结果
列表 元素个数有5
元组 元素个数有5
字符串元素个数有7
集合 元素个数有5
字典 元素个数有5
列表 最大的元素是5
元组 最大的元素是5
字符串最大的元素是g
集合 最大的元素是5
字典 最大的元素是key5
列表 最小的元素是1
元组 最小的元素是1
字符串最小的元素是a
集合 最小的元素是1
字典 最小的元素是key14.2通用转换功能 【代码示例】
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}# 类型转换: 容器转列表
print(f元组转列表的结果是{list(my_tuple)})
print(f字符串转列表结果是{list(my_str)})
print(f集合转列表的结果是{list(my_set)})
print(f字典转列表的结果是{list(my_dict)})# 类型转换: 容器转元组
print(f列表转元组的结果是{tuple(my_list)})
print(f字符串转元组结果是{tuple(my_str)})
print(f集合转元组的结果是{tuple(my_set)})
print(f字典转元组的结果是{tuple(my_dict)})# 类型转换: 容器转字符串
print(f列表转字符串的结果是{str(my_list)})
print(f元组转字符串的结果是{str(my_tuple)})
print(f集合转字符串的结果是{str(my_set)})
print(f字典转字符串的结果是{str(my_dict)})# 类型转换: 容器转集合
print(f列表转集合的结果是{set(my_list)})
print(f元组转集合的结果是{set(my_tuple)})
print(f字符串转集合结果是{set(my_str)})
print(f字典转集合的结果是{set(my_dict)})运行结果
元组转列表的结果是[1, 2, 3, 4, 5]
字符串转列表结果是[a, b, c, d, e, f, g]
集合转列表的结果是[1, 2, 3, 4, 5]
字典转列表的结果是[key1, key2, key3, key4, key5]
列表转元组的结果是(1, 2, 3, 4, 5)
字符串转元组结果是(a, b, c, d, e, f, g)
集合转元组的结果是(1, 2, 3, 4, 5)
字典转元组的结果是(key1, key2, key3, key4, key5)
列表转字符串的结果是[1, 2, 3, 4, 5]
元组转字符串的结果是(1, 2, 3, 4, 5)
集合转字符串的结果是{1, 2, 3, 4, 5}
字典转字符串的结果是{key1: 1, key2: 2, key3: 3, key4: 4, key5: 5}
列表转集合的结果是{1, 2, 3, 4, 5}
元组转集合的结果是{1, 2, 3, 4, 5}
字符串转集合结果是{c, b, d, a, f, e, g}
字典转集合的结果是{key1, key5, key2, key3, key4}4.3通用排序功能 【语法】sorted(容器[reverse True])将给定的容器进行排序
# 进行容器的排序
my_list [3, 1, 2, 5, 4]
my_tuple (3, 1, 2, 5, 4)
my_str bdcefga
my_set {3, 1, 2, 5, 4}
my_dict {key3: 1, key1: 2, key2: 3, key5: 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)})# 逆序排序
print(f列表对象的反向排序结果{sorted(my_list, reverseTrue)})
print(f元组对象的反向排序结果{sorted(my_tuple, reverseTrue)})
print(f字符串对象反向的排序结果{sorted(my_str, reverseTrue)})
print(f集合对象的反向排序结果{sorted(my_set, reverseTrue)})
print(f字典对象的反向排序结果{sorted(my_dict, reverseTrue)})运行结果
列表对象的排序结果[1, 2, 3, 4, 5]
元组对象的排序结果[1, 2, 3, 4, 5]
字符串对象的排序结果[a, b, c, d, e, f, g]
集合对象的排序结果[1, 2, 3, 4, 5]
字典对象的排序结果[key1, key2, key3, key4, key5]
列表对象的反向排序结果[5, 4, 3, 2, 1]
元组对象的反向排序结果[5, 4, 3, 2, 1]
字符串对象反向的排序结果[g, f, e, d, c, b, a]
集合对象的反向排序结果[5, 4, 3, 2, 1]
字典对象的反向排序结果[key5, key4, key3, key2, key1]
