Python 数据类型转换可以分为两种：
隐式类型转换 - 自动完成
显式类型转换 - 需要使用类型函数来转换
隐式类型转换
在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。
以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。
# 定义一个整数变量
# num_int，值为 123
num_int = 123
# 定义一个浮点数变量
# num_flo，值为 1.23
num_flo = 1.23
# 将整数 num_int 和浮点数 num_flo 相加，结果赋值给 num_new
num_new = num_int + num_flo
# 打印 num_int 的数据类型，应该是 <class 'int'>
print("num_int 数据类型为:", type(num_int))
# 打印 num_flo 的数据类型，应该是 <class 'float'>
print("num_flo 数据类型为:", type(num_flo))
# 打印相加后的结果 num_new，值为 124.23
print("num_new 值为:", num_new)
# 打印 num_new 的数据类型，由于有浮点数参与运算，结果应该是 <class 'float'>
print("num_new 数据类型为:", type(num_new))运行
num_int 数据类型为: <class 'int'>
num_flo 数据类型为: <class 'float'>
num_new 值为: 124.23
num_new 数据类型为: <class 'float'>代码解析：
实例中我们对两个不同数据类型的变量
num_int和num_flo进行相加运算，并存储在变量num_new中。然后查看三个变量的数据类型。
在输出结果中，我们看到
num_int是整型（integer），num_flo是浮点型（float）。同样，新的变量
num_new是浮点型（float），这是因为 Python 会将较小的数据类型转换为较大的数据类型，以避免数据丢失。
我们再看一个实例，整型数据与字符串类型的数据进行相加：
num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int))
print("num_str 数据类型为:",type(num_str))
print(num_int+num_str)运行
num_int 数据类型为: <class 'int'>
num_str 数据类型为: <class 'str'>
Traceback (most recent call last):
File "/runoob-test/test.py", line 7, in <module>
print(num_int+num_str)
TypeError: unsupported operand type(s) for +: 'int' and 'str'从输出中可以看出，整型和字符串类型运算结果会报错，输出 TypeError。
Python 在这种情况下无法使用隐式转换。
num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int))
print("num_str 数据类型为:",type(num_str))
# 将字符串转换为整数
#num_str_to_int = int(num_str)
#或者直接在print中int(num_str)
print(num_int+int(num_str))运行
num_int 数据类型为: <class 'int'>
num_str 数据类型为: <class 'str'>
579但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。
显式类型转换
在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。
我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。
int() 强制转换为整型：
x = int(1) # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3运行结果
x = 1 # x 是整数 1
y = 2 # y 是整数 2（2.8 被截断）
z = 3 # z 是整数 3（字符串 "3" 被转换为整数）1. x = int(1)
这里
1本身已经是一个整数。使用
int(1)，会将1转换为整数（虽然它本来就是整数），结果还是1。x的值为1，类型为int。
2. y = int(2.8)
这里
2.8是一个浮点数。使用
int(2.8)，Python 会将浮点数2.8转换为整数，转换时舍弃小数部分，不会进行四舍五入。因此，
y的值是2，类型为int。
3. z = int("3")
这里
"3"是一个字符串，表示数字3。使用
int("3")，Python 会将这个字符串解析为一个整数。字符串必须是表示数字的形式，才能被成功转换。
z的值是3，类型为int。
总结：
int()函数 可以将不同类型的值（整数、浮点数、字符串）转换为整数。当输入是浮点数时，
int()会直接截断小数部分。当输入是表示整数的字符串时，
int()会将其转换为整数。
float() 强制转换为浮点型：
x = float(1) # x 输出结果为 1.0
y = float(2.8) # y 输出结果为 2.8
z = float("3") # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2运行结果
x = 1.0 # 整数 1 被转换为浮点数 1.0
y = 2.8 # 浮点数 2.8 保持不变
z = 3.0 # 字符串 "3" 被转换为浮点数 3.0
w = 4.2 # 字符串 "4.2" 被转换为浮点数 4.21. x = float(1)
这里
1是一个整数。使用
float(1)，Python 将整数1转换为浮点数，即1.0。整数
1被转换为浮点数时，自动在数值后面加上.0以表示浮点数。x的值为1.0，类型为float。
2. y = float(2.8)
这里
2.8本身是一个浮点数。使用
float(2.8)，Python 将2.8保持为浮点数，不会改变值。y的值是2.8，类型为float。
3. z = float("3")
这里
"3"是一个字符串，表示数字3。使用
float("3")，Python 会将字符串"3"转换为浮点数3.0。虽然字符串
"3"表示的是一个整数，但转换为浮点数后会变成3.0。z的值为3.0，类型为float。
4. w = float("4.2")
这里
"4.2"是一个字符串，表示浮点数4.2。使用
float("4.2")，Python 会将字符串"4.2"转换为浮点数4.2。w的值是4.2，类型为float。
总结：
float()函数 可以将整数、浮点数和表示数字的字符串转换为浮点数。如果输入是整数或表示整数的字符串，
float()会在数值后面加上.0，转换为浮点数。如果输入本身是浮点数或表示浮点数的字符串，
float()会保持原有的浮点数格式。
str() 强制转换为字符串类型：
x = str("s1") # x 输出结果为 's1'
y = str(2) # y 输出结果为 '2'
z = str(3.0) # z 输出结果为 '3.0'运行结果
x = 's1' # 字符串 "s1" 保持不变
y = '2' # 整数 2 被转换为字符串 '2'
z = '3.0' # 浮点数 3.0 被转换为字符串 '3.0'1. x = str("s1")
这里
"s1"本身就是一个字符串。使用
str("s1")，Python 不会对已经是字符串的内容做任何改变，结果仍然是字符串's1'。x的值为's1'，类型为str。
2. y = str(2)
这里
2是一个整数。使用
str(2)，Python 将整数2转换为字符串'2'。整数转换为字符串时，输出的形式是带引号的字符。
y的值为'2'，类型为str。
3. z = str(3.0)
这里
3.0是一个浮点数。使用
str(3.0)，Python 将浮点数3.0转换为字符串'3.0'。浮点数被转换为字符串后，保留了原有的表示形式，包括小数点。
z的值为'3.0'，类型为str。
总结：
str()函数 可以将任何类型的值转换为字符串。如果输入已经是字符串，
str()不会改变其值。如果输入是整数或浮点数，
str()会将其转换为对应的字符串形式。
实例
num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int))
print("类型转换前，num_str 数据类型为:",type(num_str))
num_str = int(num_str) # 强制转换为整型
print("类型转换后，num_str 数据类型为:",type(num_str))
num_sum = num_int + num_str
print("num_int 与 num_str 相加结果为:",num_sum)
print("sum 数据类型为:",type(num_sum))这里的关键就是
num_str = int(num_str) # 强制转换为整型使用
int()函数将字符串"456"转换为整数456。这一步将
num_str的类型从str（字符串）转换为int（整数）。
在转换后才能进行加法运算
num_sum = num_int + num_str将整数
num_int与转换后的整数num_str相加，结果是123 + 456 = 579。num_sum的值是579，它是一个整数类型的值。
总结：
字符串到整数的转换：最初
num_str是一个字符串，使用int()函数将其转换为整数。加法运算：字符串
"456"被转换为整数后，可以与另一个整数123进行加法运算。类型一致性：只有相同类型（比如两个整数）才能进行算术运算，Python 允许通过类型转换来达到这一目的。
运算结果：加法运算结果是
579，其类型为int（整数）。
-.-
评论区