python基础----04-----函数、数据容器(列表list、元祖tuple、字符串str、集合set、字典dict，包括容器序列的切片操作)、容器之间的转换、容器sorted排序、字符串大小比
一 函数的基本定义语法
函数的定义：
def 函数名 (传入参数):
函数体
return 返回值 #其中传入参数与返回值可以没有
函数的调用：
# 传入参数可以是空，或者是一个到多个
a = 函数名(传入参数)
例如。
if __name__ == '__main__':
def check():
print("你好")
# 函数调用
check()
"""
你好
"""
二 函数的返回值定义语法
if __name__ == '__main__':
def add(a,b):
result = a + b
return result
r = add(1,2)
print(r)
"""
3
"""
如果函数没有使用return语句返回数据，那么函数有返回值吗?
实际上是：有的。
Python中有一个特殊的字面量: None, 其类型是:
无返回值的函数，实际上就是返回了： None这个字面量。
if __name__ == '__main__':
def add(a, b):
result = a + b
r = add(1, 2)
print(type(r)) #None作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。
- 用在函数无返回值上。
- 用在if判断上。
- 在if判断中，None等同于False，一般用于在函数中主动返回None，配合if判断做相关处理。
- 用于声明无内容的变量上。定义变量，但暂时不需要变量有具体值，可以用None来代替。
if __name__ == '__main__':
# 主动返回None的函数
def say_hi2():
print("你好呀")
return None
result = say_hi2()
print(f"无返回值函数，返回的内容是: {result}")
print(f"无返回值函数，返回的内容类型是: {type(result)}")
# None用于if判断
def check_age(age):
if age > 18:
return " SUCCESS"
else:
return None
result=check_age(16)
if not result:
# 进入if表示result是None值也就是False
print("未成年，不可以进入")
"""
你好呀
无返回值函数，返回的内容是: None
无返回值函数，返回的内容类型是:
未成年，不可以进入
"""
if __name__ == '__main__':
name = None
三 变量在函数中的作用域
变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用)。
主要分为两类：局部变量和全局变量，
- 局部变量的作用：在函数体内部，函数 调用完之后 临时变量立即消失（前面讨论if for while 中定义的变量时 外部可以访问 但是不推荐那样用 函数 是出错 不可以外面调用局部变量）。
if __name__ == '__main__':
def testA():
num = 100
print(num)
testA() # 100
print(num)# 报错: name 'num is not defined'
- 全局变量：指的是在函数体内、外都能生效的变量。
if __name__ == '__main__':
num = 100
def testA():
print(num)
testA() # 100
print(num)# 100
可以通过global声明或者定义全局变量。
没有global声明，由于作用域不同，所以在testA()函数内部修改num=200，无法影响到函数外的值。
if __name__ == '__main__':
num = 100
def testA():
num = 200
print(num)
testA()
print(num)
若想在testA()声明为全局变量，此时可以加上global声明：
if __name__ == '__main__':
num = 100
def testA():
global num
num = 200
print(num)
testA()
print(num)
注意，如果我们把最开头的num = 100去掉，在testA()内部加上global关键字，此时也是全局变量。
if __name__ == '__main__':
def testA():
global num
num = 200
print(num)
testA()
print(num)
四 数据容器入门
python数据容器主要分为5类，分别是：列表(list) 、元组(tuple) 、字符串(str) 、集合(set) 、字典(dict)。
4.1 列表
4.1.1 列表的定义语法
#字面量
[元素1，元素2，元素3...]
#定义变量
变量名称 = [元素1，元素2，元素3...]
#定义空列表
变量名称 = []
变量名称 = list()
列表内的每一个数据，称之为元素。
- 以[ ]作为标识。
- 列表内每一个元素之间用，逗号隔开。
- 注意：列表可以存储一次存储多个数据，且可以为不同的数据类型，支持嵌套。
if __name__ == '__main__':
my_list = ["who", "are", "you"]
print(my_list)
print(type(my_list))
my_list = [" who", 666, True]
print(my_list)
print(type(my_list))
列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增；或者从后向前，从-1开始，依次递减。
if __name__ == '__main__':
# 定义一个嵌套的列表
my_list = [1, 2, 3]
print(my_list[0], my_list[1], my_list[2])
print(my_list[-3], my_list[-2], my_list[-1])
4.1.2 列表的常用操作方法
列表除了定义、使用下标索引，以外也提供了一系列功能：插入元素、删除元素、清空元素、修改元素、统计元素个数等等功能，我们成为列表的方法。
函数是一个封装的代码单元，可以提供特定功能。在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)
4.1.2.1 列表的查询功能
语法：列表.index(元素)
功能：查找指定元素在列表的下标，如果找不到，报错ValueError。
index就是列表对象(变量)内置的方法(函数)。
if __name__ == '__main__':
my_list = [" itheima", 666, True]
print(my_list.index(" itheima"))
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list.index(1)) #报错！！！
print(my_list.index([1, 2, 3])) # 0
4.1.2.2 列表的修改
语法：列表[下标]=值
if __name__ == '__main__':
# 正向下标
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]
4.1.2.3 列表的插入
语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素。
if __name__ == '__main__':
my_list = [1, 2, 3]
my_list.insert(1, "itheima")
print(my_list)
'''
[1, 'itheima', 2, 3]
'''
4.1.2.4 列表的追加
语法：列表.append（元素），在指定元素，追加到列表的尾部。
if __name__ == '__main__':
my_list = [1, 2, 3]
print(my_list)
my_list.append(4)
print(my_list)
# 结果:
'''
[1, 2, 3]
[1, 2, 3, 4]
'''
4.1.2.5 列表的extend用法
extend可以一次往列表添加多个元素。
if __name__ == '__main__':
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)
# 结果:
'''
[1, 2, 3, 4, 5, 6]
'''
if __name__ == '__main__':
my_list = [1, 2, 3]
my_list.extend(["who", "are", True])
print(my_list)
# 结果:
'''
[1, 2, 3, 'who', 'are', True]
'''
4.1.2.6 列表的删除
列表的删除有3种方式。
- 语法1：del 列表[下标]。
- 语法2：列表.pop(下标)。
- 语法3：列表.remove(元素)。注意，remove函数传的是元素，并非是下标。
if __name__ == '__main__':
my_list = [1, 2, 3]
print(my_list)
del my_list[1]
print(my_list)
my_list.pop(1)
print(my_list)
# 结果:
'''
[1, 2, 3]
[1, 3]
[1]
'''
列表.remove测试。
if __name__ == '__main__':
my_list = [1, 2, 3]
print(my_list)
my_list.remove(2)
print(my_list)
my_list.remove(2) # 删除不存在的元素会报错
print(my_list)
# 结果:
'''
[1, 2, 3]
[1, 3]
'''
4.1.2.7 清空列表
语法：列表.clear()。
if __name__ == '__main__':
my_list = [1,2,3]
print(my_list)
my_list.clear()
print(my_list)
# 结果:
'''
[1, 2, 3]
[]
'''
4.1.2.8 列表统计某个元素个数
语法：列表.count(元素)。
if __name__ == '__main__':
my_list = [1, 2, 3, 3, 3, 3, 5]
print(my_list)
count = my_list.count(3)
print(count)
# 结果:
'''
[1, 2, 3, 3, 3, 3, 5]
4
'''
4.1.2.9 统计全部元素个数(长度)
语法：len(列表)。
if __name__ == '__main__':
my_list = [1, 2, 3, 3, 3, 3, 5]
print(my_list)
count = len(my_list)
print(count)
# 结果:
'''
[1, 2, 3, 3, 3, 3, 5]
7
'''
4.1.3 列表总结
经过上述对列表的学习，可以总结出列表有如下特点：
●可以容纳多个元素(上限为2**63+1、9223372036854775807个)。
●可以容纳不同类型的元素(混装)。
●数据是有序存储的 (有下标序号)。
●允许重复数据存在。
●可以修改(增加或删除元素等)。
4.1.4 列表的循环遍历
while循环。
定义一个变量表示下标，从0开始。
循环条件：下标值 < 列表的元素数量。
if __name__ == '__main__':
my_list = [21,25,21,23,22,20]
index = 0
while index < len(my_list):
print(my_list[index], end=" ")
index +=1
print()
print(my_list)
for循环。
语法：
'''
for 临时变量 in 数据容器：
对临时变量进行处理
'''
表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，我们可以对临时变量(元素)进行处理。
if __name__ == '__main__':
my_list = [21,25,21,23,22,20]
index = 0
for a in my_list:
print(a ,end=" ")
print()
print(my_list)
while与for的对比，while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
- 1）while循环可以自定循环条件，并自行控制。
- 2）for循环不可以自定循环条件，只可以一个个从容器内取出数据。
在无限循环上：
- 1）while循环可以通过条件控制做到无限循环。
- 2）for循环理论上不可以，因为被遍历的容器容量不是无限的。
在使用场景上：
- 1）while循环适用于任何想要循环的场景。
- 2）for循环适用于，遍历数据容器的场景或简单的固定次数循环场景。
4.2 元组的定义和操作
4.2.1 元祖的定义
为什么要引入元组？
思考列表的痛点，他可以被修改，我们有时候需要我自己封装的程序数据不被修改，那么我们就引入了元组——一旦完成定义，就不可以修改。他同样可以储存不同类型元素。
if __name__ == '__main__':
# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是: {type(t1)}， 内容是: {t1}")
print(f"t2的类型是: {type(t2)}， 内容是: {t2}")
print(f"t3的类型是: {type(t3)}， 内容是: {t3}")
'''
t1的类型是: ， 内容是: (1, 'Hello', True)
t2的类型是: ， 内容是: ()
t3的类型是: ， 内容是: ()
'''
但是定义单个变量时！！！！一个元素后面加上逗号","，这是为了防止和字符串发生二义。
if __name__ == '__main__':
# 定义元组
t1 = ("Hello",)
# 单个元素不加逗号，类型是字符串
t2 = ("Hello")
print(f"t1的类型是: {type(t1)}， 内容是: {t1}")
print(f"t2的类型是: {type(t2)}， 内容是: {t2}")
'''
t1的类型是: ， 内容是: ('Hello',)
t2的类型是: ， 内容是: Hello
'''
同样元组可以嵌套使用。
if __name__ == '__main__':
# 元组的嵌套
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的类型是: {type(t5)}， 内容是: {t5}")
'''
t5的类型是: ， 内容是: ((1, 2, 3), (4, 5, 6))
'''
4.2.2 元祖的操作
元祖的操作方法。
if __name__ == '__main__':
# 1. 元组支持下标索引
t5 = ((1, 2, 3), (4, 5, 6))
num = t5[1][2]
print(f"t5的取出的内容是: {num}") # 6
# 2. 根据index()，查找特定元素的第一个匹配项
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello')) # 结果:2
# 3. 统计某个数据在元组内出现的次数
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.count('hello')) # 结果: 2
# 4. 统计元组内的元素个数
t1 = (1, 2, 3)
print(len(t1)) # 结果3
元组的遍历。
if __name__ == '__main__':
t1 = ("h", 1, 4.2, True)
index = 0
while index < len(t1):
print(f"元组的元素有: {t1[index]}")
# 至关重要
index += 1
# 元组的遍历: for
for eLement in t1:
print(f"2元组的元素有: {eLement}")
如果尝试修改tuple中的数据：
错误提示：TypeError: ’ tuple 'object does not support item assignment
但是如果你元组中嵌套了一个list，它就可以改list里面的东西。
if __name__ == '__main__':
# 尝试修改元组内容
t1 = (1, 2, ['itheima', 'itcast'])
t1[2][1] = ' best' # 列表可以修改
print(t1)# 结果:(1, 2, ['itheima', ' best'])
t1[0] = 10 # 报错，除了元祖的元素是列表以外，其它类型无法修改
4.2.3 元祖的总结
4.3 字符串的定义和操作
字符串是字符的容器，一个字符串可以存放任意数量的字符。
和其它容器如:列表、元组一样，字符串也可以通过下标进行访问。
- 从前向后，下标从0开始。
- 从后向前，下标从-1开始。
1. 字符串的下标（索引）
if __name__ == '__main__':
t1 = "who are you"
print(t1[2])# o
print(t1.index("h")) # 1
2. 字符串无法修改
1）无法修改指定下标的字符(如:字符串[0]=“a" )
2）无法移除特定下标的字符(如: del 字符串[0]、字符串.remove()、字符串.pop()等)
3）无法追加字符等(如:字符串.append())
这些都是无法完成的，除非重新定义另一个字符串才可以。
如果修改会发生错误：TypeError: ‘str’ object does not support item assignment。
if __name__ == '__main__':
t1 = "who are you"
t1[0] = '1'
3. 字符串的替换
语法：字符串.replace(字符串1,字符串2)
功能：将字符串内的全部字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新字符串
if __name__ == '__main__':
t1 = "(1,2,['itheima', 'itcast'])"
t2 = t1.replace(',', "sb")
print(t2)
结果。
4. 字符串的分割
语法:字符串.split(分隔符字符串)
功能:按照指定的分隔符字符串,将字符串划分为多个字符串，并存入列表对象中
注意:字符串本身不变，而是得到了一个列表对象
if __name__ == '__main__':
t1 = "(1,2,['itheima', 'itcast'])"
t2 = t1.split(',')
print(t2) #['(1', '2', "['itheima'", " 'itcast'])"]
5. 字符串的规整操作
if __name__ == '__main__':
t1 = "12who are you21"
t2 = t1.strip("12")
print(t2)
t3 = t1.strip("1")
print(t3)
# 由于2不是最开头和最末尾，所以不会处理
t4 = t1.strip("2")
print(t4)
6. 字符串的元素个数
if __name__ == '__main__':
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是: {count}")
'''
字符串itheima and itcast中it出现的次数是: 2)
'''
7. 字符串的长度
if __name__ == '__main__':
my_str = "sb"
a = len(my_str)
print(a)#2
4.4 数据容器（序列）的切片
序列是指：内容连续、有序，可使用下标索引的一类数据容。列表、元组、字符串，均可以可以视为序列。
序列的切片语法：
切片操作不会影响序列本身。
if __name__ == '__main__':
# 1 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1,2, 3,4, 5,6]
result1 = my_list[1:4]
# 步长默认是1,所以可以省略不写
print(f"结果1: {result1}")
# 2 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1, 2,3, 4,5,6)
result2 = my_tuple[:]
# 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2: {result2}")
# 3 对str进行切片，从头开始，到最后结束,步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3: {result3}")
# 4 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]
# 等同于将序列反转了
print(f"结果4: {result4}")
# 5 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5: {result5}")
# 6 对元组进行切片，从头开始，到尾结束，步长-2
my_tupLe = (0,1, 2, 3, 4,5,6)
result6 = my_tupLe[::-2]
print(f"结果6: {result6}")
'''
结果1: [1, 2, 3]
结果2: (0, 1, 2, 3, 4, 5, 6)
结果3: 0246
结果4: 76543210
结果5: [3, 2]
结果6: (6, 4, 2, 0)
'''
4.5 集合的定义和操作
集合的语法：
集合set的特点：
- 1）集合是无序的。
- 2）集合的元素是去重的。
集合的方法。
1. 添加新元素
if __name__ == '__main__':
# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
print(my_set)# 注意，set是自动去重的.
my_set.add("Python")
print(my_set)
注意，因为set是自动去重的，所以有重复的元素只会保存一个。而且set是无序的，所以每次打印输出结果是无序的。
2. 移除元素
if __name__ == '__main__':
# 定义集合
my_set = {"1", "2", "1", "2"}
print(my_set)
my_set.remove("2")
print(my_set)
3. 随机移除元素
if __name__ == '__main__':
# 定义集合
my_set = {"1","2", "3", "1"}
print(my_set)
a = my_set.pop()
print(a)
print(my_set)
可以看到下面，运行多次，pop是随机移除一个元素。
4. 清空元素
if __name__ == '__main__':
# 定义集合
my_set = {"1", "2", "3", "4", "5"}
print(my_set)
a = my_set.clear()
print(a)
print(my_set)
5. 取俩个集合的差集
if __name__ == '__main__':
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}不变
6. 消除2个集合的差集
if __name__ == '__main__':
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)
# 结果:{2，3}
print(set2)
# 结果:{1，5，6}
7. 2个集合合并
if __name__ == '__main__':
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)
# 结果:{1，2，3，5，6}，新集合,1会去重
print(set1)
# 结果:{1，2，3}，set1不变
print(set2)
# 结果:{1，5，6}，set2不变
8. 集合长度
if __name__ == '__main__':
set1 = {1, 2, 3}
print(len(set1))#3
9. 集合的遍历
因为集合不能用于索引下标，所以只能用for循环进行遍历，while循环不可以使用。
if __name__ == '__main__':
set1 = {1, 2, 13, 4, 5}
for eLement in set1:
print(f"集合的元素有: {eLement}")
4.6 字典的定义
if __name__ == '__main__':
my_dict1 = { "k1":99,"k2":75 ,"k3":75}
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的内容是: {'k1': 99, 'k2': 75, 'k3': 75},类型:
字典2的内容是: {}，类型:
字典3的内容是: {},类型:
'''
字典的注意事项需要注意一下。
字典可以嵌套。
if __name__ == '__main__':
my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
"k2":{"语文":88,"数学":66,"英语":33} ,
"k3":{"语文":99,"数学":66,"英语":33}}
print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
score = my_dict1["k1"]["语文"]
print(score)
4.6.1 字典的常用操作
1. 新增/更新元素
语法：字典[Key] = Value
当key不存在，表示新增
当key存在，表示更新，即修改Value。
if __name__ == '__main__':
d1 = {}
d1["k1"] = "who"
print(d1)
print(type(d1))
d1["k1"] = "are"
print(d1)
print(type(d1))
2. 删除元素
语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
if __name__ == '__main__':
my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
"k2":{"语文":88,"数学":66,"英语":33} ,
"k3":{"语文":99,"数学":66,"英语":33}}
print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
a = my_dict1.pop("k1")
print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
3. 清空元素
语法：字典.clear()
if __name__ == '__main__':
my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
"k2":{"语文":88,"数学":66,"英语":33} ,
"k3":{"语文":99,"数学":66,"英语":33}}
print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
my_dict1.clear()
print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
4. 获取全部的key
语法：字典.keys(),结果：得到自带那种的全部Key
if __name__ == '__main__':
my_dict1 = { "k1": {"语文":77,"数学":66,"英语":33},
"k2":{"语文":88,"数学":66,"英语":33} ,
"k3":{"语文":99,"数学":66,"英语":33}}
print(f"字典1的内容是: {my_dict1},类型: {type(my_dict1)}")
keys = my_dict1.keys()
print(keys)
5. 遍历字典
语法：只能for 不能while 因为他不支持下标索引！！！！
if __name__ == '__main__':
my_dict = { "k1": {"语文":77,"数学":66,"英语":33},
"k2":{"语文":88,"数学":66,"英语":33} ,
"k3":{"语文":99,"数学":66,"英语":33}}
keys = my_dict.keys()
# 方式1:通过获取到全部的key来完成遍历
for key in keys:
print(f"字典的key是: {key}")
print(f"字典的value是: {my_dict[key]}")
# 方式2:直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
print(f"2字典的key是: {key}")
print(f"2字典的value是: {my_dict[key]}")
6. 统计字典内的元素数量
语法：len(字典)
if __name__ == '__main__':
my_dict = { "k1": {"语文":77,"数学":66,"英语":33},
"k2":{"语文":88,"数学":66,"英语":33} ,
"k3":{"语文":99,"数学":66,"英语":33}}
print(len(my_dict))#3
五 五类数据容器的总结对比
六 数据容器的通用操作
这里主要讲述不同容器之间的转换。
if __name__ == '__main__':
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}
# 1 类型转换:容器转列表
print(f"列表转列表的结果是: {list(my_list)}")
print(f"元组转列表的结果是: {list(my_tuple)}")
print(f"字串转列表结果是: {list(my_str)}")
print(f"集合转列表的结果是: {list(my_set)}")
print(f"字典转列表的结果是: {list(my_dict)}")# 字典的value没了
print("======================")
# 2 类型转换:容器转元组
print(f"列表转元组的结果是: {tuple(my_list)}")
print(f"元组转元组的结果是: {tuple(my_tuple)}")
print(f"字串转元组结果是: {tuple(my_str)}")
print(f"集合转元组的结果是: {tuple(my_set)}")
print(f"字典转元组的结果是: {tuple(my_dict)}")# 字典的value没了
print("======================")
# 3 类型转换:容器转字符串
print(f"列表转字符串的结果是: {str(my_list)}")
print(f"元组转字符串的结果是: {str(my_tuple)}")
print(f"字串转字符串结果是: {str(my_str)}")
print(f"集合转字符串的结果是: {str(my_set)}")
print(f"字典转字符串的结果是: {str(my_dict)}")
print("======================")
# 4 类型转换:容器转集合
print(f"列表转集合的结果是: {set(my_list)}")
print(f"元组转集合的结果是: {set(my_tuple)}")
print(f"字串转集合结果是: {set(my_str)}")
print(f"集合转集合的结果是: {set(my_set)}")
print(f"字典转集合的结果是: {set(my_dict)}")# 字典的value没了，且无序
# 5 类型转换:容器转字典(会报错)
# print(f"列表转字典的结果是: {dict(my_list)}")
# print(f"元组转字典的结果是: {dict(my_tuple)}")
# print(f"字串转字典结果是: {dict(my_str)}")
# print(f"集合转字典的结果是: {dict(my_set)}")
# print(f"字典转字典的结果是: {dict(my_dict)}")
七 容器通用排序和功能
容器通用排序和功能。
sorted（容器，[reverse = True]）
其中，最重要的是，排序结果变成了列表！！！！字典value丢失。
if __name__ == '__main__':
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("======================")
print(f"列表type: {type(sorted(my_list))}" )
print(f"元组type: {type(sorted(my_tuple))}")
print(f"字符串type: {type(sorted(my_str))}")
print(f"集合type: {type(sorted(my_set))}" )
print(f"字典type: {type(sorted(my_dict))}")
print("======================")
print(f"列表对象的排序结果: {sorted(my_list,reverse=True)}" )
print(f"元组对象的排序结果: {sorted(my_tuple,reverse=True)}")
print(f"字符串对象的排序结果: {sorted(my_str,reverse=True)}")
print(f"集合对象的排序结果: {sorted(my_set,reverse=True)}" )
print(f"字典对象的排序结果: {sorted(my_dict,reverse=True)}")
八 拓展字符串大小比较方式
python的字符串比较和C/C++是一样的，都是通过ascii码进行比较。
if __name__ == '__main__':
# abc比较abd
print(f"abd大于abc，结果: {'abd' > 'abc'}")
# a比较ab
print(f"ab大于a，结果: {'ab' > 'a'}")
# a比较A
print(f"a大于A，结果: {'a' > 'A'}")
# key1比较key2
print(f"key2 > key1， 结果: {'key2' > 'key1'}")
