python中的容器

# 容器是指一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素的类型可以是任意的，如字符串、数字、布尔等
# 5类容器：是否支持重复元素、是否可以修改、是否有序
# 列表、元组、字符串、集合、字典
import random

# 列表： [元素1, 元素2, 元素3, ...]
# 定义空列表
# 变量名称 = []   /变量名称 = list()
# name_list = ['tom', 'lily', 'rose']
# print(name_list[0])
# print(name_list[1])
# print(name_list[2])
# print(name_list[-1])
# print(name_list[-2])
# print(name_list[-3])

# 列表常用方法：
# 查找某元素的下标    列表.index(元素)
# 插入元素   列表.insert(下标， 元素)，在指定的下标位置，插入指定的元素
# 追加元素方式1   列表.append(元素)，将指定的元素，追加到列表的尾部
# 追加元素方式2   列表.extend(其它数据容器)，将其他数据容器的内容取出，依次追加到列表尾部
# list1 = [1, 2, 3]
# list1.extend([4, 5, 6])
# print(list1)  # [1, 2, 3, 4, 5, 6]
# 删除元素
# 语法1：del 列表[下标]  只能删除
# 语法2：列表.pop(下标)  既能删除，还能得到删除的元素
# 语法3：列表.remove(元素)   只能删掉第一个出现的元素
# 清空列表内容： 列表.clear()
# 统计某元素在列表内的数量： 列表.count(元素)
# 统计列表内有多少元素：len(列表)

# 列表总结：
# 可以容纳多个数据
# 可以容纳不同类型的数据
# 数据是有序存储的
# 允许重复数据存在
# 可以修改（增加、删除、修改）

# 列表的遍历
# while循环
# index = 0
# while index < len(列表)：
#   元素 = 列表[index]
#   对元素进行处理
#   index += 1

# 元组：元组也可以封装多个不同类型的元素，但不同之处在于：元组一旦定义完成就不可修改
# 定义空元组： 变量名称 = ()  / 变量名称 = tuple()
# 元组的元素只有单个时，必须加上逗号
# t1 = ("hello")
# t1 = ("hello", )
# # print(f"t1的类型是:{type(t1)},t1的内容是：{t1}")    # str
# print(f"t1的类型是:{type(t1)},t1的内容是：{t1}")    # tuple
#
# t2 = ((1, 2, 3), (4, 5, 6))
# # 下标索引取出内容
# print(t2[1][2])

# 元组的操作： index() \ count() \ len(元组)
# print(t2.index((1, 2, 3)))
# print(len(t2))

# 字符串：和列表、元组一样，字符串也可以通过下表进行访问
# 字符串是一个不可修改的数据容器
# str1 = "i have a flower"
# str1[-1] = 'm'  # 报错
# print(str1)

# 字符串的常用操作：
# 字符串.index(字符串)
# print(str1.index('a'))  # 3
# print(str1.index('have'))   # 2
# 字符串.replace(字符串1， 字符串2)
# print(str1.replace('flower', 'book'))   # i have a book 返回了一个新的字符串，并没有修改str1本身
# print(str1)   # i have a flower str1并没有发生改变
# 字符串分割：字符串.split(分隔字符串)  按照指定的分隔符，将字符串划分为多个字符串，并存入列表对象中
# 注意：字符串本身不表，而是得到了一个列表对象
# print(f"str1.split(' ')的类型是{type(str1.split(' '))},值是：{str1.split(' ')}")
# str1.split(' ')的类型是<class 'list'>,值是：['i', 'have', 'a', 'flower']
# 字符串的规整操作：
# 去掉前后空格: 字符串.strip()
# str3 = "     i like dog   "
# print(str3.strip())   # i like dog
# 去掉前后指定字符串： 字符串.strip(字符串)
# str4 = "12 it heima dog 21"
# print(str4.strip("12"))        #  it heima dog   注意：传入的”12“ 其实就是”1“和”2“都会移除，是按照单个字符

# 序列：内容连续、有序，可使用下标索引的一类数据容器。列表、元素、字符串可视为序列
# 数据容器的切片操作：序列[起始下标：结束下标：步长] 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
# str5 = "i have an apple"
# str6 = str5[2:6]   # 包左不包右
# print(str6)  # have
# print(random.randint(1, 10))   # 可以取到10
# str7 = "01234567"
# print(str7[::-1])

# 序列是支持索引的，而集合不支持索引，所以集合不是序列
# 集合 ： 无序、不重复、可修改
# {元素, 元素, 元素, ...}
# 定义空集合  变量名 = set()
# 注意：集合是无序的，所以集合不支持下标索引访问

# set1 = {"hello", "hi", "xt", "hello", "hi", "xt"}
# print(set1)   # {'xt', 'hello', 'hi'}
# set1.add("lv")
# print(set1)   # {'xt', 'lv', 'hi', 'hello'}
# set1.remove("hi")
# print(set1)   # {'xt', 'lv', 'hello'}
# 随机取出一个元素
# set1.pop()
# print(set1)   # {'lv', 'hello'}
# set1.clear()
# print(set1)     # 集合清空
# 取2个集合的差集。  集合1.difference(集合2). 取出集合1和集合2的差集（集合1有而集合2没有的），结果：得到一个新集合，集合1和集合2不变
# set2 = {1, 2, 3}
# set3 = {1, 5, 6}
# set4 = set2.difference(set3)
# print(set4)   # {2, 3}
# print(set3)   # {1, 5, 6}
# print(set2)   # {1, 2, 3}
# 消除2个集合的差集。 语法：集合1.difference_update(集合2) 功能：在集合1内，删除和集合2相同的元素  结果：集合1被修改，集合2不变
# set2.difference_update(set3)
# print(set2)   # {2, 3}
# print(set3)     # {1, 5, 6}
# 2个集合合并 语法：集合1.union(集合2)  功能：将集合1和集合2组合成新集合  结果：得到新集合，集合1和集合2不变
# 统计集合中的元素个数：len()
# 集合的遍历
# 集合不支持下标索引，不能用while循环，但可以用for循环
# set5 = {1, 2, 3, 4, 5, 6}
# for element in set5:
#     print(element)
# 字典：{key: value, key:value,...}
# 定义空字典
# 方式1：my_dict = {}
# 方式2：my_dict = dict()
# score = {"小红": 99, "小兰": 100, "小哀": 88}
# my_dict2 = {}
# my_dict3 = dict()
# print(f"字典1的内容是：{score}, 类型：{type(score)}")
# print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
# print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")
# # 定义重复的key字典,不允许重复的key，非要这样出现，只保留最后一个重复的key
# score1 = {"小红": 99, "小兰": 100, "小兰": 88}
# print(f"重复key字典的内容是：{score1},类型是：{type(score1)}")
# # 字典同集合一样，不可以使用下标索引，但是字典可以通过key获取相应的value
# print(score1["小兰"])
# 字典的key和value可以是任意的类型（但key不可为字典），则 字典是可以嵌套的
# 姓名    语文      数学      英语
# 小红    77        66       33
# 小兰    88        86       55
# 小哀    99        96       66
# info = {"小红": {"语文": 77, "数学": 66, "英语": 33},
#         "小兰": {"语文": 88, "数学": 86, "英语": 55},
#         "小哀": {"语文": 99, "数学": 96, "英语": 66}
#         }
# print(f"学生的考试信息如下：{info}")
# print(f"学生的考试信息如下：{info['小兰']['语文']}")
# score2 = {"小红": 99, "小兰": 100, "小哀": 88}
# # 字典添加元素
# score2["小柯"] = 100
# print(score2)
# # 修改元素
# score2["小红"] = 33
# print(score2)
# # 删除元素  字典.pop(Key)
# score2.pop("小红")
# print(score2)
# # 清空元素 clear
# # 获取全部key：字典.keys()
# keys = score2.keys()
# print(keys, type(keys))
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
# for key in keys:
#     print(key)
#     print(f"字典的value是：{score2[key]}")
# for key2 in score2:
#     print(f"key为：{key2}，对应的Value为：{score2[key2]}")
# # 统计字典的元素数量，len()函数
# num = len(score2)
# print(num)

# 总结：
# 是否支持下标索引：
# 支持：列表、元组、字符串  --序列类型
# 不支持：集合、字典     --非序列类型
# 是否支持重复元素：
# 支持：列表、元组、字符串  --序列类型
# 不支持：集合、字典     --非序列类型
# 是否可以修改：
# 支持：列表、集合、字典
# 不支持：元组、字符串

# 容器的转换功能：list(容器)：将给定容器转换为列表  str(容器)：将给定容器转换为字符串
#              tuple(容器)：将给定容器转换为元组   set(容器)：将给定容器转换为集合
# 将字典转列表、元组、集合时会将Value抛弃掉，转str时会保留value

# 容器的通用排序功能 ：sorted(容器, [reverse = True])  sorted之后的结果全变成list对象，字典排序也会丢失value