python学习笔记-（十六）python操作mysql

一. mysql安装

1. windows下安装mysql

1.1. 下载源：

http://dev.mysql.com/downloads/installer/，请认准对应版本 Windows (x86, 64-bit), ZIP Archive；

不想注册和登录的话可以选择"No thanks, just start my download."

1.2 解压文件：

下载好后解压文件，您可以把内容解压到想要的位置，本例解压到“D:mysql”，还有一个问题新版没有data名称的文件夹，这个文件夹顾名思义是放数据文件的，你可以放在任何其他地方，你认为方便的位置，只要在下面配置对路径就好了，在这里我还是放在“D:mysql”下。

1.3 修改配置文件：

用记事本打开文件my-default.ini，最基本配置前后如图：

1、去掉basedir和datadir前面的#

2、basedir添加的是MySQL的解压路径；

3、datadir添加的是MySQL的data文件夹路径。

4、port = 3306 设置专用数据库服务器和端口3306，有冲突可选择修改；

1.4 添加环境变量： 

把bin的路径添加到Path变量值里，记住是追加到最后，不是覆盖。

具体操作如下：

1、为防出错，在地址栏复制bin文件夹的路径，如例“D:mysqlin”

2、打开电脑桌面:计算机—>右键—>属性—>高级系统设置—>高级—>环境变量（N）—>系统变量(S)—>找到变量Path—>编辑；

3、把刚刚复制的MySQL的bin路径添加的Path变量值后。确定，退出。

1.5 安装初始化数据库： 

1、以管理员身份运行cmd（一定要用管理员身份运行，不然权限不够），

2、输入：D: [回车]      （因为在D盘，要先转到D盘）

3、输入：cd D:mysqlin  [回车]  进入mysql的bin文件夹(不管有没有配置过环境变量，也要进入bin文件夹，否则之后启动服务仍然会报错误2)

4、输入：mysqld --install [回车]   （这个命令就是安装服务, 执行完后, 提示英文的成功, 这时候你可以在你的 windows 服务中看到  MySQL 的服务，但未启动。）

5、输入：mysqld --initialize --console   这步很重要，这是初始化数据库, 然后你可以在初始化的最后面看到有一个 root@localhost: 后面有一连串的字母数字符号, 这是 MySQL 为你自动生成的随机密码，一定要记下来, 一会我们登陆 MySQL 数据库的时候要用。

PS：使用-initialize生成随机密码，使用-initialize-insecure生成空密码，初始化后data文件夹会自动生成，不用自己新建哦。

1.6 启动服务：

启动了MySQL 服务你才能用 MySQL 数据库。有两种方式可以启动 MySQL：

方法一: 用命令启动 输入：net start mysql  [回车]    

方法二: 从 windows 服务中启动

此时我们就可以使用MySQL了

 

1.7 登录并修改初始密码：

登陆 MySQL 数据库命令

输入：mysql -uroot -p   [回车]

要求你输入密码，把刚才 MySQL 随机生成的密码输入，然后回车，就登陆进去了，进了数据库我们就可以修改密码了

修改密码的命令如下：

SET PASSWORD = PASSWORD(‘你的新密码‘);

PS：以前 mysql-5.6.* 的时候，直接用 update 语句来更新root密码。在 mysql-5.7.12 中，系统的 user 表中没有 password 这一列了，这种方法在 mysql-5.7.12 中没法用了, 我们只能用 SET PASSWORD = PASSWORD(‘你的新密码‘); 来修改密码。

好了，安装就到此为止了，需要图形界面的朋友自己找合适喜欢的了。

2. linux下安装mysql

略过

二. pymysql

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

1. 安装

• 管理员打开cmd，切换到python的安装路径，进入到Scripts目录下（如：C:UsersAdministratorAppDataLocalProgramsPythonPython35Scripts）；

• 执行以下命令：pip install pymysql

• 校验是否安装成功：进入到python命令行模式，输入import pymysql，无报错代表成功；

2. 使用操作

2.1 查询数据

import pymysql
#创建链接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123123', db='t1')
#创建游标
cursor = conn.cursor()
#执行sql
cursor.execute("select * from students")
  
# 获取第一行数据
row_1 = cursor.fetchone()
  
# 获取前n行数据
row_2 = cursor.fetchmany(3)
# 获取所有数据
row_3 = cursor.fetchall()
# 提交，不然无法保存新建或者修改的数据
conn.commit()
#关闭游标
cursor.close()
#关闭链接
conn.close()

2.2 执行sql

import pymysql
  
# 创建连接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123123', 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()

三. ORM sqlachemy

1.对象映射关系（ORM）

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

优点：

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

缺点：

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

2. SQLAlchemy

在Python中，最有名的ORM框架是SQLAlchemy。用户包括openstack＼Dropbox等知名公司或应用

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

注：支持连接MySQL、Oracles数据库

2.1 安装：

pip install SQLAlchemy
pip install pymysql 
#由于mysqldb依然不支持py3，所以这里我们用pymysql与sqlalchemy交互

2.2 基本使用：

下面就开始让你见证orm的nb之处，盘古开天劈地之前，我们创建一个表是这样的：

CREATE TABLE user (
    id INTEGER NOT NULL AUTO_INCREMENT,
    name VARCHAR(32),
    password VARCHAR(64),
    PRIMARY KEY (id)
)

这只是最简单的sql表，如果再加上外键关联什么的，一般程序员的脑容量是记不住那些sql语句的，于是有了orm,实现上面同样的功能，代码如下：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
 
engine = create_engine("mysql+pymysql://root:alex3714@localhost/testdb",
                                    encoding='utf-8', echo=True)
 
 
Base = declarative_base() #生成orm基类
 
class User(Base):
    __tablename__ = 'user' #表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))
 
Base.metadata.create_all(engine) #创建表结构

最基本的表我们创建好了，那我们开始用orm创建一条数据试试

Session_class = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class() #生成session实例
 
 
user_obj = User(name="cc",password="123123") #生成你要创建的数据对象
print(user_obj.name,user_obj.id)  #此时还没创建对象呢，不信你打印一下id发现还是None
 
Session.add(user_obj) #把要创建的数据对象添加到这个session里， 一会统一创建
print(user_obj.name,user_obj.id) #此时也依然还没创建
 
Session.commit() #现此才统一提交，创建数据

2.2.1 查询

my_user = Session.query(User).filter_by(name="cc").first()
print(my_user)

#打印输出：<__main__.User object at 0x105b4ba90>
print(my_user.id,my_user.name,my_user.password)
#打印输出：cc 123123

不过刚才上面的显示的内存对象对址你是没办法分清返回的是什么数据的，除非打印具体字段看一下，如果想让它变的可读，只需在定义表的类下面加上这样的代码

ef __repr__(self):
    return "<User(name='%s',  password='%s')>" % (
        self.name, self.password)

2.2.2 修改

my_user = Session.query(User).filter_by(name="cc").first()
 
my_user.name = "TT"
 
Session.commit()

2.2.3 回滚

my_user = Session.query(User).filter_by(id=1).first()
my_user.name = "Jack"
 
 
fake_user = User(name='Rain', password='12345')
Session.add(fake_user)
 
print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() )  #这时看session里有你刚添加和修改的数据
 
Session.rollback() #此时你rollback一下
 
print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() ) #再查就发现刚才添加的数据没有了。
 
# Session
# Session.commit()

2.2.4 获取所有数据

print(Session.query(User.name,User.id).all() )

2.2.5 多条件查询

objs = Session.query(User).filter(User.id>0).filter(User.id<7).all()

2.2.6 统计和分组

统计：

Session.query(User).filter(User.name.like("Ra%")).count()

分组：

from sqlalchemy import func
print(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')]

2.2.7 外键关联

我们先创建个study_record表与student进行关联

# 外键关联
 
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import String,Column,Integer,ForeignKey,DATE
from sqlalchemy.orm import sessionmaker,relationship
 
engine = create_engine("mysql+pymysql://root:zyw@123@192.168.1.18/testdb",
                       encoding="utf-8")
 
Base = declarative_base()
 
class Student(Base):
    __tablename__ ="student"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)
 
    def __repr__(self):
        return "<%s name:%s>"%(self.id,self.name)
 
class StudyRecord(Base):
    __tablename__ = "study_record"
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("student.id")) #关联student表里的id
 
    my_student = relationship("Student",backref="my_study_record") # Student为关联的类

 def __repr__(self):
        return "<%s name:%s>" % (self.id, self.name)
 
Base.metadata.create_all(engine)
 
Session_class = sessionmaker(bind=engine)
session = Session_class()
 
s1 = Student(name="cc",register_date="2016-10-28")
s2 = Student(name="tt",register_date="2015-10-28")
s3 = Student(name="RR",register_date="2014-10-28")
s4 = Student(name="YY",register_date="2013-10-28")
 
r1 = StudyRecord(day=1,status="YES",stu_id=1)
r2 = StudyRecord(day=2,status="No",stu_id=1)
r3 = StudyRecord(day=3,status="YES",stu_id=1)
r4 = StudyRecord(day=1,status="YES",stu_id=2)
 
session.add_all([s1,s2,s3,s4,r1,r2,r3,r4])
session.commit()

注：my_student = relationship("Student",backref="my_study_record")这个nb，允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项

查询：

# 外键查询
 
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import String,Column,Integer,ForeignKey,DATE
from sqlalchemy.orm import sessionmaker,relationship
 
engine = create_engine("mysql+pymysql://root:zyw@123@192.1681.18/testdb",
                       encoding="utf-8")
 
Base = declarative_base()
 
class Student(Base):
    __tablename__ ="student"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)
 
    def __repr__(self):
        return "<id:%s name:%s>"%(self.id,self.name)
 
class StudyRecord(Base):
    __tablename__ = "study_record"
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("student.id")) #关联student表里的id
 
    my_student = relationship("Student",backref="my_study_record") # Student为关联的类
 
    def __repr__(self):
        return "<name:%s day:%s status:%s>" % (self.my_student.name,self.day,self.status)
 
Base.metadata.create_all(engine)
 
Session_class = sessionmaker(bind=engine)
session = Session_class()
 
stu_obj = session.query(Student).filter(Student.name=="cc").first()
print(stu_obj)
#<id:1 name:cc>
 
print(stu_obj.my_study_record)
#[<name:cc day:1 status:YES>, <name:cc day:2 status:No>, <name:cc day:3 status:YES>]

2.2.8 多外键关联

下表中，Customer表有2个字段都关联了Address表，首先先创建表结构：

#多外键关联
 
from sqlalchemy import create_engine
from sqlalchemy import Integer,String,Column,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship
 
engine = create_engine("mysql+pymysql://root:zyw@123@192.168.1.18/testdb",
                       encoding="utf-8",echo= True)
 
Base =  declarative_base()
 
class Customer(Base):
    __tablename__ = "customer"
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    billing_address_id = Column(Integer,ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("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__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String(32))
    city = Column(String(32))
    state = Column(String(32))
 
Base.metadata.create_all(engine)
 
 
mysql> desc address;
+--------+-------------+------+-----+---------+----------------+
| Field  | Type        | Null | Key | Default | Extra          |
+--------+-------------+------+-----+---------+----------------+
| id     | int(11)     | NO   | PRI | NULL    | auto_increment |
| street | varchar(32) | YES  |     | NULL    |                |
| city   | varchar(32) | YES  |     | NULL    |                |
| state  | varchar(32) | YES  |     | NULL    |                |
+--------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)
 
mysql> desc customer;
+---------------------+-------------+------+-----+---------+----------------+
| Field               | Type        | Null | Key | Default | Extra          |
+---------------------+-------------+------+-----+---------+----------------+
| id                  | int(11)     | NO   | PRI | NULL    | auto_increment |
| name                | varchar(32) | YES  |     | NULL    |                |
| billing_address_id  | int(11)     | YES  | MUL | NULL    |                |
| shipping_address_id | int(11)     | YES  | MUL | NULL    |                |
+---------------------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

生成数据：

Session = sessionmaker(bind=engine)
session = Session()
 
a1 = Address(street="Tiantongyuan",city="ChangPing",state="BJ")
a2 = Address(street="Wudaokou",city="HaiDian",state="BJ")
a3 = Address(street="Yanjiao",city="LangFang",state="HB")
 
session.add_all([a1,a2,a3])
c1 = Customer(name="lzl",billing_address_id=1,shipping_address_id=2)
c2 = Customer(name="Alex",billing_address_id=3,shipping_address_id=3)
 
session.add_all([c1,c2])
 
session.commit()

查询数据：

class Customer(Base):
    __tablename__ = "customer"
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    billing_address_id = Column(Integer,ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))
 
    billing_address = relationship("Address",foreign_keys=[billing_address_id]) #必须写foreign_keys
    shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
 
    def __repr__(self):
        return "<name:%s billing_add:%s shipping_add:%s>"%(self.name,self.billing_address.street,
                                                           self.shipping_address.street)
 
 
#Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
 
cus_obj = session.query(Customer).filter_by(name="lzl").first()
print(cus_obj)
# <name:lzl billing_add:Tiantongyuan shipping_add:Wudaokou>

2.2.9 多对多关联

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

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

1）创建表结构：

#一本书可以有多个作者，一个作者又可以出版多本书
 
 
from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
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:zyw@123@192.168.1.18/testdb",
                       encoding="utf-8")
 
Base = declarative_base()
 
#创建book_m2m_author表，表不用用户操作，系统自动维护，自动添加数据
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)
    #关联Author类，secondary表示通过book_m2m_author表进行查询关联数据，backref反向查询也一样
    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)

2）创建表数据：

#创建数据
 
Session = sessionmaker(bind=engine)
session = Session()
 
b1 = Book(name="learn python with Alex",pub_date="2014-05-02")
b2 = Book(name="learn linux with Alex",pub_date="2015-05-02")
b3 = Book(name="learn go with Alex",pub_date="2016-05-02")
 
a1 = Author(name="Alex")
a2 = Author(name="Jack")
a3 = Author(name="Rain")
 
#关键来了，创建关联关系
b1.authors = [a1,a3]
b3.authors = [a1,a2,a3]
 
session.add_all([b1,b2,b3,a1,a2,a3])
session.commit()
 
 
mysql> select * from book_m2m_author;
+---------+-----------+
| book_id | author_id |
+---------+-----------+
|       1 |         1 |
|       2 |         1 |
|       2 |         2 |
|       1 |         3 |
|       2 |         3 |
+---------+-----------+
5 rows in set (0.00 sec)
 
mysql> select * from authors;
+----+------+
| id | name |
+----+------+
|  1 | Alex |
|  2 | Jack |
|  3 | Rain |
+----+------+
3 rows in set (0.00 sec)
 
mysql> select * from books;
+----+------------------------+------------+
| id | name                   | pub_date   |
+----+------------------------+------------+
|  1 | learn python with Alex | 2014-05-02 |
|  2 | learn go with Alex     | 2016-05-02 |
|  3 | learn linux with Alex  | 2015-05-02 |
+----+------------------------+------------+
3 rows in set (0.00 sec)

3）查询

author_obj = session.query(Author).filter_by(name="Alex").first()
print(author_obj,author_obj.books)
 
book_obj = session.query(Book).filter_by(id=2).first()
print(book_obj,book_obj.authors)
 
 
# Alex [learn python with Alex, learn go with Alex]
# learn go with Alex [Alex, Jack, Rain]

2.2.10 多对多删除

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

通过书删除作者：

author_obj =s.query(Author).filter_by(name="Jack").first()
 
book_obj = s.query(Book).filter_by(name="跟Alex学把妹").first()
 
book_obj.authors.remove(author_obj) #从一本书里删除一个作者
s.commit()

直接删除作者：

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

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