009 数据类型转换

1.Number数据类型自动转换类型

当有两个不同的类型的数据进行运算时，默认会想高精度转换；

数据类型的自动转化从低到高： bool < int < float < complex

#number 自动类型转换，从低到高： bool < int < float <complex
num01 = False
num02 = 2
num03 = 5.23
num04 = 6 + 2j

print((num01 + num02),(num01 + num03),(num01 + num04))  #2 5.23 (6+2j)
print((num02 + num01),(num02 + num03),(num02 + num04))  #2 7.23 (8+2j)
print((num03 + num02),(num03 + num01),(num03 + num04))  #7.23 5.23 (11.23+2j)
print((num04 + num02),(num03 + num03),(num01 + num04))  #(8+2j) 10.46 (6+2j)

2.强制类型转换

2.1 Number 数据类型强制转换

##强制类型装换：Number(int bool float complex)
#int     : int bool float 纯数字字符串
#float   ：int bool float 纯数字字符串
#complex : int bool float 纯数字字符串  （复数本身）
#bool    ： Number 类型、 容器类型

mess01 = 18
mess02 = False
mess03 = 3.15
mess04 = 5-3j
mess05 = '2554'
mess06 = 'wef'

# # int 强制转换成整数
print(int(mess01),type(int(mess01)))     #18 <class 'int'>
print(int(mess02),type(int(mess02)))     #0 <class 'int'>
print(int(mess03),type(int(mess03)))     #3 <class 'int'>
# print(int(mess04),type(int(mess04)))   #报错,不支持
print(int(mess05),type(int(mess05)))     #2554 <class 'int'>
# print(int(mess06),type(mess06))   #报错,不支持


#float 强制转换成浮点数
print(float(mess01), type(float(mess01)))  #18.0 <class 'float'>
print(float(mess02), type(float(mess02)))  #0.0 <class 'float'>
print(float(mess03), type(float(mess03)))  #3.15 <class 'float'>
# print(float(mess04), type(float(mess04)))
print(float(mess05), type(float(mess05)))  #2554.0 <class 'float'>
# print(float(mess06), type(float(mess06)))

#complex 强制转换成复数
print(complex(mess01),type(complex(mess01)))  #(18+0j) <class 'complex'>
print(complex(mess02),type(complex(mess02)))  #0j <class 'complex'>
print(complex(mess03),type(complex(mess03)))  #(3.15+0j) <class 'complex'>
print(complex(mess04),type(complex(mess04)))  #(5-3j) <class 'complex'>
print(complex(mess05),type(complex(mess05)))  #(2554+0j) <class 'complex'>
# print(complex(mess06),type(complex(mess06)))


#bool 强制转换成布尔值
有10种类型代表bool 的False,其他为True
例如：
0、0.0、False、0j
''、[]、()、{}、set()
None

2.2容器类型数据强制转换

##容器类型的强制装换： str list tuple set dict

strvar = "中国加油!"
listvar = [1, 2, "武汉"]
tuplevar = ('张三','王五','李四')
setvar = {'北京','山东','河北','新疆'}
dictvar = {'name':"李明",'age':18,'sex':'1'}

#str ：强制转换成str （str list tuple set dict） #不受数据类型的限制，无论是 Number还是容器型数据类型都可以转换，在原数据类型的基础上加引号; #使用repr 可以原型化输出字符串，不转义字符（显示引号）用法：repr()

print(repr(str(strvar)),'
',
      repr(str(listvar)),'
',
      repr(str(tuplevar)),'
',
      repr(str(setvar)),'
',
      repr(str(dictvar)))
'''
结果：
'中国加油!' 
 "[1, 2, '武汉']" 
 "('张三', '王五', '李四')" 
 "{'新疆', '山东', '北京', '河北'}" 
 "{'name': '李明', 'age': 18, 'sex': '1'}"
'''

#list ：强制转化成列表（str list tuple set dict）

如果是字符串，会把每个单独的作为一个元素放到列表中；
如果是字典，会把字典的每个键，作为列表的新元素，生成新的列表；
如果是其他容器，只会单纯的把原有数据的符号，替换成[]


print(list(strvar),'
',
      list(tuplevar),'
',
      list(setvar),'
',
      list(dictvar),'
')
'''
结果：
['中', '国', '加', '油', '!'] 
 ['张三', '王五', '李四'] 
 ['山东', '新疆', '北京', '河北'] 
 ['name', 'age', 'sex'] 

'''

#tuple ：强制转换成元组（str list tuple set dict）

如果是字符串，会把每个单独的作为一个元素放到元组中；
如果是字典，会把字典的每个键，作为列表的新元素，生成新的元组；
如果是其他容器，只会单纯的把原有数据的符号，替换成()

print(tuple(strvar),'
',
      tuple(tuplevar),'
',
      tuple(setvar),'
',
      tuple(dictvar),'
')
'''
结果：
('中', '国', '加', '油', '!') 
 ('张三', '王五', '李四') 
 ('山东', '新疆', '河北', '北京') 
 ('name', 'age', 'sex') 
'''

#set ：强制转换成集合（str list tuple set dict）

如果是字符串，会把每个单独的作为一个元素放到集合中，且无序自动去重；

如果是字典，会把字典的每个键，作为列表的新元素，生成新的集合，且无序自动去重；

如果是其他容器，只会单纯的把原有数据的符号，替换成[],且无序，自动去重

print(set(strvar),'
',
      set(tuplevar),'
',
      set(setvar),'
',
      set(dictvar),'
')

'''
结果：
 {'!', '中', '加', '油', '国'} 
 {'张三', '王五', '李四'} 
 {'山东', '河北', '新疆', '北京'} 
 {'age', 'name', 'sex'} 
'''

dict ：强制转换成字典类型（str、list、tuple、set）

强转成字典时 , 必须是等长的二级容器,里面的元素个数是2个
最外层为，list 、tuple 或set,里面的容器的最好使用list、tuple;
最好不使用set集合，他是无序，对于内层如果是set，无法确定每次取到的键与值的对应关系一直相同；如果在外层，无法保证每次取到的字典的顺序一致；

二级容器如下：

listvar = [1,2,5,['李四','王五']]
tuplevar = ('w','a','g',('张三','小明'))
setvar = {'北京','重庆','武汉',(1,2)}
dictvar = {'name':'王','age':18,'aihao':{'num01':'running','num02':'pingpang'}}
print(listvar,tuplevar,setvar,dictvar)
#结果：[1, 2, 5, ['李四', '王五']] ('w', 'a', 'g', ('张三', '小明')) {(1, 2), '重庆', '武汉', '北京'} {'name': '王', 'age': 18, 'aihao': {'num01': 'running', 'num02': 'pingpang'}}

#强制转换成字典

message01 = [['a','b'],(1,2)]
message02 = [['a','b','c'],(1,2,3)] #报错

message03 = ((1,2),('a','b'))
message04 = {('a',1),('b',2)}


print(dict(message01))     #{'a': 'b', 1: 2}
# print(dict(message02))   #报错，列表中的列表，与元组的元素不为2
print(dict(message03))     #{1: 2, 'a': 'b'}
print(dict(message04))