数据类型转换

  • 自动类型转换

程序自发的行为，在需要的情况下进行的操作，无法干预,自动类型转换多发生运算或者判断过程当中

1
2
3
4
5
6
7
8
9
10
11
12
13
#声明一个整数
intvar = 99
#声明一个浮点数
floatvar = 5.56

#加法运算(发生了自动类型转换！ 自动的操作)
result = intvar + floatvar #intvar 转换成了浮点数 99 -> 99.0
print(result)
print(type(result))

#判断情况
if -5:#整型转化为布尔值
  print('python大法好')
  • 强制数据类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1.int()    强制转换为整型  Int

#var = 8.9
#var = False
#var = '99'
#打印原有数据类型和值
print(var,type(var))
#强制转换操作
newvar = int(var)
#打印转换之后的数据类型和值
print(newvar,type(newvar))

1.整型不需要转换
2.浮点型转换为整型，去掉小数部分
3.布尔值转换为整型,True转换为1, False转换为0
4.复数无法转换为整型
5.字符串只有纯整数的字符串可以转换，其余都不行
6.列表不能转换
7.元组不能转换
8.集合不能转换
9.字典不能转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2.float()  强制转换为浮点型 Float

#var = 88
#var = True
#var = '9.9'
#打印原有类型和值
print(var,type(var))
#强制转换过程
newvar = float(var)
#打印转换之后的类型和值
print(newvar,type(newvar))

1.整型转换为浮点型，添加.0即可
2.浮点型无需转换
3.布尔值转换为浮点型，True转换1.0,False转换为0.0
4.复数无法转换为浮点型
5.字符串只要是数值类型的字符串就可以转换
6.列表不能转换
7.元组不能转换
8.集合不能转换
9.字典不能转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
3.bool()   强制转换为布尔类型 Bool

#var = 0
#var = 0.0
#var = False
#var = 0 + 0j
#var = ''
#var = []
#var = ()
#var = set()
#var = {'a':1,'b':2}
print(var,type(var))
newvar = bool(var)
print(newvar,type(newvar))

(必须记忆转换为False情况)
1.整型0
2.浮点型0.0
3.布尔值的False
4.复数0j
5.字符串的空字符串''
6.空列表[]
7.空元组()
8.空集合set()
9.空字典{}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
4.complex()    强制转换为复数   Complex

#var = 88
#var = 8.9
#var = True
#var = '9.9'
print(var,type(var))
newvar = complex(var)
print(newvar,type(newvar))

1.整型转换为复数后面+0j
2.浮点型转换为复数后面+0j
3.布尔值 True -> 1+0j , False ->0j
4.复数无需转换
5.字符串只有纯数值的字符串可以转换，后面+0j
6.列表不能转换
7.元组不能转换
8.集合不能转换
9.字典不能转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
5.str()    强制转换为字符串  Str

#var = 19
#var = 7.8
#var = False
#var = 9 + 2j
#var = '小飞机'
#var = [1,2,3,5,67]
#var = (1,2,3,5,7) #-> '(1,2,3,5,7)'
#var = {1,2,3,5,6}
#var = {'a':1,'b':2}
print(var,type(var))
newvar = str(var)
print(newvar,type(newvar))

1.所有数据转换为字符串都是变成字符格式的内容而已。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
6.list()   强制转换为列表   List

#var = '唧唧复唧唧，木兰当户织'
#var = (1,2,3,4,5,6,7,8,9)
#var = {1,2,3,5,6,8,9}
var = {'a':1,'b':2,'c':3}
print(var,type(var))
newvar = list(var)
print(newvar,type(newvar))

1.整型不可以转换
2.浮点型不可以转换
3.布尔值不可转换
4.复数不可以转换
5.字符串转换为列表，每个字符变成列表中的每个值
6.列表类型不需要转换
7.元组转换为列表，类型改变，内容不变
8.集合转换为列表，类型改变，内容不变，顺序随机
9.字典转换为列表仅保留键，舍弃值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
7.tuple()  强制转换为元组  Tuple

#var = '唧唧复唧唧，木兰当户织'
#var = [2,3,5,6,7]
#var = {1,2,3,5,6,8,9}
#var = {'a':1,'b':2,'c':3}
print(var,type(var))
newvar = tuple(var)
print(newvar,type(newvar))

1.整型不可以转换
2.浮点型不可以转换
3.布尔值不可转换
4.复数不可以转换
5.字符串转换为元组，每个字符变成元组中的每个值
6.列表转换为元组，内容和顺序不变，类型改变
7.元组无需转换
8.集合转换为元组，类型改变，内容不变，顺序随机
9.字典转换为元组仅保留键，舍弃值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
8.set()    强制转换为集合   Set

#var = '唧唧复唧唧，木兰当户织'
#var = [2,3,5,6,7,2,3,5,6,7]
#var = (1,2,3,4,5,6,7,8,9,8,8,8,8)
var = {'a':1,'b':2,'c':3}
print(var,type(var))
newvar = set(var)
print(newvar,type(newvar))

1.整型不可以转换
2.浮点型不可以转换
3.布尔值不可转换
4.复数不可以转换
5.字符串转换为集合，去掉重复的数据，每个字符变成集合的每个值，顺序随机
6.列表转换为集合，去掉重复的数据，剩下的值变成集合的值，顺序随机
7.元组转换为集合，去掉重复的数据，剩下的值变成集合的值，顺序随机
8.集合无需转换
9.字典转换为集合，将字典的键变成集合的值，字典的值舍弃
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 9.dict()   强制转换为字典   Dict

#var = 9.9
#var = '唧唧复唧唧，木兰当户织'
var = [['A',1],['B',2],['C',3],['D',4]]#二级列表
var = ((1,1.1),(2,2.2),(3,3.3))#二级元组
var = {(1,2),(3,4)}#二级容器
print(var,type(var))
newvar = dict(var)
print(newvar,type(newvar))

1.整型不可以转换
2.浮点型不可以转换
3.布尔值不可转换
4.复数不可以转换
5.字符串不可以转换
6.列表必须是二级列表，并且第二级只有2个数据的列表可以转换
7.元组必须是二级元组，并且第二级只有2个数据的元组可以转换
8.集合必须是二级容器，并且第二级只有2个数据的集合可以转换
9.字典无需转换

容器类数据：1.字符串、2.列表、3.元组、4.集合、5.字典。
只有容器类数据才能转换为容器类数据,字符串除外。