Python 中的 5 种数据容器：列表、元组、字符串、集合和字典

Python 中的 5 种数据容器：列表、元组、字符串、集合和字典 | 极客日志

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

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

# 方式一 变量名称 = [] 
# 方式二 变量名称 = list()

[1,2,3,4,5] 
lst = [1,2,3,4,5] 
print(lst) #输出 [1, 2, 3, 4, 5] 
lst2 = ["a", "b", "c"] 
print(lst2) #输出 ['a', 'b', 'c'] 
lst3 = ["a", "b", "c",1,2,"haha"] 
print(lst3) #输出 ['a', 'b', 'c', 1, 2, 'haha'] 
lst4 = [[1,2,3],["aa","bb","cc"]] 
print(type(lst4)) #输出<class 'list'>

# 语法：列表 [下标索引]
name_list = ['Tom', 'Lily', 'Rose'] 
print(name_list[0]) # 结果：Tom 
print(name_list[1]) # 结果：Lily 
print(name_list[2]) # 结果：Rose

# 反向下标 从右到左 -1、-2、-3 递减
lst = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24] 
print(lst[-1]) # 结果 24 
print(lst[-2]) # 结果 23 
print(lst[-3]) # 结果 22

# 定义一个嵌套列表
lst =[[1,2,3],[4,5,6],[7,8]] 
# 访问嵌套列表中的元素
print(lst[1][1]) # [4,5,6] 中的 5 
print(lst[0][-1]) # [1,2,3] 中的 3

my_list = ["example", "demo", "python"] 
print(my_list.index("demo")) # 结果：1

lst = ['demo', 'example', 'python', '666'] 
# 查找元素下标，找不到会报错
print(lst.index("666")) 
# 快捷操作：确定某个元素是否在列表内（找不到不报错）
# 元素 in 列表变量
# 在里面返回 True，不在里面返回 False
print("666" in lst)

my_list = [1, 2, 3] 
my_list[0] = 5 
print(my_list) # 结果：[5, 2, 3]

my_list = [1, 2, 3] 
my_list[-3] = 5 
print(my_list) # 结果：[5, 2, 3]

my_list = [1, 2, 3] 
my_list.insert(1, "item") 
print(my_list) # 结果：[1, "item", 2, 3]

lst.insert(10, '666') # 下标超出范围时，会自动插入到列表末尾
print(lst) # 输出：[1, 'demo', 2, 3, 'item', '666']

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]]

my_list = [1, 2, 3] 
my_list.extend([4, 5, 6]) 
print(my_list) # 结果：[1, 2, 3, 4, 5, 6]

my_list = [1, 2, 3] 
# 方式 1：使用 del
del my_list[0] 
print(my_list) # 结果：[2, 3] 
# 方式 2：使用 pop()
my_list.pop(0) 
print(my_list) # 结果：[2, 3]

# 在列表尾部新增元素
# 语法：列表变量.append(元素)
lst = [1, 2, 3] 
lst.append(4) 
lst.append(5) 
lst.append(6) 
print(lst) # 输出：[1, 2, 3, 4, 5, 6] 
# 在列表尾部新增一批元素（将其它数据容器追加到当前列表尾部）
# 语法：列表变量.extend(数据容器)
lst = [1, 2, 3] 
lst.extend([4, 5, 6]) 
print(lst) # 输出：[1, 2, 3, 4, 5, 6]

my_list = [1, 2, 3, 2, 3] 
my_list.remove(2) 
print(my_list) # 结果：[1, 3, 2, 3]

# 删除列表元素
# 方式 1 del 列表 [下标]
lst = [1, 2, 3, 4, 5, 6] 
del lst[0] 
print(lst) # 输出：[2, 3, 4, 5, 6] 
# 方式 2 列表.pop(下标)
# 和方式 1 的区别是 pop 有返回值，返回的是：被删除的元素
deleted_data = lst.pop(2) 
print("被删除的是：", deleted_data) # 输出：被删除的是：5 
print(lst) # 输出：[2, 3, 6] 
# 删除某元素在列表中的第一个匹配项
# 语法：列表.remove(元素)
lst = ["demo", "example", "example", "python", "666"] 
lst.remove("example") 
print(lst) # 输出：['demo', 'example', 'python', '666'] 
lst.remove("xxx") # 报错：ValueError: list.remove(x): x not in list
print(lst)

my_list = [1, 2, 3] 
my_list.clear() 
print(my_list) # 结果：[]

# 方式 1
lst = [1, 2, 3, 4, 5, 6] 
lst.clear() 
print(lst) # 输出：[] 
# 方式 2
lst = [1, 2, 3, 4, 5, 6] 
lst = [] 
print(lst) # 输出：[]

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 (列表)	统计容器内有多少元素

index = 0 # 控制因子
while index < len(列表):
    元素 = 列表 [index] # 对元素进行处理
    index += 1 # 因子更新

lst = [1, 3, 5, 7, 9] 
index = 0 
while index < len(lst):
    print(lst[index]) # 依次输出：1, 3, 5, 7, 9
    index += 1

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

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
for i in lst:
    print(i) # 依次输出：1, 2, ..., 10

# 字面量
(1, 3, 5, "haha") 
# 变量
t1 = (1, 2, 3, "6") 
print(t1, "类型：", type(t1)) #(1, 2, 3, '6') 类型：<class 'tuple'> 
# 得到空元组
t1 = () 
t2 = tuple() 
print(type(t1), type(t2)) #<class 'tuple'> <class 'tuple'> 
# 只有 1 个元素的元组（特殊写法）
t1 = (1,) 
print(type(t1)) #<class 'tuple'> 
# 定义一个嵌套元组
t1 = ( (1, 2, 3), (4, 5, 6) ) 
print(t1[0][0]) # 结果：1

# 尝试修改元组内容
t1 = (1, 2, 3) 
t1[0] = 5

Traceback (most recent call last): File "D:\python-learn\05_数据容器\test.py", line 3, in <module> t1[0] = 5 TypeError: 'tuple' object does not support item assignment

# 尝试修改元组内容
t1 = (1, 2, ['item', 'demo']) 
t1[2][1] = 'best' 
print(t1) # 结果：(1, 2, ['item', 'best'])

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

序号	方法	功能描述
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

name = "example" 
print(name[0]) # 结果：i 
print(name[-1]) # 结果：a

name = "传智播客 传智教育 黑马程序员 博学谷"
name_list = name.split(" ") 
print(name_list) # 结果：['传智播客', '传智教育', '黑马程序员', '博学谷'] 
print(type(name_list)) # 结果：<class 'list'>

# 字符串分割
s = "周杰伦 | 王力宏 | 刘德滑"
lst = s.split("|") 
print("字符串本身：", s) 
print("分隔后：", lst, type(lst))

字符串本身：周杰伦 | 王力宏 | 刘德滑
分隔后：['周杰伦', '王力宏', '刘德滑'] <class 'list'>

my_str = " example and demo " 
print(my_str.strip()) # 结果："example and demo"

# strip() 去除字符串的前后空格和回车符
# 原有字符串不会被修改，而是返回一个新的
s = " \nexample666\n " 
s2 = s.strip() 
print(s2) # 结果："example666"

my_str = "12example and demo21" 
print(my_str.strip("12")) # 结果："example and demo"

# strip(字符串) 去除字符串中前后指定的字符
s = "|||example666|||" 
s2 = s.strip("|") 
print(s2) # 结果："example666"

my_str = "1234 abcd !@#$ 黑马程序员" 
print(len(my_str)) # 结果：20

# 统计字符串有多少个 a
# count(字符串) 统计字符串内有多少个指定的子串
s = "example a a a a a a a" 
num = s.count("a") 
print(num) # 结果：8

my_str = "黑马程序员" 
index = 0 
while index < len(my_str):
    print(my_str[index])
    index += 1

my_str = "黑马程序员" 
for i in my_str:
    print(i)

编号	操作	说明
1	字符串 [下标]	根据下标索引取出特定位置字符
2	字符串.index (字符串)	查找给定字符串的第一个匹配项的下标
3	字符串.replace (字符串 1, 字符串 2)	将字符串内的全部字符串 1，替换为字符串 2 不会修改原字符串，而是得到一个新的
4	字符串.split (字符串)	按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表
5	字符串.strip () 字符串.strip (字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count (字符串)	统计字符串内某字符串的出现次数
7	len (字符串)	统计字符串的字符个数

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

my_str = "12345" 
new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长 -1（倒序）
print(new_str) # 结果："54321" 
new_str = my_str[:4:2] # 从头开始，到下标 4（不含）结束，步长 2
print(new_str) # 结果："13"

my_list = [1, 2, 3, 4, 5] 
new_list = my_list[1:4] # 下标 1 开始，下标 4（不含）结束，步长 1
print(new_list) # 结果：[2, 3, 4] 
new_list = my_list[::2] # 从头开始，到最后结束，步长 2
print(new_list) # 结果：[1, 3, 5] 
new_list = my_list[3:1:-1] # 从下标 3 开始，到下标 1（不含）结束，步长 -1（倒序）
print(new_list) # 结果：[4, 3] 
lst = ["aa", "bb", 3, 5, 6] 
print(lst[1:3]) # 取出 "bb", 3 → 结果：['bb', 3] 
print(lst[-2:-5:-1]) # 取出 5, 3, "bb" → 结果：[5, 3, 'bb']

my_tuple = (1, 2, 3, 4, 5) 
new_tuple = my_tuple[:] # 从头开始，到最后结束，步长 1
print(new_tuple) # 结果：(1, 2, 3, 4, 5) 
new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标 1（不含）结束，步长 -2（倒序）
print(new_tuple) # 结果：(5, 3)

特性	列表	元组	字符串
存储类型	混装	混装	单一存储（字符）
有序性	有序（支持下标）	有序（支持下标）	有序（支持下标）
元素重复	支持重复	支持重复	支持重复
可修改性	可以修改	不可修改	不可修改

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

# 字面量
{1, 3, 5, "哈哈", True, 3, 5} 
# 变量
set1 = {1, 3, 5, "哈哈", True, 3, 5} 
# 去重
# 空集合
set2 = set() 
print(set1, type(set1)) #{1, 3, 5, '哈哈', True} <class 'set'> 
print(set2, type(set2)) #set() <class 'set'> 
# 去重且无序
set3 = {"bbb", "bbb", "aaa", "ccc"} 
print(set3) #{'aaa', 'bbb', 'ccc'}

my_set = {"Hello", "World"} 
my_set.add("item") 
print(my_set) # 结果：{'Hello', 'item', 'World'} 集合是无序

# remove(元素) 移除指定元素
my_set.remove("d") 
print(my_set)

# 从集合中随机取出元素
# 语法：集合.pop()，功能：从集合中随机取出一个元素
# 结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
my_set = {"Hello", "world", "item"} 
element = my_set.pop() 
print(my_set) # 结果：{'world', 'item'} 
print(element) # 结果：'Hello'

# 清空集合
my_set.clear() 
# my_set = set()
print(my_set) # 结果：set()

set1 = {1, 2, 3} 
set2 = {1, 5, 6} 
set3 = set1.union(set2) 
print(set3) # 结果：{1, 2, 3, 5, 6}，新集合
print(set1) # 结果：{1, 2, 3}，set1 不变
print(set2) # 结果：{1, 5, 6}，set2 不变

# 2 个集合的并集，合并
# set1.union(set2) 2 个集合合并为 1 个
# 结果：原有 set1、set2 不变，得到新的集合
set1 = {1, 2, 3} 
set2 = {1, 4, 5} 
set3 = set1.union(set2) 
print("合并后：", set3) 
print("原有 set1：", set1) 
print("原有 set2：", set2)

set1 = {1, 2, 3} 
print(len(set1)) # 结果：3

my_set = {"c", "a", "b", "c"} 
# 统计元素数量，len(集合)
print(len(my_set)) # 结果：3（因为集合自动去重）

# 集合同样支持 for 循环遍历
set1 = {1, 2, 3} 
for i in set1:
    print(i) # 结果
    # 1
    # 2
    # 3

编号	操作	说明
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 (集合)	得到一个整数，记录了集合的元素数量

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

# 前文记录学生成绩的需求，可以如下记录：
stu_score = {"王力鸿": 99, "周杰伦": 88, "林俊节": 77}

# 空字典
d = {} 
print(type(d)) # 打印结果：<class 'dict'> 
d = dict() 
print(type(d)) # 打印结果：<class 'dict'>

# 字面量
{"周杰伦": 99, "王力鸿": 88, "林军杰": 77} 
# 变量
d = {"周杰伦": 99, "王力鸿": 88, "林军杰": 77, 0: 66}

# 字典的 key 是不可以重复的
d = {"周杰伦": 99, "王力鸿": 88, "林军杰": 77, "林军杰": 66} 
# 打印出来后，第二个林军杰覆盖第一个林军杰
print(d)

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

d = {
 "周杰伦": ["唱", "跳", "rap"], 
 "林军杰": ["吃", "喝", "玩"], 
 "王力鸿": ["睡", "呆", "憨"]
}
# 查看王力鸿的爱好
print(d["王力鸿"]) 
# 查看王力鸿的爱好 2
print(d["王力鸿"][1])

# 语法：字典 [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
}
stu_score.clear() 
print(stu_score) # 结果：{}

# 语法：字典.keys()，结果：得到字典中的全部 Key
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
keys = stu_score.keys() 
print(keys) # 结果：dict_keys(['王力鸿', '周杰伦', '林俊节'])

# 方式 1：通过 keys()
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
keys = stu_score.keys() 
for key in keys:
    print(f"学生:{key}, 分数:{stu_score[key]}") 
# 方式 2：直接遍历字典（可读性好）
for key in stu_score.keys():
    print(f"{key}: {stu_score[key]}") 
# 方式 3：直接对字典 for x in 字典，得到的就是 key
for key in stu_score:
    print(f"{key}: {stu_score[key]}")

# 语法：len(字典)
print(len(stu_score)) # 结果：3

d = {
 "王力鸿": {"部门": "科技部", "工资": 3000, "级别": 1}, 
 "周杰伦": {"部门": "市场部", "工资": 5000, "级别": 2}, 
 "林军杰": {"部门": "市场部", "工资": 7000, "级别": 3}, 
 "张学油": {"部门": "科技部", "工资": 4000, "级别": 1}, 
 "刘德滑": {"部门": "市场部", "工资": 6000, "级别": 2}
}
print(f"更新前：\n{d}") 
for k in d:
    if d[k]["级别"] == 1: # 更新工资
        d[k]["工资"] = d[k]["工资"] + 1000 
        # 更新级别
        d[k]["级别"] = 2 
print(f"更新后：\n{d}")

lst = [1, 3, 5, 7, 9] 
t = (1, 3, 5, 7, 9) 
s_str = "itheima" 
s_set = {1, 3, 5, 7, 9} 
d = {"1": 11, "2": 22, "3": 33} 
# 转字符串
print("*"*50) # 输出：**************************************************
print(f"{lst} 转 str： {str(lst)}") # 输出：[1, 3, 5, 7, 9] 转 str： [1, 3, 5, 7, 9]
print(f"{t} 转 str： {str(t)}") # 输出：(1, 3, 5, 7, 9) 转 str： (1, 3, 5, 7, 9)
print(f"{s_set} 转 str： {str(s_set)}") # 输出：{1, 3, 5, 7, 9} 转 str： {1, 3, 5, 7, 9}
print(f"{d} 转 str： {str(d)}") # 输出：{'1': 11, '2': 22, '3': 33} 转 str： {'1': 11, '2': 22, '3': 33}
# 转集合
print("*"*50) # 输出：**************************************************
print(f"{lst} 转 set： {set(lst)}") # 输出：[1, 3, 5, 7, 9] 转 set： {1, 3, 5, 7, 9}
print(f"{t} 转 set： {set(t)}") # 输出：(1, 3, 5, 7, 9) 转 set： {1, 3, 5, 7, 9}
print(f"{s_str} 转 set： {set(s_str)}") # 输出：itheima 转 set： {'m', 'i', 't', 'h', 'e', 'a'}
print(f"{d} 转 set： {set(d)}") # 输出：{'1': 11, '2': 22, '3': 33} 转 set： {'1', '2', '3'}
# 转列表
print(f"{t} 转 list： {list(t)}") # 输出：(1, 3, 5, 7, 9) 转 list： [1, 3, 5, 7, 9]
print(f"{s_str} 转 list： {list(s_str)}") # 输出：itheima 转 list： ['i', 't', 'h', 'e', 'i', 'm', 'a']
print(f"{s_set} 转 list： {list(s_set)}") # 输出：{1, 3, 5, 7, 9} 转 list： [1, 3, 5, 7, 9]
print(f"{d} 转 list： {list(d)}") # 输出：{'1': 11, '2': 22, '3': 33} 转 list： ['1', '2', '3']

# 排序
lst = [5, 3, 1, 7, 2] 
t = (5, 3, 1, 7, 2) 
s_str = "itheima" 
s_set = {5, 3, 1, 7, 2} 
d = {"33": 11, "cc": 22, "bb": 33} 
print("*"*50) # 输出：**************************************************
print(f"{lst}, 排序后：{sorted(lst)}") # 输出：[5, 3, 1, 7, 2], 排序后：[1, 2, 3, 5, 7]
print(f"{t}, 排序后：{sorted(t)}") # 输出：(5, 3, 1, 7, 2), 排序后：[1, 2, 3, 5, 7]
print(f"{s_str}, 排序后：{sorted(s_str)}") # 输出：itheima, 排序后：['a', 'e', 'h', 'i', 'i', 'm', 't']
print(f"{s_set}, 排序后：{sorted(s_set)}") # 输出：{1, 2, 3, 5, 7}, 排序后：[1, 2, 3, 5, 7]
print(f"{d}, 排序后：{sorted(d)}") # 输出：{'33': 11, 'cc': 22, 'bb': 33}, 排序后：['33', 'bb', 'cc'] （按 key 排序并且仅剩余 key 转为 list）
# 降序排序 reverse=True
print("*"*50) # 输出：**************************************************
print(f"{lst}, 排序后 (reverse=True): {sorted(lst, reverse=True)}") # 输出：[5, 3, 1, 7, 2], 排序后 (reverse=True): [7, 5, 3, 2, 1] （转为 list）
print(f"{t}, 排序后 (reverse=True): {sorted(t, reverse=True)}") # 输出：(5, 3, 1, 7, 2), 排序后 (reverse=True): [7, 5, 3, 2, 1] （转为 list）
print(f"{s_str}, 排序后 (reverse=True): {sorted(s_str, reverse=True)}") # 输出：itheima, 排序后 (reverse=True): ['t', 'm', 'i', 'i', 'h', 'e', 'a']
print(f"{s_set}, 排序后 (reverse=True): {sorted(s_set, reverse=True)}") # 输出：{1, 2, 3, 5, 7}, 排序后 (reverse=True): [7, 5, 3, 2, 1] （转为 list）
print(f"{d}, 排序后 (reverse=True): {sorted(d, reverse=True)}") # 输出：{'33': 11, 'cc': 22, 'bb': 33}, 排序后 (reverse=True): ['cc', 'bb', '33'] （按 key 排序并且仅剩余 key 转为 list）

lst = [1, 3, 5, 7, 9] 
t = (1, 3, 5, 7, 9) 
s_str = "itheima" 
s_set = {1, 3, 5, 7, 9} 
d = {"1": 11, "2": 22, "3": 33} 
# 找出最大值
print(f"{lst}, max: {max(lst)}") # 输出：[1, 3, 5, 7, 9], max: 9
print(f"{t}, max: {max(t)}") # 输出：(1, 3, 5, 7, 9), max: 9
print(f"{s_str}, max: {max(s_str)}") # 输出：itheima, max: t
print(f"{s_set}, max: {max(s_set)}") # 输出：{1, 3, 5, 7, 9}, max: 9
print(f"{d}, max: {max(d)}") # 输出：{'1': 11, '2': 22, '3': 33}, max: 3
# 找出最小值
print(f"{lst}, min: {min(lst)}") # 输出：[1, 3, 5, 7, 9], min: 1
print(f"{t}, min: {min(t)}") # 输出：(1, 3, 5, 7, 9), min: 1
print(f"{s_str}, min: {min(s_str)}") # 输出：itheima, min: a
print(f"{s_set}, min: {min(s_set)}") # 输出：{1, 3, 5, 7, 9}, min: 1
print(f"{d}, min: {min(d)}") # 输出：{'1': 11, '2': 22, '3': 33}, min: 1

print("a" > "A") # 输出：True
print("A" > "!") # 输出：True
# 有内容大于空，即 d 大于空，则 abcd 大
print("abc" > "abcd") # 输出：False
# 2 大，第一位"2"是大于"1"
print("123" > "2") # 输出：False
# 中文也能比较大小，依靠编码表（一般是 UTF8 或 GBK）
print("黑" > "马") # 输出：False

Python 中的 5 种数据容器：列表、元组、字符串、集合和字典

1 数据容器入门

2 列表

2.1 列表定义

2.2 列表下标索引

2.3 列表常用方法

2.4 列表的遍历

3 元组

3.1 元组的定义

3.2 重新认识字符串

4 序列

4.1 序列的定义

4.2 序列的切片

5 集合

5.1 基本语法

5.2 集合的操作

5.3 总结

6 字典

6.1 字典的定义

6.2 字典的操作

6.3 总结

6.4 练习案例

7 总结

更多推荐文章

相关免费在线工具

Python 中的 5 种数据容器：列表、元组、字符串、集合和字典

1 数据容器入门

2 列表

2.1 列表定义

2.2 列表下标索引

2.3 列表常用方法

2.4 列表的遍历

3 元组

3.1 元组的定义

3.2 重新认识字符串

4 序列

4.1 序列的定义

4.2 序列的切片

5 集合

5.1 基本语法

5.2 集合的操作

5.3 总结

6 字典

6.1 字典的定义

6.2 字典的操作

6.3 总结

6.4 练习案例

7 总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具