【数据类及相互转化知识点总结】-优快云博客

类别	数据类型	可变性	示例
基础类型	`int`, `float`, `bool`	不可变	`5`, `3.14`, `True`
	`str`, `NoneType`	不可变	`"hello"`, `None`
容器类型	`list`, `set`, `dict`	可变	`[1, 2]`, `{1, 2}`, `{"a": 1}`
	`tuple`, `frozenset`	不可变	`(1, 2)`, `frozenset({1, 2})`
其他类型	`bytes`, `bytearray`	`bytes`不可变，`bytearray`可变	`b"abc"`, `bytearray(b"xyz")`

二、基础数据类型详解

1. 数值类型

(1) 整数 (`int`)

特点：支持任意精度，无大小限制

操作：

a = 10
b = 0b1010  # 二进制 (10)
c = 0o12    # 八进制 (10)
d = 0xA     # 十六进制 (10)
print(a + b)  # 输出: 20

(2) 浮点数 (`float`)

特点：双精度浮点，存在精度误差

陷阱：

print(0.1 + 0.2 == 0.3)  # False → 实际值: 0.30000000000000004

(3) 布尔 (`bool`)

本质：True (1) 和 False (0) 是 int 的子类
```
print(True + 1)  # 输出: 2
```

2. 字符串 (`str`)

(1) 基本操作

s = "Python"
print(s[0])        # 'P' → 索引访问（不可修改）
print(s[2:4])      # 'th' → 切片
print("Py" in s)   # True → 成员检查

(2) 格式化方法

name = "Alice"
age = 30
# f-string (Python 3.6+)
print(f"{name} is {age} years old")  # Alice is 30 years old

三、容器数据类型详解

1. 列表 (`list`)

(1) 核心操作

lst = [1, 2, 3]
lst.append(4)       # [1, 2, 3, 4]
lst.insert(1, 5)    # [1, 5, 2, 3, 4]
lst.remove(5)       # [1, 2, 3, 4]
print(lst[-1])      # 4 → 负索引

(2) 列表推导式

squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

2. 元组 (`tuple`)

不可变性：元素不可修改，但可包含可变对象

t = (1, [2, 3])
t[1].append(4)      # 允许 → t = (1, [2, 3, 4])
# t[0] = 5         # 报错: TypeError

3. 字典 (`dict`)

(1) 基本操作

d = {"name": "Bob", "age": 25}
print(d.get("name"))       # Bob
d["age"] = 26             # 修改值
d["city"] = "Paris"       # 新增键值对

(2) 字典推导式

square_dict = {x: x**2 for x in range(3)}  # {0:0, 1:1, 2:4}

4. 集合 (`set`)

特性：无序、元素唯一、高效成员检测

s = {1, 2, 2, 3}
print(s)          # {1, 2, 3} → 自动去重
print(2 in s)     # True → O(1) 时间复杂度

四、可变 vs 不可变类型

1. 不可变类型 (`int`, `str`, `tuple` 等)

修改行为：实际创建新对象

a = "hello"
b = a          # a 和 b 指向同一对象
a += " world"  # 创建新对象，a 指向新地址
print(b)       # 输出: hello

2. 可变类型 (`list`, `dict`, `set` 等)

原地修改：所有引用同步变化

lst1 = [1, 2]
lst2 = lst1
lst1.append(3)
print(lst2)     # [1, 2, 3]

五、类型转换与检查

1. 显式类型转换

print(int("42"))        # 42
print(str(3.14))        # '3.14'
print(list("abc"))      # ['a', 'b', 'c']
print(tuple([1, 2]))    # (1, 2)

2. 隐式类型转换（自动提升）

result = 5 + 3.14       # int → float → 8.14
print(type(result))     # <class 'float'>

3. 类型检查

print(isinstance(5, int))      # True
print(type("text") is str)     # True

六、高级数据类型

1. 字节序列 (`bytes` 和 `bytearray`)

b = b"hello"            # 不可变字节序列
ba = bytearray(b)       # 可变字节数组
ba[0] = 72              # 修改为 ASCII 'H'
print(ba)               # bytearray(b'Hello')

2. `NoneType`

用途：表示空值或缺失

def func():
    pass            # 默认返回 None

print(func())       # None

3. 枚举 (`Enum`) (Python 3.4+)

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2

print(Color.RED)        # Color.RED

七、注意事项与最佳实践

避免浮点数精度问题
使用 decimal 模块处理精确计算：

from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2') == Decimal('0.3'))  # True

浅拷贝与深拷贝

import copy
lst = [1, [2, 3]]
shallow = copy.copy(lst)    # 浅拷贝：嵌套列表仍共享
deep = copy.deepcopy(lst)   # 深拷贝：完全独立

字典键的限制
键必须是不可变类型（如 int, str, tuple）：

valid_key = {(1, 2): "value"}  # 合法
# invalid_key = {[1, 2]: "value"}  # 报错

内存管理
循环引用可能导致内存泄漏，可用 weakref 模块处理：

import weakref

class Node:
    pass

a = Node()
b = Node()
a.ref = weakref.ref(b)  # 弱引用避免循环引用

八、数据类型应用场景总结

数据类型	典型应用场景	优势
`list`	动态数据集合、有序操作	灵活增删改查
`tuple`	不可变数据记录、函数多返回值	安全、哈希可用作字典键
`dict`	键值映射、快速查找	O(1) 时间复杂度查询
`set`	去重、集合运算（交集、并集）	高效成员检测
`str`	文本处理、正则表达式操作	丰富的字符串方法
`bytes`	二进制文件/网络数据传输	精确控制字节数据

掌握这些知识点后，您将能够：

根据需求选择最优数据类型
避免因类型错误导致的常见 Bug
编写高效且易维护的 Python 代码

Python 数据类型相互转换总结

Python 提供了灵活的类型转换机制，允许在不同数据类型之间按需转换。以下是常见数据类型转换方法、示例及注意事项：

一、基础类型转换

目标类型	转换函数	示例代码	输出结果	注意事项
整数	`int()`	`int("42")`	`42`	字符串必须为整数格式，否则抛出 `ValueError`
		`int(3.99)`	`3`	浮点数转换会截断小数部分
		`int(True)`	`1`	`True` 转 `1`，`False` 转 `0`
浮点	`float()`	`float("3.14")`	`3.14`	字符串可为整数或浮点格式
		`float(5)`	`5.0`	整数转浮点自动补 `.0`
布尔	`bool()`	`bool(0)`	`False`	非零数值、非空容器/字符串为 `True`
		`bool("Hello")`	`True`	空字符串 `""` 转 `False`
字符串	`str()`	`str(100)`	`"100"`	所有类型均可转为字符串
		`str([1, 2])`	`"[1, 2]"`	容器转字符串保留原始结构（如 `"[1, 2]"`）

二、容器类型转换

目标类型	转换函数	示例代码	输出结果	注意事项
列表	`list()`	`list("abc")`	`['a', 'b', 'c']`	字符串按字符拆分，字典转列表仅保留键
		`list((1, 2))`	`[1, 2]`	元组转列表
元组	`tuple()`	`tuple([1, 2])`	`(1, 2)`	列表转元组
集合	`set()`	`set([1, 2, 2])`	`{1, 2}`	自动去重，顺序丢失
字典	`dict()`	`dict([('a', 1), ('b', 2)])`	`{'a': 1, 'b': 2}`	需传入可迭代的键值对（如元组列表）
		`dict(zip(['a', 'b'], [1, 2]))`	`{'a':1, 'b':2}`	常用 `zip` 组合键列表和值列表

三、字符串与容器互转

1. 字符串 ↔ 列表

# 字符串 → 列表（按分隔符拆分）
s = "apple,banana,orange"
lst = s.split(",")  # ['apple', 'banana', 'orange']

# 列表 → 字符串（按分隔符合并）
new_s = "-".join(lst)  # 'apple-banana-orange'

2. 字符串 ↔ 字典（需特定格式）

# JSON 格式字符串 → 字典
import json
s = '{"name": "Alice", "age": 30}'
dct = json.loads(s)  # {'name': 'Alice', 'age': 30}

# 字典 → 字符串
new_s = json.dumps(dct)  # '{"name": "Alice", "age": 30}'

四、进制与编码转换

1. 进制转换

# 十进制 → 二进制/八进制/十六进制字符串
bin(10)   # '0b1010'
oct(10)   # '0o12'
hex(255)  # '0xff'

# 其他进制 → 十进制
int("1010", 2)   # 10
int("A", 16)     # 10

2. 编码转换

# 字符串 → 字节序列
s = "你好"
b = s.encode("utf-8")  # b'\xe4\xbd\xa0\xe5\xa5\xbd'

# 字节序列 → 字符串
s_new = b.decode("utf-8")  # '你好'

五、特殊转换场景

1. 数字与字符互转

# ASCII 字符 ↔ 数字
chr(65)  # 'A'
ord('A')  # 65

2. 布尔陷阱

# 空容器、零值、空字符串 → False
print(bool([]))       # False
print(bool(""))       # False
print(bool(0))        # False

# 非空值 → True
print(bool(" "))      # True（空格非空）
print(bool([0]))      # True（列表非空）

3. 类型检查与安全转换

def safe_int(value):
    try:
        return int(value)
    except ValueError:
        return 0

print(safe_int("42"))  # 42
print(safe_int("abc"))  # 0

六、注意事项总结

精度丢失
浮点转整数会截断小数，高精度计算建议使用 Decimal 模块。
隐式转换风险
避免依赖自动类型转换，如 5 + "3" 会抛出 TypeError。
可变与不可变
转换不可变类型（如元组）到可变类型（如列表）可修改数据，反之需新建对象。
容器元素要求
字典的键必须是不可变类型（如 str, int, tuple）。

七、转换速查表

原始类型 → 目标类型	转换方法
`str` → `int`	`int("123")`（需为数字格式）
`float` → `int`	`int(3.99)` → `3`（截断小数）
`list` → `tuple`	`tuple([1, 2])` → `(1, 2)`
`dict` → `list`	`list(dct)` → 键列表
`set` → `list`	`list({1, 2})` → `[1, 2]`（顺序不确定）
`bytes` → `str`	`b"abc".decode("utf-8")` → `"abc"`