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))