Python学习笔记（八）

# 数据容器的分类：
# 1.是否支持下表索引
#   支持：列表、元组、字符串--序列类型
#   不支持：集合、字典--非序列类型
# 2.是否支持重复元素
#   支持：列表、元祖、字符串-序列类型
#   不支持：集合、字典-非序列
# 3.是否可修改
#   支持：列表、集合、字典
#   不支持：元组、字符串
# 4.数据有序
#   集合、字典无序，其余有序

"""
演示数据容器的通用功能
"""

# 字符串、列表、元组可以用+合并
# 字符串、列表、元组可以用*复制
# 字符串、列表、元组、字典可以用 in（not in) 查看元素是否存在(不存在)

# enumerate() 效果是输出(下标，数据)，通常用for遍历
# list1=['a','b','c']
# for i in enumerate(list1):
#     print(i)

# 列表推导式打印一个列表
list1=[i for i in range(10)]
print(list1)

# 元组推导式打印一个元组
t1=(i for i in range(10))
print(t1) #返回的是t1的地址
print(tuple(t1))  #返回的是结果元组

# 字典推导式打印一个字典
dic1={i:i**2 for i in range(1,5)}
print(dic1)

# 集合推导式
list1=[1,2,3]
set1={i**2 for i in list1}
print(set1)

# 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)}")

# # 类型转换: 容器转列表
# 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)}")

# # 类型转换: 容器转元组
# 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)}")

# # 类型转换: 容器转字符串
# 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(f"列表转集合的结果是：{set(my_list)}")
# print(f"元组转集合的结果是：{set(my_tuple)}")
# print(f"字符串转集合结果是：{set(my_str)}")
# print(f"集合转集合的结果是：{set(my_set)}")
# print(f"字典转集合的结果是：{set(my_dict)}")

# # 其他类型无法转直接换成字典，因为他们没有键值对,需要打包
# a=['a1','a2','a3']
# b=['b1','b2','b3']
# c=zip(a,b)
# print(c)  #返回的是c的地址
# print(dict(c))

# id(a)查看a的内存地址
# 当两个变量的数值相同时，他们共用一个存放数值的内存空间
# 也就是b没有重复去存放10这个数据，而是引用了a的内存地址
# 即b=10的指针实际上指向了a的内存地址。--好处：节省内存空间
a=10
b=10
print(id(a),id(b))


# # 进行容器的排序
# 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)}")
# # 默认是从小到大排序，reverse=True从大到小
# 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)}")

"""
演示字符串大小比较
"""
# 从前到后一位一位的比，如果有一位大，那么整体就大
# 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'}")