Python操作MySQL[转]

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

1、原生模块pymsql。

2、ORM框架SQLAchemy。

pymsql

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

windows下载安装

1. pip3 install pymysql

使用操作

执行SQL

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4. import pymysql
5.  
6. # 创建连接
7. conn = pymysql.connect(host='192.168.31.134',port=3306,user='root',passwd='123456',db='information_schema')
8. # 创建游标
9. cursor = conn.cursor()
10. # 执行SQL，并返回受影响行数
11. effect_row = cursor.execute("select * from tables")
12. print(effect_row)
13. # 取出一条数据
14. print(cursor.fetchone())
15. # 取出前n条数据
16. print("*********************************************************")
17. print(cursor.fetchmany(5))
18. # 取出所有数据
19. print("*********************************************************")
20. print(cursor.fetchall())
21. # 提交，不然无法保存新建或修改的数据
22. conn.commit()
23. # 关闭游标
24. cursor.close()
25. # 关闭连接
26. conn.close()

可能报错：pymysql.err.InternalError: (1130, "Host '192.168.31.1' is not allowed to connect to this MySQL server")

可能是因为你的账号不允许从远程登录，只能在localhost登录。只需要在localhost的那台电脑登录mysql，更改对应数据库里的"user"表里的"host"项，把"localhost"改为"%"。

解决办法：

1、改表法

1. [root@lnmp ~]# mysql -uroot -p123456
2. mysql> use test;
3. Database changed
4. mysql> update user set host = '%' where user = 'root';
5. mysql> select host,user from user;
6. mysql> flush rivileges;

2、授权法

允许用户user使用密码password从任何主机连接到mysql服务器。

1. mysql> grant all privileges on *.* to 'user'@'%' identified by 'password' with grant option;
2. mysql> flush privileges;

允许用户user从ip192.168.1.122的主机连接到mysql服务器，并使用password作为密码。

1. mysql> grant all privileges on *.* to 'user'@'192.168.1.122' identified by 'password' with grant option;
2. mysql> flush privileges;

允许用户user从ip192.168.1.122的主机连接到mysql服务器的test_db数据库，并使用password作为密码。

1. mysql> grant all privileges on test_db.* to 'user'@'192.168.1.122' identified by 'password' with grant option;
2. mysql> flush privileges;

插入数据

1. # 插入数据
2. effect_row = cursor.executemany("inster into table_name(field_name1,field_name2) values(%s,%s)",[("value_1","value_2"),("value_3","value_4")])

SQLAlchemy ORM

ORM介绍

对象关系映射（Object Relational Mapping，简称ORM），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的——"虚拟对象数据库"。

面向对象是从软件工程基本原则（如耦合、聚合、封装）的基础上发展起来的，而关系数据库则是从数学理论发展而来的，两套理论存在显著的区别。为了解决这个不匹配的现象，对象关系映射技术应运而生。

对象关系映射（Object Relational Mapping）提供了概念性的、易于理解的模型化数据的方法。ORM方法论基于三个核心原则。简单，以最基本的形式建模数据。传达性，数据库结构被任何人都能理解的语言文档化。精确性，基于数据模型创建正确标准化的结构。典型地，建模者通过收集来自那些熟悉应用程序但不熟练数据建模者开发信息模型。建模者必须能够用非技术企业专家可以理解的术语在概念层次上与数据结构进行通讯。建模者也必须能以简单的单元分析信息，对样本数据进行处理。ORM专门被设计为改进这种联系。

ORM的优点

1、隐藏了数据访问细节，"封闭"的通用数据库交互，ORM的核心。使得通用数据库的交互变得简单易行，并且完全不用考虑SQL语句。

2、ORM使构造固化数据结构变得简单易行。

ORM的缺点

1、自动化意味着映射和关联管理，代价是牺牲性能。现在各种ORM框架都在尝试使用各种方法（如LazyLoad、Cache）来减轻性能的影响，效果比较显著。

2、面向对象的查询语言（OQL）作为一种数据库与对象之间的过渡，虽然隐藏了数据层面的业务抽象，但并不能完全的屏蔽掉数据库层的设计，并且无疑将增加学习成本。

3、对于复杂查询，ORM仍然力不从心。虽然可以实现，但是不值得。视图可以解决大部分calculated column、case、group、having、order by、exists，但是查询条件a and b and not c and (d or e)不能很好解决。

常用的ORM框架

1、Hibernate全自动需要hql语句。

2、iBatis半自动自己写sql语句，可操作性强，小巧。

3、EclipseLink一个可扩展的支持JPA的ORM框架，提供强大的缓存功能，缓存支持集群。

4、Apache OJB等等。

5、在Python中最著名的ORM框架是SQLAlchemy。

SQLAlchemy安装

SQLAlchemy的理念是，SQL数据库的量级和性能重要于对象集合，而对象集合的抽象又重要与表和行。

Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作。

1. MySQL-Python
2.     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
3.  
4. pymysql
5.     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
6.  
7. MySQL-Connector
8.     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
9.  
10. cx_Oracle
11.     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
12.  
13. 更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

安装sqlalchemy

1. pip3 install sqlalchemy

SQLAlchemy基本使用

创建一个表。

SQL实现：

1. CREATE TABLE USER(
2.    ID INTEGER NOT NULL AUTO_INCREMENT,
3.    NAME VARCHAR(32),
4.    PASSWORD VARCHAR(64),
5.    PRIMARY KET (ID)
6. )

ORM实现：

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6.  
7. from sqlalchemy import create_engine
8. from sqlalchemy.ext.declarative import declarative_base
9. from sqlalchemy import Column,Integer,String
10.  
11. # echo=True打印信息
12. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
13.                        encoding='utf-8',echo=True)
14.  
15. # 生成orm基类
16. Base = declarative_base()
17.  
18. class User(Base):
19.     # 表名
20.     __tablename__ = 'USER'
21.     # 定义字段ID，并设置为主键
22.     ID = Column(Integer,primary_key=True)
23.     NAME = Column(String(32))
24.     PASSWORD = Column(String(64))
25. # 创建表结构
26. Base.metadata.create_all(engine)

除了上面的创建表之外，还有一种创建表的方式。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6.  
7. from sqlalchemy import create_engine,Table,MetaData,Column,Integer,String,ForeignKey
8. from sqlalchemy.orm import mapper
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=True)
12. metadata = MetaData()
13.  
14. user = Table('USER_TABLE',metadata,
15.              Column('ID',Integer,primary_key=True),
16.              Column('NAME',String(50)),
17.              Column('FULLNAME',String(50)),
18.              Column('PASSWORD',String(12))
19.              )
20.  
21.  
22. class User(object):
23.     def __init__(self,name,fullname,password):
24.         self.name = name
25.         self.fullname = fullname
26.         self.password = password
27.  
28. mapper(User,user)
29.  
30. # 创建表结构
31. metadata.create_all(engine)

第一种方式创建的表是基于第二种方式的再封装。

使用ORM创建一条数据。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String
7. from sqlalchemy.orm import sessionmaker
8. from sqlalchemy.ext.declarative import declarative_base
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=True)
12. Base = declarative_base()
13.  
14. class User(Base):
15.     __tablename__ = 'USER'
16.     ID = Column(Integer,primary_key=True)
17.     NAME = Column(String(32))
18.     PASSWORD = Column(String(64))
19.  
20. Base.metadata.create_all(engine)
21. # 创建与数据库的会话session class，注意这里返回给session的是一个class，不是实例
22. Session_class = sessionmaker(bind=engine)
23. # 生成session实例
24. Session = Session_class()
25. # 生成要创建的数据对象
26. user_obj = User(NAME="Golden",PASSWORD="123456")
27. # 此时还没有创建对象
28. print(user_obj.NAME,user_obj.ID)
29. # 把需要创建的数据对象添加到session
30. Session.add(user_obj)
31. # 此时还没有创建对象
32. print(user_obj.NAME,user_obj.ID)
33. # 创建数据，统一提交
34. Session.commit()

查询、修改

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String
7. from sqlalchemy.ext.declarative import declarative_base
8. from sqlalchemy.orm import sessionmaker
9. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
10.                        encoding='utf-8',echo=False)
11. Base = declarative_base()
12. class User(Base):
13.     __tablename__ = 'USER'
14.     ID = Column(Integer,primary_key=True)
15.     NAME = Column(String(32))
16.     PASSWORD = Column(String(64))
17.  
18.     def __repr__(self):
19.         return "<NAME : %s | PASSWORD : %s>" %(self.NAME,self.PASSWORD)
20.  
21. Session_class = sessionmaker(bind=engine)
22. Session = Session_class()
23. # first 查出NAME='Golden'的第一个
24. my_user = Session.query(User).filter_by(NAME='Golden').first()
25. print(my_user.NAME,my_user.PASSWORD)
26. # NAME='Golden'
27. data = Session.query(User).filter_by(NAME='Golden').all()
28. print(data[0].PASSWORD)
29. #all 查出所有
30. data_2 = Session.query(User).filter_by().all()
31. print(data_2)
32. data_3 = Session.query(User).filter(User.ID == 1).all()
33. print(data_3)
34. data_4 = Session.query(User).filter_by(ID=1).all()
35. print(data_4)
36. # 多条件查询
37. data_5 = Session.query(User).filter(User.ID > 1).filter(User.ID < 4).all()
38. print(data_5)
39. data_6 = Session.query(User).filter().first()
40. print(data_6)
41. # 修改
42. data_6.NAME = 'zhangsan'
43. data_6.PASSWORD = '110'
44. # 提交
45. Session.commit()

回滚

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String
7. from sqlalchemy.ext.declarative import declarative_base
8. from sqlalchemy.orm import sessionmaker
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=False)
12. Base = declarative_base()
13.  
14. class User(Base):
15.     __tablename__ = 'USER'
16.     ID = Column(Integer,primary_key=True)
17.     NAME = Column(String(32))
18.     PASSWORD = Column(String(64))
19.  
20.     def __repr__(self):
21.         return "<ID : %s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
22.  
23. Session_class = sessionmaker(bind=engine)
24. Session = Session_class()
25.  
26. my_user = Session.query(User).filter_by(ID=1).first()
27. my_user.NAME = 'Mark'
28.  
29. fake_user = User(NAME='Merry',PASSWORD='999999')
30. Session.add(fake_user)
31. # 查看刚刚添加和修改的数据
32. print(Session.query(User).filter(User.NAME.in_(['Merry','Mark'])).all())
33. # rollback
34. Session.rollback()
35. # 再次查询
36. print(Session.query(User).filter(User.NAME.in_(['Merry','Mark'])).all())

统计和分组

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String,func
7. from sqlalchemy.ext.declarative import declarative_base
8. from sqlalchemy.orm import sessionmaker
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=False)
12.  
13. Base = declarative_base()
14.  
15.  
16. class User(Base):
17.     __tablename__ = 'USER'
18.     ID = Column(Integer,primary_key=True)
19.     NAME = Column(String(32))
20.     PASSWORD = Column(String(64))
21.  
22.     def __repr__(self):
23.         return "<ID : %s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
24.  
25. Session_class = sessionmaker(bind=engine)
26. Session = Session_class()
27. # 统计ha开头的NAME个数
28. print(Session.query(User).filter(User.NAME.like("ha%")).count())
29. # 分组
30. print(Session.query(User.NAME,func.count(User.NAME)).group_by(User.NAME).all())

连表

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import sqlalchemy
6. from sqlalchemy import create_engine,Column,Integer,String,DATE
7. from sqlalchemy.orm import sessionmaker
8. from sqlalchemy.ext.declarative import declarative_base
9.  
10. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
11.                        encoding='utf-8',echo=True)
12. Base = declarative_base()
13.  
14. class User(Base):
15.     __tablename__ = 'USER'
16.     ID = Column(Integer,primary_key=True)
17.     NAME = Column(String(32))
18.     PASSWORD = Column(String(64))
19.  
20.     def __repr__(self):
21.         return "<ID :%s | NAME : %s | PASSWORD : %s>" %(self.ID,self.NAME,self.PASSWORD)
22.  
23.  
24. class Student(Base):
25.     __tablename__ = 'STUDENT'
26.     ID = Column(Integer,primary_key=True)
27.     NAME = Column(String(32),nullable=False)
28.     REGISTER_DATE = Column(DATE,nullable=False)
29.     GENDER = Column(String(32),nullable=False)
30.  
31.     def __repr__(self):
32.         return "<NAME : %s | PASSWORD : %s>" %(self.NAME,self.REGISTER_DATE)
33.  
34. Base.metadata.create_all(engine)
35. Session_class = sessionmaker(bind=engine)
36. Session = Session_class()
37.  
38. # 外联
39. print(Session.query(User,Student).filter(User.ID == Student.ID).all())
40. # 两个表必须有外键关联才能使用 Can't find any foreign key relationships between 'A' and 'B'
41. print(Session.query(User).join(Student).all())
42. print(Session.query(User).join(Student,isouter=True).all())
43. Session.commit()

实现两个表的外键关联

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4. import sqlalchemy
5. from sqlalchemy import create_engine,Column,Integer,String,DATE,ForeignKey
6. from sqlalchemy.orm import sessionmaker,relationship
7. from sqlalchemy.ext.declarative import declarative_base
8.  
9. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
10.                        encoding='utf-8',echo=False)
11. Base = declarative_base()
12.  
13. class Student(Base):
14.     __tablename__ = 'student'
15.     id = Column(Integer,primary_key=True)
16.     name = Column(String(32),nullable=False)
17.     register_date = Column(DATE,nullable=False)
18.  
19.     def __repr__(self):
20.         return "<name : %s | register_date : %s>"%(self.name,self.register_date)
21.  
22.  
23. class StudyRecord(Base):
24.     __tablename__ = "study_record"
25.     id = Column(Integer,primary_key=True)
26.     day = Column(Integer,nullable=False)
27.     status = Column(String(32),nullable=False)
28.     # 创建外键
29.     stu_id = Column(Integer,ForeignKey("student.id"))
30.     #
31.     student = relationship("Student",backref="my_study_record")
32.  
33.     def __repr__(self):
34.        return "<%s day :%s | status : %s>"%(self.student.name,self.day,self.status)
35. # 创建表结构
36. Base.metadata.create_all(engine)
37. # 创建与数据库的会话session
38. Session_class = sessionmaker(bind=engine)
39. # 生成session实例
40. session = Session_class()
41.  
42. """添加数据
43. s1 = Student(name="Golden",register_date="2017-12-24")
44. s2 = Student(name="Jack",register_date="2017-11-13")
45. s3 = Student(name="Rain",register_date="2017-10-11")
46. s4 = Student(name="Eric",register_date="2017-07-07")
47.  
48. study_obj1 = StudyRecord(day=1,status="Yes",stu_id=1)
49. study_obj2 = StudyRecord(day=2,status="No",stu_id=1)
50. study_obj3 = StudyRecord(day=3,status="Yes",stu_id=1)
51. study_obj4 = StudyRecord(day=1,status="Yes",stu_id=2)
52.  
53. # 一次性全部创建
54. session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])
55. """
56. stu_obj = session.query(Student).filter(Student.name == "Golden").first()
57. print(stu_obj)
58. print(stu_obj.my_study_record)
59. # 提交
60. session.commit()

多外键关联

创建包含多外键的表结构。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. from sqlalchemy.orm import relationship
6. from sqlalchemy import create_engine,Column,Integer,String,DATE,ForeignKey
7. from sqlalchemy.ext.declarative import declarative_base
8.  
9. Base = declarative_base()
10.  
11. class Customer(Base):
12.     __tablename__ = 'customer'
13.     id = Column(Integer,primary_key=True)
14.     name = Column(String(64))
15.  
16.     billing_address_id = Column(Integer,ForeignKey("address.id"))
17.     shipping_address_id = Column(Integer,ForeignKey("address.id"))
18.  
19.     billing_address = relationship("Address",foreign_keys=[billing_address_id])
20.     shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
21.  
22. class Address(Base):
23.     __tablename__ = 'address'
24.     id = Column(Integer,primary_key=True)
25.     street = Column(String(64))
26.     city = Column(String(64))
27.     state = Column(String(64))
28.  
29.     def __repr__(self):
30.         return self.street
31.  
32. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
33.                        encoding='utf-8',echo=False)
34. # 创建表结构
35. # Base.metadata.create_all(engine)

插入数据和查询。

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import os,sys
6. path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
7. sys.path.append(path)
8. from day11 import orm_many_fk
9. from sqlalchemy.orm import sessionmaker
10.  
11. Session_class = sessionmaker(bind=orm_many_fk.engine)
12. session = Session_class()
13.  
14. # 创建数据
15. # addr1 = orm_many_fk.Address(street="zhongshanroad",city="qiaokou",state='hankou')
16. # addr2 = orm_many_fk.Address(street="dongyiroad",city="hongshan",state="wuchang")
17. # addr3 = orm_many_fk.Address(street="guangshanroad",city="gaoxin",state="guanggu")
18. #
19. # session.add_all([addr1,addr2,addr3])
20. # c1 = orm_many_fk.Customer(name="Golden",billing_address=addr1,shipping_address=addr3)
21. # c2 = orm_many_fk.Customer(name="Jack",billing_address=addr2,shipping_address=addr2)
22. #
23. # session.add_all([c1,c2])
24.  
25. # 查询数据
26. obj = session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name=="Golden").first()
27. print(obj.name,obj.billing_address,obj.shipping_address)
28.  
29. session.commit()

多对多关联

创建多对多关联表

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. from sqlalchemy import Table,Column,Integer,String,DATE,ForeignKey,create_engine
6. from sqlalchemy.orm import relationship,sessionmaker
7. from sqlalchemy.ext.declarative import declarative_base
8.  
9. engine = create_engine("mysql+pymysql://root:123456@192.168.31.134/test_db",
10.                        encoding='utf-8',echo=False)
11.  
12. Base = declarative_base()
13.  
14. book_m2m_author = Table('book_m2m_author',Base.metadata,
15.                         Column('book_id',Integer,ForeignKey('books.id')),
16.                         Column('author_id',Integer,ForeignKey('authors.id')))
17.  
18. class Book(Base):
19.     __tablename__ = 'books'
20.     id = Column(Integer,primary_key=True)
21.     name = Column(String(64))
22.     pub_date = Column(DATE)
23.     authors = relationship('Author',secondary=book_m2m_author,backref='books')
24.  
25.     def __repr__(self):
26.         return self.name
27.  
28.  
29. class Author(Base):
30.     __tablename__ = 'authors'
31.     id = Column(Integer,primary_key=True)
32.     name = Column(String(32))
33.  
34.     def __repr__(self):
35.         return self.name
36.  
37. Base.metadata.create_all(engine)
38. Session_class = sessionmaker(bind=engine)
39. session = Session_class()

插入数据和查询

1. __author__ = 'Golden'
2. #!/usr/bin/env python3
3. # -*- coding:utf-8 -*-
4.  
5. import os,sys
6. path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
7. sys.path.append(path)
8. from day11 import orm_m2m
9. from sqlalchemy.orm import sessionmaker
10.  
11. Session_class = sessionmaker(bind=orm_m2m.engine)
12. session = Session_class()
13.  
14. # 创建数据
15. # b1 = orm_m2m.Book(name="Python")
16. # b2 = orm_m2m.Book(name="JAVA")
17. # b3 = orm_m2m.Book(name="C++")
18. # b4 = orm_m2m.Book(name="c#")
19. #
20. # a1 = orm_m2m.Author(name="Golden")
21. # a2 = orm_m2m.Author(name="Jack")
22. # a3 = orm_m2m.Author(name="Rain")
23. #
24. # b1.authors = [a1,a2]
25. # b2.authors = [a1,a2,a3]
26. #
27. # session.add_all([b1,b2,b3,b4,a1,a2,a3])
28. # session.commit()
29.  
30. print("通过书表查询关联的作者".center(50,"*"))
31. book_obj = session.query(orm_m2m.Book).filter_by(name="JAVA").first()
32. print(book_obj.name,book_obj.authors)
33. print("通过作者表查询关联的书".center(50,"*"))
34. author_obj = session.query(orm_m2m.Author).filter_by(name="Golden").first()
35. print(author_obj.name,author_obj.books)
36.  
37. # 多对多删除，删除数据时不用管book_m2m_author,sqlalchemy会自动删除对应的数据
38. # 通过书删除作者
39. book_obj.authors.remove(author_obj)
40.  
41. # 直接删除作者
42. author_obj2 = session.query(orm_m2m.Author).filter_by(name="Jack").first()
43. session.delete(author_obj2)
44. session.commit()