Python数据类型转换详解

在Python编程中，经常需要将一种数据类型转换为另一种数据类型。数据类型转换可以是隐式的（自动发生）或显式的（使用转换函数）。本文将详细介绍Python中的数据类型转换。

一、数据类型转换概述

1. 什么是数据类型转换？

数据类型转换是指将一个数据类型的值转换为另一个数据类型的值的过程。例如，将整数转换为字符串，将列表转换为元组等。

2. 隐式转换 vs 显式转换

(1) 隐式转换（自动转换）

隐式转换是指Python解释器自动进行的数据类型转换，不需要程序员显式调用转换函数。

# 整数和浮点数相加，整数自动转换为浮点数
x = 10  # 整数

 = 3.14  # 浮点数
result = x + y
print(result)  # 13.14
print(type(result))  # <class 'float'>

# 布尔值和整数相加，布尔值自动转换为整数
True = 1，False = 0
a = True
 = 5
result = a + b
print(result)  # 6
print(type(result))  # <class 'int'>

(2) 显式转换（强制转换）

显式转换是指程序员使用Python内置的转换函数手动进行的数据类型转换。

# 将浮点数转换为整数
y = 3.14
x = int(y)
print(x)  # 3
print(type(x))  # <class 'int'>

# 将整数转换为字符串
num = 100
str_num = str(num)
print(str_num)  # "100"
print(type(str_num))  # <class 'str'>

二、常用的类型转换函数

Python提供了一系列内置函数用于数据类型转换：

函数 描述
int() 将对象转换为整数
float() 将对象转换为浮点数
complex() 将对象转换为复数
str() 将对象转换为字符串
repr() 将对象转换为表示形式字符串
bool() 将对象转换为布尔值
list() 将对象转换为列表
tuple() 将对象转换为元组
set() 将对象转换为集合
dict() 将对象转换为字典
bytes() 将对象转换为字节序列
bytearray() 将对象转换为字节数组
memoryview() 创建对象的内存视图

三、数字类型转换

1. 整数转换

(1) int()函数

int()函数用于将对象转换为整数类型。

语法： int(x=0, base=10)

  • x：要转换的对象（可选，默认为0）
  • base：进制基数（可选，默认为10）
# 将浮点数转换为整数（截断小数部分）
print(int(3.14))  # 3
print(int(-2.71))  # -2

# 将字符串转换为整数
print(int("123"))  # 123
print(int("-456"))  # -456

# 指定进制转换
print(int("1010", 2))  # 10（二进制转十进制）
print(int("0xA", 16))  # 10（十六进制转十进制）
print(int("12", 8))  # 10（八进制转十进制）

# 布尔值转换为整数
print(int(True))  # 1
print(int(False))  # 0

# 无参数时返回0
print(int())  # 0

2. 浮点数转换

(1) float()函数

float()函数用于将对象转换为浮点数类型。

语法： float(x=0.0)

  • x：要转换的对象（可选，默认为0.0）
# 将整数转换为浮点数
print(float(10))  # 10.0
print(float(-5))  # -5.0

# 将字符串转换为浮点数
print(float("3.14"))  # 3.14
print(float("-2.718"))  # -2.718
print(float("1e3"))  # 1000.0
print(float("-1.23e-4"))  # -0.000123

# 布尔值转换为浮点数
print(float(True))  # 1.0
print(float(False))  # 0.0

# 无参数时返回0.0
print(float())  # 0.0

3. 复数转换

(1) complex()函数

complex()函数用于将对象转换为复数类型。

语法： complex(real=0, imag=0)

  • real：复数的实部（可选，默认为0）
  • imag：复数的虚部（可选，默认为0）
# 创建复数
print(complex(1, 2))  # (1+2j)
print(complex(3))  # (3+0j)
print(complex(0, 4))  # 4j

# 将字符串转换为复数
print(complex("1+2j"))  # (1+2j)
print(complex("3"))  # (3+0j)
print(complex("4j"))  # 4j

# 无参数时返回0j
print(complex())  # 0j

四、字符串类型转换

1. 字符串转换

(1) str()函数

str()函数用于将对象转换为字符串类型。

语法： str(object= '')

  • object：要转换的对象（可选，默认为空字符串）
# 将整数转换为字符串
print(str(123))  # "123"
print(str(-456))  # "-456"

# 将浮点数转换为字符串
print(str(3.14))  # "3.14"
print(str(1.23e-4))  # "0.000123"

# 将布尔值转换为字符串
print(str(True))  # "True"
print(str(False))  # "False"

# 将列表转换为字符串
print(str([1, 2, 3]))  # "[1, 2, 3]"

# 将字典转换为字符串
print(str({"name": "Python", "version": 3.12}))  # "{'name': 'Python', 'version': 3.12}"

# 将None转换为字符串
print(str(None))  # "None"

(2) repr()函数

repr()函数返回一个对象的官方字符串表示形式，通常可以使用eval()函数将其转换回原始对象。

# repr() vs str()
x = "Hello, World!"
print(str(x))  # Hello, World!
print(repr(x))  # 'Hello, World!'

# repr()返回的字符串可以使用eval()转换回原始对象
y = repr(x)
print(eval(y))  # Hello, World!

# 数字类型的repr()和str()结果相同
num = 123
print(str(num))  # "123"
print(repr(num))  # "123"

五、布尔类型转换

1. 布尔值转换

(1) bool()函数

bool()函数用于将对象转换为布尔值类型。

语法： bool([x])

  • x：要转换的对象（可选，默认为False）

Python中，以下值会被转换为False：

  • 数字：0, 0.0, 0j（复数零）
  • 字符串：""（空字符串）
  • 序列：[], (), set()（空列表、空元组、空集合）
  • 映射：{}（空字典）
  • None

其他所有值都会被转换为True。

# 转换为False的值
print(bool(0))  # False
print(bool(0.0))  # False
print(bool(0j))  # False
print(bool(""))  # False
print(bool([]))  # False
print(bool(()))  # False
print(bool(set()))  # False
print(bool({}))  # False
print(bool(None))  # False

# 转换为True的值
print(bool(1))  # True
print(bool(3.14))  # True
print(bool("Hello"))  # True
print(bool([1, 2, 3]))  # True
print(bool((1, 2, 3)))  # True
print(bool({1, 2, 3}))  # True
print(bool({"name": "Python"}))  # True
print(bool("False"))  # True（非空字符串）

六、序列类型转换

1. 列表转换

(1) list()函数

list()函数用于将可迭代对象转换为列表类型。

语法： list([iterable])

  • iterable：可迭代对象（可选，默认为空列表）
# 将元组转换为列表
print(list((1, 2, 3, 4, 5)))  # [1, 2, 3, 4, 5]

# 将集合转换为列表
print(list({"apple", "banana", "orange"}))  # ['apple', 'banana', 'orange']（顺序可能不同）

# 将字典转换为列表（只包含键）
print(list({"name": "Python", "version": 3.12}))  # ['name', 'version']

# 将字符串转换为列表
print(list("Python"))  # ['P', 'y', 't', 'h', 'o', 'n']

# 将range对象转换为列表
print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 无参数时返回空列表
print(list())  # []

2. 元组转换

(1) tuple()函数

tuple()函数用于将可迭代对象转换为元组类型。

语法： tuple([iterable])

  • iterable：可迭代对象（可选，默认为空元组）
# 将列表转换为元组
print(tuple([1, 2, 3, 4, 5]))  # (1, 2, 3, 4, 5)

# 将集合转换为元组
print(tuple({"apple", "banana", "orange"}))  # ('apple', 'banana', 'orange')（顺序可能不同）

# 将字典转换为元组（只包含键）
print(tuple({"name": "Python", "version": 3.12}))  # ('name', 'version')

# 将字符串转换为元组
print(tuple("Python"))  # ('P', 'y', 't', 'h', 'o', 'n')

# 将range对象转换为元组
print(tuple(range(10)))  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# 无参数时返回空元组
print(tuple())  # ()

3. 集合转换

(1) set()函数

set()函数用于将可迭代对象转换为集合类型。集合会自动去重且元素无序。

语法： set([iterable])

  • iterable：可迭代对象（可选，默认为空集合）
# 将列表转换为集合（自动去重）
print(set([1, 2, 2, 3, 4, 4, 5]))  # {1, 2, 3, 4, 5}

# 将元组转换为集合
print(set((1, 2, 3, 4, 5)))  # {1, 2, 3, 4, 5}

# 将字典转换为集合（只包含键）
print(set({"name": "Python", "version": 3.12}))  # {'name', 'version'}

# 将字符串转换为集合
print(set("Python"))  # {'P', 'y', 't', 'h', 'o', 'n'}

# 将range对象转换为集合
print(set(range(10)))  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

# 无参数时返回空集合
print(set())  # set()

七、映射类型转换

1. 字典转换

(1) dict()函数

dict()函数用于将对象转换为字典类型。

语法： dict(**kwarg), dict(mapping, **kwarg), dict(iterable, **kwarg)

  • **kwarg：关键字参数
  • mapping：映射对象
  • iterable：可迭代对象，其中每个元素是键值对
# 使用关键字参数创建字典
print(dict(name="Python", version=3.12))  # {'name': 'Python', 'version': 3.12}

# 使用映射对象创建字典
fromkeys方法创建的字典
keys = ["name", "version", "author"]
d = dict.fromkeys(keys)
print(d)  # {'name': None, 'version': None, 'author': None}

# 使用可迭代对象创建字典
# 列表中的每个元素是一个包含两个元素的序列（键值对）
pairs = [("name", "Python"), ("version", 3.12)]
print(dict(pairs))  # {'name': 'Python', 'version': 3.12}

# 使用zip函数创建字典
keys = ["name", "version", "author"]
values = ["Python", 3.12, "Guido van Rossum"]
print(dict(zip(keys, values)))  # {'name': 'Python', 'version': 3.12, 'author': 'Guido van Rossum'}

# 无参数时返回空字典
print(dict())  # {}

八、其他类型转换

1. 字节序列转换

(1) bytes()函数

bytes()函数用于将对象转换为不可变的字节序列。

语法： bytes([source[, encoding[, errors]]])

# 将字符串转换为字节序列（需要指定编码）
print(bytes("Hello", "utf-8"))  # b'Hello'

# 将整数转换为指定长度的字节序列
print(bytes(5))  # b'\x00\x00\x00\x00\x00'（5个空字节）

# 将可迭代对象转换为字节序列
print(bytes([65, 66, 67]))  # b'ABC'（ASCII码）

(2) bytearray()函数

bytearray()函数用于将对象转换为可变的字节数组。

语法： bytearray([source[, encoding[, errors]]])

# 将字符串转换为字节数组
ba = bytearray("Hello", "utf-8")
print(ba)  # bytearray(b'Hello')

# 字节数组是可变的
ba[0] = 104  # 'h'的ASCII码
print(ba)  # bytearray(b'hello')

# 将整数转换为字节数组
print(bytearray(5))  # bytearray(b'\x00\x00\x00\x00\x00')

2. 内存视图转换

(1) memoryview()函数

memoryview()函数用于创建对象的内存视图，可以直接访问对象的内存缓冲区。

语法： memoryview(obj)

# 创建字节对象的内存视图
ba = bytearray("Hello", "utf-8")
mv = memoryview(ba)

# 修改内存视图会影响原始对象
mv[0] = 104  # 'h'的ASCII码
print(ba)  # bytearray(b'hello')

# 内存视图支持切片
print(mv[1:4])  # <memory at 0x...>
print(mv[1:4].tobytes())  # b'ell'

九、常见的类型转换组合

1. 数字与字符串之间的转换

# 数字转字符串
num = 123
str_num = str(num)
print(str_num, type(str_num))  # "123" <class 'str'>

# 字符串转数字
str_num = "123"
num = int(str_num)
print(num, type(num))  # 123 <class 'int'>

str_float = "3.14"
float_num = float(str_float)
print(float_num, type(float_num))  # 3.14 <class 'float'>

2. 列表、元组、集合之间的转换

# 列表转元组
lst = [1, 2, 3, 4, 5]
tpl = tuple(lst)
print(tpl, type(tpl))  # (1, 2, 3, 4, 5) <class 'tuple'>

# 元组转列表
tpl = (1, 2, 3, 4, 5)
lst = list(tpl)
print(lst, type(lst))  # [1, 2, 3, 4, 5] <class 'list'>

# 列表转集合（去重）
lst = [1, 2, 2, 3, 4, 4, 5]
s = set(lst)
print(s, type(s))  # {1, 2, 3, 4, 5} <class 'set'>

# 集合转列表
s = {1, 2, 3, 4, 5}
lst = list(s)
print(lst, type(lst))  # [1, 2, 3, 4, 5] <class 'list'>

3. 字符串与列表之间的转换

# 字符串转列表
str1 = "Hello"
lst1 = list(str1)
print(lst1, type(lst1))  # ['H', 'e', 'l', 'l', 'o'] <class 'list'>

# 使用split()方法分割字符串
str2 = "Hello,World,Python"
lst2 = str2.split(",")
print(lst2, type(lst2))  # ['Hello', 'World', 'Python'] <class 'list'>

# 列表转字符串
lst = ['Hello', 'World', 'Python']
str3 = ",".join(lst)
print(str3, type(str3))  # "Hello,World,Python" <class 'str'>

十、类型转换的注意事项

1. 转换失败的情况

在进行类型转换时，如果目标类型不支持源类型的值，会引发TypeError或ValueError异常。

# 字符串转整数失败（字符串包含非数字字符）
try:
    int("123abc")
except ValueError as e:
    print(f"错误：{e}")  # 错误：invalid literal for int() with base 10: '123abc'

# 将字典转换为整数（类型不支持）
try:
    int({"name": "Python"})
except TypeError as e:
    print(f"错误：{e}")  # 错误：int() argument must be a string, a bytes-like object or a real number, not 'dict'

2. 浮点数转整数的截断

使用int()函数将浮点数转换为整数时，会截断小数部分，而不是四舍五入。

print(int(3.999))  # 3
print(int(-3.999))  # -3

# 如果需要四舍五入，可以使用round()函数
print(round(3.999))  # 4
print(round(-3.999))  # -4

3. 集合转换的无序性

将列表或元组转换为集合时，集合的元素是无序的，且会自动去重。

lst = [3, 1, 4, 1, 5, 9, 2, 6, 5]
s = set(lst)
print(s)  # {1, 2, 3, 4, 5, 6, 9}（顺序可能不同）

4. 字典转换的键要求

将对象转换为字典时，键必须是不可变类型（如字符串、数字、元组）。

# 尝试使用列表作为键（会失败）
try:
    d = {[1, 2]: "value"}
except TypeError as e:
    print(f"错误：{e}")  # 错误：unhashable type: 'list'

# 使用元组作为键（可以）
d = {(1, 2): "value"}
print(d)  # {(1, 2): 'value'}

5. 字符串编码问题

在将字符串转换为字节序列时，必须指定正确的编码，否则可能会引发UnicodeEncodeError异常。

# 包含中文字符的字符串转换
try:
    bytes("你好", "ascii")
except UnicodeEncodeError as e:
    print(f"错误：{e}")  # 错误：'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

# 使用utf-8编码
b = bytes("你好", "utf-8")
print(b)  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

十一、总结

Python提供了丰富的数据类型转换函数，使程序员可以方便地在不同数据类型之间进行转换：

  1. 隐式转换：由Python解释器自动进行，无需程序员干预
  2. 显式转换：使用内置转换函数手动进行，包括：
    • 数字转换：int(), float(), complex()
    • 字符串转换：str(), repr()
    • 布尔值转换：bool()
    • 序列转换：list(), tuple(), set()
    • 映射转换：dict()
    • 其他转换：bytes(), bytearray(), memoryview()

在进行类型转换时，需要注意以下几点：

  • 转换可能会失败，需要处理异常
  • 浮点数转整数会截断小数部分
  • 集合转换会自动去重且无序
  • 字典的键必须是不可变类型
  • 字符串转换为字节序列时需要指定正确的编码

掌握Python的数据类型转换对于编写高效、灵活的代码至关重要。

发布网站：荣殿教程（zhangrongdian.com）

作者：张荣殿