Python语法
在Python编程语言中，数据结构是组织和存储数据的基本方式。Python提供了四种内置的核心数据结构：列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。
列表是Python中最常用的数据结构之一，它表现为一个有序的可变序列。列表中的元素可以是任何数据类型，包括数字、字符串、甚至其他列表。
| 1 | # 创建列表的多种方式 |
| 2 | numbers = [1, 2, 3, 4, 5] |
| 3 | fruits = ['apple', 'banana', 'cherry'] |
| 4 | mixed = [1, 'hello', 3.14, True] |
列表的可变性是其最重要的特征之一。与字符串不同，列表创建后可以修改其中的元素，可以添加或删除元素，也可以改变现有元素的值。
列表支持丰富的操作方法，下面是一些最常用的：
增删改查操作：
| 1 | # 添加元素 |
| 2 | fruits.append('orange') # 在末尾添加 |
| 3 | fruits.insert(1, 'mango') # 在指定位置插入 |
| 4 | |
| 5 | # 删除元素 |
| 6 | del fruits[0] # 删除指定索引元素 |
| 7 | fruits.remove('banana') # 删除指定值元素 |
| 8 | popped = fruits.pop() # 删除并返回最后一个元素 |
| 9 | |
| 10 | # 修改元素 |
| 11 | fruits[0] = 'kiwi' |
| 12 | |
| 13 | # 查找元素 |
| 14 | if 'apple' in fruits: |
| 15 | print("苹果在列表中") |
切片操作：\
列表支持强大的切片操作，可以方便地获取子列表：
| 1 | numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] |
| 2 | first_three = numbers[:3] # [0, 1, 2] |
| 3 | last_three = numbers[-3:] # [7, 8, 9] |
| 4 | middle = numbers[3:7] # [3, 4, 5, 6] |
| 5 | every_other = numbers[::2] # [0, 2, 4, 6, 8] |
| 6 | reversed_list = numbers[::-1] # 反转列表 |
虽然列表非常灵活，但在某些操作上性能并不理想：
- 在列表开头或中间插入/删除元素的时间复杂度为O(n)，因为需要移动后续所有元素
- 查找元素是否在列表中（使用in操作）的时间复杂度也是O(n)
对于需要频繁在开头或中间插入删除元素的场景，可以考虑使用collections.deque，它提供了O(1)时间复杂度的两端操作。
Python提供了一种简洁的创建列表的方式——列表推导式：
| 1 | # 创建平方数列表 |
| 2 | squares = [x**2 for x in range(10)] |
| 3 | # 带条件的列表推导式 |
| 4 | even_squares = [x**2 for x in range(10) if x % 2 == 0] |
列表推导式不仅代码简洁，而且在某些情况下比普通循环更快，因为它的实现是在C语言层面优化的。
元组与列表非常相似，都是有序的序列结构，但关键区别在于元组是不可变的。一旦创建，就不能修改元组的内容。
| 1 | # 创建元组 |
| 2 | coordinates = (10.0, 20.0) |
| 3 | colors = ('red', 'green', 'blue') |
| 4 | single_element = (42,) # 注意逗号，区别于(42) |
元组的不可变性带来了几个优势：
- 安全性：数据不会被意外修改
- 可哈希性：可以作为字典的键
- 性能：在某些操作上比列表更快
虽然元组不如列表灵活，但在以下场景中非常有用：
作为函数的返回值：
| 1 | def get_stats(data): |
| 2 | return min(data), max(data), sum(data)/len(data) |
| 3 | |
| 4 | minimum, maximum, average = get_stats([1, 2, 3, 4, 5]) |
作为字典的键：
| 1 | locations = { |
| 2 | (35.6895, 139.6917): "Tokyo", |
| 3 | (40.7128, -74.0060): "New York" |
| 4 | } |
保护数据不被修改：\
当需要确保数据在程序运行期间不被改变时，使用元组比列表更合适。
Python的collections模块提供了namedtuple，它是元组的子类，可以为元组的每个位置分配名称，使代码更易读：
| 1 | from collections import namedtuple |
| 2 | |
| 3 | Point = namedtuple('Point', ['x', 'y']) |
| 4 | p = Point(10, y=20) |
| 5 | print(p.x) # 10 |
| 6 | print(p.y) # 20 |
命名元组既有元组的不可变性和性能优势，又提高了代码的可读性。
字典是Python中的映射类型，存储键值对（key-value pairs）。字典是无序的（Python 3.7+中保持插入顺序），键必须是不可变类型（如字符串、数字或元组），且唯一。
| 1 | # 创建字典 |
| 2 | person = {'name': 'Alice', 'age': 25, 'city': 'New York'} |
| 3 | grades = dict(math=90, physics=85, chemistry=88) |
字典的查找速度非常快，时间复杂度接近O(1)，因为它基于哈希表实现。
基本操作：
| 1 | # 访问元素 |
| 2 | print(person['name']) # Alice |
| 3 | |
| 4 | # 修改元素 |
| 5 | person['age'] = 26 |
| 6 | |
| 7 | # 添加元素 |
| 8 | person['job'] = 'Engineer' |
| 9 | |
| 10 | # 删除元素 |
| 11 | del person['city'] |
安全访问：
| 1 | # 避免KeyError的访问方式 |
| 2 | age = person.get('age', 0) # 如果'age'不存在，返回0 |
字典遍历：
| 1 | # 遍历键 |
| 2 | for key in person: |
| 3 | print(key) |
| 4 | |
| 5 | # 遍历键值对 |
| 6 | for key, value in person.items(): |
| 7 | print(f"{key}: {value}") |
类似于列表推导式，字典也有自己的推导式语法：
| 1 | # 创建数字到其平方的映射 |
| 2 | squares = {x: x**2 for x in range(6)} |
| 3 | # 带条件的字典推导式 |
| 4 | even_squares = {x: x**2 for x in range(6) if x % 2 == 0} |
defaultdict：\
collections模块中的defaultdict可以自动为不存在的键创建默认值：
| 1 | from collections import defaultdict |
| 2 | |
| 3 | word_counts = defaultdict(int) # 默认值为0 |
| 4 | for word in words: |
| 5 | word_counts[word] += 1 |
Counter：\
专门用于计数的字典子类：
| 1 | from collections import Counter |
| 2 | |
| 3 | counts = Counter(['apple', 'banana', 'apple', 'orange']) |
| 4 | print(counts['apple']) # 2 |
集合是无序的、不重复元素的集合。集合的主要用途包括成员测试、消除重复元素以及数学集合运算（并集、交集、差集等）。
| 1 | # 创建集合 |
| 2 | fruits = {'apple', 'banana', 'cherry'} |
| 3 | numbers = set([1, 2, 3, 4, 5]) |
集合中的元素必须是可哈希的（不可变类型），因此列表不能作为集合元素，但元组可以。
基本操作：
| 1 | # 添加元素 |
| 2 | fruits.add('orange') |
| 3 | |
| 4 | # 删除元素 |
| 5 | fruits.remove('banana') # 如果不存在会引发KeyError |
| 6 | fruits.discard('banana') # 安全删除，不存在也不报错 |
集合运算：
| 1 | a = {1, 2, 3} |
| 2 | b = {2, 3, 4} |
| 3 | |
| 4 | # 并集 |
| 5 | print(a | b) # {1, 2, 3, 4} |
| 6 | |
| 7 | # 交集 |
| 8 | print(a & b) # {2, 3} |
| 9 | |
| 10 | # 差集 |
| 11 | print(a - b) # {1} |
| 12 | |
| 13 | # 对称差集（仅在其中一个集合中的元素） |
| 14 | print(a ^ b) # {1, 4} |
去重：
| 1 | unique_numbers = list(set([1, 2, 2, 3, 3, 3])) # [1, 2, 3] |
快速成员测试：\
集合的成员测试时间复杂度为O(1)，比列表的O(n)快得多：
| 1 | if 'apple' in fruits: # 非常高效 |
| 2 | print("找到了苹果") |
登录后可以选中正文添加批注（仅自己可见）。
评论 (0)
登录后参与评论。
还没有评论，来做第一个。