python之容器类型转换

一、介绍

在python中，容器类型转换是基础的语法，而常见的容器类型有列表、元组、集合、字符串、字典，接下来逐一介绍各个容器之间的相互转换

二、语法

要转换成的容器类型(待转换的容器)

三、前言

为了方便大家能看懂接下来的测试，这里我简单提一下星号表达式，它可以将一个可迭代序列中的元素以空格隔开输出在一行，并且末尾不会有多余的空格以下面的代码为例
这是使用星号表达式输出的结果

lst = [1, 2, 3, 4]
print(*lst)

输出：
1 2 3 4

这是我们用循环输出的代码

lst = [1, 2, 3, 4]
for i in lst:
    print(i, end=" ")

输出：
1 2 3 4 

当然，我们可以用一个特判将最后的空格给取消掉，但显然不如星号表达式简洁

四、其他容器转换成字符串类型

1、列表、元组转字符串

lst = [1, 2, 3, 4, 5]
print("原列表：", *lst)
s1 = str(lst)
print("字符串：", *s1)
print("="*50)
t = 1, 2, 3, 4, 5
print("原元组：", *t)
s2 = str(t)
print("字符串：", *s2)

输出：
原列表： 1 2 3 4 5
字符串： [ 1 ,   2 ,   3 ,   4 ,   5 ]
==================================================
原元组： 1 2 3 4 5
字符串： ( 1 ,   2 ,   3 ,   4 ,   5 )

我们可以发现，将列表、元组转换成字符串类型后，列表的"[]"这个中括号也会被转换，包括其中的“，"逗号也被视为强转后的类型，同理我们不妨大胆猜测对集合、字典强转成字符串类型后，它们的逗号（,）、冒号（:）是不是也会被强转成字符串的元素呢？

2、集合，字典转字符串

set1 = {1, 2, 3, 4, 5}
print("原集合：", *set1)
s1 = str(set1)
print("字符串：", *s1)
print("=" * 50)
dict1 = {"name": "Tom", "age": 18}
print("原字典：", dict1)
print(*dict1)
s2 = str(dict1)
print("字符串：", *s2)

输出：
原集合： 1 2 3 4 5
字符串： { 1 ,   2 ,   3 ,   4 ,   5 }
==================================================
原字典： {'name': 'Tom', 'age': 18}
name age
字符串： { ' n a m e ' :   ' T o m ' ,   ' a g e ' :   1 8 }

由此可以发现我们上面的推断是正确的，不过在这里我发现一个有意思的东西就是输出字典的元素时，它输出的是它的key值，同时需要注意的是，虽然集合是无需的，但是在转换成字符串的时候他会根据代码中的顺序进行转换，也就是说，不管运行多少次，输出转换成字符串的集合，结果都是一样的，同时用星号表达式输出集合也是同样的结果，不管运行多少次，结果都是一样的

五、其他容器转换成列表、元组类型

由于列表与元组类似，所以就将它们同一讲了

1、列表、元组的相互转换

lst1 = [1, 2, 3, 4, 5]
print("lst1:", *lst1)
print("lst1类型：", type(lst1))

print("=" * 50)

t1 = tuple(lst1)
print("t1:", *t1)
print("t1类型：", type(t1))

print("=" * 50)

lst2 = list(t1)
print("lst2:", *lst2)
print("lst2类型：", type(lst2))

输出：
lst1: 1 2 3 4 5
lst1类型： <class 'list'>
==================================================
t1: 1 2 3 4 5
t1类型： <class 'tuple'>
==================================================
lst2: 1 2 3 4 5
lst2类型： <class 'list'>

2、集合转换成列表、元组

set1 = {1, 2, 3, 4, 5}
print("set1:", set1)
# 集合转换成列表
lst1 = list(set1)
print("lst1:", lst1)
# 集合转换成元组
t1 = tuple(set1)
print("t1:", t1)

输出：
set1: {1, 2, 3, 4, 5}
lst1: [1, 2, 3, 4, 5]
t1: (1, 2, 3, 4, 5)

3、字典转换成列表、元组

dict1 = {"name": "Tom", "age": 18}
print("dict1:", dict1)
# 字典转换成列表
lst1 = list(dict1)
print("lst1:", lst1)
# 字典转换成元组
t1 = tuple(dict1)
print("t1:", t1)

输出：
dict1: {'name': 'Tom', 'age': 18}
lst1: ['name', 'age']
t1: ('name', 'age')

由此我们可以看到，在对字典进行强转时，我们可以看成是讲字典的每一个key值放在列表或元组里

六、其他容器转换成集合类型

1、列表、元组转换成集合

lst1 = [1, 2, 3, 4, 5]
print("lst1:", lst1)
set1 = set(lst1)
print("s1:", set1)
print("==================================")
t1 = (1, 2, 3, 4, 5)
set2 = set(t1)
print("t1:", t1)
print("set2:", set2)

输出：
lst1: [1, 2, 3, 4, 5]
s1: {1, 2, 3, 4, 5}
==================================
t1: (1, 2, 3, 4, 5)
set2: {1, 2, 3, 4, 5}

2、字符串转换成集合

str1 = "abcde"
print("str1:", str1)
set1 = set(str1)
print("set1:", set1)

输出：
str1: abcde
set1: {'b', 'e', 'd', 'c', 'a'}

当我们在将字符串转换成集合类型后访问，会体现出集合的无序性，到这里，我就疑惑了，为什么会在强转后有时候能体现出集合的无序性，有时候不能呢？我带着这个问题去查了以下，最终得到的答案是因为集合的无序性主要体现在集合的迭代顺序上，即你无法确定集合中元素的顺序。集合类使用哈希表实现元素的存储和查找，不同元素的顺序可能是不确定的，这也是为什么集合元素的顺序是无序的。
列表、元组和字符串转换为集合的情况是不一样的。在 Python 中，列表和元组都是有序的容器类型，所以在转换为集合后，输出的顺序是有序的。列表和元组的顺序是按照它们的顺序进行存储，转换为集合时，也会保留它们的顺序。而对于字符串转换为集合后输出的顺序是随机的，这是因为字符串中的字符出现的顺序并没有特定的规律，所以在转换为集合时，出现的顺序是无序的，每次输出的结果可能不同。
需要注意的是，虽然列表、元组和字符串在转换为集合后输出的顺序可能是有序的或无序的，但是集合的元素本身是无序的，你无法通过下标来访问集合中的元素。

3、字典转换成集合

dict1 = {"name": "Tom", "age": 18}
print("dict1:", dict1)
set1 = set(dict1)
print("set1:", set1)

输出：
dict1: {'name': 'Tom', 'age': 18}
set1: {'age', 'name'}

这里我们就可以发现，在对字典进行强转的时候，字典的键值都会强转后的元素

七、其他容器转换成字典类型

这里我们需要知道的是不管是列表、元组，还是字符串或者集合，都是不能单独转换成字典类型的，那我们应该怎么做呢？
需要指出，任何一个单独的序列都是无法直接转换成字典类型的，哪怕我们将字典转换成字符串后再想转换成字典也是不行的，例如下面的代码

dict1 = {"name": "Tom", "age": 18, "gender": "男"}
s1 = str(dict1)
print(dict(s1))

运行会报错
ValueError: dictionary update sequence element #0 has length 1; 2 is required

所以我们可以先用zip函数打包，然后再转换为字典

str1 = "abcd"
lst1 = [1, 2, 3, 4]
print(dict(zip(str1, lst1)))

输出：
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

这方法可以概括为：
dict(zip(key序列， value序列))