程序员scholar
scholar
2025-07-20
目录

数据类型转换

# 数据类型转换

在 Python 编程中，我们经常需要在不同的数据类型之间进行转换，以满足不同的计算和操作需求。例如，将从用户输入中获取的字符串数字转换为整数进行计算，或者将列表转换为集合以快速去重。理解并熟练掌握数据类型转换是编写灵活、健壮代码的基础。

# 1. 核心转换函数概览

Python 提供了一系列内置函数，可以轻松地在各种数据类型之间进行转换。

函数名 功能描述
int(x) 将 x 转换为一个整数。
float(x) 将 x 转换为一个浮点数。
str(x) 将对象 x 转换为字符串。
list(s) 将序列 s（如字符串、元组、集合）转换为列表。
tuple(s) 将序列 s（如字符串、列表、集合）转换为元组。
set(s) 将序列 s（如字符串、列表、元组）转换为集合。
dict(d) 创建一个字典。d 必须是一个键值对序列。
bool(x) 将 x 转换为布尔值 (True 或 False)。

# 2. 数字类型转换

数字类型之间的转换主要涉及整数、浮点数和布尔值。

# 2.1 转换为整数 int()

  • 浮点数转整数: 小数部分会被直接截断（非四舍五入）。
    float_num = 9.99
int_num = int(float_num)
print(f"{float_num} 转换为整数是: {int_num}") # 输出: 9.99 转换为整数是: 9
    1
    2
    3
  • 布尔值转整数: True 变为 1，False 变为 0。
    print(f"True 转换为整数是: {int(True)}")   # 输出: True 转换为整数是: 1
print(f"False 转换为整数是: {int(False)}")  # 输出: False 转换为整数是: 0
    1
    2
  • 数字字符串转整数: 字符串内容必须是纯整型数字。
    str_int = "123"
result = int(str_int)
print(f"字符串 '{str_int}' 转换为整数是: {result}") # 输出: 字符串 '123' 转换为整数是: 123
    1
    2
    3

# 2.2 转换为浮点数 float()

  • 整数转浮点数: 直接在末尾添加 .0。
    int_val = 100
float_val = float(int_val)
print(f"{int_val} 转换为浮点数是: {float_val}") # 输出: 100 转换为浮点数是: 100.0
    1
    2
    3
  • 数字字符串转浮点数: 字符串内容必须是有效的数字格式。
    str_float = "3.14159"
result = float(str_float)
print(f"字符串 '{str_float}' 转换为浮点数是: {result}") # 输出: 字符串 '3.14159' 转换为浮点数是: 3.14159
    1
    2
    3

# 2.3 转换为布尔值 bool()

在 Python 中，任何非零数字和非空对象都会被转换为 True，而 0、None 和所有空对象（如 "", [], (), {}) 都会被转换为 False。

print(f"1 转换为布尔值: {bool(1)}")         # 输出: True
print(f"-1 转换为布尔值: {bool(-1)}")        # 输出: True
print(f"0 转换为布尔值: {bool(0)}")         # 输出: False

print(f"'hello' 转换为布尔值: {bool('hello')}") # 输出: True
print(f"'' 转换为布尔值: {bool('')}")         # 输出: False

print(f"[1, 2] 转换为布尔值: {bool([1, 2])}") # 输出: True
print(f"[] 转换为布尔值: {bool([])}")       # 输出: False
1
2
3
4
5
6
7
8
9

# 3. 字符串与其他序列的转换

字符串可以被看作是字符的序列，因此可以方便地与列表、元组等序列类型进行转换。

# 3.1 序列转换为字符串 str.join()

使用字符串的 join() 方法可以将一个包含字符串元素的可迭代对象（如列表、元组）连接成一个单一的字符串。

# 列表转字符串
words_list = ["Python", "is", "awesome"]
sentence = " ".join(words_list)  # 使用空格作为分隔符
print(f"列表连接成的字符串: '{sentence}'") # 输出: 'Python is awesome'

# 元组转字符串
chars_tuple = ('P', 'Y', 'T', 'H', 'O', 'N')
word = "".join(chars_tuple) # 不使用任何分隔符
print(f"元组连接成的字符串: '{word}'")   # 输出: 'PYTHON'
1
2
3
4
5
6
7
8
9

# 3.2 字符串转换为序列 list() 和 tuple()

  • 字符串转列表: 字符串中的每个字符都会成为列表的一个独立元素。
    greeting = "Hello"
char_list = list(greeting)
print(f"'{greeting}' 转换为列表: {char_list}") # 输出: ['H', 'e', 'l', 'l', 'o']
    1
    2
    3
  • 字符串转元组: 与转列表类似。
    char_tuple = tuple(greeting)
print(f"'{greeting}' 转换为元组: {char_tuple}") # 输出: ('H', 'e', 'l', 'l', 'o')
    1
    2

# 4. 列表、元组、集合的相互转换

这三种序列类型可以非常方便地相互转换。

# 4.1 转换为列表 list()

# 元组转列表
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(f"{my_tuple} 转换为列表: {my_list}") # 输出: [1, 2, 3]

# 集合转列表（注意：集合是无序的，所以转换后的列表顺序不固定）
my_set = {'apple', 'banana', 'cherry'}
fruit_list = list(my_set)
print(f"{my_set} 转换为列表: {fruit_list}") # 输出可能是 ['cherry', 'apple', 'banana']
1
2
3
4
5
6
7
8
9

# 4.2 转换为元组 tuple()

# 列表转元组
my_list = [1, 'a', True]
my_tuple = tuple(my_list)
print(f"{my_list} 转换为元组: {my_tuple}") # 输出: (1, 'a', True)
1
2
3
4

# 4.3 转换为集合 set()

转换为集合的最大特点是 自动去重。

# 列表转集合（去重）
numbers = [1, 2, 2, 3, 4, 3, 5]
unique_numbers = set(numbers)
print(f"{numbers} 转换为集合后: {unique_numbers}") # 输出: {1, 2, 3, 4, 5}
1
2
3
4

# 5. 字典相关的转换

字典的转换相对特殊，通常涉及其键、值或键值对。

# 5.1 从字典到其他类型

person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 获取所有键
keys_list = list(person.keys())
print(f"字典的键转为列表: {keys_list}") # 输出: ['name', 'age', 'city']

# 获取所有值
values_tuple = tuple(person.values())
print(f"字典的值转为元组: {values_tuple}") # 输出: ('Alice', 30, 'New York')

# 获取所有键值对（项）
items_list = list(person.items())
print(f"字典的项转为列表: {items_list}") # 输出: [('name', 'Alice'), ('age', 30), ('city', 'New York')]
1
2
3
4
5
6
7
8
9
10
11
12
13

# 5.2 从其他类型到字典 dict()

要创建一个字典，你需要提供一个可迭代对象，其中每个元素本身都是一个包含两个元素（键和值）的序列（如列表或元组）。

# 从元组列表创建字典
data = [('name', 'Bob'), ('age', 25)]
person_dict = dict(data)
print(f"{data} 转换为字典: {person_dict}") # 输出: {'name': 'Bob', 'age': 25}

# 从键列表和值列表创建字典 (使用 zip)
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
print(f"使用 zip 创建字典: {my_dict}") # 输出: {'a': 1, 'b': 2, 'c': 3}
1
2
3
4
5
6
7
8
9
10

# 6. 高级技巧：使用 map() 进行批量转换

当你需要对一个序列中的所有元素应用同一种类型转换时，map() 函数非常有用。

# 字符串数字列表 -> 整数列表
str_numbers = ["1", "2", "3", "4", "5"]
int_numbers = list(map(int, str_numbers))
print(f"使用 map 将 {str_numbers} 转换为: {int_numbers}") # 输出: [1, 2, 3, 4, 5]

# 混合类型列表 -> 字符串列表
mixed_data = ["apple", 100, 3.14, True]
str_data = list(map(str, mixed_data))
print(f"使用 map 将混合列表转换为字符串列表: {str_data}") # 输出: ['apple', '100', '3.14', 'True']
1
2
3
4
5
6
7
8
9

# 7. 转换中的常见陷阱与注意事项

  1. ValueError 转换失败: 当转换的格式不正确时，会引发 ValueError。

    # int("hello") # 会引发 ValueError: invalid literal for int() with base 10: 'hello'
# float("3.14a") # 会引发 ValueError: could not convert string to float: '3.14a'
    1
    2

  2. 精度损失: 浮点数转整数会直接丢弃小数部分。

    price = 199.99
int_price = int(price)
print(f"价格 {price} 取整后为 {int_price}，小数部分丢失。") # 输出: 199
    1
    2
    3

  3. 数据去重: 将有重复元素的列表或元组转换为集合时，重复项会自动消失。

    tags = ['python', 'web', 'python', 'data']
unique_tags = set(tags)
print(f"标签列表 {tags} 去重后为 {unique_tags}。") # 输出: {'web', 'python', 'data'}
    1
    2
    3

  4. join() 的要求: str.join() 方法要求其参数（可迭代对象）中的所有元素都必须是字符串。

    data = ["年份", 2023]
# " ".join(data) # 会引发 TypeError: sequence item 1: expected str instance, int found
# 正确做法是先用 map 将所有元素转为字符串
correct_str = " ".join(map(str, data))
print(f"正确连接混合类型列表: '{correct_str}'") # 输出: '年份 2023'
    1
    2
    3
    4
    5
编辑此页 (opens new window)
上次更新: 2025/07/23, 06:33:16
数据类型
运算符

← 运算符→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar