Python





```python
import copy
import logging
import sys
class ColoredFormatter(logging.Formatter):
    COLORS = {
        "DEBUG": "\033[0;36m",  # CYAN
        "INFO": "\033[0;32m",  # GREEN
        "WARNING": "\033[0;33m",  # YELLOW
        "ERROR": "\033[0;31m",  # RED
        "CRITICAL": "\033[0;37;41m",  # WHITE ON RED
        "RESET": "\033[0m",  # RESET COLOR
    }
    def format(self, record):
        colored_record = copy.copy(record)
        levelname = colored_record.levelname
        seq = self.COLORS.get(levelname, self.COLORS["RESET"])
        colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
        return super().format(colored_record)
# Create a new logger
logger = logging.getLogger("user_server")
logger.propagate = False
# Add handler if we don't have one.
if not logger.handlers:
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(
        ColoredFormatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    )
    logger.addHandler(handler)
# Configure logger
loglevel = getattr(logging, "INFO", "info")
logger.setLevel(loglevel)
logger.info("sdfasdasdas")
logger.warning("sdfasdasdas")
logger.error("sdfasdasdas")
```


![在这里插入图片描述](/static/img/images/03790.png)

【python】【logging】python如何使用logging模块，一个完美的logging模块

pip install pillow





示例代码：
```python
from PIL import Image, ImageSequence
# 图片文件名列表
image_files = ['car.png', 'detected_map.png', 'base64_image_out.png']
# 打开图片
images = [Image.open(filename) for filename in image_files]
# 设置输出 GIF 文件名
output_gif = 'output.gif'
# 将图片保存为 GIF
images[0].save(
    output_gif,
    save_all=True,
    append_images=images[1:],
    duration=2000,  # 设置每张图片的显示时间（毫秒）
    loop=0,  # 设置循环次数，0 表示不循环
)
print(f'GIF 文件已创建: {output_gif}')
```

将某个路径的所有图片按名称排序后，转为gif文件：

```clike
import os
from PIL import Image, ImageSequence
# 目标路径
target_path = './images'
# 获取目录下所有文件
all_files = os.listdir(target_path)
# 筛选出图片文件
image_files = [os.path.join(target_path, filename) for filename in all_files if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif'))]
# 按照文件名排序
sorted_image_files = sorted(image_files)
# 打开图片并调整为相同的模式
images = [Image.open(filename).convert('RGBA') for filename in sorted_image_files]
# 设置输出 GIF 文件名
output_gif = 'output.gif'
# 将图片保存为 GIF
images[0].save(
    output_gif,
    save_all=True,
    append_images=images[1:],
    duration=2000,  # 设置每张图片的显示时间（毫秒）
    loop=0,  # 设置循环次数，0 表示不循环
)
print(f'GIF 文件已创建: {output_gif}')
```

![在这里插入图片描述](/static/img/images/03791.gif)

【python】Python生成GIF动图，多张图片转动态图，pillow

原则：





1. 输入输出都基于BaseModel

2. 依靠JSONResponse制定返回错误的json信息

3. 依靠装饰器中@app.post制定responses字典从而让docs文档更丰富


```python
import uvicorn
from pydantic import BaseModel, Field
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from transformers import BlipProcessor, BlipForConditionalGeneration
from fastapi.responses import JSONResponse
from PIL import Image
import io
import base64
class UpscalerRequest(BaseModel):
    base64_image: str = Field(
        ...,
        title="Base64 Encoded Image",
        description="The base64-encoded image that you want to upscale."
    )
    outscale: float = Field(
        ...,
        ge=1.0,  # 大于等于1.0
        le=5.0,  # 小于等于5.0
        title="Upscale Factor",
        description="The scaling factor for image upscaling. Should be between 1.0 and 5.0."
    )
class UpscalerResponse(BaseModel):
    base64_image_out: str = Field(
        ...,
        title="Base64 Encoded Upscaled Image",
        description="The base64-encoded image after upscaling."
    )
class CustomErrorResponse:
    def __init__(self, description: str, error_code: int, detail: str):
        self.description = description
        self.error_code = error_code
        self.detail = detail
    def to_response_dict(self):
        return {
            "description": self.description,
            "content": {
                "application/json": {
                    "example": {"error_code": self.error_code, "detail": self.detail}
                }
            },
        }
    def __call__(self, extra_detail=None):
        if extra_detail is not None:
            self.detail = f"detail:{self.detail}, extra_detail:{extra_detail}"
        return JSONResponse(content={"error_code": self.error_code, "detail": self.detail}, status_code=self.error_code)
image_upscaler_CustomErrorResponse = CustomErrorResponse("超分执行错误", 501, "upscale error")
@app.post("/image_upscaler", response_model=UpscalerResponse, summary="Image Upscaler",
          responses={image_upscaler_CustomErrorResponse.error_code: image_upscaler_CustomErrorResponse.to_response_dict()})
def image_upscaler(request: UpscalerRequest):
    """
    Image Upscaler.
    Parameters:
    - `base64_image`: The base64-encoded image.
    - `outscale`: The scaling factor for image upscaling (between 1.0 and 5.0).
    Returns:
    - `output`: The base64-encoded upscaled image.
    Example:
    ```python

import requests

import base64

from PIL import Image

from io import BytesIO

# 1. 读取图像文件并转换为base64字符串

image_path = "car.png"

with open(image_path, "rb") as image_file:

    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

# 2. 构造请求数据

outpainting_request = {

    "base64_image": base64_image,

    "outscale": 3,

}

# 3. 发送HTTP POST请求

api_url = "http://home.elvisiky.com:7862/image_upscaler"

response = requests.post(api_url, json=outpainting_request)

# 4. 处理响应

if response.status_code == 200:

    result_data = response.json()

    # 5. 保存base64编码的图像为文件

    detected_map_base64 = result_data["base64_image_out"]

    detected_map_image = Image.open(BytesIO(base64.b64decode(detected_map_base64)))

    detected_map_image.save("base64_image_out.png")

    print("图像保存成功！")

else:

    print(f"API调用失败，HTTP状态码：{response.status_code}")

    print(response.json())

    ```
    """
    try:
        base64_image = request.base64_image
        logging.info(f"image_upscaler, image length {len(base64_image)}")
        img = decode_image_from_base64(base64_image)
        img_cv2 = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
        output = enhance_image(img_cv2, outscale=request.outscale)
        if output is None:
            return image_upscaler_CustomErrorResponse()
        else:
            output_base64 = base64.b64encode(cv2.imencode('.png', output)[1]).decode('utf-8')
            return {"base64_image_out": output_base64}
    except Exception as e:
        return image_upscaler_CustomErrorResponse(str(e))
if __name__ == '__main__':
    uvicorn.run(f'{os.path.basename(__file__).split(".")[0]}:app',
                host='0.0.0.0',
                port=7862,
                reload=False,
                workers=1)
```

![在这里插入图片描述](/static/img/images/03792.png)

【python FastAPI】fastapi中如何限制输入参数，如何让docs更好看，如何自定义错误码json返回

![在这里插入图片描述](/static/img/images/03819.png)






```python
import tkinter as tk
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['FangSong']  # 指定默认字体
mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
# 函数用于执行最小二乘法线性拟合
def linear_regression():
    x_values = [float(x) for x in x_entry.get().split()]
    y_values = [float(y) for y in y_entry.get().split()]
    A = np.vstack([x_values, np.ones(len(x_values))]).T
    m, c = np.linalg.lstsq(A, y_values, rcond=None)[0]
    # 清空画布
    ax[0].clear()
    ax[1].clear()
    # 绘制数据点
    ax[0].scatter(x_values, y_values, label='数据点')
    # 绘制最小二乘法拟合线
    ax[0].plot(x_values, m * np.array(x_values) + c, 'r', label='自己计算的')
    ax[0].set_title(f'自己计算的: Y = {m:.5f} * X + {c:.5f}')
    # 从斜率和截距输入框获取备选直线的参数
    lines_m = [float(m) for m in m_entry.get().split()]
    lines_c = [float(c) for c in c_entry.get().split()]
    # 绘制备选直线
    for i in range(len(lines_m)):
        ax[0].plot(x_values, lines_m[i] * np.array(x_values) + lines_c[i], label=f'直线 {i + 1}')
    # 计算备选直线中最好的拟合直线，得到是哪一条直线最好
    best_line_index = np.argmin([np.sum(np.square(y_values - (m * np.array(x_values) + c))) for m, c in
                                 zip(lines_m, lines_c)])
    ax[0].set_xlabel('X')
    ax[0].set_ylabel('Y')
    ax[0].legend()
    # 在ax[1]绘制最好的直线
    ax[1].scatter(x_values, y_values, label='数据点')
    ax[1].plot(x_values, lines_m[best_line_index] * np.array(x_values) + lines_c[best_line_index], 'r',
               label=f'直线 {best_line_index + 1}')
    ax[1].set_title(
        f'最佳备选线: Y = {lines_m[best_line_index]} * X + {lines_c[best_line_index]},Index: {best_line_index + 1}')
    ax[1].set_xlabel('X')
    ax[1].set_ylabel('Y')
    ax[1].legend()
    canvas.draw()
# 创建Tkinter窗口
root = tk.Tk()
root.title('最小二乘法线性拟合')
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)
# 创建输入框和标签
x_label = tk.Label(frame, text='输入x值（用空格分隔）:')
x_label.pack()
x_entry = tk.Entry(frame)
x_entry.insert(0, '2 4 6 8 10')  # 设置默认值
x_entry.pack()
y_label = tk.Label(frame, text='输入y值（用空格分隔）:')
y_label.pack()
y_entry = tk.Entry(frame)
y_entry.insert(0, '10.046 20.090 30.155 40.125 50.074')  # 设置默认值
y_entry.pack()
m_label = tk.Label(frame, text='输入备选直线的斜率（用空格分隔）:')
m_label.pack()
m_entry = tk.Entry(frame)
m_entry.insert(0, '5.0 5.01 4.97 4.95 5.08')  # 设置默认值
m_entry.pack()
c_label = tk.Label(frame, text='输入备选直线的截距（用空格分隔）:')
c_label.pack()
c_entry = tk.Entry(frame)
c_entry.insert(0, '0.08 0.07 0.12 0.15 0.06')  # 设置默认值
c_entry.pack()
# 创建确认按钮
calculate_button = tk.Button(frame, text='确认', command=linear_regression)
calculate_button.pack()
# 创建大画布
fig, ax = plt.subplots(1, 2, figsize=(10, 5))
canvas = FigureCanvasTkAgg(fig, master=frame)
canvas.get_tk_widget().pack()
canvas.draw()
# 运行Tkinter主循环
root.mainloop()
```

最小二乘法，可视化UI界面

![在这里插入图片描述](/static/img/images/03841.png)






python

```python
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.staticfiles import StaticFiles
from fastapi.responses import HTMLResponse
from typing import List
import requests
app = FastAPI()
# 配置静态文件目录
app.mount("/static", StaticFiles(directory="static"), name="static")
# HTML页面路由
@app.get("/", response_class=HTMLResponse)
async def get_upload_page():
    return """
    <!DOCTYPE html>
    <html>
    <head>
        <title>Image Upload</title>
    </head>
    <body>
        <h1>Image Upload</h1>
        <form method="post" enctype="multipart/form-data">
            <input type="file" name="file">
            <button type="submit">Upload</button>
        </form>
        <div id="descriptions"></div>
        <script src="/static/main.js"></script>
    </body>
    </html>
    """
# 文件上传端点
@app.post("/upload")
async def file_(file: bytes = File(...)):  # 如果要上传多个文件 files: List[bytes] = File(...)
    """使用File类 文件内容会以bytes的形式读入内存 适合于上传小文件"""
    return {"file_size": len(file)}  # 返回文件大小
if __name__ == "__main__":
    import uvicorn
    uvicorn.run('main:app', host='0.0.0.0', port=8000, reload=True, workers=1)
```


js

```js
document.addEventListener('DOMContentLoaded', () => {
  const form = document.querySelector('form');
  const fileInput = document.querySelector('input[type="file"]');
  const descriptions = document.getElementById('descriptions');
  form.addEventListener('submit', async (e) => {
    e.preventDefault();
    const formData = new FormData();
    formData.append('file', fileInput.files[0]);
    try {
      const response = await fetch('/upload', {
        method: 'POST',
        body: formData,
      });
      if (response.ok) {
        const data = await response.json();
        descriptions.innerHTML = `File size: ${data.file_size} bytes`;
      } else {
        descriptions.innerHTML = 'Upload failed';
      }
    } catch (error) {
      console.error('Error:', error);
      descriptions.innerHTML = 'An error occurred';
    }
  });
});
```


结果网页：

![在这里插入图片描述](/static/img/images/03842.png)

【Python Fastapi】js上传文件，fastapi处理，js显示回传信息

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。