类型转换
分为隐式类型转换和强制类型转换两种。
隐式类型转换
将一种类型的实例隐式转换为另一种类型的实例，也叫做自动类型转换。在 3 + 4.5 中，每个参数的类型不同（一个int，一个float），并且两个参数必须先转换为相同的类型才能计算,否则它将引发TypeError。在没有隐式类型转换的情况下，甚至兼容类型的所有参数都必须由程序员标准化为相同的值后才能进行下一步操作，例如 float(3) + 4.5 而不是 3 + 4.5。
数字类型之间可以进行隐式类型转换，bool是int的子类，bool类型和int类型计算时，自动隐式转换为int类型。int类型和float类型计算时，自动隐式转化为float类型。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
t = True
i = 10
f = 5.5
result1 = t + i # bool类型变量t隐式转化为int类型，再计算。计算结果是11，int类型。
result2 = t + f # bool类型变量t隐式转化为float类型，再计算。计算结果是6.5，float类型。
result3 = i + f # int类型变量i隐式转化为float类型，再计算。计算结果是15.5，float类型。
result4 = t + i + f # bool类型变量t隐式转化为float类型，int类型变量i隐式转化为float类型。计算结果是16.5，float类型。
print(type(result1))
print(result1)
print(type(result2))
print(result2)
print(type(result3))
print(result3)
print(type(result4))
print(result4)
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
|
<class 'int'>
11
<class 'float'>
6.5
<class 'float'>
15.5
<class 'float'>
16.5
|
强制类型转换
强制性的转换数据的类型。例如，int(3.15) 强制将浮点类型数据3.15转换为整数数字3。python内置一些强制类型转化函数，如下。
bool()强制转换为布尔类型,
int()强制转换为10进制整数类型,
bin()强制转换为2进制整数类型,
oct()强制转换为8进制整数类型,
hex()强制转换为16进制整数类型,
float()强制转换为浮点数类型,
str()强制转换为字符串类型,
list()强制转换为列表类型,
set()强制转换为集合类型,
tuple()强制转换为元组类型,
dict()强制转换为字典类型,
bool()强制类型转换
以下数值会被认为是False：
为0的数字，包括0，0.0
空字符串，包括”，”“,”“”,“”“”“”
空字节，包括b”，b”“,b”“”,b”“”“””
表示空值的None
空元组()
空列表[]
空字典{}
空集合set()
除此之外，其他的值都认为是True。
例如：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
a1 = 0
print(type(a1))
print(bool(a1)) # False
a2 = 10
print(type(a2))
print(bool(a2)) # True
b1 = 0.0
print(type(b1))
print(bool(b1)) # False
b2 = 0.1
print(type(b2))
print(bool(b2)) # True
c1 = None
print(type(c1))
print(bool(c1)) # False
c2 = abs
print(type(c2))
print(bool(c2)) # True
d1 = ''
print(type(d1))
print(bool(d1)) # False
d2 = ' '
print(type(d2))
print(bool(d2)) # True
e1 = ""
print(type(e1))
print(bool(e1)) # False
e2 = " "
print(type(e2))
print(bool(e2)) # True
f1 = ''''''
print(type(f1))
print(bool(f1)) # False
f2 = ''' '''
print(type(f2))
print(bool(f2)) # True
g1 = """"""
print(type(g1))
print(bool(g1)) # False
g2 = """ """
print(type(g2))
print(bool(g2)) # True
h1 = b''
print(type(h1))
print(bool(h1)) # False
h2 = b' '
print(type(h2))
print(bool(h2)) # True
i1 = b""
print(type(i1))
print(bool(i1)) # False
i2 = b" "
print(type(i2))
print(bool(i2)) # True
j1 = b''''''
print(type(j1))
print(bool(j1)) # False
j2 = b''' '''
print(type(j2))
print(bool(j2)) # True
k1 = b""""""
print(type(k1))
print(bool(k1)) # False
k2 = b""" """
print(type(k2))
print(bool(k2)) # True
l1 = ()
print(type(l1))
print(bool(l1)) # False
l2 = (3,)
print(type(l2))
print(bool(l2)) # True
m1 = []
print(type(m1))
print(bool(m1)) # False
m2 = [1,2]
print(type(m2))
print(bool(m2)) # True
n1 = {}
print(type(n1))
print(bool(n1)) # False
n2 = {"a":1}
print(type(n2))
print(bool(n2)) # True
o1 = set()
print(type(o1))
print(bool(o1)) # False
o2 = {1}
print(type(o2))
print(bool(o2)) # True
|
执行以上程序会输出如下结果：
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
<class 'int'>
False
<class 'int'>
True
<class 'float'>
False
<class 'float'>
True
<class 'NoneType'>
False
<class 'builtin_function_or_method'>
True
<class 'str'>
False
<class 'str'>
True
<class 'str'>
False
<class 'str'>
True
<class 'str'>
False
<class 'str'>
True
<class 'str'>
False
<class 'str'>
True
<class 'bytes'>
False
<class 'bytes'>
True
<class 'bytes'>
False
<class 'bytes'>
True
<class 'bytes'>
False
<class 'bytes'>
True
<class 'bytes'>
False
<class 'bytes'>
True
<class 'tuple'>
False
<class 'tuple'>
True
<class 'list'>
False
<class 'list'>
True
<class 'dict'>
False
<class 'dict'>
True
<class 'set'>
False
<class 'set'>
True
|
int()强制类型转换
2进制整数类型，转换为10进制整数,仅是进制表示改变，类型并未变化。
8进制整数类型，转换为10进制整数,仅是进制表示改变，类型并未变化。
16进制整数类型，转换为10进制整数,仅是进制表示改变，类型并未变化。
浮点数去除小数位，转换成相应的整数。
布尔类型的True转换为1，False转换为0。
字符串和字节比较特殊，看下面的讲解。
除此之外，其他的值都不能转换为int类型，否则会报错，抛出TypeError异常。
例如：
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
26
|
a = 0b101
print(type(a))
print(int(a)) # 5
b = 0o67
print(type(b))
print(int(b)) # 55
c = 0xa2f
print(type(c))
print(int(c)) # 11
d = 11.2
print(type(d))
print(int(d)) # 2607
e1 = True
print(type(e1))
print(int(e1)) # 1
e2 = False
print(type(e2))
print(int(e2)) # 0
f = None
print(type(f))
print(int(f)) # 抛出TypeError异常
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
<class 'int'>
5
<class 'int'>
55
<class 'int'>
2607
<class 'float'>
11
<class 'bool'>
1
<class 'bool'>
0
<class 'NoneType'>
Traceback (most recent call last):
File "main.py", line 27, in <module>
print(int(f)) # 抛出TypeError异常
TypeError: int() argument must be a string, a bytes-like object or a number, not 'NoneType'
|
字符串，字节的int强制类型转换
int函数还有第二个参数，表示进制。
只含有数字的字符串，可以转换为10进制整数。如”100”,‘100’,“”“100”“”,“‘100”‘。”a100”不能转换为整数。
0b或者0B开头的只含有数字的字符串，int(字符串，2)可以转换为10进制整数。
0o或者0O开头的只含有数字的字符串，int(字符串，8)可以转换为10进制整数。
0x或者0X开头的只含有数字的字符串，int(字符串，16)可以转换为10进制整数。
字节对象和字符串转换一样，只不过在字符串前面加b。
例如：
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
26
27
28
29
|
a1 = "100"
print(type(a1))
print(int(a1)) # 100
a2 = "0B100"
print(type(a2))
print(int(a2,2)) # 4
a3 = "0O100"
print(type(a3))
print(int(a3,8)) # 64
a4 = "0X100"
print(type(a4))
print(int(a4,16)) # 256
b1 = b"100"
print(type(b1))
print(int(b1)) # 100
b2 = b"0B100"
print(type(b2))
print(int(b2,2)) # 4
b3 = b"0O100"
print(type(b3))
print(int(b3,8)) # 64
b4 = b"0X100"
print(type(b4))
print(int(b4,16)) # 256
c = "100a"
print(type(c))
print(int(c)) # 抛出TypeError异常
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
<class 'str'>
100
<class 'str'>
4
<class 'str'>
64
<class 'str'>
256
<class 'bytes'>
100
<class 'bytes'>
4
<class 'bytes'>
64
<class 'bytes'>
256
<class 'str'>
Traceback (most recent call last):
File "main.py", line 29, in <module>
print(int(c)) # 抛出TypeError异常
ValueError: invalid literal for int() with base 10: '100a'
|
bin()强制类型转换
10进制整数类型，转换为2进制整数,仅是进制表示改变，类型并未变化。
8进制整数类型，转换为2进制整数,仅是进制表示改变，类型并未变化。
16进制整数类型，转换为2进制整数,仅是进制表示改变，类型并未变化。
布尔类型的True转换为0b1，False转换为0b0。
除此之外，其他的值都不能转换为2进制int类型，否则会报错，抛出TypeError异常。
例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
a = 101
print(type(a))
print(bin(a)) # 0b1100101
b = 0o67
print(type(b))
print(bin(b)) # 0b110111
c = 0xa2f
print(type(c))
print(bin(c)) # 0b101000101111
d1 = True
print(type(d1))
print(bin(d1)) # 0b1
d2 = False
print(type(d2))
print(bin(d2)) # 0b0
e = 11.2
print(type(e))
print(bin(e)) # 抛出TypeError异常
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<class 'int'>
0b1100101
<class 'int'>
0b110111
<class 'int'>
0b101000101111
<class 'bool'>
0b1
<class 'bool'>
0b0
<class 'float'>
Traceback (most recent call last):
File "main.py", line 22, in <module>
print(bin(e)) # 抛出TypeError异常
TypeError: 'float' object cannot be interpreted as an integer
|
oct()，hex()的强制类型转换同bin()一样，就不举例介绍了。
float()强制类型转换
2进制整数类型，转换为float类型，带有小数位。
8进制整数类型，转换为float类型，带有小数位。
10进制整数类型，转换为float类型，带有小数位。
16进制整数类型，转换为float类型，带有小数位。
布尔类型的True转换为1.0，False转换为0.0。
除此之外，其他的值都不能转换为int类型，否则会报错，抛出TypeError异常。
例如：
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
26
27
|
a = 0b101
print(type(a))
print(float(a)) # 5.0
b = 0o67
print(type(b))
print(float(b)) # 55.0
c = 0xa2f
print(type(c))
print(float(c)) # 2607.0
d = 11
print(type(d))
print(float(d)) # 11.0
e1 = True
print(type(e1))
print(float(e1)) # 1.0
e2 = False
print(type(e2))
print(float(e2)) # 0.0
f = None
print(type(f))
print(float(f)) # 抛出TypeError异常
|
执行以上程序会输出如下结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
<class 'int'>
5.0
<class 'int'>
55.0
<class 'int'>
2607.0
<class 'int'>
11.0
<class 'bool'>
1.0
<class 'bool'>
0.0
<class 'NoneType'>
Traceback (most recent call last):
File "main.py", line 27, in <module>
print(float(f)) # 抛出TypeError异常
TypeError: float() argument must be a string or a number, not 'NoneType'
|
转载请注明本网址。