1. 转换为 string
1.1 list 转 string
由字符串构成的列表 → 字符串
# str.join(seq) ：将序列 seq 中的元素以指定字符 str 连接生成一个新字符串
>>> ''.join(['1','a'])
'1a'强制类型转换 → 字符串
>>> str(['a',1])
"['a', 1]"1.2 dict 转 string
由字符串构成的字典 → 字符串
>>> ''.join({'x':'y', 'a':'b'}) # 字符串 dict (默认 keys)
'xa'
>>> ''.join({'x':'y', 'a':'b'}.keys()) # 字符串 dict.keys
'xa'
>>> ''.join({'x':'y', 'a':'b'}.values()) # 字符串 dict.values
'yb'强制类型转换 → 字符串
>>> str({'x':1, 'y':2})
"{'x': 1, 'y': 2}"
# json.dumps()：将 Python 对象编码成 JSON 字符串
>>> import json
>>> json.dumps({"x":1,"y":2,"z":3})
'{"x": 1, "y": 2, "z": 3}'
1.3 其他序列 → 字符串
>>> ''.join({'x','y'}) # 字符串 set
'xy'
>>> ''.join(('x','y')) # 字符串 tuple
'xy'2. 转换为 list
2.1 string → list
常见的字符串 → 列表
>>> string = 'x1y2'
>>> list(string) ## 1.强制类型转换
['x', '1', 'y', '2']
>>> [str(char) for char in string] ## 2.列表解析式 A
['x', '1', 'y', '2']
>>> list(map(lambda z:str(z),'x1y2')) ## 2.列表解析式 B
['x', '1', 'y', '2']
# str.split(str="", num=string.count(str))： ## 3.split()
# 指定分隔符 str 对字符串切片 (默认为所有空字符，包括空格、换行(\n)、制表符(\t)等)；
# 若指定分隔次数 num ，则分隔出 num+1 个子字符串 (默认-1 自适应分隔所有)
>>> string1 = 'p y t h o n' # 空格间隔字符串
>>> string1.split()
['p', 'y', 't', 'h', 'o', 'n']
>>> string2 = 'c s g o' # 制表符间隔字符串
>>> string2.split()
['c', 's', 'g', 'o']
>>> string3 = 'h,e,l,l,o' # 逗号间隔字符串
>>> string3.split(',')
['h', 'e', 'l', 'l', 'o']
>>> string4 = 'w#o#r#l#d' # 井号间隔字符串
>>> string4.split('#')
['w', 'o', 'r', 'l', 'd'](列表)字符串表达式 → 列表
# eval(expression[, globals[, locals]])： ## 4.eval()
# 执行一个字符串表达式 expression，并返回表达式的值
>>> exp = '[5,6,7]'
>>> eval(exp)
[5, 6, 7]
# 如果用 list() 强制类型转换，则会...
>>> list(exp)
['[', '5', ',', '6', ',', '7', ']']2.2 dict → list
常见的字典 → 列表
>>> dictionary = {'x':1, 'y':2}
>>> list(dictionary) # 强制类型转换 (默认 keys 转换)
['x', 'y']
>>> [i for i in dictionary] # 列表解析式 A
['x', 'y']
>>> list(map(lambda z: z, dictionary)) # 列表解析式 B
['x', 'y']
>>> list(dictionary.keys()) # 强制类型转换 (keys 转换)
['x', 'y']
>>> [j for j in dictionary.keys()] # 列表解析式
['x', 'y']
>>> list(map(lambda z:z, dictionary.keys())) # 列表解析式 B
['x', 'y']
>>> list(dictionary.values()) # 强制类型转换 (values 转换)
[1, 2]
>>> [k for k in dictionary.values()] # 列表解析式
[1, 2]
>>> list(map(lambda z:z, dictionary.values())) # 列表解析式 B
[1, 2]3. 转换为 dict
3.1 string → dict
(字典)字符串表达式 → 字典
# eval(expression[, globals[, locals]])：执行一个字符串表达式 expression，并返回表达式的值
>>> dictionary1 = '{"x":1, "y":2}'
>>> eval(dictionary1)
{'x': 1, 'y': 2}
# json.loads()：解码 JSON 数据，返回 Python 字段的数据类型
>>> import json
>>> jsonData = '{"x":1,"y":2,"z":3}'
>>> json.loads(jsonData)
{'x': 1, 'y': 2, 'z': 3}3.2 list → dict
嵌套列表 → 字典
>>> list1 = [['x',1],['y',2]] # 列表嵌套于列表
>>> dict(list1)
{'x': 1, 'y': 2}
>>> list2 = [('x',1),('y',2)] # 元组嵌套于列表
>>> dict(list2)
{'x': 1, 'y': 2}
>>> list3 = [{'x',1},{'y',2}] # 集合嵌套于列表
>>> dict(list3)
{1: 'x', 2: 'y'} # 注意顺序！两个列表 → 字典
>>> list_key = ['x', 'y']
>>> list_value = [1, 2]
>>> dict(zip(list_key, list_value)) # zip()
{'x': 1, 'y': 2}
>>> {key:value for key in list_key for value in list_value} # 字典解析式
{'x': 2, 'y': 2}其他
a. 转换为 int
int() ：由数字构成的字符串 (string) / 各精度的数字 / 由数字构成的字节 (bytes) / 布尔型 (bool) → 整型 (int)
或其他进制数 (int) → 十进制整型 (int)
>>> int('666') # 字符串 (type=string) (不可以含小数点)
666
>>> int(6.66) # 浮点型 (type=float)
6
>>> int(b'666') # 字节 (type=bytes)
666
>>> int(True) # 布尔型 (type=bool)
1
>>> int(False) # 布尔型 (type=bool)
0
>>> int(0b110) # 二进制数 (type=int)
6
>>> int(0x6) # 十六进制数 (type=int)
6
>>> int() # 无参数默认输出 0
0
b. 转换为 float
float() ：由数字构成的字符串 (str) / 各精度的数字/ 由数字构成的字节 (bytes) / 布尔型 (bool) → 浮点型 (float)
或其他进制数 → 十进制浮点型 (float)
>>> float('666') # 字符串 (type=string) (不可以含小数点)
666.0
>>> float(6) # 整型 (type=int)
6.0
>>> float(b'666') # 字节 (type=bytes)
666.0
>>> float(True) # 布尔型 (type=bool)
1.0
>>> float(False) # 布尔型 (type=bool)
0.0
>>> float(0b110) # 二进制数 (type=int)
6.0
>>> float(0x6) # 十六进制数 (type=int)
6.0
>>> float() # 无参数默认输出 0.0
0.0
参考文献：
