Python中常见数据类型相互转换的全攻略_Python

在python编程中，数据类型转换（也称为类型转换或类型强制）是将一个数据类型转换为另一个数据类型的过程。这在数据处理、用户输入处理、文件操作和算法实现中至关重要。python提供了多种内置函数来实现显式转换，同时也支持隐式转换（自动类型提升）。以下内容将从基础数据类型回顾开始，逐步详细解释每种转换函数的使用方法、规则、示例和常见陷阱。确保代码示例清晰易懂。

python基本数据类型回顾

在深入转换前，先简要回顾python常见数据类型：

数值类型：整数（int）、浮点数（float）、布尔值（bool）、复数（complex）。
序列类型：字符串（str）、列表（list）、元组（tuple）、范围（range）。
集合类型：集合（set）、不可变集合（frozenset）。
映射类型：字典（dict）。
其他类型：字节（bytes）、字节数组（bytearray）、空值（nonetype）。
每个类型都有其特定属性和操作，转换时需遵循规则以避免错误。

内置类型转换函数详解

python提供了一系列内置函数用于显式转换。以下是主要函数的详细解释，包括输入要求、输出行为和代码示例。

int()：转换为整数

作用：将其他类型转换为整数（int）。支持从字符串、浮点数、布尔值等转换。

规则：

字符串输入必须是有效的整数表示（如 "123"），不能包含小数点或非数字字符。
浮点数输入会被截断小数部分（向下取整）。
布尔值：true 转为 1，false 转为 0。
不支持直接从非数值序列（如列表）转换。

示例代码：

# 字符串转整数
num_str = "42"
num_int = int(num_str)
print(num_int)  # 输出: 42
print(type(num_int))  # 输出: <class 'int'>

# 浮点数转整数 (截断小数)
num_float = 3.14
num_int = int(num_float)
print(num_int)  # 输出: 3

# 布尔值转整数
bool_val = true
num_int = int(bool_val)
print(num_int)  # 输出: 1

# 错误示例: 无效字符串
try:
    invalid_str = "42.5"
    num_int = int(invalid_str)  # 引发 valueerror
except valueerror as e:
    print(f"错误: {e}")  # 输出: 错误: invalid literal for int() with base 10: '42.5'

float()：转换为浮点数

作用：将其他类型转换为浮点数（float）。常用于处理小数。

规则：

字符串输入必须是有效的浮点数表示（如 "3.14" 或 "42"）。
整数输入直接转为浮点数。
布尔值：true 转为 1.0，false 转为 0.0。
不支持无效格式字符串。

示例代码：

# 字符串转浮点数
str_val = "3.14"
num_float = float(str_val)
print(num_float)  # 输出: 3.14
print(type(num_float))  # 输出: <class 'float'>

# 整数转浮点数
num_int = 42
num_float = float(num_int)
print(num_float)  # 输出: 42.0

# 布尔值转浮点数
bool_val = false
num_float = float(bool_val)
print(num_float)  # 输出: 0.0

# 错误示例: 非数字字符串
try:
    invalid_str = "hello"
    num_float = float(invalid_str)  # 引发 valueerror
except valueerror as e:
    print(f"错误: {e}")  # 输出: 错误: could not convert string to float: 'hello'

str()：转换为字符串

作用：将任何类型转换为字符串（str）。这是最通用的转换函数。

规则：

输入可以是任何对象（数值、布尔、序列等），输出是该对象的字符串表示。
对于自定义对象，默认调用 __str__() 方法；如果没有定义，则使用 __repr__()。
不会引发错误，因为所有对象都有字符串表示。

示例代码：

# 整数转字符串
num_int = 100
str_val = str(num_int)
print(str_val)  # 输出: '100'
print(type(str_val))  # 输出: <class 'str'>

# 浮点数转字符串
num_float = 3.14
str_val = str(num_float)
print(str_val)  # 输出: '3.14'

# 布尔值转字符串
bool_val = true
str_val = str(bool_val)
print(str_val)  # 输出: 'true'

# 列表转字符串
my_list = [1, 2, 3]
str_val = str(my_list)
print(str_val)  # 输出: '[1, 2, 3]'

# 自定义对象转字符串
class person:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return f"person: {self.name}"

p = person("alice")
str_val = str(p)
print(str_val)  # 输出: 'person: alice'

bool()：转换为布尔值

作用：将其他类型转换为布尔值（bool），返回 true 或 false。常用于条件判断。

规则：

假值（falsy）：以下输入转为 false：

数值零：0, 0.0
空序列："", [], (), {}, set()
none

真值（truthy）：其他所有输入转为 true。

示例代码：

# 数值转布尔
num_zero = 0
bool_val = bool(num_zero)
print(bool_val)  # 输出: false

num_nonzero = 42
bool_val = bool(num_nonzero)
print(bool_val)  # 输出: true

# 字符串转布尔
empty_str = ""
bool_val = bool(empty_str)
print(bool_val)  # 输出: false

non_empty_str = "hello"
bool_val = bool(non_empty_str)
print(bool_val)  # 输出: true

# 序列转布尔
empty_list = []
bool_val = bool(empty_list)
print(bool_val)  # 输出: false

non_empty_list = [1, 2, 3]
bool_val = bool(non_empty_list)
print(bool_val)  # 输出: true

# none 转布尔
none_val = none
bool_val = bool(none_val)
print(bool_val)  # 输出: false

list()：转换为列表

作用：将可迭代对象（如元组、字符串、集合）转换为列表（list）。

规则：

输入必须是可迭代对象（iterable）。
字符串会转为字符列表。
字典会转为键的列表。
不支持从非可迭代类型（如整数）直接转换。

示例代码：

# 元组转列表
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出: [1, 2, 3]

# 字符串转列表 (每个字符为元素)
my_str = "abc"
my_list = list(my_str)
print(my_list)  # 输出: ['a', 'b', 'c']

# 集合转列表
my_set = {4, 5, 6}
my_list = list(my_set)
print(my_list)  # 输出可能是 [4, 5, 6] (顺序不固定)

# 字典转列表 (只取键)
my_dict = {"a": 1, "b": 2}
my_list = list(my_dict)
print(my_list)  # 输出: ['a', 'b']

# 错误示例: 整数不可迭代
try:
    num_int = 42
    my_list = list(num_int)  # 引发 typeerror
except typeerror as e:
    print(f"错误: {e}")  # 输出: 错误: 'int' object is not iterable

tuple()：转换为元组

作用：将可迭代对象转换为元组（tuple）。类似 list()，但输出不可变。

规则：

输入必须是可迭代对象。
输出元组保持输入顺序。

示例代码：

# 列表转元组
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出: (1, 2, 3)

# 字符串转元组
my_str = "xyz"
my_tuple = tuple(my_str)
print(my_tuple)  # 输出: ('x', 'y', 'z')

# 集合转元组
my_set = {7, 8, 9}
my_tuple = tuple(my_set)
print(my_tuple)  # 输出可能是 (8, 9, 7) (顺序不固定)

set()：转换为集合

作用：将可迭代对象转换为集合（set），自动去重。

规则：

输入必须是可迭代对象。
输出无序且唯一元素。
不支持可变元素（如列表）直接包含。

示例代码：

# 列表转集合 (去重)
my_list = [1, 2, 2, 3]
my_set = set(my_list)
print(my_set)  # 输出: {1, 2, 3} (顺序不固定)

# 字符串转集合 (每个字符为元素)
my_str = "aabbcc"
my_set = set(my_str)
print(my_set)  # 输出: {'a', 'b', 'c'} (顺序不固定)

# 错误示例: 包含不可哈希元素
try:
    nested_list = [[1, 2], [3, 4]]
    my_set = set(nested_list)  # 引发 typeerror, 因为列表不可哈希
except typeerror as e:
    print(f"错误: {e}")  # 输出: 错误: unhashable type: 'list'

dict()：转换为字典

作用：将特定格式输入转换为字典（dict）。

规则：

输入可以是键值对序列（如列表 of tuples）、其他字典或关键字参数。
每个元素必须是可迭代的二元组（键和值）。
不支持直接从非结构化数据转换。

示例代码：

# 列表 of tuples 转字典
pairs = [("a", 1), ("b", 2)]
my_dict = dict(pairs)
print(my_dict)  # 输出: {'a': 1, 'b': 2}

# 关键字参数转字典
my_dict = dict(a=1, b=2)
print(my_dict)  # 输出: {'a': 1, 'b': 2}

# 错误示例: 无效输入格式
try:
    invalid_input = [1, 2, 3]
    my_dict = dict(invalid_input)  # 引发 valueerror, 因为元素不是二元组
except valueerror as e:
    print(f"错误: {e}")  # 输出: 错误: dictionary update sequence element #0 has length 1; 2 is required

其他转换函数

complex(real, imag)：创建复数，例如 complex(3, 4) 输出 (3+4j)。
bytes(source, encoding)：转换为字节序列，例如 bytes("hello", "utf-8")。
bytearray(source, encoding)：类似 bytes，但可变。
chr(int)：整数转 unicode 字符，例如 chr(65) 输出 'a'。
ord(char)：字符转整数编码，例如 ord('a') 输出 65。
bin(int)、hex(int)、oct(int)：整数转二进制、十六进制、八进制字符串，例如 bin(10) 输出 '0b1010'。

隐式类型转换

在表达式中，python会自动执行隐式转换（类型提升），例如：

数值运算：整数和浮点数混合时，结果转为浮点数。

result = 3 + 4.5  # 隐式转换为 float, 输出 7.5

布尔上下文：在 if 或 while 中，非布尔值自动转为布尔值。

if "non-empty":  # 隐式 bool("non-empty") 为 true
    print("执行")

规则基于操作优先级：整数 → 浮点数 → 复数。

常见陷阱与最佳实践

错误处理：转换可能引发 valueerror（无效输入）或 typeerror（不支持类型）。使用 try-except 块处理异常。

try:
    num = int("123a")
except valueerror:
    num = 0  # 默认值

数据丢失：浮点数转整数时截断小数；集合转换时丢失顺序和重复项。

性能考虑：频繁转换大型对象（如列表到集合）可能影响效率。

最佳实践：

显式转换优于隐式，提高代码可读性。
验证输入数据格式（如用 isinstance() 检查类型）。
在文件 i/o 中，优先使用 str() 和 int()/float() 处理文本数据。
对于自定义对象，实现 __int__() 或 __float__() 方法支持转换。

完整代码

# ==============================
# python 全类型互相转换 完整示例
# ==============================

# ------------------------------
# 1. 基础数值类型：int / float / bool
# ------------------------------
print("========== 1. 数值 & 布尔转换 ==========")

# int → float
a = 10
f1 = float(a)
print("int→float:", f1, type(f1))

# float → int (直接截断小数)
b = 3.99
i1 = int(b)
print("float→int:", i1, type(i1))

# 数值 → bool
print("0→bool:", bool(0))
print("非0→bool:", bool(123))
print("0.0→bool:", bool(0.0))
print("空字符串→bool:", bool(""))

# bool → int / float
print("true→int:", int(true))
print("false→float:", float(false))

print("-" * 50)

# ------------------------------
# 2. 字符串 str 互相转换
# ------------------------------
print("========== 2. 字符串 str 转换 ==========")

# 数值 → str
s1 = str(123)
s2 = str(3.14)
s3 = str(true)
print("int→str:", s1, type(s1))
print("float→str:", s2)
print("bool→str:", s3)

# 纯数字 str → int / float
num1 = int("666")
num2 = float("99.99")
print("str→int:", num1)
print("str→float:", num2)

# 进制字符串转整数
print("二进制字符串转int:", int("1011", 2))
print("十六进制字符串转int:", int("ff", 16))

print("-" * 50)

# ------------------------------
# 3. str 与 bytes / bytearray 转换
# ------------------------------
print("========== 3. str <-> 字节类型 ==========")

text = "你好python"

# str → bytes 编码
b_text = text.encode("utf-8")
print("str→bytes:", b_text, type(b_text))

# bytes → str 解码
res_text = b_text.decode("utf-8")
print("bytes→str:", res_text)

# str → bytearray
ba_text = bytearray(text, "utf-8")
print("str→bytearray:", ba_text)

# bytearray → str
res2 = ba_text.decode("utf-8")
print("bytearray→str:", res2)

# bytes <-> bytearray
ba = bytearray(b"abcd")
b = bytes(ba)
print("bytearray→bytes:", b)

print("-" * 50)

# ------------------------------
# 4. 列表 list / 元组 tuple 互转
# ------------------------------
print("========== 4. list <-> tuple ==========")

lst = [1, 2, 3, 4]
tup = (10, 20, 30)

# list → tuple
t1 = tuple(lst)
print("list→tuple:", t1)

# tuple → list
l1 = list(tup)
print("tuple→list:", l1)

# 字符串 → 列表/元组（拆分成单个字符）
print("str→list:", list("hello"))
print("str→tuple:", tuple("hello"))

print("-" * 50)

# ------------------------------
# 5. 集合 set 转换
# ------------------------------
print("========== 5. set 集合转换 ==========")

# list / tuple / str → set (自动去重)
lst2 = [1, 2, 2, 3, 3]
s1 = set(lst2)
s2 = set((5, 5, 6))
s3 = set("aabbcc")

print("list→set:", s1)
print("tuple→set:", s2)
print("str→set:", s3)

# set → list / tuple
lst3 = list(s1)
tup3 = tuple(s1)
print("set→list:", lst3)
print("set→tuple:", tup3)

print("-" * 50)

# ------------------------------
# 6. 字典 dict 转换
# ------------------------------
print("========== 6. dict 字典转换 ==========")

# 二元组列表 → dict
item_list = [("name", "张三"), ("age", 20)]
d1 = dict(item_list)
print("列表→dict:", d1)

# dict → 列表 / 元组
keys = list(d1.keys())
vals = tuple(d1.values())
items = list(d1.items())
print("dict键→list:", keys)
print("dict值→tuple:", vals)
print("dict键值对→list:", items)

print("-" * 50)

# ------------------------------
# 7. array 数组 转换
# ------------------------------
print("========== 7. array 数组转换 ==========")
from array import array

# list → array
arr = array("i", [100, 200, 300])
print("list→array:", arr)

# array → list / tuple
arr_list = arr.tolist()
arr_tup = tuple(arr)
print("array→list:", arr_list)
print("array→tuple:", arr_tup)

print("-" * 50)

# ------------------------------
# 8. 错误转换示例（必看避坑）
# ------------------------------
print("========== 8. 非法转换报错示例 ==========")
try:
    # 非纯数字字符串不能转int
    int("abc123")
except valueerror as e:
    print("错误：非数字字符串转int失败")

try:
    # 多层容器不能直接转
    float([1, 2])
except typeerror as e:
    print("错误：容器类型不能直接转数值")

运行结果：

"d:\user\01417804\桌面\新建文件夹 (2)\.venv\scripts\python.exe" "d:\user\01417804\桌面\新建文件夹 (2)\main.py"
========== 1. 数值 & 布尔转换 ==========
int→float: 10.0 <class 'float'>
float→int: 3 <class 'int'>
0→bool: false
非0→bool: true
0.0→bool: false
空字符串→bool: false
true→int: 1
false→float: 0.0
--------------------------------------------------
========== 2. 字符串 str 转换 ==========
int→str: 123 <class 'str'>
float→str: 3.14
bool→str: true
str→int: 666
str→float: 99.99
二进制字符串转int: 11
十六进制字符串转int: 255
--------------------------------------------------
========== 3. str <-> 字节类型 ==========
str→bytes: b'\xe4\xbd\xa0\xe5\xa5\xbdpython' <class 'bytes'>
bytes→str: 你好python
str→bytearray: bytearray(b'\xe4\xbd\xa0\xe5\xa5\xbdpython')
bytearray→str: 你好python
bytearray→bytes: b'abcd'
--------------------------------------------------
========== 4. list <-> tuple ==========
list→tuple: (1, 2, 3, 4)
tuple→list: [10, 20, 30]
str→list: ['h', 'e', 'l', 'l', 'o']
str→tuple: ('h', 'e', 'l', 'l', 'o')
--------------------------------------------------
========== 5. set 集合转换 ==========
list→set: {1, 2, 3}
tuple→set: {5, 6}
str→set: {'b', 'a', 'c'}
set→list: [1, 2, 3]
set→tuple: (1, 2, 3)
--------------------------------------------------
========== 6. dict 字典转换 ==========
列表→dict: {'name': '张三', 'age': 20}
dict键→list: ['name', 'age']
dict值→tuple: ('张三', 20)
dict键值对→list: [('name', '张三'), ('age', 20)]
--------------------------------------------------
========== 7. array 数组转换 ==========
list→array: array('i', [100, 200, 300])
array→list: [100, 200, 300]
array→tuple: (100, 200, 300)
--------------------------------------------------
========== 8. 非法转换报错示例 ==========
错误：非数字字符串转int失败
错误：容器类型不能直接转数值

进程已结束，退出代码为 0