Python语言基础知识详解：数据类型及运算

Python语言基础知识详解：数据类型及运算

---

一、Python的数据类型体系

Python是强类型动态语言，所有数据均以对象形式存在。数据类型分为 不可变类型（值不可修改）和 可变类型（值可修改）。

分类	数据类型	示例	特性
不可变类型	int, float, bool, str, tuple, frozenset, bytes	10, 3.14, "hello", (1,2)	创建后不可修改，操作生成新对象
可变类型	list, dict, set, bytearray	[1,2], {"a":1}, {1,2}	支持原地修改，内存地址不变

---

二、基础数据类型详解

1. 数值类型（Numeric Types）

• 整型（int）
  支持任意大整数（无溢出），可表示不同进制：

  a = 100          # 十进制
  b = 0b1101       # 二进制（13）
  c = 0o755        # 八进制（493）
  d = 0x1F         # 十六进制（31）
  

• 浮点型（float）
  支持科学计数法，存在精度问题（需注意计算误差）：

  f1 = 3.1415
  f2 = 2e3         # 2000.0
  f3 = 0.1 + 0.2   # 0.30000000000000004（精度问题）
  

• 布尔型（bool）
  继承自int，True为1，False为0：

  is_valid = True
  print(int(is_valid))  # 输出 1
  

• 复数（complex）
  用于科学计算：

  c = 3 + 4j
  print(c.real)    # 3.0
  print(c.imag)    # 4.0
  

---

2. 字符串（str）

• 定义与操作

  s1 = 'Hello'     # 单引号
  s2 = "World"     # 双引号
  s3 = '''多行
  字符串'''         # 三引号（保留换行）
  s4 = f"{s1} {s2}" # f-string（Python 3.6+）
  
  # 常用操作
  print(s1[1])     # 'e'（索引）
  print(s1 + s2)   # 'HelloWorld'（拼接）
  print(s1 * 3)    # 'HelloHelloHello'（重复）
  

• 字符串方法

  s = "  Python  "
  s.strip()        # "Python"（去空格）
  s.upper()        # "  PYTHON  "（转大写）
  "py" in s.lower() # True（成员检测）
  s.split('t')     # ['  Py', 'hon  ']（分割）
  

---

3. 序列类型（Sequence Types）

• 列表（list）
  有序、可变，支持混合类型：

  lst = [1, "a", [2,3]]
  lst.append(4)    # [1, "a", [2,3], 4]
  lst[1] = "b"     # 修改元素
  

• 元组（tuple）
  有序、不可变，适合固定数据：

  t = (1, "a", [2,3])
  # t[1] = "b"     # 错误！元组不可修改
  t[2].append(4)   # 合法（内部列表可变）
  

---

4. 映射类型（dict）

键值对集合，键必须为不可变类型：

d = {"name": "Alice", "age": 20}
d["age"] = 21      # 修改值
d["city"] = "NY"   # 新增键值对
keys = d.keys()     # 获取所有键（视图对象）

---

5. 集合类型（set, frozenset）

• set：无序、元素唯一、可变

  s = {1, 2, 3}
  s.add(4)         # {1,2,3,4}
  s.remove(1)      # {2,3,4}
  

• frozenset：不可变集合

  fs = frozenset({1,2,3})
  

---

6. 其他类型

• NoneType：表示空值

  x = None  # 常用于初始化变量
  

• 二进制类型：

  b = b"hello"      # bytes（不可变）
  ba = bytearray(b) # bytearray（可变）
  

---

三、运算符详解

1. 算术运算符

运算符	描述	示例
+	加	3 + 2 → 5
-	减	5 - 3 → 2
*	乘	2 * 3 → 6
/	浮点除	7 / 2 → 3.5
//	整数除	7 // 2 → 3
%	取模	7 % 2 → 1
**	幂运算	2 ** 3 → 8

---

2. 比较运算符

返回布尔值（True/False）：

a, b = 5, 3
print(a > b)    # True
print(a == b)   # False
print(a != b)   # True

---

3. 逻辑运算符

运算符	描述	示例
and	逻辑与	True and False → False
or	逻辑或	True or False → True
not	逻辑非	not True → False

---

4. 位运算符

处理整数的二进制形式：

a = 0b1010  # 10
b = 0b1100  # 12
print(bin(a & b))   # 0b1000（按位与）
print(bin(a | b))   # 0b1110（按位或）
print(bin(a ^ b))   # 0b0110（按位异或）

---

5. 成员运算符

检查元素是否在容器中：

lst = [1, 2, 3]
print(2 in lst)    # True
print(4 not in lst) # True

---

6. 身份运算符

比较对象的内存地址（is vs ==）：

a = [1,2]
b = [1,2]
c = a

print(a == b)  # True（值相等）
print(a is b)  # False（不同对象）
print(a is c)  # True（同一对象）

---

四、类型转换与内存管理

1. 显式类型转换

int("100")      # 100（字符串→整数）
float(10)       # 10.0（整数→浮点）
str(3.14)       # "3.14"
list("abc")     # ['a', 'b', 'c']
tuple([1,2,3])  # (1,2,3)

2. 内存管理机制

• 引用计数：自动回收无引用对象。
• 深浅拷贝：

  import copy
  lst1 = [1, [2,3]]
  lst2 = copy.copy(lst1)    # 浅拷贝（内部列表共享）
  lst3 = copy.deepcopy(lst1) # 深拷贝（完全独立）
  

---

五、常见问题与解决方案

1. 浮点数精度问题

   # 使用decimal模块精确计算
   from decimal import Decimal
   print(Decimal('0.1') + Decimal('0.2'))  # 0.3
   

2. 可变类型作为函数默认参数

   # 错误示例：默认参数在函数定义时创建一次
   def append_to(item, lst=[]):
       lst.append(item)
       return lst
   
   # 正确做法：使用None作为默认值
   def append_to(item, lst=None):
       if lst is None:
           lst = []
       lst.append(item)
       return lst
   

3. is与==的误用

   a = 256
   b = 256
   print(a is b)  # True（小整数池优化）
   
   c = 257
   d = 257
   print(c is d)  # False（超出缓存范围）
   

---

六、总结

核心概念	关键要点
数据类型分类	不可变类型（安全但效率低） vs 可变类型（高效但需注意副作用）
运算符优先级	括号 > 算术 > 比较 > 逻辑 > 赋值
类型转换	显式转换确保数据兼容性，注意信息丢失风险
内存管理	理解深浅拷贝区别，避免共享可变对象导致的意外修改
常见陷阱	浮点精度、默认参数陷阱、is与==的区别

掌握数据类型与运算是构建复杂程序的基石。通过合理选择数据类型和运算符，可以显著提升代码性能和可维护性。