py 数据结构

day02/dict_basics.py

@@ -0,0 +1,80 @@
+"""dict_basics.py - Python 字典基础示例
+
+包含常见的字典操作示例：创建、访问、添加、修改、删除、遍历、嵌套和推导式等。
+运行后会打印每个示例的结果，并在代码中注释预期输出。
+"""
+
+
+def main():
+    # 1. 创建字典
+    student = {"name": "Tom", "age": 18, "city": "Beijing"}
+    print("student ->", student)
+
+    # 2. 访问值
+    print("student['name'] ->", student["name"])  # Tom
+    print("student['age'] ->", student["age"])    # 18
+
+    # 3. 安全获取值
+    print("student.get('score') ->", student.get("score"))        # None
+    print("student.get('score', 0) ->", student.get("score", 0))  # 0
+
+    # 4. 添加和修改
+    student["score"] = 95
+    student["age"] = 19
+    print("after add/modify ->", student)
+
+    # 5. 删除键值对
+    del student["city"]
+    print("after del student['city'] ->", student)
+
+    # pop() 删除指定键并返回值
+    age = student.pop("age")
+    print("age popped ->", age)
+    print("after pop('age') ->", student)
+
+    # 6. 判断 key 是否存在
+    print("'name' in student ->", "name" in student)       # True
+    print("'score' in student ->", "score" in student)     # True
+    print("'city' in student ->", "city" in student)       # False
+
+    # 7. 遍历字典
+    for key in student:
+        print("loop key ->", key)
+
+    for key, value in student.items():
+        print("loop item ->", key, value)
+
+    for value in student.values():
+        print("loop value ->", value)
+
+    # 8. 常见方法
+    print("student.keys() ->", student.keys())
+    print("student.values() ->", student.values())
+    print("student.items() ->", student.items())
+    print("len(student) ->", len(student))
+
+    # 9. 字典嵌套
+    users = {
+        "alice": {"age": 20, "city": "Shanghai"},
+        "bob": {"age": 22, "city": "Hangzhou"}
+    }
+    print("users['alice']['city'] ->", users["alice"]["city"])  # Shanghai
+
+    # 10. 字典推导式
+    squares = {x: x * x for x in range(1, 5)}
+    print("squares ->", squares)  # {1: 1, 2: 4, 3: 9, 4: 16}
+
+    # 11. 统计频次
+    counts = {"apple": 3, "banana": 2}
+    counts["apple"] += 1
+    print("counts ->", counts)
+
+    # 12. 说明：
+    # - 键唯一
+    # - 通过 key 快速查找 value
+    # - 适合表达“映射关系”
+    # - Python 3.7+ 保留插入顺序
+
+
+if __name__ == '__main__':
+    main()

day02/example01.py

@@ -0,0 +1,57 @@
+"""
+example01 - 列表切片示例
+auther: tanlie
+date: 2026/8/22
+
+本文件演示关于负索引和切片（slice）的常见用法，
+并在每个示例旁给出注释和预期输出。
+"""
+
+# 练习用的列表
+skills = ["python", "java", "c++", "c#", "javascript"]
+
+# print("skills =", skills)
+# # skills = ['python', 'java', 'c++', 'c#', 'javascript']
+#
+# # 1) 取最后一个元素（元素本身，类型是 str）
+# last_elem = skills[-1]
+# print("skills[-1] ->", last_elem, type(last_elem))
+# # 输出: skills[-1] -> javascript <class 'str'>
+#
+# # 2) 取从最后一个元素到末尾的切片（返回列表）
+# last_slice = skills[-1:]
+# print("skills[-1:] ->", last_slice, type(last_slice))
+# # 输出: skills[-1:] -> ['javascript'] <class 'list'>
+#
+# # 3) 当 start 索引在 stop 索引之后，且 step 为正时，结果为空列表
+# empty_slice = skills[-1:0]
+# print("skills[-1:0] ->", empty_slice, type(empty_slice))
+# # 输出: skills[-1:0] -> [] <class 'list'>
+#
+# # 4) 取最后两个元素
+# last_two = skills[-2:]
+# print("skills[-2:] ->", last_two)
+# # 输出: skills[-2:] -> ['c#', 'javascript']
+#
+# # 5) 取中间一段：从 -3（c++）到 -1（不含） => 包含索引 2 和 3
+# mid_slice = skills[-3:-1]
+# print("skills[-3:-1] ->", mid_slice)
+# # 输出: skills[-3:-1] -> ['c++', 'c#']
+#
+# # 6) 使用负步长，从最后向前切到索引 0（不含 0）
+# reverse_part = skills[-1:0:-1]
+# print("skills[-1:0:-1] ->", reverse_part)
+# # 输出: skills[-1:0:-1] -> ['javascript', 'c#', 'c++', 'java']
+#
+# # 7) 完整反转列表（等价于 list(reversed(skills))）
+# reversed_all = skills[::-1]
+# print("skills[::-1] ->", reversed_all)
+# # 输出: skills[::-1] -> ['javascript', 'c#', 'c++', 'java', 'python']
+#
+# # 额外提示：如果你只想以列表形式获取最后一个元素，使用
+# #   skills[-1:]
+# # 如果想获取元素本身（不是列表），使用
+# #   skills[-1]
+
+skills2 = ["python", "java", "c++", "c#", "javascript"]
+print(skills + skills2) # list 是可变的，元素是可以重复的，使用 + 号可以拼接两个列表，返回一个新的列表

day02/list_basics.py

@@ -0,0 +1,85 @@
+"""list_basics.py - Python 列表基础示例
+
+包含常见的列表操作示例：创建、访问、切片、增删、查询、排序、复制、遍历、推导式等。
+运行后会打印每个示例的结果（并在代码中注释预期输出）。
+"""
+
+import copy
+
+def main():
+    skills = ["python", "java", "c++", "c#", "javascript"]
+
+    print("原始列表:", skills)
+    # 访问与切片
+    print("skills[0] ->", skills[0])           # python
+    print("skills[-1] ->", skills[-1])         # javascript
+    print("skills[1:4] ->", skills[1:4])       # ['java', 'c++', 'c#']
+    print("skills[-2:] ->", skills[-2:])       # ['c#', 'javascript']
+    print("skills[::-1] ->", skills[::-1])     # 反转，返回新列表
+
+    # 增加
+    skills.append("go")
+    print("append ->", skills)                 # 尾部添加
+
+    skills.extend(["rust", "swift"])
+    print("extend ->", skills)                 # 尾部添加多个
+
+    skills.insert(1, "typescript")
+    print("insert ->", skills)                 # 在索引1前插入
+
+    # 删除
+    skills.remove("java")               # 删除第一个 'java'
+    print("remove('java') ->", skills)
+
+    popped = skills.pop()                      # 弹出最后一个
+    print("pop() ->", popped, "; after pop ->", skills)
+
+    popped_idx = skills.pop(2)                 # 弹出索引2的元素
+    print("pop(2) ->", popped_idx, "; after pop ->", skills)
+
+    # 查询
+    print("'python' in skills ->", 'python' in skills)
+    print("skills.count('python') ->", skills.count('python'))
+
+    # 排序与反转
+    nums = [3, 1, 4, 1, 5]
+    print("nums before:", nums)
+    print("sorted(nums) ->", sorted(nums))     # 返回新列表
+    nums.sort()
+    print("nums after sort() ->", nums)        # 原地排序
+    nums.reverse()
+    print("nums after reverse() ->", nums)     # 原地反转
+
+    # 复制与可变性
+    a = [1, 2, [3, 4]]
+    b = a          # b 与 a 指向同一个对象
+    c = a[:]       # 浅拷贝，顶层复制
+    d = copy.deepcopy(a)  # 深拷贝
+
+    a[0] = 100
+    a[2].append(5)
+    print("a:", a)
+    print("b (same ref):", b)    # 反映 a 的所有变化
+    print("c (shallow copy):", c) # c[0] 未改变，但 c[2]（嵌套列表）受影响
+    print("d (deep copy):", d)    # 完全独立
+
+    # 遍历与推导式
+    for i, val in enumerate(['a', 'b', 'c']):
+        print("enumerate:", i, val)
+
+    squares = [x*x for x in range(6) if x % 2 == 0]
+    print("squares (comprehension):", squares)
+
+    # 例：交换两个元素
+    arr = [1, 2, 3]
+    arr[0], arr[2] = arr[2], arr[0]
+    print("swap arr ->", arr)
+
+    # 解包（剩余收集）
+    first, *middle, last = [10, 20, 30, 40, 50]
+    print("unpack ->", first, middle, last)
+
+
+if __name__ == '__main__':
+    main()
+

day02/set_basics.py

@@ -0,0 +1,89 @@
+"""set_basics.py - Python 集合基础示例
+
+包含常见的集合操作示例：创建、添加、删除、成员判断、集合运算、去重、推导式等。
+运行后会打印每个示例的结果，并在代码中注释预期输出。
+"""
+
+
+def main():
+    # 1. 创建集合
+    fruits = {"apple", "banana", "orange"}
+    nums = {1, 2, 3, 3, 4}          # 重复元素会自动去重
+    empty_set = set()               # 空集合必须用 set()，不能写 {}，{} 是空字典
+    mixed = {1, "python", (2, 3)}  # 集合元素必须是可哈希对象
+
+    print("fruits ->", fruits)
+    print("nums ->", nums)          # {1, 2, 3, 4}
+    print("empty_set ->", empty_set)
+    print("mixed ->", mixed)
+
+    # 2. 添加元素
+    fruits.add("grape")
+    fruits.add("apple")   # 已存在，重复添加不会报错
+    print("after add ->", fruits)
+
+    # 3. 删除元素
+    fruits.remove("banana")
+    print("after remove('banana') ->", fruits)
+
+    # discard() 不会因为不存在而报错
+    fruits.discard("pear")
+    print("after discard('pear') ->", fruits)
+
+    # pop() 随机弹出一个元素
+    popped = fruits.pop()
+    print("pop() ->", popped, "; after pop ->", fruits)
+
+    # 4. 成员判断
+    print("'apple' in fruits ->", 'apple' in fruits)
+    print("'mango' in fruits ->", 'mango' in fruits)
+
+    # 5. 长度与遍历
+    print("len(fruits) ->", len(fruits))
+    for item in fruits:
+        print("loop ->", item)
+
+    # 6. 集合运算：并集、交集、差集、对称差集
+    a = {1, 2, 3, 4}
+    b = {3, 4, 5, 6}
+
+    print("a | b ->", a | b)          # 并集
+    print("a.union(b) ->", a.union(b))
+
+    print("a & b ->", a & b)          # 交集
+    print("a.intersection(b) ->", a.intersection(b))
+
+    print("a - b ->", a - b)          # 差集
+    print("a.difference(b) ->", a.difference(b))
+
+    print("a ^ b ->", a ^ b)          # 对称差集
+    print("a.symmetric_difference(b) ->", a.symmetric_difference(b))
+
+    # 7. 子集和超集
+    c = {1, 2}
+    print("c.issubset(a) ->", c.issubset(a))
+    print("a.issuperset(c) ->", a.issuperset(c))
+
+    # 8. 集合推导式
+    squares = {x * x for x in range(1, 8) if x % 2 == 0}
+    print("squares ->", squares)
+
+    # 9. 去重
+    names = ["alice", "bob", "alice", "charlie", "bob"]
+    unique_names = set(names)
+    print("unique_names ->", unique_names)
+
+    # 10. 冰冻集合（不可变集合）
+    frozen = frozenset({1, 2, 3})
+    print("frozen ->", frozen)
+    # frozen.add(4)  # 会报错，因为 frozenset 不可修改
+
+    # 11. 集合的特点
+    # - 无序
+    # - 元素唯一
+    # - 可变（set）/ 不可变（frozenset）
+    # - 适合去重、快速判断成员是否存在
+
+
+if __name__ == '__main__':
+    main()

day02/tuple_basics.py

@@ -0,0 +1,78 @@
+"""tuple_basics.py - Python 元组基础示例
+一句话总结：元组就是“固定、稳定、不可修改的一组数据”。
+包含常见的元组操作示例：创建、访问、切片、拼接、查找、解包、不可变性等。
+运行后会打印每个示例的结果，并在代码中注释预期输出。
+"""
+
+
+def main():
+    # 1. 创建元组
+    nums = (1, 2, 3, 4)
+    names = ("alice", "bob", "charlie")
+    mixed = (10, "python", True, 3.14)
+    empty = ()
+    single = (42,)   # 只有一个元素时必须保留逗号
+
+    print("nums ->", nums)
+    print("names ->", names)
+    print("mixed ->", mixed)
+    print("empty ->", empty)
+    print("single ->", single)
+
+    # 2. 访问元素
+    print("nums[0] ->", nums[0])      # 1
+    print("nums[-1] ->", nums[-1])    # 4
+    print("names[1] ->", names[1])    # bob
+
+    # 3. 切片
+    print("nums[1:3] ->", nums[1:3])    # (2, 3)
+    print("names[:2] ->", names[:2])    # ('alice', 'bob')
+    print("nums[::-1] ->", nums[::-1])  # 反转，返回新元组
+
+    # 4. 长度和成员判断
+    print("len(nums) ->", len(nums))
+    print("2 in nums ->", 2 in nums)
+    print("5 in nums ->", 5 in nums)
+
+    # 5. 计数和查找
+    numbers = (1, 2, 2, 3, 2, 4)
+    print("numbers.count(2) ->", numbers.count(2))    # 3
+    print("numbers.index(3) ->", numbers.index(3))    # 3
+
+    # 6. 拼接
+    print("nums + (5, 6) ->", nums + (5, 6))
+
+    # 7. 元组不可变：不能修改元素
+    # 如果取消下面注释，会报错：TypeError
+    # nums[0] = 100
+
+    # 8. 多重赋值（解包）
+    student = ("Tom", 18, "CS")
+    name, age, major = student
+    print("unpack ->", name, age, major)
+
+    # 9. 部分解包（*）
+    first, *rest, last = (10, 20, 30, 40, 50)
+    print("first, *rest, last ->", first, rest, last)
+
+    # 10. 迭代
+    for item in names:
+        print("loop ->", item)
+
+    # 11. 元组常用于固定数据
+    point = (10, 20)
+    x, y = point
+    print("point = (10, 20), x, y ->", x, y)
+
+    # 12. 与列表区别
+    # 列表可以修改，元组不能修改
+    list_example = [1, 2, 3]
+    tuple_example = (1, 2, 3)
+
+    list_example[0] = 100
+    print("list_example after change ->", list_example)
+    # tuple_example[0] = 100  # 会报错，元组不可变
+
+
+if __name__ == '__main__':
+    main()

note/python_data_structures_cheatsheet.md

@@ -0,0 +1,151 @@
+# Python 常见数据结构速查表
+
+## 1. 列表 list
+
+- 语法：
+  ```python
+  nums = [1, 2, 3]
+  ```
+- 特点：
+  - 有序
+  - 可变
+  - 可放重复元素
+- 常用操作：
+  ```python
+  nums.append(4)
+  nums.remove(2)
+  nums[0]
+  nums[1:3]
+  ```
+
+## 2. 元组 tuple
+
+- 语法：
+  ```python
+  point = (10, 20)
+  ```
+- 特点：
+  - 有序
+  - 不可变
+  - 可放重复元素
+- 常用操作：
+  ```python
+  point[0]
+  len(point)
+  point.count(10)
+  ```
+
+## 3. 集合 set
+
+- 语法：
+  ```python
+  s = {1, 2, 3}
+  ```
+- 特点：
+  - 无序
+  - 元素唯一
+  - 可变
+- 常用操作：
+  ```python
+  s.add(4)
+  s.remove(2)
+  3 in s
+  ```
+
+## 4. 字典 dict
+
+- 语法：
+  ```python
+  stu = {"name": "Tom", "age": 18}
+  ```
+- 特点：
+  - 键值对
+  - key 唯一
+  - 无序（Python 3.7+ 记录插入顺序）
+- 常用操作：
+  ```python
+  stu["name"]
+  stu["age"] = 19
+  stu.keys()
+  stu.values()
+  ```
+
+## 5. 字符串 str
+
+- 语法：
+  ```python
+  msg = "hello"
+  ```
+- 特点：
+  - 不可变
+  - 由字符组成
+- 常用操作：
+  ```python
+  msg.lower()
+  msg.upper()
+  msg.strip()
+  msg.split(" ")
+  ```
+
+## 6. 范围 range
+
+- 语法：
+  ```python
+  r = range(5)
+  ```
+- 特点：
+  - 表示一段连续整数
+  - 常用于循环
+- 例子：
+  ```python
+  for i in range(5):
+      print(i)
+  ```
+
+## 7. 冰冻集合 frozenset
+
+- 语法：
+  ```python
+  fs = frozenset({1, 2, 3})
+  ```
+- 特点：
+  - 跟 set 类似
+  - 但不可变
+- 用途：
+  - 作为字典 key
+  - 需要固定集合时
+
+## 8. 生成器/迭代器
+
+- 例子：
+  ```python
+  gen = (x * x for x in range(5))
+  ```
+- 特点：
+  - 惰性计算
+  - 适合大数据/流式处理
+
+## 快速对比
+
+- 列表：`[ ]`，可变，有序
+- 元组：`( )`，不可变，有序
+- 集合：`{ }`，去重，无序
+- 字典：`{ key: value }`，键值对
+- 字符串：`" "`，文本
+- range：连续整数序列
+
+## 记忆口诀
+
+- `[]` -> 列表
+- `()` -> 元组
+- `{}` -> 集合或字典（看里面是否是 `key: value`）
+- `""` -> 字符串
+
+## 常见使用场景
+
+- 列表：存放多个值，易修改
+- 元组：存放固定值，确保数据不变
+- 集合：去重、快速查重
+- 字典：映射关系，如姓名-年龄
+- 字符串：文本处理
+- range：循环计数