Python FastAPI 框架 操作Mysql数据库 增删改查

news2024/9/20 22:27:52

2 比 1 更容易理解，可以先看2（单文件级别）
在这里插入图片描述

1、FastAPI 框架 操作Mysql数据库(项目多文件级别)

FastAPI 可以使用任何您想要的关系型数据库。
在这里，让我们看一个使用着SQLAlchemy的示例。
您可以很容易地将SQLAlchemy支持任何数据库，像：

  • PostgreSQL
  • MySQL
  • SQLite
  • Oracle
  • Microsoft SQL Server，等等其它数据库
    在此示例中，我们将使用SQLite，因为它使用单个文件并且 在Python中具有集成支持。因此，您可以复制此示例并按原样来运行它。

稍后，对于您的产品级别的应用程序，您可能会要使用像PostgreSQL这样的数据库服务器。

1.0 创建mysql数据库

  • 创建test数据库，数据库创建users表和items表

  • users表

在这里插入图片描述

  • items表

在这里插入图片描述

1.1 测试项目文件结构

对于这些示例，假设您有一个名为的目录my_super_project，其中包含一个名为的子目录sql_app，其结构如下：

.
└── sql_app
    ├── __init__.py
    ├── crud.py
    ├── database.py
    ├── main.py
    ├── models.py
    └── schemas.py

该文件__init__.py只是一个空文件，但它告诉 Python 其中sql_app的所有模块（Python 文件）都是一个包。

1.2 数据库配置 database.py

# 1、导入 SQLAlchemy 部件
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# 连接mysql数据库需要导入pymysql模块
import pymysql
pymysql.install_as_MySQLdb()

# 2、为 SQLAlchemy 定义数据库 URL地址
# 配置数据库地址：数据库类型+数据库驱动名称://用户名:密码@机器地址:端口号/数据库名
SQLALCHEMY_DATABASE_URL = "mysql://test:123456@127.0.0.1:3306/test"

# 3、创建 SQLAlchemy 引擎
engine = create_engine(SQLALCHEMY_DATABASE_URL, encoding='utf-8')


# 4、创建数据库会话
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 5、创建一个Base类declarative_base
# 稍后我们将用这个类继承，来创建每个数据库模型或类（ORM 模型）
Base = declarative_base()

1.3 创建数据库模型 models.py

用Base类来创建 SQLAlchemy 模型
我们将使用我们之前创建的Base类来创建 SQLAlchemy 模型。

SQLAlchemy 使用的“模型”这个术语 来指代与数据库交互的这些类和实例。
而 Pydantic 也使用“模型”这个术语 来指代不同的东西，即数据验证、转换以及文档类和实例。

from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
from sqlalchemy.orm import relationship

# 1、从database.py导入Base类
from .database import Base

# User继承Base类
class User(Base):
    # 表名
    __tablename__ = "users"

    # 2、创建模型属性/列，使用Column来表示 SQLAlchemy 中的默认值。
    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True)
    hashed_password = Column(String)
    is_active = Column(Boolean, default=True)

    # 3、创建关系
    # 当访问 user 中的属性items时，如 中my_user.items，它将有一个ItemSQLAlchemy 模型列表（来自items表），这些模型具有指向users表中此记录的外键
    # 当您访问my_user.items时，SQLAlchemy 实际上会从items表中的获取一批记录并在此处填充进去。
    # 同样，当访问 Item中的属性owner时，它将包含表中的UserSQLAlchemy 模型users。使用owner_id属性/列及其外键来了解要从users表中获取哪条记录。
    items = relationship("Item", back_populates="owner")

# Item继承Base类
class Item(Base):
    __tablename__ = "items"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, index=True)
    description = Column(String, index=True)
    owner_id = Column(Integer, ForeignKey("users.id"))

    owner = relationship("User", back_populates="items")

创建关系

    items = relationship("Item", back_populates="owner")
  • 当访问 user 中的属性items时，如 中my_user.items，它将有一个ItemSQLAlchemy 模型列表（来自items表），这些模型具有指向users表中此记录的外键
  • 当您访问my_user.items时，SQLAlchemy 实际上会从items表中的获取一批记录并在此处填充进去。
  • 同样，当访问 Item中的属性owner时，它将包含表中的-UserSQLAlchemy 模型users。使用owner_id属性/列及其外键来了解要从users表中获取哪条记录。

1.4 创建 Pydantic 模型 schemas.py

现在让我们查看一下文件sql_app/schemas.py。

为了避免 SQLAlchemy模型和 Pydantic模型之间的混淆，我们将有models.py（SQLAlchemy 模型的文件）和schemas.py（ Pydantic 模型的文件）。
这些 Pydantic 模型或多或少地定义了一个“schema”（一个有效的数据形状）。
因此，这将帮助我们在使用两者时避免混淆。
创建初始 Pydantic模型/模式¶
创建一个ItemBase和UserBasePydantic模型（或者我们说“schema”）以及在创建或读取数据时具有共同的属性。

ItemCreate为 创建一个UserCreate继承自它们的所有属性（因此它们将具有相同的属性），以及创建所需的任何其他数据（属性）。

因此在创建时也应当有一个password属性。

但是为了安全起见，password不会出现在其他同类 Pydantic模型中，例如用户请求时不应该从 API 返回响应中包含它。

from typing import List, Union

# 1、创建初始 Pydantic模型/模式
from pydantic import BaseModel

# 1、创建初始 Pydantic模型/模式
class ItemBase(BaseModel):
    title: str
    description: Union[str, None] = None

# 1、创建初始 Pydantic模型/模式
class ItemCreate(ItemBase):
    pass

# 2、创建用于读取/返回的Pydantic模型/模式
class Item(ItemBase):
    id: int
    owner_id: int

    class Config:
        orm_mode = True

# 1、创建初始 Pydantic模型/模式
class UserBase(BaseModel):
    email: str

# 1、创建初始 Pydantic模型/模式
class UserCreate(UserBase):
    password: str

# 2、创建用于读取/返回的Pydantic模型/模式
class User(UserBase):
    id: int
    is_active: bool
    items: List[Item] = []

    class Config:
        orm_mode = True

请注意，读取用户（从 API 返回）时将使用不包括password的User Pydantic模型。

SQLAlchemy 风格和 Pydantic 风格

请注意，SQLAlchemy模型使用 =来定义属性，并将类型作为参数传递给Column，例如：

name = Column(String)

虽然 Pydantic模型使用: 声明类型，但新的类型注释语法/类型提示是：

name: str

请牢记这一点，这样您在使用:还是=时就不会感到困惑。

1.5 CRUD工具 crud.py

从 sqlalchemy.orm中导入Session，这将允许您声明db参数的类型，并在您的函数中进行更好的类型检查和完成。

导入之前的models（SQLAlchemy 模型）和schemas（Pydantic模型/模式）。

from sqlalchemy.orm import Session

from . import models, schemas


def get_user(db: Session, user_id: int):
    return db.query(models.User).filter(models.User.id == user_id).first()

# 通过 ID 和电子邮件查询单个用户
def get_user_by_email(db: Session, email: str):
    return db.query(models.User).filter(models.User.email == email).first()

# 查询多个用户
def get_users(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.User).offset(skip).limit(limit).all()

def create_user(db: Session, user: schemas.UserCreate):
    fake_hashed_password = user.password + "notreallyhashed"
    # 使用您的数据创建一个 SQLAlchemy 模型实例。
    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
    # 使用add来将该实例对象添加到您的数据库。
    db.add(db_user)
    # 使用commit来对数据库的事务提交（以便保存它们）。
    db.commit()
    # 使用refresh来刷新您的数据库实例（以便它包含来自数据库的任何新数据，例如生成的 ID）。
    db.refresh(db_user)
    return db_user

# 查询多个项目
def get_items(db: Session, skip: int = 0, limit: int = 100):
    return db.query(models.Item).offset(skip).limit(limit).all()


def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
    db_item = models.Item(**item.dict(), owner_id=user_id)
    db.add(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item

1.6 主FastAPI应用程序 main.py

from typing import List

from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.orm import Session

from . import crud, models, schemas
from .database import SessionLocal, engine

# 1、创建数据库表
models.Base.metadata.create_all(bind=engine)

app = FastAPI()


# 2、创建依赖项
# Dependency
def get_db():
    # 我们需要每个请求有一个独立的数据库会话/连接（SessionLocal），
    # 在所有请求中使用相同的会话，然后在请求完成后关闭它。
    db = SessionLocal()
    # 我们的依赖项将创建一个新的 SQLAlchemy SessionLocal，
    # 它将在单个请求中使用，然后在请求完成后关闭它。
    try:
        yield db
    finally:
        db.close()

# 4、创建您的FastAPI 路径操作
# 3、db: Session = Depends(get_db) ：当在路径操作函数中使用依赖项时，我们使用Session，直接从 SQLAlchemy 导入的类型声明它。
@app.post("/users/", response_model=schemas.User)
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    db_user = crud.get_user_by_email(db, email=user.email)
    if db_user:
        raise HTTPException(status_code=400, detail="Email already registered")
    return crud.create_user(db=db, user=user)

# 4、创建您的FastAPI 路径操作
@app.get("/users/", response_model=List[schemas.User])
def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    users = crud.get_users(db, skip=skip, limit=limit)
    return users

# 4、创建您的FastAPI 路径操作
@app.get("/users/{user_id}", response_model=schemas.User)
def read_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id=user_id)
    if db_user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return db_user

# 4、创建您的FastAPI 路径操作
@app.post("/users/{user_id}/items/", response_model=schemas.Item)
def create_item_for_user(
    user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
):
    return crud.create_user_item(db=db, item=item, user_id=user_id)

# 4、创建您的FastAPI 路径操作
@app.get("/items/", response_model=List[schemas.Item])
def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    items = crud.get_items(db, skip=skip, limit=limit)
    return items

1.6 关于 def 对比 async def

在这里，我们在路径操作函数和依赖项中都使用着 SQLAlchemy 模型，它将与外部数据库进行通信。

这会需要一些“等待时间”。

但是由于 SQLAlchemy 不具有await直接使用的兼容性，因此类似于：

user = await db.query(User).first()

…相反，我们可以使用：

user = db.query(User).first()

然后我们应该声明路径操作函数和不带 的依赖关系async def，只需使用普通的def，如下：

@app.get("/users/{user_id}", response_model=schemas.User)
def read_user(user_id: int, db: Session = Depends(get_db)):
    db_user = crud.get_user(db, user_id=user_id)
    ...

如果您需要异步连接到关系数据库，请参阅Async SQL (Relational) Databases

如果您很好奇并且拥有深厚的技术知识，您可以在Async文档中查看有关如何处理 async def于def差别的技术细节。

1.7 执行项目

  • 在sql_app目录外执行
uvicorn sql_app.main:app --reload
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

在这里插入图片描述

2、FastAPI 对MySQL 数据库的操作（单文件级别）

(317条消息) FastAPI 对MySQL 数据库的操作(win64)_fastapi 连接mysql_梧钴的博客-CSDN博客

2.1 安装依赖

$ pip install sqlalchemy -i https://pypi.tuna.tsinghua.edu.cn/simple
$ pip install pymysql -i https://pypi.tuna.tsinghua.edu.cn/simple

2.2 测试连接

  • main.py
# 导入FastAPI模块
from fastapi import FastAPI
app = FastAPI()

# 1、连接mysql数据库需要导入pymysql模块
import pymysql
pymysql.install_as_MySQLdb()

# 2、配置数据库
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# 配置数据库地址：数据库类型+数据库驱动名称://用户名:密码@机器地址:端口号/数据库名
SQLALCHEMY_DATABASE_URL = "mysql://test:123456@127.0.0.1:3306/test"
engine = create_engine(SQLALCHEMY_DATABASE_URL, encoding='utf-8')

# 3、把当前的引擎绑定给这个会话；
# autocommit：是否自动提交 autoflush：是否自动刷新并加载数据库 bind：绑定数据库引擎
Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
# 实例化
session = Session()

# 4、创建Base实例
# declarative_base类维持了一个从类到表的关系，通常一个应用使用一个Base实例，所有实体类都应该继承此类对象
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()


# 5、创建数据库模型（定义表结构:表名称，字段名称以及字段类型）
from sqlalchemy import Column, String, Integer

class User(Base):
    # 定义表名
    __tablename__ = 'user'
    # 定义字段
    # primary_key=True 设置为主键
    userid = Column(Integer, primary_key=True)
    username = Column(String(255))

    # 构造函数
    def __init__(self, userid, username):
        self.userid = userid
        self.username = username

    # 打印形式
    def __str__(self):
        return "id:%s, name:%s" % (str(self.userid), self.username)


# 6、在数据库中生成表
Base.metadata.create_all(bind=engine)
  • 运行
$ uvicorn main:app --reload

2.3 增删改查代码

增

from pydantic import BaseModel
# 定义数据模型
class CreatUser(BaseModel):
    userid: int
    username: str

    def __str__(self):
        return "id：%s, name：%s" % (str(self.userid), self.username)

# 添加单个数据
@app.post("/user/addUser")
async def InserUser(user: CreatUser):
    try:
        # 添加数据
        dataUser = User(userid=user.userid, username=user.username)
        session.add(dataUser)
        session.commit()
        session.close()
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}
    return {"code": "0000", "message": "添加成功"}


from typing import List


# 添加多个数据
@app.post("/user/addUserList")
async def addUserList(*, user: List[CreatUser]):
    try:
        # user是一个列表，每个内部元素均为CreatUser类型
        for u in user:
            # 自定义的数据模型可以用.访问属性
            dataUser = User(userid=u.userid, username=u.username)
            session.add(dataUser)
        session.commit()
        session.close()
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}
    return {"code": "0000", "message": "添加成功"}

查

# 按照user_id查询
@app.get("/user/{user_id}")
async def queryUserByUserId(user_id: int):
    # 创建Query查询，filter是where条件，调用one返回唯一行，调用all则是返回所有行
    try:
        # one与first的区别：
        # one：要求结果集中只有一个结果；如果数据库返回0或2个或更多结果，并且将引发异常，则为错误。
        # first：返回可能更大的结果集中的第一个，如果没有结果，则返回None。不会引发异常。
        # filter_by与filter的区别：
        # filter_by接收的参数形式是关键字参数，而filter接收的参数是更加灵活的SQL表达式结构
        # user1 = session.query(User).filter_by(userid=user_id).first()
        user1 = session.query(User).filter(User.userid == user_id).first()
        session.close()
        # 由于user1只有一个值，所以它直接是一个字典
        if user1:
            return {"code": "0000", "message": "请求成功", "data": user1}
        else:
            return {"code": "0001", "message": "查询无结果"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}


## 查询所有
@app.get("/user/selectall/")
async def queryUserByUserId():
    # 创建Query查询，filter是where条件，调用one返回唯一行，调用all则是返回所有行
    try:
        user1 = session.query(User).all()
        session.close()
        # user1 是一个列表，内部元素为字典
        return {"code": "0000", "message": "请求成功", "data": user1}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}

删

# 根据user_id删除单个
@app.delete("/user/deleteUser/{user_id}")
async def deleteUser(user_id: int):
    try:
        user1 = session.query(User).filter(User.userid == user_id).first()
        if user1:
            session.delete(user1)
            session.commit()
            session.close()
            return {"code": "0000", "message": "删除成功"}
        else:
            return {"code": "0001", "message": "参数错误"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}


from typing import List


# 删除多个
@app.delete("/user/deleteUserList")
async def deleteUser(user_ids: List[int]):
    try:
        for user_id in user_ids:
            user1 = session.query(User).filter(User.userid == user_id).first()
            if user1:
                session.delete(user1)
                session.commit()
                session.close()
        return {"code": "0000", "message": "删除成功"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}

改

# 根据user_id修改user_name
@app.put("/user/updateUser/")
# 定义查询参数user_id和user_name
async def updateUser(user_id: int, user_name: str):
    try:
        user1 = session.query(User).filter(User.userid == user_id).first()
        print(user1)
        if user1:
            user1.username = user_name
            session.commit()
            session.close()
            return {"code": "0000", "message": "修改成功"}
        else:
            return {"code": "0001", "message": "参数错误"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}


# 方式2：
class AlterUser(BaseModel):
    userid: int
    username: str


@app.put("/user/updateUser01/")
async def deleteUser(user: AlterUser):
    try:
        user1 = session.query(User).filter(User.userid == user.userid).first()
        if user1:
            user1.username = user.username
            session.commit()
            session.close()
            return {"code": "0000", "message": "修改成功"}
        else:
            return {"code": "0001", "message": "参数错误"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}

完整代码

# 导入FastAPI模块
from fastapi import FastAPI
app = FastAPI()

# 1、连接mysql数据库需要导入pymysql模块
import pymysql
pymysql.install_as_MySQLdb()

# 2、配置数据库
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# 配置数据库地址：数据库类型+数据库驱动名称://用户名:密码@机器地址:端口号/数据库名
SQLALCHEMY_DATABASE_URL = "mysql://test:123456@127.0.0.1:3306/test"
engine = create_engine(SQLALCHEMY_DATABASE_URL, encoding='utf-8')

# 3、把当前的引擎绑定给这个会话；
# autocommit：是否自动提交 autoflush：是否自动刷新并加载数据库 bind：绑定数据库引擎
Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
# 实例化
session = Session()

# 4、创建Base实例
# declarative_base类维持了一个从类到表的关系，通常一个应用使用一个Base实例，所有实体类都应该继承此类对象
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()


# 5、创建数据库模型（定义表结构:表名称，字段名称以及字段类型）
from sqlalchemy import Column, String, Integer

class User(Base):
    # 定义表名
    __tablename__ = 'user'
    # 定义字段
    # primary_key=True 设置为主键
    userid = Column(Integer, primary_key=True)
    username = Column(String(255))

    # 构造函数
    def __init__(self, userid, username):
        self.userid = userid
        self.username = username

    # 打印形式
    def __str__(self):
        return "id:%s, name:%s" % (str(self.userid), self.username)


# 6、在数据库中生成表
Base.metadata.create_all(bind=engine)

# 【增】
from pydantic import BaseModel
# 定义数据模型
class CreatUser(BaseModel):
    userid: int
    username: str

    def __str__(self):
        return "id：%s, name：%s" % (str(self.userid), self.username)

# 添加单个
@app.post("/user/addUser")
async def InserUser(user: CreatUser):
    try:
        # 添加数据
        dataUser = User(userid=user.userid, username=user.username)
        session.add(dataUser)
        session.commit()
        session.close()
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}
    return {"code": "0000", "message": "添加成功"}


from typing import List


# 添加多个
@app.post("/user/addUserList")
async def addUserList(*, user: List[CreatUser]):
    try:
        # user是一个列表，每个内部元素均为CreatUser类型
        for u in user:
            # 自定义的数据模型可以用.访问属性
            dataUser = User(userid=u.userid, username=u.username)
            session.add(dataUser)
        session.commit()
        session.close()
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}
    return {"code": "0000", "message": "添加成功"}


# 【查】

# 按照user_id查询
@app.get("/user/{user_id}")
async def queryUserByUserId(user_id: int):
    # 创建Query查询，filter是where条件，调用one返回唯一行，调用all则是返回所有行
    try:
        # one与first的区别：
        # one：要求结果集中只有一个结果；如果数据库返回0或2个或更多结果，并且将引发异常，则为错误。
        # first：返回可能更大的结果集中的第一个，如果没有结果，则返回None。不会引发异常。
        # filter_by与filter的区别：
        # filter_by接收的参数形式是关键字参数，而filter接收的参数是更加灵活的SQL表达式结构
        # user1 = session.query(User).filter_by(userid=user_id).first()
        user1 = session.query(User).filter(User.userid == user_id).first()
        session.close()
        # 由于user1只有一个值，所以它直接是一个字典
        if user1:
            return {"code": "0000", "message": "请求成功", "data": user1}
        else:
            return {"code": "0001", "message": "查询无结果"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}


## 查询所有
@app.get("/user/selectall/")
async def queryUserByUserId():
    # 创建Query查询，filter是where条件，调用one返回唯一行，调用all则是返回所有行
    try:
        user1 = session.query(User).all()
        session.close()
        # user1 是一个列表，内部元素为字典
        return {"code": "0000", "message": "请求成功", "data": user1}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库异常"}


#【删】

# 根据user_id删除单个
@app.delete("/user/deleteUser/{user_id}")
async def deleteUser(user_id: int):
    try:
        user1 = session.query(User).filter(User.userid == user_id).first()
        if user1:
            session.delete(user1)
            session.commit()
            session.close()
            return {"code": "0000", "message": "删除成功"}
        else:
            return {"code": "0001", "message": "参数错误"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}


from typing import List


## 删除多个
@app.delete("/user/deleteUserList")
async def deleteUser(user_ids: List[int]):
    try:
        for user_id in user_ids:
            user1 = session.query(User).filter(User.userid == user_id).first()
            if user1:
                session.delete(user1)
                session.commit()
                session.close()
        return {"code": "0000", "message": "删除成功"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}


# 【改】

## 根据user_id修改user_name
@app.put("/user/updateUser/")
# 定义查询参数user_id和user_name
async def updateUser(user_id: int, user_name: str):
    try:
        user1 = session.query(User).filter(User.userid == user_id).first()
        print(user1)
        if user1:
            user1.username = user_name
            session.commit()
            session.close()
            return {"code": "0000", "message": "修改成功"}
        else:
            return {"code": "0001", "message": "参数错误"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}


# 方式2：
class AlterUser(BaseModel):
    userid: int
    username: str


@app.put("/user/updateUser01/")
async def deleteUser(user: AlterUser):
    try:
        user1 = session.query(User).filter(User.userid == user.userid).first()
        if user1:
            user1.username = user.username
            session.commit()
            session.close()
            return {"code": "0000", "message": "修改成功"}
        else:
            return {"code": "0001", "message": "参数错误"}
    except ArithmeticError:
        return {"code": "0002", "message": "数据库错误"}

运行测试

uvicorn main:app --reload

在这里插入图片描述

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

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

相关文章

每天进步一点点，今天来学结构体

每天进步一点点，今天来学结构体

什么是结构体？ C 语言允许用户自己指定这样一种数据结构，它由不同类型的数据组合成一个整体，以便引用，这些组合在一个整体中的数据是互相联系的，这样的数据结构称为结构体，它相当于其它高级语言中记录。 …
阅读更多...
01、数据结构——数组

01、数据结构——数组

一、数据结构与算法 数据结构是一门研究组织数据方式的学科，有了编程语言也就有了数据结构。学好数据结构可以编写出更加漂亮、更加有效率的代码。程序数据结构算法数据结构是算法的基础 二、稀疏数组： 1、基本介绍： 当一个数组中大部分元…
阅读更多...
【Javascript】文本转语音SpeechSynthesisUtterance

【Javascript】文本转语音SpeechSynthesisUtterance

SpeechSynthesisUtterance基本介绍 SpeechSynthesisUtterance是HTML5中新增的API,用于将指定文字合成为对应的语音.也包含一些配置项,指定如何去阅读(语言,音量,音调)等 SpeechSynthesisUtterance基本属性 SpeechSynthesisUtterance.lang 获取并设置话语的语言 SpeechSynthesis…
阅读更多...
InfluxDB 笔记

InfluxDB 笔记

概念 Measurement 类似于表名。 A measurement acts as a container for tags, fields, and timestamps. Tag 补充描述数据的信息，如示例中的location和scientist描述了该数据的采集地和采集人。这两个称为Tag Key，具体的值则称为Tag Value&#xff0c…
阅读更多...
小程序基础篇-视图与逻辑

小程序基础篇-视图与逻辑

本次学习目标&#xff1a;实现页面间的导航跳转实现下拉刷新实现上拉加载更多知道小程序常用的生命周期函数1.页面导航页面导航指的是页面之前相互的跳转浏览器之间的页面导航有两种&#xff1a;<a>;location.href小程序之间的页面导航有两种&#xff1a;声明式导航&…
阅读更多...
告警与恢复告警原理及实现

告警与恢复告警原理及实现

一、 背景自“双碳”政策提出以来&#xff0c;KaiwuDB 聚焦“数字能源”领域&#xff0c;为用户打造数字能源管理平台&#xff0c;旨在提升综合能源和碳资产管理能力。数字能源管理平台是以 KaiwuDB 为核心建设的云-边-端一体化数据服务平台&#xff0c;致力于为 IoT、工业互联…
阅读更多...
前言技术--swagger

前言技术--swagger

目录一、前后端分离的特点二、在没有swagger之前三、swagger的作用四、swagger的优点五、集成swagger5.1 新建springboot项目5.2 集成swagger5.3 开发一个controller用于测试5.4 启动服务&#xff0c;验证集成效果六、swagger常用注解七、swagger使用综合案例一、前后端分离的特…
阅读更多...
Python的PyQt框架的使用-常用控件篇

Python的PyQt框架的使用-常用控件篇

Python的PyQt框架的使用-常用控件篇一、前言二 、QLineEdit 文本框三 、QPushButton按钮控件四、QRadioButton 单选按钮一、前言 个人主页: ζ小菜鸡大家好我是ζ小菜鸡&#xff0c;小伙伴们&#xff0c;让我们一起来学习Python的PyQt框架的常用控件。如果文章对你有帮助、欢迎…
阅读更多...
第一个程序——构建一个ServerUI

第一个程序——构建一个ServerUI

简介 本次程序设计均使用python实现&#xff0c;使用sql server对聊天室用户的数据进行存储。通过python socket套接字编程&#xff0c;实现了在线聊天室的功能&#xff0c;并使用python tkinter进行UI界面的设计。 思路 由计算机网络的基础知识易知&#xff0c;两个主机之间…
阅读更多...
基于LSTMGRU的微博突发事件分析与谣言检测(附完整的代码+报告)

基于LSTMGRU的微博突发事件分析与谣言检测(附完整的代码+报告)

问题描述及方法基础 本章主要对课题研究所涉及的机器学习、自然语言处理的原理和方法进行介绍，主要分为四部分，第一部分是将本课谣言检测任务的符号化描述；第二部分是微博数据的预处理，包括语言模型、文本分词等技术；第三部分与第四部分分别是本文搭建的微博谣言检测模型所…
阅读更多...
py字符串的格式化笔记

py字符串的格式化笔记

print():和cjava差不多&#xff0c;只是逗号变了&#xff0c;其中 %s 就是模板中的占位符&#xff0c;表示这个位置先占着&#xff0c;待会儿要有数据填入到这里。然后再提供一个元组&#xff0c;里面依次存放需要填入到 %s 位置 的数据。这里是使用变量 (salary,tax,aftertax)…
阅读更多...
CSS.前端基础.html

CSS.前端基础.html

什么是 CSS? CSS 指层叠样式表 (Cascading Style Sheets)样式定义如何显示 HTML 元素样式通常存储在样式表中把样式添加到 HTML 4.0 中&#xff0c;是为了解决内容与表现分离的问题外部样式表可以极大提高工作效率外部样式表通常存储在 CSS 文件中多个样式定义可层叠为一个示…
阅读更多...
丝绸之路也可以是科技传播之路

丝绸之路也可以是科技传播之路

唐宋元海外贸易 618年-1368年 王孝通 生卒年代不详 孙思邈541年—682年 一行 公元683年-公元727年 李淳风 602年&#xff0d;670年 沈括 1031年&#xff0d;1095年 郭守敬 1231年&#xff0d;1316年 扎马鲁丁生卒年代不详 阿拉伯帝国 632年-1258年 阿尔花拉子模 780年&#xf…
阅读更多...
【深度强化学习】【论文阅读】【双臂模仿】Deep Imitation Learning for BimanualRobotic Manipulation

【深度强化学习】【论文阅读】【双臂模仿】Deep Imitation Learning for BimanualRobotic Manipulation

title: Deep Imitation Learning for BimanualRobotic Manipulation date: 2023-01-15T20:54:56Z lastmod: 2023-01-19T18:31:57Z Deep Imitation Learning for BimanualRobotic Manipulation 1 Introduction 文中使用的模型是一个深度的、分层的、模块化的架构。与 baselin…
阅读更多...
微服务负载均衡器Ribbon学习笔记

微服务负载均衡器Ribbon学习笔记

目录 1.什么是Ribbon 1.1 客户端的负载均衡 1.2 服务端的负载均衡 1.3 常见负载均衡算法 2. Nacos使用Ribbon 3. Ribbon负载均衡策略 4.修改默认负载均衡策略 方式1&#xff1a;通过自定义配置类来实现 方式2&#xff1a;通过修改配置文件实现&#xff08;推荐&#xf…
阅读更多...
9、jQuery

9、jQuery

jQuery库&#xff1a;里面存在大量的JavaScript函数 官网&#xff1a;https://jquery.com/ 9.1 获取jQuery jQuery引入 cdn 引入 <script src"https://cdn.bootcss.com/jquery/3.4.1/core.js"></script>本地引入 <script src"lib/jquery-3.6.3.…
阅读更多...
C语言练习——3

C语言练习——3

C语言练习——3一、 操作符练习1.1交换两个变量&#xff08;不创建临时变量&#xff09;1.2 打印整数二进制的奇数位和偶数位1.3[二进制中1的个数](https://www.nowcoder.com/questionTerminal/8ee967e43c2c4ec193b040ea7fbb10b8)1.4[两个整数二进制位不同个数](https://www.no…
阅读更多...
【 java 反射下篇】java反射机制不难吧？来看看这篇

【 java 反射下篇】java反射机制不难吧？来看看这篇

&#x1f4cb; 个人简介 &#x1f496; 作者简介&#xff1a;大家好&#xff0c;我是阿牛&#xff0c;全栈领域优质创作者。&#x1f61c;&#x1f4dd; 个人主页&#xff1a;馆主阿牛&#x1f525;&#x1f389; 支持我&#xff1a;点赞&#x1f44d;收藏⭐️留言&#x1f4d…
阅读更多...
Element Plus 跟踪表格数据总数，包括查询、筛选等操作

Element Plus 跟踪表格数据总数，包括查询、筛选等操作

前言 Element Plus的表格组件提供了筛选功能 前端项目中&#xff0c;如果表格使用的是后端分页&#xff0c;使用表格插件及分页器插件就可以了。这种情况下&#xff0c;前端的表格筛选被后端的分页条件查询取代了 另一种情况&#xff1a;不分页&#xff0c;直接查询所有数据…
阅读更多...
Win7快速部署weblogic 12c

Win7快速部署weblogic 12c

0x00 前言 需要一个漏洞中等数量的版本。 0x01 安装环境 版本操作系统Windows 7 64bitJDKjdk-8u101-windows-x64weblogic12.2.1.3 0x02 下载地址 JDK 下载地址 https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html jdk 1.8版本&#xff0c;文…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023