# python数据类型转换
"""
python数据类型转换可以分为两种：
隐式类型转换-自动完成
显示类型转换-需要使用类型函数来转换
"""
# 隐式类型转换(自动类型转换)
# 隐式类型转换中，python会自动将一种数据类型转换为另一种数据类型。
# 转换规则：低精度向高精度转换 （bool -> int -> float -> complex）
num_int = 123
num_float = 1.23
num_bool = True
num_complex = 3 + 2j
# bool + int -> int
num_new = num_bool + num_int
print(num_new, type(num_new)) # 124 <class 'int'>
# bool + float -> float
num_new = num_bool + num_float
print(num_new, type(num_new)) # 2.23 <class 'float'>
# bool + complex -> complex
num_new = num_bool + num_complex
print(num_new, type(num_new)) # (4+2j) <class 'complex'>
# int + float -> float
num_new = num_int + num_float
print(num_new, type(num_new)) # 124.23 <class 'float'>
# int + complex -> complex
num_new = num_int + num_complex
print(num_new, type(num_new)) # (126+2j) <class 'complex'>
# float + complex -> complex
num_new = num_float + num_complex
print(num_new, type(num_new)) # (4.23+2j) <class 'complex'>
# 显式类型转换（强制类型转换）
var1 = 123
var2 = 5.78
var3 = False
var4 = 7 + 9j
var5 = '4567'
var6 = '78.89'
var7 = '4-5j'
# 强转成整型(可以转的类型：整型本身，浮点型，布尔值，纯数字的字符串)
# 浮点型 -》整型
res = int(var2)
print(res) # 5
# 布尔值 -》整型
res = int(var3)
print(res) # 0
# 复数 -》整型：失败，不可转
# res = int(var4)
# print(res) # TypeError: can't convert complex to int
# 纯数字字符串 -》整型
res = int(var5) # 纯数字的字符串
print(res) # 4567
# 整型 -》整型
res = int(var1)
print(res)
# 强转成浮点型
# 整型 -》浮点型
res = float(var1)
print(res) # 123.0
# 浮点型 -》浮点型
res = float(var2)
print(res) # 5.78
# 布尔值 -》浮点型
res = float(var3) # True => 1.0, False => 0.0
print(res) # 0.0
# 复数 -》浮点型：失败，报错
# res = float(var4)
# print(res) # TypeError: can't convert complex to float
# 纯数字字符串 -》浮点型
res = float(var5)
print(res) # 4567.0
# 纯小数字符串 -》浮点型
res = float(var6)
print(res) # 78.89
# 强转成复数
# 整型 -》复数
res = complex(var1)
print(res) # (123+0j)
# 浮点型 -》复数
res = complex(var2)
print(res) # (5.78+0j)
# 布尔值 -》复数
res = complex(var3)
print(res) # 0j
# 复数 -》复数
res = complex(var4)
print(res) # (7+9j)
# 纯数字字符串 -》复数
res = complex(var5)
print(res) # (4567+0j)
# 纯小数字符串 -》复数
res = complex(var6)
print(res) # (78.89+0j)
# 纯复数字符串 -》复数
res = complex(var7)
print(res) # (4-5j)
# 强转成布尔型
# 布尔型为假（False）的十种情况
# 0, 0.0, False, 0j, 空字符串（''）, 空列表（[]）， 空元组（()）, 空集合（set()）, 空字典（{}）, None
# None是系统关键字，代表空，什么也没有，一般用于变量初始化
a = None
b = None
print(a) # None
print(b) # None
# 容器类型的强制转换 str list tuple set dict
var1_str = '这是一个字符串'
var2_list = ['这', '是', '一', '个', '列', '表']
var3_tuple = ('这', '是', '一', '个', '元', '组')
var4_set = {'这', '是', '一', '个', '集', '合'}
var5_dict = {1: '这', 2: '是', 3: '一', 4: '个', 5: '字', 6: '典'}
var6_int = 123
var7_float = 1.23
var8_bool = True
var9_complex = 2 + 3j
# 强转成字符串
# 规则：在当前数据两边套上引号
res = str(var1_str)
print(res) # 这是一个字符串
res = str(var2_list)
print(res, repr(res)) # ['这', '是', '一', '个', '列', '表'] "['这', '是', '一', '个', '列', '表']"
res = str(var3_tuple)
print(res, repr(res)) # ('这', '是', '一', '个', '元', '组') "('这', '是', '一', '个', '元', '组')"
res = str(var4_set)
print(res, repr(res)) # {'个', '集', '一', '这', '是', '合'} "{'个', '集', '一', '这', '是', '合'}"
res = str(var5_dict)
print(res,
repr(res)) # {1: '这', 2: '是', 3: '一', 4: '个', 5: '字', 6: '典'} "{1: '这', 2: '是', 3: '一', 4: '个', 5: '字', 6: '典'}"
res = str(var6_int)
print(res, repr(res)) # 123 '123'
res = str(var7_float)
print(res, repr(res)) # 1.23 '1.23'
res = str(var8_bool)
print(res, repr(res)) # True 'True'
res = str(var9_complex)
print(res, repr(res)) # (2+3j) '(2+3j)'
# 不转义字符串，原型化输出
print(repr(res))
# list强转成列表
"""
规律：
如果是字符串：把里面的字符单独一个个抽出来作为列表的新元素
如果是字典：把里面的键抽出来，作为列表的新元素
如果是其他：无脑在该数据类型两边加上[]
"""
res = list(var1_str)
print(res) # ['这', '是', '一', '个', '字', '符', '串']
res = list(var2_list)
print(res) # ['这', '是', '一', '个', '列', '表']
res = list(var3_tuple)
print(res) # ['这', '是', '一', '个', '元', '组']
res = list(var4_set)
print(res) # ['合', '是', '个', '这', '集', '一']
res = list(var5_dict)
print(res) # [1, 2, 3, 4, 5, 6]
# res = list(var6_int) # 整型是不可迭代类型
# print(res) # TypeError: 'int' object is not iterable
# res = list(var7_float)
# print(res) # TypeError: 'float' object is not iterable
# res = list(var8_bool)
# print(res) # TypeError: 'bool' object is not iterable
# res = list(var9_complex)
# print(res) # TypeError: 'complex' object is not iterable
# tuple强转成元组
"""
规律：
如果是字符串：把里面的字符单独抽出来作为元组的新元素
如果是字典：把里面的键抽出来，作为元组的新元素
如果是其他：无脑在该数据类型两边换上()
"""
res = tuple(var1_str)
print(res) # ('这', '是', '一', '个', '字', '符', '串')
res = tuple(var2_list)
print(res) # ('这', '是', '一', '个', '列', '表')
res = tuple(var3_tuple)
print(res) # ('这', '是', '一', '个', '元', '组')
res = tuple(var4_set)
print(res) # ('是', '一', '这', '个', '合', '集')
res = tuple(var5_dict)
print(res) # (1, 2, 3, 4, 5, 6)
# res = tuple(var6_int)
# print(res) # TypeError: 'int' object is not iterable
# 强转成集合
"""
规律：
如果是字符串：把里面的字符串一个个抽出来作为集合的新元素
如果是字典：把里面的键抽出来作为集合的新元素
如果是其他：无脑在该数据类型两边换上{}
注意：
自动去重，无序
"""
res = set(var1_str)
print(res) # {'字', '符', '串', '一', '这', '个', '是'}
res = set(var2_list)
print(res) # {'是', '个', '表', '一', '列', '这'}
res = set(var3_tuple)
print(res) # {'一', '这', '是', '组', '个', '元'}
res = set(var4_set)
print(res) # {'这', '是', '集', '个', '一', '合'}
res = set(var5_dict)
print(res) # {1, 2, 3, 4, 5, 6}
# res = set(var6_int)
# print(res) # TypeError: 'int' object is not iterable
# 强转成字典
# 二级容器 list tuple set dict
# 二级列表
var1 = [1, 2, 3, [4, 5, 6]]
# 二级元组
var2 = (1, 2, 3, (4, 5, 6))
# 二级集合
var3 = {1, 2, 3, (4, 5, 6)}
# 二级字典
var4 = {1: 'a', 2: 'b', 3: 'c', 4: {5: 'd'}}
# 四级容器
var5 = [1, 2, (3, 4, 5, {'a': 1, 'b': 2, 'c': {"aa": "bbbb"}})]
res1 = var5[-1]
print(res1) # (3, 4, 5, {'a': 1, 'b': 2, 'c': {'aa': 'bbbb'}})
# 等长的二级容器[外面是容器，里面元素都是容器，容器里面的元素个数都相同]
var6 = [(1, 2, 3, 4), (5, 6, 7, 8)]
var7 = ({1, 2}, [3, 4], {5, 6})
# 强转字典时，需要等长的二级容器，且元素个数是两个
# 1.外面是列表，里面是元组/列表的等长二级容器
lst = [('a', 1), ('b', 2), ['c', 3]]
dic = dict(lst)
print(dic) # {'a': 1, 'b': 2, 'c': 3}
# 2.外面是元组，里面是元组/列表的等长二级容器
tup = (('a', 1), ("b", 2), ['c', 3])
dic = dict(tup)
print(dic) # {'a': 1, 'b': 2, 'c': 3}
# 3.外面是集合，里面是元组的等长二级容器
setvar = {('a', 1), ('b', 2), ('c', 3)}
dic = dict(setvar)
print(dic) # {'b': 2, 'c': 3, 'a': 1}
# 其他用法1:外面是列表，里面是元组/集合 ,不推荐，集合无序，导致键值对顺序相反
lst = [('a', 1), ('b', 2), {'c', 3}]
dic = dict(lst)
print(dic) # {'a': 1, 'b': 2, 3: 'c'}
# 其他用法2: 必须要求字符串长度为2，多了就报错
lst = [('a', 1), ('b', 2), ('c', 3), "23"]
dic = dict(lst)
print(dic) # {'a': 1, 'b': 2, 'c': 3, '2': '3'}
lst = [('a', 1), ('b', 2), ('c', 3), "2233"]
dic = dict(lst)
print(dic) # ValueError: dictionary update sequence element #3 has length 4; 2 is required
