python常见问题-CSDN博客

本文链接：https://blog.csdn.net/NickDeCodes/article/details/138305158

python常见问题

fastapi 框架的使用

FastAPI 是一个现代、快速（高性能）的 Web 框架，用于构建 API 服务，基于标准 Python 类型提示。它的主要特点是快速、直观和易于学习，同时提供自动交互式 API 文档（基于 Swagger 和 ReDoc）。

安装 FastAPI 和 Uvicorn

FastAPI 依赖于 Starlette（用于 Web 功能）和 Pydantic（用于数据验证）。Uvicorn 是一个轻量级、高性能的 ASGI 服务器，用于运行 FastAPI。

pip install fastapi uvicorn

创建一个基本的 FastAPI 应用

创建一个简单的 FastAPI 应用，定义一些路由：

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

在这个例子中，我们定义了两个路由：

一个根路由 /，返回一个简单的字典。
一个带路径参数 item_id 的路由 /items/{item_id}，可选的查询参数 q。

运行 FastAPI 应用

保存上面的代码到一个文件中，比如 main.py，然后使用 Uvicorn 运行它：

uvicorn main:app --reload

这里 main:app 表示 main.py 文件中的 app 对象。--reload 参数使服务器在代码改变时自动重启，便于开发。

访问 API 文档

FastAPI 自动为你的 API 生成交互式文档。启动应用后，你可以访问以下 URL 查看和交互你的 API 文档：

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

更复杂的数据处理

FastAPI 支持 Pydantic 模型来处理更复杂的数据结构和验证：

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

app = FastAPI()

@app.post("/items/")
async def create_item(item: Item):
    item_dict = item.dict()
    if item.tax:
        price_with_tax = item.price + item.tax
        item_dict.update({"price_with_tax": price_with_tax})
    return item_dict

这个例子中，我们定义了一个 Pydantic 模型 Item，用于接收和验证客户端发送的数据。然后在 POST 请求中使用这个模型。

总结

FastAPI 是一个非常强大的工具，用于快速开发高性能的 API 服务。它支持异步编程，可以处理大量并发请求。通过自动文档生成，它也极大地简化了 API 的测试和前后端的协同开发工作。

使用 asyncio 实现聊天室功能

使用 asyncio 实现聊天室功能涉及到协程的使用、客户端和服务器的异步通信等。在这个示例中，我们将创建一个基本的聊天室服务器，该服务器能够接收来自多个客户端的连接，并允许客户端之间互发消息。

聊天室服务器

服务器的主要职责是：

接受客户端的连接。
接收来自客户端的消息，并将其广播给所有其他连接的客户端。
处理客户端断开连接的情况。

下面是服务器的实现代码：

import asyncio

class ChatServer:
    def __init__(self):
        self.clients = set()

    async def handle_client(self, reader, writer):
        # 将新客户端加入集合
        self.clients.add(writer)
        try:
            while True:
                data = await reader.read(100)
                if not data:
                    break
                message = data.decode()
                print(f"Received: {message}")
                await self.broadcast(message, writer)
        except asyncio.CancelledError:
            pass
        finally:
            # 断开连接时移除客户端
            print("Closing connection")
            self.clients.remove(writer)
            writer.close()
            await writer.wait_closed()

    async def broadcast(self, message, sender):
        for client in self.clients:
            if client != sender:
                client.write(message.encode())
                await client.drain()

    async def run_server(self):
        server = await asyncio.start_server(
            self.handle_client, '127.0.0.1', 8888)
        async with server:
            await server.serve_forever()

async def main():
    server = ChatServer()
    await server.run_server()

asyncio.run(main())

聊天室客户端

客户端的主要职责是：

连接到服务器。
发送用户输入的消息到服务器。
接收并显示从服务器广播的消息。

客户端实现代码如下：

import asyncio

async def send_messages(writer):
    while True:
        message = input("Enter message: ")
        writer.write(message.encode())
        await writer.drain()

async def receive_messages(reader):
    while True:
        data = await reader.read(100)
        if not data:
            print("Disconnected from server")
            break
        message = data.decode()
        print(f"Received: {message}")

async def main():
    reader, writer = await asyncio.open_connection('127.0.0.1', 8888)
    print("Connected to the server.")
    task1 = asyncio.create_task(send_messages(writer))
    task2 = asyncio.create_task(receive_messages(reader))
    await asyncio.gather(task1, task2)

asyncio.run(main())

运行说明

首先运行服务器代码。
然后在多个终端窗口中运行客户端代码，以模拟多个用户。

这个示例展示了如何使用 asyncio 创建一个基本的聊天室。客户端可以发送消息到服务器，服务器则将消息广播给所有其他客户端。这只是一个基本的实现，实际应用中可能需要添加更多的功能，如用户认证、更健壮的错误处理等。

Python 性能调优问题

Python 是一种非常灵活和强大的编程语言，但由于其动态性和解释性，可能在性能上不及一些编译型语言如 C++ 或 Java。然而，有多种方法可以优化 Python 代码的性能，以下是一些常见的策略：

1. 使用内置数据类型

Python 的内置数据类型（如列表、字典、集合等）是高度优化的。使用这些数据类型通常比自定义数据结构更高效。

2. 利用库和模块

Python 拥有丰富的库和模块，很多都是用 C 或 Cython 编写的，可以提供接近本地代码的性能：

NumPy: 用于高效的数值计算。
Pandas: 数据分析和操作。
SciPy: 科学计算。
Cython: 将 Python 代码编译成 C 代码以提高执行速度。

3. 避免全局变量

在 Python 中，访问局部变量比访问全局变量要快得多。因此，尽可能使用局部变量。

4. 循环优化

循环是许多程序中的性能瓶颈。优化循环的一些方法包括：

尽可能使用列表推导式和生成器表达式，它们通常比相应的循环更快且更简洁。
避免在循环内部进行重复的计算。
使用内置函数和库函数（如 map() 和 filter()）替代循环。

5. 使用函数

将代码分解成函数可以帮助Python更好地优化执行。此外，内联函数（特别是在热点代码中）可能增加开销。

6. 多线程与多进程

由于 Python 的全局解释器锁（GIL），多线程在 CPU 密集型任务中常常不会带来性能提升。在这种情况下，使用多进程可以更好地利用多核处理器：

threading: 适用于 I/O 密集型任务。
multiprocessing: 适用于 CPU 密集型任务。

7. 异步编程

对于 I/O 密集型应用，使用异步编程模型可以显著提高性能。asyncio 是 Python 的异步编程库，适用于处理大量网络连接和 I/O 操作。

8. 性能分析

在进行性能优化之前，了解瓶颈在哪里是非常重要的。Python 提供了多种性能分析工具，如 cProfile 和 timeit。

9. JIT 编译器

使用 Just-In-Time (JIT) 编译器如 PyPy 可以提供显著的性能提升。PyPy 是一个 Python 解释器，它使用 JIT 技术来优化执行速度。

10. 避免不必要的资源消耗

优化数据结构和算法，减少内存占用和计算量。例如，使用生成器代替列表可以减少内存消耗。

通过这些策略，你可以显著提高 Python 程序的性能。每种方法都有其适用场景，因此在实际应用中需要根据具体需求和瓶颈选择合适的优化策略。

python 中装饰器原理是什么

在 Python 中，装饰器是一种非常强大的功能，它允许程序员修改或增强函数或方法的行为，而无需直接修改函数或方法本身的代码。装饰器本质上是一个函数，它接受一个函数作为参数并返回一个新的函数。装饰器可以在函数调用前后添加功能，或者甚至可以修改函数的行为。

装饰器的工作原理

函数作为对象：在 Python 中，函数是一等公民，意味着它们可以像任何其他对象一样被传递和赋值。
高阶函数：装饰器是一个接受函数作为参数并返回一个函数的高阶函数。
闭包：装饰器通常利用闭包来封装被装饰函数的环境，使得可以在返回的函数中访问原始函数。

装饰器的基本结构

def decorator(func):
    def wrapper(*args, **kwargs):
        # 在 func 被调用前可以执行一些代码
        result = func(*args, **kwargs)
        # 在 func 被调用后可以执行一些代码
        return result
    return wrapper

@decorator
def my_function():
    print("Hello, World!")

my_function()

在这个例子中，decorator 是一个装饰器，它内部定义了一个 wrapper 函数。这个 wrapper 函数调用原始的 my_function，并在调用前后可以执行一些额外的代码。使用 @decorator 语法糖实际上是一个语法简化，等同于写：

my_function = decorator(my_function)

装饰器的高级用法

装饰器可以用来做很多事情，比如：

日志记录：自动记录函数的调用细节。
性能测试：记录函数的执行时间。
访问控制：检查调用者是否有权执行函数。
参数检查：自动检查输入参数类型。

参数化装饰器

装饰器本身也可以被设计为接受参数，这需要再定义一个外层的函数：

def repeat(number=2):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(number):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

say_hello()

在这个例子中，repeat 是一个接受参数的装饰器生成器，它返回一个装饰器，该装饰器又返回一个函数。

总结

装饰器是 Python 中一个非常强大的功能，允许开发者以非常干净和模块化的方式增强函数功能。理解装饰器的工作原理可以帮助开发者写出更清晰、更有效、更 Pythonic 的代码。

python 中的 gc 机制和循环引用问题

Python 使用自动内存管理，其中垃圾回收（GC）是核心组成部分。Python 的垃圾回收机制主要依赖于引用计数，同时辅以“标记-清除”和“分代收集”机制来处理更复杂的场景，如循环引用。

引用计数

Python 中每个对象都有一个引用计数，用来跟踪有多少个引用指向该对象。当一个对象的引用计数降到零时，意味着没有任何引用指向这个对象，该对象的内存就可以被立即释放了。这种方法的优点是简单且实时，但主要缺点是无法解决循环引用的问题。

循环引用

循环引用发生在两个或多个对象相互引用，形成一个闭环。例如：

a = []
b = []
a.append(b)
b.append(a)

在这个例子中，a 引用 b，而 b 也引用 a，形成了一个循环。即使这两个对象从外部不再被任何变量引用，它们的引用计数也不会降到零，因此不会被引用计数机制回收。

标记-清除和分代收集

为了解决循环引用问题，Python 使用了标记-清除（Mark-Sweep）算法。这个算法通过标记所有从根对象（例如全局命名空间、堆栈等）可达的对象，未被标记的对象即为不可达对象，可能是循环引用的一部分，因此可以被安全回收。

Python 还采用了分代收集机制，将对象分为三代。新创建的对象放在第一代，如果在一次垃圾收集后仍然存活，它们会被移动到第二代，再存活下来的会被移动到第三代。每一代使用的标记-清除频率不同，越老的代频率越低。这种方法基于的假设是，存活时间越长的对象，越可能继续存活。

手动管理和调试

尽管 Python 提供了自动垃圾回收，但在某些情况下，手动干预可能是必要的。例如，可以使用 gc 模块来手动触发垃圾回收，或者调整垃圾回收的配置。gc 模块还提供了工具来帮助识别循环引用：

import gc

gc.collect()  # 强制进行垃圾回收

# 查看无法回收的对象列表
for obj in gc.garbage:
    print(obj)

总结

Python 的垃圾回收机制通过引用计数来实时回收无用对象，并通过标记-清除和分代收集来处理复杂情况如循环引用。了解这些机制有助于更好地理解 Python 的内存管理，以及在遇到内存问题时进行调试和优化。