以下从ORM的作用，是什么，优缺点以及一些比较流行的ORM的对比的个人总结：

1.ORM的作用
对象关系映射，能够直接将数据库对象进行持久化。

在没有ORM前，我们要自己写数据库连接方法，自己在方法里面嵌入原生的sql语句去访问数据表……

这时问题就来了：
数据库名，数据表名完全暴露在代码中，有脱库的风险；
需要我们自己处理数据表对象，比如说把数据表中取出的数据转化为标准json等，sql语句安全过滤，数据表、字段别名、兼容多种数据库等一系列的数据处理工作；

下面介绍一下ORM到底是啥？

2、ORM是什么？
ORM作为数据库层与业务逻辑层之间的一个抽象，能够将业务逻辑的处理持久化为内存对象，交由数据库去处理。其封装了数据库的连接，数据表的操作细节……在文中我们可以看到ORM将sql语句做了封装，我们可以通过filter实现过滤，而不是写where子句。

ORM真的那么好？

3、优缺点
优点：
安全：因为屏蔽了数据库的具体操作细节以及对sql做了严格的过滤，因此能够保证数据库信息的隐蔽性，同时防止sql注入。
简单：屏蔽了数据层的访问细节，我们只需要集中注意力处理业务逻辑就可以了。

缺点：
性能低：自动化意味着加载很多即使没有必要的关联和映射，牺牲性能。但ORM也采取了一些补救措施：对象懒加载，缓存技术等。

学习成本高：面向对象的封装设计，是的我们必须要去了解对象的处理细节。

难以实现复杂查询：ORM实现的是一些通用的数据处理方法，一些负责的业务处理还是需要自己组装sql。

那么还有哪些比较流行的ORM呢？
hibernate:强调对单条数据的处理
mybits:基于自定义配置的sql操作

日常交作业~~~

# -*- coding:utf-8 -*-
from sqlalchemy import and_
from sqlalchemy import Column, INT, FLOAT, VARCHAR
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()


class Test_db:
    def __init__(self):
        """此处填上自己的连接配置"""
        self.engine = create_engine(
            'mysql+pymysql://UserName:Password@host:port/Db_Name?charset=utf8')
        db_session = sessionmaker(bind=self.engine)
        self.session = db_session()

    def update(self, target_class, query_filter, target_obj):
        """
        更新操作通用方法
        :param target_class: 表对象
        :param query_filter: 查询条件
        :param target_obj: 更新目标对象
        :return:
        """
        try:
            self.session.query(target_class).filter(query_filter).update(target_obj)
            self.session.commit()
            self.session.close()
            return True
        except Exception as e:
            print(e)


class Player(Base):
    """定义表结构"""
    __tablename__ = 'player'
    player_id = Column(INT(), primary_key=True)
    team_id = Column(INT())
    player_name = Column(VARCHAR(255))
    height = Column(FLOAT())

    def __init__(self, player_id, team_id, player_name, height):
        self.player_id = player_id
        self.team_id = team_id
        self.player_name = player_name
        self.height = height


if __name__ == '__main__':
    db_obj = Test_db()
    query_filter = and_(Player.height == 2.08)
    target_obj = {'height': 2.09}
    update_result = db_obj.update(Player, query_filter, target_obj)

后续更新数量、更新结果等等判断就略过了...
（小声bb：什么时候极客时间评论也能支持markdown啊。。）

框架对实体的映射不难理解,数据库本身就是对现实世界的映射,借由映射将事实转换为数据.
代码部分有些基础的也不难理解;基础较弱硬钢的亲们,耐心一条条来缕也可以捋顺,都是基础的东西,无非花费时间长短问题.有几个坑这里记录下,供后来人借鉴:
1.关于初始化连接数据库问题.creat_engine的参数这块容易卡壳,可以参考以下文字说明:
create_engine("数据库类型+数据库驱动://数据库用户名:数据库密码@IP地址:端口/数据库"，其他参数)
2.数据库驱动这块,老师的参考代码是用mysqlconnector,沿承得是上篇中导入mysql-connector包;网上一些资料以及参考其他同学的答案有使用pymysql,要用这个需安装pip install pymysql.这两货对于本篇的学习内容在本质上是一样的,任选一个即可.
3.在代码复写过程中,删除操作一直报错.网上查了资料说是跟返回值有关.经过测试,发现问题所在,filter返回结果为None.也就是说没有查询到"约翰-科林斯".往回倒腾,发现开始新增数据那里,增加的" 约翰-科林斯 ",前后对比后者两侧多了个空格.统一前后,删除操作顺利完成.

翻了一下SQLAlchemy的官方文档,看到一个简单的办法,作业如下:

'''

作业:

使用SQLAlchemy工具查询身高为2.08米的球员,并且将这些球员的身高修改为2.09;


参考:
        
        https://docs.sqlalchemy.org/en/13/core/dml.html


'''

from sqlalchemy import Column, String, Integer, Float,create_engine,update
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
Base = declarative_base()
engine = create_engine('mysql+mysqlconnector://root:123456@localhost:3306/geektime-sql')


class Player(Base):
    __tablename__ = 'player'
 
    player_id = Column(Integer, primary_key=True, autoincrement=True)
    team_id = Column(Integer)
    player_name = Column(String(255))
    height = Column(Float(3,2))

def to_dict(self):
    return {c.name: getattr(self, c.name, None)
            for c in self.__table__.columns}

if __name__ == '__main__':
    DBSession = sessionmaker(bind=engine)
    session = DBSession()
    Base.to_dict = to_dict
    print("更新前:")
    rows = session.query(Player).filter(Player.height == 2.08).all()
    print([row.to_dict() for row in rows])
    # 参考: https://docs.sqlalchemy.org/en/13/core/dml.html#sqlalchemy.sql.expression.update
    stmt = update(Player).where(Player.height == 2.08).values(height=2.09)
    engine.execute(stmt)
    session.commit()
    rows = session.query(Player).filter(Player.height == 2.09).all()
    print("更新后:")
    print([row.to_dict() for row in rows])
    session.close()
太长,省略了部分执行结果.自己执行一下,就可以看到完整结果了..

更新前:
[{'player_id': 10010, 'team_id': 1001, 'player_name': '乔恩-洛伊尔', 'height': Decimal('2.0800000000')}......
更新后:
[{'player_id': 10010, 'team_id': 1001, 'player_name': '乔恩-洛伊尔', 'height': Decimal('2.0900000000')}......
[Finished in 0.9s]

文章中的示例代码.完整可运行.

from sqlalchemy import Column, String, Integer, Float,create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
Base = declarative_base()
# 初始化数据库连接，修改为你的数据库用户名和密码
engine = create_engine('mysql+mysqlconnector://root:123456@localhost:3306/geektime-sql')

# 定义 Player 对象:
class Player(Base):
    # 表的名字:
    __tablename__ = 'player'
 
    # 表的结构:
    player_id = Column(Integer, primary_key=True, autoincrement=True)
    team_id = Column(Integer)
    player_name = Column(String(255))
    height = Column(Float(3,2))


# 增加 to_dict() 方法到 Base 类中
def to_dict(self):
    return {c.name: getattr(self, c.name, None)
            for c in self.__table__.columns}



if __name__ == '__main__':
    # 创建 DBSession 类型:
    DBSession = sessionmaker(bind=engine)
    # 创建 session 对象:
    session = DBSession()

    # 创建 Player 对象:
    new_player = Player(team_id = 1003, player_name = "约翰 - 科林斯", height = 2.08)
    # 添加到 session:
    session.add(new_player)
    # 提交即保存到数据库:
    session.commit()
    # 关闭 session:
    session.close()
    # 将对象可以转化为 dict 类型
    Base.to_dict = to_dict
    # 查询身高 >=2.08 的球员有哪些
    # rows = session.query(Player).filter(Player.height >=2.08, Player.height <=2.10).all()
    # from sqlalchemy import or_
    # rows = session.query(Player).filter(or_(Player.height >=2.08, Player.height <=2.10)).all()
    rows = session.query(Player).filter(Player.height >= 2.08).all()
    print([row.to_dict() for row in rows])
    from sqlalchemy import func
    rows = session.query(Player.team_id, func.count(Player.player_id)).group_by(Player.team_id).having(func.count(Player.player_id)>5).order_by(func.count(Player.player_id).asc()).all()
    print(rows)
    row = session.query(Player).filter(Player.player_name=='约翰 - 科林斯').first()
    session.delete(row)
    session.commit()
    session.close()
    row = session.query(Player).filter(Player.player_name=='索恩-马克').first()
    row.height = 2.17
    session.commit()
    session.close()

错误解决：
如果报如下错误：Authentication plugin 'caching_sha2_password' is not supported
sqlalchemy.exc.NotSupportedError: (mysql.connector.errors.NotSupportedError) Authentication plugin 'caching_sha2_password' is not supported (Background on this error at: http://sqlalche.me/e/tw8g)
可以参考下面的链接处理：
https://stackoverflow.com/questions/51783313/how-do-i-get-sqlalchemy-create-engine-with-mysqlconnector-to-connect-using-mysql

老师好，对于修改数据的事例有一点困惑还请您解答。对于下面这段代码中

row = session.query(Player).filter(Player.player_name=='索恩 - 马克').first()
row.height = 2.17
session.commit()
session.close()

我理解row是存在于内存中的对象，但是我们在修改后并没有传递到数据库中，如果直接commit可以进行修改的话，这个row是在哪里存放的对象呢？

我自己总结的博客链接：https://blog.csdn.net/weixin_42564710/article/details/103978476
完整版的代码如下：
# -*- coding: UTF-8 -*-
from sqlalchemy import create_engine
from sqlalchemy import Column, String, Integer, Float, or_
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import func

# 创建对象的基类:
Base = declarative_base()
# 定义 Player 对象:
class Player(Base):
    # 表的名字:
    __tablename__ = 'player'

    # 表的结构:
    player_id = Column(Integer, primary_key=True, autoincrement=True)
    team_id = Column(Integer)
    player_name = Column(String(255))
    height = Column(Float(3, 2))
    # 增加 to_dict() 方法到 Base 类中
    def to_dict(self):
        return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}
    # 将对象可以转化为 dict 类型
    Base.to_dict = to_dict
if __name__=='__main__':
    engine = create_engine('mysql+mysqlconnector://root:密码@localhost:3306/world')
    # 创建 DBSession 类型:
    DBSession = sessionmaker(bind=engine)
    # 创建 session 对象:
    session = DBSession()

    # 创建 Player 对象:
    new_player = Player(team_id=1101, player_name=" 约翰 - 雪诺 ", height=2.08)
    # 添加到 session:
    session.add(new_player)
    # 提交即保存到数据库:
    session.commit()
    session.close()
    # 查询身高 >=2.08 的球员有哪些
    rows_1 = session.query(Player).filter(Player.height >= 2.08).all()
    print([row.to_dict() for row in rows_1])

    rows_2 = session.query(Player).filter(or_(Player.height >=2.08, Player.height <=2.10)).all()
    print([row.to_dict() for row in rows_2])
    rows_3 = session.query(Player.team_id, func.count(Player.player_id)).group_by(Player.team_id).having(func.count(Player.player_id)>5).order_by(func.count(Player.player_id).asc()).all()
    print(rows_3)


    row = session.query(Player).filter(Player.player_name=='索恩-马克').first()
    row.height = 2.19
    session.commit()
    # 关闭 session:
    session.close()

    row = session.query(Player).filter(Player.player_name == ' 约翰 - 雪诺 ').first()
    session.delete(ro

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

Base = declarative_base()

engine = create_engine("mysql+pymysql://root:toor@localhost:3306/test")

Session = sessionmaker(bind=engine)


def to_dict(self):
    return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}


Base.to_dict = to_dict


class Player(Base):
    __tablename__ = "player"

    player_id = Column(Integer, primary_key=True, autoincrement=True)
    team_id = Column(Integer)
    player_name = Column(String(255))
    height = Column(Float(3, 2))


session = Session()

rows = session.query(Player).filter(Player.height == 2.08).all()
for row in rows:
    print(row.to_dict())
    row.height = 2.09
session.commit()


# 验证
rows = session.query(Player).filter(Player.height == 2.09).all()
print([row.to_dict() for row in rows])

session.close()

陈老师 ，你在增加数据库数据哪里是不是少导入了两个类和一行定义Base的代码？
from sqlalchemy.ext.declarative import declarative_base
#引用基本映射类
from sqlalchemy.orm import sessionmaker
#引用session类操作后面的增删改查

Base = declarative_base()
#建立基本映射类，方便后面真正的映射类Player来继承它