# 一对多（多对一）

```python
class Question(models.Model):
    question_text = models.CharField(max_length=200)

class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
```
一个问题可以多个选择，即Question一对多Choice，外键ForeignKey放置于一对多中的多位置


# 多对多

```python
class TestPackage(UUIDModel):
    """ 记录每个测试使用过插件包"""
    plugin_appliances = models.ManyToManyField(
        'TestPluginAppliance',
        through='TestPackagePluginApplianceRel',
        blank=True,
        related_name='test_packages'
    )

class TestTaskPluginAppliance(NamedModel):
    """ 记录每个测试任务使用过插件设备"""
    pass
    
class TestPackagePluginApplianceRel(models.Model):
    """ 中间模型，用于记录 TestPackage 和 TestPluginAppliance 之间的多对多关系 """
    test_package = models.ForeignKey(TestPackage, on_delete=models.CASCADE)
    test_plugin_appliance = models.ForeignKey(TestPluginAppliance, on_delete=models.CASCADE)
    additional_info = models.JSONField(verbose_name='附加信息', blank=True, default=dict)

    class Meta:
        unique_together = ('test_package', 'test_plugin_appliance')
```
一个插件包可以在很多插件设备上使用，一个插件设备通过替换，也可以支持很多插件包

django模型

# asyncio
asyncio 是 Python 中用于编写异步代码的标准库，它的核心是事件循环机制。事件循环负责调度和执行异步任务，使得多个任务可以在单线程中协同工作.

日常中用到的场景为，批量获取某手机的多个应用列表里面具体应用的信息时，需要异步处理，不然逐个获取遍历太慢了（异步2秒内，逐个为60秒可能不止）

# 事件循环机制
1、事件循环:

事件循环是一个运行在单线程中的循环，它负责管理和调度异步任务。
在事件循环中，任务是以协程的形式存在，协程可以在执行过程中暂停（使用 await），并在合适的时机恢复执行。

2、任务调度:

事件循环通过调度器来管理任务的执行顺序。
当一个协程遇到 await 时，它会暂停执行，事件循环可以切换到其他任务。
事件循环会不断检查任务的状态，并在任务准备好继续执行时恢复它。

3、I/O 操作:

异步 I/O 操作是事件循环的一个重要部分。事件循环可以在等待 I/O 操作完成时执行其他任务。
这使得 asyncio 非常适合处理网络请求、文件读写等 I/O 密集型任务。
# 协同多个任务

1、创建任务:

使用 asyncio.create_task() 或 loop.create_task() 可以将协程包装成任务，并提交给事件循环。
任务是事件循环调度的基本单位。

2、并发执行:

asyncio.gather() 可以用于并发执行多个协程。它会等待所有协程完成，并返回结果。
asyncio.wait() 可以用于等待多个任务完成，提供更细粒度的控制。

# 案例

```python
import asyncio

async def task(name, delay):
    print(f"Task {name} started")
    await asyncio.sleep(delay)
    print(f"Task {name} finished")
    return name

async def main():
    # 创建多个任务
    tasks = [
        asyncio.create_task(task("A", 2)),
        asyncio.create_task(task("B", 1)),
        asyncio.create_task(task("C", 3))
    ]
    # 并发执行任务
    results = await asyncio.gather(*tasks)
    print(f"Results: {results}")

# 运行事件循环
asyncio.run(main())

# Task A started
# Task B started
# Task C started
# Task B finished
# Task A finished
# Task C finished
Results: ['A', 'B', 'C']
```

asyncio

# 线程
python中一般使用threading和concurrent.futures.ThreadPoolExecutor

定义: 线程是操作系统调度的基本单位，是进程中的一个执行路径。一个进程可以包含多个线程，它们共享进程的内存空间。

特点:

共享内存: 线程共享进程的内存空间，可以方便地共享数据。
轻量级: 创建和销毁线程的开销比进程小。
并发执行: 在多核处理器上，多个线程可以并发执行。
适用场景:

I/O 密集型任务: 适合处理需要等待外部设备响应的任务，如网络请求、文件读写。
需要共享数据: 适合需要多个执行路径共享数据的场景。

# 进程
python中一般用multiprocessing和concurrent.futures.ProcessPoolExecutor

定义: 进程是操作系统分配资源的基本单位，每个进程都有独立的内存空间。进程之间的通信需要通过进程间通信（IPC）机制。

特点:

独立内存空间: 进程之间不共享内存，数据隔离性好。
较重: 创建和销毁进程的开销较大。
真正并行: 在多核处理器上，多个进程可以真正并行执行。
适用场景:

CPU 密集型任务: 适合需要大量计算的任务，因为可以利用多核处理器的能力。
需要隔离: 适合需要数据隔离的场景，避免共享内存带来的复杂性


```python
import multiprocessing
import math


def compute_factorial(n):
    return math.factorial(n)


def main():
    numbers = [100000, 200000, 300000, 400000, 500000]

    # create processing pool
    with multiprocessing.Pool(processes=multiprocessing.cpu_count()) as pool:
        # map parallel computing
        results = pool.map(compute_factorial, numbers)
        
    for number, result in zip(numbers, results):
        print(f'Factorial of {number} is calculated.')


if __name__ == '__main__':
    main()

```

# 协程
python中一般用asyncio和aiohttp

定义:
协程是一种用户态的轻量级线程，由程序自身调度。协程允许在执行过程中暂停和恢复，通常用于异步编程。

特点:

轻量级: 协程的创建和销毁开销非常小。
非抢占式调度: 协程由程序显式调度，而不是由操作系统调度。
单线程执行: 协程通常在单线程中执行，避免了线程切换的开销。

适用场景:

异步 I/O: 适合处理大量并发 I/O操作，如网络请求、数据库查询。
高并发: 适合需要处理大量并发任务的场景，尤其是在 I/O 密集型任务

# 总结
- 线程: 适合需要共享数据的 I/O 密集型任务。
- 进程: 适合需要数据隔离的 CPU 密集型任务。
- 协程: 适合异步 I/O和高并发场景，尤其是在单线程环境

线程、进程和协程

# GIL
Python 的全局解释器锁（GIL）是一个机制，它确保同一时间只有一个线程执行 Python 字节码。这意味着在多线程环境中，Python 的多线程不能真正并行执行 Python 代码，这可能导致性能问题，特别是在 CPU 密集型任务中

# 解决GIL的措施
1、使用多进程而不是多线程：Python 的 multiprocessing 模块允许创建多个进程，每个进程都有自己的 Python 解释器和 GIL。这使得可以真正并行地执行代码




```python
from multiprocessing import Pool

def cpu_bound_task(n):
    # 进行一些 CPU 密集型计算
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with Pool(processes=4) as pool:
        results = pool.map(cpu_bound_task, [1000000, 2000000, 3000000, 4000000])
        print(results)
# [333332833333500000, 2666664666667000000, 8999995500000500000, 21333325333334000000]
```

2、异步编程：python中的asyncio支持异步处理，允许在单线程中处理多个 I/O 操作


```python
import asyncio


async def io_bound_task():
    await asyncio.sleep(1)
    return "Task completed"


async def main():
    tasks = [io_bound_task() for _ in range(10)]
    results = await asyncio.gather(*tasks)
    print(results)


asyncio.run(main())

```

3、使用 C 扩展或第三方库（需要知道某些库是用其他语言写的，比如NumPy 底层是C）

4、算法优化或代码优化

Python GIL

# 生成器
默认使用yield在函数内，即改函数就会成为一个特殊的迭代器，称为生成器

作用：实现高效的迭代和流式数据处理，惰性求值，省内存



# 案例

```python
def fibonacci_generator(n):
    """生成斐波那契数列的生成器"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

print(list(fibonacci_generator(5)))  # [0, 1, 1, 2, 3]
```

# 其他生成器情况
(x * x for x in range(1000000)) 使用元组方式去生成


```python
# 列表推导式
squares_list = [x * x for x in range(1000000)]

# 生成器表达式
squares_generator = (x * x for x in range(1000000))

# 计算内存使用
import sys
print(f"List size: {sys.getsizeof(squares_list)} bytes")
print(f"Generator size: {sys.getsizeof(squares_generator)} bytes")

# List size: 8448728 bytes
# Generator size: 208 bytes
```
优势对比：生成器在处理大数据集、流式数据和无限序列时，比列表推导式更节省内存。通过惰性求值，生成器可以有效地减少内存使用，提高程序的性能和可扩展性。