MySQL

MySQL相关文章这里不在赘述,想了解的点击下面的链接:

>> MySQL安装

>> 数据库介绍 && MySQL基本使用

>> MySQL使用(一)

>> MySQL使用(二)

Python操作MySQL

本篇对于Python操作MySQL主要使用两种方式:

  • 原生模块 pymsql
  • ORM框架 SQLAchemy

pymysql

pymsql是Python中操作MySQL的模块,其使用方法和MySQLdb几乎相同。

下载安装

pip3 install pymysql

使用操作

1、执行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()

2、获取新创建数据自增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

3、获取查询数据

#!/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()

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

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

4、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()

ORM && sqlalchemy

ORM介绍

ORM英文全称object relational mapping,就是对象映射关系程序,简单来说我们类似python这种面向对象的程序来说一切皆对象,但是我们使用的数据库却都是关系型的,为了保证一致的使用习惯,通过ORM将编程语言的对象模型和数据库的关系模型建立映射关系,这样我们在使用编程语言对数据库进行操作的时候可以直接使用编程语言的对象模型进行操作就可以了,而不用直接使用SQL语言。

ORM的优点:

  1. 隐藏了数据访问细节,“封闭”的通用数据库交互,ORM的核心。他使得我们的通用数据库交互变得简单易行,并且完全不用考虑该死的SQL语句。快速开发,由此而来。
  2. ORM使我们构造固化数据结构变得简单易行。

ORM的缺点:

  1. 无可避免的,自动化意味着映射和关联管理,代价是牺牲性能(早期,这是所有不喜欢ORM人的共同点)。现在的各种ORM框架都在尝试使用各种方法来减轻这块(LazyLoad,Cache),效果还是很显著的。

sqlalchemy

SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果点击这里了解主要用户列表

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

sqlalchemy 安装

pip3 install SQLAlchemy

sqlalchemy 操作数据

使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象,对象转换成SQL,执行SQL。

#!/usr/bin/env python
#-*-coding:utf-8-*-
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 engine = create_engine("mysql+pymysql://root:123456@192.168.92.201/test?charset=utf8",encoding='utf-8',echo=True) Base = declarative_base() # 生成ORM基类 class User(Base):
__tablename__='users' # 表名
id = Column(Integer,primary_key=True)
name = Column(String(32))
password = Column(String(64)) def __repr__(self): # 让返回的数据不直接是对象,变得可读
return "<User(name='%s',password='%s')>" % (self.name,self.password) # 创建表结构:寻找Base的所有子类,按照子类的结构在数据库中生成对应的数据表信息
# Base.metadata.create_all(engine) Session_class = sessionmaker(bind=engine)
session = Session_class() ################### 插入一条数据 ###################
data1 = User(name="Jack",password="123")
session.add(data1)
session.commit() ################### 插入多条数据 ###################
session.add_all([
User(ame="David",password="333")
User(ame="Lily",password="666")
])
session.commit() ##################### 查询数据 #####################
my_user = session.query(User).filter_by(name="David").first()
print (my_user)
# 你可以看到输出结果是 <User(name='David',password='123')> ,如果不加__repr__,返回的数据直接是对象。 ### 其他查询姿势:
my_user = session.query(User).filter(User.id>0).filter(User.id<7).all() # 多条件查询,相当于 user.id >1 AND user.id <7 my_user = session.query(User).filter(User.name.in_(['David','SB'])).all() # select tables in ... my_user = session.query(User.name.label('name_label')).all() # ??? my_user = session.query(User).order_by(User.id).all() # 排序 my_user = session.query(User).order_by(User.id)[1:3] # 结果从1~3顺序显示 my_user = session.query(User).filter(User.name.like("Da%")).count() # like匹配 && 统计 ### 分组查询:
from sqlalchemy import func
my_user = session.query(func.count(User.name),User.name).group_by(User.name).all()
# 相当于SQL为:
SELECT count(user.name) AS count_1, user.name AS user_name FROM user GROUP BY user.name;
# 输出结果为:
[(1, 'Jack'), (2, 'Rain')] print (my_user)
session.commit() ##################### 修改数据 #####################
session.query(User).filter(User.name=="David").update({'password':4848})
session.commit()
# 上述方法可以修改数据,还有一种方法,当你查询出来数据的时候,也可以直接修改,看下面步骤:
my_user = session.query(User).filter_by(name="David").first()
my_user.name = "SB"
session.commit() ##################### 删除数据 #####################
session.query(User).filter(User.name=="David").delete ####################### 回滚 #######################
session.rollback()
# sqlalchemy操作默认就是事务,增删改balabala..只要没commit,随时可以rollback...

注:SQLAlchemy无法修改表结构,如果需要可以使用SQLAlchemy开发者开源的另外一个软件Alembic来完成。

外键关联

我们创建一个addresses表,跟上面创建的users表关联

from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship class Address(Base):
__tablename__ = 'addresses'
id = Column(Integer, primary_key=True)
email_address = Column(String(32), nullable=False)
user_id = Column(Integer, ForeignKey('users.id')) user = relationship("User", backref="addresses") # 允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项 def __repr__(self):
return "<Address(email_address='%s')>" % self.email_address

表创建好后,我们这样来反查试试

obj = Session.query(User).first()
for i in obj.addresses: #通过user对象反查关联的addresses记录
print(i) addr_obj = Session.query(Address).first()
print(addr_obj.users.name) #在addr_obj里直接查关联的users表

创建关联对象

obj = Session.query(User).filter(User.name=='David').all()[0]
print(obj.addresses) obj.addresses = [Address(email_address="xx@jd.com"), #添加关联对象
Address(email_address="oo@jd.com")] session.commit()

多外键关联

下表中,Customer表有2个字段都关联了Address表

#!/usr/bin/env python
#-*-coding:utf-8-*-
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import relationship,sessionmaker
from sqlalchemy import ForeignKey engine = create_engine("mysql+pymysql://root:123456@192.168.92.201/test?charset=utf8",
encoding='utf-8',echo=True) Base = declarative_base() # 生成ORM基类 class Customer(Base):
__tablename__ = 'customer'
id = Column(Integer, primary_key=True)
name = Column(String(64))
billing_address_id = Column(Integer, ForeignKey("new_address.id"))
shipping_address_id = Column(Integer, ForeignKey("new_address.id")) billing_address = relationship("Address",foreign_keys=[billing_address_id]) # 此处添加foreign_keys来执行外键和哪个字段对应
shipping_address = relationship("Address",foreign_keys=[shipping_address_id]) class Address(Base):
__tablename__ = 'new_address'
id = Column(Integer, primary_key=True)
street = Column(String(64))
city = Column(String(64))
state = Column(String(64)) # Base.metadata.create_all(engine) Session_class = sessionmaker(bind=engine)
session = Session_class() # 添加几个数据试试!!
addr1 = Address(street="fengtai",city="beijing",state="china")
addr2 = Address(street="haidian",city="beijing",state="china")
addr3 = Address(street="fangshan",city="beijing",state="china") c1 = Customer(name="user1",billing_address_id="2",shipping_address_id="3")
c2 = Customer(name="user2",billing_address_id="1",shipping_address_id="3")
c3 = Customer(name="user3",billing_address_id="3",shipping_address_id="3") session.add_all([addr1,addr2,addr3,c1,c2,c3])
session.commit()

多对多关系

现在来设计一个能描述“图书”与“作者”的关系的表结构,需求是:

  1. 一本书可以有好几个作者一起出版
  2. 一个作者可以写好几本书

此时,我们可以再搞出一张中间表,来关联书名和作者。

下面我们通过book_m2m_author表完成了book表和author表之前的多对多关联

#!/usr/bin/env python
#-*-coding:utf-8-*-
from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey,engine
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker engine = create_engine("mysql+pymysql://root:123456@192.168.92.201/test?charset=utf8",
encoding='utf-8',echo=True) Base = declarative_base() # 创建一个表来让sqlalchemy关联authors表和books表
book_m2m_author = Table('book_m2m_author', Base.metadata,
Column('book_id',Integer,ForeignKey('books.id')),
Column('author_id',Integer,ForeignKey('authors.id')),
) class Book(Base):
__tablename__ = 'books'
id = Column(Integer,primary_key=True)
name = Column(String(64))
pub_date = Column(DATE)
authors = relationship('Author',secondary=book_m2m_author,backref='books') def __repr__(self):
return self.name class Author(Base):
__tablename__ = 'authors'
id = Column(Integer, primary_key=True)
name = Column(String(32)) def __repr__(self):
return self.name # Base.metadata.create_all(engine)
Session_class = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
s = Session_class() #生成session实例 # 插入数据
b1 = Book(name="book1",pub_date="2016-05-08")
b2 = Book(name="book2",pub_date="2017-06-08")
b3 = Book(name="book3",pub_date="2018-07-08")
b4 = Book(name="book4",pub_date="2019-08-08")
b5 = Book(name="book5",pub_date="2020-08-08") a1 = Author(name="Alex")
a2 = Author(name="Jack")
a3 = Author(name="Rain")
a4 = Author(name="David") b1.authors = [a1,a2]
b2.authors = [a1,a2,a3]
b5.authors = [a4] s.add_all([b1,b2,b3,b4,b5,a1,a2,a3,a4])
s.commit()

此时,我们去用orm查一下数据

print('--------通过书表查关联的作者---------')

book_obj = s.query(Book).filter_by(name="book1").first()
print(book_obj.name, book_obj.authors) print('--------通过作者表查关联的书---------')
author_obj =s.query(Author).filter_by(name="David").first()
print(author_obj.name , author_obj.books)
s.commit()

输出如下

--------通过书表查关联的作者---------
book1 [David, Jack]
--------通过作者表查关联的书---------
Alex [book3, book4]

这就实现了多对多关系啦!

多对多删除

删除数据时不用管boo_m2m_authors , sqlalchemy会自动帮你把对应的数据删除

通过书删除作者

author_obj =s.query(Author).filter_by(name="Jack").first()

book_obj = s.query(Book).filter_by(name="book2").first()

book_obj.authors.remove(author_obj) #从一本书里删除一个作者
s.commit()

直接删除作者

删除作者时,会把这个作者跟所有书的关联关系数据也自动删除

author_obj =s.query(Author).filter_by(name="David").first()
# print(author_obj.name , author_obj.books)
s.delete(author_obj)
s.commit()

Python-12-MySQL & sqlalchemy ORM的更多相关文章

  1. Python 12 - Mysql & ORM

    本节内容 1.数据库介绍 2.mysql数据库安装使用 3.mysql数据库基础 4.mysql命令 5.事务 6.索引 7.Python操作mysql 8.ORM sqlalchemy了解 数据库介 ...

  2. python操作三大主流数据库(3)python操作mysql③python操作mysql的orm工具sqlaichemy安装配置和使用

    python操作mysql③python操作mysql的orm工具sqlaichemy安装配置和使用 手册地址: http://docs.sqlalchemy.org/en/rel_1_1/orm/i ...

  3. Python自动化 【第十二篇】:Python进阶-MySQL和ORM

    本节内容 数据库介绍 mysql 数据库安装使用 mysql管理 mysql 数据类型 常用mysql命令 创建数据库 外键 增删改查表 权限 事务 索引 python 操作mysql ORM sql ...

  4. python对Mysql操作和使用ORM框架(SQLAlchemy)

    python对mysql的操作 Mysql 常见操作 数据库操作 创建数据库 create database fuzjtest 删除数据库 drop database fuzjtest 查询数据库 s ...

  5. python 学习笔记十一 SQLALchemy ORM(进阶篇)

    SqlAlchemy ORM SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据A ...

  6. Python-Day12 Python mysql and ORM

    一.Mysql数据库 1.什么是数据库? 数据库(Database)是按照数据结构来组织.存储和管理数据的仓库,    每个数据库都有一个或多个不同的API用于创建,访问,管理,搜索和复制所保存的数据 ...

  7. python 之路,Day11 (下)- sqlalchemy ORM

    python 之路,Day11 - sqlalchemy ORM   本节内容 ORM介绍 sqlalchemy安装 sqlalchemy基本使用 多外键关联 多对多关系 表结构设计作业 1. ORM ...

  8. Python之路第十二天,高级(5)-Python操作Mysql,SqlAlchemy

    Mysql基础 一.安装 Windows: 1.下载 http://dev.mysql.com/get/Downloads/MySQL-5.6/mysql-5.6.31-winx64.zip 2.解压 ...

  9. MySQL之ORM框架SQLAlchemy

    一 介绍 SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取 ...

  10. sqlalchemy orm 操作 MySQL

    一.ORM介绍 orm英文全称object relational mapping,是对象映射关系程序,简单来说类似python这种面向对象的程序来说一切皆对象,但是我们使用的数据库却都是关系型的,为了 ...

随机推荐

  1. 《C#微信开发系列(4)-接收 / 返回文本消息》

    4.0接收 / 返回文本消息 ①接收/返回文本消息原理说明 当普通微信用户向公众账号发消息时,微信服务器将POST消息的XML数据包到开发者填写的URL上,着手开发之前先行阅读微信公众平台接收普通消息 ...

  2. if语句,case语句

    1.句式:if...then.判断赋值 例: if RadioButton1.Checked then sex:='男' else if RadioButton2.Checked then sex:= ...

  3. SharePoint 2007 User Re-created in AD with new SID issue on MySite

    When active directory users get deleted and re-created, even with the same user id, there's a nasty ...

  4. android:Intent匹配action,category和data原则

    1.当你在androidmanifest里面定义了一个或多个action时 你使用隐式意图其他activity或者service时,规定你隐式里面的action必须匹配XML中定义的action,可以 ...

  5. [原创]python之socket-ftp

    今天来讲讲ftp文件下载,感觉挺有趣的,知道吧,就那种看到新文件生成,而自己写的代码也不多,那种成就感! 一.需求: 客户端发送指令给服务端,服务端根据指令找到相应文件,发送给客户端 分析: PS:e ...

  6. 基于Ruby的watir-webdriver自动化测试方案与实施(四)

    接着基于Ruby的watir-webdriver自动化测试方案与实施(三) http://www.cnblogs.com/Javame/p/4159468.html 继续 ... ...   首先回忆 ...

  7. 页面之间传值方式的总结,五种方式,通知,block,代理,单例,NSUERDEFALUT,

    首先代码拿上 1:单例 2:通知 3:代理 4:block方法 5:NSUSERDEFAULT(沙盒文件) 先是单例类: .h文件 @interface DataSource : NSObject @ ...

  8. width 、 height 与 box-sizing : border-box ,content-box 的关系

    默认 width .height的 content-box 的宽高. box-sizing 经常用来设置 width.height指定的区域 box-sizing 经常用做一些自适应的布局. 语法: ...

  9. 数据仓库之启用cdc

    准备工作: 先将sqlservere 代理服务启动 USE [MyDB]; GO EXECUTE sys.sp_cdc_enable_db; --启用数据库对CDC的支持 GO -- 设置别名 @ca ...

  10. 【转载】latch: cache buffers chains

    本文转自惜分飞的博客,博客原文地址:www.xifenfei.com/1109.html,支持原创,分享知识! 当一个数据块读入sga区,相应的buffer header会被放置到hash列表上,我们 ...