Python入门--数据容器的通用操作

1、打开Pycharm，创建Python文件，复制代码，保存运行！

"""
# 5类容器 列表 元组 字符串 集合 字典
my_list = [1,2,5,4,8,9,55]
my_tuple = (1,8,6,4,9)
my_str = "abcdefg"
my_set = {2,3,45,77,5,9}
my_dict = {"key1":3,"key2":6,"key3":83,"key4":37,"key5":7,"key6":55}

# 5类容器都支持for循环
# 列表 元组 字符串支持while循环，集合 字典不支持 无法下标索引

# 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元素是：{min(my_list)}")
print(f"元组 最小的min元素是：{min(my_tuple)}")
print(f"字符串最小的min元素是：{min(my_str)}")
print(f"集合 最小的min元素是：{min(my_set)}")
print(f"字典 最小的min元素是：{min(my_dict)}")

# 通用类型转换
# list(容器) 将给定的容器转化为列表
print(f"列表转列表的结果是：{list(my_list)},类型是{type(list(my_list))}")
print(f"元组转列表的结果是：{list(my_tuple)},类型是{type(list(my_tuple))}")
print(f"字符串转列表的结果是：{list(my_str)},类型是{type(list(my_str))}")
print(f"集合转列表的结果是：{list(my_set)},类型是{type(list(my_set))}")
print(f"字典转列表的结果是：{list(my_dict)},类型是{type(list(my_dict))}")

# str(容器) 将给定的容器转换成字符串
print(f"列表 转字符串的结果是：{str(my_list)}, 类型是{type(str(my_list))}")
print(f"元组 转字符串的结果是：{str(my_tuple)},类型是{type(str(my_tuple))}")
print(f"字符串转字符串的结果是：{str(my_str)},  类型是{type(str(my_str))}")
print(f"集合 转字符串的结果是：{str(my_set)},  类型是{type(str(my_set))}")
print(f"字典 转字符串的结果是：{str(my_dict)}, 类型是{type(str(my_dict))}")

# tuple(容器) 将给定的容器转化成元组
print(f"列表 转元组的结果是：{tuple(my_list)}, 类型是{type(tuple(my_list))}")
print(f"元组 转元组的结果是：{tuple(my_tuple)},类型是{type(tuple(my_tuple))}")
print(f"字符串转元组的结果是：{tuple(my_str)},  类型是{type(tuple(my_str))}")
print(f"集合 转元组的结果是：{tuple(my_set)},  类型是{type(tuple(my_set))}")
print(f"字典 转元组的结果是：{tuple(my_dict)}, 类型是{type(tuple(my_dict))}")

# set(容器)将给定的容器转化成集合
print(f"列表 转集合的结果是：{set(my_list)}, 类型是{type(set(my_list))}")
print(f"元组 转集合的结果是：{set(my_tuple)},类型是{type(set(my_tuple))}")
print(f"字符串转集合的结果是：{set(my_str)},  类型是{type(set(my_str))}")
print(f"集合 转集合的结果是：{set(my_set)},  类型是{type(set(my_set))}")
print(f"字典 转集合的结果是：{set(my_dict)}, 类型是{type(set(my_dict))}")

# 通用容器排序 sorted(容器，reverse = True) #[reverse = True]是否反转，默认是False省略 结果全变成了列表对象
my_list = [8,2,55,4,7,9,5]
my_tuple = (9,8,6,4,2)
my_str = "bcaged"
my_set = {88,3,95,77,5,9}
my_dict = {"key4":3,"key6":82,"key3":83,"key1":37,"key5":7,"key2":55}
print(f"列表对象的排序结果是：{sorted(my_list)}，结果类型是{type(sorted(my_list))}")
print(f"元组对象的排序结果是：{sorted(my_tuple)}，结果类型是{type(sorted(my_tuple))}")
print(f"字符串对象的排序结果是：{sorted(my_str)}，结果类型是{type(sorted(my_str))}")
print(f"集合对象的排序结果是：{sorted(my_set)}，结果类型是{type(sorted(my_set))}")
print(f"字典对象的排序结果是：{sorted(my_dict)}，结果类型是{type(sorted(my_dict))}")

print(f"列表对象的反向排序结果是：{sorted(my_list,reverse=True)}，结果类型是{type(sorted(my_list))}")
print(f"元组对象的反向排序结果是：{sorted(my_tuple,reverse=True)}，结果类型是{type(sorted(my_tuple))}")
print(f"字符串对象的反向排序结果是：{sorted(my_str,reverse=True)}，结果类型是{type(sorted(my_str))}")
print(f"集合对象的反向排序结果是：{sorted(my_set,reverse=True)}，结果类型是{type(sorted(my_set))}")
print(f"字典对象的反向排序结果是：{sorted(my_dict,reverse=True)}，结果类型是{type(sorted(my_dict))}")