容器入门       

容器概念:可以容纳多个元素的python数据类型,就是容器
容器分类:字符串str 列表list 元组tuple 集合set 字典dict

#上一节 讲过了 字符串所以这一节 直接从 列表讲起

列表容器

列表是可变类型

列表的定义和知识点

定义空列表: [ ] 或者list()
定义非空列表:[元素1,元素2,元素3,...]
列表支持嵌套[[元素...],[元素.......]]

#### 示例:

```python
# 定义空列表
l1 = []
print(l1, type(l1))
l2 = list()
print(l2, type(l2))
# 定义非空列表
l3 = ['张三', '李四', 10, 20, 3.14, 13.14, True, False]
print(l3, type(l3))

# 列表嵌套
l4 = [l1, l2, l3]
print(l4, type(l4))
```



### 列

列表的下标索引

知识点:

索引: 也叫下标,就是咱们所说的编号,只是这个编号比较特殊,有两套编号
​
正索引:从左到右,从0开始依次递增
负索引:从右到左,从-1开始依次递减
​
列表名[索引]: 查询指定索引位置处的元素

示例:

# 需求:定义非空列表分别存储姓名和年龄
name_list = ['张三', '李四', '王五']
age_list = [18, 28, 38]
# 需求: 分别获取第一个姓名和第一个年龄
print(name_list[0])
print(age_list[0])
# 需求: 分别获取最后一个姓名和最后一个年龄
print(name_list[-1])
print(age_list[-1])
print('-------------------------------------')
# 需求: 定义学生信息列表把姓名和年龄列表再次封装起来
stu_list = [name_list, age_list]
# 需求: 从学生列表中分别获取第一个姓名和第一个年龄
print(stu_list[0][0])
print(stu_list[1][0])
# 需求: 从学生列表中分别获取最后一个姓名和最后一个年龄
print(stu_list[0][-1])
print(stu_list[1][-1])

列表的增删改查(下方的list代表列表名)

增加

list.apend(元素):把指定元素追加到对应的列表中
list.extend(元素):把指定容器中的元素依次取出追加到对应列表中
list.insert(索引,元素)把指定元素插入到对应列别的指定索引位置

删

list.pop(索引): 把指定索引位置处的元素从列表中删除
del list[索引]:把指定索引位置处的元素从列表中删除
list.remove(元素):把指定元素直接从列表中删除  一次删除一个
list.clear():清空列表中所有元素
del list: 删除整个列表

改 

list[索引] = 新元素     将 对应索引 改成新元素

查

list[索引]:查询指定索引位置处的元素  
list.count(元素) 查询元素出现在list中的次数 ###如果元素不存在就返回0

点

list.index(元素): 查询列表中 元素出现在的索引位置##假如有多个只返回一个 不存在就报错

返回第一个位置

len(list):查询列表的长度#也就是元素的总个数

示例

"""列表是可变类型"""
# 0.定义空列表
names = []
print(names)
# 1.增
# 	列表名.append(元素): 把指定元素追加到对应列表中
names.append('张三')
print(names)
# 	列表名.extend(容器): 把指定容器中的元素依次取出追加到对应列表中
names.extend(['张三', '李四', '王五'])
print(names)
# 	列表名.insert(索引,元素): 把指定元素插入到对应列表的指定索引位置
names.insert(0, '熊大')
print(names)
names.insert(1, '熊二')
print(names)
print('-----------------------------------')
# 2.改
# 	列表名[索引] = 新元素 : 修改列表指定索引位置的元素
names[0] = '老大'
print(names)
print('-----------------------------------')
# 3.查
# 	列表名[索引]: 查询指定索引位置处的元素
print(names[0])
# 	列表名.count(元素):查询指定元素在列表中出现的次数    注意:如果元素不存在就返回0
print(names.count('张三'))
#     列表名.index(元素):查询指定元素在列表中出现的索引位置 注意:如果元素不存在就报错,多个只返回第一个位置
print(names.index('张三'))
# print(names.index('张丰')) # 报错
#     len(列表名): 查询指定列表的元素总个数
print(len(names))
print('-----------------------------------')
# 4.删
# 	列表名.pop(索引): 把指定索引位置处元素从列表中删除
names.pop(0)
print(names)
# 	del 列表名[索引]: 把指定索引位置处元素从列表中删除
del names[0]
print(names)
# 	列表名.remove(元素): 把指定元素直接从列表中删除   注意:一次只会删除一个
names.remove('张三')
print(names)
names.remove('张三')
print(names)
# 	列表名.clear(): 清空列表中所有元素
names.clear()
print(names)
# 	del 列表名: 删除整个列表
del names
print(names)  # NameError: name 'names' is not defined

列表的遍历

for i in list:
        循环体

index = 0 
while index <len(list)
        变量 = list[index]##将值赋给变量 或者也可以直接打印list[index]
        循环体
        index+=1

​
"""列表是可变类型"""
# 0.定义空列表
names = []
print(names)
# 1.增
# 	列表名.append(元素): 把指定元素追加到对应列表中
names.append('张三')
print(names)
# 	列表名.extend(容器): 把指定容器中的元素依次取出追加到对应列表中
names.extend(['张三', '李四', '王五'])
print(names)
# 	列表名.insert(索引,元素): 把指定元素插入到对应列表的指定索引位置
names.insert(0, '熊大')
print(names)
names.insert(1, '熊二')
print(names)
print('-----------------------------------')
# 2.改
# 	列表名[索引] = 新元素 : 修改列表指定索引位置的元素
names[0] = '老大'
print(names)
print('-----------------------------------')
# 3.查
# 	列表名[索引]: 查询指定索引位置处的元素
print(names[0])
# 	列表名.count(元素):查询指定元素在列表中出现的次数    注意:如果元素不存在就返回0
print(names.count('张三'))
#     列表名.index(元素):查询指定元素在列表中出现的索引位置 注意:如果元素不存在就报错,多个只返回第一个位置
print(names.index('张三'))
# print(names.index('张丰')) # 报错
#     len(列表名): 查询指定列表的元素总个数
print(len(names))
print('-----------------------------------')
# 4.删
# 	列表名.pop(索引): 把指定索引位置处元素从列表中删除
names.pop(0)
print(names)
# 	del 列表名[索引]: 把指定索引位置处元素从列表中删除
del names[0]
print(names)
# 	列表名.remove(元素): 把指定元素直接从列表中删除   注意:一次只会删除一个
names.remove('张三')
print(names)
names.remove('张三')
print(names)
# 	列表名.clear(): 清空列表中所有元素
names.clear()
print(names)
# 	del 列表名: 删除整个列表
del names
print(names)  # NameError: name 'names' is not defined

​

列表的特点

列表是可变类型
支持容纳多个元素
支持for循环遍历
支持修改操作
能存储任意类型数据
列表可以嵌套
列表有下标索引
因为有索引 所以可以重复

元组容器

元组是不可变类型

定义空元组 tuple_name = ()  ;tuple_name = tuple ()
定义非空元组    tuple_name = (1,2,34,5)
##如果元组里面只有一个元素 必须要有逗号 如 tuple_name = (1,)#否则系统会把括号去掉 以为只是变量赋值

# 定义空元组
t1 = ()
print(t1, type(t1))
t2 = tuple()
print(t2, type(t2))
# 定义非空元组
t3 = ('张三', '李四', 10, 20, 3.14, 13.14, True, False)
print(t3, type(t3))

# 元组嵌套
t4 = (t1, t2, t3)
print(t4, type(t4))

# 注意: 如果是一个元素的元组,一定加逗号!!!
t5 = ('张三',)
print(t5, type(t5))

元组的下标索引

知识点:

索引: 也叫下标,就是咱们所说的编号,只是这个编号比较特殊,有两套编号

正索引:从左到右,从0开始依次递增
负索引:从右到左,从-1开始依次递减

元组名[索引]: 查询指定索引位置处的元素

# 需求:定义非空元组分别存储姓名和年龄
name_tuple = ('张三', '李四', '王五')
age_tuple = (18, 28, 38)
# 需求: 分别获取第一个姓名和第一个年龄
print(name_tuple[0])
print(age_tuple[0])
# 需求: 分别获取最后一个姓名和最后一个年龄
print(name_tuple[-1])
print(age_tuple[-1])
print('-------------------------------------')
# 需求: 定义学生信息元组把姓名和年龄元组再次封装起来
stu_tuple = (name_tuple, age_tuple)
# 需求: 从学生元组中分别获取第一个姓名和第一个年龄
print(stu_tuple[0][0])
print(stu_tuple[1][0])
# 需求: 从学生元组中分别获取最后一个姓名和最后一个年龄
print(stu_tuple[0][-1])
print(stu_tuple[1][-1])

元组的操作(下面的tuple代表元组名)

查询

a = tuple[索引]: 查询索引对应的元素
a= tuple.count(元素): 查询元素出现的次数#如果不存在就返回0
a=tuple.index(元素)查询元素所在位置的索引##返回第一个,不存在就报错
len(tuple):查询元组元素的个数

"""元组是不可变类型"""
# 0.定义非空元组
names = ('张三', '李四', '王五', '张三')
print(names)
# 查
# 	元组名[索引]: 查询指定索引位置处的元素
print(names[0])
# 	元组名.count(元素):查询指定元素在元组中出现的次数    注意:如果元素不存在就返回0
print(names.count('张三'))
#     元组名.index(元素):查询指定元素在元组中出现的索引位置 注意:如果元素不存在就报错,多个只返回第一个位置
print(names.index('张三'))
# print(names.index('张丰')) # 报错
# len(元组名): 查询指定元组的元素总个数
print(len(names))

元组遍历同上

# 需求: 定义非空元组,然后遍历打印元素
names = ('熊大', '熊二', '张三', '李四', '王五')
# for循环方式
# 核心思想: 依次从元组中取出每个元素赋值给临时变量
for name in names:
    print(name)
print('---------------------')
# while循环方式
# 核心思想: 用while循环的变量作为元组的索引使用
index = 0
while index < len(names):
    # 根据索引获取元素  index此时就充当索引使用
    name = names[index]
    print(name)
    # 条件控制
    index += 1

元组的特点

是不可变类型
支持存储多个元素
有索引
支持遍历
有序
可以重复
能存储任意类型数据

序列详解

五大容器中属于序列的有:字符串 列表 元组

1.序列支持切片(截取部分内容)格式-> 序列[开始索引:结束位置:步长]
注意事项如下:
    1.序列有两套索引: 正索引从0开始从左到右依次递增,负索引从-1开始从右到左依次递减
    2.步长决定截取方向: 正步长代表从左到右,负步长代表从右到左 
    3.开始索引:如果留空,默认代表从头开始
    4.结束位置:结束索引=结束位置-1,如果留空默认代表到尾部(含)结束

索引支持运算符如下

s1 = s2+s3 两个序列内容拼接返回一个新的序列
s1 = s2 * x   表示 序列里面的内容乘于x份放回s1中返回

# 定义非空字符串,要求截取'bd'
s = 'abcde'
print(s[1:4:2])

# 定义非空列表,要求截取['b', 'd']
l = ['a', 'b', 'c', 'd', 'e']
print(l[1:4:2])

# 定义非空元组,要求截取('b', 'd')
t = ('a', 'b', 'c', 'd', 'e')
print(t[1:4:2])

# 定义非空字符串
s = 'abcde'
# 定义非空列表
l = ['a', 'b', 'c', 'd', 'e']
# 定义非空元组
t = ('a', 'b', 'c', 'd', 'e')
# + : 序列+序列: 两个序列内容拼接返回一个新序列
print(s + s)
print(l + l)
print(t + t)
print('-------------------------------------')
# * : 序列*x:表示序列的内容乘以x份放到一个新的序列中返回
print(s * 2)
print(l * 2)
print(t * 2)
print('-------------------------------------')
# 注意: +和append操作列表的区别?
# +是拼接返回一个新的列表
print(l + ['f'])
# append是直接修改原有列表
l.append('f')
print(l)

列表的切片

list[开始索引:结束索引:步长]

集合

集合定义空集合  set_name = set()
定义非空集合  set_name = {元素1,元素2,元素3,.....}   ##假如直接用{}定义空集合 会变成字典
集合核心特点:无序不重复       
集合里面只能包含不可变类型如 字符串 整数 布尔 元组 而不能包含列表

# 定义空集合
# 注意: 空的{}代表是字典
d1 = {}
print(d1, type(d1))
print('-------------------------------------------')
s1 = set()
print(s1, type(s1))
# 定义非空集合
# 注意1: 自带去重功能
s2 = {'张三', '李四', 10, 10, 3.14, 3.14, True, False}
print(s2, type(s2))
print('-------------------------------------------')
# 集合嵌套
# 注意2: 集合中只能放不可变类型: 整数,浮点数,布尔值,字符串,元组
# 也就意味着,集合中不能放可变类型: 列表/集合/字典,否则报错TypeError: unhashable type
s3 = {10, 3.14, True, "123", ('a', 'b')}
print(s3, type(s3))

集合的增删改查

增
set.add(元素):把元素添加到集合内

删除
set.pop() 随机删除一个内容  ###其实是有规律的 按照哈希值 最小的 删除 但是我们没有索引下标 所以不知道 并且每一次哈希值 都会变动所以删的确实不一定 不要依赖这个
set.remove(元素) 移除指定元素
set.clear() 清空集合内的元素但是 集合还在
del set 删除集合 ##此时打印该集合会报错

改

set1.difference_update(集合2):修改集合1的内容为他和集合2的元素的差集
set1.update(集合2) 并集
##集合不能真正的直接从里面直接更改具体内容 而是先删除再加入  因为要判断是否重复 只有加入进去的时候才会做 这个判断 这也是 为什么 集合里面不能有可变内容了 假如 直接改变内容但是不做去重操作 这个就报废了  

查
        len(set) 查询集合的元素个数

"""集合是可变类型"""
# 0.定义空集合
names = set()
print(names)
# 1.增
# 	集合名.add(元素): 把指定元素追加到对应集合中
names.add('张三')
names.add('李四')
names.add('王五')
print(names)
print('-----------------------------------')
# 2.改
# 修改为和集合{'张三','赵六'}的差集
names.difference_update({'张三','赵六'})
print(names)
# 修改为何集合{'张三','赵六'}的并集
names.update({'张三','赵六'})
print(names)
print('-----------------------------------')
# 3.查

# len(集合名): 查询指定集合的元素总个数
print(len(names))
print('-----------------------------------')
# 4.删
# 	集合名.pop(): 随机删除一个
names.pop()
print(names)
# 	集合名.remove(元素): 把指定元素直接从集合中删除   注意:一次只会删除一个
names.remove('张三')
print(names)
# 	集合名.clear(): 清空集合中所有元素
names.clear()
print(names)
# 	del 集合名: 删除整个集合
del names
# print(names)  # NameError: name 'names' is not defined

集合的遍历

for遍历如上
但是没有while 循环 因为 没有索引 所以不能遍历

# 需求: 定义非空集合,然后遍历打印元素
names = {'老大', '熊二', '张三', '李四', '王五'}
# for循环方式
# 核心思想: 依次从集合中取出每个元素赋值给临时变量
for name in names:
    print(name)

集合的特点

集合是可变类型
支持容纳多个元素
支持for循环
支持修改操作
只能存储不可变类型
没有下标索引 所以 不支持while  无序  不重复

字典

空字典 dict_name = {}  和 dict_name = dice()

定义非空字典 dict_name = {k1:v1,k2:v2,...............}
###键key:只能是不可变类型且不能重复 值 value 可以是任意类型并且可以重复

# 定义空字典
d1 = {}
print(d1, type(d1))
d2 = dict()
print(d2, type(d2))
# 定义非空字典
d3 = {"张三": 18, "李四": 28, '王五': 38}
print(d3, type(d3))
# 字典的嵌套
# 注意: key不能重复且不能是可变类型: 列表,集合,字典
# key只能是不可变类型: 整数,浮点数,布尔值,字符串,元组
d4 = {1: d1, 2: d2, 3: d3}
print(d4, type(d4))
# 综合案例:定义字典,存储每个学生的成绩:语文,数学,英语
score_dict = {
    "张三": {'语文': 99, '数学': 88, '英语': 98},
    "李四": {'语文': 89, '数学': 68, '英语': 100},
    "王五": {'语文': 79, '数学': 98, '英语': 99},
}
print(score_dict, type(score_dict))

字典的增删改查

增加
        dict[新key] = value:在字典中增加一个新的键值对

改
        dict[key] = 新value 将已有的key 的 value 变成 新的value

###也可以理解为 有的话 就改变 没有的话就创建

删除
        dict.pop(key):删除key的键值对
        del dict[key]: 删除key的键值对
        dict.clear(): 清空字典
        del dict 删除整个字典

查询
        dict[key],根据key获取value
        dict.get(key),根据key获得value
        len(dict):查询字典里面键值对的个数
        dict.keys():或者字典中所有的键
        dict.values()

"""字典是可变类型"""
# 定义空字典,存储学生的成绩
score_dict = {}
print(score_dict)
# 1.增
# 	字典名[新key] = value : 在字典中添加一个键值对 新key:value
score_dict['李四'] = 80
score_dict['王五'] = 90
score_dict['赵六'] = 90
score_dict['张三'] = 99
score_dict['张三'] = 100
score_dict['田七'] = 100
print(score_dict)
print('-------------------------------------------------')
# 2.改
# 	字典名[旧key] = value : 在字典中修改旧key对应的值为value
# 需求: 修改王五的成绩为99
score_dict['王五'] = 99
print(score_dict)
print('-------------------------------------------------')
# 3.查
# 	字典名[key]:  根据key获取value
print(score_dict['张三'])
# 	字典名.get(key):  根据key获取value
print(score_dict.get('王五'))
#     len(字典名): 获取字典中键值对的个数
print(len(score_dict))
#     字典名.keys(): 获取所有的key
# 需求: 获取所有的姓名
names = list(score_dict.keys())
print(names, type(names))
#     字典名.values(): 获取所有的values
# 需求: 获取所有的分数
scores = list(score_dict.values())
print(scores, type(scores))
#     字典名.items(): 获取所有的键值对  注意: 每个键值对都单独封装为元组
# 需求: 获取所有的键值对
kvs = score_dict.items()
print(kvs)
print('-------------------------------------------------')
# 4.删
# 	字典名.pop(key): 根据key删除对应的键值对
score_dict.pop('张三')
print(score_dict)
# 	del 字典名[key]: 根据key删除对应的键值对
del score_dict['王五']
print(score_dict)
# 	字典名.clear(): 清空字典中所有元素
score_dict.clear()
print(score_dict)
# 	del 字典名: 删除整个字典
del score_dict
# print(score_dict) # NameError: name 'score_dict' is not defined

字典的遍历

for k in dict:
        v = dict[k]
        循环体
###字典里的遍历 只能获得key 在不用函数的情况下 ,所以只能在循环体里面用k得到对应v的值
或者还有底下的这种方法

for k,v in dict.items:
        print(k,v)
        循环体

#这用到了函数和拆包 就可以直接把k v都拿到

# 定义非空字典,要求遍历打印格式为: xx分数是yy
score_dict = {'李四': 80, '王五': 99, '赵六': 90, '张三': 100, '田七': 100}
# 方式1.1(推荐): 直接遍历字典(默认获取的键)
for k in score_dict:
    # 根据k获取v
    # v = score_dict[k]
    v = score_dict.get(k)
    # 格式化输出
    print(f"{k}的分数是:{v}")
print('---------------------------')
# 方式1.2(了解): 先获取所有的key,然后遍历依次获取value
for k in score_dict.keys():
    # 根据k获取v
    # v = score_dict[k]
    v = score_dict.get(k)
    # 格式化输出
    print(f"{k}的分数是:{v}")
print('---------------------------')
# 方式2(推荐): 先获取所有的键值对,然后拆包直接拿到k,v
for k, v in score_dict.items():
    # 格式化输出
    print(f"{k}的分数是:{v}")

字典的特点
字典是可变类型

支持for循环遍历
支持修改操作
每个元素是键值对,key只能是不可变类型 原理和集合一样,value可以是任意类型
没有索引所以
不支持while
无序
键不能重复

推导式

五大容器中支持推导式的有 列表 集合 字典

知识点:

Python 的推导式（Comprehension）是一种简洁、优雅的语法，用于创建数据结构。它能够通过一行代码生成列表、字典、集合或生成器表达式。

# 需求: 生成存储了1-10的列表
# 方式1: 原始方式
# 1.定义空列表
nums1 = []
# 2.循环依次生成1-10,依次放到列表中
for i in range(1, 11):
    # i依次代表1-10,然后依次放到列表中
    nums1.append(i)

# 3.使用列表
print(nums1)

# 方式2: 推导式
nums2 = [i for i in range(1, 11)]
print(nums2)
print('---------------------------------------------')
# 需求: 生成一个存储了1-10中偶数的列表
# 方式1: 原始方式
# 1.定义空列表
nums1 = []
# 2.循环依次生成1-10,依次放到列表中
for i in range(1, 11):
    # 如果是偶数放到列表中
    if i % 2 == 0:
        # i依次代表1-10,然后依次放到列表中
        nums1.append(i)

# 3.使用列表
print(nums1)

# 方式2: 推导式
nums2 = [i for i in range(1, 11) if i % 2 == 0]
print(nums2)

# 需求: 生成存储了1-10的集合
# 方式1: 原始方式
# 1.定义空集合
nums1 = set()
# 2.循环依次生成1-10,依次放到集合中
for i in range(1, 11):
    # i依次代表1-10,然后依次放到集合中
    nums1.add(i)

# 3.使用集合
print(nums1)

# 方式2: 推导式
nums2 = {i for i in range(1, 11)}
print(nums2)

# 需求: 生成存储了1:1-10:10的字典
# 方式1: 原始方式
# 1.定义空字典
nums1 = {}
# 2.循环依次生成1-10,依次放到字典中
for i in range(1, 11):
    # i依次代表1-10,然后依次放到字典中
    nums1[i] = i

# 3.使用字典
print(nums1)

# 方式2: 推导式
nums2 = {i: i for i in range(1, 11)}
print(nums2)

生成器推导式
nums = (i for i in range(1,11))
print(nums)
##此时打印出来 不是一串数字 而是推导式 的地址
需要将nums给转换成tuple 才能把推导式出来的东西 拿到手
其他也是同理只是省略了这一步
t1 = tuple(nums)
print(t1)

五大容器总结对比
是否是序列
        序列:列表,元组,字符串
        非序列 集合 字典

是否 是可变类型
        可变类型:列表,集合,字典
        不可变类型:字符串,元组

# 1.定义五大容器
# 定义非空字符串
s = 'cbedaa'
# 定义非空列表
l = ['c', 'b', 'e', 'd', 'a', 'a']
# 定义非空元组
t = ('c', 'b', 'e', 'd', 'a', 'a')
# 定义非空集合
se = {'c', 'b', 'e', 'd', 'a', 'a'}
# 定义非空字典
d = {'c': 1, 'b': 1, 'e': 1, 'd': 1, 'a': 1, 'a': 1}
print('---------------------------------------------------')
# 2.演示通用操作
# len()获取容器中元素个数
print(len(s))
print(len(l))
print(len(t))
print(len(se))
print(len(d))
print('---------------------------------------------------')
# min()获取容器中最小元素
print(min(s))
print(min(l))
print(min(t))
print(min(se))
print(min(d))
print('---------------------------------------------------')
# max()获取容器中最大元素
print(max(s))
print(max(l))
print(max(t))
print(max(se))
print(max(d))
print('---------------------------------------------------')
# max()获取容器中最大元素
print(max(s))
print(max(l))
print(max(t))
print(max(se))
print(max(d))
print('---------------------------------------------------')
# sorted(容器)默认升序排序
print(sorted(s))
print(sorted(l))
print(sorted(t))
print(sorted(se))
print(sorted(d))
print('---------------------------------------------------')
# sorted(容器,reverse)反转
print(sorted(s, reverse=True))
print(sorted(l, reverse=True))
print(sorted(t, reverse=True))
print(sorted(se, reverse=True))
print(sorted(d, reverse=True))
print('---------------------------------------------------')
# in : 判断指定元素是否在容器中
print('c' in s)
print('c' in l)
print('c' in t)
print('c' in se)
print('c' in d)
print('---------------------------------------------------')
# not in : 判断指定元素是否不在容器中
print('c' not in s)
print('c' not in l)
print('c' not in t)
print('c' not in se)
print('c' not in d)
print('---------------------------------------------------')
# 拆包
a, b, c = '123'
print(a, b, c)
a, b, c = [1, 2, 3]
print(a, b, c)
a, b, c = (1, 2, 3)
print(a, b, c)
a, b, c = {1, 2, 3}
print(a, b, c)
a, b, c = {1: 'a', 2: 'a', 3: 'a'}
print(a, b, c)

# 定义非空列表
l = [2, 1, 3, 1]
# 定义非空元组
t = (2, 1, 3, 1)
# 定义非空字符串
s = '2131'
# 定义非空集合
ss = {2, 1, 3, 1}
# 定义非空字典
d = {2: 'a', 1: 'a', 3: 'a', 1: 'a'}

# list(其他容器): 把其他容器转换为列表
print(list(t))
print(list(s))
print(list(ss))
print(list(d))
print('----------------')
# tuple(其他容器): 把其他容器转换为元组
print(tuple(l))
print(tuple(s))
print(tuple(ss))
print(tuple(d))
print('----------------')
# set(其他容器): 把其他容器转换为集合
print(set(l))
print(set(t))
print(set(s))
print(set(d))
print('----------------')
# str(其他容器): 把其他容器转换为字符串
print(str(l))  # '[2, 1, 3, 1]'
print(str(t))  # '(2, 1, 3, 1)'
print(str(ss))  # '{1, 2, 3}'
print(str(d))  # "{2: 'a', 1: 'a', 3: 'a'}"
print('----------------')

# TODO 需求: 上述的字符串结果,如何再转换回去?
print(list('[2, 1, 3, 1]'))  # 结果是有问题的
print(tuple('(2, 1, 3, 1)'))  # 结果是有问题的
print(set('{1, 2, 3}'))  # 结果是有问题的
# print(dict("{2: 'a', 1: 'a', 3: 'a'}")) # 结果报错
print('-----------------------------------------------------------')

# TODO 拓展:
# TODO 思路: 如何把引号去掉? 方式1: 手动删除两端引号   方式2: eval(字符串)自动去除引号
print(eval('[2, 1, 3, 1]'))  # 结果转为列表
print(eval('(2, 1, 3, 1)'))  # 结果转为元组
print(eval('{1, 2, 3}'))  # 结果转为集合
print(eval("{2: 'a', 1: 'a', 3: 'a'}"))  # 结果转为字典
print('-----------------------------------------------------------')
# eval可以把字符串中是整数,浮点数,布尔值的变成本身类型
print(eval('10'))
print(eval('3.14'))
print(eval('True'))
# 但是eval不要直接去除非整数,浮点数,布尔值,容器意外的引号!!!
# print(eval('你好')) # 报错