编写网站程序,工作1月工资257元,营销策划书范文,北京企业网站建设公司哪家好数据来源
01 数据容器
为什么学习数据容器 数据容器 总结 02 列表
1#xff09;列表定义
为什么需要列表 列表的定义语法 列表的定义方式 演示 演示数据容器之:list列表
语法:[元素,元素,......]# 定义一个列表list
my_list …数据来源
01 数据容器
为什么学习数据容器 数据容器 总结 02 列表
1列表定义
为什么需要列表 列表的定义语法 列表的定义方式 演示 演示数据容器之:list列表
语法:[元素,元素,......]# 定义一个列表list
my_list [张三,18,法外狂徒]
print(my_list)
print(type(my_list))# 定义一个嵌套的列表
my_list2 [[张三,18,法外狂徒],[刘海柱,19,职业法师]]
print(my_list2)
print(type(my_list2)) 总结 2列表的下标索引 演示
# 通过下标索引取出对应位置的数据
my_list [张三,18,法外狂徒]
print(f我是my_list列表的第1个数据{my_list[0]})
print(f我是my_list列表的第2个数据{my_list[1]})
print(f我是my_list列表的第3个数据{my_list[2]})列表的下标索引- 反向 演示
# 通过下标索引取出数据(倒序取出)
my_list [张三,18,法外狂徒]
print(f我是my_list列表的倒数第1个数据{my_list[-1]})
print(f我是my_list列表的倒数第2个数据{my_list[-2]})
print(f我是my_list列表的倒数第3个数据{my_list[-3]}) 嵌套列表的下标索引 演示
# 取出嵌套列表的元素
my_list [[张三,18,法外狂徒],[刘海柱,19,职业法师]]
print(f我是my_list列表的第1个数据的第1个数据{my_list[0][0]})
print(f我是my_list列表的第2个数据的第2个数据{my_list[1][1]}) 总结 3列表的常用操作
列表的常用操作方法 列表的查询功能方法 演示 演示示数据容器之:list列表的常用操作my_list [1,2,3,4,5,6,7]
# 1.1 查找某元素在列表内的下标(索引)
print(my_list.index(7))# 1.2 如果被查找的元素不存在会报错
print(my_list.index(8)) 列表的修改功能方法 演示
# 2.1 修改特定下际索引的值正向下标
my_list [1,2,3]
my_list[0] 9
print(f正向下标:{my_list})# 2.2 修改特定下际索引的值反向下标
my_list[-1] 666
print(f反向下标:{my_list})插入元素 演示
# 3. 在指定下际位置插入新元素
my_list [1,2,3]
# 语法insert(指定位置,要插入的元素)
my_list.insert(1,张三)
print(my_list) 追加元素 演示
# 4. 在列表的尾部追加单个新元素
# 语法append(要追加的元素)
my_list [1,2,3]
my_list.append(李四)
print(my_list)my_list.append([22,34]) # 也可以追加一个列表
print(my_list)追加元素方式2追加一批元素 演示
# 5. 在列表的尾部追加一批新元素
my_list [1,2,3]
my_list.extend([4,5,6,7])
print(my_list)
# 或
arr [你好,李银河,18]
my_list.extend(arr)
print(my_list) 删除元素 演示
# 6. 别除指定下际索引的元素(2种方式)
my_list [1,2,3,4,张,6,7,三,9]
# 6.1 方式1:del列表[下标]
# 语法: del 列表[索引]
del my_list[4]
print(my_list)# 6.2方式2:列表,pop(下标)
# 语法: 列表.pop(索引)
element my_list.pop(6) # 我这里要删除列表中的三字因为上面已经删除了一个元素三字的下标已经由7变成6所以这里索引写6
print(my_list)
print(f被删除的元素是{element})# 两种方式的最大区别del只能删除指定的元素pop删除指定的元素并返回被删除的元素 删除某元素在列表中的第一个匹配项 演示
# 7. 除某元素在列表中的第一个匹配项
my_list [1,2,3,4,2,57,2]
my_list.remove(2)
print(my_list) 清空列表内容 演示
# 8. 清空列表的内容
my_list [1,2,3,4,2,57,2]
my_list.clear()
print(my_list)统计列表内容某元素的数量 演示
# 9. 统计列表内容某元素的数量
my_list [1,2,3,4,2,57,2]
print(my_list.count(2)) 统计列表中全部元素数量 演示
# 10. 统计列表中全部元素数量
my_list [1,2,3,4,2,57,2]
print(len(my_list)) 列表的方法-总览
使用方式的完整代码演示 演示示数据容器之:list列表的常用操作# my_list [1,2,3,4,5,6,7]
# # 1.1 查找某元素在列表内的下标(索引)
# print(my_list.index(7))
#
# # 1.2 如果被查找的元素不存在会报错
# print(my_list.index(8))# 2.1 修改特定下际索引的值正向下标
# my_list [1,2,3]
# my_list[0] 9
# print(f正向下标:{my_list})
#
# # 2.2 修改特定下际索引的值反向下标
# my_list[-1] 666
# print(f反向下标:{my_list})# 3. 在指定下际位置插入新元素
# my_list [1,2,3]
# # 语法insert(指定位置,要插入的元素)
# my_list.insert(1,张三)
# print(my_list)# 4. 在列表的尾部追加单个新元素
# 语法append(要追加的元素)
# my_list [1,2,3]
# my_list.append(李四)
# print(my_list)
#
# my_list.append([22,34]) # 也可以追加一个列表
# print(my_list)# 5. 在列表的尾部追加一批新元素
# my_list [1,2,3]
# my_list.extend([4,5,6,7])
# print(my_list)
# # 或
# arr [你好,李银河,18]
# my_list.extend(arr)
# print(my_list)# 6. 别除指定下际索引的元素(2种方式)
# my_list [1,2,3,4,张,6,7,三,9]
# # 6.1 方式1:del列表[下标]
# # 语法: del 列表[索引]
# del my_list[4]
# print(my_list)# 6.2方式2:列表,pop(下标)
# 语法: 列表.pop(索引)
# element my_list.pop(6) # 我这里要删除列表中的三字因为上面已经删除了一个元素三字的下标已经由7变成6所以这里索引写6
# print(my_list)
# print(f被删除的元素是{element})# 两种方式的最大区别del只能删除指定的元素pop删除指定的元素并返回被删除的元素# 7. 除某元素在列表中的第一个匹配项
# my_list [1,2,3,4,2,57,2]
# my_list.remove(2)
# print(my_list)# 8. 清空列表的内容
# my_list [1,2,3,4,2,57,2]
# my_list.clear()
# print(my_list)# 9. 统计列表内容某元素的数量
# my_list [1,2,3,4,2,57,2]
# print(my_list.count(2))# 10. 统计列表中全部元素数量
my_list [1,2,3,4,2,57,2]
print(len(my_list))
列表的方法-说明 列表的特点 总结
练习 演示
# 1. 定义变量
my_list [21,25,21,23,22,20]
# 2. 追加数字31到列表尾部
my_list.append(31)
print(追加数字31到列表尾部:,my_list)# 3.追加一个新的列表[29,33,30]
my_list.extend([29,33,30])
print(追加一个新的列表[29,33,30]:,my_list)# 4. 取出第一个元素21
print(取出第一个元素:,my_list[0])# 5. 取出最后一个元素30
print(取出最后一个元素:,my_list[-1])# 6. 查找元素31在列表中的下标位置
print(查找元素31在列表中的下标位置是:,my_list.index(31)) 4列表的遍历
列表的遍历- while循环 列表的遍历 - for循环 演示 演示对lint列表的循环使用while和for循环两种方式def list_while_func():使用while循环遍历列表的演示函数:return:Noneindex 0 # 控制循环的变量my_list [法外, 狂徒, 李四]while index len(my_list):print(my_list[index],end) # end 是让print输出的字符不换行index 1list_while_func() # 调用函数def list_for_func():使用for循环遍历列表的演示函数:return:Noneprint() # print 输出空相当于输出换行my_list [法外, 狂徒, 王五]for item in my_list:print(item,end)list_for_func() # 调用函数 While循环和for循环的对比 总结 03 tuple元组
为什么需要元组 定义元组 演示 演示 tuple 元组的定义和操作# 定义元组
(1,Hello,True) # 字面量定义
t1 (1,Hello,True) # 用变量接收
t2 () # 定义空的元组
t3 tuple() # 定义空的元组对象print(ft1的类型是:{type(t1)},内容是{t1})
print(ft2的类型是:{type(t2)},内容是{t2})
print(ft3的类型是:{type(t3)},内容是{t3})# 定义单个元素的元组
t4 (张三,) # 当元组的内容只有一个元素是后面要加逗号不然就不是元组类型了
t5 (张三) # 不加逗号的情况print(------注意事项------)
print(ft4的类型是:{type(t4)},内容是{t4})
print(ft5的类型是:{type(t5)},内容是{t5}) # 没有逗号就变成字符串类型了# 元组的嵌套
t6 ((1,2,3),(4,5,6))
print(ft6的类型是:{type(t6)},内容是{t6})# 下标索引取出元组的内容
print(-----------------下标索引取出元组的内容-----------------)
print(ft1的第2个元素是{t1[1]}) # Hello
print(ft6的第1个元素内的第2个元素是{t6[0][1]})元组的相关操作 演示
# 元组的操作: index 查找指定元素的第一个索引
t7 (1,3,2,5,2,3,5,3,2,4)
print(f在t7中数字3的索引是:{t7.index(3)})# 元组的操作: count 统计某个元素出现的次数
print(f在t7中数字5的出现次数是:{t7.count(5)})# 元组的操作:len函数统计元组元素数量
print(f在t7元组的元素长度数量是:{len(t7)}) 遍历元组
# 元组的遍历: while
t8 (9,3,5,0,2,3,5)
index 0
while index len(t8):print(t8[index])index 1# 元组的遍历:for
t9 (你好,啊,李银河)
for x in t9:print(x) 元组操作完整代码 演示 tuple 元组的定义和操作# 定义元组
(1,Hello,True) # 字面量定义
t1 (1,Hello,True) # 用变量接收
t2 () # 定义空的元组
t3 tuple() # 定义空的元组对象print(ft1的类型是:{type(t1)},内容是{t1})
print(ft2的类型是:{type(t2)},内容是{t2})
print(ft3的类型是:{type(t3)},内容是{t3})# 定义单个元素的元组
t4 (张三,) # 当元组的内容只有一个元素是后面要加逗号不然就不是元组类型了
t5 (张三) # 不加逗号的情况print(------注意事项------)
print(ft4的类型是:{type(t4)},内容是{t4})
print(ft5的类型是:{type(t5)},内容是{t5}) # 没有逗号就变成字符串类型了# 元组的嵌套
t6 ((1,2,3),(4,5,6))
print(ft6的类型是:{type(t6)},内容是{t6})# 下标索引取出元组的内容
print(-----------------下标索引取出元组的内容-----------------)
print(ft1的第2个元素是{t1[1]}) # Hello
print(ft6的第1个元素内的第2个元素是{t6[0][1]})print(------------元组的操作------------)
# 元组的操作: index 查找指定元素的第一个索引
t7 (1,3,2,5,2,3,5,3,2,4)
print(f在t7中数字3的索引是:{t7.index(3)})# 元组的操作: count 统计某个元素出现的次数
print(f在t7中数字5的出现次数是:{t7.count(5)})# 元组的操作:len函数统计元组元素数量
print(f在t7元组的元素长度数量是:{len(t7)})print(-----------元组的遍历-----------)
# 元组的遍历: while
t8 (9,3,5,0,2,3,5)
index 0
while index len(t8):print(t8[index])index 1# 元组的遍历:for
t9 (你好,啊,李银河)
for x in t9:print(x)
元组的相关操作 - 注意事项 演示
# 修改元组 错误示范
# t1 (1,2,3,4,5,6)
# t1[0] 10 # 元组不可修改会报错# 可以修改元组内的list的内容
t1 (1,2,[3,4,5],6,8)
t1[2][0] Hello
print(t1) 元组的特点 总结 04 str字符串
再识字符串
字符串的下标索引 演示 演示以数据容器的角色,学习字符申的相关操作# 通过下标索取值
my_str 你好李银河
print(f取my_str的第一个字符{my_str[0]})
print(f取my_str的最后一个字符{my_str[-1]})# 通过索引修改字符串 错误示例字符串不可以直接修改
my_str[-3] 张 字符串的常用操作
index() 查看特定字符的索引 演示
# index寻找指定元素的第一个索引方法
my_str 你好李银河
print(好字的索引是,my_str.index(好)) replace() 字符串的替换
演示
# replace 方法
my_str2 my_str.replace(李银,张二)
print(fmy_str{my_str},my_str2{my_str2})
# 注意replace 方法是得到一个新的字符串不是修改原来的字符串 split() 字符串的分割
演示
# split 方法
# 语法split(分割符) 分割符就是以什么来分割如空格、逗号之类的
my_str 你*好*李*银*河
my_str3 my_str.split(*)
print(fmy_str3{my_str3}my_str3的类型是{type(my_str3)})
# 注意分割之后字符串本身不变而是得到一个新的列表对象strip() 字符串的规整操作去前后空格 演示
# strip 方法
my_str 你好,李银河 222
print(my_str)
print(f清除空格前{my_str})
# 使用strip方法清除两边空格
print(f清除空格后{my_str.strip()}) # strip() 不传参就是去除首尾空格
print(f原来的my_str{my_str})
# 注意strip()方法也不会修改原来的字符串
# 使用strip方法清除指定字符串
print(f清除指定的字符串222{my_str.strip(222)}) # strip() 传参就是去除传入的字符 coute() 统计字符中某字符的出现次数与 len() 统计字符申的长度
# 统计字符中某字符的出现次数 coute()
my_str 222 你好,李银河 222
print(f2出现的次数是{my_str.count(2)})# 统计字符申的长度 len()
print(fmy_str的长度是{len(my_str)}) 字符串常用操作汇总 字符串的遍历 字符串的特点 总结 练习 str itheima itcast boxuequ# 统计字符串中有多少个“it” 使用count() 方法
print(字符串的it数量是,str.count(it))# 将字符串内的空格全部替换为字符“I”
str1 str.replace( ,I)
print(fstr1{str1})# 并且按照”I“进行字符分割得到列表
str_list str1.split(I)
print(fstr_list{str_list}) 05 数据容器序列切片
序列 序列的常用操作-切片 注意此操作不会影响序列本身而是会的得到一个新的序列因为字符串、元组都是不支持修改的 演示对序列进行切片操作 语法序列[起始下标结束下标步长] 不包括结束下标# 对几list进行切片,从1开始,4结束,步长1
my_list [1,2,3,4,5,6]
new_my_list my_list[1:4:1] # [2, 3, 4]
print(f切片后的my_list{new_my_list})# 对 tuple 进行切片,从头开始,到最后结束,步长1
my_tuple (1,2,3,4,5,6,7,8)
new_my_tuple my_tuple[::1] # 不写就是从0开始到最后
print(f切片后的my_tuple{new_my_tuple}) # (1, 2, 3, 4, 5, 6, 7, 8)# 对 str 进行切片,从头开始,到最后结束,步长2
my_str 你好李银河123
new_my_str my_str[::2]
print(f切片后的my_str{new_my_str}) # 你银13# 对 str 进行切片,从头开始,到最后结束,步长-1
my_str 你好李银河123
new_my_str my_str[::-1] # 就是把字符串倒过来
print(f切片后的my_str{new_my_str}) # 321河银李好你# 对列表进行切片,从3开始,到结束,步长-1
my_list [1,2,3,4,5,6] # 就是从索引3开始把数据倒过来
new_my_list my_list[3::-1] # [4, 3, 2, 1]
print(f切片后的my_list{new_my_list})# 对元组进行切片,从头开始,到尾结束,步长2
my_tuple (1,2,3,4,5,6,7,8)
new_my_tuple my_tuple[::2] # 不写就是从0开始到最后
print(f切片后的my_tuple{new_my_tuple}) # (1, 3, 5, 7) 总结 06 set集合
为什么使用集合 集合的定义 演示 演示数据容器集合的使用# 定义集合
my_set {你好李银河,年龄18,职业小黑子,你好李银河,年龄18,职业小黑子,你好李银河,年龄18,职业小黑子}
my_set_empty set() # 定义空集合
print(fmy_set{my_set}类型是{type(my_set)}) # 集合不会存储重复的数据自动去重
print(fmy_set_empty{my_set_empty}类型是{type(my_set_empty)}) 集合的常用操作 - 修改
添加与删除元素 演示 演示数据容器集合的使用# 添加新元素 add()
my_set {你好李银河,年龄18,职业小黑子}
my_set.add(Hello)
print(fmy_set:{my_set})# 移除元素 remove()
my_set.remove(Hello)
print(fmy_set:{my_set}) 从集合中随机取出元素与清空集合 演示
# 随机取出一个元素 pop()
my_set {你好李银河,年龄18,职业小黑子}
element my_set.pop() # 注意被随机取出的元素会在集合中被移除
print(f随机取出的数据是:{element})
print(f原来的集合:{my_set})# 清空集合 clear()
my_set {你好李银河,年龄18,职业小黑子}
my_set.clear()
print(f清空集合:{my_set}) 取出两个集合的差集 演示
# 取(2个集合的差集)
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} 不变 消除2个集合的差集 # 消除2个集合的差集
set1 {1,2,3}
set2 {1,5,6}
set1 set1.difference(set2) # 和取差集一样区别就是取出的差集重新赋值给set1从而改变了set1
print(set1) # {2, 3} set1被改变
print(set2) # {1, 5, 6} 不变两个集合的合并 演示
# 2个集合合并为1个
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} 不变 统计集合的元素与集合的遍历
# 统计集合元素数量
set3 {1,2,3,5,6}
str4 len(set3)
print(f统计集合元素数量:{str4})# for 遍历集合while 无法遍历集合因为集合没有下标索引
set3 {1,2,3,5,6}for x in set3:print(fx{x})完整代码 演示数据容器集合的使用# 定义集合
my_set {你好李银河,年龄18,职业小黑子,你好李银河,年龄18,职业小黑子,你好李银河,年龄18,职业小黑子}
my_set_empty set() # 定义空集合
print(fmy_set{my_set}类型是{type(my_set)}) # 集合不会存储重复的数据自动去重
print(fmy_set_empty{my_set_empty}类型是{type(my_set_empty)})# 添加新元素 add()
my_set {你好李银河,年龄18,职业小黑子}
my_set.add(Hello)
print(fmy_set:{my_set})# 移除元素 remove()
my_set.remove(Hello)
print(fmy_set:{my_set})# 随机取出一个元素 pop()
my_set {你好李银河,年龄18,职业小黑子}
element my_set.pop() # 注意被随机取出的元素会在集合中被移除
print(f随机取出的数据是:{element})
print(f原来的集合:{my_set})# 清空集合 clear()
my_set {你好李银河,年龄18,职业小黑子}
my_set.clear()
print(f清空集合:{my_set})# 取(2个集合的差集)
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} 不变# 消除2个集合的差集
set1 {1,2,3}
set2 {1,5,6}
set1 set1.difference(set2) # 和取差集一样区别就是取出的差集重新赋值给set1从而改变了set1
print(set1) # {2, 3} set1被改变
print(set2) # {1, 5, 6} 不变# 2个集合合并为1个
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} 不变# 统计集合元素数量
set3 {1,2,3,5,6}
str4 len(set3)
print(f统计集合元素数量:{str4})# for 遍历集合while 无法遍历集合因为集合没有下标索引
set3 {1,2,3,5,6}for x in set3:print(fx{x})
集合常用功能总结 集合的特点 总结 07 dict 字典
为什么使用字典 字典定义 演示数据容器字典的定义# 定义字典
my_dict1 {张三:99,李四:60,王五:80}# 定义空字典
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)})# 定义重复Key的字典
my_dict {张三:99,张三:88,李四:60,王五:80}
print(f重复Key的字典是{my_dict}) # {张三: 88, 李四: 60, 王五: 80}
# 结论key重复是只保留后面的key与value字典数据的获取 演示
# 从字典中基于Key获取Value
my_dict1 {张三:99,李四:60,王五:80}
print(my_dict1[张三]) # 99
print(my_dict1[李四]) # 60
print(my_dict1[王五]) # 80 字典的嵌套 演示
# 定义嵌套字典
my_dict1 {张三:{语文:99,数学:88,英语:66},李四: {语文: 95,数学: 78,英语: 76},王五: {语文: 89,数学: 38,英语: 96}}# 从嵌套字典中获取数据
# 看看张三的数学成绩
print(f张三的数学成绩:{my_dict1[张三][数学]})
print(f王五的英语成绩:{my_dict1[王五][英语]}) 总结 字典的常用操作
新增、更新、删除、清空元素 演示 演示字典的常用操作# 新增元素
my_dict1 {张三:99,李四:60,王五:80}
my_dict1[陈六] 67
print(f新增元素{my_dict1})# 更新元素
my_dict1[王五] 100
print(f更新元素{my_dict1})# 删除元素 pop()
score my_dict1.pop(李四) # pop删除指定的元素也会返回被删除的元素
print(f删除元素{my_dict1},李四的考试分数是{score})# 清空元素
my_dict1.clear()
print(f清空元素{my_dict1}) 获取全部的key 、遍历字典、统计字典的元素 演示
# 获取全部的key
my_dict1 {张三:99,李四:60,王五:80}
my_dict_keys my_dict1.keys()
print(f获取全部的key:{my_dict_keys})# 遍历字典
for K in my_dict1:# k 键key my_dict1[K] 值valueprint(f遍历字典:{K}:{my_dict1[K]})# 统计字典内的元素数量
print(f统计字典内的元素数量{len(my_dict1)}) 字典的常用操作总结 字典的特点 总结 08 5类数据容器的总结对比
数据容器分类 数据容器特点对比 总结 09 数据容器的通用操作
数据容器的通用操作-遍历 数据容器的通用统计功能
容器通用转换功能 演示
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(-------------容器转列表-------------)
print(f类型转换集合转列表:{list(my_set)},类型{type(list(my_set))})
print(f类型转换字典转列表:{list(my_dict)},类型{type(list(my_dict))})# 类型转换容器转元组
print(-------------容器转元组-------------)
print(f类型转换集合转元组:{tuple(my_set)},类型{type(tuple(my_set))})
print(f类型转换字典转元组:{tuple(my_dict)},类型{type(tuple(my_dict))})# 类型转换容器转字符串
print(-------------容器转字符串------------)
print(f类型转换集合转字符串:{str(my_set)},类型{type(str(my_set))})
print(f类型转换字典转字符串:{str(my_dict)},类型{type(str(my_dict))})# 类型转换容器转字集合
print(-------------容器转集合------------)
print(f类型转换元组转集合:{set(my_tuple)},类型{type(set(my_tuple))})
print(f类型转换字典转集合:{set(my_dict)},类型{type(set(my_dict))})容器通用排序功能 演示
# sorted() 容器通用排序功能
my_list {3,5,8,2,1,0}
my_str qegaegrhr
# 注意排序后的结果都会变成列表对象
print(f正序排序{sorted(my_list)})
print(f正序排序{sorted(my_str)})
print(f反序排序{sorted(my_list,reverseTrue)})
print(f反序排序{sorted(my_str,reverseTrue)}) 容器通用功能总览 10 字符串大小比较
ASCII码表 字符串比较 演示 演示字符串大小比较
# abc 比较 adc
print(fabd大于abc?{abdabc})# a 比较 ab
print(fab大于a?{aba})# a 比较 A
print(fa大于A?{aA})# key1 比较 key2
print(fkey1大于key2?{key1key2}) 总结
