查看“︁Python2026”︁的源代码

[[category:python]] 
<pre>
每天都做成详细的 step-by-step 计划。

---

## Day 1 — 字符串操作（60-90分钟）

### 第一步：看这些操作，每个自己手打一遍（20分钟）
```python
s = "Hello World"

# 基础操作
print(s[::-1])           # 反转 → "dlroW olleH"
print(s.upper())         # 全大写
print(s.lower())         # 全小写
print(s.strip())         # 去首尾空格
print(s.split(" "))      # 分割 → ["Hello", "World"]
print("-".join(["a","b","c"]))  # 合并 → "a-b-c"
print(s.replace("l","x"))       # 替换
print(s.count("l"))      # 统计出现次数 → 3
print(s.find("World"))   # 找位置 → 6
print(s.startswith("He")) # True
print(s.isdigit())       # 是否全是数字
print(s.isalpha())       # 是否全是字母
```

### 第二步：把这 3 个模板理解并默写（15分钟）
```python
# 模板1：判断回文
def is_palindrome(s):
    s = s.lower().replace(" ", "")  # 忽略大小写和空格
    return s == s[::-1]

# 模板2：统计每个字符频率
from collections import Counter
def char_frequency(s):
    return Counter(s)

# 模板3：反转句子里的单词顺序
def reverse_words(s):
    return " ".join(s.split()[::-1])

# 测试
print(is_palindrome("A man a plan a canal Panama"))  # True
print(char_frequency("hello"))  # Counter({'l':2,'h':1,'e':1,'o':1})
print(reverse_words("hello world foo"))  # "foo world hello"
```

### 第三步：去 HackerRack 做这 3 道题（30-45分钟）
1. **Reverse a String** — 搜索直接做
2. **String Validators** — 考 isdigit/isalpha/isupper
3. **Capitalize** — 考 split + join + capitalize()

> HackerRank 注册后 → 选 Python → Practice → Strings

### 今天结束前问自己：
- [ ] `s[::-1]` 和 `s.split()` 不看笔记能写出来吗？
- [ ] 3 道题都通过了吗？
- [ ] 有没有遇到边界条件出错（空字符串）？

---

## Day 2 — 列表 & 推导式（60-90分钟）

### 第一步：手打这些操作（20分钟）
```python
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5]

print(sorted(lst))               # 升序（不改原列表）
print(sorted(lst, reverse=True)) # 降序
print(max(lst), min(lst))        # 最大最小
print(sum(lst))                  # 求和
print(lst.count(5))              # 5 出现几次 → 2
print(list(set(lst)))            # 去重（顺序不保证）

# enumerate 和 zip（很常用）
for i, val in enumerate(lst):
    print(f"index {i}: {val}")

for a, b in zip([1,2,3], ["x","y","z"]):
    print(a, b)
```

### 第二步：列表推导式重点练（15分钟）
```python
# 基础
squares = [x**2 for x in range(10)]

# 带条件过滤
evens = [x for x in range(20) if x % 2 == 0]

# 嵌套（二维矩阵）
matrix = [[i*j for j in range(1,4)] for i in range(1,4)]

# 字符串 + 列表组合
words = ["hello", "world", "python"]
upper_words = [w.upper() for w in words if len(w) > 4]

print(squares)
print(evens)
print(matrix)
print(upper_words)
```

### 第三步：把这个模板理解并默写（15分钟）
```python
# 两数之和（最经典的 Easy 题）
def two_sum(nums, target):
    seen = {}
    for i, n in enumerate(nums):
        complement = target - n
        if complement in seen:
            return [seen[complement], i]
        seen[n] = i
    return []

print(two_sum([2,7,11,15], 9))   # [0, 1]
print(two_sum([3,2,4], 6))       # [1, 2]
print(two_sum([], 5))            # [] ← 边界条件
```

### 第三步：HackerRank 做这 3 道题
1. **List Comprehensions**
2. **Find the Runner-Up Score**
3. **Nested Lists**

---

## Day 3 — 字典 & 集合（60-90分钟）

### 第一步：手打操作（15分钟）
```python
d = {"name": "Alice", "age": 25}

# 安全取值（不会 KeyError）
print(d.get("name"))          # Alice
print(d.get("salary", 0))     # 0（默认值）

# 遍历
for k, v in d.items():
    print(k, v)

# 集合运算
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b)   # 交集 {3, 4}
print(a | b)   # 并集 {1,2,3,4,5,6}
print(a - b)   # 差集 {1, 2}
```

### 第二步：defaultdict 专项练习（15分钟）
```python
from collections import defaultdict

# 场景1：统计词频（比普通 dict 方便很多）
def word_count(sentence):
    freq = defaultdict(int)
    for word in sentence.split():
        freq[word] += 1
    return dict(freq)

# 场景2：按某个属性分组
def group_by_length(words):
    groups = defaultdict(list)
    for w in words:
        groups[len(w)].append(w)
    return dict(groups)

print(word_count("the cat sat on the mat the cat"))
# {'the': 3, 'cat': 2, 'sat': 1, 'on': 1, 'mat': 1}

print(group_by_length(["hi","hello","hey","world","ok"]))
# {2: ['hi', 'ok'], 5: ['hello', 'world'], 3: ['hey']}
```

### 第三步：Counter 专项（10分钟）
```python
from collections import Counter

# 最常用的操作
c = Counter("abracadabra")
print(c)                    # 每个字符的频率
print(c.most_common(3))     # 前3个最常见的
print(c["a"])               # a 出现几次
print(list(c.keys()))       # 所有出现的字符

# 找出现次数最多的字符，并列时取字母最小的
def most_frequent_char(s):
    c = Counter(s)
    max_count = max(c.values())
    candidates = [ch for ch, cnt in c.items() if cnt == max_count]
    return min(candidates)  # 字母最小的

print(most_frequent_char("aabbcc"))  # a
```

### 第四步：HackerRank 做这 3 道
1. **Collections.Counter()**
2. **DefaultDict Tutorial**
3. **Word Order**

---

## Day 4 — 数学逻辑（60分钟）

### 第一步：把这 5 个模板全部默写出来（30分钟）

不要看笔记，直接默写，写不出来再看：

```python
import math

# 1. FizzBuzz
def fizzbuzz(n):
    for i in range(1, n+1):
        if i % 15 == 0: print("FizzBuzz")
        elif i % 3 == 0: print("Fizz")
        elif i % 5 == 0: print("Buzz")
        else: print(i)

# 2. 判断质数
def is_prime(n):
    if n < 2: return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0: return False
    return True

# 3. 斐波那契（返回第 n 个）
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

# 4. 最大公约数 & 最小公倍数
def gcd(a, b): return math.gcd(a, b)
def lcm(a, b): return a * b // math.gcd(a, b)

# 5. 数字各位求和
def digit_sum(n):
    return sum(int(d) for d in str(abs(n)))

# 测试
fizzbuzz(15)
print([n for n in range(20) if is_prime(n)])
print([fibonacci(i) for i in range(10)])
print(gcd(48, 18), lcm(4, 6))
print(digit_sum(12345))
```

### 第二步：HackerRank 做
1. **Integers Come In All Sizes**
2. **Triangle Quest**
3. 任意一道 Math Easy 题

---

## Day 5 — 排序进阶（60分钟）

### 第一步：lambda 排序练习（20分钟）
```python
# 场景1：按元组第二个元素排序
students = [("Alice",85), ("Bob",92), ("Charlie",78), ("Dave",85)]
print(sorted(students, key=lambda x: x[1]))           # 按分数升序
print(sorted(students, key=lambda x: x[1], reverse=True))  # 降序

# 场景2：按多个条件排序（先按分数降序，分数相同按名字升序）
print(sorted(students, key=lambda x: (-x[1], x[0])))

# 场景3：按字符串长度排序，长度相同按字母顺序
words = ["banana","apple","kiwi","fig","cherry"]
print(sorted(words, key=lambda x: (len(x), x)))

# 场景4：对字典列表排序
people = [{"name":"Alice","age":30}, {"name":"Bob","age":25}]
print(sorted(people, key=lambda x: x["age"]))
```

### 第二步：双指针模板（20分钟）
```python
# 模板1：判断回文
def is_palindrome(lst):
    left, right = 0, len(lst) - 1
    while left < right:
        if lst[left] != lst[right]: return False
        left += 1
        right -= 1
    return True

# 模板2：找数组中两个数之和等于 target（数组已排序）
def two_sum_sorted(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        s = nums[left] + nums[right]
        if s == target: return [left, right]
        elif s < target: left += 1
        else: right -= 1
    return []

print(is_palindrome([1,2,3,2,1]))   # True
print(two_sum_sorted([1,3,5,7,9], 8))  # [0, 3]
```

### 第三步：自己写一道题
> 给一个字符串列表，先按字符串长度排序，长度相同的按字母倒序排。写完测试边界：空列表、只有一个元素。

---

## Day 6 — 栈 & 队列（60分钟）

### 第一步：基础操作（10分钟）
```python
from collections import deque

# 栈（LIFO）
stack = []
stack.append("a")
stack.append("b")
print(stack.pop())   # b
print(stack[-1])     # 查看栈顶不弹出

# 队列（FIFO）
queue = deque()
queue.append(1)
queue.append(2)
print(queue.popleft())  # 1（从左边出）
```

### 第二步：括号匹配（最经典栈题，必须会）（20分钟）
```python
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

# 测试（包括边界条件）
print(is_valid("()[]{}"))   # True
print(is_valid("([)]"))     # False
print(is_valid("{[]}"))     # True
print(is_valid(""))         # True（空字符串）
print(is_valid("]"))        # False（只有右括号）
```

### 第三步：用栈解一道实际题（20分钟）
```python
# 题目：给一个整数数组，用栈找出每个元素右边第一个比它大的数
# 输入: [2, 1, 2, 4, 3]
# 输出: [4, 2, 4, -1, -1]（没有则返回 -1）

def next_greater(nums):
    result = [-1] * len(nums)
    stack = []  # 存 index
    for i, n in enumerate(nums):
        while stack and nums[stack[-1]] < n:
            idx = stack.pop()
            result[idx] = n
        stack.append(i)
    return result

print(next_greater([2, 1, 2, 4, 3]))  # [4, 2, 4, -1, -1]
```

---

## Day 7 — 复盘日（45分钟）

### Step 1：做一张自己的错题表（15分钟）

回顾这一周，记录：
- 哪类题最容易出错？
- 哪个语法经常忘？
- 边界条件有没有经常漏掉？

### Step 2：不看笔记，默写这些模板（20分钟）
```
1. 判断回文
2. 统计字符频率（Counter）
3. 两数之和（用 dict）
4. 判断质数
5. 括号匹配（用栈）
```

### Step 3：限时做 2 道综合题（30分钟，每题15分钟）

题目1：
> 给一个字符串，找出第一个不重复的字符，返回它的 index。如果不存在返回 -1。
> 例："leetcode" → 0，"aabb" → -1

题目2：
> 给一个整数数组，返回乘积最大的三个数之积。
> 例：[1,2,3,4] → 24，[-10,-10,1,3,2] → 300

---

## Day 8 — 二维数组（60分钟）

### 第一步：基础操作（15分钟）
```python
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

rows = len(matrix)
cols = len(matrix[0])

# 遍历
for i in range(rows):
    for j in range(cols):
        print(matrix[i][j], end=" ")
    print()

# 转置
transposed = list(map(list, zip(*matrix)))
# [[1,4,7],[2,5,8],[3,6,9]]

# 对角线元素
main_diag = [matrix[i][i] for i in range(rows)]          # [1,5,9]
anti_diag = [matrix[i][rows-1-i] for i in range(rows)]   # [3,5,7]
```

### 第二步：常见考题（30分钟）
```python
# 1. 顺时针旋转 90 度
def rotate_90(matrix):
    return [list(row) for row in zip(*matrix[::-1])]

# 2. 螺旋遍历（偶尔出）
def spiral_order(matrix):
    result = []
    while matrix:
        result += matrix.pop(0)
        matrix = list(zip(*matrix))[::-1]
    return result

print(rotate_90([[1,2,3],[4,5,6],[7,8,9]]))
print(spiral_order([[1,2,3],[4,5,6],[7,8,9]]))
```

---

## Day 9 — 递归（60分钟）

### 第一步：理解递归三要素（10分钟）
```
1. 终止条件（base case）
2. 递归调用（缩小问题规模）
3. 返回值
```

### 第二步：练习这 3 个（30分钟）
```python
# 1. 二分搜索
def binary_search(arr, target, left=0, right=None):
    if right is None: right = len(arr) - 1
    if left > right: return -1
    mid = (left + right) // 2
    if arr[mid] == target: return mid
    elif arr[mid] < target: return binary_search(arr, target, mid+1, right)
    else: return binary_search(arr, target, left, mid-1)

# 2. 幂运算
def power(base, exp):
    if exp == 0: return 1
    if exp % 2 == 0:
        half = power(base, exp // 2)
        return half * half
    return base * power(base, exp - 1)

# 3. 展平嵌套列表
def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

print(binary_search([1,3,5,7,9,11], 7))  # 3
print(power(2, 10))                       # 1024
print(flatten([1,[2,[3,4]],5]))           # [1,2,3,4,5]
```

---

## Day 10 — 补弱点日

### 根据你第 7 天的错题表，选对应的练习：

**如果字符串是弱点：**
- 做 HackerRank → Strings 里 5 道你没做过的题

**如果排序/lambda 是弱点：**
```python
# 专练这类题
data = [("Alice",85,"F"), ("Bob",92,"M"), ("Charlie",85,"M")]
# 按分数降序，分数相同按名字升序排
sorted(data, key=lambda x: (-x[1], x[0]))
```

**如果边界条件是弱点：**
- 把 Day 1-6 所有模板加上这些测试用例重跑一遍：
```python
# 空输入
func([])
func("")
# 单个元素
func([1])
func("a")
# 负数
func([-1, -2, -3])
# 全相同
func([5,5,5,5])
```

---

## Day 11 — 限时模拟①（60分钟）

### 规则
- 3 道题，每题严格 **15 分钟**，计时器一定要开
- 时间到了立刻停，不管写没写完
- 剩余 15 分钟复盘

### 今日题目（自己去 HackerRank 找同类型）：

**题1（字符串）：** 给一个字符串，判断它是否是另一个字符串的字母异位词（anagram）
```
"listen" 和 "silent" → True
"hello" 和 "world" → False
```

**题2（数组）：** 给一个数组，找出所有出现次数超过 n//2 的元素
```
[3,2,3] → [3]
[1,1,1,2,2,3] → [1]
```

**题3（数学）：** 给一个数，判断它是不是完全平方数，不能用 sqrt
```
16 → True
14 → False
```

### 15分钟复盘：
- 哪道题超时了？为什么？
- 有没有边界条件没考虑到？

---

## Day 12 — 限时模拟②（60分钟）

### 完全模拟 SHL 节奏：2 道题，45 分钟

**题1：**
> 给一个字符串，找出出现次数最多的字符。如果有多个字符次数相同，返回字母表中最小的那个。空字符串返回空字符串。

```python
# 期望输出
most_frequent("aabbbcc") → "b"
most_frequent("aabb")    → "a"
most_frequent("")         → ""
```

**题2：**
> 给一个整数数组和目标值 target，找出数组中所有和等于 target 的不重复二元组，返回列表。

```python
# 期望输出
find_pairs([1,2,3,4,5,6], 7) → [(1,6),(2,5),(3,4)]
find_pairs([1,1,2,3], 4)     → [(1,3)]  # 不重复
find_pairs([], 5)             → []
```

**做完之后对答案：** 所有测试用例过了吗？

---

## Day 13 — 边界条件专项（45分钟）

### 把这 6 类边界条件变成习惯

每道题写完之前都问自己这 6 个问题：

```python
"""
1. 输入为空？         → [] 或 "" 或 None
2. 只有一个元素？     → 不要假设 len >= 2
3. 有负数？           → 数学逻辑还成立吗
4. 有重复元素？       → 去重逻辑对吗
5. 返回类型对吗？     → 要 list 别返回 tuple，要 int 别返回 float
6. 数字超大？         → Python 不会溢出，但逻辑还对吗
"""

# 练习：给下面这个函数加边界条件处理
def find_max_pair_sum(nums):
    # 找两个数之和的最大值
    nums.sort()
    return nums[-1] + nums[-2]

# 问题：如果 nums 是空列表？如果只有一个元素？
# 修复版：
def find_max_pair_sum_safe(nums):
    if len(nums) < 2: return None  # 或者 raise ValueError
    nums.sort()
    return nums[-1] + nums[-2]
```

### 专项练习：把 Day 11-12 的题全部加上边界测试重跑一遍

---

## Day 14 — 考前最终模拟（75分钟）

### 模拟考试（60分钟）

找安静的地方，手机放一边，**不查任何资料**：

**题1：** 给一个句子，返回其中最长的单词。如果有多个同样长的，返回第一个出现的。

**题2：** 给一个正整数，判断它是否是回文数（不转成字符串来做）。

**题3：** 给两个列表 A 和 B，找出所有在 A 中出现但不在 B 中的元素，以及在 B 中出现但不在 A 中的元素，合并返回（去重，升序）。

### 最后15分钟：检查清单

```
✅ 每道题的边界条件都处理了吗？
✅ 函数有 return 吗（别忘了返回值）？
✅ 测试用例都跑过了吗？
✅ 变量名是否清晰（别用 a/b/x 这种）？
```

### 考试当天记住

- 先**读完所有题目**，从最有把握的开始
- 能通过部分测试用例也比完全不提交好
- 代码**能跑通**比最优解更重要
- 时间不够时，优先保证已写部分是对的

---



想要我帮你出每天的参考答案，或者模拟出题吗？
</pre>