第 1 周：Python 核心与数据结构基础

蓝桥杯Python备考第一周笔记：核心语法与基础数据结构

一、Python核心语法强化

1. 列表推导式与字典组合

知识点：列表推导式、zip()函数、字典构造

• 列表推导式是Python高效创建列表的方式，格式为[表达式 for 变量 in 可迭代对象 if 条件]
• zip(a, b)将两个可迭代对象按索引配对，返回元组迭代器，可直接用dict()转换为字典

nums = [1,2,3,4,5,6,7,8,9,10]
odds = [x for x in nums if x % 2 != 0]  # 筛选奇数的推导式
squares = [x**2 for x in odds]          # 计算平方的推导式
result = dict(zip(odds, squares))       # zip组合键值对

2. 质数生成器

知识点：生成器（yield）、质数判定优化、迭代器使用

• 生成器通过yield返回值，每次调用next()生成下一个元素，节省内存
• 质数判定优化：只需检查到sqrt(n)，减少循环次数

import math

def prime_generator():
    for num in range(2, 101):
        is_prime = True
        # 优化：只需检查到平方根
        for i in range(2, int(math.sqrt(num)) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            yield num  # 生成器返回当前质数

gen = prime_generator()
print([next(gen) for _ in range(10)])  # 迭代获取前10个质数

3. collections库应用

知识点：Counter计数、deque双端队列

• Counter是字典的子类，用于快速统计元素出现次数，most_common(n)返回前n个高频元素
• deque提供O(1)复杂度的append()和popleft()，适合实现队列

from collections import Counter, deque

s = "abacabacddeeff"
count = Counter(s)               # 统计字符频次
top3 = [k for k, _ in count.most_common(3)]  # 取前3高频字符

dq = deque(top3)                 # 用deque实现队列
while dq:
    print(dq.popleft(), end=' ') # 先进先出遍历

4. sys库输入优化

知识点：sys.stdin.readline输入效率、批量数据转换

• 蓝桥杯中输入量大时，sys.stdin.readline比input()更快（避免缓存问题）
• map(int, ...)可批量转换字符串为整数，配合split()处理空格分隔的输入

import sys

n = int(sys.stdin.readline())                # 读取第一行整数n
nums = list(map(int, sys.stdin.readline().split()))  # 读取n个整数
total = sum(nums)
avg = total / n
print(f"总和: {total}, 平均值: {avg:.2f}")  # 格式化输出保留2位小数

5. 耗时统计装饰器

知识点：装饰器原理、functools.wraps、时间计算

• 装饰器是修改函数行为的工具，通过嵌套函数实现，@wraps(func)保留原函数元信息
• time.time()获取时间戳，计算差值得到函数执行耗时

import time
from functools import wraps

def time_cost(func):          # 装饰器函数
    @wraps(func)              # 保留原函数属性
    def wrapper(*args, **kwargs):
        start = time.time()   # 记录开始时间
        result = func(*args, **kwargs)
        end = time.time()     # 记录结束时间
        print(f"耗时: {end - start:.4f}秒")
        return result
    return wrapper

@time_cost                     # 应用装饰器
def sum_1_to_n(n):
    return sum(range(1, n+1))

print("结果:", sum_1_to_n(1000000))

二、基础数据结构

6. 数组去重与找第二大

知识点：数组去重（保持顺序）、排序与极值

• Python 3.7+中字典保留插入顺序，dict.fromkeys(arr)可快速去重
• 排序后通过索引获取第二大值（注意处理重复元素）

arr = [3,1,4,1,5,9,2,6]
# 去重并保持原顺序：利用字典键唯一特性
unique_arr = list(dict.fromkeys(arr))  
# 找第二大：先降序排序，取索引1的元素
sorted_unique = sorted(unique_arr, reverse=True)
second_largest = sorted_unique[1] if len(sorted_unique)>=2 else None

7. 栈实现括号匹配

知识点：栈的后进先出（LIFO）特性、映射表应用

• 栈适合处理"匹配"问题：左括号入栈，右括号与栈顶元素匹配
• 用映射表{右括号: 左括号}简化匹配逻辑

def is_valid(s):
    stack = []
    mapping = {')':'(', ']':'[', '}':'{'}  # 右括号到左括号的映射
    for char in s:
        if char in mapping:  # 遇到右括号
            # 栈空时用特殊字符避免报错
            top = stack.pop() if stack else '#'
            if mapping[char] != top:  # 不匹配则无效
                return False
        else:  # 遇到左括号则入栈
            stack.append(char)
    return not stack  # 栈空表示所有括号匹配

8. 队列模拟消息队列

知识点：队列的先进先出（FIFO）特性、deque实现

• 队列适合处理"顺序存取"场景（如消息传递、广度优先搜索）
• deque的append()（入队）和popleft()（出队）效率为O(1)

from collections import deque

class MessageQueue:
    def __init__(self):
        self.queue = deque()  # 用deque实现队列
    def enqueue(self, msg):   # 入队
        self.queue.append(msg)
    def dequeue(self):        # 出队
        return self.queue.popleft() if self.queue else None

# 模拟消息入队和出队
mq = MessageQueue()
for i in range(10):
    mq.enqueue(f"消息{i+1}")
while msg := mq.dequeue():  # 海象运算符简化循环
    print(msg)

9. 哈希表求交并集

知识点：集合（哈希表实现）的交并集运算

• 集合是哈希表的一种应用，元素唯一且支持高效的成员判断（O(1)）
• 交集（&）：两集合共有的元素；并集（|）：两集合所有元素

list1 = [1,2,3,4,5]
list2 = [4,5,6,7,8]
set1, set2 = set(list1), set(list2)  # 列表转集合（去重+哈希表）

intersection = list(set1 & set2)  # 交集：[4,5]
union = list(set1 | set2)          # 并集：[1,2,3,4,5,6,7,8]

10. 二叉树层序遍历

知识点：二叉树结构、队列实现层序遍历

• 层序遍历（广度优先）需按"从上到下、从左到右"访问节点
• 用队列暂存节点：出队一个节点时，将其左右子节点入队

from collections import deque

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 构建示例二叉树
root = TreeNode(1,
                left=TreeNode(2, TreeNode(4), TreeNode(5)),
                right=TreeNode(3)
               )

def level_order(root):
    if not root:
        return []
    q = deque([root])  # 队列初始化，存入根节点
    res = []
    while q:
        node = q.popleft()  # 出队当前节点
        res.append(node.val)
        # 左子节点入队
        if node.left:
            q.append(node.left)
        # 右子节点入队
        if node.right:
            q.append(node.right)
    return res  # [1,2,3,4,5]

三、总结

1. 核心语法 ：掌握列表推导式、生成器、装饰器等Python特有语法，熟练使用collections、sys等库提升效率。
   2. 数据结构 ：理解数组、栈（LIFO）、队列（FIFO）、哈希表（集合）、二叉树的特性及应用场景，重点练习其核心操作（如栈的匹配、队列的层序遍历）。
   3. 优化意识：输入输出用sys库提速，质数判定缩小范围，集合运算替代暴力循环，为后续复杂算法打基础。