14 数据类型转换大全

1、基本数值转换：

• int(): 转整数（截断）

• float(): 转浮点数

• complex(): 转复数

2、字符串转换：

• str(): 万能转字符串

• repr(): 显示对象的规范字符串表示

3、序列转换：

• list(): 转可变列表
• tuple(): 转不可变元组

• set(): 转集合（自动去重）

4、字典转换：

• dict(): 从键值对创建字典

• zip(): 配合dict()使用

"""
Python数据类型转换详解
目的：展示Python中常见的数据类型转换方法和注意事项
"""


def numeric_conversion():
    print("1. 数值类型转换")
    print("-" * 50)

    # 1.1 整数转换
    print("1.1 转换为整数(int)：")
    print("-" * 30)

    # 浮点数转整数：直接截断小数部分，不会四舍五入
    print(f"float -> int: {int(3.14)} ← 直接截断")
    print(f"float -> int: {int(-3.14)} ← 负数也是截断")

    # 字符串转整数：必须是有效的数字字符串
    print(f"str -> int: {int('123')} ← 普通数字字符串")
    print(f"str -> int: {int('0b1111', 2)} ← 二进制字符串")
    print(f"str -> int: {int('0o77', 8)} ← 八进制字符串")
    print(f"str -> int: {int('0xff', 16)} ← 十六进制字符串")

    # 布尔值转整数
    print(f"bool -> int: True = {int(True)}, False = {int(False)}")


def float_conversion():
    print("\n2. 浮点数转换")
    print("-" * 50)

    # 2.1 转换为浮点数(float)
    print("2.1 转换为浮点数：")
    print("-" * 30)

    # 整数转浮点数
    print(f"int -> float: {float(123)} ← 添加小数点")

    # 字符串转浮点数
    print(f"str -> float: {float('3.14')} ← 普通浮点数字符串")
    print(f"str -> float: {float('3.14e-2')} ← 科学计数法字符串")

    # 布尔值转浮点数
    print(f"bool -> float: True = {float(True)}, False = {float(False)}")


def string_conversion():
    print("\n3. 字符串转换")
    print("-" * 50)

    # 3.1 转换为字符串(str)
    print("3.1 转换为字符串：")
    print("-" * 30)

    # 几乎所有类型都可以转换为字符串
    num = 123
    pi = 3.14
    boolean = True
    lst = [1, 2, 3]
    tup = (4, 5, 6)
    st = {7, 8, 9}
    dic = {"a": 1, "b": 2}

    # 使用str()函数转换
    print(f"int -> str: {str(num)} ← 整数转字符串")
    print(f"float -> str: {str(pi)} ← 浮点数转字符串")
    print(f"bool -> str: {str(boolean)} ← 布尔值转字符串")
    print(f"list -> str: {str(lst)} ← 列表转字符串")
    print(f"tuple -> str: {str(tup)} ← 元组转字符串")
    print(f"set -> str: {str(st)} ← 集合转字符串")
    print(f"dict -> str: {str(dic)} ← 字典转字符串")


def list_conversion():
    print("\n4. 列表转换")
    print("-" * 50)

    # 4.1 转换为列表(list)
    print("4.1 转换为列表：")
    print("-" * 30)

    # 字符串转列表：每个字符成为一个元素
    text = "Python"
    print(f"str -> list: {list(text)} ← 字符串转列表")

    # 元组转列表
    tup = (1, 2, 3)
    print(f"tuple -> list: {list(tup)} ← 元组转列表")

    # 集合转列表
    st = {4, 5, 6}
    print(f"set -> list: {list(st)} ← 集合转列表")

    # 字典转列表：获取所有键
    dic = {"a": 1, "b": 2}
    print(f"dict -> list: {list(dic)} ← 字典转列表(获取键)")


def tuple_set_conversion():
    print("\n5. 元组和集合转换")
    print("-" * 50)

    # 5.1 转换为元组(tuple)
    print("5.1 转换为元组：")
    print("-" * 30)

    # 列表转元组
    lst = [1, 2, 3]
    print(f"list -> tuple: {tuple(lst)} ← 列表转元组")

    # 字符串转元组
    text = "Python"
    print(f"str -> tuple: {tuple(text)} ← 字符串转元组")

    # 5.2 转换为集合(set)
    print("\n5.2 转换为集合：")
    print("-" * 30)

    # 列表转集合：自动去重
    lst = [1, 2, 2, 3, 3, 3]
    print(f"list -> set: {set(lst)} ← 列表转集合(去重)")

    # 字符串转集合：字符去重
    text = "hello"
    print(f"str -> set: {set(text)} ← 字符串转集合(去重)")


def dict_conversion():
    print("\n6. 字典转换")
    print("-" * 50)

    # 6.1 转换为字典(dict)
    print("6.1 转换为字典：")
    print("-" * 30)

    # 二元组列表转字典
    pairs = [("a", 1), ("b", 2)]
    print(f"list -> dict: {dict(pairs)} ← 二元组列表转字典")

    # 关键字参数转字典
    print(
        f"keywords -> dict: {dict(a=1, b=2)} ← 关键字参数转字典"
    )  # 关键字参数转字典,a=1,b=2,将a,b作为键,1,2作为值,转换成字典

    # 两个列表转字典（使用zip）
    keys = ["a", "b", "c"]
    values = [1, 2, 3]
    print(
        f"zip -> dict: {dict(zip(keys, values))} ← 两个列表转字典"
    )  # 两个列表转字典,zip函数将两个列表合并成一个二元组列表


def type_checking():
    print("\n7. 类型检查技巧")
    print("-" * 50)

    # 7.1 类型检查方法
    print("7.1 检查数据类型：")
    print("-" * 30)

    value = "123"
    print(f"变量值: {value}")
    print(f"type(): {type(value)} ← 获取类型")
    print(
        f"isinstance(): {isinstance(value, str)} ← 检查是否是字符串"
    )  # 检查变量value是否是字符串类型

    # 7.2 类型转换异常处理
    print("\n7.2 安全的类型转换：")
    print("-" * 30)

    def safe_int_convert(value):
        try:
            return (
                int(value),
                True,
            )  # 将变量value转换为整数,如果转换成功,返回True,否则返回False
        except (ValueError, TypeError):
            return None, False  # 如果转换失败,返回None,False

    tests = ["123", "12.34", "abc", None]
    for test in tests:
        result, success = safe_int_convert(test)
        print(f"转换 {test}: {'成功 = ' + str(result) if success else '失败'}")


def conversion_tips():
    print("\n8. 转换技巧总结")
    print("-" * 50)
    print("1) 数值转换：")
    print("   - int()：截断小数部分")
    print("   - float()：添加小数点")
    print("   - round()：四舍五入")

    print("\n2) 字符串转换：")
    print("   - str()：几乎可转换所有类型")
    print("   - f-string：格式化转换")

    print("\n3) 容器类型转换：")
    print("   - list()：转换为可变序列")
    print("   - tuple()：转换为不可变序列")
    print("   - set()：转换并去重")

    print("\n4) 注意事项：")
    print("   - 总是检查输入类型")
    print("   - 使用异常处理保护转换")
    print("   - 注意数据精度和范围")


if __name__ == "__main__":
    numeric_conversion()
    float_conversion()
    string_conversion()
    list_conversion()
    tuple_set_conversion()
    dict_conversion()
    type_checking()
    conversion_tips()

1. 数值类型转换
--------------------------------------------------
1.1 转换为整数(int)：
------------------------------
float -> int: 3 ← 直接截断
float -> int: -3 ← 负数也是截断
str -> int: 123 ← 普通数字字符串
str -> int: 15 ← 二进制字符串
str -> int: 63 ← 八进制字符串
str -> int: 255 ← 十六进制字符串
bool -> int: True = 1, False = 0

2. 浮点数转换
--------------------------------------------------
2.1 转换为浮点数：
------------------------------
int -> float: 123.0 ← 添加小数点
str -> float: 3.14 ← 普通浮点数字符串
str -> float: 0.0314 ← 科学计数法字符串
bool -> float: True = 1.0, False = 0.0

3. 字符串转换
--------------------------------------------------
3.1 转换为字符串：
------------------------------
int -> str: 123 ← 整数转字符串
float -> str: 3.14 ← 浮点数转字符串
bool -> str: True ← 布尔值转字符串
list -> str: [1, 2, 3] ← 列表转字符串
tuple -> str: (4, 5, 6) ← 元组转字符串
set -> str: {8, 9, 7} ← 集合转字符串
dict -> str: {'a': 1, 'b': 2} ← 字典转字符串

4. 列表转换
--------------------------------------------------
4.1 转换为列表：
------------------------------
str -> list: ['P', 'y', 't', 'h', 'o', 'n'] ← 字符串转列表
tuple -> list: [1, 2, 3] ← 元组转列表
set -> list: [4, 5, 6] ← 集合转列表
dict -> list: ['a', 'b'] ← 字典转列表(获取键)

5. 元组和集合转换
--------------------------------------------------
5.1 转换为元组：
------------------------------
list -> tuple: (1, 2, 3) ← 列表转元组
str -> tuple: ('P', 'y', 't', 'h', 'o', 'n') ← 字符串转元组

5.2 转换为集合：
------------------------------
list -> set: {1, 2, 3} ← 列表转集合(去重)
str -> set: {'l', 'o', 'e', 'h'} ← 字符串转集合(去重)

6. 字典转换
--------------------------------------------------
6.1 转换为字典：
------------------------------
list -> dict: {'a': 1, 'b': 2} ← 二元组列表转字典
keywords -> dict: {'a': 1, 'b': 2} ← 关键字参数转字典
zip -> dict: {'a': 1, 'b': 2, 'c': 3} ← 两个列表转字典

7. 类型检查技巧
--------------------------------------------------
7.1 检查数据类型：
------------------------------
变量值: 123
type(): <class 'str'> ← 获取类型
isinstance(): True ← 检查是否是字符串

7.2 安全的类型转换：
------------------------------
转换 123: 成功 = 123
转换 12.34: 失败
转换 abc: 失败
转换 None: 失败

8. 转换技巧总结
--------------------------------------------------
1) 数值转换：
   - int()：截断小数部分
   - float()：添加小数点
   - round()：四舍五入

2) 字符串转换：
   - str()：几乎可转换所有类型
   - f-string：格式化转换

3) 容器类型转换：
   - list()：转换为可变序列
   - tuple()：转换为不可变序列
   - set()：转换并去重

4) 注意事项：
   - 总是检查输入类型
   - 使用异常处理保护转换
   - 注意数据精度和范围