Python核心编程概念：类、模块、包与高级特性详解

一、类与面向对象编程

类（Class）是面向对象编程（OOP）的核心，用于定义对象的属性和方法。对象是类的实例，通过类模板创建具体实体。

1. 类的定义与实例化

使用 class 关键字定义类，__init__ 方法为构造函数，用于初始化对象属性。

class Product:
    def __init__(self, name, price):
        self.name = name  # 实例属性
        self.price = price
    
    def display(self):  # 实例方法
        print(f"商品：{self.name}，价格：{self.price}元")

# 实例化对象
phone = Product("手机", 3999)
phone.display()  # 输出：商品：手机，价格：3999元

2. 继承与多态

继承：子类通过 class ChildClass(ParentClass) 继承父类属性和方法，使用 super() 调用父类构造函数。

多态：子类重写父类方法，实现不同行为。

class ElectronicProduct(Product):
    def __init__(self, name, price, brand):
        super().__init__(name, price)  # 继承父类属性
        self.brand = brand
    
    def display(self):  # 重写父类方法
        print(f"品牌：{self.brand}，商品：{self.name}，价格：{self.price}元")

laptop = ElectronicProduct("笔记本电脑", 5999, "联想")
laptop.display()  # 输出：品牌：联想，商品：笔记本电脑，价格：5999元

3. 封装

通过双下划线 __ 定义私有属性，仅允许类内部访问，外部需通过公开方法操作。

class User:
    def __init__(self, username, password):
        self.username = username
        self.__password = password  # 私有属性
    
    def get_password(self):  # 公开方法获取私有属性
        return self.__password

user = User("admin", "123456")
print(user.get_password())  # 输出：123456

二、模块与包的组织

模块（Module）是单个 .py 文件，包含函数、类或变量；

包（Package）是包含 __init__.py 的目录，用于组织多个模块。

1. 模块的导入

直接导入模块：import math

导入模块中的特定内容：from math import pi

导入并指定别名：import numpy as np

2. 包的初始化文件 init.py

标识包：Python 3.3+ 支持无 __init__.py 的命名空间包，但传统包仍需该文件。
批量导入：在 __init__.py 中定义 __all__，指定 from package import * 时导入的模块。
包级初始化：执行全局配置或初始化代码。

# mypackage/__init__.py
__all__ = ["module1", "module2"]  # 允许 from mypackage import * 导入指定模块
print("包初始化完成")

3. 第三方包管理

使用 pip 工具安装、升级和管理第三方包：

安装包：pip install requests
升级包：pip install --upgrade requests

pip list  # 列出所有包
pip show 包名  # 查看包详情（版本、路径等）
pip install --upgrade 包名  # 升级
pip uninstall 包名  # 卸载
pip freeze > requirements.txt  # 导出依赖
pip install -r requirements.txt  # 批量安装

三、注解与装饰器

1. 类型注解

通过类型提示增强代码可读性和静态检查，使用 : 指定参数和返回值类型。

def add(a: int, b: int) -> int:
    return a + b

result: int = add(3, 5)  # 类型提示

2. 装饰器

装饰器是高阶函数，用于动态修改函数或类的行为，语法糖为 @decorator。

函数装饰器：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数：{func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log_decorator  # 应用装饰器
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # 输出：调用函数：greet → Hello, Alice!

类装饰器：

def singleton(cls):
    instances = {}
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return wrapper

@singleton  # 实现单例模式
class Database:
    pass

db1 = Database()
db2 = Database()
print(db1 is db2)  # 输出：True

四、异步编程

异步编程通过非阻塞 I/O 和协程实现高效并发，核心是 async/await 语法与 asyncio 模块。

1. 协程与事件循环

协程：使用 async def 定义，需在事件循环中运行。

await：暂停协程，等待可等待对象（如 asyncio.sleep）完成。

import asyncio

async def fetch_data():
    await asyncio.sleep(2)  # 模拟I/O等待
    return {"status": "success"}

async def main():
    result = await fetch_data()  # 等待协程完成
    print(result)

asyncio.run(main())  # 启动事件循环

2. 并发任务管理

asyncio.gather()：并行执行多个协程，返回结果列表。

asyncio.create_task()：创建任务对象，支持取消和状态查询。

async def main():
    task1 = asyncio.create_task(fetch_data())
    task2 = asyncio.create_task(fetch_data())
    results = await asyncio.gather(task1, task2)
    print(results)  # 输出：[{"status": "success"}, {"status": "success"}]

总结

Python 通过类与对象实现面向对象编程，模块与包组织代码结构，注解提升代码可读性，装饰器动态扩展功能，异步编程优化 I/O 密集型任务。这些核心概念共同构成了 Python 灵活高效的编程生态，适用于从基础开发到复杂系统构建的各类场景。