容器类型的强制转换(str、list、tuple、set、dict)

 

强制转换成字符串

所有的数据类型都可以转换, 在当前的数据类型两边套上引号

var2 = [1,2,3]
var3 = (4,4,5)
var4 = {"张三","上朝气","李四","合理"}
var5 = {"zs":"文质彬彬,斯文败类","ls":"学霸","ww":"篮球少年","zl":"武林高手"}
var6 = 90
var7 = True
res2 = str(var2) 
res3 = str(var3)
res4 = str(var4)
res5 = str(var5)
res6 = str(var6)
res7 = str(var7)
# repr 不转移字符原型化输出字符串
print(res2 ,type(res2),repr(res2))
print(res3 ,type(res3),repr(res3))
print(res4 ,type(res4),repr(res4))
print(res5 ,type(res5),repr(res5))
print(res6 ,type(res6),repr(res6))
print(res7 ,type(res7),repr(res7))

输出结果：

[1, 2, 3] <class 'str'> '[1, 2, 3]'
(4, 4, 5) <class 'str'> '(4, 4, 5)'
{'上朝气', '合理', '张三', '李四'} <class 'str'> "{'上朝气', '合理', '张三', '李四'}"
{'zs': '文质彬彬,斯文败类', 'ls': '学霸', 'ww': '篮球少年', 'zl': '武林高手'} <class 'str'> "{'zs': '文质彬彬,斯文败类', 'ls': '学霸', 'ww': '篮球少年', 'zl': '武林高手'}"
90 <class 'str'> '90'
True <class 'str'> 'True'

 

强制转换成列表

如果是字符串: 把字符串中的每个元素单独拿出来,作为列表中的新元素
如果是字典: 只保留字典中的键
如果是其他容器数据: 就是单纯的在原数据类型德两边换上[]括号

var1 = "心连心,手牵手"
var3 = (4,4,5)
var4 = {"张三","上朝气","李四","合理"}
var5 = {"zs":"文质彬彬,斯文败类","ls":"学霸","ww":"篮球少年","zl":"武林高手"}
var6 = 90
res1 = list(var1)
res2 = list(var3)
res4 = list(var4)
# 字典: 只获取字典得键,忽略掉值
res5 = list(var5)
# res6 = list(var6) error 只能是容器间的互转
print(res1 ,type(res1))
print(res2 ,type(res2))
print(res4 ,type(res4))
print(res5 ,type(res5))

输出结果：

['心', '连', '心', ',', '手', '牵', '手'] <class 'list'>
[4, 4, 5] <class 'list'>
['李四', '张三', '上朝气', '合理'] <class 'list'>
['zs', 'ls', 'ww', 'zl'] <class 'list'>

 

强制转换成元组

如果是字符串:把字符串中的每个元素单独拿出来,作为元组中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上()括号

var1 = "心连心,手牵手"
var2 = [1,2,3]
var4 = {"张三","上朝气","李四","合理"}
var5 = {"zs":"文质彬彬,斯文败类","ls":"学霸","ww":"篮球少年","zl":"武林高手"}
res1 = tuple(var1)
res2 = tuple(var2)
res4 = tuple(var4)
res5 = tuple(var5)
print(res1 ,type(res1))
print(res2 ,type(res2))
print(res4 ,type(res4))
print(res5 ,type(res5))

输出结果：

('心', '连', '心', ',', '手', '牵', '手') <class 'tuple'>
(1, 2, 3) <class 'tuple'>
('合理', '张三', '上朝气', '李四') <class 'tuple'>
('zs', 'ls', 'ww', 'zl') <class 'tuple'>

 

强制转换成集合

如果是字符串:把字符串中的每个元素单独拿出来,作为集合中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上{}括号

var1 = "心连心,手牵手"
var2 = [1,2,3]
var5 = {"zs":"文质彬彬,斯文败类","ls":"学霸","ww":"篮球少年","zl":"武林高手"}
res1 = set(var1)
res2 = set(var2)
res3 = set(var5)
print(res1 ,type(res1))
print(res2 ,type(res2))
print(res3 ,type(res3))

输出结果：

{'连', ',', '心', '牵', '手'} <class 'set'>
{1, 2, 3} <class 'set'>
{'ls', 'zl', 'ww', 'zs'} <class 'set'>

多滤掉列表中所有重复元素

lst = [1,222,3,3,3,44,88,999,77,88,1]
res = set(lst)
print(res)
# 在把当前的集合转换成原来的列表
res2 = list(res)
print(res2)

输出结果：

{1, 3, 999, 44, 77, 88, 222}
[1, 3, 999, 44, 77, 88, 222]

默认不加任何值,转换成该数据类型的空值
str() list()  tuple()  set()  dict()

res = dict()
print(res )
print(type(res))

输出结果：

{}
<class 'dict'>

字典类型的强制转换

要求: 必须是等长的二级容器,并且里面的元素个数是2个;
外层是列表,元组,集合 , 里层是列表或者元组的等长二级容器 => 字典;

外层是列表,里层是列表或者元组

lst = [ ["a",1] , ("b",2) ]
dic = dict(lst)
print(dic , type(dic)) 

输出结果：

{'a': 1, 'b': 2} <class 'dict'>

 

外层是元组,里层是列表或者元组

tup = ( ["a",1] , ("b",2) )
dic = dict(tup)
print(dic , type(dic))

输出结果：

{'a': 1, 'b': 2} <class 'dict'>

 

外层是集合,里层是元组

setvar = { ("a",1) , ("b",2) }
dic = dict(setvar)
print(dic , type(dic))

输出结果：

{'a': 1, 'b': 2} <class 'dict'>

 

例外1:外层是列表/元组,里层放集合
可以实现,不推荐使用,因为达不到想要的目的,集合无序,不推荐使用

lst = [ ["a",1] , {"b","250"} ]
dic = dict(lst)
print(dic)

输出结果：

{'b': 2, 'a': 1} <class 'dict'>

 

例外2:外层是列表/元组,里层放字符串
字符串长度只能是2位,有极大的局限性,不推荐使用

lst = ["a1","b2"]
# lst = ["a11","b22"] error 
dic = dict(lst)
print(dic)

输出结果：

{'a': '1', 'b': '2'}