我的知识库

Appearance

Python 学习笔记 ​

📚 学习路线图 ​

  1. 基础入门

    • 变量与数据类型（int, float, str, bool）
    • 输入输出（input, print）
    • 运算符（算术、比较、逻辑、赋值）
    • 字符串操作

  2. 流程控制

    • 条件语句（if-elif-else）
    • 循环（for, while）
    • break、continue、pass

  3. 数据结构

    • 列表（List）
    • 元组（Tuple）
    • 字典（Dictionary）
    • 集合（Set）

  4. 函数

    • 函数定义与调用
    • 参数（位置、关键字、默认、可变）
    • 返回值
    • 作用域
    • Lambda 表达式

  5. 面向对象

    • 类与对象
    • 属性与方法
    • 继承
    • 多态
    • 封装

  6. 进阶

    • 虚拟环境（venv）
    • 装饰器（Decorator）
    • 生成器（Generator）
    • 迭代器（Iterator）
    • 异常处理
    • 文件操作
    • 模块与包

基础语法 ​

Hello World ​

python
print("Hello World")

变量与数据类型 ​

python
# 整数
age = 25
# 浮点数
height = 1.75
# 字符串
name = "张三"
# 布尔值
is_student = True

# 类型转换
num_str = "100"
num = int(num_str)  # "100" -> 100
price = 3.14159
price_rounded = round(price, 2)  # 3.14

字符串操作 ​

python
s = "Hello World"

# 索引与切片
print(s[0])     # 'H'
print(s[-1])    # 'd'
print(s[0:5])   # 'Hello'
print(s[::-1])  # 'dlroW olleH' (反转)

# 常用方法
print(s.lower())   # 'hello world'
print(s.upper())   # 'HELLO WORLD'
print(s.split())   # ['Hello', 'World']
print("  hello  ".strip())  # 'hello' (去除空格)

列表 ​

python
# 创建列表
fruits = ["apple", "banana", "cherry"]

# 访问元素
print(fruits[0])     # 'apple'
print(fruits[-1])    # 'cherry'

# 修改元素
fruits[1] = "orange"

# 添加元素
fruits.append("grape")
fruits.insert(1, "pear")

# 删除元素
fruits.remove("apple")
del fruits[0]
popped = fruits.pop()

# 切片
print(fruits[1:3])    # 取索引 1-2 的元素
print(fruits[:2])     # 取前两个元素

# 常用方法
print(len(fruits))    # 列表长度
print("apple" in fruits)  # 判断元素是否存在

# 列表推导式
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

字典 ​

python
# 创建字典
person = {
    "name": "张三",
    "age": 25,
    "city": "北京"
}

# 访问元素
print(person["name"])        # '张三'
print(person.get("age"))     # 25
print(person.get("job", "未知"))  # '未知'（键不存在时返回默认值）

# 修改/添加元素
person["age"] = 26
person["job"] = "工程师"

# 删除元素
del person["city"]
job = person.pop("job")

# 常用方法
print(person.keys())    # dict_keys(['name', 'age'])
print(person.values())  # dict_values(['张三', 26])
print(person.items())   # dict_items([('name', '张三'), ('age', 26)])

# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

流程控制 ​

条件语句 ​

python
score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

循环 ​

python
# for 循环
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# while 循环
count = 0
while count < 5:
    print(count)
    count += 1

# 循环控制
for i in range(10):
    if i == 3:
        continue  # 跳过本次循环
    if i == 7:
        break     # 退出循环
    print(i)

函数 ​

python
# 基本函数定义
def greet(name):
    return f"Hello, {name}!"

print(greet("张三"))  # Hello, 张三!

# 默认参数
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("张三"))              # Hello, 张三!
print(greet("张三", "你好"))      # 你好, 张三!

# 可变参数
def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3))  # 6
print(sum_all(1, 2, 3, 4, 5))  # 15

# 关键字参数
def create_user(name, **kwargs):
    user = {"name": name}
    user.update(kwargs)
    return user

print(create_user("张三", age=25, city="北京"))
# {'name': '张三', 'age': 25, 'city': '北京'}

# Lambda 表达式
square = lambda x: x**2
print(square(5))  # 25

# 排序示例
students = [("张三", 25), ("李四", 20), ("王五", 22)]
students.sort(key=lambda x: x[1])  # 按年龄排序
print(students)  # [('李四', 20), ('王五', 22), ('张三', 25)]

面向对象 ​

python
# 定义类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"你好，我是{self.name}，今年{self.age}岁"

    def birthday(self):
        self.age += 1
        print(f"{self.name} 生日快乐！现在 {self.age} 岁了")

# 创建对象
person = Person("张三", 25)
print(person.greet())  # 你好，我是张三，今年25岁
person.birthday()      # 张三 生日快乐！现在 26 岁了

# 继承
class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

    def greet(self):
        return f"我是{self.school}的学生{self.name}，今年{self.age}岁"

student = Student("李四", 20, "清华大学")
print(student.greet())  # 我是清华大学的学生李四，今年20岁

虚拟环境 ​

为什么需要虚拟环境 ​

Python 虚拟环境可以为每个项目创建独立的 Python 环境，避免不同项目之间的依赖冲突。

使用 venv ​

bash
# 创建虚拟环境
python -m venv venv

# macOS/Linux 激活虚拟环境
source venv/bin/activate

# Windows 激活虚拟环境
venv\Scripts\activate

# 退出虚拟环境
deactivate

# 删除虚拟环境
rm -rf venv  # macOS/Linux
rmdir /s venv  # Windows

激活虚拟环境后，命令行前面会显示 (venv) 提示符。

requirements.txt ​

requirements.txt 文件用于记录项目的所有依赖。

生成 requirements.txt ​

bash
# 导出当前环境所有已安装的包
pip freeze > requirements.txt

# 只导出项目直接依赖（推荐）
pip install pipreqs
pipreqs . --encoding=utf8

安装 requirements.txt 中的依赖 ​

bash
# 安装所有依赖
pip install -r requirements.txt

# 使用国内镜像加速
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

requirements.txt 示例 ​

# requirements.txt
flask==3.0.0
requests==2.31.0
pytest==7.4.3
python-dotenv==1.0.0

pip 常用命令 ​

bash
# 安装包
pip install package_name
pip install package_name==1.0.0  # 指定版本
pip install package_name>=1.0.0,<2.0.0  # 版本范围

# 卸载包
pip uninstall package_name

# 查看已安装的包
pip list
pip list --format=freeze

# 查看包信息
pip show package_name

# 升级包
pip install --upgrade package_name

# 清理缓存
pip cache purge

# 配置国内镜像（永久）
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

常用国内镜像源 ​

镜像源地址
清华大学https://pypi.tuna.tsinghua.edu.cn/simple
阿里云https://mirrors.aliyun.com/pypi/simple
中科大https://pypi.mirrors.ustc.edu.cn/simple
豆瓣https://pypi.douban.com/simple

装饰器 ​

什么是装饰器 ​

装饰器是一个接受函数作为参数并返回新函数的函数。它可以在不修改原函数代码的情况下，为函数添加额外的功能。

基本装饰器 ​

python
def my_decorator(func):
    """装饰器模板"""
    def wrapper(*args, **kwargs):
        # 函数执行前的操作
        print(f"正在调用函数: {func.__name__}")

        # 执行原函数
        result = func(*args, **kwargs)

        # 函数执行后的操作
        print(f"函数 {func.__name__} 执行完毕")
        return result

    return wrapper

@my_decorator
def say_hello(name):
    return f"Hello, {name}!"

print(say_hello("张三"))
# 输出：
# 正在调用函数: say_hello
# 函数 say_hello 执行完毕
# Hello, 张三!

保留原函数元数据 ​

使用 functools.wraps 装饰 wrapper 函数，保留原函数的元数据（如 __name__、__doc__ 等）：

python
import functools

def my_decorator(func):
    @functools.wraps(func)  # 保留原函数元数据
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name):
    """打招呼函数"""
    return f"Hello, {name}!"

print(greet.__name__)  # greet（没有 @wraps 会是 wrapper）
print(greet.__doc__)   # 打招呼函数

带参数的装饰器 ​

python
def repeat(times):
    """重复执行函数的装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()
# 输出：
# Hello!
# Hello!
# Hello!

类装饰器 ​

python
class CountCalls:
    """统计函数调用次数的类装饰器"""
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"函数 {self.func.__name__} 已被调用 {self.count} 次")
        return self.func(*args, **kwargs)

@CountCalls
def greet(name):
    return f"Hello, {name}!"

print(greet("张三"))  # 函数 greet 已被调用 1 次
print(greet("李四"))  # 函数 greet 已被调用 2 次

常用装饰器示例 ​

1. 计时装饰器 ​

python
import time
import functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 执行时间: {end - start:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "完成"

print(slow_function())

2. 日志装饰器 ​

python
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        print(f"调用 {func.__name__}({signature})")
        try:
            result = func(*args, **kwargs)
            print(f"{func.__name__} 返回 {result!r}")
            return result
        except Exception as e:
            print(f"{func.__name__} 抛出异常: {e!r}")
            raise
    return wrapper

@log
def divide(a, b):
    return a / b

print(divide(10, 2))
print(divide(10, 0))  # 会显示异常信息

3. 缓存装饰器 ​

python
def cache(func):
    """简单的缓存装饰器"""
    cached_results = {}

    @functools.wraps(func)
    def wrapper(*args):
        if args in cached_results:
            return cached_results[args]
        result = func(*args)
        cached_results[args] = result
        return result
    return wrapper

@cache
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(10))  # 计算并缓存
print(fib(10))  # 从缓存中读取

内置装饰器 ​

@property - 将方法转换为属性 ​

python
class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def age(self):
        """获取年龄"""
        return self._age

    @age.setter
    def age(self, value):
        """设置年龄，带验证"""
        if value < 0:
            raise ValueError("年龄不能为负数")
        self._age = value

    @age.deleter
    def age(self):
        """删除年龄"""
        print("删除年龄属性")
        del self._age

person = Person("张三", 25)
print(person.age)  # 25（像访问属性一样调用方法）
person.age = 26    # 调用 setter
del person.age     # 调用 deleter

@staticmethod - 静态方法 ​

python
class MathUtils:
    @staticmethod
    def add(a, b):
        """静态方法不需要 self 参数"""
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

print(MathUtils.add(1, 2))      # 3
print(MathUtils.multiply(3, 4)) # 12

@classmethod - 类方法 ​

python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        """类方法的第一个参数是 cls（类本身）"""
        age = 2026 - birth_year
        return cls(name, age)

    def greet(self):
        return f"我是{self.name}，今年{self.age}岁"

person = Person.from_birth_year("张三", 2000)
print(person.greet())  # 我是张三，今年26岁

多个装饰器 ​

python
def bold(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

# 装饰器从下往上执行
@bold
@italic
def greet(name):
    return f"Hello, {name}!"

print(greet("张三"))  # <b><i>Hello, 张三!</i></b>

单例模式装饰器 ​

python
def singleton(cls):
    """确保一个类只有一个实例"""
    instances = {}

    @functools.wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper

@singleton
class Database:
    def __init__(self):
        print("创建数据库连接")

db1 = Database()  # 创建数据库连接
db2 = Database()  # 不会再次创建
print(db1 is db2)  # True

权限验证装饰器 ​

python
def require_permission(permission):
    """检查用户权限的装饰器"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(user, *args, **kwargs):
            if permission not in user.permissions:
                raise PermissionError(f"需要 {permission} 权限")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

class User:
    def __init__(self, name, permissions):
        self.name = name
        self.permissions = permissions

@require_permission("delete")
def delete_user(admin, user_id):
    print(f"删除用户 {user_id}")

admin = User("管理员", ["read", "write", "delete"])
guest = User("访客", ["read"])

delete_user(admin, 1)  # 删除用户 1
delete_user(guest, 1)  # PermissionError: 需要 delete 权限

装饰器最佳实践 ​

  1. 始终使用 @functools.wraps：保留原函数的元数据
  2. 装饰器应该是可配置的：使用带参数的装饰器
  3. 保持装饰器简单：复杂的逻辑放在被装饰的函数中
  4. 考虑性能：装饰器会增加函数调用的开销

参考资源 ​

python
# 基本装饰器
def my_decorator(func):
    def wrapper():
        print("函数执行前")
        func()
        print("函数执行后")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# 输出：
# 函数执行前
# Hello!
# 函数执行后

# 带参数的装饰器
def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 执行时间: {end - start:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "完成"

print(slow_function())

异常处理 ​

python
try:
    num = int(input("请输入数字: "))
    result = 10 / num
    print(f"结果: {result}")
except ValueError:
    print("请输入有效的数字！")
except ZeroDivisionError:
    print("除数不能为零！")
except Exception as e:
    print(f"发生错误: {e}")
else:
    print("计算成功！")
finally:
    print("程序结束")

文件操作 ​

python
# 写入文件
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!\n")
    f.write("这是第二行")

# 读取文件
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()      # 读取全部内容
    print(content)

with open("test.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()    # 读取所有行
    for line in lines:
        print(line.strip())

# 逐行读取（大文件推荐）
with open("test.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

推荐资源 ​

官方文档 ​

学习网站 ​

书籍推荐 ​

  • 《Python 编程：从入门到实践》（入门首选）
  • 《Python 基础教程》（经典教材）
  • 《流畅的 Python》（进阶必读）