Python3+SQLAlchemy+Sqlite3实现ORM教程

一、Sqlite3、SQLAlchemy安装

Sqlite3是Python3标准库不需要另外安装,只需要安装SQLAlchemy即可。本文sqlalchemy版本为1.2.12

pip install sqlalchemy

二、ORM操作

除了第一步创建引擎时连接URL不一样,其他操作其他mysql等数据库和sqlite都是差不多的。

2.1 创建数据库连接格式说明

sqlite创建数据库连接就是创建数据库,而其他mysql等应该是需要数据库已存在才能创建数据库连接;建立数据库连接本文中有时会称为建立数据库引擎。

2.1.1 sqlite创建数据库连接

以相对路径形式,在当前目录下创建数据库格式如下:

# sqlite://<nohostname>/<path>
# where <path> is relative:
engine = create_engine('sqlite:///foo.db')

以绝对路径形式创建数据库,格式如下:

#Unix/Mac - 4 initial slashes in total
engine = create_engine('sqlite:////absolute/path/to/foo.db')
#Windows
engine = create_engine('sqlite:///C:\\path\\to\\foo.db')
#Windows alternative using raw string
engine = create_engine(r'sqlite:///C:\path\to\foo.db')

sqlite可以创建内存数据库(其他数据库不可以),格式如下:

# format 1
engine = create_engine('sqlite://')
# format 2
engine = create_engine('sqlite:///:memory:', echo=True)

2.1.2 其他数据库创建数据库连接

PostgreSQL:

# default
engine = create_engine('postgresql://scott:tiger@localhost/mydatabase')
# psycopg2
engine = create_engine('postgresql+psycopg2://scott:tiger@localhost/mydatabase')
# pg8000
engine = create_engine('postgresql+pg8000://scott:tiger@localhost/mydatabase')

MySQL:

# default
engine = create_engine('mysql://scott:tiger@localhost/foo')
# mysql-python
engine = create_engine('mysql+mysqldb://scott:tiger@localhost/foo')
# MySQL-connector-python
engine = create_engine('mysql+mysqlconnector://scott:tiger@localhost/foo')
# OurSQL
engine = create_engine('mysql+oursql://scott:tiger@localhost/foo')

Oracle:

engine = create_engine('oracle://scott:tiger@127.0.0.1:1521/sidname')
engine = create_engine('oracle+cx_oracle://scott:tiger@tnsname')

MSSQL:

# pyodbc
engine = create_engine('mssql+pyodbc://scott:tiger@mydsn')
# pymssql
engine = create_engine('mssql+pymssql://scott:tiger@hostname:port/dbname')

2.2 创建数据库连接

我们以在当前目录下创建foo.db为例,后续各步同使用此数据库。

在create_engine中我们多加了两样东西,一个是echo=Ture,一个是check_same_thread=False。

echo=Ture----echo默认为False,表示不打印执行的SQL语句等较详细的执行信息,改为Ture表示让其打印。

check_same_thread=False----sqlite默认建立的对象只能让建立该对象的线程使用,而sqlalchemy是多线程的所以我们需要指定check_same_thread=False来让建立的对象任意线程都可使用。否则不时就会报错:sqlalchemy.exc.ProgrammingError: (sqlite3.ProgrammingError) SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 35608 and this is thread id 34024. [SQL: 'SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password \nFROM users \nWHERE users.name = ?\n LIMIT ? OFFSET ?'] [parameters: [{}]] (Background on this error at: http://sqlalche.me/e/f405)

from sqlalchemy import create_engine

engine = create_engine('sqlite:///foo.db?check_same_thread=False', echo=True)

2.3 定义映射

先建立基本映射类,后边真正的映射类都要继承它

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

然后创建真正的映射类,我们这里以一下User映射类为例,我们设置它映射到users表。

首先要明确,ORM中一般情况下表是不需要先存在的反而为了类与表对应无误借助通过映射类来创建;当然表已戏存在了也无可以,在下一小结中你可以自己决定如果表存在时要如何操作是重新创建还是使用已有表,但使用已有表你需要确保和类的变量名与表的各字段名要对得上。

from sqlalchemy import Column, Integer, String

# 定义映射类User,其继承上一步创建的Base
class User(Base):
  # 指定本类映射到users表
  __tablename__ = 'users'
  # 如果有多个类指向同一张表,那么在后边的类需要把extend_existing设为True,表示在已有列基础上进行扩展
  # 或者换句话说,sqlalchemy允许类是表的字集
  # __table_args__ = {'extend_existing': True}
  # 如果表在同一个数据库服务(datebase)的不同数据库中(schema),可使用schema参数进一步指定数据库
  # __table_args__ = {'schema': 'test_database'}

  # 各变量名一定要与表的各字段名一样,因为相同的名字是他们之间的唯一关联关系
  # 从语法上说,各变量类型和表的类型可以不完全一致,如表字段是String(64),但我就定义成String(32)
  # 但为了避免造成不必要的错误,变量的类型和其对应的表的字段的类型还是要相一致
  # sqlalchemy强制要求必须要有主键字段不然会报错,如果要映射一张已存在且没有主键的表,那么可行的做法是将所有字段都设为primary_key=True
  # 不要看随便将一个非主键字段设为primary_key,然后似乎就没报错就能使用了,sqlalchemy在接收到查询结果后还会自己根据主键进行一次去重
  # 指定id映射到id字段; id字段为整型,为主键,自动增长(其实整型主键默认就自动增长)
  id = Column(Integer, primary_key=True, autoincrement=True)
  # 指定name映射到name字段; name字段为字符串类形,
  name = Column(String(20))
  fullname = Column(String(32))
  password = Column(String(32))

  # __repr__方法用于输出该类的对象被print()时输出的字符串,如果不想写可以不写
  def __repr__(self):
    return "<User(name='%s', fullname='%s', password='%s')>" % (
          self.name, self.fullname, self.password)

在上面的定义我__tablename__属性是写死的,但有时我们可能想通过外部给类传递表名,此时可以通过以下变通的方法来实现:

def get_dynamic_table_name_class(table_name):
  # 定义一个内部类
  class TestModel(Base):
    # 给表名赋值
    __tablename__ = table_name
    __table_args__ = {'extend_existing': True}

    username = Column(String(32), primary_key=True)
    password = Column(String(32))
  # 把动态设置表名的类返回去
  return TestModel

2.4 创建数据表

# 查看映射对应的表
User.__table__

# 创建数据表。一方面通过engine来连接数据库,另一方面根据哪些类继承了Base来决定创建哪些表
# checkfirst=True,表示创建表前先检查该表是否存在,如同名表已存在则不再创建。其实默认就是True
Base.metadata.create_all(engine, checkfirst=True)

# 上边的写法会在engine对应的数据库中创建所有继承Base的类对应的表,但很多时候很多只是用来则试的或是其他库的
# 此时可以通过tables参数指定方式,指示仅创建哪些表
# Base.metadata.create_all(engine,tables=[Base.metadata.tables['users']],checkfirst=True)
# 在项目中由于model经常在别的文件定义,没主动加载时上边的写法可能写导致报错,可使用下边这种更明确的写法
# User.__table__.create(engine, checkfirst=True)

# 另外我们说这一步的作用是创建表,当我们已经确定表已经在数据库中存在时,我完可以跳过这一步
# 针对已存放有关键数据的表,或大家共用的表,直接不写这创建代码更让人心里踏实

从上边的讨论可以知道,我们可以定义model然后根据model来创建数据表(当然也可以不创建),那可不可以反过来根据已有的表来自动生成model代码呢,答案是可以的,使用sqlacodegen。

sqlacodegen安装操作如下:

# 如果网络通,直接pip安装
pip install sqlacodegen

# 如果网络不通,先在网络通的机器上使用pip下载sqlacodegen及期依赖包
pip download sqlacodegen
# 上传到真正要安装的机器后再用pip安装,依赖包也会自动安装。版本可能会变化改成自己具体的包名
pip install sqlacodegen-2.1.0-py2.py3-none-any.whl

sqlacodegen生成model操作如下:

# linux应该被安装在/usr/local/bin/sqlacodegen
# mysql+pymysql示例
# 可使用--tables指定要生成model的表,不指定时为所有表都生成model
# 可使用--outfile指定代码输出到的文件,不指定时输出到stdout
# 注意只有当表有主键时sqlacodegen才生成如下的class,不然会使用旧的生成Table()类实例的形式
# 更多说明可使用-h参看
sqlacodegen mysql+pymysql://user:password@localhost/dbname [--tables table_name1,table_name2] [--outfile model.py]

如我的一个示例操作如下,成功为指定表生成model:

2.5 建立会话

增查改删(CRUD)操作需要使用session进行操作

from sqlalchemy.orm import sessionmaker

# engine是2.2中创建的连接
Session = sessionmaker(bind=engine)

# 创建Session类实例
session = Session()

2.6 增(向users表中插入记录)

# 创建User类实例
ed_user = User(name='ed', fullname='Ed Jones', password='edspassword')

# 将该实例插入到users表
session.add(ed_user)

# 一次插入多条记录形式
session.add_all(
  [User(name='wendy', fullname='Wendy Williams', password='foobar'),
  User(name='mary', fullname='Mary Contrary', password='xxg527'),
  User(name='fred', fullname='Fred Flinstone', password='blah')]
)

# 当前更改只是在session中,需要使用commit确认更改才会写入数据库
session.commit()

2.7 查(查询users表中的记录)

2.7.1 查实现

query将转成select xxx from xxx部分,filter/filter_by将转成where部分,limit/order by/group by分别对应limit()/order_by()/group_by()方法。这句话非常的重要,理解后你将大量减少sql这么写那在sqlalchemy该怎么写的疑惑。

filter_by相当于where部分,外另可用filter。他们的区别是filter_by参数写法类似sql形式,filter参数为python形式。

更多匹配写法见:https://docs.sqlalchemy.org/en/13/orm/tutorial.html#common-filter-operators

our_user = session.query(User).filter_by(name='ed').first()

our_user

# 比较ed_user与查询到的our_user是否为同一条记录
ed_user is our_user

# 只获取指定字段
# 但要注意如果只获取部分字段,那么返回的就是元组而不是对象了
# session.query(User.name).filter_by(name='ed').all()
# like查询
# session.query(User).filter(User.name.like("ed%")).all()
# 正则查询
# session.query(User).filter(User.name.op("regexp")("^ed")).all()
# 统计数量
# session.query(User).filter(User.name.like("ed%")).count()
# 调用数据库内置函数
# 以count()为例,都是直接func.func_name()这种格式,func_name与数据库内的写法保持一致
# from sqlalchemy import func
# session.query(func.count(User3.name)).one()
# 字段名为字符串形式
# column_name = "name"
# session.query(User).filter(User3.__table__.columns[column_name].like("ed%")).all()
# 获取执行的sql语句
# 获取记录数的方法有all()/one()/first()等几个方法,如果没加这些方法,得到的只是一个将要执行的sql对象,并没真正提交执行
# from sqlalchemy.dialects import mysql
# sql_obj = session.query(User).filter_by(name='ed')
# sql_command = sql_obj.statement.compile(dialect=mysql.dialect(), compile_kwargs={"literal_binds": True})
# sql_result = sql_obj.all()

另外要注意该链接Common Filter Operators节中形如equals的query.filter(User.name == 'ed'),在真正使用时都得改成session.query(User).filter(User.name == 'ed')形式,不然只后看到报错“NameError: name 'query' is not defined”。

2.7.2 参数传递问题

我们上边的sql直接是our_user = session.query(User).filter_by(name='ed').first()形式,但到实际中时User部分和name=‘ed'这部分是通过参数传过来的,使用参数传递时就要注意以下两个问题。

首先,是参数不要使用引号括起来。比如如下形式是错误的(使用引号),将报错sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) no such column

table_and_column_name = "User"
filter = "name='ed'"

our_user = session.query(table_and_column_name).filter_by(filter).first()

其次,对于有等号参数需要变换形式。如下去掉了引号,对table_and_column_name没问题,但filter = (name='ed')这种写法在python是不允许的

table_and_column_name = User
# 下面这条语句不符合语法
filter = (name='ed')

our_user = session.query(table_and_column_name).filter_by(filter).first()

对参数中带等号的这种形式,现在能想到的只有使用filter代替filter_by,即将sql语句中的=号转变为python语句中的==。正确写法如下:

table_and_column_name = User
filter = (User.name=='ed')

our_user = session.query(table_and_column_name).filter(filter).first()

2.8 改(修改users表中的记录)

# 要修改需要先将记录查出来
mod_user = session.query(User).filter_by(name='ed').first()

# 将ed用户的密码修改为modify_paswd
mod_user.password = 'modify_passwd'

# 确认修改
session.commit()

# 但是上边的操作,先查询再修改相当于执行了两条语句,和我们印象中的update不一致
# 可直接使用下边的写法,传给服务端的就是update语句
# session.query(User).filter_by(name='ed').update({User.password: 'modify_passwd'})
# session.commit()
# 以同schema的一张表更新另一张表的写法
# 在跨表的update/delete等函数中synchronize_session=False一定要有不然报错
# session.query(User).filter_by(User.name=User1.name).update({User.password: User2.password}, synchronize_session=False)
# 以一schema的表更新另一schema的表的写法
# 写法与同一schema的一样,只是定义model时需要使用__table_args__ = {'schema': 'test_database'}等形式指定表对应的schema

2.9 删(删除users表中的记录)

# 要删除需要先将记录查出来
del_user = session.query(User).filter_by(name='ed').first()

# 打印一下,确认未删除前记录存在
del_user

# 将ed用户记录删除
session.delete(del_user)

# 确认删除
session.commit()

# 遍历查看,已无ed用户记录
for user in session.query(User):
  print(user)

# 但上边的写法,先查询再删除,相当于给mysql服务端发了两条语句,和我们印象中的delete语句不一致
# 可直接使用下边的写法,传给服务端的就是delete语句
# session.query(User).filter_by(name='ed').first().delete()

2.10 直接执行SQL语句

虽然使用框架规定形式可以在一定程度上解决各数据库的SQL差异,比如获取前两条记录各数据库形式如下。

# mssql/access
select top 2 * from table_name;

# mysql
select * from table_name limit 2;

# oracle
select * from table_name where rownum <= 2;

但框架存消除各数据库SQL差异的同时会引入各框架CRUD的差异,而开发人员往往就有一定的SQL基础,如果一个框架强制用户只能使用其规定的CRUD形式那反而增加用户的学习成本,这个框架注定不能成为成功的框架。直接地执行SQL而不是使用框架设定的CRUD虽然不是一种被鼓励的操作但也不应被视为一种见不得人的行为。

# 正常的SQL语句
sql = "select * from users"

# sqlalchemy使用execute方法直接执行SQL
records = session.execute(sql)

更多关于Python3 SQLAlchemy Sqlite3相关教程请查看下面的相关链接

(0)

相关推荐

  • python使用SQLAlchemy操作MySQL

    SQLAlchemy是Python编程语言下的一款开源软件,提供了SQL工具包及对象关系映射(ORM)工具,使用MIT许可证发行.SQLAlchemy首次发行于2006年2月,并迅速地在Python社区中最广泛使用的ORM工具之一,不亚于Django的ORM框架. 本文将介绍如何使用SQLAlchemy操作MySQL,完成基础的表创建,表格数据的新增.查询.修改.删除(CRUD)等操作. 首先我们需要确认当前的Python环境下已经安装sqlalchemy和pymysql模块. 新建表格 我们使

  • 基于sqlalchemy对mysql实现增删改查操作

    需求场景: 老大让我利用爬虫爬取的数据写到或更新到mysql数据库中,百度了两种方法 1 是使用pymysql连接mysql,通过操作原生的sql语句进行增删改查数据: 2 是使用sqlalchemy连接mysql,通过ORM模型建表并操作数据库,不需要写原生的sql语句,相对简单些: 以下就是本次使用sqlalchemy的经验之谈. 实现流程:连接数据库>通过模型类创建表>建立会话>执行创建表语句>通过会话进行增删改查 from sqlalchemy import exists,

  • Python_查看sqlite3表结构,查询语句的示例代码

    如下所示: #!/usr/bin/env python3 # -*- coding: utf-8 -*- import sqlite3 conn = sqlite3.connect('test.db') # 创建一个Cursor: cursor = conn.cursor() # 查询记录: conn = sqlite3.connect('calendar.db') cursor = conn.cursor() # 执行查询语句: cursor.execute('select * from pe

  • Python sqlite3事务处理方法实例分析

    本文实例讲述了Python sqlite3事务处理方法.分享给大家供大家参考,具体如下: sqlite3事务总结: 在connect()中不传入 isolation_level 事务处理: 使用connection.commit() #!/usr/bin/env python # -*- coding:utf-8 -*- '''sqlite3事务总结: 在connect()中不传入 isolation_level 事务处理: 使用connection.commit() 分析: 智能commit状

  • Python使用flask框架操作sqlite3的两种方式

    本文实例讲述了Python使用flask框架操作sqlite3的两种方式.分享给大家供大家参考,具体如下: 方式一:raw_sql import sqlite3 from flask import Flask, request, jsonify app = Flask(__name__) DATABASE_URI = ":memory:" # 创建表格.插入数据 @app.before_first_request def create_db(): # 连接 conn = sqlite3

  • Python SQLite3简介

    最近需要用Python写一个简易通讯录,但是对于数据存储很发愁.大家都知道,使用 Python 中的列表和字典进行存储数据是很不靠谱的,所以就想到Python有没有内置的数据库模块. SQLite3简介 SQLite3 可使用 sqlite3 模块与 Python 进行集成.sqlite3 模块是由 Gerhard Haring 编写的.它提供了一个与 PEP 249 描述的 DB-API 2.0 规范兼容的 SQL 接口.您不需要单独安装该模块,因为 Python 2.5.x 以上版本默认自带

  • python与sqlite3实现解密chrome cookie实例代码

    本文研究的主要问题:有一个解密chrome cookie的事情,google出了代码,却不能正常执行,原因在于sqlite3的版本太低,虽然我切换到了python3.5的环境,但sqlite3的版本也只有3.6. google了许久,终于找到方法: 1. 进入页面 http://www6.atomicorp.com/channels/atomic/centos/6/x86_64/RPMS/ 2. 下载 atomic-sqlite-sqlite-3.8.5-2.el6.art.x86_64.rpm

  • Python流行ORM框架sqlalchemy安装与使用教程

    本文实例讲述了Python流行ORM框架sqlalchemy安装与使用.分享给大家供大家参考,具体如下: 安装 http://docs.sqlalchemy.org 1.安装 #进入虚拟环境 #执行 ./python3 -m pip install import sqlalchemy print(sqlalchemy.__version__) # 1.1.15 我这里使用的版本是1.1.15 创建连接对象 http://docs.sqlalchemy.org/en/latest/orm/tuto

  • python SQLAlchemy 中的Engine详解

    先看这张图,这是从官方网站扒下来的. Engine 翻译过来就是引擎的意思,汽车通过引擎来驱动,而 SQLAlchemy 是通过 Engine 来驱动,Engine 维护了一个连接池(Pool)对象和方言(Dialect).方言简单而言就是你连的到底是 MySQL 还是 Oracle 或者 PostgreSQL 还是其它数据库,关于方言(Dialect)的介绍在另外一篇文章有介绍,可参考数据库方言dialect. 连接池很重要,因为每次发送sql查询的时候都需要先建立连接,如果程序启动的时候事先

  • Python开发SQLite3数据库相关操作详解【连接,查询,插入,更新,删除,关闭等】

    本文实例讲述了Python开发SQLite3数据库相关操作.分享给大家供大家参考,具体如下: '''SQLite数据库是一款非常小巧的嵌入式开源数据库软件,也就是说 没有独立的维护进程,所有的维护都来自于程序本身. 在python中,使用sqlite3创建数据库的连接,当我们指定的数据库文件不存在的时候 连接对象会自动创建数据库文件:如果数据库文件已经存在,则连接对象不会再创建 数据库文件,而是直接打开该数据库文件. 连接对象可以是硬盘上面的数据库文件,也可以是建立在内存中的,在内存中的数据库

  • python数据库操作mysql:pymysql、sqlalchemy常见用法详解

    本文实例讲述了python数据库操作mysql:pymysql.sqlalchemy常见用法.分享给大家供大家参考,具体如下: 相关内容: 使用pymysql直接操作mysql 创建表 查看表 修改表 删除表 插入数据 查看数据 修改数据 删除数据 使用sqlmary操作mysql 创建表 查看表 修改表 删除表 插入数据 查看数据 修改数据 删除数据 首发时间:2018-02-24 23:59 修改: 2018-06-15,发现自己关于pymysql写了对于数据的操作示例,但没有写表结构的示例

  • Python简单操作sqlite3的方法示例

    本文实例讲述了Python简单操作sqlite3的方法.分享给大家供大家参考,具体如下: import sqlite3 def Test1(): #con =sqlite3.connect("D:\\test.db") con =sqlite3.connect(":memory:") #store in memory cur =con.cursor() try: cur.execute('create table score(id integer primary k

  • Python实现读取TXT文件数据并存进内置数据库SQLite3的方法

    本文实例讲述了Python实现读取TXT文件数据并存进内置数据库SQLite3的方法.分享给大家供大家参考,具体如下: 当TXT文件太大,计算机内存不够时,我们可以选择按行读取TXT文件,并将其存储进Python内置轻量级splite数据库,这样可以加快数据的读取速度,当我们需要重复读取数据时,这样的速度加快所带来的时间节省是非常可观的,比如,当我们在训练数据时,要迭代10万次,即要从文件中读取10万次,即使每次只加快0.1秒,那么也能节省几个小时的时间了. #创建数据库并把txt文件的数据存进

  • python 获取sqlite3数据库的表名和表字段名的实例

    Python中对sqlite3数据库进行操作时,经常需要用到字段名,然而对于sqlite使用select语句并不能象MySql等数据库一样返回带字段名的字典数据集.特别是对于一个不熟悉的sqlite数据库,写代码时如果需要借助工具查看,那其实是有点对不起python的. 下面两段代码就可以轻易获得一个sqlite数据库中所有数据表名和字段名的列表: # python 获取sqlite3数据库mydb.db中的表名和表字段名 import sqlite3 conn=sqlite3.connect(

  • python使用sqlite3时游标使用方法

    cursor就是一个Cursor对象,这个cursor是一个实现了迭代器(def__iter__())和生成器(yield)的MySQLdb对象,这个时候cursor中还没有数据,只有等到fetchone()或fetchall()的时候才返回一个元组tuple,才支持len()和index()操作,这也是它是迭代器的原因.但同时为什么说它是生成器呢?因为cursor只能用一次,即每用完一次之后记录其位置,等到下次再取的时候是从游标处再取而不是从头再来,而且fetch完所有的数据之后,这个curs

  • Python SQLite3数据库日期与时间常见函数用法分析

    本文实例讲述了Python SQLite3数据库日期与时间常见函数.分享给大家供大家参考,具体如下: import sqlite3 #con = sqlite3.connect('example.db') con = sqlite3.connect(":memory:") c = con.cursor() # Create table c.execute('''CREATE TABLE stocks (date text, trans text, symbol text, qty re

  • 基于SQLAlchemy实现操作MySQL并执行原生sql语句

    场景应用 老大我让爬取内部网站获取数据,插入到新建的表中,并每天进行爬取更新数据(后面做了定时任务).然后根据该表统计每日的新增数量/更新数量进行制图制表,向上级汇报. 思路构建 选用sqlalchemy+mysqlconnector,连接数据库,创建表,对指定表进行CRUD from sqlalchemy import exists, Column, Integer, String, ForeignKey, DateTime, Text, func from sqlalchemy.ext.de

  • python orm 框架中sqlalchemy用法实例详解

    本文实例讲述了python orm 框架中sqlalchemy用法.分享给大家供大家参考,具体如下: 一.ORM简介 1. ORM(Object-Relational Mapping,对象关系映射):作用是在关系型数据库和业务实体对象之间做一个映射. 2. ORM优点: 向开发者屏蔽了数据库的细节,使开发者无需与SQL语句打交道,提高了开发效率; 便于数据库的迁移,由于每种数据库的SQL语法有差别,基于Sql的数据访问层在更换数据库时通过需要花费时间调试SQL时间,而ORM提供了独立于SQL的接

  • Python SQLAlchemy入门教程(基本用法)

    本文将以Mysql举例,介绍sqlalchemy的基本用法.其中,Python版本为2.7,sqlalchemy版本为1.1.6. 一. 介绍 SQLAlchemy是Python中最有名的ORM工具. 关于ORM: 全称Object Relational Mapping(对象关系映射). 特点是操纵Python对象而不是SQL查询,也就是在代码层面考虑的是对象,而不是SQL,体现的是一种程序化思维,这样使得Python程序更加简洁易读. 具体的实现方式是将数据库表转换为Python类,其中数据列

  • python SQLAlchemy的Mapping与Declarative详解

    前面介绍过vSQLAlchemy中的 Engine 和 Connection,这两个对象用在row SQL (原生的sql语句)上操作,而 ORM(Object Relational Mapper)则是一种用面向对象的思维来操作表数据的技术.所谓ORM 就是Python 对象到数据表的一种映射关系. 以前 SQLAlchemy 是怎么把Python对象和数据库中表里面的每条记录进行映射的呢?通过一个mapping函数 先来看个例子: from sqlalchemy import Table, M

随机推荐