高级篇

1. 面向对象编程

1.1 类和对象

  • 类是程序中的“设计图纸”，对象是基于类创建的具体实体
  • 类定义语法： 
    1
    2
    3
    4
    class 类名称:  
        类属性 = 值  # 成员变量  
        def 方法名(self, 参数列表):  # 成员方法  
            方法体
  • 对象创建与使用： 
    1
    2
    3
    obj = 类名称()  # 创建对象  
    obj.属性 = 值    # 操作属性  
    obj.方法()       # 调用方法

1.2 构造方法 __init__

  • 作用：在创建对象时自动执行，用于初始化对象属性
  • 语法： 
    1
    2
    3
    class 类名称:  
        def __init__(self, 参数列表):  
            self.属性 = 参数  # 初始化属性
  • 示例： 
    1
    2
    3
    4
    5
    class Student:  
        def __init__(self, name, age):  
            self.name = name  
            self.age = age  
    stu = Student("周杰伦", 18)

1.3 魔术方法

方法名 功能描述
__str__ 定义对象字符串表示
__lt__ 定义小于比较逻辑
__eq__ 定义相等比较逻辑
__init__ 构造方法，初始化对象

示例：__str__ 方法 

1
2
3
4
5
6
7
class Student:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
    def __str__(self):  
        return f"Student(name={self.name}, age={self.age})"  
print(Student("林俊杰", 20))  # 输出：Student(name=林俊杰, age=20)

1.4 封装特性

  • 私有成员：以 __ 开头的属性/方法，仅限类内部访问 
    1
    2
    3
    4
    5
    class MyClass:  
        def __init__(self):  
            self.__private_var = 10  # 私有属性  
        def __private_method(self):  # 私有方法  
            print("私有方法")
  • 访问控制：通过公共方法间接访问私有成员

1.5 继承特性

  • 单继承： 
    1
    2
    class 子类(父类):  
        pass
  • 多继承： 
    1
    2
    class 子类(父类1, 父类2):  
        pass
  • 方法重写：子类重新实现父类方法
  • 调用父类方法： 
    1
    2
    super().父类方法()  # 使用 super()  
    父类名.父类方法(self)  # 显式调用

1.6 多态特性

  • 抽象类：包含抽象方法（未实现的方法）的类，用于定义接口 
    1
    2
    3
    4
    5
    from abc import ABC, abstractmethod  
    class Animal(ABC):  
        @abstractmethod  
        def speak(self):  
            pass
  • 子类实现：子类必须实现抽象类的所有抽象方法

2. 类型注解

2.1 变量注解

  • 基础类型： 
    1
    2
    3
    num: int = 10  
    name: str = "张三"  
    is_ok: bool = True
  • 容器类型： 
    1
    2
    scores: list[int] = [90, 85, 95]  # 列表元素类型为 int  
    person: dict[str, str] = {"name": "李四", "age": "20"}  # key/value 均为 str

2.2 函数注解

  • 参数与返回值类型： 
    1
    2
    def add(a: int, b: int) -> int:  
        return a + b
  • 联合类型（Union）： 
    1
    2
    3
    from typing import Union  
    def process(data: Union[int, str]) -> Union[int, str]:  
        return data

3. 闭包与装饰器

3.1 闭包

  • 定义：嵌套函数中，内层函数引用外层函数变量，并返回内层函数
  • 示例： 
    1
    2
    3
    4
    5
    6
    def outer(x):  
        def inner(y):  
            return x + y  
        return inner  
    add_10 = outer(10)  
    print(add_10(5))  # 输出：15
  • nonlocal 关键字：修改外层函数变量

3.2 装饰器

  • 作用：在不修改原函数的前提下，为函数添加新功能
  • 语法糖写法： 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def decorator(func):  
        def wrapper():  
            print("前置逻辑")  
            func()  
            print("后置逻辑")  
        return wrapper  

    @decorator  
    def say_hello():  
        print("Hello!")  
    say_hello()  # 输出：前置逻辑 -> Hello! -> 后置逻辑

4. 设计模式

4.1 单例模式

  • 作用：确保类只有一个实例，全局唯一访问点
  • 实现： 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Singleton:  
        _instance = None  
        def __new__(cls):  
            if not cls._instance:  
                cls._instance = super().__new__(cls)  
            return cls._instance  
    obj1 = Singleton()  
    obj2 = Singleton()  
    print(obj1 is obj2)  # 输出：True

4.2 工厂模式

  • 作用：统一创建对象的入口，解耦对象创建与使用
  • 示例： 
    1
    2
    3
    4
    5
    6
    7
    class AnimalFactory:  
        @staticmethod  
        def create_animal(animal_type):  
            if animal_type == "dog":  
                return Dog()  
            elif animal_type == "cat":  
                return Cat()

5. 多线程编程

5.1 基础概念

  • 进程：独立运行的程序实例，内存隔离
  • 线程：进程内的执行单元，共享进程内存
  • 并行与并发：并行指同时执行多个任务（多核CPU），并发指交替执行（单核CPU）

5.2 线程创建

  • threading 模块： 
    1
    2
    3
    4
    5
    import threading  
    def task(name):  
        print(f"任务 {name} 开始")  
    thread = threading.Thread(target=task, args=("A",))  
    thread.start()  # 启动线程

6. 网络编程（Socket）

6.1 服务端开发

  1. 创建 Socket： 
    1
    2
    import socket  
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  2. 绑定地址： 
    1
    server_socket.bind(("0.0.0.0", 8888))
  3. 监听连接： 
    1
    server_socket.listen(5)
  4. 处理连接： 
    1
    2
    conn, addr = server_socket.accept()  
    data = conn.recv(1024).decode()

6.2 客户端开发

1
2
3
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
client_socket.connect(("127.0.0.1", 8888))  
client_socket.send("Hello Server!".encode())

7. 正则表达式

7.1 基础匹配

  • re.match：从字符串开头匹配
  • re.search：搜索整个字符串，返回首个匹配
  • re.findall：返回所有匹配项 
    1
    2
    3
    import re  
    text = "abc123def456"  
    print(re.findall(r'\d+', text))  # 输出：['123', '456']

7.2 元字符

元字符 含义
. 匹配任意字符（除\n）
\d 匹配数字
* 匹配前一个字符0次或多次
^ 匹配字符串开头
$ 匹配字符串结尾

8. 递归

8.1 基本概念

  • 定义：函数直接或间接调用自身
  • 关键要素：
    1. 终止条件（递归出口）
    2. 递归调用（规模递减）

8.2 示例：计算阶乘

1
2
3
4
5
def factorial(n):  
    if n == 0:  
        return 1  
    return n * factorial(n-1)  
print(factorial(5))  # 输出：120

9. os模块常用方法

  • os.listdir(path)：列出目录下的所有文件
  • os.path.isdir(path)：判断路径是否为目录
  • os.path.exists(path)：判断路径是否存在 
    1
    2
    import os  
    print(os.listdir("/"))  # 列出根目录文件