wehub-skill-sync
657 lines
12 KiB
Markdown
657 lines
12 KiB
Markdown
# Python 快速参考
|
||
|
||
## 基本语法
|
||
|
||
### 变量与类型
|
||
```python
|
||
# 动态类型
|
||
x = 5 # int
|
||
y = 3.14 # float
|
||
name = "Alice" # str
|
||
is_valid = True # bool
|
||
|
||
# 类型提示（可选，Python 3.5+）
|
||
def greet(name: str) -> str:
|
||
return f"Hello, {name}"
|
||
|
||
# 多重赋值
|
||
a, b, c = 1, 2, 3
|
||
x = y = z = 0
|
||
```
|
||
|
||
### 字符串
|
||
```python
|
||
# 字符串创建
|
||
s = "hello"
|
||
s = 'hello'
|
||
s = """multi
|
||
line"""
|
||
|
||
# F-字符串（Python 3.6+）
|
||
name = "Alice"
|
||
age = 30
|
||
message = f"{name} is {age} years old"
|
||
|
||
# 常用方法
|
||
s.upper() # "HELLO"
|
||
s.lower() # "hello"
|
||
s.strip() # 移除空白字符
|
||
s.split(',') # 拆分为列表
|
||
s.replace('h', 'H') # "Hello"
|
||
s.startswith('he') # True
|
||
s.endswith('lo') # True
|
||
s.find('ll') # 2（索引，未找到返回 -1）
|
||
|
||
# 切片
|
||
s[0] # 'h'
|
||
s[-1] # 'o'
|
||
s[1:4] # 'ell'
|
||
s[::-1] # 'olleh'（反转）
|
||
```
|
||
|
||
### 列表
|
||
```python
|
||
# 创建
|
||
nums = [1, 2, 3, 4, 5]
|
||
mixed = [1, "hello", True, 3.14]
|
||
|
||
# 常用操作
|
||
nums.append(6) # 添加到末尾
|
||
nums.insert(0, 0) # 在指定索引处插入
|
||
nums.remove(3) # 移除首次出现的元素
|
||
nums.pop() # 移除并返回最后一个元素
|
||
nums.pop(0) # 移除并返回指定索引的元素
|
||
nums.extend([7, 8]) # 添加多个元素
|
||
len(nums) # 长度
|
||
nums.sort() # 原地排序
|
||
sorted(nums) # 返回排序后的副本
|
||
nums.reverse() # 原地反转
|
||
nums[::-1] # 返回反转后的副本
|
||
|
||
# 列表推导式
|
||
squares = [x**2 for x in range(10)]
|
||
evens = [x for x in range(10) if x % 2 == 0]
|
||
```
|
||
|
||
### 字典
|
||
```python
|
||
# 创建
|
||
person = {'name': 'Alice', 'age': 30}
|
||
person = dict(name='Alice', age=30)
|
||
|
||
# 访问
|
||
name = person['name'] # 键不存在时抛出 KeyError
|
||
name = person.get('name') # 键不存在时返回 None
|
||
name = person.get('name', 'Unknown') # 指定默认值
|
||
|
||
# 修改
|
||
person['city'] = 'NYC' # 添加/更新
|
||
del person['age'] # 删除
|
||
age = person.pop('age', 0) # 删除并返回
|
||
|
||
# 迭代
|
||
for key in person:
|
||
print(key, person[key])
|
||
|
||
for key, value in person.items():
|
||
print(key, value)
|
||
|
||
# 字典推导式
|
||
squares = {x: x**2 for x in range(5)}
|
||
```
|
||
|
||
### 集合
|
||
```python
|
||
# 创建
|
||
s = {1, 2, 3, 4, 5}
|
||
s = set([1, 2, 3, 3, 3]) # {1, 2, 3}
|
||
|
||
# 操作
|
||
s.add(6) # 添加元素
|
||
s.remove(3) # 移除（元素不存在时抛出 KeyError）
|
||
s.discard(3) # 移除（元素不存在时不报错）
|
||
s.union({4, 5, 6}) # {1, 2, 3, 4, 5, 6}
|
||
s.intersection({3, 4}) # {3, 4}
|
||
s.difference({3, 4}) # {1, 2, 5}
|
||
```
|
||
|
||
---
|
||
|
||
## 控制流
|
||
|
||
### If-Elif-Else
|
||
```python
|
||
x = 10
|
||
|
||
if x > 0:
|
||
print("Positive")
|
||
elif x < 0:
|
||
print("Negative")
|
||
else:
|
||
print("Zero")
|
||
|
||
# 三元表达式
|
||
result = "Positive" if x > 0 else "Non-positive"
|
||
```
|
||
|
||
### 循环
|
||
```python
|
||
# For 循环
|
||
for i in range(5): # 0, 1, 2, 3, 4
|
||
print(i)
|
||
|
||
for i in range(2, 10, 2): # 2, 4, 6, 8
|
||
print(i)
|
||
|
||
for item in [1, 2, 3]:
|
||
print(item)
|
||
|
||
# Enumerate（索引 + 值）
|
||
for i, val in enumerate(['a', 'b', 'c']):
|
||
print(f"{i}: {val}")
|
||
|
||
# While 循环
|
||
i = 0
|
||
while i < 5:
|
||
print(i)
|
||
i += 1
|
||
|
||
# Break 和 continue
|
||
for i in range(10):
|
||
if i == 3:
|
||
continue # 跳过 3
|
||
if i == 8:
|
||
break # 在 8 处停止
|
||
print(i)
|
||
```
|
||
|
||
---
|
||
|
||
## 函数
|
||
|
||
### 基本函数
|
||
```python
|
||
def greet(name):
|
||
return f"Hello, {name}"
|
||
|
||
# 默认参数
|
||
def greet(name="World"):
|
||
return f"Hello, {name}"
|
||
|
||
# 多个返回值
|
||
def divide(a, b):
|
||
return a // b, a % b # 返回元组
|
||
|
||
quotient, remainder = divide(10, 3)
|
||
|
||
# *args 和 **kwargs
|
||
def print_all(*args):
|
||
for arg in args:
|
||
print(arg)
|
||
|
||
def print_info(**kwargs):
|
||
for key, value in kwargs.items():
|
||
print(f"{key}: {value}")
|
||
|
||
print_all(1, 2, 3)
|
||
print_info(name="Alice", age=30)
|
||
```
|
||
|
||
### Lambda 函数
|
||
```python
|
||
# 匿名函数
|
||
square = lambda x: x ** 2
|
||
add = lambda x, y: x + y
|
||
|
||
# 常用于 map、filter、sorted
|
||
nums = [1, 2, 3, 4, 5]
|
||
squares = list(map(lambda x: x**2, nums))
|
||
evens = list(filter(lambda x: x % 2 == 0, nums))
|
||
sorted_tuples = sorted([(1, 'c'), (2, 'a')], key=lambda x: x[1])
|
||
```
|
||
|
||
---
|
||
|
||
## 面向对象编程
|
||
|
||
### 类
|
||
```python
|
||
class Person:
|
||
# 类变量
|
||
species = "Homo sapiens"
|
||
|
||
def __init__(self, name, age):
|
||
# 实例变量
|
||
self.name = name
|
||
self.age = age
|
||
|
||
def greet(self):
|
||
return f"Hello, I'm {self.name}"
|
||
|
||
def __str__(self):
|
||
return f"Person(name={self.name}, age={self.age})"
|
||
|
||
def __repr__(self):
|
||
return f"Person('{self.name}', {self.age})"
|
||
|
||
# 使用
|
||
p = Person("Alice", 30)
|
||
print(p.greet())
|
||
print(p) # 使用 __str__
|
||
```
|
||
|
||
### 继承
|
||
```python
|
||
class Animal:
|
||
def __init__(self, name):
|
||
self.name = name
|
||
|
||
def speak(self):
|
||
pass
|
||
|
||
class Dog(Animal):
|
||
def speak(self):
|
||
return f"{self.name} says Woof!"
|
||
|
||
class Cat(Animal):
|
||
def speak(self):
|
||
return f"{self.name} says Meow!"
|
||
|
||
dog = Dog("Buddy")
|
||
print(dog.speak()) # Buddy says Woof!
|
||
```
|
||
|
||
### 属性
|
||
```python
|
||
class Circle:
|
||
def __init__(self, radius):
|
||
self._radius = radius
|
||
|
||
@property
|
||
def radius(self):
|
||
return self._radius
|
||
|
||
@radius.setter
|
||
def radius(self, value):
|
||
if value < 0:
|
||
raise ValueError("Radius cannot be negative")
|
||
self._radius = value
|
||
|
||
@property
|
||
def area(self):
|
||
return 3.14159 * self._radius ** 2
|
||
|
||
# 使用
|
||
c = Circle(5)
|
||
print(c.area) # 78.53975
|
||
c.radius = 10 # 使用 setter
|
||
```
|
||
|
||
### 特殊方法（魔术方法）
|
||
```python
|
||
class Vector:
|
||
def __init__(self, x, y):
|
||
self.x = x
|
||
self.y = y
|
||
|
||
def __add__(self, other):
|
||
return Vector(self.x + other.x, self.y + other.y)
|
||
|
||
def __str__(self):
|
||
return f"Vector({self.x}, {self.y})"
|
||
|
||
def __len__(self):
|
||
return 2
|
||
|
||
def __getitem__(self, index):
|
||
return [self.x, self.y][index]
|
||
|
||
v1 = Vector(1, 2)
|
||
v2 = Vector(3, 4)
|
||
v3 = v1 + v2 # 使用 __add__
|
||
print(v3) # 使用 __str__
|
||
```
|
||
|
||
---
|
||
|
||
## 文件 I/O
|
||
|
||
```python
|
||
# 读取
|
||
with open('file.txt', 'r') as f:
|
||
content = f.read() # 读取整个文件
|
||
# 或
|
||
lines = f.readlines() # 读取为行列表
|
||
# 或
|
||
for line in f: # 逐行迭代
|
||
print(line.strip())
|
||
|
||
# 写入
|
||
with open('file.txt', 'w') as f:
|
||
f.write("Hello\n")
|
||
f.writelines(["Line 1\n", "Line 2\n"])
|
||
|
||
# 追加
|
||
with open('file.txt', 'a') as f:
|
||
f.write("New line\n")
|
||
|
||
# JSON
|
||
import json
|
||
|
||
# 写入 JSON
|
||
data = {'name': 'Alice', 'age': 30}
|
||
with open('data.json', 'w') as f:
|
||
json.dump(data, f, indent=2)
|
||
|
||
# 读取 JSON
|
||
with open('data.json', 'r') as f:
|
||
data = json.load(f)
|
||
```
|
||
|
||
---
|
||
|
||
## 错误处理
|
||
|
||
```python
|
||
# Try-except
|
||
try:
|
||
result = 10 / 0
|
||
except ZeroDivisionError:
|
||
print("Cannot divide by zero")
|
||
except Exception as e:
|
||
print(f"Error: {e}")
|
||
else:
|
||
print("No errors") # 未发生异常时执行
|
||
finally:
|
||
print("Always runs") # 始终执行
|
||
|
||
# 抛出异常
|
||
def divide(a, b):
|
||
if b == 0:
|
||
raise ValueError("Divisor cannot be zero")
|
||
return a / b
|
||
|
||
# 自定义异常
|
||
class InvalidAgeError(Exception):
|
||
pass
|
||
|
||
def set_age(age):
|
||
if age < 0:
|
||
raise InvalidAgeError("Age cannot be negative")
|
||
```
|
||
|
||
---
|
||
|
||
## 常用库
|
||
|
||
### Collections
|
||
```python
|
||
from collections import Counter, defaultdict, deque
|
||
|
||
# Counter
|
||
words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
|
||
count = Counter(words)
|
||
print(count['apple']) # 3
|
||
print(count.most_common(2)) # [('apple', 3), ('banana', 2)]
|
||
|
||
# defaultdict
|
||
d = defaultdict(list)
|
||
d['key'].append(1) # 不会抛出 KeyError
|
||
|
||
# deque（双端队列）
|
||
q = deque([1, 2, 3])
|
||
q.append(4) # 从右侧添加
|
||
q.appendleft(0) # 从左侧添加
|
||
q.pop() # 从右侧移除
|
||
q.popleft() # 从左侧移除
|
||
```
|
||
|
||
### Itertools
|
||
```python
|
||
from itertools import combinations, permutations, product
|
||
|
||
# 组合
|
||
list(combinations([1, 2, 3], 2)) # [(1, 2), (1, 3), (2, 3)]
|
||
|
||
# 排列
|
||
list(permutations([1, 2, 3], 2)) # [(1, 2), (1, 3), (2, 1), ...]
|
||
|
||
# 笛卡尔积
|
||
list(product([1, 2], ['a', 'b'])) # [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
|
||
```
|
||
|
||
### Functools
|
||
```python
|
||
from functools import lru_cache, reduce
|
||
|
||
# 记忆化
|
||
@lru_cache(maxsize=None)
|
||
def fibonacci(n):
|
||
if n < 2:
|
||
return n
|
||
return fibonacci(n-1) + fibonacci(n-2)
|
||
|
||
# Reduce
|
||
from functools import reduce
|
||
product = reduce(lambda x, y: x * y, [1, 2, 3, 4]) # 24
|
||
```
|
||
|
||
---
|
||
|
||
## 列表/字典/集合推导式
|
||
|
||
```python
|
||
# 列表推导式
|
||
squares = [x**2 for x in range(10)]
|
||
evens = [x for x in range(10) if x % 2 == 0]
|
||
nested = [[i for i in range(3)] for j in range(3)]
|
||
|
||
# 字典推导式
|
||
squares_dict = {x: x**2 for x in range(5)}
|
||
filtered = {k: v for k, v in squares_dict.items() if v > 5}
|
||
|
||
# 集合推导式
|
||
unique_lengths = {len(word) for word in ['apple', 'banana', 'kiwi']}
|
||
|
||
# 生成器表达式（内存高效）
|
||
sum_of_squares = sum(x**2 for x in range(1000000))
|
||
```
|
||
|
||
---
|
||
|
||
## 有用的内置函数
|
||
|
||
```python
|
||
# any, all
|
||
any([False, True, False]) # True（至少一个为 True）
|
||
all([True, True, True]) # True（全部为 True）
|
||
|
||
# zip
|
||
names = ['Alice', 'Bob']
|
||
ages = [30, 25]
|
||
for name, age in zip(names, ages):
|
||
print(f"{name}: {age}")
|
||
|
||
# enumerate
|
||
for i, val in enumerate(['a', 'b', 'c']):
|
||
print(f"{i}: {val}")
|
||
|
||
# map, filter
|
||
nums = [1, 2, 3, 4, 5]
|
||
squared = list(map(lambda x: x**2, nums))
|
||
evens = list(filter(lambda x: x % 2 == 0, nums))
|
||
|
||
# sorted, reversed
|
||
sorted([3, 1, 2]) # [1, 2, 3]
|
||
sorted([3, 1, 2], reverse=True) # [3, 2, 1]
|
||
list(reversed([1, 2, 3])) # [3, 2, 1]
|
||
|
||
# max, min, sum
|
||
max([1, 5, 3]) # 5
|
||
min([1, 5, 3]) # 1
|
||
sum([1, 2, 3]) # 6
|
||
```
|
||
|
||
---
|
||
|
||
## 常用惯用法
|
||
|
||
### 变量交换
|
||
```python
|
||
a, b = b, a
|
||
```
|
||
|
||
### 三元运算符
|
||
```python
|
||
result = "Even" if x % 2 == 0 else "Odd"
|
||
```
|
||
|
||
### 字典默认值
|
||
```python
|
||
value = my_dict.get('key', default_value)
|
||
```
|
||
|
||
### 带起始值的 Enumerate
|
||
```python
|
||
for i, val in enumerate(items, start=1):
|
||
print(f"{i}. {val}")
|
||
```
|
||
|
||
### 解包
|
||
```python
|
||
first, *middle, last = [1, 2, 3, 4, 5]
|
||
# first=1, middle=[2,3,4], last=5
|
||
```
|
||
|
||
### 上下文管理器
|
||
```python
|
||
with open('file.txt') as f:
|
||
data = f.read()
|
||
# 文件自动关闭
|
||
```
|
||
|
||
---
|
||
|
||
## 最佳实践
|
||
|
||
### 1. PEP 8 风格指南
|
||
```python
|
||
# 使用 4 个空格缩进
|
||
# 变量和函数使用 snake_case
|
||
# 类使用 PascalCase
|
||
# 常量使用大写
|
||
|
||
def calculate_total(items):
|
||
DISCOUNT_RATE = 0.1
|
||
total = sum(items)
|
||
return total * (1 - DISCOUNT_RATE)
|
||
```
|
||
|
||
### 2. 列表推导式 vs 循环
|
||
```python
|
||
# 简单转换优先使用推导式
|
||
squares = [x**2 for x in range(10)]
|
||
|
||
# 复杂逻辑使用循环
|
||
results = []
|
||
for x in range(10):
|
||
if x % 2 == 0:
|
||
result = process_even(x)
|
||
else:
|
||
result = process_odd(x)
|
||
results.append(result)
|
||
```
|
||
|
||
### 3. None 用 `is`，值比较用 `==`
|
||
```python
|
||
if value is None: # 正确
|
||
if value == None: # 也能工作但不推荐
|
||
```
|
||
|
||
### 4. EAFP 与 LBYL
|
||
```python
|
||
# 请求原谅比获得许可更容易（Pythonic 风格）
|
||
try:
|
||
value = my_dict['key']
|
||
except KeyError:
|
||
value = default
|
||
|
||
# 三思而后行（不够 Pythonic）
|
||
if 'key' in my_dict:
|
||
value = my_dict['key']
|
||
else:
|
||
value = default
|
||
```
|
||
|
||
---
|
||
|
||
## 常见陷阱
|
||
|
||
### 1. 可变默认参数
|
||
```python
|
||
# 错误
|
||
def append_to(element, lst=[]):
|
||
lst.append(element)
|
||
return lst
|
||
|
||
# 所有调用共享同一个列表！
|
||
print(append_to(1)) # [1]
|
||
print(append_to(2)) # [1, 2] — 不符合预期！
|
||
|
||
# 正确
|
||
def append_to(element, lst=None):
|
||
if lst is None:
|
||
lst = []
|
||
lst.append(element)
|
||
return lst
|
||
```
|
||
|
||
### 2. 闭包延迟绑定
|
||
```python
|
||
# 错误
|
||
funcs = [lambda: i for i in range(5)]
|
||
print([f() for f in funcs]) # [4, 4, 4, 4, 4]
|
||
|
||
# 正确
|
||
funcs = [lambda i=i: i for i in range(5)]
|
||
print([f() for f in funcs]) # [0, 1, 2, 3, 4]
|
||
```
|
||
|
||
### 3. 遍历列表时修改
|
||
```python
|
||
# 错误
|
||
lst = [1, 2, 3, 4, 5]
|
||
for item in lst:
|
||
if item % 2 == 0:
|
||
lst.remove(item) # 可能跳过元素
|
||
|
||
# 正确
|
||
lst = [item for item in lst if item % 2 != 0]
|
||
```
|
||
|
||
---
|
||
|
||
## Python 3.10+ 特性
|
||
|
||
### 结构化模式匹配
|
||
```python
|
||
def process_command(command):
|
||
match command.split():
|
||
case ["quit"]:
|
||
return "Quitting"
|
||
case ["load", filename]:
|
||
return f"Loading {filename}"
|
||
case ["save", filename]:
|
||
return f"Saving {filename}"
|
||
case _:
|
||
return "Unknown command"
|
||
```
|
||
|
||
### 联合类型
|
||
```python
|
||
def greet(name: str | None = None) -> str:
|
||
if name is None:
|
||
return "Hello, stranger"
|
||
return f"Hello, {name}"
|
||
```
|