您的位置:时时app平台注册网站 > 编程知识 > Python(九)【分分钟通晓】 Python 操作 MySQL 之

Python(九)【分分钟通晓】 Python 操作 MySQL 之

2019-10-30 04:17

前提:

  • 第一需求安装python与mysql交互的库【PyMySQL 是在 Python3 版本中用来连接 MySQL 服务器的一个库】:

    • 设置模块:pymysql:

      pip3 install pymysql
      

      或者在Pycharm中安装

3.奉行插入、改过、删除:

import pymysql

#创建连接
conn=pymysql.connect(host="localhost",port=3306,user="root",password="123456",db="python_test",charset="utf8")
#创建游标
cursor=conn.cursor()

print("-----------插入----------------")
cursor.execute("insert into student values ('nazha',2000,'男');")
cursor.execute("select * from student;")
print(cursor.fetchall())
print("-----------插入----------------")
#cursor.executemany(self,query,args)
cursor.executemany("insert into student value(%s,%s,%s);",[('zhangsan',18,'男'),('lisi',18,'男')])
cursor.execute("select * from student;")
print(cursor.fetchall())
print("-----------修改----------------")
cursor.execute("update student set name = 'zhangsan1' where name = 'zhangsan';")
cursor.execute("select * from student;")
print(cursor.fetchall())
print("----------删除-----------------")
cursor.execute("delete from student where name = 'lisi';")
cursor.execute("select * from student;")
print(cursor.fetchall())
print("---------------------------")

#需要提交才能插入、成功修改、删除
conn.commit()
#关闭游标
cursor.close()
#关闭连接
conn.close()

结果:

(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'))
---------------------------
(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'), ('zhangsan', 18, '男'), ('lisi', 18, '男'))
---------------------------
(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'), ('zhangsan1', 18, '男'), ('lisi', 18, '男'))
---------------------------
(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'), ('zhangsan1', 18, '男'))
---------------------------

2、执行SQL

试行 SQL 语句的为主语法:

须求注意的是:创造链接后,都由游标来进展与数据库的操作,当然,得到数码也靠游标

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql

# 创建连接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
# 创建游标
cursor = conn.cursor()

# 执行SQL,并返回收影响行数
effect_row = cursor.execute("update hosts set host = '1.1.1.2'")

# 执行SQL,并返回受影响行数
#effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))

# 执行SQL,并返回受影响行数
#effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])


# 提交,不然无法保存新建或者修改的数据
conn.commit()

# 关闭游标
cursor.close()
# 关闭连接
conn.close()

1.创制连接:

import pymysql

#创建连接
conn=pymysql.connect(host="localhost",port=3306,user="root",passwd="123456",db="python_test")
#创建游标
cursor=conn.cursor()
#..............操作过程
#关闭游标
cursor.close()
#关闭连接
conn.close()

相关内容:

  • 动用pymysql直接操作mysql

    • 创建表
    • 查看表
    • 修改表
    • 删除表
    • 插入数据
    • 查看数据
    • 改正数据
    • 去除数据

     

  • 使用sqlmary操作mysql

    • 创建表
    • 查看表
    • 修改表
    • 删除表
    • 布置数据
    • 查阅数据
    • 纠正数据
    • 删去数据

 

 

首发时间:2018-02-24 23:59

【第三回写那么长的博文,若有荒唐,请不吝与本身说明】


4、获取查询数据

获得查询数据的三种方法:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.execute("select * from hosts")

# 获取第一行数据
row_1 = cursor.fetchone()

# 获取前n行数据
# row_2 = cursor.fetchmany(3)

# 获取所有数据
# row_3 = cursor.fetchall()

conn.commit()
cursor.close()
conn.close()

 

1.创立连接:

import pymysql

#创建连接
conn=pymysql.connect(host="localhost",port=3306,user="root",passwd="123456",db="python_test")
#创建游标
cursor=conn.cursor()
#..............操作过程
#关闭游标
cursor.close()
#关闭连接
conn.close()

Python(九)【分分钟精晓】 Python 操作 MySQL 之 pysql 与 ORM,pysqlorm

本文针对 Python 操作 MySQL 主要行使的两种办法疏解:

  • 原生模块 pymsql
  • ORM框架 SQLAchemy

本章内容: 

  • pymsql 执行 sql 增删改查 语句
  • pymsql 获取查询内容、获取自增 ID
  • pymsql 游标
  • pymsql 修正 fetch 数据类型
  • pymsql 利用 with 简化操作
  • ORM 下载安装
  • ORM 史上最全操作

 

有关内容:

  • 选拔pymysql直接操作mysql

    • 创建表
    • 查看表
    • 修改表
    • 删除表
    • 插入数据
    • 翻开数据
    • 更正数据
    • 删去数据

     

  • 使用sqlmary操作mysql

    • 创建表
    • 查看表
    • 修改表
    • 删除表
    • 安顿数据
    • 查看数据
    • 改正数据
    • 剔除数据

 

 

先发时间:2018-02-24 23:59

修改:

  • 2018-06-15,开掘自个儿关于pymysql写了对于数据的操作示例,但不曾写表结构的演示,于是增多上

 


使用:

  • 导入模块:
    • 导入连接数据库模块:from sqlalchemy import create_engine
    • 比如要求创建新表,则需求导入表结构定义模块:from sqlalchemy.ext.declarative import declarative_base
    • 导入别的有关模块,主若是炫目的类,如字段映射为Column,如数据类型int映射为Integer,如索引映射为Index,要求怎么着导入什么:from sqlalchemy import Column,Integer,String
    • 照耀关系:
      数据库中 映射 模块【如果可以从多个模块处导入,用 | 分隔】【方式太多,可能有漏,但不影响导入】
      Table from sqlalchemy import Table
      int Integer from sqlalchemy.types import Integer
      索引 Index from sqlalchemy import Index
           
      字段、列 Column from sqlalchemy import Column
      varchar VARCHAR、String from sqlalchemy.types import String    |   from sqlalchemy import String
      外键 ForeignKey
      from sqlalchemy import ForeignKey
           
           
  • 连接数据库:连接对象=create_engine('数据库类型 数据库驱动名称://客户名:口令@机器地址:端口号/数据库名',编码格式,echo)
    • sqlalchemy协助各个API操作格局,可以运用分裂的情势来三回九转操作数据库:'数据库类型 数据库驱动名称://客商名:口令@机器地址:端口号/数据库名'
      • 比如pymsql【py3常用】:mysql pymysql://<username>:<password>@<host>/<dbname>[?<options>
    • 别的参数:
      • echo是不是展现ORM转成实际sql语句的进度,echo=True为显
      • encoding为连接时使用的字符集

 

 2、内处

应用 Engine/ConnectionPooling/Dialect 举行数据库操作,Engine使用ConnectionPooling连接数据库,然后再通过Dialect实行SQL语句。

时时app平台注册网站 1#!/usr/bin/env python # -*- coding:utf-8 -*- from sqlalchemy import create_engine engine = create_engine("mysql pymysql://root:[email protected]:3306/t1", max_overflow=5) # 执行SQL # cur = engine.execute( # "INSERT INTO hosts (host, color_id) VALUES ('1.1.1.22', 3)" # ) # 新插入行自增ID # cur.lastrowid # 执行SQL # cur = engine.execute( # "INSERT INTO hosts (host, color_id) VALUES(%s, %s)",[('1.1.1.22', 3),('1.1.1.221', 3),] # ) # 执行SQL # cur = engine.execute( # "INSERT INTO hosts (host, color_id) VALUES (%(host)s, %(color_id)s)", # host='1.1.1.99', color_id=3 # ) # 执行SQL # cur = engine.execute('select * from hosts') # 获取第生龙活虎行数据 # cur.fetchone() # 获取第n行数据 # cur.fetchmany(3) # 获取具备数据 # cur.fetchall() View Code

3.施行查询:

import pymysql

#创建连接
conn=pymysql.connect(host="localhost",port=3306,user="root",passwd="123456",db="python_test",charset="utf8")
#创建游标
cursor=conn.cursor()

cursor.execute("select * from student;")
print(cursor.fetchone())#获取一条
print(cursor.fetchmany(2))#获取两条
print(cursor.fetchall())#获取结果集合中的全部

#关闭游标
cursor.close()
#关闭连接
conn.close()

介绍:

  • ORM 将数据库中的表与面向对象语言中的类创建了意气风发种对应提到,【ORM能够说是参照他事他说加以考察映射来拍卖数量的模型,举个例子说:须要创设八个表,能够定义一个类,而以此类存在与表相映射的品质,那么可以通过操作这些类来创立三个表】
  • sqlmary是一个mysql的ORM

一、pymsql

pymsql 是 Python 中操作 MySQL 的原生模块,其利用格局和 MySQL 的SQL语句大概相仿

补给表明:

1.engine 能够一贯运营sql语句,格局是engine.execute(),重返值是结果集,能够利用fetchall等艺术来赢得结果

2.其实创造表还也会有超多措施,能够接收各个对象来创建【比方在上头Table格局中也得以使用t来create(engine)】,但提议利用方式后生可畏

3.如出风度翩翩辙的,不单创立表有各个艺术,查看表,删除表等也会有两种操作形式,也是因为能够使用两种对象来操作

4.session也能够直接运转sql语句: session.execute()

 

 

屈居sessionmake API官方文书档案:内部详细而简约的授课了用法

甚至贰个第三方援助文书档案: 里面有广大关于sqlalchemy的用法例子

 


前提:

  • 率先要求安装python与mysql交互的库【PyMySQL 是在 Python3 版本中用来连接 MySQL 服务器的一个库】:

    • 安装模块:pymysql:

      pip3 install pymysql
      

      或者在Pycharm中安装

3、获取新创造数据自增ID

能够博得到最新自增的ID,也正是最后插入的一条数据ID

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
conn.commit()
cursor.close()
conn.close()

# 获取最新自增ID
new_id = cursor.lastrowid

示例:

使用:

  • 第生机勃勃导入模块:import pymysql
  • 连续几日数据库 :数据库连接对象 = pymysql.connect("host="localhost",port=3306,user='root',passwd='123456',db='python_test') 【假设需求扶助汉语,则拉长charset=”utf8”】
  • 创办游标【游标用于施行sql语句和治本查询到的结果】 :游标对象 = 数据库连接对象.cursor()
  • 试行sql语句 :游标对象.execute(SQL语句) ,重回值是受影响行数

    • 由于暗许开端作业,假使波及矫正、插入,则必要提交:连接对象.commit() ;以致打消纠正、插入的回滚:连接对象.rollback()
    • executemany是还要进行多条sql语句【以多组参数的格式,executemany(self,query,args)】:
  • 赢得结果:

    • 收获一条结果:data = 游标对象.fetchone()

    • 获得全部结果:data=游标对象.fetchall()

    • 收获钦点数量结果:data=游标对象.fetmany(x)

    • 赢得结果后,就能够将相应的结果删掉,举个例子fetchone是收获一条,那么这一条就能够从原先的结果中删除

    • 游标对象.rowcount()能够获得施行sql语句后受影响的行数

    •  

  • 关闭游标: 游标对象.close()

  • 闭馆数据库连接:数据库连接对象.close()

 

5、移动游标

操作都以靠游标,那对游标的操纵也是必需的

注:在fetch数据时按照顺序进行,可以使用cursor.scroll(num,mode)来移动游标位置,如:

cursor.scroll(1,mode='relative')  # 相对当前位置移动
cursor.scroll(2,mode='absolute')  # 相对绝对位置移动

4.实行插入、纠正、删除:

import pymysql

#创建连接
conn=pymysql.connect(host="localhost",port=3306,user="root",password="123456",db="python_test",charset="utf8")
#创建游标
cursor=conn.cursor()

print("-----------插入----------------")
cursor.execute("insert into student values ('nazha',2000,'男');")
cursor.execute("select * from student;")
print(cursor.fetchall())
print("-----------插入----------------")
#cursor.executemany(self,query,args)
cursor.executemany("insert into student value(%s,%s,%s);",[('zhangsan',18,'男'),('lisi',18,'男')])
cursor.execute("select * from student;")
print(cursor.fetchall())
print("-----------修改----------------")
cursor.execute("update student set name = 'zhangsan1' where name = 'zhangsan';")
cursor.execute("select * from student;")
print(cursor.fetchall())
print("----------删除-----------------")
cursor.execute("delete from student where name = 'lisi';")
cursor.execute("select * from student;")
print(cursor.fetchall())
print("---------------------------")

#需要提交才能插入、成功修改、删除
conn.commit()
#关闭游标
cursor.close()
#关闭连接
conn.close()

结果:

(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'))
---------------------------
(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'), ('zhangsan', 18, '男'), ('lisi', 18, '男'))
---------------------------
(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'), ('zhangsan1', 18, '男'), ('lisi', 18, '男'))
---------------------------
(('lilei', 18, '男'), ('hanmeimei', 18, '女'), ('huluwa', 18, '男'), ('sunwukong', 18, '男'), ('baigujing', 3000, '女'), ('nazha', 2000, '男'), ('zhangsan1', 18, '男'))
---------------------------

使用sqlalchemy操作mysql:

 

3、ORM功效应用

选择 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 全部组件对数码举办操作。

基于类创造对象,对象转换到SQL,实行SQL。

5.装置援救汉语【创制连接时加多charset=”utf8”】:

import pymysql

#创建连接
# conn=pymysql.connect(host="localhost",port=3306,user='root',passwd='123456',db='python_test')
conn=pymysql.connect(host="localhost",port=3306,user='root',passwd='123456',db='python_test',charset="utf8")

#创建游标
cursor = conn.cursor()

effect_row= cursor.execute("select * from student;")


print("执行成功,受影响行数:",effect_row)
print(cursor.fetchall())

conn.commit()

cursor.close()
conn.close()

添加前:

时时app平台注册网站 2

添加后:

时时app平台注册网站 3

 

 

 

 


一贯操作mysql:

1、下载安装

pip3 install pymysql

前提:

  • 设置模块:pip3 install sqlalchemy

2.施行查询:

import pymysql

#创建连接
conn=pymysql.connect(host="localhost",port=3306,user="root",passwd="123456",db="python_test",charset="utf8")
#创建游标
cursor=conn.cursor()

cursor.execute("select * from student;")
print(cursor.fetchone())#获取一条
print(cursor.fetchmany(2))#获取两条
print(cursor.fetchall())#获取结果集合中的全部

#关闭游标
cursor.close()
#关闭连接
conn.close()

7、利用 with 自动关闭

每趟再而三数据库都亟需三回九转和关闭,啊,好多代码,那么方法又来了:

是或不是好厉害啊?

# 利用with定义函数

    @contextlib.contextmanager
    def mysql(self, host='127.0.0.1', port=3306, user='nick', passwd='', db='db1', charset='utf8'):
        self.conn = pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=db, charset=charset)
        self.cuersor = self.conn.cursor(cursor=pymysql.cursors.DictCursor)

        try:
            yield self.cuersor
        finally:
            self.conn.commit()
            self.cuersor.close()
            self.conn.close()

# 执行
with mysql() as cuersor:
   print(cuersor)
   # 操作MySQL代码块

 

直接操作mysql--pymysql:

直白操作mysql意思是接收python实现雷同命令行方式下的mysql交互。

 

操作:

基本操作:

创办新表

方法一: 使用declarative

1.导入模块from sqlalchemy.ext.declarative import declarative_base

2.根据需要的元素来导入模块``from sqlalchemy import Column

  • 导入需要的数据类型【注:数据类型在sqlalchemy中也有指向,所以也可以from sqlalchemy import String,Integer,Char】:from sqlalchemy.types import *

3.创建连接,

3.使用declarative_base来获得一个类对象,此处我定义该对象为Base

定义一个类,继承declarative_base生成的类对象Base

使用__tablename__来定义表名

使用 列名 = Column(数据类型,其他列属性…)等类似格式来定义字段

  • nullable=False 代表这一列不得感觉空,index=True 表示在该列创设索

创建表:Base.metadata.create_all(engine)

from sqlalchemy import create_engine#负责导入连接数据库的对象
from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
from sqlalchemy import Column #负责导入列
from sqlalchemy.types import *#负责导入列类型

#数据库连接
engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8',echo=True)
#方式一:
Base = declarative_base()

class User(Base):
    __tablename__ = 'user'#表名
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

Base.metadata.create_all(engine)

 

  • 方法二:使用Table

    • 1.导入模块: from sqlalchemy import Table
    • 2.老是数据库:engine=create_engine(….)
    • 3.获取meta类,metadata=MetaData(engine)
    • 4.创建Table对象( 比如:t=Table("group" ,metadata,Column("id",Integer,primary_key=True),Column("group_name",String(32)))  )
    • 5.创建表:metadata.create_all()

      from sqlalchemy import create_engine
      from sqlalchemy import Table
      from sqlalchemy import MetaData
      from sqlalchemy import Column
      from sqlalchemy.types import *
      from sqlalchemy.ext.declarative import declarative_base
      
        ####下面的注释部分可以与上面一句的未注释的替换
        engine=create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8',echo=True)
        metadata=MetaData(engine) ###  
        # Base=declarative_base()

        t=Table(
        "group" ,metadata,#表名
        # "group",Base.metadata,
        Column("id",Integer,primary_key=True),
        Column("group_name",String(32))
        )

        metadata.create_all()
        # Base.metadata.create_all(engine)

 

  • 查看表:
    • db_table=Base.metadata.tables#独有当次运维中承接了Base而创造的新表
    • db_tables=engine.table_names()#独有表名
  • 删除表:Base.metadata.drop_all(engine)
  • 修改表:
    • 一向改正表所对应的类组织是回天无力修改成功的,
    • 比如供给修正在程序中自定义的表的构造,那么须求手动改过,手动的措施有无数,比方直接engine.execute(sql语句)。。。。

 

 

 

  • 插入 数据【这里仅针对使用declarative_base创立的表,对于不是前后相继中才创设的,能够团结使用declarative_base建一个类来映射以前的表,只要映射风流罗曼蒂克致,就能够插入数据】

    • 1.接连数据库:engine=create_engine(….)
    • 1.导入模块:from sqlalchemy.orm import sessionmaker
    • 2.获取session_class类:Session_class=sessionmaker(bind=engine)
    • 3.获取session对象:s=Session_class()
    • 4.使用s来添加:
      • s.add()
      • s.add_all()
    • 5.提交数额: s.commit()

      from sqlalchemy import create_engine#负责导入连接数据库的对象
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8',echo=True)
      Base = declarative_base()
      class User(Base):
          __tablename__ = 'user'#表名
          id = Column(Integer,primary_key=True)
          name = Column(String(32))
          password = Column(String(64))
          group = Column(Integer)
      
      Base.metadata.create_all(engine)
      
        from sqlalchemy.orm import sessionmaker
        obj1=User(name='lisi',password='123456',group=1)

        Session=sessionmaker(bind=engine)
        s=Session()
        s.add(obj1)#

        users=[User(name='wangwu',password='123456',group=1),
               User(name='zhaoliu', password='123456', group=1),
               User(name='sunqi', password='123456', group=1)
               ]
        s.add_all(users)#

        s.commit()

 

 

  • 查找 数据

    • 同样适用sessionmaker来查找,与插入相同,需要创建session_class对象(我定义为s)
    • 使用s来查找:

      • s.query(表对应类)是也正是select对应表,后边能够跟first()、all()等来获得结果,也足以加filter、filter_by等来挑选结果
      • 获取全部 : s.query(表对应类).all() 【重返的是二个结出列表】
      • 查找指定: s.query(表对应类).filter(表对应类.xxx==xxxx)【filter获取的是结果集,需要使用all(),first()等方法来获取结果】
      • 查找指定: s.query(表对应类).filter_by(xxx=xxxx)
      • 附:虽然返回值是一个结果集,但这个集合是一个类对象,如果想查看内容,需要在表对应的类中增加__repr__方法。
      • 多个筛选条件使用“,”隔开
      • 常见可用筛选条件【User是一个表对应的类】:

        使用filter,filter_by时:
        User.name==’lisi’
        User.name.like(“lisi%”))
        User.name != ’lisi’
        User.name.any()
        or_(筛选条件) 【代表里面的多个筛选条件以or组合,需要导入:from sqlalchemy import or_】
        and_(筛选条件) 【代表里面的多个筛选条件以and组合,需要导入:from sqlalchemy import and_】【默认是and】
        in_([筛选条件])  【使用比如User.name.in_(['xiaxia', 'lilei', 'lover'])】
        使用all时,以下是放在query里面的:
        User.name  [这相当于不使用where的select name from 表]
         
         
      • 连接查询使用:s.query(表对应类).join(表对应类.xxx==xxxx)

      • 还有group_by,order_by等用法这里不做讲解[什么时候有空再补吧!]

        from sqlalchemy import create_engine#负责导入连接数据库的对象
        from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
        from sqlalchemy import Column #负责导入列
        from sqlalchemy.types import *#负责导入列类型
        
        #数据库连接
        engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8')
        Base = declarative_base()
        class User(Base):
            __tablename__ = 'user'#表名
            id = Column(Integer,primary_key=True)
            name = Column(String(32))
            password = Column(String(64))
            group = Column(Integer)
        
            def __repr__(self):
                return "<id:%s name:%s group:%s>"%(self.id,self.name,self.group)
        Base.metadata.create_all(engine)
        
            from sqlalchemy.orm import sessionmaker
            obj1=User(name='lisi',password='123456',group=1)

            Session=sessionmaker(bind=engine)
            s=Session()

            a=s.query(User).all()
            a2=s.query(User).filter(User.name=='lisi').first()
            a3=s.query(User).filter_by(name='lisi').first()



            print(a)
            print(a2)
            print(a3)

 

 

  • 修改 数据:

    • 修改数据的基本功是先查找到数据,查找:row=s.query(X).filter(X.xxx=xxx).first()
    • 利用赋值语句修改 :row.xxx=xxxx

      from sqlalchemy import create_engine#负责导入连接数据库的对象
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8')
      Base = declarative_base()
      class User(Base):
          __tablename__ = 'user'#表名
          id = Column(Integer,primary_key=True)
          name = Column(String(32))
          password = Column(String(64))
          group = Column(Integer)
      
          def __repr__(self):
              return "<id:%s name:%s group:%s>"%(self.id,self.name,self.group)
      Base.metadata.create_all(engine)
      
        from sqlalchemy.orm import sessionmaker
        obj1=User(name='lisi',password='123456',group=1)

        Session=sessionmaker(bind=engine)
        s=Session()


        row=s.query(User).filter(User.name=='lisi').first()
        row.name='lisi2'
        s.commit()

 

 

  • 删除 数据:

    • 除去数据的底子是先查找到数据,查找:row=s.query(X).filter(X.xxx=xxx)
    • 使用delete删除:row.delete()

      # coding: utf-8
      from sqlalchemy import create_engine#负责导入连接数据库的对象
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8')
      Base = declarative_base()
      class User(Base):
          __tablename__ = 'user'#表名
          id = Column(Integer,primary_key=True)
          name = Column(String(32))
          password = Column(String(64))
          group = Column(Integer)
          def __repr__(self):
              return "<id:%s name:%s group:%s>"%(self.id,self.name,self.group)
      
      Base.metadata.create_all(engine)
      
        from sqlalchemy.orm import sessionmaker
        obj1=User(name='lisi',password='123456',group=1)

        Session=sessionmaker(bind=engine)
        s=Session()


        a3=s.query(User).filter_by(name='lisi1')
        a3.delete()
        s.commit()

 

外键相关:

  • 外键使用foregin_key创建
  • 类中的relationship的职能:帮忙ORM得到消息他们的外键关系,以便ORM使用外键获取有关数据
    • relationship中的backref的用途:relationship使得能够在一个表中定义的relationshop能被七个表使用,另多少个表使用backref来博取相关音信
    • relationship中的foreign_keys的用处:当有多少个relationship时,为了防止ORM混淆八个relationship,非常的标号哪个外键是哪些relationship
    • relationship中的secondary的用途:在多对多的关系中,填入的值是中间表,维持两边表关系。
  • 一定的外键关系:
    • 1.导入模块:from sqlalchemy import Foreign_key
    • 2.确立外键(如:group = Column(Integer,ForeignKey("group.id")),创建关联(如:group_relation=relationship('Group',backref="g_users")
    • 3.插入数据
    • 4.查询到一条数据:如row=s.query(User).filter(User.name=='lisi').first()
    • 5.尝试A表调用关系来博取B(row.group_relation.group_name),B使用backref来获取A的数据(row2.g_users)
    • 上边包车型地铁实例大约正是“贰个开垦人士对应三个开采组的涉及”
#负责导入连接数据库的对象
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
from sqlalchemy import Column,ForeignKey #负责导入列
from sqlalchemy.types import *#负责导入列类型
from sqlalchemy.orm import relationship

#数据库连接
engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8')
Base = declarative_base()



class Group(Base):
    __tablename__="group"
    id=Column(Integer,primary_key=True)
    group_name=Column(String(32),nullable=False)

    def __repr__(self):
        return "<id:%s group_name:%s>"%(self.id,self.group_name)

class User(Base):
    __tablename__ = 'user'#表名
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    password = Column(String(64),nullable=False)
    group = Column(Integer,ForeignKey("group.id"))#这里创建外键

    group_relation=relationship('Group',backref="g_users")#为ORM指明关系,方便ORM处理,第一个是对应的类
    def __repr__(self):
        return "<id:%s name:%s>"%(self.id,self.name)
Base.metadata.create_all(engine)

from sqlalchemy.orm import sessionmaker
# group1=Group(group_name='python')
# group2=Group(group_name='linux')
# group3=Group(group_name='AI')
# user1=User(name='lisi',password='123456',group=1)
# user2=User(name='zhangsan',password='123456',group=2)
# user3=User(name='wangwu',password='123456',group=3)
# user4=User(name='lilei',password='123456',group=3)


Session=sessionmaker(bind=engine)
s=Session()
# s.add_all([group1,group2,group3,user1,user2,user3,user4])
# s.commit()

# row=s.query(User).filter(User.name=='lisi').first()
row=s.query(User).first()
print(row.group_relation.group_name)#这里User通过关系来获取Group的数据
row2=s.query(Group).first()
print(row2)
print(row2.g_users)#这里Group通过relationship的backref来获取User的数据
  • 风流洒脱对多涉及,外键关联

    • 以一个老师能做一个班的班主任此外还能做另一个班的副班主任为例【即一个老师能对应多个班级】
    • 风流倜傥对多关系的创造的中央是relationship中的foreign_keys
    • 附:当你建表成功而插入数据失败时,可以尝试先删除掉数据表,有时候因为外键依赖会导致插入失败

      #负责导入连接数据库的对象
      from sqlalchemy import create_engine
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column,ForeignKey #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      from sqlalchemy.orm import relationship
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8')
      Base = declarative_base()
      
        class Grade(Base):
            __tablename__="grade"
            id=Column(Integer,primary_key=True)
            grade_name=Column(String(32),nullable=False)

            def __repr__(self):
                return "<id:%s group_name:%s>"%(self.id,self.grade_name)

        class Teacher(Base):
            __tablename__ = 'teacher'#表名
            id = Column(Integer,primary_key=True)
            name = Column(String(32),nullable=False)
            primary_grade = Column(Integer,ForeignKey("grade.id"))
            second_grade = Column(Integer,ForeignKey("grade.id"))

            primary_grade_relation=relationship('Grade',backref="first_teacher",foreign_keys=[primary_grade])
            second_grade_relation=relationship('Grade',backref="second_teacher",foreign_keys=[second_grade])
            def __repr__(self):
                return "<id:%s name:%s>"%(self.id,self.name)


        Base.metadata.create_all(engine)

        from sqlalchemy.orm import sessionmaker
        # grade1=Grade(grade_name='python')
        # grade2=Grade(grade_name='linux')
        # grade3=Grade(grade_name='AI')
        # grade4=Grade(grade_name='Java')
        # t1=Teacher(name='lisi',primary_grade=1,second_grade=2)
        # t2=Teacher(name='zhangsan',primary_grade=2,second_grade=1)
        # t3=Teacher(name='wangwu',primary_grade=4,second_grade=3)
        # t4=Teacher(name='lilei',primary_grade_relation=grade3,second_grade=4)
        #这里外键相关的比如primary_grade=x可以使用primary_grade_relation=对象来代替,
        # 会根据对象来转成对应id,不过问题是不知道grade3的准确id,因为可能创建顺序不一致

        Session=sessionmaker(bind=engine)
        s=Session()
        # s.add_all([grade1,grade2,grade3,grade4])
        # s.add_all([t1,t2,t3,t4])
        # s.commit()

        row=s.query(Teacher).filter(Teacher.name=='lisi').first()

        print(row.name,row.primary_grade_relation.grade_name)#这里Teacher通过关系来获取Grade的数据
        print(row.name,row.second_grade_relation.grade_name)
        row2=s.query(Grade).first()
        print(row2.grade_name,row2.first_teacher)#这里Grade通过relationship的backref来获取Teacher的数据
        print(row2.grade_name,row2.second_teacher)

`` 

多对多外键关联

  • 以选课中一门课能有多名学子,一个学员可以选多门课为示范:
  • 里面relationship中的secondary的值是中间表,肩负维持中间表与其它两表的关联,创造多对多的中坚是secondary
#负责导入连接数据库的对象
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
from sqlalchemy import Column,ForeignKey #负责导入列
from sqlalchemy.types import *#负责导入列类型
from sqlalchemy.orm import relationship

#数据库连接
engine = create_engine("mysql pymysql://root:[email protected]/python_test",encoding ='utf-8')
Base = declarative_base()

class SelectInfo(Base):
    __tablename__="selectClassInfo"
    id=Column(Integer,primary_key=True)
    sid=Column(Integer,ForeignKey("student.id"))
    cid=Column(Integer,ForeignKey("course.id"))


"""使用declarative_base和Table 创建表时,secondary的填写不一样
selectInfo2=Table(
'selectClassInfo',Base.metadata,
Column('sid',Integer,ForeignKey('student.id'))
Column('cid',Integer,ForeignKey('student.id'))
)
"""

class Student(Base):
    __tablename__="student"
    id=Column(Integer,primary_key=True)
    name=Column(String(32),nullable=False)

    def __repr__(self):
        return "<id:%s name:%s>"%(self.id,self.name)

class Course(Base):
    __tablename__ = 'course'
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)

    student_relation=relationship('Student',secondary="selectClassInfo",backref="courses")
    # student_relation=relationship('Student',secondary=selectClassInfo2,backref="courses") 
    # #如果使用Table来创建中间表,上面是这样填的

    def __repr__(self):
        return "<id:%s name:%s>"%(self.id,self.name)


Base.metadata.create_all(engine)

from sqlalchemy.orm import sessionmaker
#
# s1=Student(name='lisi')
# s2=Student(name='zhangsan')
# s3=Student(name='wangwu')
# s4=Student(name='lilei')
# c1=Course(name='python',student_relation=[s1,s2])
# c2=Course(name='linux',student_relation=[s3])
# c3=Course(name='AI',student_relation=[s3,s4])
# c4=Course(name='Java')
# c4.student_relation=[s1,s2,s3,s4]##在一边增加关系之后,在secondary中会加入两边的数据
#
#
#
Session=sessionmaker(bind=engine)
s=Session()
# s.add_all([s1,s2,s3,s4,c1,c2,c3,c4])
# s.commit()

row=s.query(Course).filter(Course.id=='4').first()

print(row.name,row.student_relation)#这里Course通过关系来获取Student的数据
row2=s.query(Student).filter(Student.id=="3").first()
print(row2.name,row2.courses)#这里Student通过relationship的backref来获取Course的数据

 

 

 

 

6、fetch数据类型

默许获得的多寡是小括号,元祖类型,借使是字典的话会更利于操作,这艺术来了:

# 关于默认获取的数据是元祖类型,如果想要或者字典类型的数据,即:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql

conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')

# 游标设置为字典类型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
r = cursor.execute("call p1()")

result = cursor.fetchone()

conn.commit()
cursor.close()
conn.close()

使用sqlalchemy操作mysql:

 

4.设置援救普通话【增添charset=”utf8”】:

import pymysql

#创建连接
# conn=pymysql.connect(host="localhost",port=3306,user='root',passwd='123456',db='python_test')
conn=pymysql.connect(host="localhost",port=3306,user='root',passwd='123456',db='python_test',charset="utf8")

#创建游标
cursor = conn.cursor()

effect_row= cursor.execute("select * from student;")


print("执行成功,受影响行数:",effect_row)
print(cursor.fetchall())

conn.commit()

cursor.close()
conn.close()

添加前:

添加后:

 

 

 

 


a、创建表

时时app平台注册网站 4#!/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:[email protected]:3306/suoning4?charset=utf8", 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): # 查是出口的剧情格式,本质依旧对象 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) 创建表

注:设置外检的另生龙活虎种艺术 ForeignKeyConstraint(['other_id'], ['othertable.other_id'])

使用:

  • 首最早入模块:import pymysql
  • 三番五次数据库 :数据库连接对象 = pymysql.connect("host="localhost",port=3306,user='root',passwd='123456',db='python_test') 【如若须要扶持汉语,则增进charset=”utf8”】时时app平台注册网站 5
  • 开创游标【游标用于施行sql语句和管理查询到的结果】 :游标对象 = 数据库连接对象.cursor()
  • 进行sql语句 :游标对象.execute(SQL语句) ,重回值是受影响行数  【execute可以举行全数的sql语句,无论是表相关的,依然多少相关的。】
    • 出于默许开端事务,假设提到校正、插入,则要求提交:连接对象.commit() ;以致撤废更改、插入的回滚:连接对象.rollback()
    • executemany是还要实践多条sql语句【以多组参数的格式,executemany(self,query,args)】:
    • 时时app平台注册网站 6
  • 得到结果:

    • 收获一条结果:data = 游标对象.fetchone()

    • 赢得全体结果:data=游标对象.fetchall()

    • 获得内定数量结果:data=游标对象.fetmany(x)

    • 收获结果后,就能将相应的结果删掉,比方fetchone是获得一条,那么这一条就能够从原来的结果中除去

    • 游标对象.rowcount()能够赢得试行sql语句后受影响的行数

    • 时时app平台注册网站 7 

  • 关门游标: 游标对象.close()

  • 关门数据库连接:数据库连接对象.close()

 

14.python与数据库之mysql:pymysql、sqlalchemy,14.pythonpymysql

1、下载安装

pip3 install SQLAlchemy

时时app平台注册网站 8

亟需静心了:SQLAlchemy 自个儿没辙操作数据库,必需结合 pymsql 品级三方插件,Dialect 用于和多少 API 实行相互,依据铺排文件的例向外调拨运输用不一致的数据库 API,进而达成对数据库的操作,如:

MySQL-Python
    mysql mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql
    mysql pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector
    mysql mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle
    oracle cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

更多详见:http://docs.sqlalchemy.org/en/latest/dialects/index.html

2.实行成立表:

import pymysql

conn=pymysql.connect(host="localhost",port=3306,user="root",password="123456",db="it",charset="utf8")

cursor=conn.cursor()

sql="""
create table user(
id int PRIMARY KEY auto_increment,
username VARCHAR(20),
password VARCHAR(20),
address VARCHAR(35) 
)
"""
cursor.execute(sql)

conn.commit()
cursor.close()
conn.close()

示例:

b、操作表

操作表那必得导入模块,创制相应类,相应增删改查的语法,详细见下code吧^^:

#!/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:[email protected]:3306/suoning4?charset=utf8", 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):
        # 查是输出的内容格式,本质还是对象
        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)


# 先实例化sessionmaker类,Session对象加括号执行类下的__call__方法,
# 得到session对象,所以session可以调用Session类下的add,add_all等方法
Session = sessionmaker(bind=engine) # 指定引擎
session = Session()

# 增

# 添加一条
obj = Users(name="张三", extra='三儿')
session.add(obj)
# 添加多条
session.add_all([
    Users(name="李四", extra='四儿'),
    Users(name="汪五", extra='五儿'),
])
# 提交
session.commit()

# 删

session.query(Users).filter(Users.id > 2).delete()
session.query(Users).filter_by(id = 1).delete()
session.commit()

# 改

session.query(Users).filter(Users.id > 2).update({"name" : "nick"})
session.query(Users).filter(Users.id > 2).update({"name" : "nick", "extra":"niubily"})
session.query(Users).filter(Users.id > 2).update({Users.name: Users.name   "Suo"}, synchronize_session=False)
session.query(Users).filter(Users.id > 2).update({"num": Users.num   1}, synchronize_session="evaluate")
session.commit()

# 查
# all()结果为对象列表,first()为具体对象

ret = session.query(Users).all()
ret = session.query(Users.name, Users.extra).all()
ret = session.query(Users).filter_by(name='nick').all()
ret = session.query(Users).filter_by(name='nick').first()
print(ret)

 那什么样加约束条件等,小编要更加灵活选择,可以吗,依旧见下 code:

# 条件
ret = session.query(Users).filter_by(name='nick').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'nick').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'nick').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='nick'))).all()

from sqlalchemy import and_, or_        # 导入模块
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'nick')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'nick')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'nick', Users.id > 3),
        Users.extra != ""
    )).all()


# 通配符
ret = session.query(Users).filter(Users.name.like('n%')).all()
ret = session.query(Users).filter(~Users.name.like('n%')).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
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()

ret = session.query(Person).join(Favor, isouter=True).all()

# isouter=True 理解为 left join ,如果不写为 inner 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()

 

Python 操作 MySQL 之 pysql 与 ORM,pysqlorm 本文针对 Python 操作 MySQL 主要选取的二种艺术疏解: 原生模块 pymsql ORM框...

使用:

  • 导入模块:
    • 导入连接数据库模块:from sqlalchemy import create_engine
    • 如果急需创制新表,则供给导入表结构定义模块:from sqlalchemy.ext.declarative import declarative_base
    • 导入别的相关模块,首若是炫丽的类,如字段映射为Column,如数据类型int映射为Integer,如索引映射为Index,需求哪些导入什么:from sqlalchemy import Column,Integer,String
    • 照耀关系:
      数据库中 映射 模块【如果可以从多个模块处导入,用 | 分隔】【方式太多,可能有漏,但不影响导入】
      Table from sqlalchemy import Table
      int Integer from sqlalchemy.types import Integer
      索引 Index from sqlalchemy import Index
           
      字段、列 Column from sqlalchemy import Column
      varchar VARCHAR、String from sqlalchemy.types import String    |   from sqlalchemy import String
      外键 ForeignKey
      from sqlalchemy import ForeignKey
           
           
  • 连天数据库:连接对象=create_engine('数据库类型 数据库驱动名称://客商名:口令@机器地址:端口号/数据库名',编码格式,echo)
    • sqlalchemy帮衬八种API操作情势,能够使用差异的方式来连接操作数据库:'数据库类型 数据库驱动名称://客商名:口令@机器地址:端口号/数据库名'
      • 比如pymsql【py3常用】:mysql pymysql://<username>:<password>@<host>/<dbname>[?<options>
    • 其余参数:
      • echo是不是呈现ORM转成实际sql语句的历程,echo=True为显
      • encoding为连接时使用的字符集

 

增加补充表达:

1.engine 足以间接运维sql语句,方式是engine.execute(),再次来到值是结果集,能够使用fetchall等方法来赢得结果

2.其实创立表还有众多措施,能够行使各类对象来创设【比方在上头Table形式中也得以动用t来create(engine)】,但提出接纳方式大器晚成

3.风流倜傥致的,不单创立表有各类艺术,查看表,删除表等也许有多样操作方式,也是因为能够行使种种对象来操作

4.session也能够一贯运转sql语句: session.execute()

 

 

依靠sessionmake API官方文书档案:

以致一个第三方援救文书档案: 里面有无尽有关sqlalchemy的用法例子

 


相关内容: 使用pymysql直接操作mysql 创立表 查看表 改过表 删除表 插入数据 查看数据...

二、SQLAlchemy

SQLAlchemy 简单的称呼 ORM 框架,该框架营造在数据库的 API 之上,使用关系对象映射来举办数据库操作;

简言之正是:将类对象转变来 SQL 语句,然后利用数据 API 实施 SQL 语句并得到推行结果。

介绍:

  • ORM 将数据库中的表与面向对象语言中的类建构了意气风发种对应涉及,【ORM可以说是仿照效法映射来管理数量的模型,比方说:须要创立叁个表,能够定义叁个类,而以此类存在与表相映射的性质,那么可以透过操作那么些类来创建多个表】
  • sqlmary是一个mysql的ORM

前提:

  • 安装模块:pip3 install sqlalchemy

操作:

基本操作:

  • 创造新表

    • 方法一: 使用declarative

      • 1.导入模块from sqlalchemy.ext.declarative import declarative_base
      • 2.根据需要的元素来导入模块``from sqlalchemy import Column
        • 导入需要的数据类型【注:数据类型在sqlalchemy中也有指向,所以也可以from sqlalchemy import String,Integer,Char】:from sqlalchemy.types import *
      • 3.创建连接,
      • 3.使用declarative_base来获得一个类对象,此处我定义该对象为Base
      • 定义一个类,继承declarative_base生成的类对象Base
        • 使用__tablename__来定义表名
        • 使用 列名 = Column(数据类型,其他列属性…)等类似格式来定义字段
          • nullable=False 代表这一列不可感觉空,index=True 表示在该列创造索
      • 创建表:Base.metadata.create_all(engine)

        from sqlalchemy import create_engine#负责导入连接数据库的对象
        from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
        from sqlalchemy import Column #负责导入列
        from sqlalchemy.types import *#负责导入列类型
        
        #数据库连接
        engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8',echo=True)
        #方式一:
        Base = declarative_base()
        
        class User(Base):
            __tablename__ = 'user'#表名
            id = Column(Integer,primary_key=True)
            name = Column(String(32))
            password = Column(String(64))
        
        Base.metadata.create_all(engine)
        

     

    • 方法二:使用Table
      • 1.导入模块: from sqlalchemy import Table
      • 2.接连数据库:engine=create_engine(….)
      • 3.获取meta类,metadata=MetaData(engine)
      • 4.创建Table对象( 比如:t=Table("group" ,metadata,Column("id",Integer,primary_key=True),Column("group_name",String(32)))  )
      • 5.创建表:metadata.create_all()
        from sqlalchemy import create_engine
        from sqlalchemy import Table
        from sqlalchemy import MetaData
        from sqlalchemy import Column
        from sqlalchemy.types import *
        from sqlalchemy.ext.declarative import declarative_base
        
            ####下面的注释部分可以与上面一句的未注释的替换
            engine=create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8',echo=True)
            metadata=MetaData(engine) ###  
            # Base=declarative_base()

            t=Table(
            "group" ,metadata,#表名
            # "group",Base.metadata,
            Column("id",Integer,primary_key=True),
            Column("group_name",String(32))
            )

            metadata.create_all()
            # Base.metadata.create_all(engine)

 

  • 查看表:
    • db_table=Base.metadata.tables#只有当次运营中一而再延续了Base而创办的新表
    • db_tables=engine.table_names()#唯有表名
  • 删除表:Base.metadata.drop_all(engine)
  • 修改表:
    • 直白修正表所对应的类组织是力不能够及改正成功的,
    • 就算急需纠正在前后相继中自定义的表的组织,那么需求手动矫正,手动的章程有为数不菲,举例直接engine.execute(sql语句)。。。。

 

 

 

  • 插入 数据【这里仅针对利用declarative_base创制的表,对于不是程序中才创制的,能够本身行使declarative_base建贰个类来映射在此以前的表,只要映射生龙活虎致,就会插入数据】

    • 1.连接数据库:engine=create_engine(….)
    • 1.导入模块:from sqlalchemy.orm import sessionmaker
    • 2.获取session_class类:Session_class=sessionmaker(bind=engine)
    • 3.获取session对象:s=Session_class()
    • 4.使用s来添加:
      • s.add()
      • s.add_all()
    • 5.提交多少: s.commit()

      from sqlalchemy import create_engine#负责导入连接数据库的对象
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8',echo=True)
      Base = declarative_base()
      class User(Base):
          __tablename__ = 'user'#表名
          id = Column(Integer,primary_key=True)
          name = Column(String(32))
          password = Column(String(64))
          group = Column(Integer)
      
      Base.metadata.create_all(engine)
      
        from sqlalchemy.orm import sessionmaker
        obj1=User(name='lisi',password='123456',group=1)

        Session=sessionmaker(bind=engine)
        s=Session()
        s.add(obj1)#

        users=[User(name='wangwu',password='123456',group=1),
               User(name='zhaoliu', password='123456', group=1),
               User(name='sunqi', password='123456', group=1)
               ]
        s.add_all(users)#

        s.commit()

 

 

  • 查找 数据

    • 同样适用sessionmaker来查找,与插入相同,需要创建session_class对象(我定义为s)
    • 使用s来查找:

      • s.query(表对应类)是一定于select对应表,前边能够跟first()、all()等来获取结果,也能够加filter、filter_by等来筛选结果
      • 获取全部 : s.query(表对应类).all() 【再次回到的是贰个结果列表】
      • 查找指定: s.query(表对应类).filter(表对应类.xxx==xxxx)【filter获取的是结果集,需要使用all(),first()等方法来获取结果】
      • 查找指定: s.query(表对应类).filter_by(xxx=xxxx)
      • 附:虽然返回值是一个结果集,但这个集合是一个类对象,如果想查看内容,需要在表对应的类中增加__repr__方法。
      • 多个筛选条件使用“,”隔开
      • 常见可用筛选条件【User是一个表对应的类】:

        使用filter,filter_by时:
        User.name==’lisi’
        User.name.like(“lisi%”))
        User.name != ’lisi’
        User.name.any()
        or_(筛选条件) 【代表里面的多个筛选条件以or组合,需要导入:from sqlalchemy import or_】
        and_(筛选条件) 【代表里面的多个筛选条件以and组合,需要导入:from sqlalchemy import and_】【默认是and】
        in_([筛选条件])  【使用比如User.name.in_(['xiaxia', 'lilei', 'lover'])】
        使用all时,以下是放在query里面的:
        User.name  [这相当于不使用where的select name from 表]
         
         
      • 连接查询使用:s.query(表对应类).join(表对应类.xxx==xxxx)

      • 还有group_by,order_by等用法这里不做讲解[什么时候有空再补吧!]

        from sqlalchemy import create_engine#负责导入连接数据库的对象
        from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
        from sqlalchemy import Column #负责导入列
        from sqlalchemy.types import *#负责导入列类型
        
        #数据库连接
        engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8')
        Base = declarative_base()
        class User(Base):
            __tablename__ = 'user'#表名
            id = Column(Integer,primary_key=True)
            name = Column(String(32))
            password = Column(String(64))
            group = Column(Integer)
        
            def __repr__(self):
                return "<id:%s name:%s group:%s>"%(self.id,self.name,self.group)
        Base.metadata.create_all(engine)
        
            from sqlalchemy.orm import sessionmaker
            obj1=User(name='lisi',password='123456',group=1)

            Session=sessionmaker(bind=engine)
            s=Session()

            a=s.query(User).all()
            a2=s.query(User).filter(User.name=='lisi').first()
            a3=s.query(User).filter_by(name='lisi').first()



            print(a)
            print(a2)
            print(a3)

 

 

  • 修改 数据:

    • 改正数据的基础是先查找到数据,查找:row=s.query(X).filter(X.xxx=xxx).first()
    • 采用赋值语句修正 :row.xxx=xxxx

      from sqlalchemy import create_engine#负责导入连接数据库的对象
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8')
      Base = declarative_base()
      class User(Base):
          __tablename__ = 'user'#表名
          id = Column(Integer,primary_key=True)
          name = Column(String(32))
          password = Column(String(64))
          group = Column(Integer)
      
          def __repr__(self):
              return "<id:%s name:%s group:%s>"%(self.id,self.name,self.group)
      Base.metadata.create_all(engine)
      
        from sqlalchemy.orm import sessionmaker
        obj1=User(name='lisi',password='123456',group=1)

        Session=sessionmaker(bind=engine)
        s=Session()


        row=s.query(User).filter(User.name=='lisi').first()
        row.name='lisi2'
        s.commit()

 

 

  • 删除 数据:

    • 去除数据的底蕴是先查找到数据,查找:row=s.query(X).filter(X.xxx=xxx)
    • 使用delete删除:row.delete()

      # coding: utf-8
      from sqlalchemy import create_engine#负责导入连接数据库的对象
      from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
      from sqlalchemy import Column #负责导入列
      from sqlalchemy.types import *#负责导入列类型
      
      #数据库连接
      engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8')
      Base = declarative_base()
      class User(Base):
          __tablename__ = 'user'#表名
          id = Column(Integer,primary_key=True)
          name = Column(String(32))
          password = Column(String(64))
          group = Column(Integer)
          def __repr__(self):
              return "<id:%s name:%s group:%s>"%(self.id,self.name,self.group)
      
      Base.metadata.create_all(engine)
      
        from sqlalchemy.orm import sessionmaker
        obj1=User(name='lisi',password='123456',group=1)

        Session=sessionmaker(bind=engine)
        s=Session()


        a3=s.query(User).filter_by(name='lisi1')
        a3.delete()
        s.commit()

 

  • 外键相关:

    • 外键使用foregin_key创建
    • 类中的relationship的效果:援救ORM获悉他们的外键关系,以便ORM使用外键获取相关数据
      • relationship中的backref的用处:relationship使得能够在二个表中定义的relationshop能被八个表使用,另二个表使用backref来收获相关新闻
      • relationship中的foreign_keys的用处:当有八个relationship时,为了防止ORM混淆多个relationship,特别的标号哪个外键是哪些relationship
      • relationship中的secondary的用途:在多对多的关系中,填入的值是中间表,维持两侧表关系。
    • 一定的外键关系:

      • 1.导入模块:from sqlalchemy import Foreign_key
      • 2.成家立业外键(如:group = Column(Integer,ForeignKey("group.id")),建构关系(如:group_relation=relationship('Group',backref="g_users")
      • 3.插入数据
      • 4.查询到一条数据:如row=s.query(User).filter(User.name=='lisi').first()
      • 5.尝试A表调用关系来收获B(row.group_relation.group_name),B使用backref来获取A的数据(row2.g_users)
      • 上边包车型大巴实例大致正是“一个开采职员对应八个开辟组的涉嫌”

      #担负导入连接数据库的对象 from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base#肩负导入创造表的api from sqlalchemy import Column,ForeignKey #负担导入列 from sqlalchemy.types import *#担任导入列类型 from sqlalchemy.orm import relationship

      #数据库连接 engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8') Base = declarative_base()

    class Group(Base):
        __tablename__="group"
        id=Column(Integer,primary_key=True)
        group_name=Column(String(32),nullable=False)

        def __repr__(self):
            return "<id:%s group_name:%s>"%(self.id,self.group_name)

    class User(Base):
        __tablename__ = 'user'#表名
        id = Column(Integer,primary_key=True)
        name = Column(String(32),nullable=False)
        password = Column(String(64),nullable=False)
        group = Column(Integer,ForeignKey("group.id"))#这里创建外键

        group_relation=relationship('Group',backref="g_users")#为ORM指明关系,方便ORM处理,第一个是对应的类
        def __repr__(self):
            return "<id:%s name:%s>"%(self.id,self.name)
    Base.metadata.create_all(engine)

    from sqlalchemy.orm import sessionmaker
    # group1=Group(group_name='python')
    # group2=Group(group_name='linux')
    # group3=Group(group_name='AI')
    # user1=User(name='lisi',password='123456',group=1)
    # user2=User(name='zhangsan',password='123456',group=2)
    # user3=User(name='wangwu',password='123456',group=3)
    # user4=User(name='lilei',password='123456',group=3)


    Session=sessionmaker(bind=engine)
    s=Session()
    # s.add_all([group1,group2,group3,user1,user2,user3,user4])
    # s.commit()

    # row=s.query(User).filter(User.name=='lisi').first()
    row=s.query(User).first()
    print(row.group_relation.group_name)#这里User通过关系来获取Group的数据
    row2=s.query(Group).first()
    print(row2)
    print(row2.g_users)#这里Group通过relationship的backref来获取User的数据

-   一对多关系,外键关联
    -   `以一个老师能做一个班的班主任此外还能做另一个班的副班主任为例【即一个老师能对应多个班级】`
    -   一对多关系的创建的核心是relationship中的foreign_keys
    -   `附:当你建表成功而插入数据失败时,可以尝试先删除掉数据表,有时候因为外键依赖会导致插入失败 

`

            #负责导入连接数据库的对象
            from sqlalchemy import create_engine
            from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
            from sqlalchemy import Column,ForeignKey #负责导入列
            from sqlalchemy.types import *#负责导入列类型
            from sqlalchemy.orm import relationship

            #数据库连接
            engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8')
            Base = declarative_base()



            class Grade(Base):
                __tablename__="grade"
                id=Column(Integer,primary_key=True)
                grade_name=Column(String(32),nullable=False)

                def __repr__(self):
                    return "<id:%s group_name:%s>"%(self.id,self.grade_name)

            class Teacher(Base):
                __tablename__ = 'teacher'#表名
                id = Column(Integer,primary_key=True)
                name = Column(String(32),nullable=False)
                primary_grade = Column(Integer,ForeignKey("grade.id"))
                second_grade = Column(Integer,ForeignKey("grade.id"))

                primary_grade_relation=relationship('Grade',backref="first_teacher",foreign_keys=[primary_grade])
                second_grade_relation=relationship('Grade',backref="second_teacher",foreign_keys=[second_grade])
                def __repr__(self):
                    return "<id:%s name:%s>"%(self.id,self.name)


            Base.metadata.create_all(engine)

            from sqlalchemy.orm import sessionmaker
            # grade1=Grade(grade_name='python')
            # grade2=Grade(grade_name='linux')
            # grade3=Grade(grade_name='AI')
            # grade4=Grade(grade_name='Java')
            # t1=Teacher(name='lisi',primary_grade=1,second_grade=2)
            # t2=Teacher(name='zhangsan',primary_grade=2,second_grade=1)
            # t3=Teacher(name='wangwu',primary_grade=4,second_grade=3)
            # t4=Teacher(name='lilei',primary_grade_relation=grade3,second_grade=4)
            #这里外键相关的比如primary_grade=x可以使用primary_grade_relation=对象来代替,
            # 会根据对象来转成对应id,不过问题是不知道grade3的准确id,因为可能创建顺序不一致

            Session=sessionmaker(bind=engine)
            s=Session()
            # s.add_all([grade1,grade2,grade3,grade4])
            # s.add_all([t1,t2,t3,t4])
            # s.commit()

            row=s.query(Teacher).filter(Teacher.name=='lisi').first()

            print(row.name,row.primary_grade_relation.grade_name)#这里Teacher通过关系来获取Grade的数据
            print(row.name,row.second_grade_relation.grade_name)
            row2=s.query(Grade).first()
            print(row2.grade_name,row2.first_teacher)#这里Grade通过relationship的backref来获取Teacher的数据
            print(row2.grade_name,row2.second_teacher)

`` 

-   多对多外键关联
    -   以选课中一门课能有多名学生,一个学生可以选多门课为示例:
    -   其中relationship中的secondary的值是中间表,负责维持中间表与另外两表的关系,创建多对多的核心是secondary
            #负责导入连接数据库的对象
            from sqlalchemy import create_engine
            from sqlalchemy.ext.declarative import declarative_base#负责导入创建表的api
            from sqlalchemy import Column,ForeignKey #负责导入列
            from sqlalchemy.types import *#负责导入列类型
            from sqlalchemy.orm import relationship

            #数据库连接
            engine = create_engine("mysql pymysql://root:123456@localhost/python_test",encoding ='utf-8')
            Base = declarative_base()

            class SelectInfo(Base):
                __tablename__="selectClassInfo"
                id=Column(Integer,primary_key=True)
                sid=Column(Integer,ForeignKey("student.id"))
                cid=Column(Integer,ForeignKey("course.id"))


            """使用declarative_base和Table 创建表时,secondary的填写不一样
            selectInfo2=Table(
            'selectClassInfo',Base.metadata,
            Column('sid',Integer,ForeignKey('student.id'))
            Column('cid',Integer,ForeignKey('student.id'))
            )
            """

            class Student(Base):
                __tablename__="student"
                id=Column(Integer,primary_key=True)
                name=Column(String(32),nullable=False)

                def __repr__(self):
                    return "<id:%s name:%s>"%(self.id,self.name)

            class Course(Base):
                __tablename__ = 'course'
                id = Column(Integer,primary_key=True)
                name = Column(String(32),nullable=False)

                student_relation=relationship('Student',secondary="selectClassInfo",backref="courses")
                # student_relation=relationship('Student',secondary=selectClassInfo2,backref="courses") 
                # #如果使用Table来创建中间表,上面是这样填的

                def __repr__(self):
                    return "<id:%s name:%s>"%(self.id,self.name)


            Base.metadata.create_all(engine)

            from sqlalchemy.orm import sessionmaker
            #
            # s1=Student(name='lisi')
            # s2=Student(name='zhangsan')
            # s3=Student(name='wangwu')
            # s4=Student(name='lilei')
            # c1=Course(name='python',student_relation=[s1,s2])
            # c2=Course(name='linux',student_relation=[s3])
            # c3=Course(name='AI',student_relation=[s3,s4])
            # c4=Course(name='Java')
            # c4.student_relation=[s1,s2,s3,s4]##在一边增加关系之后,在secondary中会加入两边的数据
            #
            #
            #
            Session=sessionmaker(bind=engine)
            s=Session()
            # s.add_all([s1,s2,s3,s4,c1,c2,c3,c4])
            # s.commit()

            row=s.query(Course).filter(Course.id=='4').first()

            print(row.name,row.student_relation)#这里Course通过关系来获取Student的数据
            row2=s.query(Student).filter(Student.id=="3").first()
            print(row2.name,row2.courses)#这里Student通过relationship的backref来获取Course的数据

 

 

 

 

本文由时时app平台注册网站发布于编程知识,转载请注明出处:Python(九)【分分钟通晓】 Python 操作 MySQL 之

关键词: