1. 引言

Python作为一门简洁、易读且功能强大的编程语言，其数据处理能力是其核心优势之一。无论是数据分析、机器学习还是日常脚本编写，熟练掌握Python的基础数据操作都是必不可少的。本文将系统介绍Python中常用的数据结构及其基本操作，并通过丰富的代码示例帮助读者快速上手。

2. 基本数据类型

Python内置了多种基本数据类型，它们是构建更复杂数据结构的基础。

2.1 数字类型

Python支持整数（int）、浮点数（float）和复数（complex）。

# 整数 a = 10 b = -5 浮点数 c = 3.14 d = 2.0 复数 e = 1 + 2j f = complex(3, 4) # 3 + 4j print(type(a)) # <class 'int'> print(type(c)) # <class 'float'> print(type(e)) # <class 'complex'>

2.2 数值运算与处理

Python提供了丰富的数值运算和处理功能，包括基本算术运算、数学函数、类型转换和数值比较等。

2.2.1 基本算术运算

Python支持所有基本的算术运算符：

# 基本算术运算 a = 10 b = 3 print(a + b) # 加法：13 print(a - b) # 减法：7 print(a * b) # 乘法：30 print(a / b) # 除法：3.3333333333333335（浮点数结果） print(a // b) # 整除：3（向下取整） print(a % b) # 取模：1（余数） print(a ** b) # 幂运算：1000（10的3次方）

2.2.2 数学函数

Python的math模块提供了丰富的数学函数：

import math 常用数学函数 print(math.sqrt(16)) # 平方根：4.0 print(math.pow(2, 3)) # 幂运算：8.0 print(math.exp(1)) # e的1次方：2.718281828459045 print(math.log(10)) # 自然对数：2.302585092994046 print(math.log10(100)) # 以10为底的对数：2.0 print(math.sin(math.pi/2)) # 正弦函数：1.0 print(math.cos(0)) # 余弦函数：1.0 取整函数 print(math.floor(3.7)) # 向下取整：3 print(math.ceil(3.2)) # 向上取整：4 print(round(3.14159, 2)) # 四舍五入到2位小数：3.14 绝对值 print(abs(-5)) # 5 print(math.fabs(-3.14)) # 3.14（返回浮点数）

2.2.3 类型转换与精度处理

数值类型之间可以相互转换，但需要注意精度问题：

# 类型转换 int_num = 10 float_num = 3.14 complex_num = 2 + 3j 显式类型转换 print(float(int_num)) # 10.0 print(int(float_num)) # 3（截断小数部分） print(complex(int_num)) # (10+0j) 自动类型提升 result1 = 5 + 3.14 # int + float → float：8.14 result2 = 2 + 3j + 4 # complex + int → complex：(6+3j) 精度处理 from decimal import Decimal, getcontext from fractions import Fraction 使用Decimal处理高精度小数 getcontext().prec = 10 # 设置精度为10位 d1 = Decimal('0.1') d2 = Decimal('0.2') print(d1 + d2) # 0.3（精确结果，不是0.30000000000000004） 使用Fraction处理分数 f1 = Fraction(1, 3) # 1/3 f2 = Fraction(1, 6) # 1/6 print(f1 + f2) # 1/2 print(float(f1 + f2)) # 0.5

2.2.4 数值比较与判断

Python提供了多种数值比较和判断方法：

# 比较运算符 x = 10 y = 20 print(x == y) # False print(x != y) # True print(x < y) # True print(x > y) # False print(x <= y) # True print(x >= y) # False 链式比较 print(5 < x < 15) # True（10在5和15之间） 特殊数值判断 import math num1 = 10 num2 = float('nan') # 非数字 num3 = float('inf') # 正无穷大 num4 = -float('inf') # 负无穷大 print(math.isnan(num2)) # True print(math.isinf(num3)) # True print(math.isfinite(num1)) # True（有限数） print(math.isclose(0.1 + 0.2, 0.3)) # True（浮点数近似相等）

2.2.5 随机数生成

random模块提供了随机数生成功能：

import random 生成随机整数 print(random.randint(1, 10)) # 1到10之间的随机整数（包含1和10） print(random.randrange(0, 100, 5)) # 0到100之间步长为5的随机数 生成随机浮点数 print(random.random()) # [0.0, 1.0)之间的随机浮点数 print(random.uniform(1.5, 5.5)) # 1.5到5.5之间的随机浮点数 从序列中随机选择 colors = ['red', 'green', 'blue', 'yellow'] print(random.choice(colors)) # 随机选择一个元素 print(random.sample(colors, 2)) # 随机选择2个不重复的元素 打乱序列顺序 cards = ['A', 'K', 'Q', 'J', '10'] random.shuffle(cards) print(cards) # 打乱后的顺序

掌握这些数值处理和运算方法，能够帮助你在Python中更高效地进行数学计算和数据处理。

2.2 布尔类型

布尔类型只有两个值：True和False，常用于条件判断。

is_valid = True is_empty = False print(10 > 5) # True print(10 == 5) # False

2.3 字符串

字符串是不可变序列，用于表示文本数据。

# 创建字符串 s1 = "Hello" s2 = 'World' s3 = """多行 字符串""" 基本操作 print(s1 + " " + s2) # Hello World print(s1 * 3) # HelloHelloHello print(len(s1)) # 5 print(s1[0]) # H print(s1[1:4]) # ell

3. 数据结构

Python提供了多种内置数据结构，用于组织和存储数据。

3.1 列表（List）

列表是有序、可变的序列，可以包含不同类型的元素。

# 创建列表 my_list = [1, 2, 3, "Python", True] empty_list = [] list_from_range = list(range(5)) # [0, 1, 2, 3, 4] 访问元素 print(my_list[0]) # 1 print(my_list[-1]) # True (最后一个元素) 修改元素 my_list[1] = 20 print(my_list) # [1, 20, 3, 'Python', True] 常用方法 my_list.append("new") # 末尾添加 my_list.insert(2, "insert") # 在索引2处插入 removed = my_list.pop() # 移除并返回最后一个元素 print(removed) # True

3.2 元组（Tuple）

元组是有序、不可变的序列，通常用于存储不可修改的数据。

# 创建元组 my_tuple = (1, 2, 3, "Python") single_tuple = (5,) # 单个元素的元组需要逗号 empty_tuple = () 访问元素 print(my_tuple[0]) # 1 print(my_tuple[1:3]) # (2, 3) 元组不可修改 my_tuple[0] = 10 # 会报错：TypeError 解包 a, b, c, d = my_tuple print(a, b, c, d) # 1 2 3 Python

3.3 字典（Dictionary）

字典是无序的键值对集合，键必须是不可变类型。

# 创建字典 my_dict = {"name": "Alice", "age": 25, "city": "Beijing"} empty_dict = {} dict_from_keys = dict.fromkeys(["a", "b", "c"], 0) # {'a': 0, 'b': 0, 'c': 0} 访问元素 print(my_dict["name"]) # Alice print(my_dict.get("age")) # 25 print(my_dict.get("email", "N/A")) # 键不存在时返回默认值 修改和添加 my_dict["age"] = 26 my_dict["email"] = "alice@example.com" 常用方法 keys = my_dict.keys() # 所有键 values = my_dict.values() # 所有值 items = my_dict.items() # 所有键值对 for key, value in my_dict.items(): print(f"{key}: {value}")

3.4 集合（Set）

集合是无序、不重复元素的集合，支持数学集合运算。

# 创建集合 my_set = {1, 2, 3, 3, 4} # 重复元素自动去重：{1, 2, 3, 4} empty_set = set() # 注意：{} 创建的是空字典 基本操作 my_set.add(5) my_set.remove(2) # 如果元素不存在会报错 my_set.discard(10) # 安全移除，元素不存在也不报错 集合运算 set_a = {1, 2, 3, 4} set_b = {3, 4, 5, 6} print(set_a | set_b) # 并集：{1, 2, 3, 4, 5, 6} print(set_a & set_b) # 交集：{3, 4} print(set_a - set_b) # 差集：{1, 2} print(set_a ^ set_b) # 对称差集：{1, 2, 5, 6}

3.5 可变对象与不可变对象

在Python中，理解可变对象（mutable）和不可变对象（immutable）的区别对于编写正确、高效的代码至关重要。这一概念直接影响到数据的赋值、传递和修改行为。

3.5.1 基本概念

不可变对象（Immutable）：对象创建后其内容不能被修改。如果尝试修改，Python会创建一个新的对象。

可变对象（Mutable）：对象创建后其内容可以被修改，而对象本身的标识（内存地址）保持不变。

3.5.2 常见数据类型的可变性

不可变类型：

• 数字（int, float, complex）
• 字符串（str）
• 元组（tuple）
• 布尔值（bool）
• 冻结集合（frozenset）

可变类型：

• 列表（list）
• 字典（dict）
• 集合（set）
• 字节数组（bytearray）
• 用户自定义类（默认可变）

3.5.3 示例对比

示例1：不可变对象（字符串）

# 字符串是不可变对象 s1 = "Hello" print(f"原始字符串: {s1}, id: {id(s1)}") 尝试修改字符串 s2 = s1 + " World" # 创建新对象 print(f"修改后字符串: {s2}, id: {id(s2)}") print(f"s1是否改变: {s1}, id: {id(s1)}") 验证id不同 print(f"id是否相同: {id(s1) == id(s2)}") # False

示例2：可变对象（列表）

# 列表是可变对象 list1 = [1, 2, 3] print(f"原始列表: {list1}, id: {id(list1)}") 直接修改列表内容 list1.append(4) # 原地修改 print(f"修改后列表: {list1}, id: {id(list1)}") 验证id相同 print(f"id是否相同: {id(list1) == id(list1)}") # True

3.5.4 赋值与引用的区别

不可变对象的赋值：

# 不可变对象：赋值创建新引用 a = 10 b = a # b和a指向同一个对象 print(f"a: {a}, id: {id(a)}") print(f"b: {b}, id: {id(b)}") print(f"id是否相同: {id(a) == id(b)}") # True 修改a的值 a = 20 # 创建新对象 print(f"修改后a: {a}, id: {id(a)}") print(f"b是否改变: {b}, id: {id(b)}") # b不变

可变对象的赋值：

# 可变对象：赋值创建共享引用 list_a = [1, 2, 3] list_b = list_a # list_b和list_a指向同一个列表对象 print(f"list_a: {list_a}, id: {id(list_a)}") print(f"list_b: {list_b}, id: {id(list_b)}") 通过list_b修改列表 list_b.append(4) print(f"修改后list_a: {list_a}") # list_a也被修改！ print(f"修改后list_b: {list_b}") 创建真正的副本 list_c = list_a.copy() # 浅拷贝 list_c.append(5) print(f"list_a: {list_a}") # 不受影响 print(f"list_c: {list_c}")

3.5.5 函数参数传递的影响

def modify_immutable(x): """修改不可变对象""" x = x + 10 # 创建新对象 return x def modify_mutable(lst): """修改可变对象""" lst.append(100) # 原地修改 return lst 测试不可变对象 num = 5 print(f"调用前num: {num}") result = modify_immutable(num) print(f"调用后num: {num}") # 不变 print(f"返回值: {result}") 测试可变对象 my_list = [1, 2, 3] print(f"调用前my_list: {my_list}") result_list = modify_mutable(my_list) print(f"调用后my_list: {my_list}") # 被修改！ print(f"返回值: {result_list}")

3.5.6 实际应用建议

1. 使用不可变对象作为字典键：字典的键必须是不可变类型，因此字符串、数字、元组可以作为键，但列表、字典、集合不能。
2. 线程安全：不可变对象天然线程安全，多个线程可以安全地共享不可变对象。
3. 缓存优化：Python会对小整数和短字符串进行缓存，因为不可变对象可以被安全地重用。
4. 函数式编程：不可变对象更适合函数式编程范式，避免副作用。
5. 性能考虑：频繁修改字符串时，考虑使用列表拼接再转换为字符串，因为字符串连接会创建多个临时对象。

# 示例：字符串拼接的性能优化 # 低效方式（创建多个临时字符串） result = "" for i in range(1000): result += str(i) # 每次循环都创建新字符串 高效方式（使用列表） parts = [] for i in range(1000): parts.append(str(i)) result = "".join(parts) # 只创建一次字符串

理解可变与不可变的区别有助于避免常见的编程错误，如意外修改共享数据、函数副作用等。在实际编程中，应根据需求选择合适的数据类型，并在需要时使用拷贝来避免意外的数据共享。

4. 数据操作示例

下面通过几个综合示例展示如何组合使用这些数据结构。

4.1 学生成绩统计

# 学生成绩数据 students = [ {"name": "张三", "scores": [85, 90, 78]}, {"name": "李四", "scores": [92, 88, 95]}, {"name": "王五", "scores": [76, 82, 80]} ] 计算每个学生的平均分 for student in students: scores = student["scores"] avg_score = sum(scores) / len(scores) student["average"] = round(avg_score, 2) print(f"{student['name']}的平均分：{student['average']}") 找出最高平均分的学生 best_student = max(students, key=lambda s: s["average"]) print(f"最高分学生：{best_student['name']}，平均分：{best_student['average']}")

4.2 文本词频统计

# 统计一段文本中单词的出现频率 text = """ Python is an interpreted, high-level, general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant whitespace. """ 清理文本并分割单词 words = text.lower().replace(",", "").replace(".", "").split() 统计词频 word_count = {} for word in words: word_count[word] = word_count.get(word, 0) + 1 按频率排序 sorted_words = sorted(word_count.items(), key=lambda x: x[1], reverse=True) 输出前5个最常见的单词 print("最常见的5个单词：") for word, count in sorted_words[:5]: print(f"{word}: {count}次")

5. 总结

本文介绍了Python的基础数据类型（数字、布尔、字符串）和核心数据结构（列表、元组、字典、集合），并通过实际示例演示了它们的基本操作。掌握这些基础知识是进行更复杂数据处理的前提。建议读者在理解概念后，多动手编写代码，尝试解决实际问题，从而加深对Python数据操作的理解。

学习建议：

• 理解每种数据结构的特点和适用场景
• 掌握常用的内置方法（如列表的append、字典的get）
• 练习组合使用不同数据结构解决实际问题
• 阅读Python官方文档了解更多高级用法