随记-SQLAlchemy ORM 梳理

随记

最近在使用 SQLAlchemy 2.0 的过程中，有一些不适应的地方，所以想梳理一下 SQLAlchemy ORM 的使用。
关于旧版的使用以及其他信息请参考另一篇文章Flask 初探七, 这里就不过多赘述，直接进入主题。

One To Many

单向

官方版本

class Parent(Base):__tablename__ = "parent_table"id: Mapped[int] = mapped_column(primary_key=True)# TODO relationship()# Parent --> Childchildren: Mapped[List["Child"]] = relationship()class Child(Base):__tablename__ = "child_table"id: Mapped[int] = mapped_column(primary_key=True)parent_id: Mapped[int] = mapped_column(ForeignKey("parent_table.id"))
CompanyToApp

class CompanyInfoModel(db.Model):__tablename__ = "company_info"__table_args__ = {"comment": "公司表"}code = mapped_column(String(200), comment="公司编码", nullable=False, index=True)name = mapped_column(String(200), comment="公司名", nullable=False, index=True)detail = mapped_column(String(500), comment="描述", default="", nullable=False)# 官方版本使用 Mapped[List["AppInfoModel"]] 指定类型# app:Mapped[List["AppInfoModel"]] = relationship(back_populates="company")# 为了和上面的code、name 形式同一，我使用了下面这种方式，# TODO　单向绑定 company --> appapp = relationship("AppInfoModel")class AppInfoModel(db.Model):__tablename__ = "app_info"__table_args__ = {"comment": "应用表"}name = mapped_column(String(100), comment="应用名", nullable=False, index=True)secret = mapped_column(String(200), comment="secret", nullable=False, index=True)detail = mapped_column(String(500), comment="描述", default="", nullable=False)# 官方版本# company_id:Mapped[BIGINT] = mapped_column(ForeignKey("company_info.id"), index=True)# 单向绑定 或者 双向绑定，ForeignKey 是不变的company_id = mapped_column(BIGINT, ForeignKey("company_info.id"), index=True)

双向

官方版本

class Parent(Base):__tablename__ = "parent_table"id: Mapped[int] = mapped_column(primary_key=True)# TODO relationship(back_populates="parent")# 双向绑定，在 Parent 使用 back_populates 指定 Child 的属性 parentchildren: Mapped[List["Child"]] = relationship(back_populates="parent")class Child(Base):__tablename__ = "child_table"id: Mapped[int] = mapped_column(primary_key=True)# ForeignKey 是不变的parent_id: Mapped[int] = mapped_column(ForeignKey("parent_table.id"))# 双向绑定，在 Child 增加 Parent 类型的属性 parent ，通过 back_populates 关联 childrenparent: Mapped["Parent"] = relationship(back_populates="children")
CompanyToApp

class CompanyInfoModel(db.Model):__tablename__ = "company_info"__table_args__ = {"comment": "公司表"}code = mapped_column(String(200), comment="公司编码", nullable=False, index=True)name = mapped_column(String(200), comment="公司名", nullable=False, index=True)detail = mapped_column(String(500), comment="描述", default="", nullable=False)# 双向绑定app = relationship("AppInfoModel", back_populates="company")class AppInfoModel(db.Model):__tablename__ = "app_info"__table_args__ = {"comment": "应用表"}name = mapped_column(String(100), comment="应用名", nullable=False, index=True)secret = mapped_column(String(200), comment="secret", nullable=False, index=True)detail = mapped_column(String(500), comment="描述", default="", nullable=False) # 单向绑定 或者 双向绑定，ForeignKey 是不变的company_id = mapped_column(BIGINT, ForeignKey("company_info.id"), index=True)# 双向绑定company = relationship("CompanyInfoModel", back_populates="app")

小结

  • ForeignKey 在多的一方
  • 不管单向还是双向 ForeignKey 都是必须的
  • 单向绑定：多的一方使用 relationship 即可，双向绑定需要 relationship + back_populates
  • 双向绑定：
    • 在类 CompanyInfoModel 增加类型为 AppInfoModel 的属性 app
    • 在类 AppInfoModel 增加类型为 CompanyInfoModel 的属性 company
    • 使用 back_populates 指向关联类的 关联属性
      • CompanyInfoModel.app --> AppInfoModel.company --> CompanyInfoModel
      • AppInfoModel.company --> CompanyInfoModel.app = AppInfoModel

Many To Many 间接

间接单向

官方

from typing import Optionalfrom sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import relationshipclass Base(DeclarativeBase):passclass Association(Base):__tablename__ = "association_table"left_id: Mapped[int] = mapped_column(ForeignKey("left_table.id"), primary_key=True)right_id: Mapped[int] = mapped_column(ForeignKey("right_table.id"), primary_key=True)extra_data: Mapped[Optional[str]]child: Mapped["Child"] = relationship()class Parent(Base):__tablename__ = "left_table"id: Mapped[int] = mapped_column(primary_key=True)children: Mapped[List["Association"]] = relationship()class Child(Base):__tablename__ = "right_table"id: Mapped[int] = mapped_column(primary_key=True)
UserGroup2User

class UserUserGroupRelateModel(db.Model):__tablename__ = "user_usergroup_relate"__table_args__ = {"comment": "User_UserGroup_关联表"}user_id = mapped_column(ForeignKey("user_info.id"), primary_key=True, index=True)user_group_id = mapped_column(ForeignKey("user_group_info.id"), primary_key=True, index=True) # 多对多 单向 官方# relate_user:Mapped[List["UserInfoModel"]] = relationship()# 多对多 单向 UserUserGroupRelateModel.relate_user 是 UserInfoModel 类型# UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user --> UserInfoModelrelate_user = relationship("UserInfoModel")class UserGroupInfoModel(db.Model):__tablename__ = "user_group_info"__table_args__ = {"comment": "用户组表"}name = mapped_column(String(100), comment="用户组 组名", nullable=False, index=True) # 多对多 间接 单向 官方# users_relate:Mapped[List["UserUserGroupRelateModel"]] = relationship()# 多对多 单向 UserGroupInfoModel.users_relate 是 UserUserGroupRelateModel 类型# UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user --> UserInfoModelusers_relate = relationship("UserUserGroupRelateModel")class UserInfoModel(db.Model):__tablename__ = "user_info"__table_args__ = {"comment": "用户表"}code = mapped_column(String(200), comment="用户编码", nullable=False, index=True)name = mapped_column(String(100), comment="用户名", nullable=False, index=True)phone = mapped_column(String(100), comment="手机号", nullable=False, default="")email = mapped_column(String(100), comment="电子邮件", nullable=False, default="")

间接双向

官方
from typing import Optionalfrom sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy.orm import Mapped
from sqlalchemy.orm import mapped_column
from sqlalchemy.orm import DeclarativeBase
from sqlalchemy.orm import relationshipclass Base(DeclarativeBase):passclass Association(Base):__tablename__ = "association_table"left_id: Mapped[int] = mapped_column(ForeignKey("left_table.id"), primary_key=True)right_id: Mapped[int] = mapped_column(ForeignKey("right_table.id"), primary_key=True)extra_data: Mapped[Optional[str]]child: Mapped["Child"] = relationship(back_populates="parents")parent: Mapped["Parent"] = relationship(back_populates="children")class Parent(Base):__tablename__ = "left_table"id: Mapped[int] = mapped_column(primary_key=True)children: Mapped[List["Association"]] = relationship(back_populates="parent")class Child(Base):__tablename__ = "right_table"id: Mapped[int] = mapped_column(primary_key=True)parents: Mapped[List["Association"]] = relationship(back_populates="child")
UserGroup2User
class UserUserGroupRelateModel(db.Model):__tablename__ = "user_usergroup_relate"__table_args__ = {"comment": "User_UserGroup_关联表"}user_id = mapped_column(ForeignKey("user_info.id"), primary_key=True, index=True)user_group_id = mapped_column(ForeignKey("user_group_info.id"), primary_key=True, index=True) # 多对多 间接双向 官方# relate_user:Mapped["UserInfoModel"] = relationship(back_populates="groups_relate")# relate_user_group:Mapped["UserGroupInfoModel"] = relationship(back_populates="users_relate") # 多对多 间接单向 UserUserGroupRelateModel.relate_user 是 UserInfoModel 类型relate_user = relationship("UserInfoModel", back_populates="groups_relate")relate_user_group = relationship("UserGroupInfoModel", back_populates="users_relate")class UserGroupInfoModel(db.Model):__tablename__ = "user_group_info"__table_args__ = {"comment": "用户组表"}name = mapped_column(String(100), comment="用户组 组名", nullable=False, index=True) # 多对多 间接双向 官方# users_relate:Mapped[List["UserUserGroupRelateModel"]] = relationship(back_populates="relate_user_group")# 多对多 间接双向 # 间接双向 约等于 两个单向# UserGroupInfoModel.users_relate 是 UserUserGroupRelateModel 类型# UserUserGroupRelateModel.relate_user_group 是 UserGroupInfoModel 类型# UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user_group --> UserGroupInfoModelusers_relate = relationship("UserUserGroupRelateModel", back_populates="relate_user_group")class UserInfoModel(db.Model):__tablename__ = "user_info"__table_args__ = {"comment": "用户表"}code = mapped_column(String(200), comment="用户编码", nullable=False, index=True)name = mapped_column(String(100), comment="用户名", nullable=False, index=True)phone = mapped_column(String(100), comment="手机号", nullable=False, default="")email = mapped_column(String(100), comment="电子邮件", nullable=False, default="")# 多对多 间接双向 官方# groups_relate:Mapped[List["UserUserGroupRelateModel"]] = relationship(back_populates="relate_user")# 多对多 间接双向 # 间接双向 约等于 两个单向# UserInfoModel.groups_relate 是 UserUserGroupRelateModel 类型# UserUserGroupRelateModel.relate_user 是 UserInfoModel 类型# UserInfoModel.groups_relate --> UserUserGroupRelateModel.relate_user --> UserInfoModelgroups_relate = relationship("UserUserGroupRelateModel", back_populates="relate_user")

间接（关联对象） 小结

  • 多对多需要借助第三方 UserUserGroupRelateModel
  • 单向只需要 relationship，双向需要 relationship + back_populates
  • 多对多的单向，单向只需要 relationship
    • 在类 UserGroupInfoModel 增加类型为 UserUserGroupRelateModel 的属性 users_relate
    • 在类 UserUserGroupRelateModel 增加类型为 UserInfoModel 的属性 relate_user
    • UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user -->UserInfoModel
  • 多对多的双向
    • UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user --> UserInfoModel
      • 在类 UserGroupInfoModel 增加类型为 UserUserGroupRelateModel 的属性 users_relate
      • 在类 UserUserGroupRelateModel 增加类型为 UserInfoModel 的属性 relate_user
    • UserInfoModel.groups_relate --> UserUserGroupRelateModel.relate_user_group --> UserGroupInfoModel
      • 在类 UserInfoModel 增加类型为 UserUserGroupRelateModel 的属性 groups_relate
      • 在类 UserUserGroupRelateModel 增加类型为 UserGroupInfoModel 的属性 relate_user_group
    • 通过 back_populates 关联对应类型的 关联属性
      • UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user_group --> UserGroupInfoModel
        • 类 UserGroupInfoModel的属性 users_relate 是 UserUserGroupRelateModel 类型
        • 类 UserUserGroupRelateModel的属性 relate_user_group 是 UserGroupInfoModel 类型
      • UserInfoModel.groups_relate --> UserUserGroupRelateModel.relate_user --> UserInfoModel
        • 类 UserInfoModel的属性 groups_relate 是 UserUserGroupRelateModel 类型
        • 类 UserUserGroupRelateModel的属性 relate_user 是 UserInfoModel 类型

Many To Many 间接 + 直接

Many To Many 直接


class UserUserGroupRelateModel(db.Model):__tablename__ = "user_usergroup_relate"__table_args__ = {"comment": "User_UserGroup_关联表"}user_id = mapped_column(ForeignKey("user_info.id"), primary_key=True, index=True)user_group_id = mapped_column(ForeignKey("user_group_info.id"), primary_key=True, index=True) class UserGroupInfoModel(db.Model):__tablename__ = "user_group_info"__table_args__ = {"comment": "用户组表"}name = mapped_column(String(100), comment="用户组 组名", nullable=False, index=True) # # 多对多 双向绑定 官方# user:Mapped[List["UserInfoModel"]] = relationship(secondary="user_usergroup_relate", back_populates="group")# 多对多 双向直接user = relationship("UserInfoModel",secondary="user_usergroup_relate", back_populates="group")class UserInfoModel(db.Model):__tablename__ = "user_info"__table_args__ = {"comment": "用户表"}code = mapped_column(String(200), comment="用户编码", nullable=False, index=True)name = mapped_column(String(100), comment="用户名", nullable=False, index=True)phone = mapped_column(String(100), comment="手机号", nullable=False, default="")email = mapped_column(String(100), comment="电子邮件", nullable=False, default="")# # 多对多 双向直接 官方# group:Mapped[List["UserGroupInfoModel"]] = relationship(secondary="user_usergroup_relate", back_populates="user")# 多对多 双向直接group = relationship("UserGroupInfoModel", secondary="user_usergroup_relate", back_populates="user")

Many To Many 间接+直接

    
class UserUserGroupRelateModel(db.Model):__tablename__ = "user_usergroup_relate"__table_args__ = {"comment": "User_UserGroup_关联表"}user_id = mapped_column(ForeignKey("user_info.id"), primary_key=True, index=True)user_group_id = mapped_column(ForeignKey("user_group_info.id"), primary_key=True, index=True) # 多对多 间接双向 relate_user = relationship("UserInfoModel", back_populates="groups_relate")relate_user_group = relationship("UserGroupInfoModel", back_populates="users_relate")class UserGroupInfoModel(db.Model):__tablename__ = "user_group_info"__table_args__ = {"comment": "用户组表"}name = mapped_column(String(100), comment="用户组 组名", nullable=False, index=True) # 多对多 间接双向 users_relate = relationship("UserUserGroupRelateModel", back_populates="relate_user_group")# 多对多 双向直接user_list = relationship("UserInfoModel",secondary="user_usergroup_relate", back_populates="group_list")class UserInfoModel(db.Model):__tablename__ = "user_info"__table_args__ = {"comment": "用户表"}code = mapped_column(String(200), comment="用户编码", nullable=False, index=True)name = mapped_column(String(100), comment="用户名", nullable=False, index=True)phone = mapped_column(String(100), comment="手机号", nullable=False, default="")email = mapped_column(String(100), comment="电子邮件", nullable=False, default="")# 多对多 间接双向 groups_relate = relationship("UserUserGroupRelateModel", back_populates="relate_user")# 多对多 双向直接group_list = relationship("UserGroupInfoModel", secondary="user_usergroup_relate", back_populates="user_list")

小结

  • 直接 或者 间接都必须存在第三方 UserUserGroupRelateModel
    • 直接：可以跳过第三方，直接关联另一方
      • UserGroupInfoModel.user_list[0] --> UserInfoModel
        • 类 UserGroupInfoModel的属性 user_list （的每一项都）是 UserInfoModel 类型
      • UserInfoModel.group_list[0] --> UserGroupInfoModel
        • 类 UserInfoModel的属性 group_list 是 UserGroupInfoModel 类型
      • back_populates 关联另一方的 关联属性
        • UserGroupInfoModel.user_list back_populates UserInfoModel.group_list
        • UserInfoModel.group_list back_populates UserGroupInfoModel.user_list
    • 间接：必须通过第三方才能获取另一方
      • UserGroupInfoModel.users_relate --> UserUserGroupRelateModel.relate_user --> UserInfoModel
      • UserInfoModel.groups_relate --> UserUserGroupRelateModel.relate_user_group --> UserGroupInfoModel
  • 两者存在冲突，即通过直接方式修改的数据，在同一个session 里没办法同步到间接，反之亦然。

    When using this ORM model to make changes, changes made to Parent.children will not be coordinated with changes made to Parent.child_associations or Child.parent_associations in Python; while all of these relationships will continue to function normally by themselves, changes on one will not show up in another until the Session is expired, which normally occurs automatically after Session.commit().

    Additionally, if conflicting changes are made, such as adding a new Association object while also appending the same related Child to Parent.children, this will raise integrity errors when the unit of work flush process proceeds.

  • 如果关联对象没有特殊的属性，建议选择直接方式
    • 直接方式的 model 只需要在两个多方添加属性
    • 访问数据是可以直接跳过 第三方 ，直接得到另一方的列表 UserGroupInfoModel.user_list
    • 避免存在直接+间接时可能造成的影响

Source Code

到此结  DragonFangQy 2023.12.25

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

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

相关文章

linux下docker搭建mysql8

linux下docker搭建mysql8

1：环境信息 centos 7,mysql8 安装docker环境 2.创建mysql容器 2.1 拉取镜像 docker pull mysql:8.0.23 2.2 查询镜像拉取成功 docker images 2.3 创建挂载的目录文件 mkdir /usr/mysql8/conf mkdir /usr/mysql8/data ##给data文件赋予操作权限 chmod 777 /…
阅读更多...
mfc100u.dll文件丢失了要怎么解决？修复mfc100u.dll详细指南

mfc100u.dll文件丢失了要怎么解决？修复mfc100u.dll详细指南

mfc100u.dll文件丢失了要怎么解决?首先让我们扒一扒什么是 mfc100u.dll。这玩意儿是 Microsoft Visual Studio 2010 的一部分，它就像一款程序生活中不可或缺的零件，没了它，程序肯定跑不起来。想想看，没有一个重要的零件&#xff…
阅读更多...
DOA估计算法——迭代自适应算法(IAA)

DOA估计算法——迭代自适应算法(IAA)

1 简介 迭代自适应法 (Iterative Adaptive Approach，IAA)估计算法最早由美国的电气工程师和数学家Robert Schmidt和Roy A. Kuc在1986年的一篇论文"Multiple Emitter Location and Signal Parameter Estimation"中首次提出了这一算法， IAA DOA …
阅读更多...
jQuery显示，切换，隐藏的使用练习

jQuery显示，切换，隐藏的使用练习

<!DOCTYPE html> <html> <head lang"en"><meta charset"UTF-8"><title>标题</title><style>div {width: 200px;height: 200px;background-color: red;display: none;}</style> </head> <body>…
阅读更多...
thinkphp+vue+mysql企业车辆管理系统m117l

thinkphp+vue+mysql企业车辆管理系统m117l

“企业车辆管理系统”是运用php语言和vue框架&#xff0c;以Mysql数据库为基础而发出来的。为保证我国经济的持续性发展&#xff0c;必须要让互联网信息时代在我国日益壮大&#xff0c;蓬勃发展。伴随着信息社会的飞速发展&#xff0c;企业车辆管理系统所面临的问题也一个接一个…
阅读更多...
提升效率：使用注解实现精简而高效的Spring开发

提升效率：使用注解实现精简而高效的Spring开发

IOC/DI注解开发 1.0 环境准备1.1 注解开发定义bean步骤1:删除原XML配置步骤2:Dao上添加注解步骤3:配置Spring的注解包扫描步骤4&#xff1a;运行程序步骤5:Service上添加注解步骤6:运行程序知识点1:Component等 1.2 纯注解开发模式1.2.1 思路分析1.2.2 实现步骤步骤1:创建配置类…
阅读更多...
SpringBoot整合Canal

SpringBoot整合Canal

一 linux docker compose版本 1.第一步&#xff1a;基础环境 &#xff08;1&#xff09;第1步&#xff1a;安装jak、maven、git、nodejs、npm yum install maven mvn -v 安装maven时会帮安装jdkyum install git git --version 2.27.0yum in…
阅读更多...
import_module() 函数的理解

import_module() 函数的理解

importlib 模块中的 import_module 函数用于动态导入模块。它返回导入的模块对象&#xff0c;允许你在运行时按需加载模块。 示例代码如下&#xff1a; import importlib# 指定要导入的模块的名称 module_name math# 使用 import_module 函数动态导入模块 imported_module …
阅读更多...
基于SpringBoot的新能源充电系统

基于SpringBoot的新能源充电系统

文章目录 项目介绍主要功能截图：部分代码展示设计总结项目获取方式🍅 作者主页：超级无敌暴龙战士塔塔开 🍅 简介：Java领域优质创作者🏆、 简历模板、学习资料、面试题库【关注我，都给你】 🍅文末获取源码联系🍅 项目介绍 基于SpringBoot的新能源充电系统,java项…
阅读更多...
C语言不常用小tip

C语言不常用小tip

#include <stdio.h> #define S(x) 3 < (x) < 5 int a, n;void f1(int n) { for(; n > 0; n--){if(n % 2 ! 0) continue;printf("%d ", n); /*%d后面有1个空格*/}printf("\n"); }double f2(double x, int n) { if(n 1) retur…
阅读更多...
【C++】开源：libev事件循环库配置使用

【C++】开源：libev事件循环库配置使用

&#x1f60f;★,:.☆(&#xffe3;▽&#xffe3;)/$:.★ &#x1f60f; 这篇文章主要介绍libev事件循环库配置使用。 无专精则不能成&#xff0c;无涉猎则不能通。——梁启超 欢迎来到我的博客&#xff0c;一起学习&#xff0c;共同进步。 喜欢的朋友可以关注一下&#xff0c…
阅读更多...
Java EE Servlet之Servlet API详解

Java EE Servlet之Servlet API详解

文章目录 1. HttpServlet1.1 核心方法 2. HttpServletRequest3. HttpServletResponse 接下来我们来学习 Servlet API 里面的详细情况 1. HttpServlet 写一个 Servlet 代码&#xff0c;都是要继承这个类&#xff0c;重写里面的方法 Servlet 这里的代码&#xff0c;只需要继承…
阅读更多...
代码随想录 123. 买卖股票的最佳时机 III

代码随想录 123. 买卖股票的最佳时机 III

题目 给定一个数组&#xff0c;它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。 注意&#xff1a;你不能同时参与多笔交易&#xff08;你必须在再次购买前出售掉之前的股票&#xff09;。 示例 1: 输入…
阅读更多...
企业如何做好内容？媒介盒子分享

企业如何做好内容？媒介盒子分享

在个性化算法的支持下&#xff0c;企业通过创作优质内容使消费者主动选择企业的时代已经来临&#xff0c;对于中小企业来说&#xff0c;这是能够低成本进行营销的好机会。但是有许多企业对内容的理解依旧是片面的&#xff0c;今天媒介盒子就来和大家聊聊&#xff1a;企业如何做…
阅读更多...
Java中final、finally和finalize方法的区别

Java中final、finally和finalize方法的区别

简而言之&#xff0c;final关键字可以与变量、方法和类一起使用&#xff0c;并且对它们都有不同的含义。finally是另一个 Java 关键字&#xff0c;与try 、catch 、throw 和 throws一起用于异常处理。Finalize()是 Java 中的一个特殊方法&#xff0c;垃圾收集器在回收符合 GC 条…
阅读更多...
Spring-5-切入点的高级使用

Spring-5-切入点的高级使用

Spring提供了两个额外的Pointcut实现&#xff0c;分别是ComposablePointcut和ControlFlowPointcut,它们提供了所需的灵活性。 使用控制流切入点 由ControlFlowPointcut类实现的Spring控制流切入点类似于许多其他AOP实现中可用的cflow构造&#xff0c;尽管功能上没有那么强大。…
阅读更多...
yolov5简单手势识别

yolov5简单手势识别

实验目的 实验要求只需要识别五个简单的手势即可&#xff0c;分别对应的一下五个动作 动作对应标签名点赞goodOKok单手比心love数字 5five数字8eight 使用yolov5实现目标检测功能&#xff0c;有一下几个主要步骤 环境配置&#xff08;包括conda、labelimg、yolov5的下载&am…
阅读更多...
SAP CO系统配置-与PS集成相关配置（机器人制造项目实例）

SAP CO系统配置-与PS集成相关配置（机器人制造项目实例）

维护分配结构 配置路径 IMG菜单路径：控制>内部订单>实际过帐>结算>维护分配结构 事务代码 OKO6 维护结算参数文件 定义利润分析码
阅读更多...
Go语言中的包管理工具之Go Vendor的使用

Go语言中的包管理工具之Go Vendor的使用

GoLang 中常用的包管理的方式 常用的有三种 Go PathGo VendorGo Modules 关于 Go Vender 1 &#xff09;概述 在2015年的时候&#xff0c;我们的另一个包管理工具Go Vendor就诞生了它诞生于 2015.8.19 &#xff0c;是在Go的 1.5 版本当中引入的&#xff0c;它默认是关闭的我…
阅读更多...
焊点保护，选择使用焊点保护UV胶的优势有哪些？

焊点保护，选择使用焊点保护UV胶的优势有哪些？

快速固化 UV胶在受到紫外光照射后能够迅速固化&#xff0c;使得焊点保护的过程更加迅速。这种快速固化的特性有助于提高生产效率&#xff0c;减少等待时间。 精准涂覆 由于UV胶在受到紫外光照射后才开始固化&#xff0c;操作者有足够的时间来进行精准的涂覆和调整位置。这使…
阅读更多...
最新文章

Copyright @ 2022~2023