SQLAlchemy
以上，SQLAlchemy的两个最重要的前端部分是ORM(Object Relational Mapper,,即对象关系映射器)和 SQL表达式语言。SQL表达式可以独立于ORM使用。使用ORM时，SQL表达式语言仍然是面向对象的API的一部分，因为它在对象关系配置和查询中使用。
SQLAlchemy是python中的ORM框架。对象关系映射（英语：Object Relation Mapping，简称ORM，或O/RM，或O/R mapping）其他语言中都会有ORM框架，可以进行更加快捷便利的操作数据库。
SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。
注意：SQLAlchemy本身无法操作数据库，必须依赖第三方插件如pymysql，mysqlDB,Dialect用于和数据API进行交流，根据配置文件的不同调用不同数据库的API，从而实现对数据库的操作。
一，创建表
默认的情况下SQLAlchemy不能修改表结构，可以下载第三方工具进行修改。
#!/usr/bin/python
# _*_ coding:utf-8 _*_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5)
# 创建连接
Base = declarative_base() # 规定的必须要写这一步
# ------------------创建单表-----------------------
class Users(Base): #必须继承Base
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(32))
extra = Column(String(16))
__table_args__ = ( # 创建的联合索引
UniqueConstraint('id', 'name', name='uix_id_name'),
Index('ix_id_name', 'name', 'extra'),
)
# -----------------一对多-----------------------
class Favor(Base):
__tablename__ = 'favor'
nid = Column(Integer, primary_key=True)
caption = Column(String(50), default='red', unique=True)
class Person(Base):
__tablename__ = 'person'
nid = Column(Integer, primary_key=True)
name = Column(String(32), index=True, nullable=True)
favor_id = Column(Integer, ForeignKey("favor.nid"))
# -----------------多对多------------------
class Group(Base):
__tablename__ = 'group'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False)
port = Column(Integer, default=22)
class Server(Base):
__tablename__ = 'server'
id = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(64), unique=True, nullable=False)
class ServerToGroup(Base): # 要想创建多对多的关系，需要创建第三个表保存他们的对应关系
__tablename__ = 'servertogroup'
nid = Column(Integer, primary_key=True, autoincrement=True)
server_id = Column(Integer, ForeignKey('server.id'))
group_id = Column(Integer, ForeignKey('group.id'))
def init_db():
Base.metadata.create_all(engine) # 找到Base所有的子类，根据类去创建表
def drop_db():
Base.metadata.drop_all(engine)
# init_db() # 创建所有的表
drop_db() # 删除所有的表
二，操作表
#!/usr/bin/env python
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5)
Base = declarative_base()
# 创建单表
class Users(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(32))
extra = Column(String(16))
__table_args__ = (
UniqueConstraint('id', 'name', name='uix_id_name'),
Index('ix_id_name', 'name', 'extra'),
)
def __repr__(self): # 这个方法是SQLAlchemy内部自己规定的，这个函数对查询没有一点用处，只是在打印对象时方便查看
return "%s-%s" %(self.id, self.name)
# 一对多
class Favor(Base):
__tablename__ = 'favor'
nid = Column(Integer, primary_key=True)
caption = Column(String(50), default='red', unique=True)
def __repr__(self):
return "%s-%s" %(self.nid, self.caption)
class Person(Base):
__tablename__ = 'person'
nid = Column(Integer, primary_key=True)
name = Column(String(32), index=True, nullable=True)
favor_id = Column(Integer, ForeignKey("favor.nid"))
# 与生成表结构无关，仅用于查询方便
favor = relationship("Favor", backref='pers')
# 多对多
class ServerToGroup(Base):
__tablename__ = 'servertogroup'
nid = Column(Integer, primary_key=True, autoincrement=True)
server_id = Column(Integer, ForeignKey('server.id'))
group_id = Column(Integer, ForeignKey('group.id'))
group = relationship("Group", backref='s2g')
server = relationship("Server", backref='s2g')
class Group(Base):
__tablename__ = 'group'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False)
port = Column(Integer, default=22)
# group = relationship('Group',secondary=ServerToGroup,backref='host_list')
class Server(Base):
__tablename__ = 'server'
id = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(64), unique=True, nullable=False)
def init_db():
Base.metadata.create_all(engine)
def drop_db():
Base.metadata.drop_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
# ------增--------
obj = Users(name="alex0", extra='sb')
session.add(obj)
session.add_all([ # 添加数据
Users(name="alex1", extra='sb'),
Users(name="alex2", extra='sb'),
])
session.commit() # 提交
# -------删--------
session.query(Users).filter(Users.id > 2).delete()
session.commit()
# -------改---------
session.query(Users).filter(Users.id > 2).update({"name": "099"})
session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + "099"}, synchronize_session=False)
# 字符串的相加
session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")
# 数字的相加，synchronize_session="evaluate"，这样设置之后就会把值当成数字进行相加。
session.commit()
# --------查-----------
ret = session.query(Users).all() # 查询所有,此时返回的是User对象列表
ret = session.query(Users.name, Users.extra).all() # 查询两列
ret = session.query(Users).filter_by(name='alex').all() # 过滤出name='alex'的所有
ret = session.query(Users).filter_by(name='alex').first() # 只取第一条
# 条件
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all() # 是'且'的关系
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all() # 这里是'或'的关系
ret = session.query(Users).filter(
or_(
Users.id < 2,
and_(Users.name == 'eric', Users.id > 3),
Users.extra != ""
)).all()
# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()
# 限制
ret = session.query(Users)[1:2] # 相当于mysql中的limit
# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all() # 按照name排序，name相同再按照id排序
# 分组
from sqlalchemy.sql import func
ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
func.max(Users.id),
func.sum(Users.id),
func.min(Users.id)).group_by(Users.name).all()
ret = session.query(
func.max(Users.id),
func.sum(Users.id),
func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()
# 连表
ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()
ret = session.query(Person).join(Favor).all() # 默认是join类型为inner join，自动连表（在内部会找foreignkey）
ret = session.query(Person).join(Favor, isouter=True).all() # isouter=True表示的是left join
# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all() # 默认去重
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all() # 默认不去重
三，详解一对多
group
| nid | caption |
| 1 | 1 |
| 2 | 2 |
user
| nid | username | goup_id |
| 1 | lintao | 1 |
| 2 | lily | 1 |
| 3 | lucy | 1 |
创建上述表并对表进行简单的操作
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5)
Base = declarative_base() # 固定用法
class Group(Base):
__tablename__ = 'group'
nid = Column(Integer, primary_key=True, autoincrement=True)
caption = Column(String(32))
class User(Base):
__tablename__ = 'user'
nid = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(32))
group_id = Column(Integer, ForeignKey('group.nid')) #（引擎必须是InnoDB）创建外键，对两张表进行关联
# 注意mysql的引擎从5.5.5开始默认引擎是InnoDB, 之前的版本默认是MyISAM引擎，MyISAM不支持外键，此时需要
# 修改配置文件/etc/my.cnf 在mysqld下面增加一行：default-storage-engine=INNODB，然后重启即可生效。
Base.metadata.create_all(engine) # 创建表
Base.metadata.drop_all(engine)
Session = sessionmaker(bind=engine) # 相当于保持一个会话
session = Session()
# 创建group表记录
session.add(Group(caption='dba')) # 记录逐条添加
session.add(Group(caption='dbd'))
session.commit() #必须提交，否则不会生效
# 创建user表记录
session.add_all([ # 一次性添加多条记录
User(username='lin', group_id=1),
User(username='lily', group_id=2),
User(username='lucy', group_id=3) # 此时如果group表中的nid没有为3的，那么此时这条记录就会报错！这就是外键的作用
])
session.commit()
# 对表进行操作
sql = session.query(User).filter(User.username == "tom") # 返回的是SQL语句
print(sql)
ret = session.query(User).filter(User.username == "tom").all() # 返回的是一个对象的列表
# 如果返回的对象不知道是什么的话，可以在SQLAlchemy可以用repr方法进行自定制
print(ret)
ret1 = session.query(User.username).filter(User.username == "tom").all() # 返回的是username这一列，中的'tom'
print(ret1)
# 连表查询，这里不用像SQL语句中还要加on字段，这里由SQLAlchemy会在内部自动查找foreignkey
sql_1 = session.query(User).join(Group)
sql_2 = session.query(User).join(Group, isouter=True)
ret2 = session.query(User).join(Group).all()
print(sql_1) # 通过sql语句可以看出默认的是inner join
print(sql_2) # 通过添加isouter = True, 可以更改为left join
print(ret2) # 进行关联查询所有的数据
小结：
1，创建表需要指定外键
2，类， repr方法(# 这个方法是SQLAlchemy内部自己规定的，这个函数对查询没有一点用处，只是在打印对象时方便查看)
3，单表
4，连表 session.query("表一").join("表二").all()
上面我们发现查询在查询的时候只有user表，能不能查到group表呢？
ret3 = session.query(User, Group).all() # 返回的是对象 ret4 = session.query(User.username, User.nid, Group.caption, Group.nid).all() #返回的是列 print(ret3) print(ret4)
下面针对上述表我们提出一个需要：如何获取caption为‘dba’所有的用户名？
第一种实现方式
#!/usr/bin/env python # _*_ coding:utf-8 _*_ from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index from sqlalchemy.orm import sessionmaker, relationship from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5) Base = declarative_base() class Group(Base): __tablename__ = 'group' nid = Column(Integer, primary_key=True, autoincrement=True) caption = Column(String(32)) class User(Base): __tablename__ = 'user' nid = Column(Integer, primary_key=True, autoincrement=True) username = Column(String(32)) group_id = Column(Integer, ForeignKey('group.nid')) group = relationship("Group", backref='pers') # 与表结构无关，仅用来查询 # relationship("类名") def __repr__(self): # 这里只是来用打印对象时有用，对于查询无用 tmp = "%s -- %s :%s" % (self.nid, self.username, self.group_id) return tmp Session = sessionmaker(bind=engine) # 相当于保持一个会话 session = Session()
第二种实现方式
其中第二种实现方式，有分为两种，我们姑且称之为：正向查找和反向查找
由于连表操作比较麻烦，SQLAlchemy又提供了一个新的功能。在声明外键（ForeignKey）的表中增加一个新的字段，group = relationship("Group", backref='pers'),一般情况下foreikey和relationship在一张表里面。这一功能和Django中的类似。到底这个字段代表什么含义呢？
1，group字段含义是什么？（正向查找，通过带有关系（relationship）的表向其他地方找）
#通过user表来查询 ret = session.query(User).all() for obj in ret: # obj 代指user表中的每一行数据 # obj.group 代表的是由Group实例化的对象（对象封装的东西和user相关） print(obj.username, obj.group_id, obj.nid) print(obj.group, obj.group.nid, obj.group.caption) # SQLAlchemy在内部做的关联 print("----------------")
2，backref=pers字段是什么含义？（反向查找，通过其他表，来找到带有relation的表）
# 通过group表来查询 obj = session.query(Group).filter(Group.caption == 'dba').first() print(obj.nid) print(obj.caption) print(obj.pers) #注意这里是反向查找，此时的obj.pers代表的是User实例化对象（对象封装的内容和group相关），和正向恰好相反，结合 正向查找去理解
注意pers在数据库中并没有真实的表与其对应，只是SQLAlchemy在内存中生成的SQL语句而已。就相当于在group表中增加了一个pear字段，就像表user中的group字段一样。
四，表创建过程
1，先把写好的类转换为table对象，
2，然后根据table对象生成SQL语句
注意：在python中并没有严格的限制，可以直接用table对象生成SQL语句，一般正式和标准的用法都会用类来生成。在其他语言中只允许用类生成表。
五，详解多对多
server
| server_id | server_name | port | ip |
| 1 | c1 | xx | xxx.xx.xx.x |
| 2 | c2 | xx | xx.xx.xx.xx |
| 3 | c3 | xxxx | xx.xxx.xx.x |
server_user
| user_id | user_name |
| 1 | tom |
| 2 | lily |
| 3 | lucy |
一台主机可以有多个用户，一个用户又可以同时存在多个主机，这就是多对多的关系，这时需要建立第三张关系表
relation_table
| sid | uid |
| 1 | 1 |
| 1 | 3 |
| 2 | 2 |
| 3 | 2 |
| 3 | 1 |
此时还需要对第三张表建立约束：外键，这样可以控制数据的一致性和完整性
创建表结构并插入数据
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5)
Base = declarative_base()
class Host(Base):
__tablename__ = 'host'
nid = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(32))
port = Column(String(32))
ip = Column(String(32))
class HostUser(Base):
__tablename__ = 'host_user'
nid = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(32))
class HostToHostUser(Base):
__tablename__ = 'host_to_host_user'
nid = Column(Integer, primary_key=True, autoincrement=True)
# 暂时保留主键
host_id = Column(Integer, ForeignKey('host.nid'))
host_user_id = Column(Integer, ForeignKey('host_user.nid'))
# Base.metadata.create_all(engine) # 创建表
Session = sessionmaker(bind=engine)
session = Session()
# 添加host表中数据
session.add_all([
Host(hostname='c1', port='22', ip='1.1.1.1'),
Host(hostname='c2', port='22', ip='1.1.1.2'),
Host(hostname='c3', port='22', ip='1.1.1.3'),
Host(hostname='c4', port='22', ip='1.1.1.4'),
Host(hostname='c5', port='22', ip='1.1.1.5'),
])
session.commit()
# 添加host_user表中数据
session.add_all([
HostUser(username='root'),
HostUser(username='db'),
HostUser(username='nb'),
HostUser(username='sb'),
])
session.commit()
# 添加host_to_host_user表中数据
session.add_all([
HostToHostUser(host_id=1, host_user_id=1),
HostToHostUser(host_id=1, host_user_id=2),
HostToHostUser(host_id=1, host_user_id=3),
HostToHostUser(host_id=2, host_user_id=2),
HostToHostUser(host_id=2, host_user_id=4),
HostToHostUser(host_id=2, host_user_id=3),
])
session.commit()
需求：如何获取主机1中所有的用户？
方案一：传统方式
思路：
1，先通过主机1的主机名在host表，获取主机的nid
2，在通过主机的nid，在host_to_host_user表中找到对应的host_user_id，为用户的ID
3，最后在host_user表中找到和用户id相对应的用户的信息
host_obj = session.query(Host).filter(Host.hostname == 'c1').first() # print(host_obj.nid) # 1 host_2_host_user = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id == host_obj.nid).all() # print(host_2_host_user) # [(1,), (2,), (3,)] # 如何把它转换为列表，或者元组， # >>> li # [('a',), ('b',), ('c',)] # >>> r = map(lambda x:x[0], li) # >>> print(list(r)) # ['a', 'b', 'c'] # 也可以用r = zip(*host_2_host_user)--> list(r[0])此时为元组('a', 'b', 'c') users = session.query(HostUser.username).filter(HostUser.nid.in_(map(lambda x: x[0], host_2_host_user))).all() print(users) # 注意这里fliter不但支持==，还支持in的操作 执行结果： [('root',), ('db',), ('nb',)]
方案二：新方式（常用）
A
AB ==> foreign_key relationship
B
!/usr/bin/env python # _*_ coding:utf-8 _*_ from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index from sqlalchemy.orm import sessionmaker, relationship from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5) Base = declarative_base() class Host(Base): __tablename__ = 'host' nid = Column(Integer, primary_key=True, autoincrement=True) hostname = Column(String(32)) port = Column(String(32)) ip = Column(String(32)) class HostUser(Base): __tablename__ = 'host_user' nid = Column(Integer, primary_key=True, autoincrement=True) username = Column(String(32)) class HostToHostUser(Base): __tablename__ = 'host_to_host_user' nid = Column(Integer, primary_key=True, autoincrement=True) # 暂时保留主键 host_id = Column(Integer, ForeignKey('host.nid')) host_user_id = Column(Integer, ForeignKey('host_user.nid')) host = relationship("Host", backref='h') # host_user = relationship('HostUser', backref='u') # # 增加上面两个字段，多对多就相当于两个一对多 # Base.metadata.create_all(engine) # 创建表 Session = sessionmaker(bind=engine) session = Session() # 第三张表对应的对象 host_obj = session.query(Host).filter(Host.hostname == 'c1').first() print(host_obj.nid, host_obj.hostname, host_obj.port) print(host_obj.h) # 此时的h代表的HostToHostUsers实例化的对象（和Host相关的） # 循环获取第三张表对应的对象 for item in host_obj.h: # print(item.host_user) # 获取HostUser实例化的和关系表相关的内容 r = item.host_user.username print(r) 思路：先通过反向查找，找到HostToHostUser(即关系表)实例化的对象，然后再通过这个对象获取host_user这个字段，这个字段即代表HostUser(即关系表)对象，此时正向查找到相对应的host表中的uername
方案三：新方式（不常用，不太合理） 对象+类的方法创建的
A ==> relationship
AB ==> foreign_key
B
这里的关系表和foreign_key没有放在一张表里面
#!/usr/bin/env python # _*_ coding:utf-8 _*_ from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index, Table #这里需要导入Table模块 from sqlalchemy.orm import sessionmaker, relationship from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5) Base = declarative_base() class HostUser(Base): __tablename__ = 'host_user' nid = Column(Integer, primary_key=True, autoincrement=True) username = Column(String(32)) HostToHostUser = Table('host_to_host_user', Base.metadata, Column('host_id', ForeignKey('host.nid'), primary_key=True), Column('host_user_id', ForeignKey('host_user.nid'), primary_key=True), ) class Host(Base): __tablename__ = 'host' nid = Column(Integer, primary_key=True, autoincrement=True) hostname = Column(String(32)) port = Column(String(32)) ip = Column(String(32)) host_user = relationship("HostUser", secondary=HostToHostUser, backref='h') # 注意这里的secondary为关系表的名字：HostToHostUser Session = sessionmaker(bind=engine) session = Session() host_obj = session.query(Host).filter(Host.hostname == 'c1').first() # print(list(map(lambda x: x.username, host_obj.host_user))) for item in host_obj.host_user: print(item.username)
方案四：也比较合理，简单
#!/usr/bin/env python # _*_ coding:utf-8 _*_ from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index, Table from sqlalchemy.orm import sessionmaker, relationship from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:123@10.1.1.3:3306/s13", max_overflow=5) Base = declarative_base() class HostUser(Base): __tablename__ = 'host_user' nid = Column(Integer, primary_key=True, autoincrement=True) username = Column(String(32)) class HostToHostUser(Base): __tablename__ = 'host_to_host_user' nid = Column(Integer, primary_key=True, autoincrement=True) # 暂时保留主键 host_id = Column(Integer, ForeignKey('host.nid')) host_user_id = Column(Integer, ForeignKey('host_user.nid')) class Host(Base): __tablename__ = 'host' nid = Column(Integer, primary_key=True, autoincrement=True) hostname = Column(String(32)) port = Column(String(32)) ip = Column(String(32)) host_user = relationship("HostUser", secondary=HostToHostUser.__table__, backref='h') # 注意这里的secondary为：HostToHostUser, __table__为获取的table对象 Session = sessionmaker(bind=engine) session = Session() host_obj = session.query(Host).filter(Host.hostname == 'c1').first() # print(list(map(lambda x: x.username, host_obj.host_user))) for item in host_obj.host_user: print(item.username)
SQLAlchemy总结：
1，orm自动生成表，然后根据类和对象去生成表
2，创建表，简单
3，操作表（其实就是转换SQL语句），需要多练。
单表
连表
right.join, left join, inner join
关系：
一对多（一般情况下外键和关系会放到一起，foreignkey,relationship）
多对多
多一张表，放的是foreignkey,关联约束
1，关系表：放关系
2，A:放关系 ，(B, AB)
练习的顺序：从上往下练习，能用SQL就用SQL，像涉及到一对多和多对多时，SQLAlchemy比较简单的再考虑用。
拥抱不确定，未来可期！喜欢该文章请不吝点赞推荐，如有疑问欢迎留言，我们一起探讨。
