essesoul's Blog

5 分钟搭建自己的 AI 知识库

Tue, 23 Sep 2025 00:00:00 +0000

目录结构

AIbot-File
├── db/                         数据库文件（自动生成）
├── static/                     存储 Web 静态资源
├── templates/                  存储 Web 模板
├── app.py                      对外服务接口
├── chatbot.py                  对接大语言模型
├── embedding.py                对接嵌入模型
├── file_service.py             文件存储与管理
├── FileManage.py               文件管理 Web 服务
├── models.py                   定义 File 数据库（用于保存文件信息）
└── requirements.txt

模型对接

分成两部分，对接大语言模型和对接嵌入模型

大语言模型

from openai import OpenAI
from embedding import EmbeddingBot
from typing import Optional

class ChatBot:
    def __init__(self, api_key="", model_name="deepseek-ai/DeepSeek-V3"):
        """初始化聊天机器人
        Args:
            api_key: 可选的 API 密钥，如果提供则使用该密钥
            model_name: 使用的模型名称
        """
        # 初始化 OpenAI 客户端
        self.model_name = model_name
        self.client = OpenAI(
            base_url="https://api.siliconflow.cn",  # 模型 API 地址
            api_key=api_key if api_key else "no-key-required"
        )

        self.embedding_bot = EmbeddingBot()
        self.context_length = 5  # 保留的对话上下文长度

    def _get_relevant_context(self, query: str) -> str:
        """从向量数据库获取相关上下文"""
        # 直接查询向量数据库
        results = self.embedding_bot.query(
            query_text=query,
            n_results=5
        )
        return "\n".join(results['documents'][0])

    def chat(self, user_input: str, history: Optional[list] = None) -> str:
        """处理用户输入并返回 AI 回复"""
        # 获取相关知识上下文
        knowledge = self._get_relevant_context(user_input)
        
        # 构建对话历史
        messages = []
        if history:
            messages.extend(history[-self.context_length:])
        
        # 添加系统提示和知识上下文
        messages.append({
            "role": "system",
            "content": f"你是一个 AI 助手，请根据以下知识回答问题:\n{knowledge}"
        })
        
        messages.append({
            "role": "user",
            "content": user_input
        })
        
        # 调用
        response = self.client.chat.completions.create(
            model=self.model_name,
            messages=messages,
            temperature=0.7
        )
        
        return response.choices[0].message.content

嵌入模型

嵌入模型负责把文本转化为向量

使用向量的好处是可以更方便地找到与用户提问相关的文本

代码包含了以下功能：

原始文件向量化并存储
删除文件时，删除关联的向量数据
用户提问时查找相关文本

import os

import chromadb
import markdown
import requests


class EmbeddingBot:
    def __init__(self, api_url="https://api.siliconflow.cn/v1/embeddings",
                 api_key="", model_name="BAAI/bge-m3"):
        """初始化嵌入 API 和向量数据库
        Args:
            api_url: 嵌入 API 地址
            api_key: 可选的 API 密钥
            model_name: 使用的嵌入模型名称
        """
        self.api_url = api_url
        self.api_key = api_key
        self.model_name = model_name

        # 初始化 ChromaDB (持久化模式)
        db_path = os.path.join("db", "files")
        os.makedirs(db_path, exist_ok=True)
        from chromadb.config import Settings
        self.chroma_client = chromadb.PersistentClient(
            path=db_path,
            settings=Settings(anonymized_telemetry=False)
        )
        self.collection = self.chroma_client.get_or_create_collection(name="knowledge_base",
                                                                      metadata={"dimension": 1024})

    def extract_text(self, file_path):
        """提取文件内容"""
        text = ""
        if file_path.endswith('.md'):
            with open(file_path, 'r', encoding='utf-8') as f:
                text = markdown.markdown(f.read())
        return text

    def process_file(self, file_path, metadata=None):
        """处理文件并存储向量"""
        text = self.extract_text(file_path)
        if not text:
            return False

        # 向量化文本
        embeddings = self.embedding([text])
        if embeddings:
            # print(f"文件向量化成功，维度：{len(embeddings[0])}")
            # 合并元数据
            doc_metadata = {"file_path": file_path}
            if metadata:
                doc_metadata.update(metadata)

            # 存储到 ChromaDB
            self.collection.add(
                documents=[text],
                embeddings=[embeddings[0]],
                metadatas=[doc_metadata],
                ids=[os.path.basename(file_path)]
            )
            return True
        return False

    def process_files(self, file_paths, metadata=None):
        """批量处理文件"""
        results = []
        for file_path in file_paths:
            results.append(self.process_file(file_path, metadata))
        return results

    def delete_embeddings(self, file_path, delete_file=False):
        """删除文件对应的向量数据"""
        file_id = os.path.basename(file_path)
        if delete_file and os.path.exists(file_path):
            os.remove(file_path)
        self.collection.delete(ids=[file_id])

    def query(self, query_text, n_results=5, include_metadata=True):
        """查询知识库
        Args:
            query_text: 查询文本
            n_results: 返回结果数量
            include_metadata: 是否包含元数据
        Returns:
            dict: 包含查询结果的字典，格式为：
                {
                    'documents': 匹配的文档列表，
                    'metadatas': 匹配的元数据列表 (可选),
                    'scores': 匹配分数列表
                }
        """
        try:
            # 先将查询文本向量化
            query_embedding = self.embedding([query_text])
            
            # 使用向量进行查询
            results = self.collection.query(
                query_embeddings=query_embedding,
                n_results=n_results,
                include=["documents", "metadatas", "distances"] if include_metadata else ["documents", "distances"]
            )
            
            # 转换距离为相似度分数 (0-1)
            if 'distances' in results:
                results['scores'] = [1 - (d / 2) for d in results['distances'][0]]
                del results['distances']
            
            return results
        except Exception as e:
            print(f"查询失败：{str(e)}")
            return {'error': str(e)}

    def embedding(self, input_data):
        """通过 API 生成 embedding 向量"""
        headers = {}
        if self.api_key:
            headers["Authorization"] = f"Bearer {self.api_key}"

        response = requests.post(
            self.api_url,
            json={"input": input_data, "model": self.model_name, "dimensions": 1024},
            headers=headers,
            timeout=30
        )
        response.raise_for_status()
        embedding_data = response.json()
        # 提取 embedding 向量数组
        embeddings = embedding_data['data'][0]['embedding']

        # 验证维度
        actual_dim = len(embeddings)
        if actual_dim != 1024:
            raise ValueError(f"维度不匹配：预期 1024 维，实际{actual_dim}维")

        return [embeddings]

文件存储与管理

定义数据库

这里使用 sqlite 存储源文件信息，方便后续的下载查看

from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime

Base = declarative_base()

class File(Base):
    __tablename__ = 'files'
    
    id = Column(Integer, primary_key=True)
    filename = Column(String(255), nullable=False)
    upload_time = Column(DateTime, default=datetime.now)
    file_path = Column(String(255), nullable=False)

def init_db():
    engine = create_engine('sqlite:///db/files.db')
    Base.metadata.create_all(engine)
    return sessionmaker(bind=engine)

文件管理类

用于处理文件的上传（以及向量化存储）、下载、删除

import os
import logging
from datetime import datetime
from models import File, init_db
from embedding import EmbeddingBot


# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class FileService:
    def __init__(self):
        self.storage_dir = 'storage'
        self.db_dir = 'db'
        self.Session = init_db()
        self.embedding_bot = EmbeddingBot()
        
        
    def save_file(self, uploaded_file):
        """保存文件到 storage 目录并记录到数据库"""
        logger.info(f"开始处理文件上传：{uploaded_file.filename}")
        
        if not os.path.exists(self.storage_dir):
            logger.info(f"创建存储目录：{self.storage_dir}")
            os.makedirs(self.storage_dir)
            
        original_filename = uploaded_file.filename
        # 检查文件类型
        allowed_extensions = {'.md'}
        file_ext = os.path.splitext(original_filename)[1].lower()
        if file_ext not in allowed_extensions:
            error_msg = f"不支持的文件类型：{file_ext}，仅支持：{', '.join(allowed_extensions)}"
            logger.error(error_msg)
            raise ValueError(error_msg)
            
        # 生成唯一文件名
        import uuid
        unique_filename = f"{uuid.uuid4()}{file_ext}"
        file_path = os.path.join(self.storage_dir, unique_filename)
        logger.info(f"文件保存路径：{file_path}")
        
        try:
            # 保存文件
            logger.info("开始保存文件...")
            with open(file_path, 'wb') as buffer:
                uploaded_file.save(buffer)
            logger.info("文件保存成功")
            
            # 验证文件内容
            if os.path.getsize(file_path) == 0:
                error_msg = "上传的文件为空"
                logger.error(error_msg)
                os.remove(file_path)
                raise ValueError(error_msg)
            
            # 数据库记录
            session = self.Session()
            try:
                logger.info("开始数据库记录...")
                file_record = File(
                    filename=original_filename,  # 保存原始文件名
                    file_path=file_path,
                    upload_time=datetime.now()
                )
                session.add(file_record)
                session.commit()
                logger.info(f"数据库记录成功，ID: {file_record.id}")
                
                # 向量化处理 (通过 embedding_bot)
                logger.info("开始向量化处理...")
                try:
                    if not self.embedding_bot.process_file(file_path):
                        error_msg = "文件向量化处理失败"
                        logger.error(error_msg)
                        raise ValueError(error_msg)
                    logger.info("向量化处理成功")
                except Exception as e:
                    logger.error(f"向量化处理异常：{str(e)}")
                    raise ValueError(f"向量化处理失败：{str(e)}")
                
                return file_record
            except Exception as e:
                logger.error(f"数据库操作失败：{str(e)}")
                session.rollback()
                if os.path.exists(file_path):
                    os.remove(file_path)
                raise
            finally:
                session.close()
        except Exception as e:
            logger.error(f"文件处理失败：{str(e)}")
            if os.path.exists(file_path):
                os.remove(file_path)
            raise
    
    def delete_file(self, file_id):
        """删除文件及相关记录"""
        session = self.Session()
        try:
            file_record = session.query(File).filter(File.id == file_id).first()
            if file_record:
                # 删除物理文件
                if os.path.exists(file_record.file_path):
                    os.remove(file_record.file_path)
                
                # 删除向量数据 (通过 embedding_bot)
                try:
                    self.embedding_bot.delete_embeddings(file_record.file_path)
                except Exception as e:
                    logger.error(f"向量数据删除失败：{str(e)}")
                    raise
                
                # 删除数据库记录
                session.delete(file_record)
                session.commit()
                return True
            return False
        finally:
            session.close()
    
    def get_file(self, file_id):
        """获取文件记录"""
        session = self.Session()
        try:
            return session.query(File).filter(File.id == file_id).first()
        finally:
            session.close()

    def get_file_content(self, file_id):
        """获取文件内容 (返回内容和原始文件名)"""
        session = self.Session()
        try:
            file_record = session.query(File).filter(File.id == file_id).first()
            if not file_record:
                return None
                
            with open(file_record.file_path, 'rb') as f:
                content = f.read()
            
            return {
                'content': content,
                'filename': file_record.filename  # 原始文件名
            }
        finally:
            session.close()

Web 端文件管理

为了更方便地管理知识库文件，这里使用 Flask 做一个简单的 Web 页面，用于上传文件并管理已有文件

模板文件中的静态资源为 Bootstrap v5.3.0 点击此处获取

Jinja2 模板

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AI知识库管理系统</title>
    <link href="/static/css/bootstrap.min.css" rel="stylesheet">
    <style>
        .file-list {
            max-height: 500px;
            overflow-y: auto;
        }
        .upload-area {
            border: 2px dashed #ccc;
            padding: 20px;
            text-align: center;
            margin-bottom: 20px;
            cursor: pointer;
        }
        .upload-area:hover {
            border-color: #0d6efd;
        }
    </style>
</head>
<body>
    <div class="container mt-4">
        <h1 class="text-center mb-4">AI 知识库管理系统</h1>
        
        <div class="card">
            <div class="card-header">
                <h5>上传文件</h5>
            </div>
            <div class="card-body">
                <div id="uploadArea" class="upload-area">
                    <p>点击或拖拽文件到此处上传</p>
                    <p class="small text-muted">仅支持 Markdown(.md) 文件</p>
                    <input type="file" id="fileInput" class="d-none" accept=".md" multiple>
                </div>
                <div class="progress d-none" id="uploadProgress">
                    <div class="progress-bar" role="progressbar" style="width: 0%"></div>
                </div>
                <div id="uploadError" class="alert alert-danger d-none mt-2"></div>
                <div id="fileNameDisplay" class="mt-2 small text-muted d-none"></div>
                <button id="uploadBtn" class="btn btn-primary mt-2" disabled>上传</button>
            </div>
        </div>

        <div class="card mt-4">
            <div class="card-header">
                <h5>文件列表</h5>
            </div>
            <div class="card-body">
                <div class="file-list">
                    <table class="table table-striped">
                        <thead>
                            <tr>
                                <th><input type="checkbox" id="selectAll"></th>
                                <th>文件名</th>
                                <th>上传时间</th>
                                <th>操作</th>
                            </tr>
                        </thead>
                        <tbody id="fileTableBody">
                            <!-- 文件列表将通过 JavaScript 动态加载 -->
                        </tbody>
                    </table>
            </div>
            <div class="card-footer">
                <button class="btn btn-danger" onclick="batchDelete()">批量删除选中文件</button>
            </div>
        </div>
    </div>

    <!-- 删除进度模态框 -->
    <div class="modal fade" id="deleteModal" tabindex="-1" aria-hidden="true">
        <div class="modal-dialog">
            <div class="modal-content">
                <div class="modal-header">
                    <h5 class="modal-title">正在删除文件</h5>
                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
                </div>
                <div class="modal-body">
                    <div class="progress">
                        <div id="deleteProgressBar" class="progress-bar" role="progressbar" style="width: 0%"></div>
                    </div>
                    <p id="deleteStatusText" class="mt-2">准备删除...</p>
                </div>
                <div class="modal-footer">
                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
                </div>
            </div>
        </div>
    </div>

    <script src="/static/js/bootstrap.bundle.min.js"></script>
    <script>
        document.addEventListener('DOMContentLoaded', function() {
            // 初始化
            loadFiles();

            // 全选/取消全选
            document.getElementById('selectAll').addEventListener('change', function() {
                const checkboxes = document.querySelectorAll('#fileTableBody input[type="checkbox"]');
                checkboxes.forEach(checkbox => {
                    checkbox.checked = this.checked;
                });
            });
            
            // 上传区域点击事件
            const uploadArea = document.getElementById('uploadArea');
            const fileInput = document.getElementById('fileInput');
            const uploadBtn = document.getElementById('uploadBtn');
            
            uploadArea.addEventListener('click', () => fileInput.click());
            
            // 拖拽上传
            uploadArea.addEventListener('dragover', (e) => {
                e.preventDefault();
                uploadArea.classList.add('border-primary');
            });
            
            uploadArea.addEventListener('dragleave', () => {
                uploadArea.classList.remove('border-primary');
            });
            
            uploadArea.addEventListener('drop', (e) => {
                e.preventDefault();
                uploadArea.classList.remove('border-primary');
                const errorEl = document.getElementById('uploadError');
                
                if (e.dataTransfer.files.length) {
                    const files = Array.from(e.dataTransfer.files);
                    const invalidFiles = files.filter(file => !file.name.toLowerCase().endsWith('.md'));
                    
                    if (invalidFiles.length) {
                        errorEl.textContent = `有${invalidFiles.length}个文件不是.md 格式`;
                        errorEl.classList.remove('d-none');
                        uploadBtn.disabled = true;
                        return;
                    }
                    
                    errorEl.classList.add('d-none');
                    fileInput.files = e.dataTransfer.files;
                    uploadBtn.disabled = false;
                    document.getElementById('fileNameDisplay').textContent = `已选择${files.length}个文件`;
                    document.getElementById('fileNameDisplay').classList.remove('d-none');
                }
            });
            
            // 文件选择变化
            fileInput.addEventListener('change', () => {
                const errorEl = document.getElementById('uploadError');
                if (fileInput.files.length) {
                    const files = Array.from(fileInput.files);
                    const invalidFiles = files.filter(file => !file.name.toLowerCase().endsWith('.md'));
                    
                    if (invalidFiles.length) {
                        errorEl.textContent = `有${invalidFiles.length}个文件不是.md 格式`;
                        errorEl.classList.remove('d-none');
                        uploadBtn.disabled = true;
                        return;
                    }
                    
                    errorEl.classList.add('d-none');
                    uploadBtn.disabled = false;
                    document.getElementById('fileNameDisplay').textContent = `已选择${files.length}个文件`;
                    document.getElementById('fileNameDisplay').classList.remove('d-none');
                } else {
                    uploadBtn.disabled = true;
                    document.getElementById('fileNameDisplay').classList.add('d-none');
                }
            });
            
            // 上传按钮点击
            uploadBtn.addEventListener('click', uploadFile);
        });
        
        // 加载文件列表
        function loadFiles() {
            fetch('/files')
                .then(response => response.json())
                .then(files => {
                    const tbody = document.getElementById('fileTableBody');
                    tbody.innerHTML = '';
                    
                    files.forEach(file => {
                        const row = document.createElement('tr');
                        row.innerHTML = `
                            <td><input type="checkbox" class="file-checkbox" data-file-id="${file.id}"></td>
                            <td>${file.filename}</td>
                            <td>${new Date(file.upload_time).toLocaleString()}</td>
                            <td>
                                <button class="btn btn-sm btn-success" onclick="downloadFile(${file.id})">下载</button>
                                <button class="btn btn-sm btn-danger" onclick="deleteFile(${file.id})">删除</button>
                            </td>
                        `;
                        tbody.appendChild(row);
                    });
                });
        }
        
        // 上传文件队列
        let uploadQueue = [];
        let isUploading = false;
        
        // 上传文件
        function uploadFile() {
            const fileInput = document.getElementById('fileInput');
            const progressBar = document.getElementById('uploadProgress');
            const progressBarInner = progressBar.querySelector('.progress-bar');
            
            if (!fileInput.files.length) return;
            
            uploadQueue = Array.from(fileInput.files);
            progressBar.classList.remove('d-none');
            uploadBtn.disabled = true;
            
            processUploadQueue();
        }
        
        function processUploadQueue() {
            if (uploadQueue.length === 0) {
                isUploading = false;
                const progressBar = document.getElementById('uploadProgress');
                const progressBarInner = progressBar.querySelector('.progress-bar');
                
                progressBarInner.style.width = '100%';
                setTimeout(() => {
                    progressBar.classList.add('d-none');
                    progressBarInner.style.width = '0%';
                    document.getElementById('fileInput').value = '';
                    document.getElementById('uploadError').classList.add('d-none');
                }, 500);
                return;
            }
            
            isUploading = true;
            const file = uploadQueue[0];
            const progressBarInner = document.getElementById('uploadProgress').querySelector('.progress-bar');
            
            document.getElementById('fileNameDisplay').textContent = `正在上传：${file.name} (剩余${uploadQueue.length}个文件)`;
            progressBarInner.style.width = '0%';
            
            const formData = new FormData();
            formData.append('file', file);
            
            fetch('/upload', {
                method: 'POST',
                body: formData
            })
            .then(response => {
                if (!response.ok) {
                    return response.json().then(err => { 
                        throw new Error(err.error || '上传失败');
                    });
                }
                return response.json();
            })
            .then(data => {
                progressBarInner.style.width = '100%';
                uploadQueue.shift();
                loadFiles(); // 每次上传成功刷新列表
                setTimeout(() => {
                    processUploadQueue();
                }, 300);
            })
            .catch(error => {
                const errorEl = document.getElementById('uploadError');
                errorEl.textContent = `${file.name}上传失败：${error.message}`;
                errorEl.classList.remove('d-none');
                uploadQueue.shift();
                setTimeout(() => {
                    processUploadQueue();
                }, 300);
            });
        }
        
        // 下载文件
        function downloadFile(fileId) {
            window.open(`/download/${fileId}`, '_blank');
        }
        
        // 批量删除文件
        function batchDelete() {
            const checkboxes = document.querySelectorAll('#fileTableBody input.file-checkbox:checked');
            if (checkboxes.length === 0) {
                alert('请先选择要删除的文件');
                return;
            }

            const fileIds = Array.from(checkboxes).map(checkbox => checkbox.dataset.fileId);
            if (confirm(`确定要删除选中的${fileIds.length}个文件吗？`)) {
                const deleteModal = new bootstrap.Modal(document.getElementById('deleteModal'));
                const progressBar = document.getElementById('deleteProgressBar');
                const statusText = document.getElementById('deleteStatusText');
                
                deleteModal.show();
                progressBar.style.width = '0%';
                statusText.textContent = `准备删除 ${fileIds.length} 个文件...`;

                let completed = 0;
                const total = fileIds.length;

                function deleteNextFile() {
                    if (completed >= total) {
                        statusText.textContent = '所有文件删除完成';
                        setTimeout(() => {
                            deleteModal.hide();
                            loadFiles();
                        }, 1000);
                        return;
                    }

                    const currentFileId = fileIds[completed];
                    statusText.textContent = `正在删除文件 ${completed + 1}/${total} (ID: ${currentFileId})`;

                    fetch(`/delete/${currentFileId}`, {
                        method: 'DELETE'
                    })
                    .then(response => {
                        if (!response.ok) throw new Error('删除失败');
                        return response.json();
                    })
                    .then(() => {
                        completed++;
                        progressBar.style.width = `${(completed / total) * 100}%`;
                        deleteNextFile();
                    })
                    .catch(error => {
                        alert(`删除文件 ${currentFileId} 失败：${error.message}`);
                        completed++;
                        progressBar.style.width = `${(completed / total) * 100}%`;
                        deleteNextFile();
                    });
                }

                deleteNextFile();
            }
        }

        // 删除单个文件
        function deleteFile(fileId) {
            if (confirm('确定要删除这个文件吗？')) {
                const deleteModal = new bootstrap.Modal(document.getElementById('deleteModal'));
                const progressBar = document.getElementById('deleteProgressBar');
                const statusText = document.getElementById('deleteStatusText');
                
                deleteModal.show();
                progressBar.style.width = '0%';
                statusText.textContent = '正在删除文件...';

                fetch(`/delete/${fileId}`, {
                    method: 'DELETE'
                })
                .then(response => {
                    if (!response.ok) throw new Error('删除失败');
                    return response.json();
                })
                .then(() => {
                    progressBar.style.width = '100%';
                    statusText.textContent = '文件删除成功';
                    setTimeout(() => {
                        deleteModal.hide();
                        loadFiles();
                    }, 1000);
                })
                .catch(error => {
                    progressBar.style.width = '100%';
                    statusText.textContent = '删除失败';
                    alert(error.message);
                });
            }
        }
    </script>
</body>
</html>

Flask

from flask import Flask, request, render_template, send_file, jsonify
from file_service import FileService
from models import File

app = Flask(__name__, static_folder='static')

file_service = FileService()

# Web 界面
@app.route('/')
def index():
    return render_template('index.html')

# 文件上传
@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return jsonify({'error': 'No file part'}), 400
    
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'No selected file'}), 400
    
    try:
        file_record = file_service.save_file(file)
        return jsonify({
            'id': file_record.id,
            'filename': file_record.filename,
            'upload_time': file_record.upload_time.isoformat()
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

# 文件下载
@app.route('/download/<int:file_id>')
def download_file(file_id):
    file_data = file_service.get_file_content(file_id)
    if not file_data:
        return jsonify({'error': 'File not found'}), 404
    
    from io import BytesIO
    return send_file(
        BytesIO(file_data['content']),
        as_attachment=True,
        download_name=file_data['filename']
    )

# 文件删除
@app.route('/delete/<int:file_id>', methods=['DELETE'])
def delete_file(file_id):
    if not file_service.delete_file(file_id):
        return jsonify({'error': 'File not found'}), 404
    return jsonify({'message': 'File deleted successfully'})

# 文件列表
@app.route('/files')
def list_files():
    session = file_service.Session()
    try:
        files = session.query(File).all()
        return jsonify([
            {
                'id': f.id,
                'filename': f.filename,
                'upload_time': f.upload_time.isoformat()
            }
            for f in files
        ])
    finally:
        session.close()

if __name__ == '__main__':
    app.run(debug=False,port=5051)

对外接口

这里使用 FastAPI 提供一个对外接口示例，可以根据实际需要更改输入输出格式

import json

import uvicorn
from fastapi import FastAPI, Request

from chatbot import ChatBot

app = FastAPI()
# 初始化
chatbot = ChatBot()


@app.post("/api/chat")
async def chat_endpoint(request: Request):
    try:
        data = await request.json()
        if not data:
            return {"error": "Empty request body"}, 400
        user_input = data.get("message")
        if not user_input:
            return {"error": "Missing 'message' field"}, 400
        response = chatbot.chat(user_input)
        return {"response": response}
    except json.JSONDecodeError:
        return {"error": "Invalid JSON format"}, 400
    except Exception as e:
        return {"error": f"Server error: {str(e)}"}, 500


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

MacOS 15 微信文件保存到外置磁盘

Wed, 28 May 2025 00:00:00 +0000

环境信息

系统版本 MacOS Sequoia 15.5

微信版本 4.0.5.19

创建新文件夹

新文件夹用于存放微信文件，一般是外置扩展硬盘

例如 /Volumes/iData/WeChatData/xwechat_files

数据迁移

注意： 先退出微信再进行后面操作

将 ~/Library/Containers/com.tencent.xinWeChat/Data/Documents/xwechat_files

移动到 /Volumes/iData/WeChatData/xwechat_files

创建软链接

在终端中执行下面命令

1
2

sudo ln -s /Volumes/Files/WeChatData/xwechat_files ~/Library/Containers/com.tencent.xinWeChat/Data/Documents/xwechat_files
sudo ln -s /Volumes/Files/WeChatData/xwechat_files ~/Library/Containers/com.tencent.xinWeChat/Data/Documents/app_data/xwechat_files

创建两次链接是因为实际测试中发现微信会在 Documents 和 Documents/app_data 保存数据

当只在一个地方创建时，微信会自动在另一个路径下创建文件

重新签名微信

在终端运行下面命令，并输入密码

`1`	`sudo codesign --sign - --force --deep /Volumes/Files/Applications/WeChat.app`

出现下面提示则完成

/Volumes/Files/Applications/WeChat.app: replacing existing signature

如果出现提示 /Volumes/Files/Applications/WeChat.app: Operation not permitted ，需要在设置里面给终端授予权限。

进入设置 - App 管理

打开终端右侧的开关，重新执行上面命令即可。

Python 词云图的创建

Sat, 10 May 2025 00:00:00 +0000

代码

import os
import pandas as pd
from wordcloud import WordCloud
import matplotlib.pyplot as plt
import jieba

def generate_wordcloud(text, save_path):
    # 中文分词
    seg_list = jieba.cut(text, cut_all=False)
    seg_text = " ".join(seg_list)
    
    # 生成词云
    wc = WordCloud(
        font_path='simhei.ttf',  # 中文字体
        background_color='white',
        width=800,
        height=600,
        max_words=200
    )
    wc.generate(seg_text)
    
    # 保存词云图
    plt.figure(figsize=(10, 8))
    plt.imshow(wc, interpolation='bilinear')
    plt.axis('off')
    plt.savefig(save_path, bbox_inches='tight', dpi=300)
    plt.close()

def process_csv_files(root_dir):
    for root, dirs, files in os.walk(root_dir):
        for file in files:
            if file.endswith('.csv'):
                csv_path = os.path.join(root, file)
                try:
                    df = pd.read_csv(csv_path)
                    
                    # 检查是否有"评论内容"列
                    if '评论内容' in df.columns:
                        # 过滤空内容
                        comments = df['评论内容'].dropna().tolist()
                        if comments:
                            text = " ".join(str(c) for c in comments)
                            output_path = os.path.join(root, f'wordcloud_{os.path.splitext(file)[0]}.png')
                            generate_wordcloud(text, output_path)
                            print(f"已生成词云图：{output_path}")
                except Exception as e:
                    print(f"处理文件 {csv_path} 时出错：{e}")

if __name__ == '__main__':
    input_path = input("请输入包含 CSV 文件的目录路径：")
    if os.path.isdir(input_path):
        process_csv_files(input_path)
    else:
        print("输入的路径无效，请检查后重试")

使用方法

直接粘贴文件夹绝对路径即可，会自动在子文件夹中查找 csv文件 并保存在同级文件夹下

Python 批量情感识别

Sat, 10 May 2025 00:00:00 +0000

代码

import os
import pandas as pd
from snownlp import SnowNLP
import matplotlib.pyplot as plt

def analyze_sentiment(text):
    """使用 SnowNLP 进行情感分析"""
    try:
        return SnowNLP(text).sentiments
    except:
        return None

def process_csv(file_path):
    """处理单个 CSV 文件"""
    try:
        df = pd.read_csv(file_path)
        if '评论内容' not in df.columns:
            print(f"文件 {file_path} 中没有'评论内容'列")
            return
        
        # 过滤空评论
        comments = df['评论内容'].dropna().tolist()
        if not comments:
            print(f"文件 {file_path} 中没有有效评论内容")
            return
        
        # 情感分析
        sentiments = []
        for comment in comments:
            score = analyze_sentiment(comment)
            if score is not None:
                sentiments.append(score)
        
        if not sentiments:
            print(f"文件 {file_path} 情感分析失败")
            return
        
        # 绘制图表
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置中文字体
        plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题
        plt.figure(figsize=(10, 6))
        plt.hist(sentiments, bins=20, color='skyblue', edgecolor='black')
        plt.title('评论情感分析分布')
        plt.xlabel('情感分数 (0-1)')
        plt.ylabel('评论数量')
        plt.grid(True, linestyle='--', alpha=0.7)
        
        # 保存图表
        output_path = os.path.join(os.path.dirname(file_path), 'sentiment_analysis.png')
        plt.savefig(output_path)
        plt.close()
        print(f"图表已保存到：{output_path}")
        
    except Exception as e:
        print(f"处理文件 {file_path} 时出错：{str(e)}")

def main():
    """主函数"""
    path = input("请输入要分析的目录路径：")
    if not os.path.isdir(path):
        print("路径不存在或不是目录")
        return
    
    # 递归查找 CSV 文件
    for root, _, files in os.walk(path):
        for file in files:
            if file.endswith('.csv'):
                file_path = os.path.join(root, file)
                print(f"正在处理文件：{file_path}")
                process_csv(file_path)

if __name__ == '__main__':
    main()

使用方法

输入要处理的目录路径，程序会自动处理目录下的所有 CSV 文件 （包含子目录），并将图表保存在同级目录下。

图表中数值越接近 1 则表示评论的情感越正向，越接近 0 则表示的情感越负向。

Ubuntu 添加用户、授予 Sudo 权限

Wed, 04 Dec 2024 00:00:00 +0000

添加新用户

`1`	`sudo adduser username`

验证用户是否具有 sudo 访问权限

`1`	`sudo -l -U username`

授予 Sudo 权限

`1`	`sudo adduser username sudo`

删除用户的 Sudo 访问权限

`1`	`sudo deluser username sudo`

永久删除用户

`1`	`sudo deluser username`

删除用户及其主目录

`1`	`sudo deluser username --remove-home`

Ubuntu 修改主机名

Wed, 04 Dec 2024 00:00:00 +0000

查看当前主机名

`1`	`hostname`

`1`	`hostnamectl`

修改系统主机名

sudo hostnamectl set-hostname host.example.com
sudo hostnamectl set-hostname "Your Pretty HostName" --pretty
sudo hostnamectl set-hostname host.example.com --static
sudo hostnamectl set-hostname host.example.com --transient

修改 /etc/hosts 文件

1
2
3

sudo vim /etc/hosts
127.0.0.1 localhost
127.0.1.1 host.example.com host

Ubuntu 安装 Vmware Tools

Mon, 02 Dec 2024 00:00:00 +0000

进入终端，只需要输入三行命令

1
2
3

sudo apt upgrade
sudo apt install open-vm-tools-desktop -y
sudo reboot

Spring6 中删除了 CommonsMultipartResolver 类后，使用 SpringMVC 上传文件

Wed, 13 Nov 2024 00:00:00 +0000

问题描述

提示：CommonsMultipartFile cannot be resolved to a type

在新的 Spring6 中，官方删除了之前上传文件使用的 CommonsMultipartResolver 类，导致之前的上传文件方法行不通了。

解决方案

在 web.xml 文件配置前端处理器 DispatcherServlet 的标签中添加下面的配置：

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>


        <!--         配置文件上传的处理器   -->
        <multipart-config>
            <!--         上传文件最大为多少   -->
            <max-file-size>10485760</max-file-size>
            <!--         最大的请求大小   -->
            <max-request-size>10485760</max-request-size>
            <!--         多大以上的文件可以上传   -->
            <file-size-threshold>0</file-size-threshold>
        </multipart-config>
    </servlet>

接着在 Spring 的配置文件中，把 org.springframework.web.multipart.commons.CommonsMultipartyResolver

替换成 org.springframework.web.multipart.support.StandardServletMultipartResolver

1
2

    <!-- <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartyResolver"/> -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver"/>

最后在 Controller 类的方法中，MultipartFile 类型的形参前面加上 @RequestParam 注解，注意别忘了 value 属性

    @PostMapping("/uploadFile")
    public String uploadFile(@RequestParam("file") MultipartFile file, Model model) {
        if (file.isEmpty()) {
            model.addAttribute("message", "Please select a file to upload");
            System.out.println("Please select a file to upload");
            return "uploadStatus";
        }

        try {
            // 保存文件到本地
            byte[] bytes = file.getBytes();
            Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
            Files.write(path, bytes);

            // 把文件名添加到模型中
            model.addAttribute("message", "You successfully uploaded '" + file.getOriginalFilename() + "'");
            System.out.println("You successfully uploaded '" + file.getOriginalFilename() + "'");

        } catch (IOException e) {
            e.printStackTrace();
        }
        return "uploadStatus";
    }

.gitignore 不生效解决办法

Thu, 07 Nov 2024 00:00:00 +0000

解决方法

git 清除本地缓存（改变成未 track 状态）

1
2
3

git rm -r --cached .
git add .
git commit -m 'update .gitignore'

Cloudflare Pages 限制

Thu, 07 Nov 2024 00:00:00 +0000

官方文档：https://developers.cloudflare.com/pages/platform/limits/

自定义域

每个项目的自定义域数量

免费	Pro	Business	Enterprise
100	250	500	500

文件

每个网站最多包含 20,000 个文件

文件大小

每个文件不得大于 25 MB

项目数量

软限制：100 个

可以在页面顶部的链接中填写限制增加申请表

Ubuntu 常用软件更新命令

Thu, 07 Nov 2024 00:00:00 +0000

更新系统软件源

`1`	`apt-get update`

更新升级所有软件

`1`	`apt-get upgrade`

更新某个软件

`1`	`apt-get upgrade 软件名`

其他软件操作命令

apt list --upgradable #查看可更新的软件

apt-get dist-upgrade #升级 ubuntu 系统版本

apt-get install package_name #安装一个软件包

apt-get remove package #删除一个软件包

apt-get help #查看其他 apt-get 命令

虚拟机报错 SMBus Host Controller not enabled

Wed, 06 Nov 2024 00:00:00 +0000

问题

ubuntu 不能启动，错误信息如下： piix4_smbus : SMBus Host Controller not enabled!

解决

按住 shift 重新启动：

选择“Advanced options for Ubuntu”

选择“… (recovery mode)”进入恢复模式

选择“root": 进入命令模式

回车进入命令模式

命令：lsmod | grep piix4 查询与错误相关的模块

编辑 /etc/modprobe.d/blacklist.conf

`1`	`sudo vim /etc/modprobe.d/blacklist.conf`

在最后面另起一行加入 blacklist i2c_piix4

更新启动配置文件：

`1`	`update-initramfs -u -k all`

输入命令：reboot ，重启系统

npm 镜像源设置

Tue, 05 Nov 2024 00:00:00 +0000

在使用 npm 过程中经常会遇到无法下载包的问题，在这里整理了几个 npm 使用国内镜像加速的方法。

原始镜像源

`1`	`https://registry.npmjs.org/`

设置淘宝镜像源

`1`	`npm config set registry https://registry.npmmirror.com/`

设置腾讯云镜像源

`1`	`npm config set registry http://mirrors.cloud.tencent.com/npm/`

设置华为云镜像源

`1`	`npm config set registry https://mirrors.huaweicloud.com/repository/npm/`

检测设置

`1`	`npm config get registry`

分治算法

Mon, 04 Nov 2024 00:00:00 +0000

在计算机科学中，分治法是建基于多项分支递归的一种很重要的算法范型。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

代码示例

列出 1-5【任意不依次】取 3 个【可重复】的各种可能性

def divide_and_conquer(nums, length):
    if length == 1:
        return [[num] for num in nums]
    
    smaller_combinations = divide_and_conquer(nums, length - 1)
    all_combinations = []
    
    for combination in smaller_combinations:
        for num in nums:
            all_combinations.append(combination + [num])
    
    return all_combinations

numbers = [1, 2, 3, 4, 5]
combination_length = 3
combinations = divide_and_conquer(numbers, combination_length)

for combination in combinations:
    print(combination)

列出 1-5【任意不依次】取 3 个【不重复】的各种可能性

def divide_and_conquer(nums, length):
    if length == 1:
        return [[num] for num in nums]
    
    smaller_combinations = divide_and_conquer(nums, length - 1)
    all_combinations = []
    
    for combination in smaller_combinations:
        for num in nums:
            if num not in combination:
                all_combinations.append(combination + [num])
    
    return all_combinations

def generate_combinations(nums, length):
    if length == 0:
        return [[]]
    
    if not nums:
        return []
    
    current_num = nums[0]
    remaining_nums = nums[1:]
    
    with_current = [[current_num] + combination for combination in generate_combinations(remaining_nums, length - 1)]
    without_current = generate_combinations(remaining_nums, length)
    
    return with_current + without_current

# Define the range of numbers and the length of combinations
numbers = [1, 2, 3, 4, 5]
combination_length = 3

# Generate all possible combinations
combinations = generate_combinations(numbers, combination_length)

# Print each combination
for combination in combinations:
    print(combination)

列出 1-5【依次】取 3 个【可重复】的各种可能性

def divide_and_conquer(nums, length):
    if length == 1:
        return [[num] for num in nums]
    
    smaller_combinations = divide_and_conquer(nums, length - 1)
    all_combinations = []
    
    for combination in smaller_combinations:
        for num in nums:
            all_combinations.append(combination + [num])
    
    return all_combinations

numbers = [1, 2, 3, 4, 5]
combination_length = 3
combinations = divide_and_conquer(numbers, combination_length)

for combination in combinations:
    print(combination)

列出 1-5【依次】取 3 个【不重复】的各种可能性

def divide_and_conquer(nums, length):
    if length == 1:
        return [[num] for num in nums]
    
    all_combinations = []
    for i in range(len(nums)):
        num = nums[i]
        remaining_nums = nums[i+1:]
        smaller_combinations = divide_and_conquer(remaining_nums, length - 1)
        for combination in smaller_combinations:
            all_combinations.append([num] + combination)
    
    return all_combinations

numbers = [1, 2, 3, 4, 5]
combination_length = 3
combinations = divide_and_conquer(numbers, combination_length)

for combination in combinations:
    print(combination)

Python 报错 ImportError: cannot import name 'loguniform' from 'sklearn.utils.fixes'

Sat, 02 Nov 2024 11:44:35 +0800

问题描述

Python 代码运行时出现报错 ImportError: cannot import name 'loguniform' from 'sklearn.utils.fixes'

解决方法

`1`	`from scipy.stats import loguniform`

机器学习 - 先验、后验和条件概率

Fri, 25 Oct 2024 19:58:20 +0800

先验概率 (Prior Probability)

先验概率表示在获得额外信息之前对事件发生的原始概率。它是基于以往经验或背景知识对事件的初步估计。例如，在进行一次医学诊断之前，患某种病的概率可以被认为是该疾病的先验概率。

用数学符号表示为：

$$ P(A) $$

这里，$P(A)$ 是事件 $A$ 发生的先验概率。

后验概率 (Posterior Probability)

后验概率是指在观察到某些数据或证据之后，更新了对事件的概率。它是在获得额外信息之后的概率，是通过贝叶斯定理计算得到的。

用数学符号表示为：

$$ P(A \mid B) $$

这里，$P(A \mid B)$ 是在观察到事件 $B$ 之后，事件 $A$ 的后验概率。

条件概率 (Conditional Probability)

条件概率是指在某些条件下（已知某些其他事件发生）某个事件发生的概率。它描述了在给定另一事件已发生的前提下，事件发生的可能性。

用数学符号表示为：

$$ P(A \mid B) = \frac{P(A \cap B)}{P(B)} $$

其中：

$P(A \mid B)$ 表示在 $B$ 发生的条件下，事件 $A$ 发生的概率。
$P(A \cap B)$ 表示事件 $A$ 和 $B$ 同时发生的概率。
$P(B)$ 表示事件 $B$ 发生的概率。

Python 示例代码

# 导入库
import numpy as np

# 共 100 个样本，每个样本 x 都包括 5 个特征
np.random.seed(0)
x = np.random.randn(100, 5)

# 共 100 个样本，每个样本 x 都属于 {0,1,2，...，9} 类别中的一个
np.random.seed(0)
y = np.random.randint(0, 10, 100)

# 初始化先验概率，P[i] 表示类别 i 出现的概率
P = np.zeros(10)  # 这里应该是 10，而不是 100

# 任务 1：计算每个标签的先验概率
for i in range(10):
    P[i] = np.sum(y == i) / len(y)


# 打印结果
for i in range(10):
    print("类别 i 出现的概率为：", P[i])

机器学习 - 贝叶斯公式与全概率公式

Fri, 25 Oct 2024 19:40:39 +0800

全概率公式

定义： 设 $A_1,A_2,⋯,A_n$ 为完备事件组，$P( A_ {i} )>0(i=1,2, \cdots ,n)$

$$ P(B)= \sum _ {i=1}^ {n} P( A_ {i} )P( B|A_ {i} ) $$

贝叶斯公式

请查看此文章

Python 示例代码

# 导入库
import numpy as np

# 共 10 个盒子，b[i][0] 表示盒子 i 中的苹果数量，b[i][1] 表示盒子 i 中的橙子数量
np.random.seed(0)
b = np.random.randint(0, 10, (10, 2))

# 共 10 个盒子，p[i] 表示盒子 i 被挑中的概率
p = np.array([0.1, 0.1, 0.05, 0.15, 0.08, 0.12, 0.09, 0.11, 0.06, 0.14])

# 初始化概率，P 表示挑出的水果是橙子的概率
P = 0

# 根据全概率公式，求挑出的水果是橙子的概率
for i in range(10):
    P += (b[i][1] / (b[i][0] + b[i][1])) * p[i]

# 打印结果
print("挑出的水果是橙子的概率为：", P)

# 已知挑出的水果是橙子，根据贝叶斯公式，求是从第一个盒子挑出的概率
P_1 = (b[0][1] / (b[0][0] + b[0][1])) * p[0] / P

# 打印结果
print("已知挑出的水果是橙子，是从第一个盒子挑出的概率为：", P_1)

机器学习 - 条件独立假设

Fri, 25 Oct 2024 19:35:08 +0800

# 导入库  
import numpy as np
# 共 100 个样本，每个样本 x 都包括 5 个特征  
np.random.seed(0)  
x = np.random.randint(0,2,(100, 5))
# 共 100 个样本，每个样本 x 都属于 {0,1} 类别中的一个  
np.random.seed(0)  
y = np.random.randint(0,2,100)
# 给定 xx = [0,1,0,1,1]  
xx = np.array([0,1,0,1,1])
# setx_0 表示属于第一个类别的 x 的集合  
setx_0 = x[np.where(y==0)]
# 初始化 p_0，p_0 表示 xx 属于类别 0 的概率  
p_0 = setx_0.shape[0] / 100

# 根据条件独立假设，求样本 xx 属于第一个类别的概率
for i in range(5):  
    p_0 = p_0 * np.sum(np.where(setx_0[:, i]==xx[i], 1, 0)) / setx_0.shape[0]  

# 打印结果  
print("样本 xx = [0,1,0,1,1] 属于类别 0 的概率为：", p_0)

机器学习 - 离散型朴素贝叶斯分类器

Fri, 25 Oct 2024 19:33:17 +0800

# 导入库
import numpy as np

# 共 100 个样本，每个样本 x 都包括 5 个特征
np.random.seed(0)
x = np.random.randint(0, 2, (100, 5))

# 共 100 个样本，每个样本 x 都属于 {0,1} 类别中的一个
np.random.seed(0)
y = np.random.randint(0, 2, 100)

# 给定 xx = [0,1,0,1,1]
xx = np.array([0, 1, 0, 1, 1])

setx = []
# setx[i] 表示属于类别 i 的 x 的集合
for i in range(2):
    setx.append(x[np.where(y == i)])

p = []
# 初始化 p，p[i] 表示 xx 属于类别 i 的概率
for i in range(2):
    p.append(setx[i].shape[0] / 100)

# 根据条件独立假设，求样本 xx 属于 i 类别的概率
for i in range(2):
    for j in range(5):
        # 计算特征 j 在类别 i 中的频率
        freq = np.sum(setx[i][:, j] == xx[j]) / setx[i].shape[0]
        # 更新类别 i 的概率
        p[i] *= freq

# 根据离散型朴素贝叶斯判定准则，求样本 xx 属于哪个类别的概率最大
label = np.argmax(p)

# 打印结果
print("样本 xx = [0,1,0,1,1] 属于类别", label)

机器学习 - 连续型朴素贝叶斯分类器

Fri, 25 Oct 2024 19:30:19 +0800

# 导入库
import numpy as np

# 共 100 个样本，每个样本 x 都包括 5 个特征
np.random.seed(0)
x = np.random.randn(100, 5)

# 共 100 个样本，每个样本 x 都属于 {0,1} 类别中的一个
np.random.seed(0)
y = np.random.randint(0, 2, 100)

# 给定 xx = [0,1,0,1,1]
xx = np.array([0, 1, 0, 1, 1])

setx = []
# setx[i] 表示属于类别 i 的 x 的集合
for i in range(2):
    setx.append(x[np.where(y == i)])

p = []
# 初始化 p，p[i] 表示 xx 属于类别 i 的概率
for i in range(2):
    p.append(setx[i].shape[0] / 100)

# 正态分布的概率密度函数
def normal(x, mean, std):
    return np.exp(-(x - mean) ** 2 / (2 * std ** 2)) / (np.sqrt(2 * np.pi) * std)

# 根据条件独立假设，求样本 xx 属于 i 类别的概率
for i in range(2):
    for j in range(5):
        mean = np.mean(setx[i][:, j])
        std = np.std(setx[i][:, j])
        p[i] *= normal(xx[j], mean, std)

# 根据连续型朴素贝叶斯判定准则，求样本 xx 属于哪个类别的概率最大
label = np.argmax(p)

# 打印结果
print("样本 xx = [0,1,0,1,1] 属于类别", label)

机器学习 - 朴素贝叶斯分类器

Fri, 25 Oct 2024 18:27:14 +0800

贝叶斯公式

定义： 承接全概率公式，若已知 B 发生了，执果索因，有

$$ P( A_ {j} |B)= \frac {P(A_ {j}B)}{P(B)} = \frac {P(A_ {j})P(B|A_ {j})}{P(A\cdot P(B)} $$

称为贝叶斯公式（贝叶斯定理）

朴素贝叶斯的类型

朴素贝叶斯算法适用于不同场景，分为以下几种常见类型：

高斯朴素贝叶斯：假设数据特征符合高斯分布，常用于处理连续数据。
多项式朴素贝叶斯：假设数据符合多项式分布，适用于文本分类等离散数据。
伯努利朴素贝叶斯：假设特征为二元变量（0 或 1），适合二元分类问题。

朴素贝叶斯的应用场景

朴素贝叶斯的计算速度快，尤其适用于以下场景：

文本分类：如垃圾邮件检测、情感分析、新闻分类等任务。
文档分类：适用于多类别文档的分类。
情感分析：可以分析评论或反馈中的情感倾向。

优缺点分析

优点

简单高效：由于假设特征独立性，计算量较小。
速度快：特别适合大规模数据。
适用性广：能处理离散或连续数据。

缺点

特征独立假设不总是成立：实际中特征往往存在相关性。
数据不足时表现不佳：在数据较少时分类效果可能较差。
零概率问题：如果某特征值在训练集中未出现，赋予其零概率可能导致分类错误。

Python 代码示例

以下是用 Python 和scikit-learn库实现的朴素贝叶斯分类示例：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score

# 加载数据集
data = load_iris()
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2, random_state=42)

# 初始化模型
model = GaussianNB()

# 训练模型
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"模型准确率：{accuracy:.2f}")

机器学习 - 基于 Logistic 回归和 Sigmoid 函数的分类

Tue, 22 Oct 2024 19:10:26 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

Logistic 回归

Logistic 回归属于机器学习中的监督学习，它是一种利用回归的思想来解决分类问题的经典二分类分类器。由于其训练后的参数具有较强的可解释性，Logistic 回归通常被用作基线模型（baseline model），便于后期更好地挖掘业务相关信息或提升模型性能。

逻辑回归的特点

优点：

计算代价不高，易于理解和实现。

缺点：

容易欠拟合，分类精度可能不高。

适用数据类型：数值型和标称型数据。

Sigmoid 函数

我们需要的函数应该能够接受所有的输入并预测出类别。在二分类情况下，该函数的输出应为 0 或 1。可能你之前接触过具有这种性质的函数，例如海维赛德阶跃函数（Heaviside step function），也被称为单位阶跃函数。然而，海维赛德阶跃函数的问题在于其在跳跃点上从 0 瞬间跳跃到 1，这种瞬间跳跃过程有时较难处理。

幸运的是，Sigmoid 函数具有类似的性质，并且在数学上更容易处理。Sigmoid 函数的具体公式如下：

$$ \sigma(x) = \frac{1}{1 + e^{-x}} $$

下图展示了 Sigmoid 函数在不同坐标尺度下的两条曲线。当 $x=0$ 时，Sigmoid 函数值为 0.5；随着 $x$ 的增大，Sigmoid 函数值逼近于 1；而随着 $x$ 的减小，Sigmoid 函数值逼近于 0。如果横坐标刻度足够大，Sigmoid 函数看起来很像一个阶跃函数。

因此，为了实现 Sigmoid 回归分类器，我们可以在每个特征上乘以一个回归系数，并将所有结果值相加。然后将这个总和代入 Sigmoid 函数中，得到一个范围在 0 到 1 之间的数值。任何大于 0.5 的数据被分类为 1 类，任何小于 0.5 的数据则被归为 0 类。这样，Logistic 回归也可以被看作一种概率估计方法。

Python 代码实现

使用前请注意修改 loadDataSet() 函数中的文件名

import numpy as np

'''
Parameters:
    无
Returns:
    dataMat - 数据列表
    labelMat - 标签列表
'''
# 函数说明：加载数据
def loadDataSet():
    dataMat = []                                                    #创建数据列表
    labelMat = []                                                   #创建标签列表
    fr = open('testSet.txt')                                        #打开文件
    for line in fr.readlines():                                     #逐行读取
        lineArr = line.strip().split()                              #去回车，放入列表
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])]) #添加数据
        labelMat.append(int(lineArr[2]))                            #添加标签
    fr.close()                                                      #关闭文件
    return dataMat, labelMat                                        #返回

'''
Parameters:
    inX - 数据
Returns:
    sigmoid 函数
'''
# 函数说明:sigmoid 函数
def sigmoid(inX):
    return 1.0 / (1 + np.exp(-inX))

'''
Parameters:
    dataMatIn - 数据集
    classLabels - 数据标签
Returns:
    weights - 权重数组
'''
# 函数说明：梯度上升算法
def gradAscent(dataMatIn, classLabels):
    dataMatrix = np.mat(dataMatIn)                                  #转换成 numpy 的 mat
    labelMat = np.mat(classLabels).transpose()                      #转换成 numpy 的 mat，并进行转置
    m, n = np.shape(dataMatrix)                                     #返回 dataMatrix 的大小。m 为行数，n 为列数。
    alpha = 0.001                                                   #移动步长，也就是学习速率，控制更新的幅度。
    maxCycles = 500                                                 #最大迭代次数
    weights = np.ones((n,1))                                        #初始化权重
    for k in range(maxCycles):                                      #进行迭代
        h = sigmoid(dataMatrix * weights)                           #计算预测出的概率值
        error = labelMat - h                                        #计算错误
        weights = weights + alpha * dataMatrix.transpose() * error  #更新权重
    return weights.getA()                                           #将矩阵转换为数组，返回权重数组

if __name__ == '__main__':
    dataMat, labelMat = loadDataSet()
    print(gradAscent(dataMat, labelMat))

机器学习 - softmax 回归原理

Tue, 22 Oct 2024 19:03:02 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

Softmax 回归原理

与逻辑回归一样，Softmax 回归也是一个分类算法，不过它用于多分类问题。我们的数据有多少个特征，就有多少个输入；有多少个类别，就有多少个输出。

如图所示，假设我们的数据有四个特征和三个类别。每个输入与输出之间都有一个权重相连接，且每个输出都有一个对应的偏置。具体公式如下：

$$ z_1 = x_1 w_{11} + x_2 w_{12} + x_3 w_{13} + x_4 w_{14} + b_1 $$$$ z_2 = x_1 w_{21} + x_2 w_{22} + x_3 w_{23} + x_4 w_{24} + b_2 $$$$ z_3 = x_1 w_{31} + x_2 w_{32} + x_3 w_{33} + x_4 w_{34} + b_3 $$

输出 $z_1$, $z_2$, $z_3$ 的值大小，代表了样本属于每个类别的可能性。比如，若 $z_1 = 1$, $z_2 = 10$, $z_3 = 100$，则表示该样本更有可能属于类别 $z_3$。

然而，直接将这些输出作为样本属于某个类别的可能性存在一些问题。举个例子，若你得到一个输出为 10，你可能觉得样本属于该类别的可能性很大，但若另外两个输出分别为 1000 和 2000，这时候该样本实际上不太可能属于输出为 10 的类别。因此，我们需要将输出统一到一个合理的范围内，比如 0 到 1 之间。这样，如果某个输出的值为 0.9，我们就可以非常确定它属于该类别。

Softmax 函数

Softmax 函数的公式如下：

$$ \hat y_ {i} = \frac {exp((z_ {i}))}{\sum _ {i=1}^ {l-1}exp(z_ {i})} $$

其中，$i$ 表示第 $i$ 个类别，$c$ 为总类别数。由公式可知：

$$ 0 \leq \hat{y}_i \leq 1 $$

且

$$ \sum_{i=1}^{c} \hat{y}_i = 1 $$

这样就可以将输出的值转换到 0 到 1 之间，并且总和为 1。每个类别对应的输出值可以被视为样本属于该类别的概率。

对于单个样本，假设一共有 0, 1, 2 三个类别，输出对应为 $[0.2, 0.3, 0.5]$，则最终判断该样本属于类别 2。

Python 代码实现

import numpy as np

def softmax(x):
    '''
    input:x(ndarray):输入数据，shape=(m,n)
    output:y(ndarray):经过 softmax 函数后的输出 shape=(m,n)
    '''
    y = np.zeros((x.shape[0],x.shape[1]))  
    for i in range(x.shape[0]):  
        y[i] = np.exp(x[i])/np.sum(np.exp(x[i]))   
    return y

机器学习 - softmax 回归训练流程

Tue, 22 Oct 2024 18:56:16 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

Softmax 回归模型

与逻辑回归一样，我们先对数据进行向量化：

$$ X = (x_0, x_1, \dots, x_n) $$

其中，$x_0$ 等于 1，且 $X$ 的形状为 $m$ 行 $n+1$ 列，$m$ 为样本个数，$n$ 为特征个数。

$$ W = (w_1, \dots, w_c) $$

$W$ 的形状为 $n+1$ 行 $c$ 列，$c$ 为总类别个数。

$$ Z = XW $$

$Z$ 的形状为 $m$ 行 $c$ 列。

$$ \hat{Y} = \text{softmax}(Z) $$

同样的，$\hat{Y}$ 的形状为 $m$ 行 $c$ 列。第 $i$ 行代表第 $i$ 个样本为每个类别的概率。

对于每个样本，我们将其判定为输出中最大值对应的类别。

Softmax 回归训练流程

Softmax 回归训练流程同逻辑回归一样，首先需要构造一个损失函数，再利用梯度下降方法最小化损失函数，从而达到更新参数的目的。具体流程如下：

Python 代码实现

import numpy as np
from sklearn.preprocessing import OneHotEncoder


def softmax(x):
    '''
    input:x(ndarray):输入数据
    output:y(ndarray):经过 softmax 函数后的输出
    '''
    exp_x = np.exp(x - np.max(x))  # 防止溢出
    y = exp_x / np.sum(exp_x, axis=1, keepdims=True)
    return y


def softmax_reg(train_data, train_label, test_data, lr, max_iter):
    '''
    input:train_data(ndarray):训练数据
          train_label(ndarray):训练标签
          test_data(ndarray):测试数据
          lr(float):梯度下降中的学习率参数
          max_iter(int):训练轮数
    output:predict(ndarray):预测结果
    '''
    # 将 x0 加入训练数据
    train_data = np.c_[np.ones((train_data.shape[0], 1)), train_data]
    
    # 转换为 onehot 标签
    encoder = OneHotEncoder(sparse=False)
    train_label_onehot = encoder.fit_transform(train_label.reshape(-1, 1))
    
    # 对 w 初始化
    num_features = train_data.shape[1]
    num_classes = train_label_onehot.shape[1]
    w = np.zeros((num_features, num_classes))
    
    # 利用梯度下降对模型进行训练
    for _ in range(max_iter):
        z = np.dot(train_data, w)
        y_pred = softmax(z)
        gradient = np.dot(train_data.T, (y_pred - train_label_onehot)) / train_data.shape[0]
        w -= lr * gradient
    
    # 将 x0 加入测试数据
    test_data = np.c_[np.ones((test_data.shape[0], 1)), test_data]
    
    # 进行预测
    z_test = np.dot(test_data, w)
    y_test_pred = softmax(z_test)
    predict = np.argmax(y_test_pred, axis=1)
    return predict

机器学习 - sklearn 中的 softmax 回归

Tue, 22 Oct 2024 18:49:45 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

LogisticRegression

LogisticRegression 中将参数 multi_class 设为 "multinomial" 则表示使用 softmax 回归方法。 LogisticRegression 的构造函数中有三个常用的参数可以设置：

solver：{'newton-cg' , 'lbfgs', 'sag', 'saga'}，分别为几种优化算法。
C：正则化系数的倒数，默认为 1.0，越小代表正则化越强。
max_iter：最大训练轮数，默认为 100。

和 sklearn 中其他分类器一样，LogisticRegression 类中的 fit 函数用于训练模型，fit 函数有两个向量输入：

X：大小为 [样本数量，特征数量] 的 ndarray，存放训练样本
Y：值为整型，大小为 [样本数量] 的 ndarray，存放训练样本的分类标签

LogisticRegression 类中的 predict 函数用于预测，返回预测标签，predict 函数有一个向量输入：

X：大小为 [样本数量，特征数量] 的 ndarray，存放预测样本

LogisticRegression 的使用代码如下：

`1`	`softmax_reg = LogisticRegression(multi_class="multinomial") softmax_reg.fit(X_train, Y_train) result = softmax_reg.predict(X_test)`

Python 代码实现

from sklearn.linear_model import LogisticRegression

def softmax_reg(train_data, train_label, test_data):
    '''
    input: train_data (ndarray): 训练数据
           train_label (ndarray): 训练标签
           test_data (ndarray): 测试数据
    output: predict (ndarray): 预测结果
    '''
    # 创建一个轻量级图模型并设置为 softmax 图
    model = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000)
    
    # 训练模型
    model.fit(train_data, train_label)
    
    # 进行测试数据的预测
    predict = model.predict(test_data)
    return predict

机器学习 - 使用逻辑回归实现分类

Tue, 22 Oct 2024 18:34:58 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

逻辑回归算法

一般来说逻辑回归用于处理二元分类问题，即

$$ y \subset \{0, 1\} $$

当样本中有多个类别时

$$ y \subset \{0, 1, 2, \dots, n\} $$

Logistic Regression 和 Linear Regression 的原理是相似的，可以简单地描述为以下过程：

找一个合适的预测函数，一般表示为 $h$ 函数，该函数就是我们需要找的分类函数，它用来预测输入数据的判断结果。这个过程非常关键，需要对数据有一定的了解或分析，知道或者猜测预测函数的“大概”形式，比如是线性函数还是非线性函数。
构造一个成本函数（损失函数），该函数表示预测的输出（$h$）与训练数据类别（$y$）之间的偏差，可以是二者之间的差（$h - y$）或者是其他的形式。综合考虑所有训练数据的“损失”，将成本求和或者求平均，记为 $J(\theta)$ 函数，表示所有训练数据预测值与实际类别的偏差。
显然，$J(\theta)$ 函数的值越小表示预测函数越准确（即 $h$ 函数越准确），所以这一步需要做的是找到 $J(\theta)$ 函数的最小值。找到函数的最小值有不同的方法，Logistic Regression 实现时通常使用的是梯度下降法（Gradient Descent）。

逻辑回归模型

预测函数

Logistic Regression 虽然名字里带“回归”，但实际上是一种分类方法，用于两分类问题（即输出只有两种）。根据上述步骤的说明，需要先找到一个预测函数（$h$），显然，该函数的输出必须是两个值（分别代表两个类别），所以利用了 Logistic 函数（或称为 Sigmoid 函数），函数形式为

$$ h(x) = \frac{1}{1 + e^{-\theta^T x}} $$

$h_\theta(x)$ 函数的值有特殊的含义，它表示结果取 1 的概率。因此对于输入 $x$，分类结果类别为 1 和类别 0 的概率分布为

$$ P(y = 1 | x; \theta) = h_\theta(x) $$$$ P(y = 0 | x; \theta) = 1 - h_\theta(x) $$

代价函数

$$ J(\theta) = -\frac{1}{m} \sum_{i=1}^{m} \left[ y^{(i)} \log(h(x^{(i)})) + (1 - y^{(i)}) \log(1 - h(x^{(i)})) \right] $$

这里的 $J(\theta)$ 是基于最大似然估计推导得到的。

$$ P(y | x; \theta) = (h_\theta(x))^y (1 - h_\theta(x))^{1 - y} $$

取似然函数为

$$ L(\theta) = \prod_{i=1}^{m} P(y^{(i)} | x^{(i)}; \theta) = \prod_{i=1}^{m} (h_\theta(x^{(i)}))^{y^{(i)}} (1 - h_\theta(x^{(i)}))^{1 - y^{(i)}} $$

对数似然函数为

$$ l(\theta) = \log L(\theta) = \sum_{i=1}^{m} \left[ y^{(i)} \log h_\theta(x^{(i)}) + (1 - y^{(i)}) \log(1 - h_\theta(x^{(i)})) \right] $$

最大似然估计就是要求使 $J(\theta)$ 取最大值时的 $\theta$，其实可以使用梯度上升法求解，求得的 $\theta$ 就是最佳参数。

$$ J(\theta) = -\frac{1}{m} l(\theta) $$

因为乘了一个负的系数 $\frac{1}{m}$，所以 $J(\theta)$ 取最小值时的 $\theta$ 为所求的最佳参数。

梯度下降

求 $J(\theta)$ 的最小值可以使用梯度下降法，根据梯度下降法可得 $\theta$ 的更新过程：

$$ \theta_j := \theta_j - \alpha \cdot \frac{1}{m} \sum_{i=1}^{m} (h(x) - y) x_j^{(i)} $$

其中 $\alpha$ 为学习率。

逻辑回归在形式上更新参数与线性回归相同，实则不同。在线性回归中，$h(x)$ 是一个线性函数，而在逻辑回归中，$h(x)$ 是一个 sigmoid 函数。

Python 代码实现

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegressionCV
import numpy as np
np.random.seed(10)

if __name__ == '__main__':
    # 使用 sklearn 中的 make_classification 函数构建二分类的数据，样本数量为 100，样本种类为 2
    X, y = make_classification(n_samples=100, n_classes=2, n_features=2, n_informative=2, n_redundant=0, random_state=10)
    
    # 将数据集拆分成测试集与训练集，训练集占所有数据的 80%
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=10)
    
    # 实例化一个逻辑回归分类器，使用默认参数
    model = LogisticRegressionCV(cv=5, random_state=10).fit(X_train, y_train)
    
    # 进行模型评估并打印准确率
    accuracy = model.score(X_test, y_test)
    print(f"{accuracy:.1f}")

机器学习 - 超参数

Tue, 22 Oct 2024 18:10:11 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

过拟合和欠拟合

欠拟合

对于给定的数据集，欠拟合的成因大多是模型不够复杂、拟合函数能力不够，为此，可以增加迭代次数继续训练、尝试更换其他算法、增加模型的参数数量和复杂程度，或者采用集成方法

过拟合

过拟合成因是给定的数据集相对过于简单，使得模型在拟合函数时过分的考虑了噪声等不必要的数据间的关联。或者说相对于给定数据集，模型过于复杂、拟合能力过强

解决方案：

提前停止训练

减少训练的迭代次数，理论上来说，可以找到一个训练程度，使得验证集误差率最低，视为拟合效果最好的点

正则化

L0 正则化
L1 正则化
L2 正则化

上述解决模型过拟合和欠拟合问题的方式中，涉及到一些超参数

在 sklearn 中，可以使用网格搜索的方式寻找最佳的参数

Python 代码实现

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.datasets import load_iris

def model_train(x_train, x_test, y_train, y_test):
    # 设置 param 进行网格搜索参数设置
    # {参数名 1：[参数值 1，参数值 2]，...}
    param_dict = {
        'penalty': ['l1', 'l2'],
        'C': [0.1, 1, 10],
        'solver': ['liblinear']  # 选择 liblinear 以支持 L1 正则化
    }

    # 参数说明：
    # logistic 逻辑回归分类器
    logistic = LogisticRegression()

    # 使用网格搜索进行模型训练找出最佳参数
    grid_search = GridSearchCV(logistic, param_dict, cv=5)
    grid_search.fit(x_train, y_train)

    # 使用最佳参数的模型进行测试集评分
    best_model = grid_search.best_estimator_
    score = best_model.score(x_test, y_test)

    return score

机器学习 - 逻辑回归简述

Tue, 22 Oct 2024 16:30:34 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

什么是逻辑回归

当看到“回归”这两个字时，可能会误以为逻辑回归是一种解决回归问题的算法。然而，逻辑回归实际上是一种通过回归的思想来解决二分类问题的算法。

逻辑回归如何解决分类问题

逻辑回归通过将样本特征与样本所属类别的概率联系起来。假设已经训练好一个逻辑回归模型为 $f(x)$，则模型的输出表示样本 $x$ 的标签为 1 的概率，即

$$ \hat{p} = f(x) $$

根据此概率，可以推断：当 $\hat{p} > 0.5$ 时，$x$ 属于标签 1；否则，属于标签 0。因此，可以表示为：

$$ \hat{y} = \begin{cases} 1, & \hat{p} > 0.5 \\ 0, & \hat{p} \leq 0.5 \end{cases} $$

其中，$\hat{y}$ 是样本 $x$ 根据模型预测出的标签结果。标签 0 和标签 1 的具体含义可以根据实际业务需求来决定，例如在癌细胞识别中，0 代表良性肿瘤，1 代表恶性肿瘤。

由于概率是 0 到 1 的实数值，逻辑回归可以看作是一种回归算法，如果仅计算样本所属标签的概率；如果需要对样本进行分类，则逻辑回归是一种二分类算法。

逻辑回归中的概率计算

逻辑回归的概率计算与线性回归相关。在线性回归中，通过训练一组参数 $W^T$ 和 $b$ 来拟合样本数据，线性回归的输出为：

$$ \hat{y} = W^T x + b $$

但此时 $\hat{y}$ 的值域为 $(-\infty, +\infty)$，如果能将值域从 $(-\infty, +\infty)$ 转换为 $(0, 1)$ 的概率值，就可以解决分类问题。为此，逻辑回归将线性回归的输出作为输入，传递给另一个可以将实数转换为概率值的函数——Sigmoid 函数。则转换后的概率为：

$$ \hat{p} = \sigma(W^T x + b) $$

这里的 $\sigma$ 就是 Sigmoid 函数。

Sigmoid 函数

Sigmoid 函数的公式为：

$$ \sigma(t) = \frac{1}{1 + e^{-t}} $$

其图像如下：

从 Sigmoid 函数的图像可以看出，当 $t$ 趋近于 $-\infty$ 时，函数值趋近于 0；当 $t$ 趋近于 $+\infty$ 时，函数值趋近于 1。因此，Sigmoid 函数的值域是 $(0, 1)$，符合我们将 $(-\infty, +\infty)$ 的实数转换为 $(0, 1)$ 概率值的需求。

因此，逻辑回归在预测时可以表示为：

$$ \hat{p} = \frac{1}{1 + e^{-(W^T x + b)}} $$

Python 代码实现

import numpy as np

def sigmoid(t):
    '''
    :param t: 负无穷到正无穷的实数
    :return: 转换后的概率值
    '''
    return 1 / (1 + np.exp(-t))

阿里 druid 数据库连接池报红

Tue, 22 Oct 2024 14:49:05 +0800

问题描述

SpringBoot 项目中，阿里 druid 数据库连接池 com.alibaba.druid.pool.DruidDataSource 报红

解决方法

在 pom.xml 中添加依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.23</version>
</dependency>

可用版本详见：Maven 仓库

Linux - 命令行快捷键

Mon, 21 Oct 2024 23:52:54 +0800

概述

就像学 Photoshop 一定要记住快捷键一样，作为一名合格的 basher，一定也要学会使用命令行快捷键，让效率事半功倍；涉及在 linux 命令行下进行快速移动光标、命令编辑、编辑后执行历史命令、控制命令等。

来源：https://www.jianshu.com/p/de98af781829

常用键盘快捷键

Ctrl+ 左右键 : 在单词之间跳转
Ctrl+a : 跳到本行的行首
Ctrl+e : 跳到页尾
Ctrl+u : 删除当前光标前面的文字（还有剪切功能）
Ctrl+k : 删除当前光标后面的文字 (还有剪切功能)
Ctrl+L : 进行清屏操作
Ctrl+y : 粘贴 Ctrl+u 或 ctrl+k 剪切的内容
Ctrl+w : 删除光标前面的单词的字符（以空格隔开的字符串）
Alt – d : 由光标位置开始，往右删除单词，往行尾删
Ctrl+r : 搜索执行过的命令
! + 最近执行过的命令中的某个字符：可快速执行最近执行过的命令
fs -l : 显示部分历史命令

使用说明

Ctrl - k : 先按住 Ctrl 键，然后再按 k 键；
Alt - k : 先按住 Alt 键，然后再按 k 键；
M – k : 先单击 Esc 键，然后再按 k 键。

移动光标

Ctrl - a : 移到行首
Ctrl - e : 移到行尾
Ctrl - b : 往回 (左) 移动一个字符
Ctrl - f : 往后 (右) 移动一个字符
M - b : 往回 (左) 移动一个单词（先单击 Esc 键，再按 b 键）
M - f : 往后 (右) 移动一个单词（先单击 Esc 键，再按 f 键）

编辑命令

Ctrl – h : 删除光标左方位置的字符
Ctrl – d : 删除光标右方位置的字符（注意：当前命令行没有任何字符时，会注销系统或结束终端）
Ctrl – w : 由光标位置开始，往左删除单词。往行首删
Alt – d : 由光标位置开始，往右删除单词。往行尾删
M – d : 由光标位置开始，删除单词，直到该单词结束。
Ctrl – k : 由光标所在位置开始，删除右方所有的字符，直到该行结束。
Ctrl – u : 由光标所在位置开始，删除左方所有的字符，直到该行开始。
Ctrl – y : 粘贴之前删除的内容到光标后。
ctrl – t : 交换光标处和之前两个字符的位置。
Alt + . : 使用上一条命令的最后一个参数。
Ctrl – _ : 回复之前的状态。撤销操作。

查找历史命令

Ctrl – p : 显示当前命令的上一条历史命令
Ctrl – n : 显示当前命令的下一条历史命令
Ctrl – r : 搜索历史命令，随着输入会显示历史命令中的一条匹配命令，Enter 键执行匹配命令；ESC 键在命令行显示而不执行匹配命令。
Ctrl – g : 从历史搜索模式（Ctrl – r）退出。

控制命令

Ctrl – l : 清除屏幕，然后，在最上面重新显示目前光标所在的这一行的内容。
Ctrl – o : 执行当前命令，并选择上一条命令。
Ctrl – s : 阻止屏幕输出
Ctrl – q : 允许屏幕输出
Ctrl – c : 终止命令
Ctrl – z : 挂起命令

重复执行操作动作

M – 操作次数操作动作 : 指定操作次数，重复执行指定的操作。

计算机操作系统 - 链接

Mon, 21 Oct 2024 17:38:11 +0800

来源：https://cyc2018.xyz/

编译系统

以下是一个 hello.c 程序：

#include <stdio.h>

int main()
{
    printf("hello, world\n");
    return 0;
}

在 Unix 系统上，由编译器把源文件转换为目标文件。

`1`	`gcc -o hello hello.c`

这个过程大致如下：

预处理阶段：处理以 # 开头的预处理命令；
编译阶段：翻译成汇编文件；
汇编阶段：将汇编文件翻译成可重定位目标文件；
链接阶段：将可重定位目标文件和 printf.o 等单独预编译好的目标文件进行合并，得到最终的可执行目标文件。

静态链接

静态链接器以一组可重定位目标文件为输入，生成一个完全链接的可执行目标文件作为输出。链接器主要完成以下两个任务：

符号解析：每个符号对应于一个函数、一个全局变量或一个静态变量，符号解析的目的是将每个符号引用与一个符号定义关联起来。
重定位：链接器通过把每个符号定义与一个内存位置关联起来，然后修改所有对这些符号的引用，使得它们指向这个内存位置。

目标文件

可执行目标文件：可以直接在内存中执行；
可重定位目标文件：可与其它可重定位目标文件在链接阶段合并，创建一个可执行目标文件；
共享目标文件：这是一种特殊的可重定位目标文件，可以在运行时被动态加载进内存并链接；

动态链接

静态库有以下两个问题：

当静态库更新时那么整个程序都要重新进行链接；
对于 printf 这种标准函数库，如果每个程序都要有代码，这会极大浪费资源。

共享库是为了解决静态库的这两个问题而设计的，在 Linux 系统中通常用 .so 后缀来表示，Windows 系统上它们被称为 DLL。它具有以下特点：

在给定的文件系统中一个库只有一个文件，所有引用该库的可执行目标文件都共享这个文件，它不会被复制到引用它的可执行文件中；
在内存中，一个共享库的 .text 节（已编译程序的机器代码）的一个副本可以被不同的正在运行的进程共享。

计算机操作系统 - 设备管理

Mon, 21 Oct 2024 17:28:05 +0800

来源：https://cyc2018.xyz/

磁盘结构

盘面（Platter）：一个磁盘有多个盘面；
磁道（Track）：盘面上的圆形带状区域，一个盘面可以有多个磁道；
扇区（Track Sector）：磁道上的一个弧段，一个磁道可以有多个扇区，它是最小的物理储存单位，目前主要有 512 bytes 与 4 K 两种大小；
磁头（Head）：与盘面非常接近，能够将盘面上的磁场转换为电信号（读），或者将电信号转换为盘面的磁场（写）；
制动手臂（Actuator arm）：用于在磁道之间移动磁头；
主轴（Spindle）：使整个盘面转动。

磁盘调度算法

读写一个磁盘块的时间的影响因素有：

旋转时间（主轴转动盘面，使得磁头移动到适当的扇区上）
寻道时间（制动手臂移动，使得磁头移动到适当的磁道上）
实际的数据传输时间

其中，寻道时间最长，因此磁盘调度的主要目标是使磁盘的平均寻道时间最短。

1. 先来先服务

FCFS, First Come First Served

按照磁盘请求的顺序进行调度。

优点是公平和简单。缺点也很明显，因为未对寻道做任何优化，使平均寻道时间可能较长。

2. 最短寻道时间优先

SSTF, Shortest Seek Time First

优先调度与当前磁头所在磁道距离最近的磁道。

虽然平均寻道时间比较低，但是不够公平。如果新到达的磁道请求总是比一个在等待的磁道请求近，那么在等待的磁道请求会一直等待下去，也就是出现饥饿现象。具体来说，两端的磁道请求更容易出现饥饿现象。

3. 电梯算法

SCAN

电梯总是保持一个方向运行，直到该方向没有请求为止，然后改变运行方向。

电梯算法（扫描算法）和电梯的运行过程类似，总是按一个方向来进行磁盘调度，直到该方向上没有未完成的磁盘请求，然后改变方向。

因为考虑了移动方向，因此所有的磁盘请求都会被满足，解决了 SSTF 的饥饿问题。

计算机操作系统 - 内存管理

Mon, 21 Oct 2024 17:25:20 +0800

来源：https://cyc2018.xyz/

虚拟内存

虚拟内存的目的是为了让物理内存扩充成更大的逻辑内存，从而让程序获得更多的可用内存。

为了更好的管理内存，操作系统将内存抽象成地址空间。每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。当程序引用到不在物理内存中的页时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。

从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。

分页系统地址映射

内存管理单元（MMU）管理着地址空间和物理内存的转换，其中的页表（Page table）存储着页（程序地址空间）和页框（物理内存空间）的映射表。

一个虚拟地址分成两个部分，一部分存储页面号，一部分存储偏移量。

下图的页表存放着 16 个页，这 16 个页需要用 4 个比特位来进行索引定位。例如对于虚拟地址（0010 000000000100），前 4 位是存储页面号 2，读取表项内容为（110 1），页表项最后一位表示是否存在于内存中，1 表示存在。后 12 位存储偏移量。这个页对应的页框的地址为（110 000000000100）。

页面置换算法

在程序运行过程中，如果要访问的页面不在内存中，就发生缺页中断从而将该页调入内存中。此时如果内存已无空闲空间，系统必须从内存中调出一个页面到磁盘对换区中来腾出空间。

页面置换算法和缓存淘汰策略类似，可以将内存看成磁盘的缓存。在缓存系统中，缓存的大小有限，当有新的缓存到达时，需要淘汰一部分已经存在的缓存，这样才有空间存放新的缓存数据。

页面置换算法的主要目标是使页面置换频率最低（也可以说缺页率最低）。

1. 最佳

OPT, Optimal replacement algorithm

所选择的被换出的页面将是最长时间内不再被访问，通常可以保证获得最低的缺页率。

是一种理论上的算法，因为无法知道一个页面多长时间不再被访问。

举例：一个系统为某进程分配了三个物理块，并有如下页面引用序列：

`1`	`7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1`

开始运行时，先将 7, 0, 1 三个页面装入内存。当进程要访问页面 2 时，产生缺页中断，会将页面 7 换出，因为页面 7 再次被访问的时间最长。

2. 最近最久未使用

LRU, Least Recently Used

虽然无法知道将来要使用的页面情况，但是可以知道过去使用页面的情况。LRU 将最近最久未使用的页面换出。

为了实现 LRU，需要在内存中维护一个所有页面的链表。当一个页面被访问时，将这个页面移到链表表头。这样就能保证链表表尾的页面是最近最久未访问的。

因为每次访问都需要更新链表，因此这种方式实现的 LRU 代价很高。

`1`	`4，7，0，7，1，0，1，2，1，2，6`

3. 最近未使用

NRU, Not Recently Used

每个页面都有两个状态位：R 与 M，当页面被访问时设置页面的 R=1，当页面被修改时设置 M=1。其中 R 位会定时被清零。可以将页面分成以下四类：

R=0，M=0
R=0，M=1
R=1，M=0
R=1，M=1

当发生缺页中断时，NRU 算法随机地从类编号最小的非空类中挑选一个页面将它换出。

NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。

4. 先进先出

FIFO, First In First Out

选择换出的页面是最先进入的页面。

该算法会将那些经常被访问的页面换出，导致缺页率升高。

5. 第二次机会算法

FIFO 算法可能会把经常使用的页面置换出去，为了避免这一问题，对该算法做一个简单的修改：

当页面被访问 (读或写) 时设置该页面的 R 位为 1。需要替换的时候，检查最老页面的 R 位。如果 R 位是 0，那么这个页面既老又没有被使用，可以立刻置换掉；如果是 1，就将 R 位清 0，并把该页面放到链表的尾端，修改它的装入时间使它就像刚装入的一样，然后继续从链表的头部开始搜索。

6. 时钟

Clock

第二次机会算法需要在链表中移动页面，降低了效率。时钟算法使用环形链表将页面连接起来，再使用一个指针指向最老的页面。

分段

虚拟内存采用的是分页技术，也就是将地址空间划分成固定大小的页，每一页再与内存进行映射。

下图为一个编译器在编译过程中建立的多个表，有 4 个表是动态增长的，如果使用分页系统的一维地址空间，动态增长的特点会导致覆盖问题的出现。

分段的做法是把每个表分成段，一个段构成一个独立的地址空间。每个段的长度可以不同，并且可以动态增长。

段页式

程序的地址空间划分成多个拥有独立地址空间的段，每个段上的地址空间划分成大小相同的页。这样既拥有分段系统的共享和保护，又拥有分页系统的虚拟内存功能。

分页与分段的比较

对程序员的透明性：分页透明，但是分段需要程序员显式划分每个段。
地址空间的维度：分页是一维地址空间，分段是二维的。
大小是否可以改变：页的大小不可变，段的大小可以动态改变。
出现的原因：分页主要用于实现虚拟内存，从而获得更大的地址空间；分段主要是为了使程序和数据可以被划分为逻辑上独立的地址空间并且有助于共享和保护。

计算机操作系统 - 死锁

Mon, 21 Oct 2024 17:10:29 +0800

来源：https://cyc2018.xyz/

有删改

必要条件

互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
占有和等待：已经得到了某个资源的进程可以再请求新的资源。
不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。

处理方法

主要有以下四种方法：

鸵鸟策略
死锁检测与死锁恢复
死锁预防
死锁避免

鸵鸟策略

把头埋在沙子里，假装根本没发生问题。

因为解决死锁问题的代价很高，因此鸵鸟策略这种不采取任务措施的方案会获得更高的性能。

当发生死锁时不会对用户造成多大影响，或发生死锁的概率很低，可以采用鸵鸟策略。

大多数操作系统，包括 Unix，Linux 和 Windows，处理死锁问题的办法仅仅是忽略它。

死锁检测与死锁恢复

不试图阻止死锁，而是当检测到死锁发生时，采取措施进行恢复。

每种类型一个资源的死锁检测

上图为资源分配图，其中方框表示资源，圆圈表示进程。资源指向进程表示该资源已经分配给该进程，进程指向资源表示进程请求获取该资源。

图 a 可以抽取出环，如图 b，它满足了环路等待条件，因此会发生死锁。

每种类型一个资源的死锁检测算法是通过检测有向图是否存在环来实现，从一个节点出发进行深度优先搜索，对访问过的节点进行标记，如果访问了已经标记的节点，就表示有向图存在环，也就是检测到死锁的发生。

每种类型多个资源的死锁检测

上图中，有三个进程四个资源，每个数据代表的含义如下：

E 向量：资源总量
A 向量：资源剩余量
C 矩阵：每个进程所拥有的资源数量，每一行都代表一个进程拥有资源的数量
R 矩阵：每个进程请求的资源数量

进程 P₁ 和 P₂ 所请求的资源都得不到满足，只有进程 P₃ 可以，让 P₃ 执行，之后释放 P₃ 拥有的资源，此时 A = (2 2 2 0)。P₂ 可以执行，执行后释放 P₂ 拥有的资源，A = (4 2 2 1) 。P₁ 也可以执行。所有进程都可以顺利执行，没有死锁。

算法总结如下：

每个进程最开始时都不被标记，执行过程有可能被标记。当算法结束时，任何没有被标记的进程都是死锁进程。

寻找一个没有标记的进程 P_i，它所请求的资源小于等于 A。
如果找到了这样一个进程，那么将 C 矩阵的第 i 行向量加到 A 中，标记该进程，并转回 1。
如果没有这样一个进程，算法终止。

3. 死锁恢复

利用抢占恢复
利用回滚恢复
通过杀死进程恢复

死锁预防

在程序运行之前预防发生死锁。

破坏互斥条件

例如假脱机打印机技术允许若干个进程同时输出，唯一真正请求物理打印机的进程是打印机守护进程。

破坏占有和等待条件

一种实现方式是规定所有进程在开始执行前请求所需要的全部资源。

破坏不可抢占条件

破坏环路等待

给资源统一编号，进程只能按编号顺序来请求资源。

死锁避免

在程序运行时避免发生死锁。

安全状态

图 a 的第二列 Has 表示已拥有的资源数，第三列 Max 表示总共需要的资源数，Free 表示还有可以使用的资源数。从图 a 开始出发，先让 B 拥有所需的所有资源（图 b），运行结束后释放 B，此时 Free 变为 5（图 c）；接着以同样的方式运行 C 和 A，使得所有进程都能成功运行，因此可以称图 a 所示的状态时安全的。

定义：如果没有死锁发生，并且即使所有进程突然请求对资源的最大需求，也仍然存在某种调度次序能够使得每一个进程运行完毕，则称该状态是安全的。

安全状态的检测与死锁的检测类似，因为安全状态必须要求不能发生死锁。下面的银行家算法与死锁检测算法非常类似，可以结合着做参考对比。

单个资源的银行家算法

一个小城镇的银行家，他向一群客户分别承诺了一定的贷款额度，算法要做的是判断对请求的满足是否会进入不安全状态，如果是，就拒绝请求；否则予以分配。

上图 c 为不安全状态，因此算法会拒绝之前的请求，从而避免进入图 c 中的状态。

多个资源的银行家算法

上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。

检查一个状态是否安全的算法如下：

查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
重复以上两步，直到所有进程都标记为终止，则状态时安全的。

如果一个状态不是安全的，需要拒绝进入这个状态。

计算机操作系统 - 进程管理

Mon, 21 Oct 2024 16:44:50 +0800

来源：https://cyc2018.xyz/

有删改

进程与线程

进程

进程是资源分配的基本单位。

进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。

下图显示了 4 个程序创建了 4 个进程，这 4 个进程可以并发地执行。

线程

线程是独立调度的基本单位。

一个进程中可以有多个线程，它们共享进程资源。

QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 HTTP 请求线程、事件响应线程、渲染线程等等，线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时，浏览器还可以响应用户的其它事件。

区别

Ⅰ 拥有资源

进程是资源分配的基本单位，但是线程不拥有资源，线程可以访问隶属进程的资源。

Ⅱ 调度

线程是独立调度的基本单位，在同一进程中，线程的切换不会引起进程切换，从一个进程中的线程切换到另一个进程中的线程时，会引起进程切换。

Ⅲ 系统开销

由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。

Ⅳ 通信方面

线程间可以通过直接读写同一进程中的数据进行通信，但是进程通信需要借助 IPC。

进程状态的切换

就绪状态（ready）：等待被调度
运行状态（running）
阻塞状态（waiting）：等待资源

应该注意以下内容：

只有就绪态和运行态可以相互转换，其它的都是单向转换。就绪状态的进程通过调度算法从而获得 CPU 时间，转为运行状态；而运行状态的进程，在分配给它的 CPU 时间片用完之后就会转为就绪状态，等待下一次调度。
阻塞状态是缺少需要的资源从而由运行状态转换而来，但是该资源不包括 CPU 时间，缺少 CPU 时间会从运行态转换为就绪态。

进程调度算法

不同环境的调度算法目标不同，因此需要针对不同环境来讨论调度算法。

批处理系统

批处理系统没有太多的用户操作，在该系统中，调度算法目标是保证吞吐量和周转时间（从提交到终止的时间）。

先来先服务 first-come first-serverd（FCFS）

非抢占式的调度算法，按照请求的顺序进行调度

有利于长作业，但不利于短作业，因为短作业必须一直等待前面的长作业执行完毕才能执行，而长作业又需要执行很长时间，造成了短作业等待时间过长。

短作业优先 shortest job first（SJF）

非抢占式的调度算法，按估计运行时间最短的顺序进行调度。

长作业有可能会饿死，处于一直等待短作业执行完毕的状态。因为如果一直有短作业到来，那么长作业永远得不到调度。

最短剩余时间优先 shortest remaining time next（SRTN）

最短作业优先的抢占式版本，按剩余运行时间的顺序进行调度。当一个新的作业到达时，其整个运行时间与当前进程的剩余时间作比较。如果新的进程需要的时间更少，则挂起当前进程，运行新的进程。否则新的进程等待。

交互式系统

交互式系统有大量的用户交互操作，在该系统中调度算法的目标是快速地进行响应。

时间片轮转

将所有就绪进程按 FCFS 的原则排成一个队列，每次调度时，把 CPU 时间分配给队首进程，该进程可以执行一个时间片。当时间片用完时，由计时器发出时钟中断，调度程序便停止该进程的执行，并将它送往就绪队列的末尾，同时继续把 CPU 时间分配给队首的进程。

时间片轮转算法的效率和时间片的大小有很大关系：

因为进程切换都要保存进程的信息并且载入新进程的信息，如果时间片太小，会导致进程切换得太频繁，在进程切换上就会花过多时间。
而如果时间片过长，那么实时性就不能得到保证。

优先级调度

为每个进程分配一个优先级，按优先级进行调度。

为了防止低优先级的进程永远等不到调度，可以随着时间的推移增加等待进程的优先级。

多级反馈队列

一个进程需要执行 100 个时间片，如果采用时间片轮转调度算法，那么需要交换 100 次。

多级队列是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列时间片大小都不同，例如 1,2,4,8,..。进程在第一个队列没执行完，就会被移到下一个队列。这种方式下，之前的进程只需要交换 7 次。

每个队列优先权也不同，最上面的优先权最高。因此只有上一个队列没有进程在排队，才能调度当前队列上的进程。

可以将这种调度算法看成是时间片轮转调度算法和优先级调度算法的结合。

实时系统

实时系统要求一个请求在一个确定时间内得到响应。

分为硬实时和软实时，前者必须满足绝对的截止时间，后者可以容忍一定的超时。

进程同步

临界区

对临界资源进行访问的那段代码称为临界区。

为了互斥访问临界资源，每个进程在进入临界区之前，需要先进行检查。

1
2
3

// entry section
// critical section;
// exit section

同步与互斥

同步：多个进程因为合作产生的直接制约关系，使得进程有一定的先后执行关系。
互斥：多个进程在同一时刻只有一个进程能进入临界区。

信号量

信号量（Semaphore）是一个整型变量，可以对其执行 down 和 up 操作，也就是常见的 P 和 V 操作。

down : 如果信号量大于 0，执行 -1 操作；如果信号量等于 0，进程睡眠，等待信号量大于 0；
up ：对信号量执行 +1 操作，唤醒睡眠的进程让其完成 down 操作。

down 和 up 操作需要被设计成原语，不可分割，通常的做法是在执行这些操作的时候屏蔽中断。

如果信号量的取值只能为 0 或者 1，那么就成为了 互斥量（Mutex） ，0 表示临界区已经加锁，1 表示临界区解锁。

typedef int semaphore;
semaphore mutex = 1;
void P1() {
    down(&mutex);
    // 临界区
    up(&mutex);
}

void P2() {
    down(&mutex);
    // 临界区
    up(&mutex);
}

使用信号量实现生产者 - 消费者问题

问题描述：使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。

因为缓冲区属于临界资源，因此需要使用一个互斥量 mutex 来控制对缓冲区的互斥访问。

为了同步生产者和消费者的行为，需要记录缓冲区中物品的数量。数量可以使用信号量来进行统计，这里需要使用两个信号量：empty 记录空缓冲区的数量，full 记录满缓冲区的数量。其中，empty 信号量是在生产者进程中使用，当 empty 不为 0 时，生产者才可以放入物品；full 信号量是在消费者进程中使用，当 full 信号量不为 0 时，消费者才可以取走物品。

注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty = 0，此时生产者睡眠。消费者不能进入临界区，因为生产者对缓冲区加锁了，消费者就无法执行 up(empty) 操作，empty 永远都为 0，导致生产者永远等待下，不会释放锁，消费者因此也会永远等待下去。

#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;

void producer() {
    while(TRUE) {
        int item = produce_item();
        down(&empty);
        down(&mutex);
        insert_item(item);
        up(&mutex);
        up(&full);
    }
}

void consumer() {
    while(TRUE) {
        down(&full);
        down(&mutex);
        int item = remove_item();
        consume_item(item);
        up(&mutex);
        up(&empty);
    }
}

管程

使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制，而管程把控制的代码独立出来，不仅不容易出错，也使得客户端代码调用更容易。

c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者 - 消费者问题。

monitor ProducerConsumer
    integer i;
    condition c;

    procedure insert();
    begin
        // ...
    end;

    procedure remove();
    begin
        // ...
    end;
end monitor;

管程有一个重要特性：在一个时刻只能有一个进程使用管程。进程在无法继续执行的时候不能一直占用管程，否则其它进程永远不能使用管程。

管程引入了 条件变量 以及相关的操作：wait() 和 signal() 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。

使用管程实现生产者 - 消费者问题

// 管程
monitor ProducerConsumer
    condition full, empty;
    integer count := 0;
    condition c;

    procedure insert(item: integer);
    begin
        if count = N then wait(full);
        insert_item(item);
        count := count + 1;
        if count = 1 then signal(empty);
    end;

    function remove: integer;
    begin
        if count = 0 then wait(empty);
        remove = remove_item;
        count := count - 1;
        if count = N -1 then signal(full);
    end;
end monitor;

// 生产者客户端
procedure producer
begin
    while true do
    begin
        item = produce_item;
        ProducerConsumer.insert(item);
    end
end;

// 消费者客户端
procedure consumer
begin
    while true do
    begin
        item = ProducerConsumer.remove;
        consume_item(item);
    end
end;

经典同步问题

生产者和消费者问题前面已经讨论过了。

哲学家进餐问题

五个哲学家围着一张圆桌，每个哲学家面前放着食物。哲学家的生活有两种交替活动：吃饭以及思考。当一个哲学家吃饭时，需要先拿起自己左右两边的两根筷子，并且一次只能拿起一根筷子。

下面是一种错误的解法，如果所有哲学家同时拿起左手边的筷子，那么所有哲学家都在等待其它哲学家吃完并释放自己手中的筷子，导致死锁。

#define N 5

void philosopher(int i) {
    while(TRUE) {
        think();
        take(i);       // 拿起左边的筷子
        take((i+1)%N); // 拿起右边的筷子
        eat();
        put(i);
        put((i+1)%N);
    }
}

为了防止死锁的发生，可以设置两个条件：

必须同时拿起左右两根筷子；
只有在两个邻居都没有进餐的情况下才允许进餐。

#define N 5
#define LEFT (i + N - 1) % N // 左邻居
#define RIGHT (i + 1) % N    // 右邻居
#define THINKING 0
#define HUNGRY   1
#define EATING   2
typedef int semaphore;
int state[N];                // 跟踪每个哲学家的状态
semaphore mutex = 1;         // 临界区的互斥，临界区是 state 数组，对其修改需要互斥
semaphore s[N];              // 每个哲学家一个信号量

void philosopher(int i) {
    while(TRUE) {
        think(i);
        take_two(i);
        eat(i);
        put_two(i);
    }
}

void take_two(int i) {
    down(&mutex);
    state[i] = HUNGRY;
    check(i);
    up(&mutex);
    down(&s[i]); // 只有收到通知之后才可以开始吃，否则会一直等下去
}

void put_two(i) {
    down(&mutex);
    state[i] = THINKING;
    check(LEFT); // 尝试通知左右邻居，自己吃完了，你们可以开始吃了
    check(RIGHT);
    up(&mutex);
}

void eat(int i) {
    down(&mutex);
    state[i] = EATING;
    up(&mutex);
}

// 检查两个邻居是否都没有用餐，如果是的话，就 up(&s[i])，使得 down(&s[i]) 能够得到通知并继续执行
void check(i) {         
    if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
        state[i] = EATING;
        up(&s[i]);
    }
}

读者 - 写者问题

允许多个进程同时对数据进行读操作，但是不允许读和写以及写和写操作同时发生。

一个整型变量 count 记录在对数据进行读操作的进程数量，一个互斥量 count_mutex 用于对 count 加锁，一个互斥量 data_mutex 用于对读写的数据加锁。

typedef int semaphore;
semaphore count_mutex = 1;
semaphore data_mutex = 1;
int count = 0;

void reader() {
    while(TRUE) {
        down(&count_mutex);
        count++;
        if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问
        up(&count_mutex);
        read();
        down(&count_mutex);
        count--;
        if(count == 0) up(&data_mutex);
        up(&count_mutex);
    }
}

void writer() {
    while(TRUE) {
        down(&data_mutex);
        write();
        up(&data_mutex);
    }
}

以下内容由 @Bandi Yugandhar 提供。

The first case may result Writer to starve. This case favous Writers i.e no writer, once added to the queue, shall be kept waiting longer than absolutely necessary(only when there are readers that entered the queue before the writer).

int readcount, writecount;                   //(initial value = 0)
semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)

//READER
void reader() {
<ENTRY Section>
 down(&readLock);                 //  reader is trying to enter
 down(&rmutex);                  //   lock to increase readcount
  readcount++;                 
  if (readcount == 1)          
   down(&resource);              //if you are the first reader then lock  the resource
 up(&rmutex);                  //release  for other readers
 up(&readLock);                 //Done with trying to access the resource

<CRITICAL Section>
//reading is performed

<EXIT Section>
 down(&rmutex);                  //reserve exit section - avoids race condition with readers
 readcount--;                       //indicate you're leaving
  if (readcount == 0)          //checks if you are last reader leaving
   up(&resource);              //if last, you must release the locked resource
 up(&rmutex);                  //release exit section for other readers
}

//WRITER
void writer() {
  <ENTRY Section>
  down(&wmutex);                  //reserve entry section for writers - avoids race conditions
  writecount++;                //report yourself as a writer entering
  if (writecount == 1)         //checks if you're first writer
   down(&readLock);               //if you're first, then you must lock the readers out. Prevent them from trying to enter CS
  up(&wmutex);                  //release entry section

<CRITICAL Section>
 down(&resource);                //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource
  //writing is performed
 up(&resource);                //release file

<EXIT Section>
  down(&wmutex);                  //reserve exit section
  writecount--;                //indicate you're leaving
  if (writecount == 0)         //checks if you're the last writer
   up(&readLock);               //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading
  up(&wmutex);                  //release exit section
}

We can observe that every reader is forced to acquire ReadLock. On the otherhand, writers doesn’t need to lock individually. Once the first writer locks the ReadLock, it will be released only when there is no writer left in the queue.

From the both cases we observed that either reader or writer has to starve. Below solutionadds the constraint that no thread shall be allowed to starve; that is, the operation of obtaining a lock on the shared data will always terminate in a bounded amount of time.

int readCount;                  // init to 0; number of readers currently accessing resource

// all semaphores initialised to 1
Semaphore resourceAccess;       // controls access (read/write) to the resource
Semaphore readCountAccess;      // for syncing changes to shared variable readCount
Semaphore serviceQueue;         // FAIRNESS: preserves ordering of requests (signaling must be FIFO)

void writer()
{ 
    down(&serviceQueue);           // wait in line to be servicexs
    // <ENTER>
    down(&resourceAccess);         // request exclusive access to resource
    // </ENTER>
    up(&serviceQueue);           // let next in line be serviced

    // <WRITE>
    writeResource();            // writing is performed
    // </WRITE>

    // <EXIT>
    up(&resourceAccess);         // release resource access for next reader/writer
    // </EXIT>
}

void reader()
{ 
    down(&serviceQueue);           // wait in line to be serviced
    down(&readCountAccess);        // request exclusive access to readCount
    // <ENTER>
    if (readCount == 0)         // if there are no readers already reading:
        down(&resourceAccess);     // request resource access for readers (writers blocked)
    readCount++;                // update count of active readers
    // </ENTER>
    up(&serviceQueue);           // let next in line be serviced
    up(&readCountAccess);        // release access to readCount

    // <READ>
    readResource();             // reading is performed
    // </READ>

    down(&readCountAccess);        // request exclusive access to readCount
    // <EXIT>
    readCount--;                // update count of active readers
    if (readCount == 0)         // if there are no readers left:
        up(&resourceAccess);     // release resource access for all
    // </EXIT>
    up(&readCountAccess);        // release access to readCount
}

进程通信

进程同步与进程通信很容易混淆，它们的区别在于：

进程同步：控制多个进程按一定顺序执行；
进程通信：进程间传输信息。

进程通信是一种手段，而进程同步是一种目的。也可以说，为了能够达到进程同步的目的，需要让进程进行通信，传输一些进程同步所需要的信息。

管道

管道是通过调用 pipe 函数创建的，fd[0] 用于读，fd[1] 用于写。

1
2

#include <unistd.h>
int pipe(int fd[2]);

它具有以下限制：

只支持半双工通信（单向交替传输）；
只能在父子进程或者兄弟进程中使用。

FIFO

也称为命名管道，去除了管道只能在父子进程中使用的限制。

1
2
3

#include <sys/stat.h>
int mkfifo(const char *path, mode_t mode);
int mkfifoat(int fd, const char *path, mode_t mode);

FIFO 常用于客户 - 服务器应用程序中，FIFO 用作汇聚点，在客户进程和服务器进程之间传递数据。

消息队列

相比于 FIFO，消息队列具有以下优点：

消息队列可以独立于读写进程存在，从而避免了 FIFO 中同步管道的打开和关闭时可能产生的困难；
避免了 FIFO 的同步阻塞问题，不需要进程自己提供同步方法；
读进程可以根据消息类型有选择地接收消息，而不像 FIFO 那样只能默认地接收。

信号量

它是一个计数器，用于为多个进程提供对共享数据对象的访问。

共享存储

允许多个进程共享一个给定的存储区。因为数据不需要在进程之间复制，所以这是最快的一种 IPC。

需要使用信号量用来同步对共享存储的访问。

多个进程可以将同一个文件映射到它们的地址空间从而实现共享内存。另外 XSI 共享内存不是使用文件，而是使用内存的匿名段。

套接字

与其它通信机制不同的是，它可用于不同机器间的进程通信。

计算机操作系统 - 概述

Mon, 21 Oct 2024 16:33:29 +0800

来源：https://cyc2018.xyz/

基本特征

1. 并发

并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。

并行需要硬件支持，如多流水线、多核处理器或者分布式计算系统。

操作系统通过引入进程和线程，使得程序能够并发运行。

2. 共享

共享是指系统中的资源可以被多个并发进程共同使用。

有两种共享方式：互斥共享和同时共享。

互斥共享的资源称为临界资源，例如打印机等，在同一时刻只允许一个进程访问，需要用同步机制来实现互斥访问。

3. 虚拟

虚拟技术把一个物理实体转换为多个逻辑实体。

主要有两种虚拟技术：时（时间）分复用技术和空（空间）分复用技术。

多个进程能在同一个处理器上并发执行使用了时分复用技术，让每个进程轮流占用处理器，每次只执行一小个时间片并快速切换。

虚拟内存使用了空分复用技术，它将物理内存抽象为地址空间，每个进程都有各自的地址空间。地址空间的页被映射到物理内存，地址空间的页并不需要全部在物理内存中，当使用到一个没有在物理内存的页时，执行页面置换算法，将该页置换到内存中。

4. 异步

异步指进程不是一次性执行完毕，而是走走停停，以不可知的速度向前推进。

基本功能

1. 进程管理

进程控制、进程同步、进程通信、死锁处理、处理机调度等。

2. 内存管理

内存分配、地址映射、内存保护与共享、虚拟内存等。

3. 文件管理

文件存储空间的管理、目录管理、文件读写管理和保护等。

4. 设备管理

完成用户的 I/O 请求，方便用户使用各种设备，并提高设备的利用率。

主要包括缓冲管理、设备分配、设备处理、虛拟设备等。

系统调用

如果一个进程在用户态需要使用内核态的功能，就进行系统调用从而陷入内核，由操作系统代为完成。

Linux 的系统调用主要有以下这些：

Task	Commands
进程控制	fork(); exit(); wait();
进程通信	pipe(); shmget(); mmap();
文件操作	open(); read(); write();
设备操作	ioctl(); read(); write();
信息维护	getpid(); alarm(); sleep();
安全	chmod(); umask(); chown();

宏内核和微内核

1. 宏内核

宏内核是将操作系统功能作为一个紧密结合的整体放到内核。

由于各模块共享信息，因此有很高的性能。

2. 微内核

由于操作系统不断复杂，因此将一部分操作系统功能移出内核，从而降低内核的复杂性。移出的部分根据分层的原则划分成若干服务，相互独立。

在微内核结构下，操作系统被划分成小的、定义良好的模块，只有微内核这一个模块运行在内核态，其余模块运行在用户态。

因为需要频繁地在用户态和核心态之间进行切换，所以会有一定的性能损失。

中断分类

1. 外中断

由 CPU 执行指令以外的事件引起，如 I/O 完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。

2. 异常

由 CPU 执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。

3. 陷入

在用户程序中使用系统调用。

Cloudreve-AfdianPay

Mon, 21 Oct 2024 14:12:23 +0800

概述

https://github.com/essesoul/Cloudreve-AfdianPay

本项目是基于爱发电接口的 Cloudreve 自定义付款渠道

使用方法

爱发电账号

使用爱发电接口

需要先注册爱发电账户
在开发人员页面获取user_id
在开发人员页面底部获取API Token

手动部署

下载 src 文件夹，运行 pip install -r requirements.txt 安装依赖包

修改 .env 文件中的内容

SITE_URL="你的网站 url，不带斜杠，例如 https://demo.cloudreve.org"
USER_ID="你的爱发电 user_id"
TOKEN="你的爱发电 api token"
PORT="5000"# 监听端口，默认 5000

例如

SITE_URL="https://demo.cloudreve.org"
USER_ID="abcxxxxxxx123"
TOKEN="aAABBB123xxxxzzz"
PORT="5000"

运行 cloudreve_pay.py 文件即可

默认监听 5000 端口，可以自行修改 .env 文件的 PORT 参数

`1`	`PORT="5000"# 监听端口，默认 5000`

docker-compose 部署

version: '3'

services:
  cloudreve-pay-afd:
    image: xxdl/cloudreve-pay-afd:latest
    container_name: cloudreve-pay-afd
    network_mode: host
    command: ["python","-u", "cloudreve_pay.py"]
    environment:
      - SITE_URL=https://demo.cloudreve.org
      - USER_ID=abcxxxxxxx123
      - TOKEN=aAABBB123xxxxzzz
      - PORT=5000

配置

在爱发电开发者页面设置Webhook URL http://example.com:5000/afdian 将 example.com 更换为你的域名或 IP，点击保存

如果没有报错则说明成功

在 Cloudreve 管理后台 - 参数设置 - 增值服务 - 自定义付款渠道中填写付款方式名称、支付接口地址、通信密钥

接口地址为： http://example.com:5000/order/create 将 example.com 更换为你的域名或 IP，点击保存

通信密钥可以随意填写，暂时还没加入签名验证

URI 和 URL 的概念和区别

Fri, 18 Oct 2024 21:20:48 +0800

前言

在写 Java EE 中的注解时，提到了 URI，本文将介绍 URL 和 URI 的概念与区别。

摘要

通过下图可以知道 URI（Uniform Resource Identifier 统一资源标识符）其实包括 URL（Uniform Resource Locator 统一资源定位符）和 URN（Uniform Resource Name 统一资源名称），可以说 URI 同时具备 locator 和 name 特性的一个东西。URN 作用就好像一个人的名字，URL 就像一个人的地址。

换句话说：URN 确定了东西的身份，URL 提供了找到它的方式。

URI：统一资源标识符

URI（Uniform Resource Identifier）翻译成中文就是统一资源标识符。RFC2396 分别对这 3 个单词进行了如下定义：

Uniform：规定统一的格式可方便处理多种不同类型的资源，而不用根据上下文环境来识别资源指定的访问方式。另外，加入新增的 协议方案（如 http:或 ftp:）也更容易。
Resource：资源的定义是“可标识的任何东西”。除了文档文件、图像或服务（例如当天的天气预报）等能够区别于其他类型的，全都可作为资源。另外，资源不仅可以是单一的，也可以是多数的集合体。
Identifier：表示可标识的对象。也称为标识符。

协议方案是指访问资源所使用的协议类型名称。采用 HTTP 协议时，协议方案就是 http。除此之外，还有 ftp、mailto、telnet、file 等。标准的 URI 协议方案有 30 种左右，由隶属于国际互联网资源管理的非营利社团 ICANN（Internet Corporation for Assigned Names and Numbers，互联网名称与数字地址分配机构）的 IANA（Internet Assigned Numbers Authority，互联网号码分配局）管理颁布。

URI 是一个用来标识抽象或物理资源的紧凑字符串，通过这个标识可以访问一个唯一的资源。

这里的“资源”表示的是 web 上每一种可用的资源，如 HTML 文档、图像、视频片段、程序等，它们可以都由唯一的一个 URI 字符串进行标识，具体的标识规则由我们自己确定。放到现实中，资源可以类比一个独一无二的人、动物、物体，而 URI 类似于身份证或者 DNA（反正是要独一无二的，它可以使任何规则）。

URL：统一资源定位符

URL（Universal Resource Locator），即生活中熟知的统一资源定位符。

URL 一个通过位置来标识资源的字符串，是目前网络资源的主要访问机制的。

一个标准的 URL 必须包括：protocol、host、port、path、parameter、anchor，例如 https://www.essesoul.top/index.xml，这样通过该资源的位置可以以定位该资源。

可以看出来，URL 是通过位置来确定一个资源的，因此 URL 是 URI 的子集，或者说 URL 是 URI 的一种实现方式。

参考

正则表达式

Fri, 18 Oct 2024 21:10:54 +0800

一、概述

正则表达式用于文本内容的查找和替换。

正则表达式内置于其它语言或者软件产品中，它本身不是一种语言或者软件。

正则表达式在线工具

二、匹配单个字符

. 可以用来匹配任何的单个字符，但是在绝大多数实现里面，不能匹配换行符；

. 是元字符，表示它有特殊的含义，而不是字符本身的含义。如果需要匹配 . ，那么要用 \ 进行转义，即在 . 前面加上 \ 。

正则表达式一般是区分大小写的，但也有些实现不区分。

正则表达式

b.og

匹配结果

This is my blog.

三、匹配一组字符

[ ] 定义一个字符集合；

0-9、a-z 定义了一个字符区间，区间使用 ASCII 码来确定，字符区间在 [ ] 中使用。

- 只有在 [ ] 之间才是元字符，在 [ ] 之外就是一个普通字符；

^ 在 [ ] 中是取非操作。

应用

匹配以 abc 为开头，并且最后一个字母不为数字的字符串：

正则表达式

`1`	`abc[^0-9]`

匹配结果

abcd
abc1
abc2

四、使用元字符

匹配空白字符

元字符	说明
[\b]	回退（删除）一个字符
\f	换页符
\n	换行符
\r	回车符
\t	制表符
\v	垂直制表符

\r\n 是 Windows 中的文本行结束标签，在 Unix/Linux 则是 \n。

\r\n\r\n 可以匹配 Windows 下的空白行，因为它匹配两个连续的行尾标签，而这正是两条记录之间的空白行；

匹配特定的字符

1. 数字元字符

元字符	说明
\d	数字字符，等价于 [0-9]
\D	非数字字符，等价于 [^0-9]

2. 字母数字元字符

元字符	说明
\w	大小写字母，下划线和数字，等价于 [a-zA-Z0-9_]
\W	对 \w 取非

3. 空白字符元字符

元字符	说明
\s	任何一个空白字符，等价于 [\f\n\r\t\v]
\S	对 \s 取非

\x 匹配十六进制字符，\0 匹配八进制，例如 \xA 对应值为 10 的 ASCII 字符，即 \n。

五、重复匹配

+ 匹配 1 个或者多个字符
* 匹配 0 个或者多个字符
? 匹配 0 个或者 1 个字符

应用

匹配邮箱地址。

正则表达式

`1`	`[\w.]+@\w+\.\w+`

[\w.] 匹配的是字母数字或者 . ，在其后面加上 + ，表示匹配多次。在字符集合 [ ] 里，. 不是元字符；

匹配结果

abc.def<span>@</span>qq.com

{n} 匹配 n 个字符
{m,n} 匹配 m~n 个字符
{m,} 至少匹配 m 个字符

* 和 + 都是贪婪型元字符，会匹配尽可能多的内容。在后面加 ? 可以转换为懒惰型元字符，例如 *?、+? 和 {m,n}? 。

正则表达式

a.+c

匹配结果

abcabcabc

由于 + 是贪婪型的，因此 .+ 会匹配更可能多的内容，所以会把整个 abcabcabc 文本都匹配，而不是只匹配前面的 abc 文本。用懒惰型可以实现匹配前面的。

六、位置匹配

单词边界

\b 可以匹配一个单词的边界，边界是指位于 \w 和 \W 之间的位置；\B 匹配一个不是单词边界的位置。

\b 只匹配位置，不匹配字符，因此 \babc\b 匹配出来的结果为 3 个字符。

字符串边界

^ 匹配整个字符串的开头，$ 匹配结尾。

^ 元字符在字符集合中用作求非，在字符集合外用作匹配字符串的开头。

分行匹配模式（multiline）下，换行被当做字符串的边界。

应用

匹配代码中以 // 开始的注释行

正则表达式

`1`	`^\s\/\/.$`

匹配结果

public void fun() {
// 注释 1
int a = 1;
int b = 2;
// 注释 2
int c = a + b;
}

七、使用子表达式

使用 ( ) 定义一个子表达式。子表达式的内容可以当成一个独立元素，即可以将它看成一个字符，并且使用 * 等元字符。

子表达式可以嵌套，但是嵌套层次过深会变得很难理解。

正则表达式

`1`	`(ab){2,}`

匹配结果

ababab

| 是或元字符，它把左边和右边所有的部分都看成单独的两个部分，两个部分只要有一个匹配就行。

正则表达式

`1`	`(19\|20)\d{2}`

匹配结果

1900
2010
1020

应用

匹配 IP 地址。

IP 地址中每部分都是 0-255 的数字，用正则表达式匹配时以下情况是合法的：

一位数字
不以 0 开头的两位数字
1 开头的三位数
2 开头，第 2 位是 0-4 的三位数
25 开头，第 3 位是 0-5 的三位数

正则表达式

`1`	`((25[0-5]\|(2[0-4]\d)\|(1\d{2})\|([1-9]\d)\|(\d))\.){3}(25[0-5]\|(2[0-4]\d)\|(1\d{2})\|([1-9]\d)\|(\d))`

匹配结果

192.168.0.1
00.00.00.00
555.555.555.555

八、回溯引用

回溯引用使用 \n 来引用某个子表达式，其中 n 代表的是子表达式的序号，从 1 开始。它和子表达式匹配的内容一致，比如子表达式匹配到 abc，那么回溯引用部分也需要匹配 abc。

应用

匹配 HTML 中合法的标题元素。

正则表达式

\1 将回溯引用子表达式 (h[1-6]) 匹配的内容，也就是说必须和子表达式匹配的内容一致。

`1`	`<(h[1-6])>\w*?<\/\1>`

匹配结果

<h1>x</h1>
<h2>x</h2>
<h3>x</h1>

替换

需要用到两个正则表达式。

应用

修改电话号码格式。

文本

313-555-1234

查找正则表达式

`1`	`(\d{3})(-)(\d{3})(-)(\d{4})`

替换正则表达式

在第一个子表达式查找的结果加上 () ，然后加一个空格，在第三个和第五个字表达式查找的结果中间加上 - 进行分隔。

`1`	`($1) $3-$5`

结果

(313) 555-1234

大小写转换

元字符	说明
\l	把下个字符转换为小写
\u	把下个字符转换为大写
\L	把\L 和\E 之间的字符全部转换为小写
\U	把\U 和\E 之间的字符全部转换为大写
\E	结束\L 或者\U

应用

把文本的第二个和第三个字符转换为大写。

文本

abcd

查找

`1`	`(\w)(\w{2})(\w)`

替换

`1`	`$1\U$2\E$3`

结果

aBCd

九、前后查找

前后查找规定了匹配的内容首尾应该匹配的内容，但是又不包含首尾匹配的内容。

向前查找使用 ?= 定义，它规定了尾部匹配的内容，这个匹配的内容在 ?= 之后定义。所谓向前查找，就是规定了一个匹配的内容，然后以这个内容为尾部向前面查找需要匹配的内容。向后匹配用 ?\<= 定义（注：JavaScript 不支持向后匹配，Java 对其支持也不完善）。

应用

查找出邮件地址 @ 字符前面的部分。

正则表达式

`1`	`\w+(?=@)`

结果

abc @qq.com

对向前和向后查找取非，只要把 = 替换成 ! 即可，比如 (?=) 替换成 (?!) 。取非操作使得匹配那些首尾不符合要求的内容。

十、嵌入条件

回溯引用条件

条件为某个子表达式是否匹配，如果匹配则需要继续匹配条件表达式后面的内容。

正则表达式

子表达式 (\() 匹配一个左括号，其后的 ? 表示匹配 0 个或者 1 个。 ?(1) 为条件，当子表达式 1 匹配时条件成立，需要执行 ) 匹配，也就是匹配右括号。

`1`	`($)?abc(?(1)$)`

结果

(abc)
abc
(abc

前后查找条件

条件为定义的首尾是否匹配，如果匹配，则继续执行后面的匹配。注意，首尾不包含在匹配的内容中。

正则表达式

?(?=-) 为前向查找条件，只有在以 - 为前向查找的结尾能匹配 \d{5} ，才继续匹配 -\d{4} 。

`1`	`\d{5}(?(?=-)-\d{4})`

结果

11111
22222-
33333-4444

参考资料

CS-Notes - 正则表达式

版本号规范 - 语义化版本

Fri, 18 Oct 2024 20:47:39 +0800

什么是语义化版本？

语义化版本的英文是：Semantic Versioning。

它是由 Gravatars 创办者兼 GitHub 共同创办者 Tom Preston-Werner 所建立的一个有关如何命名软件和库（包）版本的规范，用以解决在大型项目中对依赖的版本失去控制的问题（例如你可能因为害怕不兼容而不敢去更新依赖）。

现在 Semantic Versioning 已经在开源社区中得到了广泛的认同，Node.js 的包管理工具 npm 也完全基于 Semantic Versioning 来管理依赖的版本。

而 SemVer 是语义化版本的一个具体实现，目前是由 npm 的团队维护的，实现了版本和版本范围的解析、计算、比较。

语义化版本 2.0.0

摘要

版本格式：主版本号。次版本号。修订号，版本号递增规则如下：

主版本号：当你做了不兼容的 API 修改，
次版本号：当你做了向下兼容的功能性新增，
修订号：当你做了向下兼容的问题修正。

先行版本号及版本编译信息可以加到“主版本号。次版本号。修订号”的后面，作为延伸。

语义化版本控制规范（SemVer）

以下关键词 MUST、MUST NOT、REQUIRED、SHALL、SHALL NOT、SHOULD、SHOULD NOT、RECOMMENDED、MAY、OPTIONAL 依照 RFC 2119 的叙述解读。

使用语义化版本控制的软件必须（MUST）定义公共 API。该 API 可以在代码中被定义或出现于严谨的文档内。无论何种形式都应该力求精确且完整。
标准的版本号必须（MUST）采用 X.Y.Z 的格式，其中 X、Y 和 Z 为非负的整数，且禁止（MUST NOT）在数字前方补零。X 是主版本号、Y 是次版本号、而 Z 为修订号。每个元素必须（MUST）以数值来递增。例如：1.9.1 -> 1.10.0 -> 1.11.0。
标记版本号的软件发行后，禁止（MUST NOT）改变该版本软件的内容。任何修改都必须（MUST）以新版本发行。
主版本号为零（0.y.z）的软件处于开发初始阶段，一切都可能随时被改变。这样的公共 API 不应该被视为稳定版。
1.0.0 的版本号用于界定公共 API 的形成。这一版本之后所有的版本号更新都基于公共 API 及其修改内容。
修订号 Z（x.y.Z | x > 0）必须（MUST）在只做了向下兼容的修正时才递增。这里的修正指的是针对不正确结果而进行的内部修改。
次版本号 Y（x.Y.z | x > 0）必须（MUST）在有向下兼容的新功能出现时递增。在任何公共 API 的功能被标记为弃用时也必须（MUST）递增。也可以（MAY）在内部程序有大量新功能或改进被加入时递增，其中可以（MAY）包括修订级别的改变。每当次版本号递增时，修订号必须（MUST）归零。
主版本号 X（X.y.z | X > 0）必须（MUST）在有任何不兼容的修改被加入公共 API 时递增。其中可以（MAY）包括次版本号及修订级别的改变。每当主版本号递增时，次版本号和修订号必须（MUST）归零。
先行版本号可以（MAY）被标注在修订版之后，先加上一个连接号再加上一连串以句点分隔的标识符来修饰。标识符必须（MUST）由 ASCII 字母数字和连接号 [0-9A-Za-z-] 组成，且禁止（MUST NOT）留白。数字型的标识符禁止（MUST NOT）在前方补零。先行版的优先级低于相关联的标准版本。被标上先行版本号则表示这个版本并非稳定而且可能无法满足预期的兼容性需求。范例：1.0.0-alpha、1.0.0-alpha.1、1.0.0-0.3.7、1.0.0-x.7.z.92。
版本编译信息可以（MAY）被标注在修订版或先行版本号之后，先加上一个加号再加上一连串以句点分隔的标识符来修饰。标识符必须（MUST）由 ASCII 字母数字和连接号 [0-9A-Za-z-] 组成，且禁止（MUST NOT）留白。当判断版本的优先层级时，版本编译信息可（SHOULD）被忽略。因此当两个版本只有在版本编译信息有差别时，属于相同的优先层级。范例：1.0.0-alpha+001、1.0.0+20130313144700、1.0.0-beta+exp.sha.5114f85。
版本的优先层级指的是不同版本在排序时如何比较。
1. 判断优先层级时，必须（MUST）把版本依序拆分为主版本号、次版本号、修订号及先行版本号后进行比较（版本编译信息不在这份比较的列表中）。
2. 由左到右依序比较每个标识符，第一个差异值用来决定优先层级：主版本号、次版本号及修订号以数值比较。
  
  例如：1.0.0 < 2.0.0 < 2.1.0 < 2.1.1。
3. 当主版本号、次版本号及修订号都相同时，改以优先层级比较低的先行版本号决定。
  
  例如：1.0.0-alpha < 1.0.0。
4. 有相同主版本号、次版本号及修订号的两个先行版本号，其优先层级必须（MUST）透过由左到右的每个被句点分隔的标识符来比较，直到找到一个差异值后决定：
  1. 只有数字的标识符以数值高低比较。
  2. 有字母或连接号时则逐字以 ASCII 的排序来比较。
  3. 数字的标识符比非数字的标识符优先层级低。
  4. 若开头的标识符都相同时，栏位比较多的先行版本号优先层级比较高。
  例如：1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta < 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0。

合法语义化版本的巴科斯范式语法

<valid semver> ::= <version core>
                 | <version core> "-" <pre-release>
                 | <version core> "+" <build>
                 | <version core> "-" <pre-release> "+" <build>

<version core> ::= <major> "." <minor> "." <patch>

<major> ::= <numeric identifier>

<minor> ::= <numeric identifier>

<patch> ::= <numeric identifier>

<pre-release> ::= <dot-separated pre-release identifiers>

<dot-separated pre-release identifiers> ::= <pre-release identifier>
                                          | <pre-release identifier> "." <dot-separated pre-release identifiers>

<build> ::= <dot-separated build identifiers>

<dot-separated build identifiers> ::= <build identifier>
                                    | <build identifier> "." <dot-separated build identifiers>

<pre-release identifier> ::= <alphanumeric identifier>
                           | <numeric identifier>

<build identifier> ::= <alphanumeric identifier>
                     | <digits>

<alphanumeric identifier> ::= <non-digit>
                            | <non-digit> <identifier characters>
                            | <identifier characters> <non-digit>
                            | <identifier characters> <non-digit> <identifier characters>

<numeric identifier> ::= "0"
                       | <positive digit>
                       | <positive digit> <digits>

<identifier characters> ::= <identifier character>
                          | <identifier character> <identifier characters>

<identifier character> ::= <digit>
                         | <non-digit>

<non-digit> ::= <letter>
              | "-"

<digits> ::= <digit>
           | <digit> <digits>

<digit> ::= "0"
          | <positive digit>

<positive digit> ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

<letter> ::= "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J"
           | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T"
           | "U" | "V" | "W" | "X" | "Y" | "Z" | "a" | "b" | "c" | "d"
           | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n"
           | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x"
           | "y" | "z"

为什么要使用语义化的版本控制？

这并不是一个新的或者革命性的想法。实际上，你可能已经在做一些近似的事情了。问题在于只是“近似”还不够。如果没有某个正式的规范可循，版本号对于依赖的管理并无实质意义。将上述的想法命名并给予清楚的定义，让你对软件使用者传达意向变得容易。一旦这些意向变得清楚，弹性（但又不会太弹性）的依赖规范就能达成。

举个简单的例子就可以展示语义化的版本控制如何让依赖地狱成为过去。假设有个名为“救火车”的函数库，它需要另一个名为“梯子”并已经有使用语义化版本控制的包。当救火车创建时，梯子的版本号为 3.1.0。因为救火车使用了一些版本 3.1.0 所新增的功能，你可以放心地指定依赖于梯子的版本号大于等于 3.1.0 但小于 4.0.0。这样，当梯子版本 3.1.1 和 3.2.0 发布时，你可以将直接它们纳入你的包管理系统，因为它们能与原有依赖的软件兼容。

作为一位负责任的开发者，你理当确保每次包升级的运作与版本号的表述一致。现实世界是复杂的，我们除了提高警觉外能做的不多。你所能做的就是让语义化的版本控制为你提供一个健全的方式来发行以及升级包，而无需推出新的依赖包，节省你的时间及烦恼。

如果你对此认同，希望立即开始使用语义化版本控制，你只需声明你的函数库正在使用它并遵循这些规则就可以了。请在你的 README 文件中保留此页链接，让别人也知道这些规则并从中受益。

FAQ

在 0.y.z 初始开发阶段，我该如何进行版本控制？

最简单的做法是以 0.1.0 作为你的初始化开发版本，并在后续的每次发行时递增次版本号。

如何判断发布 1.0.0 版本的时机？

当你的软件被用于正式环境，它应该已经达到了 1.0.0 版。如果你已经有个稳定的 API 被使用者依赖，也会是 1.0.0 版。如果你很担心向下兼容的问题，也应该算是 1.0.0 版了。

这不会阻碍快速开发和迭代吗？

主版本号为零的时候就是为了做快速开发。如果你每天都在改变 API，那么你应该仍在主版本号为零的阶段（0.y.z），或是正在下个主版本的独立开发分支中。

对于公共 API，若即使是最小但不向下兼容的改变都需要产生新的主版本号，岂不是很快就达到 42.0.0 版？

这是开发的责任感和前瞻性的问题。不兼容的改变不应该轻易被加入到有许多依赖代码的软件中。升级所付出的代价可能是巨大的。要递增主版本号来发行不兼容的改版，意味着你必须为这些改变所带来的影响深思熟虑，并且评估所涉及的成本及效益比。

为整个公共 API 写文档太费事了！

为供他人使用的软件编写适当的文档，是你作为一名专业开发者应尽的职责。保持项目高效的一个非常重要的部分是掌控软件的复杂度，如果没有人知道如何使用你的软件或不知道哪些函数的调用是可靠的，要掌控复杂度会是困难的。长远来看，使用语义化版本控制以及对于公共 API 有良好规范的坚持，可以让每个人及每件事都运行顺畅。

万一不小心把一个不兼容的改版当成了次版本号发行了该怎么办？

一旦发现自己破坏了语义化版本控制的规范，就要修正这个问题，并发行一个新的次版本号来更正这个问题并且恢复向下兼容。即使是这种情况，也不能去修改已发行的版本。可以的话，将有问题的版本号记录到文档中，告诉使用者问题所在，让他们能够意识到这是有问题的版本。

如果我更新了自己的依赖但没有改变公共 API 该怎么办？

由于没有影响到公共 API，这可以被认定是兼容的。若某个软件和你的包有共同依赖，则它会有自己的依赖规范，作者也会告知可能的冲突。要判断改版是属于修订等级或是次版等级，是依据你更新的依赖关系是为了修复问题或是加入新功能。对于后者，我经常会预期伴随着更多的代码，这显然会是一个次版本号级别的递增。

如果我变更了公共 API 但无意中未遵循版本号的改动怎么办呢？（意即在修订等级的发布中，误将重大且不兼容的改变加到代码之中）

自行做最佳的判断。如果你有庞大的使用者群在依照公共 API 的意图而变更行为后会大受影响，那么最好做一次主版本的发布，即使严格来说这个修复仅是修订等级的发布。记住，语义化的版本控制就是透过版本号的改变来传达意义。若这些改变对你的使用者是重要的，那就透过版本号来向他们说明。

我该如何处理即将弃用的功能？

弃用现存的功能是软件开发中的家常便饭，也通常是向前发展所必须的。当你弃用部分公共 API 时，你应该做两件事：（1）更新你的文档让使用者知道这个改变，（2）在适当的时机将弃用的功能透过新的次版本号发布。在新的主版本完全移除弃用功能前，至少要有一个次版本包含这个弃用信息，这样使用者才能平顺地转移到新版 API。

语义化版本对于版本的字符串长度是否有限制呢？

没有，请自行做适当的判断。举例来说，长到 255 个字符的版本已过度夸张。再者，特定的系统对于字符串长度可能会有他们自己的限制。

“v1.2.3”是一个语义化版本号吗？

“v1.2.3”并不是一个语义化的版本号。但是，在语义化版本号之前增加前缀“v”是用来表示版本号的常用做法。在版本控制系统中，将“version”缩写为“v”是很常见的。比如：git tag v1.2.3 -m "Release version 1.2.3" 中，“v1.2.3”表示标签名称，而“1.2.3”是语义化版本号。

是否有推荐的正则表达式用以检查语义化版本号的正确性？

有两个推荐的正则表达式。第一个用于支持按组名称提取的语言（PCRE[Perl 兼容正则表达式，比如 Perl、PHP 和 R]、Python 和 Go）。

参见：https://regex101.com/r/Ly7O1x/3/

^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$

第二个用于支持按编号提取的语言（与第一个对应的提取项按顺序分别为：major、minor、patch、prerelease、buildmetadata）。主要包括 ECMA Script（JavaScript）、PCRE（Perl 兼容正则表达式，比如 Perl、PHP 和 R）、Python 和 Go。参见：https://regex101.com/r/vkijKf/1/

`1`	`^(0\|[1-9]\d)\.(0\|[1-9]\d)\.(0\|[1-9]\d)(?:-((?:0\|[1-9]\d\|\d[a-zA-Z-][0-9a-zA-Z-])(?:\.(?:0\|[1-9]\d\|\d[a-zA-Z-][0-9a-zA-Z-]))))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$`

📝 正则表达式

参考资料

中文文案排版指北

Fri, 18 Oct 2024 20:02:36 +0800

写在前面

今天在浏览 CS-Notes 时，注意到其按照中文文案排版指北进行排版，故写此文 mark 一下 📝

注：CS-Notes 的学习笔记将会在近期逐一发布

参考资料： https://github.com/sparanoid/chinese-copywriting-guidelines

空格

有研究显示，打字的时候不喜欢在中文和英文之间加空格的人，感情路都走得很辛苦，有七成的比例会在 34 岁的时候跟自己不爱的人结婚，而其余三成的人最后只能把遗产留给自己的猫。毕竟爱情跟书写都需要适时地留白。

与大家共勉之。

——vinta/paranoid-auto-spacing

中英文之间需要增加空格

`1`	`在 LeanCloud 上，数据存储是围绕 AVObject 进行的。`

完整用法

在 LeanCloud 上，数据存储是围绕 AVObject 进行的。每个 AVObject 都包含了与 JSON 兼容的 key-value 对应的数据。数据是 schema-free 的，你不需要在每个 AVObject 上提前指定存在哪些键，只要直接设定对应的 key-value 即可。

例外：「豆瓣 FM」等产品名词，按照官方所定义的格式书写。

中文与数字之间需要增加空格

`1`	`今天出去买菜花了 5000 元。`

数字与单位之间需要增加空格

`1`	`我家的光纤入屋宽带有 10 Gbps，SSD 一共有 20 TB`

例外：度数／百分比与数字之间不需要增加空格：

1
2
3

角度为 90° 的角，就是直角。

新 MacBook Pro 有 15% 的 CPU 性能提升。

全角标点与其他字符之间不加空格

`1`	`刚刚买了一部 iPhone，好开心！`

用 `text-spacing` 来挽救？

CSS Text Module Level 4 的 text-spacing 和 Microsoft 的 -ms-text-autospace 可以实现自动为中英文之间增加空白。不过目前并未普及，另外在其他应用场景，例如 macOS、iOS、Windows 等用户界面目前并不存在这个特性，所以请继续保持随手加空格的习惯。

标点符号

不重复使用标点符号

虽然中国大陆的标点符号用法允许重复使用标点符号，但是这么做会破坏句子的美观性。

1
2
3

德国队竟然战胜了巴西队！

她竟然对你说「喵」？！

全角和半角

不明白什么是全角（全形）与半角（半形）符号？请查看维基百科条目全角和半角。

使用全角中文标点

1
2
3

嗨！你知道嘛？今天前台的小妹跟我说「喵」了哎！

核磁共振成像（NMRI）是什么原理都不知道？JFGI！

数字使用半角字符

`1`	`这个蛋糕只卖 100 元。`

例外：在设计稿、宣传海报中如出现极少量数字的情形时，为方便文字对齐，是可以使用全角数字的。

遇到完整的英文整句、特殊名词，其内容使用半角标点

中文句子内夹有英文书籍名、报刊名时，不应借用中文书名号，应以英文斜体表示。

1
2
3

乔布斯那句话是怎么说的？「Stay hungry, stay foolish.」

推荐你阅读 Hackers & Painters: Big Ideas from the Computer Age，非常地有趣。

名词

专有名词使用正确的大小写

大小写相关用法原属于英文书写范畴，不属于本文讨论内容，在这里只对部分易错用法进行简述。

1
2
3

使用 GitHub 登录

我们的客户有 GitHub、Foursquare、Microsoft Corporation、Google、Facebook, Inc.。

注意：当网页中需要配合整体视觉风格而出现全部大写／小写的情形，HTML 中请使用标淮的大小写规范进行书写；并通过 text-transform: uppercase;／text-transform: lowercase; 对表现形式进行定义。

不要使用不地道的缩写

`1`	`我们需要一位熟悉 TypeScript、HTML5，至少理解一种框架（如 React、Next.js）的前端开发者。`

争议

以下用法略带有个人色彩，即：无论是否遵循下述规则，从语法的角度来讲都是正确的。

链接之间增加空格

用法：

1
2
3

请 [提交一个 issue](#) 并分配给相关同事。

访问我们网站的最新动态，请 [点击这里](#) 进行订阅！

对比用法：

1
2
3

请[提交一个 issue](#)并分配给相关同事。

访问我们网站的最新动态，请[点击这里](#)进行订阅！

简体中文使用直角引号

用法：

`1`	`「老师，『有条不紊』的『紊』是什么意思？」`

对比用法：

`1`	`“老师，‘有条不紊’的‘紊’是什么意思？”`

工具

仓库	系列	语言
pangu.js	pangu	JavaScript
pangu-go	pangu	Go
pangu.java	pangu	Java
pangu.py	pangu	Python
pangu.rb	pangu	Ruby
pangu.php	pangu	PHP
pangu.vim	pangu	Vim
vue-pangu	pangu	Vue.js (Web Converter)
intellij-pangu	pangu	Intellij Platform Plugin
autocorrect	autocorrect	Rust, WASM, CLI tool
autocorrect-node	autocorrect	Node.js
autocorrect-py	autocorrect	Python
autocorrect-rb	autocorrect	Ruby
autocorrect-java	autocorrect	Java
autocorrect-go	autocorrect	Go
autocorrect-php	autocorrect	PHP
autocorrect-vscode	autocorrect	VS Code Extension
autocorrect-idea-plugin	autocorrect	Intellij Platform Plugin
jxlwqq/chinese-typesetting	other	PHP
sparanoid/space-lover	other	PHP (WordPress)
sparanoid/grunt-auto-spacing	other	Node.js (Grunt)
hjiang/scripts/add-space-between-latin-and-cjk	other	Python
hustcc/hint	other	Python
n0vad3v/Tekorrect	other	Python

Python 之禅

Fri, 18 Oct 2024 14:08:24 +0800

The Zen of Python, by Tim Peters

Beautiful is better than ugly.

Explicit is better than implicit.

Simple is better than complex.

Complex is better than complicated.

Flat is better than nested.

Sparse is better than dense.

Readability counts.

Special cases aren’t special enough to break the rules.

Although practicality beats purity.

Errors should never pass silently.

Unless explicitly silenced.

In the face of ambiguity, refuse the temptation to guess.

There should be one– and preferably only one –obvious way to do it.

Although that way may not be obvious at first unless you’re Dutch.

Now is better than never.

Although never is often better than right now.

If the implementation is hard to explain, it’s a bad idea.

If the implementation is easy to explain, it may be a good idea.

Namespaces are one honking great idea – let’s do more of those!

译文 By DeepL

美丽胜过丑陋。

显式优于隐式。

简单胜于复杂。

复杂优于复杂。

扁平优于嵌套。

稀疏比密集好。

可读性很重要。

特殊情况不足以打破规则。

尽管实用性胜过纯粹性。

错误不应无声传递。

除非有明确规定。

面对模棱两可的情况，要拒绝猜测的诱惑。

应该有一种–最好只有一种–显而易见的方法。

尽管这种方法一开始可能并不明显，除非你是荷兰人。

现在做总比永远不做强。

尽管“永远不做”往往比“现在不做”要好。

如果实施起来很难解释，那就是个坏主意。

如果实现起来很容易解释，那可能是个好主意。

命名空间就是一个伟大的想法–让我们多做这样的事情吧！

Pycharm 提示：variable in function should be lowercase

Thu, 17 Oct 2024 21:35:49 +0800

在 Pycharm 中书写代码时可能会出现警告（变量名下有黄色波浪线）variable in function should be lowercase

PEP 8 建议函数名应小写，并使用下划线分隔单词以提高可读性，变量名同理。

Function and Variable Names

Function names should be lowercase, with words separated by underscores as necessary to improve readability.

Variable names follow the same convention as function names.

mixedCase is allowed only in contexts where that’s already the prevailing style (e.g. threading.py), to retain backwards compatibility.

译文：

函数和变量名称

函数名应小写，必要时用下划线分隔，以提高可读性。

变量名遵循与函数名相同的约定。

为了保持向后兼容性，只有在已经使用混合大小写的情况下（例如 threading.py），才允许使用混合大小写。

推荐写法：

1
2
3

def my_function(a):
    b = a + 3
    return b

算法 - 快速排序

Thu, 17 Oct 2024 19:49:59 +0800

快速排序基本思想

选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分

其中一部分的所有数据都比另外一部分的所有数据都要小

再按此方法对这两部分数据分别进行快速排序

递归进行后，可以让整个数据变成有序序列

稳定性

快速排序是不稳定的算法，它不满足稳定算法的定义。

算法稳定性 ：假设在数列中存在 a[i]=a[j]，若在排序之前， a[i] 在 a[j] 前面；并且排序之后， a[i] 仍然在 a[j] 前面。则这个排序算法是稳定的

时间复杂度

快速排序的时间复杂度在最坏情况下是O(N2)，平均的时间复杂度是O(N*lgN)。

图源：https://www.runoob.com/

代码实现

def quickSort(arr, left=None, right=None):
    # 如果 left 不是整数或浮点数，那么将 left 设置为 0；否则保留 left 的原值。
    left = 0 if not isinstance(left, (int, float)) else left

    # 如果 right 不是一个整数或浮点数，那么 right 的值会被设置为数组 arr 的最后一个索引。
    # 如果 right 已经是一个整数或浮点数，那么它的值将保持不变。
    right = len(arr) - 1 if not isinstance(right, (int, float)) else right

    if left < right:
        # 执行分区操作，将数组分为两部分，左边都小于等于基准值，右边都大于基准值
        partition_index = partition(arr, left, right)
        # 对左半部分进行递归排序
        quickSort(arr, left, partition_index - 1)
        # 对右半部分进行递归排序
        quickSort(arr, partition_index + 1, right)
    return arr


def partition(arr, left, right):
    # 将第一个元素设为基准
    pivot = left
    # 初始化基准最终位置的索引
    index = pivot + 1

    # 从基准的下一个元素开始遍历数组
    i = index
    while i <= right:
        # 如果当前元素小于基准，将其与索引位置的元素交换，并递增索引
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index += 1
        i += 1

    # 将基准与索引 -1 位置的元素交换，以将基准放置在其正确位置
    swap(arr, pivot, index - 1)
    return index - 1


def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

为 Hugo 添加一个目录

Thu, 17 Oct 2024 18:34:42 +0800

创建 JavaScript 文件

在 Hugo 主题文件夹中，找到路径 static/js 新建文件 toc.js

function debounce(func, wait, options = {
    immediate: false,
    middle: true,
    thisArg: null,
  }) {
    let timer;
    let restDate = new Date();
    const immediate = options.immediate !== false;
    const middle = options.middle !== false;
    const thisArg = options.thisArg || null;
    return function (...args) {
      timer && clearTimeout(timer);
      let isFirst = !timer;
      timer = setTimeout(() => {
        func.apply(thisArg, args);
        restDate = new Date();
      }, wait);
      if ((new Date() - restDate > wait && middle) || (isFirst && immediate)) {
        clearTimeout(timer);
        func.apply(thisArg, args);
        restDate = new Date();
      }
    }
  }
  
  function setActive(anchors) {
    const ele = anchors.find((ele, index, arr) => {
      return ele.getBoundingClientRect().top >= 0 || index >= arr.length - 1;
    });
    if (ele) {
      const tableOfContents = document.querySelector('#table-of-contents');
      const toActive = tableOfContents.querySelector(`a[href="#${ele.id}"]`);
      if (!toActive) return;
      const activeA = tableOfContents.querySelector(`.active`);
      if (activeA) activeA.classList.remove('active');
      toActive.classList.add('active');
      window.history.pushState(null, null, `#${ele.id}`);
      tableOfContents.scrollTo({
        left: 0,
        top: toActive.offsetTop - tableOfContents.getBoundingClientRect().height / 2,
        behavior: 'smooth',
      });
    }
  }
  
  function initContents(icon = '<svg t="1690868184633" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="3381" width="32" height="32"><path d="M128 192l768 0 0 128-768 0 0-128Z" fill="#666666" p-id="3382"></path><path d="M128 448l768 0 0 128-768 0 0-128Z" fill="#666666" p-id="3383"></path><path d="M128 704l768 0 0 128-768 0 0-128Z" fill="#666666" p-id="3384"></path></svg>') {
    if(document.querySelector('#table-of-contents-wapper')) return;
    const contents = document.createElement('details');
    contents.id = 'table-of-contents-wapper';
    contents.innerHTML = `<summary>
      ${icon}
    </summary>`
    const styleElement = document.createElement('style')
    styleElement.innerHTML = `
    #table-of-contents-wapper {
      user-select: none;
      position: fixed;
      right: 1em;
      top: 4em;
      border-radius: 8px;
      z-index: 999
    }
  
    @media only screen and (min-width:768px) {
      #table-of-contents-wapper[open] summary {
        position: relative;
        left: 5.8em
      }
    }
  
    @media only screen and (max-width:768px) {
      #table-of-contents-wapper {
        top: auto;
        right: auto;
        bottom: 1.8rem;
        left: 1.8rem
      }
    }
  
    #table-of-contents-wapper summary {
      display: inline-block;
      font-size: 1.5em;
      border-radius: 4px;
      cursor: pointer;
      padding: .2em
    }
  
    #table-of-contents-wapper #table-of-contents {
      line-height: 1.3;
      width: 19rem;
      font-size: 15px;
      padding: .8em;
      border: 1px solid;
      border-radius: 6px;
      overflow-y: scroll;
      max-height: calc(100vh - 20rem);
      background-color: rgba(150, 150, 150, 0.8);
      color: #ffffff
    }
  
    #table-of-contents-wapper #table-of-contents a {
      width: 60%;
      display: inline-block;
      color: currentColor;
      line-height: 1.3;
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis
    }
  
    #table-of-contents-wapper #table-of-contents .active {
      border-left: 2px solid #bedfff;
      color: #bedfff
    }
  
    .content h1,
    .content h2,
    .content h3 {
      padding-top: 2em !important;
      margin-top: -2em !important
    }`;
  
    const anchors = [...document.querySelector('.content').querySelectorAll('h1[id],h2[id],h3[id],h4[id]')];
    if (!anchors.length) return contents.remove();
    const tableOfContents = document.createElement('div');
    tableOfContents.id = 'table-of-contents';
    anchors.forEach(ele => {
      const a = document.createElement('a');
      if (!ele.innerText) return;
      a.innerText = ele.innerText;
      a.href = `#${ele.id}`;
      a.style.paddingLeft = `${ele.tagName.charAt(1)}em`;
      tableOfContents.appendChild(a);
    });
  
    contents.appendChild(tableOfContents);
    contents.open = window.innerWidth >= 768;
  
    document.head.appendChild(styleElement);
    document.body.append(contents);
  
    setActive(anchors);
    const debounceSetActive = debounce(setActive, 200)
    window.addEventListener('scroll', () => {
      debounceSetActive(anchors);
    });
  }

创建 toc.html 文件

此文件用于在页面中导入第一步中的 JavaScript

在主题文件夹下的 layouts\partials\post 目录中，新建 toc.html

{{ if .Params.toc }}
<script src="/js/toc.js"></script>
<script>initContents()</script>
{{ end }}

新建完成后在主题文件夹下的 layouts\posts 目录中，找到 <footer></footer> 标签，插入下面代码

`1`	`{{ partial "posts/toc.html" . }}`

此时，在 Markdown 文件上方添加 toc = true 即可显示目录，效果请访问此页

（可选）修改 Markdown 文件模板

找到 archetypes 目录，修改 default.md 文件

在 +++ 之间添加下面行

`1`	`toc = false`

这样在使用 hugo new 命令时，创建的文件会自动包含 toc 项，按需设置为 true 即可

Java EE 中的注解

Wed, 16 Oct 2024 19:56:02 +0800

@Controller

@Controller 是 Spring Framework 中的一个注解，主要用于标记在一个类上，表示该类作为 Spring MVC 中的一个控制器（Controller），负责处理用户的 HTTP 请求并返回响应结果。这个注解属于 Spring Web MVC 模块的一部分，用于实现模型 - 视图 - 控制器（MVC）设计模式。

作用

标识控制器类

标注了 @Controller 的类会被 Spring 容器识别为一个 Bean，并纳入到 Spring MVC 的处理流程中。这意味着，Spring 会创建此类的实例，并将其注入到 IOC 容器中管理。

映射请求

在 @Controller 修饰的类中定义方法，通常会在方法上使用如 @GetMapping、@PostMapping、@PutMapping、@DeleteMapping 等注解来指定 HTTP 请求的方法类型（GET、POST、PUT、DELETE 等）及 URI 路径。当请求匹配到这些注解所指定的规则时，相应的方法将会被调用来处理请求。

返回视图或数据

在处理完请求之后，@Controller 中的方法可以通过返回 ModelAndView 对象、字符串（代表视图名称）、RedirectView 对象，或者直接返回 ResponseEntity、JSON 数据等方式向客户端发送响应。

@RequestMapping

@RequestMapping 是 Spring Framework 中用于处理 HTTP 请求的核心注解之一，它可以应用于类级别或方法级别，用于映射 HTTP 请求到相应的处理逻辑。这个注解同样属于 Spring Web MVC 模块，是实现 MVC 设计模式的重要组成部分。

作用

映射请求路径

在类级别使用 @RequestMapping 可以为整个控制器设置一个基本的请求映射路径，类下的每个方法可以根据需要在其基础上添加更具体的映射规则。在方法级别使用时，它可以精确指定一个或多个 HTTP 请求方法（GET、POST 等）以及请求 URI 路径。

1
2
3

@Controller
@RequestMapping("/users")
public class UserController {  }

请求参数和头信息处理

@RequestMapping 还可以结合 params 和 headers 属性，用于限制请求参数和头信息，只有满足特定条件的请求才会被映射到该方法。

内容协商

通过 consumes 和 produces 属性，可以声明处理方法期望接收的请求内容类型（如 application/json）和返回的内容类型，从而支持内容协商。

重定向和视图解析

处理方法返回的内容可以是一个视图名称（Spring MVC 自动进行视图解析），也可以是一个重定向指令，或者是直接的 HTTP 响应体（如 JSON 数据、XML 数据等）。

1
2

@RequestMapping(value = "/list", method = RequestMethod.GET)
public List<User> listUsers() { ... }

@ResponseBody

@ResponseBody 是 Spring MVC 中的一个注解，主要用于方法级别的处理，指示该方法的返回值不应该被视作一个视图名或模型数据，而是直接作为 HTTP 响应体的内容进行输出。

作用

转换响应内容

当 @ResponseBody 注解应用于一个处理方法时，Spring MVC 会利用 HttpMessageConverter 实现类将方法的返回值转换为适合 HTTP 响应的内容类型（如 JSON、XML 或纯文本等）。默认情况下，Spring 提供了一些内置的 HttpMessageConverter，如 MappingJackson2HttpMessageConverter 用于 JSON 格式的转换。

RESTful API 开发

在构建 RESTful Web 服务时，@ResponseBody 注解非常常见，因为它允许方法直接返回 JSON 或 XML 格式的数据，而不是跳转到一个视图页面。这使得服务接口能够以数据的形式对外提供服务，便于前后端分离的开发模式。

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    @ResponseBody
    public User getUser(@PathVariable Long id) {
        // 获取用户数据...
        return user;
    }
}

@RequestBody

@RequestBody 是 Spring MVC 中的一个注解，用于处理 HTTP 请求体内容的绑定，将请求体中的数据转换为 Java 对象。

作用

数据绑定

当客户端通过 HTTP 请求（通常是 POST、PUT 或 PATCH 方法）发送 JSON、XML 或自定义格式的数据时，@RequestBody 注解会告诉 Spring MVC 使用 HttpMessageConverter 把请求体的内容转换为指定类型的 Java 对象。例如，如果你的请求体包含一个 JSON 格式的用户信息，你可以将它绑定到一个 User 类型的对象。

自动类型转换

Spring 内置了许多 HttpMessageConverter 实现，如 JSON 转换器（MappingJackson2HttpMessageConverter）可以将请求体中的 JSON 数据转换为 Java 对象，反之亦然。如果请求体内容与 Java 类型不匹配，或者请求体内容无法正确解析，Spring MVC 会抛出异常。

复杂数据结构处理

@RequestBody 不仅可以处理简单的 POJO 对象，还可以处理复杂的数据结构，如嵌套对象、集合和数组等。

@PostMapping("/users")
public ResponseEntity<?> addUser(@RequestBody User user) {
    // 在此处，user 对象已经被自动填充了请求体中的 JSON 数据
    userService.add(user);
    return ResponseEntity.ok().build();
}

@PathVariable

@PathVariable 是 Spring MVC 框架中的一种注解，主要用于处理和提取 URL 路径中的动态部分（也称为模板变量或路径变量）。在构建 RESTful API 或者基于 URL 路径参数的 Web 应用时，该注解显得尤为重要。它允许开发者轻松地将 URL 路径中的动态部分映射到控制器方法的参数中，从而使方法能够根据请求的 URL 动态地处理不同的请求目标。

作用

路径变量绑定

在定义 RESTful 资源的 URL 路径时，常常会有动态的部分，比如 /users/{userId} 中的 {userId}。@PathVariable 注解可以将这种动态部分映射到控制器方法的参数中。

类型转换

Spring MVC 会自动将路径变量转换为指定类型的参数，例如上面示例中的 Long 类型。当然，它也能处理其他基本类型及其包装类、String 类型以及自定义类型（只要这些类型能通过 Spring 的 ConversionService 或 Formatter 进行转换）。

可选参数与默认值

虽然 @PathVariable 默认要求路径变量必须存在于 URL 中，但可以通过在注解中设置 required = false 并提供 defaultValue 来指定可选参数和默认值。

正则表达式约束

尽管 @PathVariable 注解本身不支持直接指定正则表达式进行约束，但在某些版本的 Spring 中，可以通过在 @GetMapping、@PostMapping 等注解的 path 属性中使用正则表达式来限定路径变量的格式。

@GetMapping("/users/{userId}")
public User getUser(@PathVariable Long userId) {
    // 这里的 userId 参数将被赋值为 URL 中的 {userId} 部分
    return userService.getUserById(userId);
}

@RestController

@RestController 是 Spring MVC 框架中的一个特殊注解，它是 @Controller 和 @ResponseBody 的组合，用于创建 RESTful Web 服务的控制器。

作用

标记控制器类

@RestController 注解用于标记一个类作为 Spring MVC 控制器，这意味着该类中的方法将处理 HTTP 请求并返回响应结果。与普通的 @Controller 相比，@RestController 更专注于返回纯数据，而不是视图或 JSP 页面。

自动添加@ResponseBody

在类级别或方法级别使用 @RestController 注解，相当于为每个处理方法都加上了 @ResponseBody 注解。这意味着类中所有处理方法的返回值都会被自动转换为 HTTP 响应体，而不是视图名或模型数据。这对于构建 RESTful API 服务极为便利，可以方便地返回 JSON、XML 或其他结构化的数据。

简化开发流程

使用 @RestController 可以简化 RESTful API 开发的流程，无需在每个方法上手动添加 @ResponseBody 注解，使得代码更加简洁、易于阅读和维护。

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        // 返回 User 对象，Spring MVC 将其自动转换为 JSON 并作为响应体返回
        return userService.getUserById(id);
    }
    @PostMapping
    public ResponseEntity<?> addUser(@RequestBody User user) {
        // 添加用户后返回响应
        userService.addUser(user);
        return ResponseEntity.ok().build();
    }
}

@ControllerAdvice

@ControllerAdvice 是 Spring MVC 中的一个注解，它提供了一种全局处理控制器层中异常和增强处理的功能。这个注解可以让开发者定义一个类，该类中的方法将在所有控制器方法执行前后统一处理一些公共逻辑，如异常处理、统一返回格式化等。

作用

全局异常处理

通过在 @ControllerAdvice 标注的类中定义带有 @ExceptionHandler 注解的方法，可以捕获并处理在整个应用程序中 controllers 出现的特定异常。这种方法可以让你统一处理某一类型的异常，而不是在每个 controller 中单独处理。

统一返回结果处理

可以使用 @ModelAttribute 或 @InitBinder 注解的方法来实现对所有 controller 中请求参数的预处理或后处理，例如数据格式化、验证等。

全局数据绑定

在 @ControllerAdvice 类中，可以定义带有 @ModelAttribute 注解的方法，该方法会在每次 controller 处理请求之前执行，可以用来填充一些公共的 model 对象或属性。

跨控制器方法拦截

@ControllerAdvice 类的方法作用域跨越所有标注了 @Controller 或 @RestController 的类，这意味着你在 @ControllerAdvice 类中定义的逻辑将适用于整个应用中的所有控制器。

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(value = {NullPointerException.class})
    public ResponseEntity<String> handleNullException(NullPointerException ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Null Pointer Exception Occurred");
    }
}

@Service

@Service 是 Spring Framework 中的一个注解，它主要用于标记业务层的服务类。这个注解属于 Spring 的核心容器模块，主要应用于面向服务的设计（Service-Oriented Design）。它的功能作用与 @Component 类似，都是作为组件扫描的一部分，用于标记类作为 Spring 容器中的一个 Bean。是 @Component 的一种细化，具有相同的基础功能，即被 Spring IoC 容器自动扫描、检测和管理。

作用

标识服务类

当一个类被 @Service 注解时，它会被 Spring IOC 容器识别并自动注册为一个 Bean，这样就可以在其他类中通过 @Autowired 注解或 XML 配置来注入和使用这个服务类。

事务管理

在 Spring 框架整合了事务管理（如使用 @Transactional 注解）的情况下，标注了 @Service 的类中的方法可以更方便地进行声明式事务管理。也就是说，如果在这样的服务类的方法上添加 @Transactional 注解，那么这些方法就能够支持数据库事务操作。

解耦和封装业务逻辑

@Service 注解的类通常包含了应用的主要业务逻辑，它可以调用 DAO（Data Access Object）来进行数据库操作，处理业务流程，并对外提供服务接口，从而实现业务逻辑与数据访问逻辑的解耦。

@Repository

@Repository 是 Spring Framework 中的一个注解，主要用于标记持久层的组件，如 DAO（Data Access Object）接口或实现类。它属于 Spring Data 模块的一部分，专门用于简化数据访问层的开发工作。

作用

标识 DAO 组件

当一个类被 @Repository 注解时，Spring IoC 容器会识别并自动将其注册为一个 Bean，这样就可以在其他类中通过 @Autowired 注解或 XML 配置来注入和使用这个 DAO。

异常转换

@Repository 注解的类在遇到特定的持久化异常（如 JDBC 的 SQLException、Hibernate 的 HibernateException 等）时，Spring 会将其转换为 DataAccessException 系列的异常，这些异常是 Spring 统一定义的异常体系，便于全局处理和理解。

事务代理

在使用 Spring AOP 进行声明式事务管理时，被 @Repository 注解的类的方法可以享受到事务管理的功能。当类或方法上有 @Transactional 注解时，Spring 会自动为其创建代理对象，并管理事务边界。

组件扫描

在 Spring 配置中启用组件扫描（如 @ComponentScan 注解或 XML 配置）时，@Repository 注解的类会被自动检测并加入到 Spring 容器中。

@Component

@Component 是 Spring Framework 中的一个注解，它是所有受 Spring 容器管理的组件的基础注解，主要用于标记任何类型的 Spring 管理的组件，包括但不限于那些不属于 @Service、@Repository 和 @Controller 这三个特定角色的类。这个注解同样属于 Spring 的核心容器模块。

作用

标识 Bean

@Component 注解的主要作用是将一个普通的 Java 类标记为 Spring 容器中的 Bean，这样 Spring 就可以在启动时通过类路径扫描自动发现并将其纳入到 IoC 容器中进行实例化、配置和管理。当一个类被 @Component 注解时，Spring 的 ClassPathScanningCandidateComponentProvider 会识别它并将其实例化为 Spring IoC 容器中的一个 Bean，允许应用程序通过依赖注入（DI）的方式使用它。

容器管理

标记了 @Component 的类的实例，可以通过 @Autowired 注解或其他注入方式，在其他需要的地方注入并使用。

自定义 Bean 名称

可以通过 value 属性来指定 Bean 在 Spring 容器中的名称，默认情况下，Bean 的名称将是类名的首字母小写的版本。

类型安全

Spring 通过注解来推断 Bean 的类型，可以在其他地方通过类型安全的方式来引用这个 Bean。

组件扫描

结合 Spring 的组件扫描功能（如使用 @ComponentScan 注解或在 XML 配置中设置 <context:component-scan>），Spring 会自动扫描指定包及其子包下的所有 @Component 注解的类，并将其作为 Bean 注册到 Spring 容器中。

@Autowired

@Autowired 是 Spring Framework 提供的一个注解，主要用于处理 Bean 的依赖注入（Dependency Injection, DI）。这是一个基于 Java 注解的注入机制，允许 Spring 容器在运行时自动为 Bean 的字段、构造器参数、方法参数等提供依赖的对象。

作用

字段注入

当 @Autowired 注解应用于类的字段上时，Spring IoC 容器会尝试自动装配一个与其类型兼容的 Bean 到该字段。如果存在多个同类型的 Bean，若没有明确指定 Bean 的名称，则可能会抛出NoUniqueBeanDefinitionException异常；但如果注解中有设置required属性为false，则不会抛出异常，而是将字段值设为null。

public class MyClass {
   @Autowired
   private SomeService someService;  // Spring 容器会找到 SomeService 类型的 Bean 并注入
}

构造器注入

也可以将 @Autowired 应用于构造器的参数上，此时 Spring 会按照构造器参数类型寻找并注入相应的 Bean。

public class MyClass {
   private final SomeService someService;


   @Autowired
   public MyClass(SomeService someService) {
       this.someService = someService;
   }

}

方法注入

@Autowired可以放在setter方法或者任意方法上，当 Spring 容器初始化 Bean 时，会调用此方法完成依赖注入。
public class MyClass {
   private SomeService someService;


   @Autowired
   public void setSomeService(SomeService someService) {
       this.someService = someService;
   }

}

限定注入

如果希望注入某个特定名称的 Bean，可以在 @Autowired 注解中使用 @Qualifier 注解来指定 Bean 的名称。

public class MyClass {
   @Autowired
   @Qualifier("specificSomeService") // 指定注入名称为'specificSomeService'的 SomeService Bean
   private SomeService someService;
}

默认行为

@Autowired 注解的默认行为是要求必须成功注入，即 required 属性默认为 true。如果找不到匹配的 Bean，Spring 容器启动时会抛出异常。但是，可以通过设置 required=false 来改变这一行为，使得即使找不到匹配的 Bean 也不会抛出异常。

@Resource

@Resource 是 Java EE 标准注解，它用于标记依赖注入（Dependency Injection, DI），最初由 Java Community Process (JCP) 在 JSR-250 标准中定义，后来也被 Spring 框架支持。尽管 Spring 也提供了自己的 @Autowired 注解，但在某些场景下，开发者可以选择使用 @Resource 来实现依赖注入。

作用

自动装配

@Resource 注解可以放在字段、setter 方法或构造器参数上，指示容器为这些成员变量自动装配相应的 Bean。类似于 Spring 的@Autowired，@Resource 可以帮助容器根据类型或名称来查找并注入依赖。

默认行为

与@Autowired 不同的是，@Resource 默认按照 Bean 的名称进行查找，而非类型。如果未指定 name 属性，它会尝试匹配字段名作为 Bean 的名称。只有当无法通过名称找到匹配的 Bean 时，@Resource 才会按照类型进行查找。

限定注入

通过在@Resource 注解中指定 name 属性，可以明确指出要注入的 Bean 的名称。

在 Spring 中的使用

虽然@Resource 不是 Spring 专有的注解，但 Spring 框架完全支持它，所以开发者可以根据项目的实际情况选择使用@Autowired 还是@Resource。

需要注意的是，在非 Spring 环境下（如 Java EE 应用服务器），@Resource 仍然能够生效，因为它遵循 Java EE 的标准。而在 Spring 环境中，两者都可以用于依赖注入，但其行为细节有所不同，尤其是在无法通过名称找到唯一匹配 Bean 时的处理策略。

@Inject

@Inject 是 Java CDI（Contexts and Dependency Injection for the Java EE Platform）规范的一部分，这个规范旨在增强 Java 平台的依赖注入能力。不过，Spring 框架也支持@Inject 注解以实现依赖注入。

作用

依赖注入

@Inject 注解用于指示容器应该将一个依赖项注入到字段、构造器、方法参数或者静态字段上。它允许容器根据类型或有时根据名称（如果提供了@Named 注解）来查找并注入相应的 Bean。

public class MyClass {
   @Inject
   private MyService myService;
}

默认行为

@Inject 的行为与 Java EE 环境中的@Resource 类似，都是默认按名称进行查找。在 Spring 环境下，@Inject 和@Autowired 的行为相似，都可以根据类型进行注入，但要注意，Spring 环境中使用@Inject 时不支持自动按名称查找 Bean，除非结合使用@Named 注解。

Java EE 环境与 Spring 环境的差异

在 Java EE 环境中，@Inject 是由容器（如 Glassfish、WildFly 等应用服务器）提供的 CDI 容器处理的，而在 Spring 环境中，@Inject 注解同样可以实现依赖注入，但其背后的实现原理是基于 Spring 自身的 IoC 容器。

与 JSR 330 的关系

@Inject 是 JSR 330（Dependency Injection for Java）规范的一部分，这个规范定义了一系列注解（包括@Inject）用于标准化 Java 的依赖注入。Spring 框架自 3.0 版本开始支持 JSR 330 标准，所以可以跨框架兼容地使用这些注解。总之，@Inject 是一个跨框架的依赖注入注解，无论在 Java EE 还是 Spring 环境中，都能帮助开发者实现对象的依赖注入，达到解耦和灵活组装组件的目的。

@Configuration

@Configuration 是 Spring Framework 中的一个注解，主要用于定义一个类作为 Spring IoC 容器中的配置类，相当于传统的 XML 配置文件。它标志着一个类可以包含 @Bean 注解的方法，这些方法会返回被 Spring 管理的 Bean 实例。通过 Java 代码替代 XML 配置文件，使得配置更加直观、灵活且易于管理和测试。同时，它也促进了代码的模块化和组件化设计。

作用

定义配置类

当一个类被标注为@Configuration 时，Spring 容器会把它当作一个“配置源”，类中所有的@Bean 注解的方法都会被调用以生成和初始化对应的 Bean。

组合配置

@Configuration 类之间可以通过@Import 注解互相导入，形成一个配置层次结构，便于组织和复用配置。

条件配置

@Configuration 类中的@Bean 方法还可以结合@Conditional 注解，根据不同的条件决定是否创建对应的 Bean。

组件扫描

带有@Configuration 注解的类也会被 Spring 的组件扫描机制（如@ComponentScan）发现，并作为一个特殊的 Bean 进行处理。

Bean 作用域

在@Bean 方法上可以声明 Bean 的作用域，例如@Scope(“singleton”) 或@Scope(“prototype”)，来决定 Bean 实例的生命周期。

自动装配

在@Configuration 类内部，可以自由地使用@Autowired 注解进行依赖注入，因为它们也是 Spring 容器管理的 Bean。

@ComponentScan

@ComponentScan 是 Spring Framework 和 Spring Boot 中的一个核心注解，它主要用于自动扫描和注册具有特定注解的类到 Spring 应用程序上下文中，它简化了 Bean 的配置流程，使得应用架构更加模块化和易于管理。

作用

包扫描

@ComponentScan 注解的主要作用是告诉 Spring 框架从指定的包及其子包中扫描识别出符合某种条件的类，并将它们作为 Bean 注册到 Spring 容器中。这样就免去了手动编写大量的 XML 配置文件来声明 Bean 的过程，降低了耦合度，提高了开发效率。

注解类型过滤

默认情况下，@ComponentScan 会识别@Component、@Service、@Repository、@Controller 以及@Configuration 注解的类。当然，可以通过 includeFilters 属性自定义扫描包含哪些注解类型的类。

排除特定 Bean

@ComponentScan 还提供了 excludeFilters 属性，用于排除特定注解类型或命名规则的 Bean 不被扫描和注册。

扫描范围

basePackages属性是最常用的配置，用来指定要扫描的基本包。另外还有basePackageClasses属性，可以接受一个或多个类，Spring 会根据这些类所在的包来确定扫描范围。

作用范围

@ComponentScan 注解通常会出现在带有@Configuration 注解的类上，这样可以确保扫描的 Bean 与当前配置类一起参与到整个应用的自动装配过程中。

定制扫描策略

除了基本的扫描和过滤功能外，还可以通过扩展 TypeFilter 接口来自定义扫描规则，以满足复杂的扫描需求。

@Bean

@Bean 是 Spring Framework 中用于方法级别的注解，主要用于在 Spring IoC 容器中声明和定义一个新的 Bean 实例。当一个方法被标注为 @Bean 时，Spring 容器会调用这个方法来创建并初始化 Bean 对象，并将其加入到 IoC 容器的管理范围之内。@Bean 注解是 Spring 框架中用来显式地配置和管理 Bean 的重要工具，它使得开发人员能够通过 Java 代码而非 XML 配置文件的方式定义和组织 Bean 的创建逻辑，实现了更加灵活、直观和可维护的依赖注入配置。

作用

定义 Bean

在带有 @Configuration 注解的类中使用 @Bean 注解的方法，表示该方法的返回值将作为一个 Bean 注册到 Spring 容器中。

@Configuration
public class AppConfig {

   @Bean
   public MyService myService() {
       return new MyServiceImpl();
   }

}

在上述代码中，myService() 方法会被 Spring 框架调用一次（默认情况下），并将返回的对象作为一个名为 myService 的 Bean 添加到 Spring 容器中。

生命周期控制

通过在 @Bean 方法内直接操作对象的初始化过程，开发者可以更好地控制 Bean 的生命周期，例如设置属性、执行初始化方法等。

依赖注入

在 @Bean 方法内部，可以直接引用其他已定义的 @Bean 方法，这样 Spring 会自动处理这些依赖关系，完成依赖注入。

@Bean
public MyService myService(AnotherDependency anotherDependency) {
   MyServiceImpl service = new MyServiceImpl();
   service.setAnotherDependency(anotherDependency);
   return service;
}

@Bean
public AnotherDependency anotherDependency() {
   return new AnotherDependencyImpl();
}

命名与别名

默认情况下，@Bean 注解的方法名就是生成 Bean 的名称。如果需要指定不同的 Bean 名称，可以通过 name 属性来实现。

作用域

通过 @Scope 注解可以给 @Bean 定义特定的作用域，例如单例（singleton）、原型（prototype）或其他自定义作用域。

@Value

@Value 是 Spring Framework 中的一个注解，用于读取配置属性值并将其注入到字段或方法参数中。它可以读取来自多种来源的属性值，如 properties 文件、yaml 文件、环境变量、命令行参数等。用于从不同来源读取配置属性，并将其注入到 Bean 的字段或方法中，方便开发者在运行时动态地调整和使用配置信息。

作用

字段注入

将属性值注入到类的字段中，字段可以是基本类型、包装类型、字符串或其他对象类型。

@Component
public class MyComponent {

   @Value("${property.name}")
   private String propertyName;

   // ...

}

方法参数注入

将属性值作为方法参数传递。

@Component
public class MyComponent {

   public void someMethod(@Value("${method.argument}") String argument) {
       // ...
   }

}

SpEL 支持

@Value 注解支持 Spring Expression Language（SpEL），因此可以进行更复杂的数据处理和计算。

1
2

@Value("#{systemProperties['os.name']}")
private String operatingSystem;

默认值

如果尝试解析的属性不存在或为空，可以提供一个默认值。

1
2

@Value("${default.property:default_value}")
private String defaultValue;

@Transactional

@Transactional 是 Spring Framework 提供的一个注解，用于管理事务边界，主要应用于数据访问层和服务层的类或方法上，用于声明该方法或类中的所有方法在一个数据库事务中执行。

作用

开启事务

当方法被调用时，Spring 的事务管理器会根据 @Transactional 注解启动一个新的数据库事务。

事务传播行为

@Transactional 注解允许我们指定事务的传播行为，如 REQUIRED（默认）意味着如果当前存在事务则加入该事务，否则新建一个事务。

回滚规则

当方法抛出未被捕获的 RuntimeException 或 Error 时，默认情况下事务会自动回滚。此外，也可以通过 rollbackFor 或 noRollbackFor 属性来指定具体的异常类型以决定是否回滚事务。

隔离级别

可以通过 isolation 属性来指定事务的隔离级别，例如 READ_COMMITTED、REPEATABLE_READ 等，不同的隔离级别有不同的并发控制效果。

超时设置

通过 timeout 属性可以设置事务等待多久之后才抛出异常，单位通常是秒。

@Aspect

@Aspect 是 Spring AOP（面向切面编程）框架中的一个注解，它用于标记一个类作为切面（Aspect），这类切面类中定义了跨越多个类的关注点，即所谓的横切关注点（Cross-cutting Concerns），如日志记录、权限验证、事务管理等。通过定义切面、切点和通知，可以将系统中分散的横切关注点集中处理，提高代码的重用性和可维护性。同时，这种解耦的方式也有利于保持业务逻辑代码的清晰和简洁。

作用

定义切面

当一个类被标注为 @Aspect 时，表示这个类是一个切面，其中包含了对系统中多个模块的交叉关注点的封装。

@Aspect
public class LoggingAspect {
   // 切面中的通知（Advice）方法定义
}

定义切点（Pointcut）

在切面类中，可以定义切点表达式，通过 @Pointcut 注解来指定一组目标方法的集合，这些方法将在特定的连接点（Join Point）处执行切面的通知。

@Pointcut("execution(* com.example.service.*.*(..))")
public void loggingMethods() {
   // 切点表达式定义，此处表示匹配 com.example.service 包及其子包下所有方法的执行
}

定义通知（Advice）

在切面中，通过各种类型的通知方法来定义具体的操作，如前置通知（Before Advice）、后置通知（After Advice）、环绕通知（Around Advice）、最终通知（After Returning Advice）和异常通知（After Throwing Advice）等。

@Before("loggingMethods()")
public void beforeAdvice(JoinPoint joinPoint) {
   // 前置通知，会在目标方法执行前执行
   System.out.println("Executing method: " + joinPoint.getSignature().getName());
}

@AfterReturning(pointcut = "loggingMethods()", returning = "result")
public void afterReturningAdvice(Object result) {
   // 后置通知（返回通知），在目标方法正常返回后执行
   System.out.println("Method executed with result: " + result);
}

织入（Weaving）

Spring AOP 框架会在运行时动态地将切面所定义的通知织入到相应的目标方法执行路径上，从而实现对目标方法的增强或拦截。

@After (后置通知)

作用

@After 注解是一种后置通知（After Advice），它标记的方法会在目标方法（或目标方法链）正常执行完毕后执行，无论目标方法是否抛出了异常。这意味着，只要目标方法开始执行，无论结果如何，后置通知总会被执行。

@Before (前置通知)

作用

@Before 注解是一种前置通知（Before Advice），它标记的方法会在目标方法执行前先被执行。前置通知常常用于在实际执行业务方法前做一些预处理工作，比如权限检查、参数校验等。

@Around (环绕通知)

作用

@Around 注解是一种环绕通知（Around Advice），它是最强大的通知类型。环绕通知能够控制目标方法的完整执行流程，即在目标方法执行前后均可以添加额外的操作，并能决定是否继续执行目标方法以及何时执行目标方法。

@Pointcut

@Pointcut 注解用于定义一个切点表达式，并给它一个标识名称。这个标识名称可以在其他的 AOP 通知注解（如@Before、@After、@Around）中引用，以便让那些通知方法在符合切点表达式的切入点上执行。

作用

@Pointcut("execution(* com.example.service..*(..))")
  public void anyMethodInServicePackage() {
   // 这里不需要有实际方法体，只是一个切点表达式的定义
  }

// 引用定义好的切点
@Before("anyMethodInServicePackage()")
public void beforeServiceMethod() {
    // ...
}

在上述代码中，@Pointcut(“execution(* com.example.service..*(..))”) 定义了一个切点表达式，它匹配 com.example.service 包及其子包下的所有方法。然后在 @Before 注解中通过引用切点名称 “anyMethodInServicePackage()” 来指定通知方法应在哪些方法执行前触发。

@PropertySource

@PropertySource 是一个 Spring 框架中的注解，用于指定一组或多个外部属性文件的路径，以便将这些文件中的配置属性导入到 Spring 容器中。通过该注解，我们可以将应用的配置信息从 Java 配置类或者 XML 配置文件中分离出来，以更灵活的方式管理应用程序的配置参数。

作用

@PropertySource 主要用于向 Spring 环境中添加额外的属性源。这些属性可以在后续的 Bean 初始化过程中作为占位符（${...}）被解析，也可以直接通过 Environment 对象访问。

使用位置

通常在 Spring 的配置类（使用 @Configuration 注解的类）上声明 @PropertySource。如果需要为 XML 配置文件引入外部属性源，可以使用 <context:property-placeholder> 或 <context:property-source> 标签。

基本语法

`1`	`@PropertySource(value = {"file:path/to/file.properties", "classpath:another-file.properties"})`

value 属性是一个字符串数组，表示待加载的属性文件路径。每个路径可以是绝对路径（对于文件系统资源）或相对于类路径的路径（对于类路径资源）。前缀 file: 表示从文件系统加载属性文件，而前缀 classpath: 表示从类路径加载属性文件。如果不指定前缀，默认会尝试从类路径加载。

特性与选项

编码：默认情况下，Spring 使用 JVM 的默认字符集来读取属性文件。如果需要指定特定的字符集，可以使用 encoding 属性，如 @PropertySource(value = "file:config.properties", encoding = "UTF-8")。失败策略：当指定的属性文件不存在或无法读取时，Spring 默认抛出异常。若希望忽略错误并继续初始化过程，可以设置 ignoreResourceNotFound 属性为 true，如 @PropertySource(value = "file:optional-config.properties", ignoreResourceNotFound = true)。

优先级与合并

多个 @PropertySource 注解可以应用于同一个配置类，它们按照定义顺序依次加载，后定义的属性值会覆盖之前定义的同名属性。
如果同时存在 XML 中定义的 context:property-placeholder 和 @PropertySource，两者提供的属性都会被合并到环境变量中。在冲突的情况下，@PropertySource 中的属性具有更高的优先级。

访问属性

在配置类中注入 Environment 对象，然后通过其 getProperty(String key) 方法获取属性值。在其他 Bean 中，可以通过 @Value("${property.key}") 注解直接注入属性值。在 SpEL 表达式中，可以使用 ${property.key} 引用属性值。

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
   @Autowired
   private Environment env;
   @Bean
   public MyService myService() {
        String someProperty = env.getProperty("my.service.some.property");
        return new MyService(someProperty);
   }
}

@PostConstruct

@PostConstruct 是一个标准的 Java EE 注解，广泛应用于 Spring 框架及其他基于 Java 的依赖注入（DI）和面向切面编程（AOP）框架中。它用于标记在一个 Bean 初始化完成后的回调方法，即当所有必需的依赖注入完成后，容器调用此方法进行进一步的初始化操作。以下是 @PostConstruct 注解的详细解释：

作用

@PostConstruct 注解用于标记在一个 Bean 中需要在构造函数及依赖注入完成后立即执行的方法。这个方法通常用于执行一些必要的初始化逻辑，如数据预加载、连接池初始化、缓存填充等。

使用位置

@PostConstruct 注解应放在无参或仅接受 javax.inject.Inject 注解参数的非静态方法上。该方法通常定义在 Spring Bean 类（即被 @Component, @Service, @Repository, @Controller 等注解标记的类）内部。

执行时机

当 Spring 容器创建并完成对 Bean 的依赖注入后，但在 Bean 被任何其他对象引用之前，会调用标注了 @PostConstruct 的方法。这意味着在此方法内，所有的依赖属性都已经设置完毕，可以安全地访问和操作。

特点

唯一性：一个 Bean 中可以有多个方法使用 @PostConstruct 注解，但它们的执行顺序没有明确保证，除非显式使用 Ordered 接口或 @Order 注解来指定顺序。
异常处理：如果 @PostConstruct 方法抛出异常，Spring 容器会视为 Bean 初始化失败，通常会导致容器启动失败或该 Bean 无法正常使用。

与构造函数的区别

构造函数主要负责对象的实例化，一般用于设置不可变状态或依赖于构造时注入的参数。而 @PostConstruct 方法则是在对象已经完全构造并注入依赖之后执行，用于执行更为复杂的初始化逻辑，可能涉及与其他 Bean 的交互或外部资源的访问。

示例

@Service
public class UserService {

    private final UserRepository userRepository;
    private Map<String, User> cachedUsers; // 假设有一个用户缓存
    
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @PostConstruct
    public void initializeCache() {
        cachedUsers = new HashMap<>();
        List<User> allUsers = userRepository.findAll();
        for (User user : allUsers) {
            cachedUsers.put(user.getId(), user);
        }
        log.info("User cache initialized with {} users.", cachedUsers.size());
    }
    
    // 其他业务方法...

}

@PreDestroy

@PreDestroy 是一个标准的 Java EE 注解，同样广泛应用于 Spring 框架及其他基于 Java 的依赖注入（DI）和面向切面编程（AOP）框架中。它用于标记在一个 Bean 销毁前需要执行的清理或资源释放方法。它和@PostConstruct 可以视为一组。

作用

@PreDestroy 注解用于标记在一个 Bean 中需要在销毁前执行的方法。这个方法通常用于执行一些必要的清理工作，如关闭数据库连接、释放系统资源、注销监听器等，确保 Bean 在生命周期结束时能够正确释放其所占用的资源，避免内存泄漏或其他资源未被正确关闭的问题。

使用位置

@PreDestroy 注解应放在无参或仅接受 javax.inject.Inject 注解参数的非静态方法上。该方法通常定义在 Spring Bean 类（即被 @Component, @Service, @Repository, @Controller 等注解标记的类）内部。

执行时机

当 Spring 容器决定要销毁一个 Bean（例如，在容器关闭时，或者由于 Bean 的作用域变化不再需要该 Bean 时），会在 Bean 实例被真正销毁之前调用标注了 @PreDestroy 的方法。这意味着在此方法内，Bean 仍然可以访问其依赖关系和持有的资源。

特点

唯一性：一个 Bean 中可以有多个方法使用 @PreDestroy 注解，但它们的执行顺序没有明确保证，除非显式使用 Ordered 接口或 @Order 注解来指定顺序。
异常处理：尽管 @PreDestroy 方法抛出的异常通常不会阻止 Bean 的销毁，但建议在实现此类方法时妥善处理异常，确保资源得到正确释放。

与 finalize() 方法的区别

finalize() 方法是 Java 中的一个特殊方法，用于在对象被垃圾回收器回收前进行最后一次清理。然而，其执行并不受控且不能保证一定会被执行，因此不适合用于资源管理。相比之下，@PreDestroy 方法的调用由 Spring 容器精确控制，提供了更加可靠的资源释放机制。

示例：

@Service
public class DatabaseConnectionService {

    private Connection connection;
    
    public void establishConnection() throws SQLException {
        connection = DriverManager.getConnection(DB_URL, USER, PASS);
    }
    
    @PreDestroy
    public void closeConnection() throws SQLException {
        if (connection != null && !connection.isClosed()) {
            connection.close();
            log.info("Database connection closed.");
        }
    }
    
    // 其他业务方法...

}

@Profile

@Profile 是 Spring 框架提供的一个条件注解，用于根据激活的 Spring 配置 Profile 来控制 Bean 的创建和注册。通过使用 @Profile，开发者可以实现应用的不同环境（如开发、测试、生产）下的差异化配置和组件启用。

作用

@Profile 注解用于标记某个 Bean、配置类、方法或 @ConfigurationProperties 类，使其仅在特定的 Profile 被激活时生效。这样可以根据运行环境选择性地加载或排除部分 Bean 或配置，实现灵活的环境切换和配置管理。

使用位置

可以将 @Profile 注解应用于以下位置：

Bean 类（如服务类、控制器类、组件类等）
配置类（使用 @Configuration 注解的类）
方法（通常是配置类中的 @Bean 方法）
@ConfigurationProperties 类

基本语法

`1`	`@Profile({"dev", "test"})`

value 属性是一个字符串数组，表示该 Bean 或配置只应在哪些 Profile 被激活时生效。当当前活动的 Profile 与列表中的任何一个相匹配时，该 Bean 或配置就会被创建和注册到 Spring 容器中。

激活 Profile

有多种方式可以激活 Profile：

在应用启动时通过命令行参数指定：--spring.profiles.active=dev,test
在 application.properties 或 application.yml 文件中设置：spring.profiles.active=dev,test
在 Web 应用上下文中通过请求参数指定：http://localhost:8080/context-path?spring.profiles.active=dev,test
在代码中通过 SpringApplication.setAdditionalProfiles(...) 或 SpringApplicationBuilder.profiles(...) 方法设置

组合与排除

可以使用包含逗号的字符串（如 dev,!production）来表达复杂的需求，其中 ! 表示排除某个 Profile。例如，@Profile("dev,!production") 表示在 dev Profile 激活且 production Profile 未激活时生效。对于方法级别的 @Profile，可以结合使用 @Conditional 注解及其派生注解（如 @ConditionalOnProperty、@ConditionalOnClass 等）实现更复杂的条件判断。示例：

// 仅在 'dev' 或 'test' Profile 下创建此 Bean
@Service
@Profile({"dev", "test"})
public class DevOrTestUserService implements UserService {
    // ...
}

// 仅在 'prod' Profile 下创建此 Bean
@Service
@Profile("prod")
public class ProductionUserService implements UserService {
    // ...
}

@Configuration
public class MyConfig {

    // 仅在 'dev' 或 'test' Profile 下创建此 Bean
    @Bean
    @Profile({"dev", "test"})
    public DataSource devOrTestDataSource() {
        // 返回适用于开发或测试环境的数据源配置
    }
    
    // 仅在 'prod' Profile 下创建此 Bean
    @Bean
    @Profile("prod")
    public DataSource productionDataSource() {
        // 返回适用于生产环境的数据源配置
    }

}

@EnableAsync

@EnableAsync 是 Spring Framework 中的一个注解，主要用于启用异步方法调用的支持。在 Spring 中，通过使用该注解，可以将普通方法标记为异步方法，使其在调用时不阻塞当前线程，而是通过异步任务执行器（如线程池）执行，从而提高系统的并发能力和响应速度。

作用

激活异步处理

当 @EnableAsync 注解被应用到一个配置类上时，Spring 会自动注册一个 AsyncConfigurer 的实现，该实现配置了默认的任务执行器（TaskExecutor），用于处理被 @Async 注解标记的方法。

异步方法定义

使用 @Async 注解标记在 service 类或 repository 类中的方法，意味着当该方法被调用时，不会立即等待方法执行完毕，而是交由异步任务执行器调度执行。

线程池配置

开发者可以通过实现 AsyncConfigurer 接口或在配置类中定义 @Bean 注解的方法来自定义异步任务执行器，比如设置线程池大小、队列容量等参数，以适应不同的异步处理需求。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 设置核心线程数
        executor.setMaxPoolSize(10); // 设置最大线程数
        executor.setQueueCapacity(20); // 设置队列容量
        executor.initialize();
        return executor;
    }
}

@Service
public class SomeService {
    @Async
    public Future<String> asyncMethod(String arg) {
        // 异步处理逻辑
        return new AsyncResult<>("Processed asynchronously with argument: " + arg);
    }
}

AsyncConfig 类启用了异步处理，并配置了一个自定义的线程池。SomeService 类中的 asyncMethod 方法被标记为异步方法，当该方法被调用时，其执行过程将由配置好的线程池管理，不再阻塞主线程。

@Async

@Async 是 Spring Framework 提供的一个注解，用于实现异步方法调用。当此注解应用于一个方法时，表明该方法将被异步执行，即在调用该方法时不会立即等待方法执行完成，而是由 Spring 的 TaskExecutor（任务执行器）在后台线程中执行，主线程可以继续执行其他任务。

作用

异步执行

标注了 @Async 的方法会在调用时切换到另一个线程（通常是由 Spring 的 TaskExecutor 提供的线程池中的线程）上执行，使得方法的执行不会阻塞调用者的线程，从而提升系统性能和响应速度。

配置

要在应用中使用 @Async，你需要首先在某个配置类上启用异步支持，即使用 @EnableAsync 注解。此外，还需要配置一个 TaskExecutor，Spring 会使用它来执行异步任务。如果不显式配置，Spring 会使用一个默认的 SimpleAsyncTaskExecutor。

返回类

异步方法通常返回 java.util.concurrent.Future 或 java.util.concurrent.CompletableFuture，以便调用方在将来某个时间点检查异步方法的执行结果或状态。

注意事项

@Async 注解的方法不能是同步的，也不能是静态的。
异步方法通常在 Spring Bean 中使用，因为异步调用的上下文是代理对象，而非原始对象。
不能在同一个类中直接调用一个异步方法，因为 Spring AOP 代理默认不会拦截内部方法调用，可以通过在其他 Bean 中间接调用或者通过 AspectJ 方式解决这个问题。

@EnableScheduling

@EnableScheduling 是 Spring Framework 中提供的一个注解，用于启用定时任务调度功能。当我们在 Spring 应用程序的某个配置类上添加这个注解时，Spring 会自动扫描和注册所有带有 @Scheduled 注解的方法，并通过一个后台调度器（默认是基于 ThreadPoolTaskScheduler）按照预定的规则周期性执行这些方法。

作用

启动定时任务

启用 @EnableScheduling 后，Spring 容器会识别并初始化一个调度器，然后根据配置定期执行带有 @Scheduled 注解的 bean 中的方法。

配合 @Scheduled 使用

@Scheduled 注解用于标记需要定时执行的方法，可以配置 cron 表达式或者固定间隔时间，以便按照指定的调度策略执行任务。

异步执行

默认情况下，被 @Scheduled 注解的方法会在一个后台线程中异步执行，不会阻塞主线程。

配置

除了使用默认的调度器配置，还可以通过自定义 TaskScheduler 或 ScheduledExecutorService 并暴露为 Spring Bean 来覆盖默认的调度器实现。

@Configuration
@EnableScheduling
public class SchedulingConfig {
    @Scheduled(cron = "0 0/5 * * * ?") // 每 5 分钟执行一次
    public void executePeriodicTask() {
        System.out.println("Executing periodic task at " + LocalDateTime.now());
        // 定时任务的具体逻辑
    }
}

@Scheduled

@Scheduled 是 Spring Framework 中提供的一个注解，用于定义和执行定时任务。当你在某个类的方法上使用 @Scheduled 注解时，Spring 会根据注解中配置的时间表达式或间隔时间定期执行该方法。

作用

定时任务

@Scheduled 注解可以用于任何 Spring Bean 中的非静态方法上，标示该方法是一个定时任务，Spring 容器会依据注解中的调度策略自动执行该方法。

调度策略

@Scheduled 支持两种类型的调度策略：

cron 表达式

通过 cron 属性指定一个 cron 表达式，如 0 0/5 * * * ? 表示每 5 分钟执行一次。

fixedDelay/fixedRate

通过 fixedDelay() 或 fixedRate() 指定一个固定时间间隔，单位是毫秒，fixedDelay() 表示两次执行之间的间隔从上次方法执行结束算起，fixedRate() 表示两次执行之间的时间间隔是固定的，不受方法执行耗时影响。

依赖 @EnableScheduling

要使 @Scheduled 注解生效，需要在配置类上开启定时任务支持，即使用 @EnableScheduling 注解。

@Configuration
@EnableScheduling
public class ScheduledTasksConfig {
    @Scheduled(cron = "0 0/5 * * * ?")
    public void executeEveryFiveMinutes() {
        System.out.println("Executing scheduled task at " + LocalDateTime.now());
        // 执行定时任务的具体逻辑
    }
    @Scheduled(fixedRate = 10000) // 每 10 秒执行一次
    public void executeWithFixedRate() {
        System.out.println("Executing scheduled task with fixed rate at " + LocalDateTime.now());
        // 执行定时任务的具体逻辑
    }
}

@Conditional

@Conditional 是 Spring Framework 中的一个条件注解，它允许基于特定的条件来决定是否包含或激活某个 Bean 的定义。当条件满足时，Spring 容器才会实例化和注册被注解的 Bean，否则该 Bean 将不会成为应用程序上下文中的一部分。

作用

细粒度控制

通过 @Conditional 注解，开发者可以对 Bean 的创建进行细粒度的控制，根据不同的环境、配置或者其他自定义条件决定是否应该创建和初始化这个 Bean。

自定义条件

@Conditional 注解需要与实现 org.springframework.context.annotation.Condition 接口的类一起使用。这个接口有两个方法 matches 和 getMatchOutcome，Spring 会在启动时调用这些方法来评估条件是否满足。

内置条件注解

Spring 提供了一系列预定义的条件注解，如 @ConditionalOnBean、@ConditionalOnClass、@ConditionalOnExpression、@ConditionalOnMissingBean、@ConditionalOnMissingClass 等，这些注解可以帮助开发者快速根据类的存在与否、Bean 的存在与否、SpEL 表达式的结果来决定 Bean 是否被加载。

@Configuration
@ConditionalOnClass(MyService.class) // 如果 MyService 类存在，则加载此配置类
public class MyConfiguration {
    @Bean
    @ConditionalOnMissingBean(MyService.class) // 如果没有定义 MyService Bean，则创建此 Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

在这个示例中，MyConfiguration 类仅在 MyService 类存在的时候才会被加载到 Spring 容器中。同时，myService 方法定义的 Bean 只有在 Spring 容器中还没有其他同类型的 Bean（即 MyService 类型的 Bean）时才会被实例化并加入到容器中。通过 @Conditional 注解及其扩展，Spring 提供了一种灵活的方式来根据运行时环境定制 Bean 的创建逻辑，有利于实现组件的按需加载和动态配置。

@ContextConfiguration

@ContextConfiguration 是 Spring Test 框架中的一个注解，用于指定测试类在运行时所需的 Spring 应用上下文配置信息。这个注解主要在集成测试中使用，它允许开发者明确指出应该使用哪些 XML 配置文件、Java 配置类或基于注解的配置来初始化 Spring 容器。

作用

加载配置

通过 locations 属性指定 Spring 配置文件的位置，可以是 XML 文件路径（如 classpath:/spring/app-context.xml ），也可以是 Groovy 脚本路径。

引用配置类

通过 classes 属性指定 Spring Java 配置类的 Class 对象，Spring 会基于这些类来创建和初始化应用上下文。

激活 Profiles

通过 profiles 属性可以指定 Spring 配置文件中的 Profile，以便在测试环境中激活特定的配置。

初始化参数

还可以通过 inheritInitializers、initializers 等属性来控制上下文初始化器的行为。

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = {"classpath:/spring/test-config.xml"}, classes = TestConfig.class)
public class MyServiceTest {

    @Autowired
    private MyService myService;
    
    @Test
    public void testMyService() {
        // 测试代码...
    }

}

// TestConfig.java
@Configuration
public class TestConfig {
    // Spring Java 配置代码...
}

@ExceptionHandler

@ExceptionHandler 是 Spring MVC 框架中用于处理控制器方法抛出的异常的注解。在 Spring Web 应用程序中，当控制器方法在执行过程中抛出异常时，Spring 会尝试找到具有相应 @ExceptionHandler 注解的方法来处理这个异常。

作用

异常处理

标注了 @ExceptionHandler 的方法会在遇到与该方法所处理异常类型相匹配的异常时被调用，从而实现对异常的捕获和自定义处理逻辑。

异常映射

可以将该注解放在控制器类上，为整个类定义通用的异常处理逻辑，也可以放在单个方法上，为特定方法定义个性化的异常处理逻辑。

返回响应

处理异常的方法通常会返回一个 ModelAndView 对象、ResponseEntity 对象、视图名称（字符串形式）或直接返回数据，这样 Spring MVC 就可以根据返回值构造并发送一个包含错误信息的 HTTP 响应给客户端。

支持多种异常类型

一个 @ExceptionHandler 方法可以处理一种或多种异常类型，只需要在注解中列出这些异常类型即可。

@Controller
public class MyController {
    @GetMapping("/users/{id}")
    public String getUserInfo(@PathVariable Long id, Model model) {
        // 假设此处抛出一个 IllegalArgumentException
        throw new IllegalArgumentException("Invalid user ID");
    }
    @ExceptionHandler({IllegalArgumentException.class})
    public String handleIllegalArgument(IllegalArgumentException e, RedirectAttributes redirectAttrs) {
        redirectAttrs.addFlashAttribute("errorMessage", e.getMessage());
        return "redirect:/error";
    }
}

@EnableAutoConfiguration

@EnableAutoConfiguration 是 Spring Boot 中的一个核心注解，它开启了 Spring Boot 的自动配置功能。这个注解背后的思想是尽可能减少开发人员在搭建新项目时所需的配置工作，通过自动配置来识别应用上下文中已经存在的组件，从而自动配置 Spring 容器中可能需要的 Bean。

作用

自动装配

当 Spring Boot 应用启动时，如果发现类路径中有特定的类或 jar 包，Spring Boot 将自动配置相应的 Bean，例如，如果类路径下存在 HSQLDB 的 jar，Spring Boot 会自动配置一个内存数据库。

条件配置

自动配置基于条件注解（如 @ConditionalOnClass 、 @ConditionalOnBean 等），这些条件注解确保只有在满足特定条件（如类路径中存在的类或已经存在的 Bean）时，才进行自动配置。

可定制化

虽然 @EnableAutoConfiguration 提供了大量的自动配置，但开发人员可以根据需要禁用某些自动配置，或者提供自定义的配置覆盖自动配置的默认行为，这通常通过创建一个 @Configuration 类并在其中定义 Bean 或使用 @EnableAutoConfiguration(exclude={...}) 注解来排除不需要的自动配置类实现。

@SpringBootApplication

@SpringBootApplication 是 Spring Boot 中的一个复合注解，它整合了 @SpringBootConfiguration 、@EnableAutoConfiguration 、@ComponentScan 的功能，是创建 Spring Boot 应用程序的主要入口点。

用它标记的主类，Spring Boot 会自动完成如下工作

初始化 Spring 容器；
自动配置 Spring Boot 应用的基本功能，如数据库连接、Web 服务器、安全性等；
扫描并注册 Spring 组件到 Spring 容器。

@SpringBootConfiguration

@SpringBootConfiguration 继承自 @Configuration 注解，表明该类是一个 Spring 配置类，可以包含 @Bean 注解的方法，用于定义 Spring 容器中的 Bean。

@EnableAutoConfiguration

@EnableAutoConfiguration 开启了 Spring Boot 的自动配置功能。Spring Boot 根据类路径中的依赖来自动配置 Bean，极大地简化了项目配置，实现开箱即用的效果。

@ComponentScan

@ComponentScan 默认会对当前包及其子包下的所有组件进行扫描，包括标记为 @Component、@Service、@Repository、@Controller 的类，以及其他带有 stereotype 注解的类，将其注册到 Spring 容器中。

机器学习 - 多项式回归

Tue, 15 Oct 2024 21:03:27 +0800

本文分为 理论介绍 和 Python 示例代码 两部分

👉 点此直接跳转到示例代码

理论介绍

多项式回归

线性回归模型形式比较简单，且有很好的解释性，但是它只适用于 X 和 Y 之间存在线性关系的数据集。对于非线性关系的数据集，线性回归不能很好的工作。本节将介绍线性回归模型的扩展–多项式回归，可以用用它拟合非线性关系的数据集。

多项式回归，回归函数是回归多变量多项式的回归。多项式回归也是线性回归模型其中的一种。由于任一函数都可以用多项式进行拟合，因此多项式回归有着广泛的应用。

研究一个因变量与一个或多个自变量之间的回归分析，成为多项式回归。如果自变量只有一个，则称为一元多项式回归，如果自变量有多个时，则称为多元多项式回归。在一元回归分析中，如果因变量与自变量的关系是非线性的，可以采用一元多项式回归。

一元 n 次多项式回归方程为：

$$ \widehat y= \theta _ {0} + \theta _ {1} x+ \theta _ {0} x^ {2} + \cdots + \theta _ {n} x^ {7} $$

数据并不是线性关系的，这个时候我们可以使用一元多项式回归来拟合。

一元多项式回归函数：

$$ y(x, \theta )= \theta _ {0} + \theta _ {1} x+ \theta _ {2} x^ {2} + \cdots + \theta _ {n} x^ {n} = \sum _ {j=0} nw_ {j} x^ {j} $$

$n$ 表示多项式的阶数，$x^j$ 表示 $x$ 的 $j$ 次幂，$w$ 则代表该多项式的系数。

当使用多项式去拟合三点时，需要确定两个要素：

多项式系数 $\theta$
多项式阶数 $n$

利用 sklearn 中的 PolynomialFeatures 构造多项式

在 sklearn 中，可以通过 PolynomialFeatures() 类自动产生多项式特征矩阵。

`1`	`sklearn.preprocessing.PolynomialFeatures(degree=2, interaction_only=False, include_bias=True)`

degree: 多项式次数，默认为 2 次多项式。
interaction_only: 默认为 False，如果为 True 则产生相互影响的特征集。
include_bias: 默认为 True，包含多项式中的截距项。

sklearn.preprocessing import PolynomialFeatures  
# degree 代表多项式的的最高次  
transfer = PolynomialFeatures(degree=2, include_bias=False)  
# 将 x 训练成多项式形式的数据  
x = transfer.fit_transform(x)

生成用于多项式回归的数据

def genY(x):  
    a0, a1, a2, a3, e = 0.01, -0.2, 0.3, -0.04, 0.05  
    yr = a0 + a1 * x + a2 * (x ** 2) + a3 * (x ** 3) + e  
    y = yr + 0.03 * np.random.rand(1)  
    return y

使用 numpy 生成线性数据：

`1`	`x = np.linspace(-1, 1, 200)`

利用公式计算出每个 x 对于的 y 值：

`1`	`y = [genY(a) for a in x]`

公式中生成一个一元三次的数据（这条语句在其中加入噪声点进行干扰。）：

`1`	`y = yr + 0.03 * np.random.rand(1)`

最后将处理 x 和 y 的形状方便用于计算：

1
2

x = x.reshape(-1, 1)
y = np.array(y).reshape(-1, 1)

使用线性回归预测：

# 导入线性回归类  
from sklearn.linear_model import LinearRegression  
# 实例化  
lr = LinearRegression()  
# 传入数据进行训练  
lr.fit(x, y)  
# 传入数据进行模型评估  
score = lr.score(x, y)
# 导入用于数据分割的函数  
from sklearn.model_selection import train_test_split  
# 将数据集分割成训练集和测试集  
# test_size=0.2 表示将 20 的数据用于测试  
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)

Python 示例代码

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.model_selection import train_test_split

np.random.seed(100)


def gen_y(x):
    a0, a1, a2, a3, e = 0.01, -0.2, 0.3, -0.04, 0.05
    yr = a0 + a1 * x + a2 * (x ** 2) + a3 * (x ** 3) + e
    y = yr + 0.03 * np.random.rand(1)
    return y


def model_train(x, y):
    # 利用 PolynomialFeatures 类构造多项式的数据，并设置最高次为 3
    poly_features = PolynomialFeatures(degree=3)
    x_poly = poly_features.fit_transform(x)

    # 将特征值拆分成训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(x_poly, y, test_size=0.2, random_state=42)

    # 实例化出一个线性回归分类器
    lin_reg = LinearRegression()

    # 传入训练数据训练模型
    lin_reg.fit(x_train, y_train)

    # 使用 score 函数对模型进行评估
    score = lin_reg.score(x_test, y_test)

    return score


if __name__ == '__main__':
    # 利用 np 中的 linspace 生成线性数据
    x = np.linspace(-1, 1, 200)
    # 用公式算出 y
    y = [gen_y(a) for a in x]
    x = x.reshape(-1, 1)
    y = np.array(y).reshape(-1, 1)
    print(model_train(x, y))

输出：0.9965995795138225

机器学习 - 梯度与梯度下降

Tue, 15 Oct 2024 20:59:04 +0800

本文分为 理论介绍 和 Python 代码示例 两部分

👉 点此直接跳转到代码示例

理论介绍

线性回归模型

单变量线性回归

$$ h_ {\theta } (x)= \theta _ {0} + \theta _ {1} x $$

`1`	`h = theta_0 + theta_1 * x`

代价函数

为了评估出线性函数拟合的怎么样，需要使用到 Cost Function（代价函数），代价函数越接近 0，说明越好，等于 0 的时候即为完全拟合。

$$ J( \theta _ {0} , \theta _ {1} )= \frac {1}{2m} \sum _ {i=1}^ {m} (h_ {\theta }(x^ {(i)})-y^ {(i)})^2 $$

`1`	`cost = 0.5 * np.sum(((theta_0 + theta_1 * x) - y) ** 2)`

梯度下降

梯度的本意是一个向量（矢量），表示某一函数（该函数一般是二元及以上的）在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大（为该梯度的模）。

当函数是一元函数时，梯度就是导数。这里我们用一个最简单的例子来讲解梯度下降法，然后推广理解更为复杂的函数。

还是用上面的例子，有 n 组数据，自变量 $x(x1,x2,…,xn)$ ，因变量 $y(y1,y2,…,yn)$ ，但这次我们假设它们之间的关系是：$f(x)=ax$ 。记 $J(a)$ 为 $f(x)$ 和 $y$ 之间的差异，即：

$$ J(a)= \sum _ {i=1}^ {n} (f( x^ {(i)} - y^ {(i))^ {2}} = \sum _ {i=1}^ {n} (ax^ {(i)}-y^ {(i)})^ {2} $$

在梯度下降法中，需要我们先给参数 a 赋一个预设值，然后再一点一点的修改 a，直到 J(a) 取最小值时，确定 a 的值。下面直接给出梯度下降法的公式（其中 $\alpha$ 为正数）：

$$ repeat\{ a:=a- \alpha \frac {\partial J(a)}{\partial a} \} $$

如果给 $a$ 去的预设值是 $a1$ ，那么 $a$ 对 $J(a)$ 的导数为负数，意味着 $a$ 会向右移。然后重复这个步骤，直到 $J(a)$ 到达最小值。

同理给 $a$ 取得预设值是 $a2$ ，那么 $a$ 对 $J(a)$ 的导数为正数，意味着 $a$ 会向左移，然后重复这个步骤，直到 $J(a)$ 到达最小值。

因此我们可以得到，不管 $a$ 的预设值取多少， $J(a)$ 经过梯度下降法的多次重复后，最后总能到达最小值。

对于上述公式的理解可以用上山下山的例子来说明，给 a 的预设值就好比是你正处在一个山的山坡上，如果你想走到山谷，那么你就会判断你是向左还是向右走，走完第一次之后又会重新判断。在公式中 $\alpha$ 叫做学习率，也就是你走的步伐的大小， $\alpha$ 越大，步伐就越大，当然， $\alpha$ 也不是越大越好，就好比如果你就快到山谷了，但是由于步伐太大而刚好跨过山谷，下一步往回走又会跨过山谷，这样就永远到不了山谷了。

# alpha 为学习率  
alpha = 0.005  
# m 为样本数量  
m, n = y.shape  
# 计算梯度下降的方向  
d_theta_0 = np.sum((theta_0 + theta_1 * x) - y) / m  
d_theta_1 = np.sum(((theta_0 + theta_1 * x) - y) * x) / m  
# 更新 theta  
theta_0 = theta_0 - alpha * d_theta_0  
theta_1 = theta_1 - alpha * d_theta_1

多变量线性回归

多变量线性回归于单变量线性回归其实差不了多少，只是需要计算的参数从两个变成多个了而已。

假设有 n 组数据，其中目标值（因变量）与特征值（自变量）之间的关系为：

$$ f(x(i))= \theta _ {0} + \theta _ {1} x_ {1}^ {(i)} + \cdots + \theta _ {n} x_ {n}^ {(i)} $$

其中 $i$ 表示第 $i$ 组数据，损失函数为：

$$ J( \theta )= \sum _ {i=1}^ {n} (f( x^ {(i)} - y^ {(i)})^ {2} $$

梯度下降法公式为：

$$ repeat \{\theta _ {j} := \theta _ {j} - \alpha \frac {\partial J(\theta )}{\partial \theta _ {j}}\} $$

Python 代码示例

from sklearn.datasets import make_regression
import numpy as np
from sklearn.model_selection import train_test_split
np.random.seed(10)


def cost(theta, x, y):
    cost = np.sum((theta.dot(x.T) - y) ** 2) / 2
    return cost


def lr(x, y, alpha=0.0005, iterations=50000):
    """
    :param x: 特征值
    :param y: 目标值
    :param alpha: 学习率
    :param iterations: 迭代次数
    :return: 最终得到的 theta 值
    """
    # 初始化 theta 为零向量
    theta = np.zeros(x.shape[1])
    
    # 学习率与迭代次数请根据实际情况进行调整
    # 通过循环不断更新 theta
    for _ in range(iterations):
        # 计算预测值与实际值之间的差值
        gradient = x.dot(theta) - y
        # 计算 theta 的梯度
        grad_theta = gradient.dot(x) / len(y)
        # 更新 theta
        theta -= alpha * grad_theta
    
    return theta

机器学习 - 正规矩阵方法

Tue, 15 Oct 2024 20:15:50 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

👉 点此直接跳转到代码实现

理论介绍

线性回归

线性回归是回归分析的一种。

假设目标值（因变量）与特征值（自变量）之间线性相关

然后构建损失函数；

最后通过令损失函数最小来确定参数。（最关键的一步）

损失函数

🔗 点击查看损失函数相关文档

正规方程

为了评估出线性函数拟合的怎么样，需要使用到 Cost Function（代价函数），代价函数越接近 0，说明越好，等于 0 的时候即为完全拟合，我们可以对损失函数求导并令其等于 0。

假设有 n 组数据，其中目标值（因变量）与特征值（自变量）之间的关系为：

$$ f(x(i))= \theta _ {0} + \theta _ {1} x_ {1}^ {(i)} + \cdots + \theta _ {n} x_ {n}^ {(i)} $$

用代码可以表示为 theta = np.linalg.inv(x.T.dot(x)).dot(x.T).dot(y)

正规方程的的适用条件

在实际中可能会出现是奇异矩阵，往往是因为特征值之间不独立。这时候需要对特征值进行筛选，剔除那些存在线性关系的特征值（好比在预测房价中，特征值 1 代表以英尺为尺寸计算房子，特征值 2 代表以平方米为尺寸计算房子，这时特征值 1 和特征值 2 只需要留 1 个即可）。

正规方程很方便而且容易实现，但是如果特征变量的数量变得很大的时候，计算量就会变得非常巨大，训练的速度将会变慢，所以，在使用正规方程时，应该考虑样本的数量，如果 n 超过 10000 时，建议不使用正规方程，可以使用下节讲到的梯度下降。

均值方差

在得到 $\theta $ 后，就可以预测出结果 prediction = x_test.dot(theta)

模型评估其实是相似的法则——找真实标签和预测值的差异。

我们的回归类算法中，可以使用均值方差评判是否预测到了正确的数值、以及是否拟合到了足够的信息。

$$ MSE= \frac {1}{m} \sum _ {i=1}^ {m} (f(x_ {i})-y_ {i})^ {2} $$

用代码可以表示为：mse = np.mean((prediction - y)**2) 其中 prediction 表示预测结果，y 表示目标值。

Python 代码实现

def lr(x_train, x_test, y_train, y_test):
    """
    :param x_train: 训练集
    :param x_test: 训练集标签
    :param y_train: 测试集
    :param y_test: 测试集标签
    :return: 预测值与测试集标签的均方误差
    """
    
    # 使用正规方程公式求得 theta
    theta = np.linalg.inv(x_train.T.dot(x_train)).dot(x_train.T).dot(y_train)
    # 使用 theta 预测结果
    prediction = x_test.dot(theta)
    # 求出预测值与目标值的均方误差
    mse = np.mean((prediction-y_test)**2)
    
    # 输出四舍五入，保留到小数点后 15 位
    return round(mse, 15)

Hugo 自动清理 Public 目录下的文件

Tue, 15 Oct 2024 18:50:52 +0800

问题描述

Hugo 构建 Public 目录时没有清除已经废弃的资源文件

解决方法

在 hugo.toml 中添加：

`1`	`cleanDestinationDir = true`

参考链接：

https://community.render.com/t/how-to-clean-published-directory-in-hugo/17738

机器学习 - 损失函数

Tue, 15 Oct 2024 18:27:14 +0800

本文分为 理论介绍 和 Python 代码实现 两部分

理论

损失函数概述

机器学习中的监督学习本质上是给定一系列训练样本 $(x_{i},y_{i})$ ，尝试学习 $x$ 与 $y$ 间的映射关系。损失函数（Loss Function）则是这个过程中关键的一个组成部分，用来衡量模型的输出 $\hat{y}$ 与真实的 $y$ 之间的差距，给模型的优化指明方向。

平均绝对误差损失

平均绝对误差损失（Mean Absolute Error Loss）是一种常见的损失函数，也称 L1损失。

$$ J_{M A E}=\frac{1}{N} \sum_{i=1}^{N}\left|y_{i}-\hat{y}_{i}\right| $$

其可视化图像如图所示

从图中可以看出 MAE 损失的最小值为 0（当预测等于真实值时），最大值为无穷大。随着预测与真实值绝对误差 $∣y− \hat{y}∣$ 的增加，MAE 损失呈线性增长。

均方差损失

均方差损失（Mean Squared Rrror Loss）也是一种在机器学习以及深度学习回归任务中常用的一种损失函数，也成为L2损失。

$$ J_{M S E}=\frac{1}{N} \sum_{i=1}^{N}\left(y_{i}-\hat{y}_{i}\right)^{2} $$

下面是是对于真实值 $y=0$ ，不同的预测值 [−1.5,1.5]的均方差损失的变化图

从图可以看到随着预测值与真实值绝对误差 $∣y− \hat{y}∣$ 的增加，均方差呈二次方增增加。

交叉熵损失

前面介绍的两种损失函数都是适用于回归问题的，对于分类问题，常用的损失函数是交叉熵损失函数（Cross-entropy Loss）。

二分类

在进行二分类时，我们通常使用 Sigmoid 函数将模型的输出压缩到 (0,1) 区间内 $\hat{y}_{i} \in (0,1)$ ，用来代表给定输入 $x_i$ ，模型判断为正类的概率。由于只有正负两类，因此同时也得到了负类的概率。

$$ p( y_ {i} = 1|x_ {i} )= \widehat {y}_ {i} p( y_ {i} = 0|x_ {i} )=1- \widehat {y}_ {i} $$

将其合并后可得

$$ p(y_i|x_i) = (\hat{y_i})^{y_i} (1-\hat{y_i})^{1-y_i} $$

假设数据点之间独立同分布，则似然可以表示为

$$ L(x, y)=\prod_{i=1}^N(\hat{y_i})^{y_i} (1-\hat{y_i})^{1-y_i} $$

对似然取对数，然后加负号变成最小化负对数似然，即为交叉熵损失函数的形式

$$ J_{CE}=-\sum_{i=1}^N\left (y_i{log(}\hat{y_i}) + (1- y_i){log}(1-\hat{y_i})\right) $$

其可视化图像如图

其中蓝线是目标值为 0 时输出不同输出的损失，黄线是目标值为 1 时的损失。可以看到越接近目标值损失越小，随着误差变大，损失呈指数增长。

多分类

在多分类的任务中，交叉熵损失函数的推导思路和二分类是一样的，变化的地方是真实值 $y_i$ 现在是一个 One-hot 向量，同时模型输出的压缩由原来的 Sigmoid 函数换成 Softmax 函数。Softmax 函数将每个维度的输出范围都限定在 (0, 1) 之间，同时所有维度的输出和为 1，用于表示一个概率分布。

$$ p(y_i|x_i) = \prod_{k=1}^K(\hat{y_i}^k)^{y_i^k} $$

其中 $k \in K$ 表示 $K$ 个类别中的一类，同样的假设数据点之间独立同分布，可得到负对数似然为

$$ J_{CE} = -\sum_{i=1}^N\sum_{k=1}^K y_i^k \mathbb{log}(\hat{y_i}^k) $$

由于 $y_i$ 是一个 one-hot 向量，除了目标类为 1 之外其他类别上的输出都为 0，因此上式也可以写为

$$ J_{CE} = -\sum_{i=1}^N y_i^{c_i}\mathbb{log}(\hat{y_i}^{c_i}) $$

其中 $c_i$ 是样本 $x_i$ 的目标类。通常这个应用于多分类的交叉熵损失函数也被称为 Softmax Loss 或者 Categorical Cross Entropy Loss。

Python 代码实现

平均绝对误差损失

def mean_absolute_loss(self,y_hat,y,n):
	"""
    平均绝对误差损失
    :param y_hat: 预测结果
    :param y: 真实结果
    :param n: 样本数量
    :return: 损失函数计算结果
    """
    
    loss = abs(y_hat - y)
    loss = np.sum(loss) / n
    
    return loss

均方差损失

def mean_squared_loss(self,y_hat,y,n):
    """
    均方差损失
    :param y_hat: 预测结果
    :param y: 真实结果
    :param n: 样本数量
    :return: 损失函数计算结果
    """
    
    loss = (y_hat - y) ** 2
    loss = np.sum(loss) / n
    
    return loss

交叉熵损失

def cross_entropy_loss(self,y_hat,y,n):
    """
    交叉熵损失
    :param y_hat: 预测结果
    :param y: 真实结果
    :param n: 样本个数
    :return: 损失函数计算结果
    """

    loss = y_hat * np.log2(y) + (1 - y) * np.log2(1 - y)
    loss = np.sum(loss)
    loss = loss / (-n)
    
    return loss

PowerShell 执行多条命令

Tue, 15 Oct 2024 15:36:14 +0800

需求

在写 Github Actions 脚本时需要一次性输入多条 PowerShell 命令后执行，故 mark 一下

可行方案

使用 && 连接
使用 ; 连接
形如 (command1) -and (command2)

飞书机器人项目文档

Mon, 14 Oct 2024 19:40:23 +0800

📌写在前面

本文是飞书 AI 机器人项目（FeishuAiBot）的介绍文档

本项目主要用于接入腾讯的混元大模型和阿里的通义大模型。

项目 Github: https://github.com/essesoul/FeishuAiBot

目前 Node.js 版本较为成熟，修改自 https://github.com/bestony/ChatGPT-Feishu，修改了 bug，并替换了过时的代码。

Python 版本正在更新中，目前经实现了对话，暂无记忆功能。

功能

功能	Node.js 版	Python 版
AI 回复	✔	✔
对话记忆	✔	❌
机器人指令	✔	❌

Node.js 版

https://github.com/essesoul/FeishuAiBot/tree/main/js

Python 版

https://github.com/essesoul/FeishuAiBot

飞书开放平台创建机器人

创建应用

访问飞书开放平台，创建应用

创建完成后，访问 凭证与基础信息 页面，复制 APPID 和 Secret 备用

开启机器人能力

添加应用的机器人能力

配置监听事件

在 事件与回调 中设置 订阅方式 为 将事件发送至开发者服务器

点击保存后，可以添加事件

直接搜索 im.message.receive_v1

添加完成后，如下所示

发布机器人

点击上方 创建版本

填写版本号、应用说明即可保存

发布版本

查看飞书回调日志

日志检索 - 事件日志检索 - 查询

使用 Typora 编辑 Hugo（不使用图床）

Mon, 14 Oct 2024 18:04:49 +0800

遇到的问题

Typora 是一个简单美观的 Markdown 编辑器，但在 Typora 中的图片路径包含文件夹时容易和 Hugo 程序不兼容。

目前大量的教程建议使用“上传”功能，将图片上传到图床

但为了实现 Simple 的目标，是否还有别的解决方案呢？👀

解决方案

创建 Hugo 文章时，使用命令 hugo new post/helloworld/index.md
在 Typora - 偏好设置 - 图像中，设置 复制图片到当前文件夹，并勾选 优先使用相对路径 ，如下图所示

✨ 原理

创建文章时，为每个文章创建单独的目录

在 Typora 中设置后，图片将和 Markdown 文本文件位于同一目录下

由于勾选了优先使用相对路径，Markdown 文件中的图片路径将不包含文件夹

Hello World

Mon, 14 Oct 2024 11:01:51 +0800

这是一个测试页面

代码测试

def test():
    print("hello world")
    return 0

test()

链接测试：link

图片测试：

关于

Mon, 01 Jan 0001 00:00:00 +0000

欢迎来到 essesoul 的博客 🚀

这个博客将被用于记录一些编程和生活中的想法和思考，因此将会非常简洁。

🔥 所有文章

☕ 我的项目

分类

📁 分类（categories）类似于文件夹，用于区分文章的类别。

RSS 订阅源

`1`	`https://www.essesoul.top/index.xml`

站点地图

`1`	`https://www.essesoul.top/sitemap.xml`

归档

Mon, 01 Jan 0001 00:00:00 +0000

联系

Mon, 01 Jan 0001 00:00:00 +0000

邮箱：i@essesoul.top
Github: @essesoul

搜索

Mon, 01 Jan 0001 00:00:00 +0000

项目

Mon, 01 Jan 0001 00:00:00 +0000

开发中

FeishuAiBot

开发完成

Cloudreve-AfdianPay Cloudreve 自定义付款渠道 - 爱发电接口