SQLModel入门

news2025/1/16 16:16:19

SQLModel 系统性指南

目录

  1. 简介
    • 什么是 SQLModel？
    • 为什么使用 SQLModel？
  2. 安装
  3. 快速入门
    • 定义模型
    • 创建数据库和表
  4. 基本 CRUD 操作
    • 创建（Create）
    • 读取（Read）
    • 更新（Update）
    • 删除（Delete）
  5. 处理关系
    • 一对多关系
    • 多对多关系
  6. 高级功能
    • 异步支持
    • 自定义查询
    • 迁移（Migrations）
  7. 与 FastAPI 的集成
    • 依赖注入
    • 路由保护
  8. 性能优化与最佳实践
  9. 常见问题解答
  10. 参考资料

1. 简介

什么是 SQLModel？

SQLModel 是一个现代化的 Python 库，旨在简化与数据库的交互。它结合了 Pydantic 和 SQLAlchemy 的优势，使得定义数据模型、进行数据验证和与数据库交互变得更加直观和高效。SQLModel 由 Sebastián Ramírez（FastAPI 的创始人）开发，专为与 FastAPI 框架无缝集成而设计。

为什么使用 SQLModel？

  • 简洁性：通过结合 Pydantic 的数据验证和 SQLAlchemy 的 ORM 功能，SQLModel 使模型定义和数据库操作更加简洁。
  • 类型安全：充分利用 Python 的类型提示，增强代码的可读性和可靠性。
  • 与 FastAPI 无缝集成：优化了与 FastAPI 的集成，支持自动文档生成和依赖注入。
  • 灵活性：支持同步和异步操作，适应不同的性能需求。
  • 现代化设计：采用现代化的 Python 编码风格和最佳实践，提升开发体验。

2. 安装

首先，确保您已经安装了 Python 3.7 或更高版本。然后，使用 pip 安装 sqlmodel 包：

pip install sqlmodel

此外，根据您使用的数据库，还需要安装相应的数据库驱动。例如：

  • SQLite：无需额外安装驱动，Python 内置支持。

  • PostgreSQL：

    pip install asyncpg

  • MySQL：

    pip install pymysql

3. 快速入门

定义模型

使用 SQLModel 定义数据模型时，通常会继承自 SQLModel 并使用 table=True 参数指示这是一个数据库表。

from typing import Optional
from sqlmodel import SQLModel, Field
from datetime import datetime

class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    username: str = Field(index=True, nullable=False, unique=True)
    email: str = Field(index=True, nullable=False, unique=True)
    hashed_password: str = Field(nullable=False)
    is_active: bool = Field(default=True)
    created_at: datetime = Field(default_factory=datetime.utcnow)

创建数据库和表

使用 SQLAlchemy 的引擎和 SQLModel 的元数据来创建数据库和表。

from sqlmodel import SQLModel, create_engine
from models import User  # 假设上面的模型保存在 models.py 文件中

DATABASE_URL = "sqlite:///./test.db"  # 或者使用其他数据库，如 PostgreSQL
engine = create_engine(DATABASE_URL, echo=True)

def create_db_and_tables():
    SQLModel.metadata.create_all(engine)

在应用启动时调用 create_db_and_tables 来创建数据库表。

4. 基本 CRUD 操作

创建（Create）

向数据库中插入一条新记录。

from sqlmodel import Session, select
from models import User
from database import engine, create_db_and_tables

def create_user(username: str, email: str, hashed_password: str) -> User:
    user = User(username=username, email=email, hashed_password=hashed_password)
    with Session(engine) as session:
        session.add(user)
        session.commit()
        session.refresh(user)
        return user

读取（Read）

从数据库中查询记录。

def get_user_by_id(user_id: int) -> Optional[User]:
    with Session(engine) as session:
        user = session.get(User, user_id)
        return user

def get_user_by_username(username: str) -> Optional[User]:
    with Session(engine) as session:
        statement = select(User).where(User.username == username)
        user = session.exec(statement).first()
        return user

更新（Update）

更新数据库中的记录。

def update_user_email(user_id: int, new_email: str) -> Optional[User]:
    with Session(engine) as session:
        user = session.get(User, user_id)
        if user:
            user.email = new_email
            session.add(user)
            session.commit()
            session.refresh(user)
            return user
        return None

删除（Delete）

从数据库中删除记录。

def delete_user(user_id: int) -> bool:
    with Session(engine) as session:
        user = session.get(User, user_id)
        if user:
            session.delete(user)
            session.commit()
            return True
        return False

5. 处理关系

一对多关系

例如，一个用户可以有多条地址记录。

from typing import List, Optional
from sqlmodel import SQLModel, Field, Relationship

class Address(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    street: str
    city: str
    user_id: int = Field(foreign_key="user.id")

    user: Optional["User"] = Relationship(back_populates="addresses")

class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    username: str = Field(index=True, nullable=False, unique=True)
    email: str = Field(index=True, nullable=False, unique=True)
    hashed_password: str = Field(nullable=False)
    is_active: bool = Field(default=True)
    created_at: datetime = Field(default_factory=datetime.utcnow)

    addresses: List[Address] = Relationship(back_populates="user")

多对多关系

例如，用户和角色之间的多对多关系。

from typing import List, Optional
from sqlmodel import SQLModel, Field, Relationship

class UserRoleLink(SQLModel, table=True):
    user_id: int = Field(foreign_key="user.id", primary_key=True)
    role_id: int = Field(foreign_key="role.id", primary_key=True)

class Role(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str

    users: List["User"] = Relationship(
        back_populates="roles",
        link_model=UserRoleLink
    )

class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    username: str = Field(index=True, nullable=False, unique=True)
    email: str = Field(index=True, nullable=False, unique=True)
    hashed_password: str = Field(nullable=False)
    is_active: bool = Field(default=True)
    created_at: datetime = Field(default_factory=datetime.utcnow)

    roles: List[Role] = Relationship(
        back_populates="users",
        link_model=UserRoleLink
    )

6. 高级功能

异步支持

SQLModel 支持异步数据库操作，适用于需要高并发和高性能的应用。

首先，安装异步驱动（如 asyncpg 用于 PostgreSQL）：

pip install asyncpg

然后，配置异步引擎和会话：

from sqlmodel import SQLModel, create_engine, select
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
from models import User
from datetime import datetime

DATABASE_URL = "postgresql+asyncpg://user:password@localhost/dbname"
async_engine = create_async_engine(DATABASE_URL, echo=True)

async_session = sessionmaker(
    async_engine, class_=AsyncSession, expire_on_commit=False
)

async def init_db():
    async with async_engine.begin() as conn:
        await conn.run_sync(SQLModel.metadata.create_all)

# 在应用启动时调用 init_db
import asyncio
asyncio.run(init_db())

# 异步获取会话
async def get_async_session():
    async with async_session() as session:
        yield session

# 异步 CRUD 操作示例
async def get_user_async(user_id: int) -> Optional[User]:
    async with async_session() as session:
        user = await session.get(User, user_id)
        return user

自定义查询

使用 SQLAlchemy 的强大查询功能，执行复杂的数据库操作。

from sqlmodel import Session, select, func
from models import User

def count_users() -> int:
    with Session(engine) as session:
        statement = select(func.count(User.id))
        count = session.exec(statement).one()
        return count

def get_users_with_email_domain(domain: str) -> List[User]:
    with Session(engine) as session:
        statement = select(User).where(User.email.like(f"%@{domain}"))
        users = session.exec(statement).all()
        return users

迁移（Migrations）

虽然 SQLModel 本身不提供迁移工具，但它与 Alembic 完全兼容，可以使用 Alembic 进行数据库迁移。

安装 Alembic：

pip install alembic

初始化 Alembic：

alembic init alembic

配置 Alembic：

编辑 alembic.ini，设置 sqlalchemy.url 为您的数据库 URL。

在 alembic/env.py 中，导入您的模型：

from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from sqlmodel import SQLModel
import sys
import os

# 将项目路径添加到 sys.path
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

from models import User  # 导入您的模型

# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config

# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)

target_metadata = SQLModel.metadata

def run_migrations_offline():
    ...
    # 保持默认配置

def run_migrations_online():
    ...
    # 保持默认配置

if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

创建迁移脚本：

alembic revision --autogenerate -m "Initial migration"

应用迁移：

alembic upgrade head

7. 与 FastAPI 的集成

依赖注入

利用 FastAPI 的依赖注入机制，将数据库会话注入到路由中。

from fastapi import FastAPI, Depends, HTTPException
from sqlmodel import Session, select
from models import User
from database import engine, get_session

app = FastAPI()

@app.post("/users/", response_model=User)
def create_user(user: User, session: Session = Depends(get_session)):
    db_user = session.exec(select(User).where(User.username == user.username)).first()
    if db_user:
        raise HTTPException(status_code=400, detail="Username already exists")
    session.add(user)
    session.commit()
    session.refresh(user)
    return user

@app.get("/users/{user_id}", response_model=User)
def read_user(user_id: int, session: Session = Depends(get_session)):
    user = session.get(User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

路由保护

结合 JWT 进行身份验证，保护特定路由。

安装 fastapi-jwt-auth：

pip install fastapi-jwt-auth

配置 JWT：

from fastapi import FastAPI, Depends, HTTPException
from fastapi_jwt_auth import AuthJWT
from pydantic import BaseModel
from sqlmodel import Session, select
from models import User
from database import engine, get_session

class Settings(BaseModel):
    authjwt_secret_key: str = "your-secret-key"

app = FastAPI()

@AuthJWT.load_config
def get_config():
    return Settings()

@app.post('/login')
def login(user: User, Authorize: AuthJWT = Depends()):
    # 验证用户凭证（此处省略具体验证逻辑）
    access_token = Authorize.create_access_token(subject=user.username)
    return {"access_token": access_token}

@app.get('/protected')
def protected(Authorize: AuthJWT = Depends()):
    Authorize.jwt_required()
    current_user = Authorize.get_jwt_subject()
    return {"message": f"Hello, {current_user}"}

8. 性能优化与最佳实践

8.1 使用连接池

优化数据库连接，使用连接池以提高性能和资源利用率。

from sqlmodel import create_engine

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL, echo=True, pool_size=20, max_overflow=0)

8.2 异步操作

对于高并发应用，使用异步数据库操作。

from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql+asyncpg://user:password@localhost/dbname"
async_engine = create_async_engine(DATABASE_URL, echo=True)
async_session = sessionmaker(
    async_engine, class_=AsyncSession, expire_on_commit=False
)

8.3 缓存

使用缓存机制（如 Redis）减少数据库查询，提高响应速度。

import redis

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def get_user_cached(user_id: int) -> Optional[User]:
    cached_user = redis_client.get(f"user:{user_id}")
    if cached_user:
        return User.parse_raw(cached_user)
    with Session(engine) as session:
        user = session.get(User, user_id)
        if user:
            redis_client.set(f"user:{user_id}", user.json(), ex=3600)
        return user

8.4 索引优化

为常用查询字段添加索引，提高查询性能。

class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    username: str = Field(index=True, nullable=False, unique=True)
    email: str = Field(index=True, nullable=False, unique=True)
    # 其他字段...

8.5 分页

对于大量数据查询，使用分页机制减少单次查询的数据量。

def get_users_paginated(skip: int = 0, limit: int = 10) -> List[User]:
    with Session(engine) as session:
        statement = select(User).offset(skip).limit(limit)
        users = session.exec(statement).all()
        return users

9. 常见问题解答

9.1 如何在 SQLModel 中使用外键？

在定义模型时，使用 Field 的 foreign_key 参数指定外键。

class Address(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    street: str
    city: str
    user_id: int = Field(foreign_key="user.id")

    user: Optional["User"] = Relationship(back_populates="addresses")

9.2 SQLModel 支持哪些数据库？

SQLModel 基于 SQLAlchemy，支持所有 SQLAlchemy 支持的数据库，包括：

  • SQLite
  • PostgreSQL
  • MySQL
  • SQL Server
  • Oracle
  • 以及其他数据库，通过相应的数据库驱动支持。

9.3 如何进行数据库迁移？

SQLModel 本身不提供迁移工具，但可以与 Alembic 配合使用进行数据库迁移。

安装 Alembic：

pip install alembic

初始化 Alembic：

alembic init alembic

配置 Alembic：

编辑 alembic.ini，设置 sqlalchemy.url 为您的数据库 URL。

在 alembic/env.py 中，导入您的模型：

from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from sqlmodel import SQLModel
import sys
import os

# 将项目路径添加到 sys.path
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

from models import User  # 导入您的模型

config = context.config

fileConfig(config.config_file_name)

target_metadata = SQLModel.metadata

def run_migrations_offline():
    ...

def run_migrations_online():
    ...

if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

创建迁移脚本：

alembic revision --autogenerate -m "Initial migration"

应用迁移：

alembic upgrade head

9.4 如何处理模型验证错误？

SQLModel 结合了 Pydantic 的数据验证功能，可以在模型定义中使用 Pydantic 的字段验证器。

from sqlmodel import SQLModel, Field
from pydantic import validator, EmailStr

class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    username: str = Field(index=True, nullable=False, unique=True)
    email: EmailStr = Field(index=True, nullable=False, unique=True)
    hashed_password: str = Field(nullable=False)

    @validator('username')
    def username_must_not_be_empty(cls, v):
        if not v or not v.strip():
            raise ValueError('Username must not be empty')
        return v

10. 参考资料

  • SQLModel 官方文档：https://sqlmodel.tiangolo.com/
  • SQLAlchemy 官方文档：https://www.sqlalchemy.org/
  • FastAPI 官方文档：https://fastapi.tiangolo.com/
  • Alembic 官方文档：https://alembic.sqlalchemy.org/en/latest/
  • Real Python 的 SQLModel 教程：https://realpython.com/sqlmodel-python-orm/
  • Pydantic 官方文档：https://pydantic-docs.helpmanual.io/
  • GitHub 上的 SQLModel 仓库：https://github.com/tiangolo/sqlmodel

附录：完整示例

以下是一个完整的 FastAPI 应用示例，展示了如何使用 SQLModel 进行数据库操作和 API 构建。

目录结构

my_fastapi_app/
├── main.py
├── models.py
├── database.py
├── schemas.py
└── alembic/
    ├── env.py
    ├── script.py.mako
    └── versions/

models.py

from typing import List, Optional
from sqlmodel import SQLModel, Field, Relationship
from datetime import datetime

class Address(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    street: str
    city: str
    user_id: int = Field(foreign_key="user.id")

    user: Optional["User"] = Relationship(back_populates="addresses")

class User(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    username: str = Field(index=True, nullable=False, unique=True)
    email: str = Field(index=True, nullable=False, unique=True)
    hashed_password: str = Field(nullable=False)
    is_active: bool = Field(default=True)
    created_at: datetime = Field(default_factory=datetime.utcnow)

    addresses: List[Address] = Relationship(back_populates="user")

schemas.py

from typing import List, Optional
from pydantic import BaseModel, EmailStr
from datetime import datetime

class AddressCreate(BaseModel):
    street: str
    city: str

class AddressRead(BaseModel):
    id: int
    street: str
    city: str

    class Config:
        orm_mode = True

class UserCreate(BaseModel):
    username: str
    email: EmailStr
    password: str

class UserRead(BaseModel):
    id: int
    username: str
    email: EmailStr
    is_active: bool
    created_at: datetime
    addresses: List[AddressRead] = []

    class Config:
        orm_mode = True

database.py

from sqlmodel import SQLModel, create_engine, Session
from models import User, Address

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL, echo=True)

def create_db_and_tables():
    SQLModel.metadata.create_all(engine)

def get_session():
    with Session(engine) as session:
        yield session

main.py

from fastapi import FastAPI, Depends, HTTPException
from sqlmodel import Session, select
from models import User, Address
from schemas import UserCreate, UserRead, AddressCreate, AddressRead
from database import create_db_and_tables, get_session
from typing import List

app = FastAPI()

@app.on_event("startup")
def on_startup():
    create_db_and_tables()

@app.post("/users/", response_model=UserRead)
def create_user(user: UserCreate, session: Session = Depends(get_session)):
    db_user = session.exec(select(User).where(User.username == user.username)).first()
    if db_user:
        raise HTTPException(status_code=400, detail="Username already exists")
    new_user = User(
        username=user.username,
        email=user.email,
        hashed_password=user.password  # 实际项目中应进行哈希处理
    )
    session.add(new_user)
    session.commit()
    session.refresh(new_user)
    return new_user

@app.get("/users/{user_id}", response_model=UserRead)
def read_user(user_id: int, session: Session = Depends(get_session)):
    user = session.get(User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

@app.post("/users/{user_id}/addresses/", response_model=AddressRead)
def create_address(user_id: int, address: AddressCreate, session: Session = Depends(get_session)):
    user = session.get(User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    new_address = Address(**address.dict(), user_id=user_id)
    session.add(new_address)
    session.commit()
    session.refresh(new_address)
    return new_address

@app.get("/users/{user_id}/addresses/", response_model=List[AddressRead])
def read_addresses(user_id: int, session: Session = Depends(get_session)):
    user = session.get(User, user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user.addresses

运行应用

使用 uvicorn 运行 FastAPI 应用：

uvicorn main:app --reload

访问 http://127.0.0.1:8000/docs 查看自动生成的 API 文档，并进行测试。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2277615.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

RabbitMQ(四)

RabbitMQ(四)

SpringBoot整合RabbitMQ SpringBoot整合1、生产者工程①创建module②配置POM③YAML④主启动类⑤测试程序 2、消费者工程①创建module②配置POM③YAML文件内配置： ④主启动类⑤监听器 3、RabbitListener注解属性对比①bindings属性②queues属性 SpringBoot整合 1、生…
阅读更多...
java_将数据存入elasticsearch进行高效搜索

java_将数据存入elasticsearch进行高效搜索

使用技术简介： (1) 使用Nginx实现反向代理，使前端可以调用多个微服务 (2) 使用nacos将多个服务管理关联起来 (3) 将数据存入elasticsearch进行高效搜索 (4) 使用消息队列rabbitmq进行消息的传递 (5) 使用 openfeign 进行多个服务之间的api调用 参…
阅读更多...
win32汇编环境,对话框程序中组合框的应用举例

win32汇编环境,对话框程序中组合框的应用举例

;运行效果 ;win32汇编环境,对话框程序中组合框的应用举例 ;比如在对话框中生成组合框，增加子项，删除某项，取得指定项内容等 ;直接抄进RadAsm可编译运行。重点部分加备注。 ;以下是ASM文件 ;>>>>>>>>>>>>…
阅读更多...
occ的开发框架

occ的开发框架

occ的开发框架 1.Introduction This manual explains how to use the Open CASCADE Application Framework (OCAF). It provides basic documentation on using OCAF. 2.Purpose of OCAF OCAF (the Open CASCADE Application Framework) is an easy-to-use platform for ra…
阅读更多...
Linux检查磁盘占用情况

Linux检查磁盘占用情况

1.检查使用情况 df -h发现是/dev/vda1占用很高 2.查看/dev/vda1文件夹 cd /dev/vda1发现不是文件夹 3.继续查看使用情况 df -h *4.原因可能是文件已经删除但是进程还在，没有释放空间 5.查看删除操作的进程 lsof -n | grep deleted6.杀死进程 kill -9 PID
阅读更多...
C# (图文教学)在C#的编译工具Visual Studio中使用SQLServer并对数据库中的表进行简单的增删改查--14

C# (图文教学)在C#的编译工具Visual Studio中使用SQLServer并对数据库中的表进行简单的增删改查--14

目录 一.安装SQLServer 二.在SQLServer中创建一个数据库 1.打开SQL Server Manager Studio(SSMS)连接服务器 2.创建新的数据库 3.创建表 三.Visual Studio 配置 1.创建一个简单的VS项目(本文创建为一个简单的控制台项目) 2.添加数据库连接 四.简单连通代码示例 简单连…
阅读更多...
Flutter插件制作、本地/远程依赖及缓存机制深入剖析（原创-附源码）

Flutter插件制作、本地/远程依赖及缓存机制深入剖析（原创-附源码）

Flutter插件在开发Flutter项目的过程中扮演着重要的角色，我们从 ​​​​​​https://pub.dev 上下载添加到项目中的第三方库都是以包或者插件的形式引入到代码中的，这些第三方工具极大的提高了开发效率。 深入的了解插件的制作、发布、工作原理和缓存机…
阅读更多...
自动化办公|xlwings简介

自动化办公|xlwings简介

xlwings 是一个开源的 Python 库，旨在实现 Python 与 Microsoft Excel 的无缝集成。它允许用户使用 Python 脚本自动化 Excel 操作，读取和写入数据，执行宏，甚至调用 VBA 脚本。这使得数据分析、报告生成和其他与 Excel 相关的任务…
阅读更多...
Dify应用-工作流

Dify应用-工作流

目录 DIFY 工作流参考 DIFY 工作流 2025-1-15 老规矩感谢参考文章的作者,避免走弯路。 2025-1-15 方便容易上手 在dify的一个桌面上,添加多个节点来完成一个任务。 每个工作流必须有一个开始和结束节点。 节点之间用线连接即可。 每个节点可以有输入和输出 输出类型有,字符串,…
阅读更多...
《C++11》并发库：简介与应用

《C++11》并发库：简介与应用

在C11之前，C并没有提供原生的并发支持。开发者通常需要依赖于操作系统的API（如Windows的CreateThread或POSIX的pthread_create）或者第三方库（如Boost.Thread）来创建和管理线程。这些方式存在以下几个问题： …
阅读更多...
建筑综合布线可视化管理

建筑综合布线可视化管理

随着数字化转型的加速，越来越多的业务应用依赖网络来实现，综合布线系统作为网络基础设施，加强对综合布线系统的管理维护是业务安全稳定运行的重要保障。传统的表格CAD图纸的综合布线管理模式，易造成综合布线系统线缆混乱、随意变更…
阅读更多...
ESXi 切换硬盘直通后无法恢复的解决办法

ESXi 切换硬盘直通后无法恢复的解决办法

起因：近日，准备了一块SATA固态硬盘，计划对现有的ESXI虚拟机上新增扩容。因为只增加一块固态，也不打算做raid，就打算把它当作单独的存储来用。在网上搜了一些方法，脑子一热，通过ESXI控制台程序&a…
阅读更多...
计算机网络 （43）万维网WWW

计算机网络 （43）万维网WWW

前言 万维网（World Wide Web，WWW）是Internet上集文本、声音、动画、视频等多种媒体信息于一身的信息服务系统。 一、基本概念与组成 定义：万维网是一个分布式、联机式的信息存储空间，通过超文本链接的方式将分散的信息…
阅读更多...
汽车免拆诊断案例 | 2007 款法拉利 599 GTB 车发动机故障灯异常点亮

汽车免拆诊断案例 | 2007 款法拉利 599 GTB 车发动机故障灯异常点亮

故障现象　 一辆2007款法拉利599 GTB车，搭载6.0 L V12自然吸气发动机（图1），累计行驶里程约为6万km。该车因发动机故障灯异常点亮进厂检修。 图1　发动机的布置 故障诊断 接车后试车，发动机怠速轻微抖动，…
阅读更多...
ChatGPT正在朝着全面个人助手迈出重要一步，推出了一个名为“Tasks”的新功能

ChatGPT正在朝着全面个人助手迈出重要一步，推出了一个名为“Tasks”的新功能

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗？订阅我们的简报，深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同，从行业内部的深度分析和实用指南中受益。不要错过这个机会，成为AI领…
阅读更多...
微软震撼发布：Phi-4语言模型登陆Hugging Face

微软震撼发布：Phi-4语言模型登陆Hugging Face

近日，微软公司在Hugging Face平台上正式发布了其最新的语言模型Phi-4，这一发布标志着人工智能技术的又一重要进步。Phi-4模型以其140亿参数的高效配置，在复杂推理任务中表现出色，特别是在数学领域，更是展现出了卓越的能…
阅读更多...
RTC(Real_Time Clock)

RTC(Real_Time Clock)

RTC概述： RTC（实时时钟，Real-Time Clock）是一种用于跟踪当前日期和时间的计时设备。RTC可以是独立的芯片，也可以是集成在微控制器或处理器中的一个模块。RTC是现代电子设备中不可或缺的一部分，为各种应用提…
阅读更多...
[leetcode]链表基础回顾

[leetcode]链表基础回顾

一.创建带头节点的链表 #include <iostream> #include <string> #include <algorithm> using namespace std; typedef struct Node { char ch; Node* next; }*LinkList,ListNode; void printLinkList(LinkList& head) { LinkList p head…
阅读更多...
rclone，云存储备份和迁移的瑞士军刀，千字常文解析，附下载链接和安装操作步骤...

rclone，云存储备份和迁移的瑞士军刀，千字常文解析，附下载链接和安装操作步骤...

一、什么是rclone&#xff1f; rclone是一个命令行程序&#xff0c;全称&#xff1a;rsync for cloud storage。是用于将文件和目录同步到云存储提供商的工具。因其支持多种云存储服务的备份&#xff0c;如Google Drive、Amazon S3、Dropbox、Backblaze B2、One Drive、Swift、…
阅读更多...
JAVA：利用 RabbitMQ 死信队列实现支付超时场景的技术指南

JAVA：利用 RabbitMQ 死信队列实现支付超时场景的技术指南

1、简述 在支付系统中&#xff0c;订单支付的超时自动撤销是一个非常常见的业务场景。通常用户未在规定时间内完成支付&#xff0c;系统会自动取消订单&#xff0c;释放相应的资源。本文将通过利用 RabbitMQ 的 死信队列&#xff08;Dead Letter Queue, DLQ&#xff09;来实现…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023