#每天一个编程技巧#

掌握数据结构的高效使用是成为优秀Python程序员的关键。下面我将分享一些实用的数据结构技巧，帮助您编写更高效、更优雅的代码。

1. 列表(List)高级技巧

1.1 列表推导式与条件筛选

# 基本列表推导式
squares = [x**2 for x in range(10)]

# 带条件的列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 多重循环
matrix = [[1, 2], [3, 4], [5, 6]]
flattened = [num for row in matrix for num in row]  # [1, 2, 3, 4, 5, 6]

1.2 列表切片技巧

lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取最后三个元素
last_three = lst[-3:]  # [7, 8, 9]

# 反转列表
reversed_lst = lst[::-1]  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 每隔两个元素取一个
every_second = lst[::2]  # [0, 2, 4, 6, 8]

1.3 列表排序高级用法

# 基本排序
lst = [5, 2, 9, 1]
lst.sort()  # 原地排序
sorted_lst = sorted(lst)  # 返回新列表

# 自定义排序
students = [{'name': 'Alice', 'grade': 89},
            {'name': 'Bob', 'grade': 72},
            {'name': 'Charlie', 'grade': 93}]

# 按grade降序排序
students_sorted = sorted(students, key=lambda x: x['grade'], reverse=True)

# 多重排序条件
from operator import itemgetter
students.sort(key=itemgetter('grade', 'name'))  # 先按grade，再按name排序

2. 字典(Dict)高级技巧

2.1 字典推导式

# 基本字典推导式
square_dict = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 带条件的字典推导式
even_square_dict = {x: x**2 for x in range(10) if x % 2 == 0}

# 键值交换
original = {'a': 1, 'b': 2, 'c': 3}
inverted = {v: k for k, v in original.items()}

2.2 字典合并

# Python 3.5+ 使用 ** 操作符
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = {**dict1, **dict2}  # {'a': 1, 'b': 3, 'c': 4}

# 使用 | 操作符 (Python 3.9+)
merged = dict1 | dict2

# 保留原始字典
from collections import ChainMap
chained = ChainMap(dict1, dict2)
print(chained['b'])  # 输出 2 (dict1中的值)

2.3 默认值处理

# 使用setdefault
d = {}
for k, v in [('a', 1), ('b', 2), ('a', 3)]:
    d.setdefault(k, []).append(v)  # {'a': [1, 3], 'b': [2]}

# 使用defaultdict
from collections import defaultdict
dd = defaultdict(list)
for k, v in [('a', 1), ('b', 2), ('a', 3)]:
    dd[k].append(v)  # defaultdict(<class 'list'>, {'a': [1, 3], 'b': [2]})

# 使用get方法处理缺失键
value = d.get('nonexistent', 'default')

3. 集合(Set)高级技巧

3.1 集合运算

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 并集
union = a | b  # {1, 2, 3, 4, 5, 6}

# 交集
intersection = a & b  # {3, 4}

# 差集
difference = a - b  # {1, 2}

# 对称差集 (只在其中一个集合中)
symmetric_diff = a ^ b  # {1, 2, 5, 6}

3.2 集合推导式

# 基本集合推导式
squares = {x**2 for x in range(-5, 6)}  # {0, 1, 4, 9, 16, 25}

# 带条件的集合推导式
odd_squares = {x**2 for x in range(10) if x % 2 != 0}  # {1, 9, 25, 49, 81}

3.3 集合去重应用

# 列表去重
lst = [1, 2, 2, 3, 4, 4, 5]
unique_lst = list(set(lst))  # 顺序可能改变

# 保持顺序的去重
from collections import OrderedDict
unique_ordered = list(OrderedDict.fromkeys(lst))  # [1, 2, 3, 4, 5]

4. 元组(Tuple)高级技巧

4.1 命名元组

from collections import namedtuple

# 创建命名元组类型
Point = namedtuple('Point', ['x', 'y'])

# 实例化
p = Point(11, y=22)

# 访问
print(p.x)  # 11
print(p[0])  # 11 (仍然支持索引)

4.2 元组拆包

# 基本拆包
x, y = (1, 2)

# 扩展拆包
first, *middle, last = (1, 2, 3, 4, 5)  # first=1, middle=[2,3,4], last=5

# 忽略某些值
_, second, _ = (1, 2, 3)  # second=2

# 字典拆包到函数参数
def greet(name, age):
    print(f"Hello {name}, you are {age}")

person = {'name': 'Alice', 'age': 25}
greet(**person)

5. 高级数据结构

5.1 堆(Heap)操作

import heapq

# 创建堆
heap = []
heapq.heappush(heap, 5)
heapq.heappush(heap, 2)
heapq.heappush(heap, 1)

# 获取最小元素
smallest = heapq.heappop(heap)  # 1

# 堆化现有列表
lst = [5, 3, 1, 4, 2]
heapq.heapify(lst)  # 原地转换为堆

# 获取n个最大/最小元素
largest = heapq.nlargest(3, lst)  # [5, 4, 3]
smallest = heapq.nsmallest(2, lst)  # [1, 2]

5.2 双端队列(deque)

from collections import deque

d = deque(maxlen=3)  # 固定长度队列
d.append(1)          # [1]
d.append(2)          # [1, 2]
d.append(3)          # [1, 2, 3]
d.append(4)          # [2, 3, 4] (自动移除最左边的1)

# 两端操作
d.appendleft(0)      # [0, 2, 3]
d.pop()              # 移除并返回3
d.popleft()          # 移除并返回0

5.3 计数器(Counter)

from collections import Counter

# 基本计数
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_counts = Counter(words)  # {'apple': 3, 'banana': 2, 'orange': 1}

# 获取最常见元素
top_two = word_counts.most_common(2)  # [('apple', 3), ('banana', 2)]

# 数学运算
more_words = ['apple', 'orange', 'grape']
more_counts = Counter(more_words)

combined = word_counts + more_counts  # {'apple':4, 'banana':2, 'orange':2, 'grape':1}
difference = word_counts - more_counts  # {'apple':2, 'banana':2}

6. 数据结构的性能优化

6.1 选择合适的数据结构

6.2 使用bisect维护有序列表

import bisect

lst = [1, 3, 4, 4, 6, 8]

# 插入元素保持有序
bisect.insort(lst, 5)  # [1, 3, 4, 4, 5, 6, 8]

# 查找插入位置
index = bisect.bisect_left(lst, 4)  # 2 (第一个4的位置)
index = bisect.bisect_right(lst, 4)  # 4 (最后一个4之后的位置)

6.3 使用数组(array)优化数值存储

import array

# 创建整型数组
arr = array.array('i', [1, 2, 3, 4, 5])  # 比列表更节省内存

# 操作类似列表
arr.append(6)
print(arr[2])  # 3

7. 实用技巧集合

7.1 字典键的多重查找

def get_value(d, *keys):
    for key in keys:
        if key in d:
            return d[key]
    return None

data = {'name': 'Alice', 'username': 'alice123'}
name = get_value(data, 'name', 'username', 'nickname')  # 'Alice'

7.2 扁平化嵌套数据结构

from collections.abc import Iterable

def flatten(items):
    for item in items:
        if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
            yield from flatten(item)
        else:
            yield item

nested = [1, [2, [3, 4], 5]]
list(flatten(nested))  # [1, 2, 3, 4, 5]

7.3 数据结构的深拷贝

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)  # 浅拷贝
deep = copy.deepcopy(original)  # 深拷贝

original[0][0] = 99
print(shallow)  # [[99, 2], [3, 4]] (受影响)
print(deep)     # [[1, 2], [3, 4]] (不受影响)

掌握这些数据结构技巧将显著提升您的Python编程能力，使您能够编写出更高效、更易维护的代码。记住，选择合适的数据结构往往比算法优化更能提升程序性能。