python第十二周：SQL alchemy、pymysql

python操作MySQL

mysqldb

python3之后的版本就不支持mysqldb了，故在此略过

pymysql

#执行SQL语句

# -*- coding:utf-8 -*-
#!/user/bin/env.python
#Author:Mr Wu

import pymysql

#建立连接
conn = pymysql.connect(host=‘localhost‘,port=3306,user=‘root‘,passwd=‘187847‘,db=‘testdb‘)

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

#删除study_record表的所有数据,并返回受影响的行数
effect_row = cursor.execute("delete from study_record where id>=1")

#删除student表的所有数据,并返回受影响的行数
effect_row = cursor.execute("delete from student where stu_id>=1")

#向student表中添加单条数据
effect_row = cursor.execute(‘insert into student(name,age,register_date) values ("N1",20,"2010-09-24")‘)

#向student表中批量插入数据
data = [
    ("N2",33,"2005-08-02"),
    ("N3",23,"2009-08-02"),
    ("N4",13,"2000-08-02"),
    ("N5",43,"1899-08-02"),
    ("N6",53,"1777-08-02"),
]
effect_row = cursor.executemany(‘insert into student (name,age,register_date) values (%s,%s,%s)‘,data)

#修改student表中的数据
effect_row = cursor.execute(‘update student set age=50 where stu_id=10‘)

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

#关闭游标
cursor.close()

#关闭连接
conn.close()

#获取新创建数据自增ID

import pymysql

#建立连接
conn = pymysql.connect(host=‘localhost‘,port=3306,user=‘root‘,passwd=‘187847‘,db=‘testdb‘)

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

cursor.execute("insert into study_record(day,status,stu_id) values (1,‘Y‘,8)")
conn.commit()
cursor.close()
conn.close()

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

#获取查询数据

import pymysql

#建立连接
conn = pymysql.connect(host=‘localhost‘,port=3306,user=‘root‘,passwd=‘187847‘,db=‘testdb‘)

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

cursor.execute(‘select * from student‘)

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

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

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

conn.commit()
cursor.close()
conn.close()
#注：已经获取的数据不能再次获取

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

cursor.scroll(1,mode=‘relative‘)  # 相对当前位置移动

cursor.scroll(2,mode=‘absolute‘) # 相对绝对位置移动

#fetch数据类型

默认获取的数据时元组类型，如果想要字典类型数据，需执行相应操作

import pymysql

#建立连接
conn = pymysql.connect(host=‘localhost‘,port=3306,user=‘root‘,passwd=‘187847‘,db=‘testdb‘)

#创建游标,将游标设置为字典类型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) #获取查询数据时，输出字典格式

cursor.execute(‘select * from student‘)

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

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

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

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

SQLachemy

orm简绍

描述：orm是一种对象映射关系程序，orm将编程语言的对象模型和数据库的关系模型建立映射关系，这样我们就能直接使用编程语言的对象模型进行对数据库的操作，而不必写自己不熟悉的数据库语句了。

orm优点：

1.隐藏了数据访问细节，使我们对数据库的操作变得简单，不必亲自写SQL语句

2.能让我们更容易构造固化数据结构

orm缺点：

由于需要将编程语言与数据库之间建立映射关系和关联管理，这会使得程序的性能低下

sqlalchemy

python常用的orm框架是SQLALchemy

sqlalchemy基本使用

#创建数据表

使用sqlalchemy创建数据表有两种方式

第一种

# -*- coding:utf-8 -*-
#!/user/bin/env.python
#Author:Mr Wu

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,Date,Enum

#建立连接
engine = create_engine("mysql+pymysql://root:187847@localhost/testdb")
#生成orm基类
Base = declarative_base()

class Student(Base):
    ‘‘‘创建学生表‘‘‘
    __tablename__ = "student" #表名
    stu_id = Column(Integer,primary_key=True) #自动设置为自增属性
    name = Column(String(32),nullable=False)
    age = Column(Integer,nullable=False)
    register_date = Column(Date,nullable=False)
#统一创建表结构
Base.metadata.create_all(engine)

第二种

# -*- coding:utf-8 -*-
#!/user/bin/env.python
#Author:Mr Wu

import sqlalchemy
from sqlalchemy import Table,Column
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy import Date,Integer,String,Enum

#建立连接
engine = sqlalchemy.create_engine("mysql+pymysql://root:187847@localhost/testdb")
#生成orm基类
Base = declarative_base()
study_record = Table("study_record",Base.metadata,
                     Column(‘id‘,Integer,primary_key=True),
                     Column(‘day‘,Integer,nullable=False),
                     Column(‘status‘,Enum(‘Y‘,"N"))
                     )

Base.metadata.create_all(engine)

#插入数据

# -*- coding:utf-8 -*-
#!/user/bin/env.python
#Author:Mr Wu

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

#建立连接
engine = create_engine("mysql+pymysql://root:187847@localhost/testdb?charset=utf8")
#生成orm基类
Base = declarative_base()

class Student(Base):
    ‘‘‘建立于student表的映射关联‘‘‘
    __tablename__="student"
    stu_id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    age = Column(Integer,nullable=False)
    register_date = Column(Date,nullable=False)
Base.metadata.create_all(engine)
#创建于数据库的会话，返回的是一个对象
Session_class = sessionmaker(bind=engine)
#生成session实例
Session = Session_class()
#创建要插入的数据对象
s1 = Student(name="赵腊月",age=18,register_date="1999-09-23")
s2 = Student(name="徐有容",age=18,register_date="1999-08-13")
s3 = Student(name="白落衡",age=14,register_date="2003-09-03")
s4 = Student(name="白早",age=24,register_date="1993-02-24")
s5 = Student(name="过冬",age=30,register_date="1887-09-25")
s6 = Student(name="南忘",age=35,register_date="1882-09-21")
#把要出入入的数据对象添加到session中，统一创建
Session.add_all([s1,s2,s3,s4,s5,s6])
#此时才统一提交，创建数据
Session.commit()

#查询数据

常用查询语法：

#equals
Session.query(Student).filter(Student.name=="XXX")
#not equals
Session.query(Student).filter(Student.name!="XXX")
#LIKE
Session.query(Student).filter(Student.name.like("%xxx%"))
#NOT LIKE
Session.query(Student).filter(Student.name.notlike("%xxx%"))
#IN
Session.query(Student).filter(Student.name.in_([‘xxx‘,‘yyy‘]))
#NOT IN
Session.query(Student).filter(Student.name.notin_([‘xxx‘,‘yyy‘]))
#LIke、IN
#Session.query(Student).filter(Student.name.in_(Session.query(Student.name).filter(Student.name.like(‘%xxx%‘)).all())).all()
#多条件查询/from sqlalchemy import and_
Session.query(Student).filter(Student.name==‘xxx‘,Student.age==‘xxx‘).all()
Session.query(Student).filter(Student.name==‘xxx‘).filter(Student.age==‘xxx‘).all()
Session.query(Student).filter(and_(Student.name==‘xxx‘,Student.age==‘xxx‘)).all()

查询实例：

# -*- coding:utf-8 -*-
#!/user/bin/env.python
#Author:Mr Wu

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

#建立连接
engine = create_engine("mysql+pymysql://root:187847@localhost/testdb?charset=utf8")
#生成orm基类
Base = declarative_base()

class Student(Base):
    ‘‘‘建立于student表的映射关联‘‘‘
    __tablename__="student"
    stu_id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    age = Column(Integer,nullable=False)
    register_date = Column(Date,nullable=False)
    def __repr__(self):
        ‘‘‘制定查询完成后，返回的数据‘‘‘
        return ("-->stu_id: %s name: %s age: %s register_date:%s"%(self.stu_id,self.name,self.age,self.register_date))
Base.metadata.create_all(engine)
#创建于数据库的会话，返回的是一个对象
Session_class = sessionmaker(bind=engine)
#生成session实例
Session = Session_class()
#查询stu_id>1的学生的信息,返回的是一个对象列表(每一条记录，就是一个对象)
all_student_obj = Session.query(Student).filter(Student.stu_id>1).all()#获取所有数据
for student_obj in all_student_obj:
    print(student_obj)

#output：
‘‘‘
-->stu_id: 2 name: 徐有容 age: 18 register_date:1999-08-13
-->stu_id: 3 name: 白落衡 age: 14 register_date:2003-09-03
-->stu_id: 4 name: 白早 age: 24 register_date:1993-02-24
-->stu_id: 5 name: 过冬 age: 30 register_date:1887-09-25
-->stu_id: 6 name: 南忘 age: 35 register_date:1882-09-21
‘‘‘

注：当query里面包含字段选项而不只是数据表类时，查询后返回的每一条记录是元组的形式（由

       query里的字段组成）

#修改数据

#修改stu_id=3的学生的年龄为15
student_obj = Session.query(Student).filter(Student.stu_id==3).first()
student_obj.age = 15
#统一提交生效
Session.commit()

#撤销命令

sqlalchemy默认开启事务，因此可以使用回滚撤销事务

student_obj = Session.query(Student).filter(Student.stu_id==3).first()
student_obj.age = 14
print(student_obj.age) #14
Session.rollback()
print(student_obj.age) #15

#多条件查询

#查询stu_id >3 且 age <30的学生的信息
all_student = Session.query(Student).filter(Student.stu_id>3).filter(Student.age<30).all()
for student in all_student:
    print(student)
#output: -->stu_id: 4 name: 白早 age: 24 register_date:1993-02-24

#统计与分组

#统计age>20的学生的人数
stu_number = Session.query(Student).filter(Student.age>20).count()
print(stu_number)
#output: 3
#把学生按照姓名分组输出具有相同名字的人数
#此时返回的每条记录是一个元组,由query里的字段组成
all_obj = Session.query(Student.name,func.count(Student.name)).group_by(Student.name).all()
for obj in all_obj:
    print("name: %s count: %s"%(obj[0],obj[1]))
#output:
‘‘‘
name: 南忘 count: 1
name: 徐有容 count: 1
name: 白早 count: 1
name: 白落衡 count: 1
name: 赵腊月 count: 1
name: 过冬 count: 1
‘‘‘

#外键关联

先建立一张学习记录表与学生表关联，并往其插入几条数据

class Study_record(Base):
    __tablename__="study_record"
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),DefaultClause(‘Y‘))
    stu_id = Column(Integer,ForeignKey(‘student.stu_id‘)) #与student表建立关联
    student = relationship(‘Student‘,backref=‘study_record‘) #与student表建立相互反查的关系
    def __repr__(self):
        return ("day: %s status:%s"%(self.day,self.status))
Base.metadata.create_all(engine)
Session_class = sessionmaker(bind=engine)
Session = Session_class()
s1 = Study_record(day=1,status=‘N‘,stu_id=1)
s2 = Study_record(day=2,stu_id=1)
s3 = Study_record(day=1,stu_id=2)
s4 = Study_record(day=2,status=‘N‘,stu_id=2)
s5 = Study_record(day=1,stu_id=3)
s6 = Study_record(day=2,stu_id=3)
Session.add_all([s1,s2,s3,s4,s5,s6])
Session.commit()

反查示例：查询学习记录表中status=‘Y‘,day=1记录，然后反查学生表中对应的学生

all_study_record = Session.query(Study_record).filter(Study_record.status==‘Y‘,Study_record.day==1).all()
for study_record in all_study_record:
    print(study_record.student)
#output:
‘‘‘
stu_id: 2 name: 徐有容 age: 18
stu_id: 3 name: 白落衡 age: 15
‘‘‘

#多外键关联

即当一张表中有多个外键来自另一张表的情况

这时在设置反查关联的时候，要添加相应的参数，

如：obj_name = relationship(‘obj_name‘,foregin_keys=[column_name(这个是外键字段名)])

否则，反查的时候会分不清通过哪个外键进行反查，于是报错。

#多对多外键关联

1.多对多关系

描述：一个学生会有很多老师来上课，一个老师会教授很多学生，学生和老师之间就是多对多关系。

显然这个时候在某一方设置外键已经无法满足需求了，于是就需要再单独建立一张外键表，其外键分别来自学生表、教师表，并组合成为一个复合主键。这个时候在学生表中查数据时便可以通过这张外键表查询教师表中对应学生的教师信息，反之亦可。

2.通过SQL alchemy建立多对多外键关联

例如：建立上述例子中的学生表、教师表、教师-学生外键表

通过：teacher=relationship("Teacher",secondary=‘student_teacher‘,backref=‘student‘)

建立student表与teacher表的反查关系

# -*- coding:utf-8 -*-
#!/user/bin/env.python
#Author:Mr Wu

import sqlalchemy
from sqlalchemy import create_engine,func,Table
from sqlalchemy.orm import sessionmaker,relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,DefaultClause,ForeignKey

engine = create_engine("mysql+pymysql://root:187847@localhost/testdb?charset=utf8")
Base = declarative_base()

class Student(Base):
    ‘‘‘建立学生表‘‘‘
    __tablename__="student"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    age = Column(Integer,nullable=False)
    teacher = relationship("Teacher",secondary=‘student_teacher‘,backref=‘student‘)
    def __repr__(self):
        return ("name: %s age: %s"%(self.name,self.age))

class Teacher(Base):
    ‘‘‘建立教师表‘‘‘
    __tablename__="teacher"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    age = Column(Integer,nullable=False)
    teach_lesson = Column(String(32),nullable=False)
    def __repr__(self):
        return ("name: %s age: %s teach_lesson: %s"%(self.name,self.age,self.teach_lesson))

#建立student_teacher外键表
student_teacher = Table(
    ‘student_teacher‘,Base.metadata,
    Column(‘stu_id‘,Integer,ForeignKey(‘student.id‘)),
    Column(‘tea_id‘,Integer,ForeignKey(‘teacher.id‘)),
)
Base.metadata.create_all(engine)

插入数据

Session_class = sessionmaker(bind=engine)
Session = Session_class()
s1 = Student(name=‘古桥文乃‘,age=17)
s2 = Student(name=‘照桥心美‘,age=18)
s3 = Student(name=‘绪方理珠‘,age=21)
s4 = Student(name="中野二乃",age=19)
s5 = Student(name=‘中野五月‘,age=20)
t1 = Teacher(name=‘上杉风太郎‘,age=18,teach_lesson=‘math‘)
t2 = Teacher(name=‘唯我成幸‘,age=19,teach_lesson=‘English‘)
t1.student = [s2,s4,s5] #关联教师、学生
t2.student = [s1,s2,s3] #关联教师、学生
Session.add_all([s1,s2,s3,s4,s5,t1,t2])
Session.commit()

查询示例

#查询上杉风太郎的学生的信息
teas_obj = Session.query(Teacher).filter(Teacher.name==‘上杉风太郎‘).first()
for stu_obj in teas_obj.student:
    print(stu_obj)

#output:
‘‘‘
name: 中野二乃 age: 19
name: 中野五月 age: 20
name: 照桥心美 age: 18
‘‘‘

多对多删除

#通过学生删除老师
stu_obj = Session.query(Student).filter(Student.name==‘照桥心美‘).first()
tea_obj = Session.query(Teacher).filter(Teacher.name==‘上杉风太郎‘).first()
stu_obj.teacher.remove(tea_obj)
#直接删除学生,会把学生跟所有老师的关联数据也自动删除
Session.delete(stu_obj)
Session.commit()

原文地址：https://www.cnblogs.com/BUPT-MrWu/p/10376060.html

时间： 2024-11-06 07:21:01

python第十二周：SQL alchemy、pymysql的相关文章

2017-2018-1 《Linux内核原理与设计》第十二周作业

<linux内核原理与设计>第十二周作业 Sql注入基础原理介绍 分组: 和20179215袁琳完成实验 一.实验说明 ??SQL注入攻击通过构建特殊的输入作为参数传入Web应用程序,而这些输入大都是SQL语法里的一些组合,通过执行SQL语句进而执行攻击者所要的操作,本章课程通过 LAMP 搭建 Sql 注入环境,两个实验分别介绍 Sql 注入爆破数据库.Sql 注入绕过验证两个知识点. 首先通过下面命令将代码下载到实验楼环境中,作为参照对比进行学习. $ wget http://labfil

第十二周进度条

第十二周          日期  星期一   星期二   星期三   星期四   星期五   星期六   星期日  了解到的知识点 js获取当前时间 var d = new Date() var nowYear = +d.getFullYear() EF框架填充下拉菜单 var model = db.GYSAllFoods.Select(m => new{GYS = m.GYS}).Distinct();//去重很关键            foreach (var item in model

学习进度第十二周

  第十二周 所花时间(包括上课) 11h(4h上课,7课下) 代码量(行) 220 博客量(篇) 1 了解到的知识点 这个星期主要进行了安卓实验和大作业的编写,从中学到了利用安卓SQLite 数据库 进行表的存储以及应用,按照教程成功编写了一个特别小的视频播放器,学会了进度 条等控件的使用.

学习进度-第十二周

  第十二周 所花时间(包括上课) 10小时 代码量(行) 48行 博客量(篇) 3篇 了解到的知识点

第十二周（补）

这几周有点心不在焉的,学习状态不好,作业都忘记写了,有的是存在记事本里忘记上传 周次 学习时间 新编写代码行数 博客量(数) 学到知识点 第十二周 6 80 1 html                               <html><head> <title> HTML</title></head><body > <h1>会员注册界面</h1><form action="proces

信息安全系统设计基础第十二周学习总结

第十二周代码学习 一.environ.c #include <stdio.h> #include <stdlib.h> int main(void) { printf("PATH=%s\n", getenv("PATH")); setenv("PATH", "hello", 1); printf("PATH=%s\n", getenv("PATH")); #if

第十二周学习进度

第十二周:   第十二周 所花时间(包括上课) 上课4小时,课后4小时 代码量(行) 160 博客量 1 了解到的知识点 找水王

第十二周周总结

周数 专业学习目标 专业学习时间 新增代码量 人文方面的学习 知识技能总结 第 十 二 周 数据结构:了解图的基本定义以及一些专有术语所指内容 3 250左右 <最后的文化贵族><少有人走的路 3> 掌握图的基本定义以及一些专有术语所指内容 计算机网络:动态分配路由 3h 200左右 完成相应实验报告:应尽量脱离课本所给出的实验例句,独立完成 WEB:学习背景图片的有关设置 3h 200左右 掌握背景图片的有关设置

第十二周学习进度条

周次 第十二周 所花时间 12小时以上 代码量 1500行以上 博客量 1 学到知识点 上周也没学什么新的内容,还是对以前学过知识的运用.除此之外还是学习了一些新的知识的.由于使用到弹窗.所以上网找了一下弹窗组件,有个叫layer的挺好用的,对于它的一些最常用的一些内容学习使用了一下.