Python数据库相关回顾

一、数据库基本操作

1. 创建一个test库

create database test;

2. 授权一个用户

grant all privileges on *.* to 'zyy'@'%' identified by '1qaz@WSX';

3. 创建表

create table student(id int not null);

4. 表查询操作

select * from tabel_name where 条件1 and  条件2;

5. 表增加数据

insert into table_name (id, name, age, sex, grander) values (1, 'zyy', 25, 'M', 99), (2, 'zpl', 45, 'F', 88);

6. 修改表数据

update table_name set id=10 where 条件判断;

7. 删除数据

# DELETE 操作不会减少表或索引所占用的空间
delete from table_name  where 条件判断;

# drop 语句将表所占用的空间全释放掉
drop table table_name;


# TRUNCATE TABLE 则一次性地从表中删除所有的数据并不把单独的删除操作记录记入日志保存，删除行是不能恢复的。
# 并且在删除的过程中不会激活与表有关的删除触发器。执行速度快。

# 在速度上，一般来说，drop> truncate > delete。

# 在使用drop和truncate时一定要注意，虽然可以恢复，但为了减少麻烦，还是要慎重。

# 如果想删除部分数据用delete，注意带上where子句，回滚段要足够大；

# 如果想删除表，当然用drop； 

# 如果想保留表而将所有数据删除，如果和事务无关，用truncate即可；

# 如果和事务有关，或者想触发trigger，还是用delete；

# 如果是整理表内部的碎片，可以用truncate跟上reuse stroage，再重新导入/插入数据。

8. 联合查询

select a.id, b.name from A a join B b on a.id=b.tid;

9. 创建索引

create index idx_库名_表名_列名1_列名2 (列名1， 列名2);

10. 查看sql是否走索引

explain select * from student where name='zyy';

11. 连接数据库

Python2 使用的是 MySQLdb
python3 使用的 pymysql  pip安装

二、使用 Python 进行数据库连接

1. 创建链接和游标

# 注意：在mysql连接中，尽量使用一个连接，确保mysql的并发数
conn = pymysql.connect(host='', port=, user='', passwd='', db='')
cus = conn.curse()

2. 实行sql

sql = "select * from Student;"
cus.execute(sql)
cus.fetchone()         # 获取单个  返回值  tuple
cus.fetchall()         # 获取多个  返回值  list（单个元素是tuple）
cus.fetchmany(size=n)  # 获取多个

3. 关闭游标和连接

cus.close()
conn.close()

# 注意结合try exception finally的使用

三、SQLAlchemy

1. 创建引擎

engine = create_engine('mysql+pymysql://username:password@hostname:port/db');

2. 创建session

DBsession = sessionmaker(bind=engine)
session = DBsession()

3.创建表

a. 获得engine
b. metadata = MetaData(engine)
c. student = Table('表名', metadata, Colume('id', Integer, primary_key=True), Colume('name', String(50))
d. metadata.create_all()

4.增加

# a. 先要有一个模型
Base = declarative_base(0
class Student(Base):
    __tablename__ = 'student'
    id = Column(Integer, primary_key=True)
    name = Column(String(100), primary_key=True)

# b. 导入模型类，实例化该类，
sutdent1 = Student(1, 'ling')

# c. session.add(单实例)      session.add_all([实例1, 实例2])

5. 查询

# filter和filter_by的区别

# filter：可以使用>  < 等，但是列必须是： 表.列，   filter的等于号是==
session.query(Student).filter(Student.id>100)

# filter 不支持组合查询
session.query(Student).filter(Studnet.id>100).filter(name=='zyy')

# filter_by： 可以直接写列，不支持< >  filter_by 等于是==
session.query(Student).filter_by(id==10)

# filter_by 可以支持组合查询
session.query(Student).filter_by(name=='zyy' and id=='342')
select * from student where name like '%zyy%';

#模糊查询含有zyy的关键字
#模糊查询
session.query(Student).filter(Student.name like('%zyy%'))

# 获取数据的时候有两个方法：
one()   tuple
all()   list(单个元素是tuple)
# 如果在查询中不写one(), 或者all()  出来的就是sql语句

6. 更新

# 1. 先查出来
# 2. 跟新一下类所对应的属性值就ok
# 3. session.commit()

student1 = session.query(Student).filter(Student.id==1001)
student1.name = "test"
session.commit()

7. 删除

1. 先查出来
2. 直接调用delete()方法就可以
3. 提交一下

8.统计， 分组，排序

统计：count()
只需要在查出来以后， 把one或者all替换成count()
统计有多少个

分组：group_by
查出来以后，把one或者all替换成group_by(属性)

四、串联总结

最后将以上内容串联起来如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time    : 2018/5/13 23:30
# @Author  : zhouyuyao
# @File    : demon1.py

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

Base = declarative_base()
# declarative_base() 创建了一个 BaseModel 类，这个类的子类可以自动与一个表关联。

class Student(Base): # 必须继承declaraive_base得到的那个基类
    __tablename__ = 'student'
    # 必须要有__tablename__来指出这个类对应什么表
    # 这个表可以暂时在库中不存在，SQLAlchemy会帮我们创建这个表
    id = Column(Integer, primary_key=True)   # Column类创建一个字段
    name = Column(String(100))
    age = Column(Integer)
    address = Column(String(100))

def update(session):
    student1 = session.query(Student).filter(Student.id == 1001).one()
    # session.query(Student) 显示SQL 语句
    # filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
    # 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判
    # 然后返回 True 或 False，最后将返回 True 的元素放到新列表中
    student1.name='test123'
    session.commit()
    # 在SQLAlchemy中一个Session（可以看作）是一个transaction，每个操作（基本上）对应一条或多条SQL语句
    # 这些SQL语句需要发送到数据库服务器才能被真正执行，而整个transaction需要commit才能真正生效
    # 如果没提交，一旦程序挂了，所有未提交的事务都会被回滚到事务开始之前的状态
    # flush就是把客户端尚未发送到数据库服务器的SQL语句发送过去，commit就是告诉数据库服务器提交事务
    # 简单说，flush之后你才能在这个Session中看到效果，而commit之后你才能从其它Session中看到效果
    student2 = session.query(Student).filter(Student.id == 1001).one()
    print(student2.name)

def delete(session):
    session.query(Student).filter(Student.id == 1001).delete()
    session.commit()

def insert(session):
    student1 = Student(id=1004, name='zyy', age=28, address='xiangtan')
    session.add(student1)
    session.commit()

def count(session):
    numnber = session.query(Student).filter().count()
    print("total student is {0}".format(numnber))

def groupBy(session):
    groupByAge = session.query(Student).group_by(Student.age).all()
    print(groupByAge)
    for i in groupByAge:
        print(i.id, i.name, i.age, i.address)

def orderBy(session):
    orderByAge = session.query(Student).order_by(Student.age.desc()).all()
    for x in orderByAge:
        print(x.id, x.name, x.age, x.address)

def main():
    engine = create_engine('mysql+pymysql://username:[email protected]/databasename')
    DBsession = sessionmaker(bind=engine)
    session = DBsession()
    # insert(session)
    # update(session)
    # delete(session)
    # count(session)
    # groupBy(session)
    orderBy(session)

if __name__ == '__main__':
    # 一个python的文件有两种使用的方法
    # 第一是直接作为脚本执行
    # 第二是import到其他的python脚本中被调用（模块重用）执行
    # 在if__name__ == 'main': 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行
    # 而import到其他脚本中是不会被执行的
    main()

参考资料：

1. https://blog.csdn.net/ws0513/article/details/49980547

2. http://www.dengfeilong.com/post/60.html

3. http://www.jb51.net/article/49789.htm

4. http://www.runoob.com/python/python-func-filter.html

5. https://segmentfault.com/q/1010000000698181

6. https://www.cnblogs.com/franknihao/p/7268752.html