[[418400]]

大家好，我是Python進階者。

前言

在我們做web開發(fā)的時候，經(jīng)常需要用到與數(shù)據(jù)庫交互，因為我們的數(shù)據(jù)通常都是保存在數(shù)據(jù)庫中的，如果有人需要訪問，就必須與數(shù)據(jù)庫訪問，所以今天我們介紹一個Flask中與數(shù)據(jù)庫交互的插件---Flask-Sqlalchemy。

一、安裝并導入

pip install flask-sqlalchemy 
 
from flask_sqlalchemy import SQLAlchemy 
import os 
import pymysql as p 
from flask import Flask 

二、基本用法

今天我們要了解的是Mysql數(shù)據(jù)庫，所以這里重點介紹連接Mysql數(shù)據(jù)庫的方法。

1.連接數(shù)據(jù)庫

1).寫在配置文件中然后讀取

首先創(chuàng)建一個配置文件"config.py"，內(nèi)容為：

db_type='mysql' 
db_conn='pymysql' 
host='127.0.0.1' 
username='root' 
password='123456' 
port='3306' 
db_name='people' 
SQLALCHEMY_DATABASE_URI='{}+{}://{}:{}@{}:{}/{}?charset=utf8'.format(db_type,db_conn,username,password,host,port,db_name) 
SQLALCHEMY_COMMIT_ON_TEARDOWN=False 
SQLALCHEMY_TRACK_MODIFICATIONS=True 

然后在應(yīng)用中導入配置文件：

from flask_sqlalchemy import SQLAlchemy 
from flask import Flask 
import config 
app=Flask(__name__) 
app.config.from_object(config) # 連接數(shù)據(jù)庫配置文件 
db=SQLAlchemy(app) 
db.create_all()  # 創(chuàng)建所有的數(shù)據(jù)庫 

2).直接寫在應(yīng)用中讀取

app=Flask(__name__) 
p.install_as_MySQLdb()   # mysql連接器，因為不支持py3版本，所以必須加上這行 
app.config['SECRET_KEY']=os.urandom(50) 
app.config['SQLALCHEMY_DATABASE_URI']='mysql+pymysql://root:123456@127.0.0.1:3306/people' 
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']=True   # 每次請求結(jié)束后都會自動提交數(shù)據(jù)庫中的變動 
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True  # 動態(tài)追蹤修改設(shè)置，如未設(shè)置只會提示警告 
db = SQLAlchemy(app) 

還有許多其它的配置參數(shù)，比如：

SQLALCHEMY_NATIVE_UNICODE    # 可以用于顯式禁用原生 unicode 支持 
SQLALCHEMY_POOL_SIZE         # 數(shù)據(jù)庫連接池的大小，默認是引擎默認值（5）  
SQLALCHEMY_POOL_TIMEOUT      # 設(shè)定連接池的連接超時時間，默認是 10 
SQLALCHEMY_POOL_RECYCLE      # 多少秒后自動回收連接，mysql默認為2小時 
SQLALCHEMY_RECORD_QUERIES    # 可以用于顯式地禁用或啟用查詢記錄 
SQLALCHEMY_ECHO              # 為Ture時用于調(diào)試，顯示錯誤信息 
SQLALCHEMY_BINDS             # 一個映射 binds 到連接 URI 的字典 

3).使用獨特的創(chuàng)建引擎

from sqlalchemy import create_engine 
# echo參數(shù)為True時，會顯示每條執(zhí)行的SQL語句，為False時關(guān)閉 
engine = create_engine('mysql+pymysql://root:123456@127.0.0.1:3306/people',echo=True) 
engine.connect() 

這樣我們就算與People數(shù)據(jù)庫建立連接了，接下來我們來建立一張表。

4).創(chuàng)建連接多個數(shù)據(jù)庫

app.config['SQLALCHEMY_BINDS']={ 
'users': "mysql+pymysql://root:123456@127.0.0.1:3306/user", 
    'admin': 'sqlite://C:/Users/Administrator/Desktop/admin', 
    'buy':   'postgresql://root:123321@127.0.0.1/buy' 
} 

然后引用表：

db.create_all(bind=['users']) 
db.create_all(bind='admin') 

指定Users數(shù)據(jù)庫中的表：

__bind_key__ = 'users' 
bind key 內(nèi)部存儲在表的 info 字典中  即：info={'bind_key': 'users'} 

2.建立數(shù)據(jù)表并插入值

1).繼承"db.Model"類

from flask_sqlalchemy import SQLAlchemy 
from flask import Flask 
import config 
app=Flask(__name__) 
app.config.from_object(config) # 添加配置文件 
db=SQLAlchemy(app) 
class User(db.Model): 
    __tablename__='users' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) # 整數(shù)類型的自增主鍵 
    username=db.Column(db.String(100),nullable=False)  # 字符類型不為空 
    password=db.Column(db.String(100),nullable=False)  # 字符類型不為空 
 
    def __init__(self,username,password): 
        self.username=username 
        self.password=password 
 
    def __repr__(self): 
        # 打印當前類名和它的實例化后的值 
        return ' %s is %r' %(self.__class__.__name__,self.username)  
     
     
# 請求鉤子,第一次請求之前執(zhí)行 
@app.before_first_request 
def create_table():  
    db.drop_all()  # 刪除所有表 
    db.create_all() # 創(chuàng)建新的表 
 
     
@app.route('/') 
def create(): 
    use1= User('hwhrr', '123321')   
    use2= User('hwzjj', '123456') 
    use3= User('hwzzz', '654321') 
    db.session.add_all([use1,use2,use3]) # 添加所有的用戶,添加一個用戶去掉_all后面加一個元祖即可  
    db.session.commit()  # 提交數(shù)據(jù) 
    return use1.__repr__() # 返回用戶1的值 
 
if __name__ == '__main__':   
    app.run(debug=True) 

Column        參數(shù)列表   
name          列名 
type_         類型 
*args         列表參數(shù) 
Constraint（約束）, ForeignKey（外鍵）, ColumnDefault（默認）, Sequenceobjects（序列）定義 
key         列名的別名 
primary_key 如果為True，則是主鍵 
nullable    如果是True，則可以為null 
default     設(shè)置默認值，默認是None 
index       是否是索引，默認是True 
unique      是否唯一鍵，默認是False 
onupdate    指定一個更新時候的值 
autoincrement 設(shè)置為整型自動增長 
quote         如果列明是關(guān)鍵字，則強制轉(zhuǎn)義，默認False 

2).利用原始引擎來創(chuàng)建會話(稍微復雜點)

from flask import Flask 
from sqlalchemy import create_engine 
from sqlalchemy.orm import sessionmaker 
from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy import Column, Integer, String 
app=Flask(__name__) 
Base = declarative_base() 
# 創(chuàng)建連接數(shù)據(jù)庫的引擎并且打開回顯 
engine = create_engine("mysql+pymysql://root:123456@localhost/people",echo=True) 
Session = sessionmaker(bind=engine) # 創(chuàng)建會話標記 
class User(Base): 
    __tablename__ = 'article' 
    id = Column(Integer, primary_key=True,autoincrement=True) 
    username = Column(String(100),nullable=False) 
    password = Column(String(100),nullable=False) 
    def __init__(self, username,password): 
        self.username = username 
        self.password=password 
    def __repr__(self): 
        return ' %s is %r' %(self.__class__.__name__,self.username) 
     
@app.before_first_request 
def create_table(): 
    Base.metadata.drop_all(engine) # 刪除所有數(shù)據(jù)庫 
    Base.metadata.create_all(engine) # 創(chuàng)建所有數(shù)據(jù)庫 
     
@app.route('/') 
def index(): 
    user= User("hwhrr","123321") 
    session = Session()   # 創(chuàng)建會話 
    session.add(user)  # 添加內(nèi)容 
    session.commit()  # 提交 
    return user.__repr__() 
 
if __name__ == '__main__':   
    app.run(debug=True) 

3.數(shù)據(jù)庫之間的關(guān)系

1). 一對一

只需讓兩張表都在同等的位置上，屬于雙向關(guān)系。

class father(db.Model): 
    __tablename__='Father' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    #主要是要在一個表上設(shè)置uselist 然后設(shè)置back_populates的值為其它表的映射返回值 
    son_fa=db.relationship('son',uselist=False, back_populates='fa_son')  
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 
 
 
class son(db.Model): 
    __tablename__='Son' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    # 這里無需設(shè)置uselist 
    fa_son=db.relationship('father',back_populates='son_fa') 
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 

2).一對多

我們需要建立一個主表和一個子表，分別命名為“father”和‘son’，然后需要建立外鍵和反射來互相引用建立一種關(guān)系，我們來看看：

class father(db.Model): 
    __tablename__='Father' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    # 表示另一端是son這個模型，backref可替代Father.id訪問father模型 
    son_fa=db.relationship('son',backref='fa'，lazy='dynamic') 
    # lazy表示加載方式： 
    # dynamic：動態(tài)加載，只有用到了才加載 只可以用在一對多和多對多關(guān)系中 
    # subquery：全部加載 
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 
 
 
class son(db.Model): 
    __tablename__='Son' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    f_id=db.Column(db.Integer,db.ForeignKey('Father.id')) # 建立外鍵關(guān)聯(lián)，指明表名和字段 
    def __init__(self,name,age): 
        self.name=name 
        self.age=age         
    def __repr__(self): 
        return '%s is %r'%(self._class__.__name__,self.name) 
 
@app.route('/') 
def create(): 
    use1= father('hw', 45) 
    use2= son('hyy', 20) 
    db.session.add_all([use1,use2]) 
    db.session.commit() 
    return use1.__repr__()+'\n'+use2.__repr__() 

3).多對一

就是將反射應(yīng)用在子表上，與父表同時進行關(guān)聯(lián)。

class father(db.Model): 
    __tablename__='Father' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    # 表示另一端是son這個模型 
    son_fa=db.relationship('son', back_populates="fath")  
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 
 
 
class son(db.Model): 
    __tablename__='Son' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    f_id=db.Column(db.Integer,db.ForeignKey('Father.id')) # 建立外鍵關(guān)聯(lián) 
    # 表示另一端是father這個模型 
    fa_son=db.relationship('father',back_populates="so")  
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 

4).多對多

設(shè)置一個關(guān)聯(lián)表來對兩個表同時進行管理。

# 設(shè)置關(guān)聯(lián)表 
gl=db.Table('glb', 
    db.Column('id',db.Integer,primary_key=True,autoincrement=True), 
    db.Column('son_id',db.Integer,db.ForeignKey('Son.id')), 
    db.Column('father_id',db.Integer,db.ForeignKey('Father.id')) 
) 
 
# 父表 
class father(db.Model): 
    __tablename__='Father' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    # 設(shè)置關(guān)聯(lián)表 動態(tài)加載 
    son_fa=db.relationship('son',secondary=gl,backref="fas",lazy="dynamic") 
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 
 
# 子表 
class son(db.Model): 
    __tablename__='Son' 
    id=db.Column(db.Integer, primary_key=True,autoincrement=True) 
    name= db.Column(db.String(100),nullable=False) 
    age= db.Column(db.Integer,nullable=False) 
    def __init__(self,name,age): 
        self.name=name 
        self.age=age 
    def __repr__(self): 
        return '%s is %r'%(self.__class__.__name__,self.name) 

可以看出我們已經(jīng)創(chuàng)建出了一張關(guān)聯(lián)表，名字就是我們設(shè)置的“glb”。

4.查看數(shù)據(jù)

1).查看全部數(shù)據(jù)(all)

father.query.all() 

2).精準查詢(filter_by)

father.query.filter_by(name='hw').all()  # 查找所有名字為hw的記錄 

3).模糊查詢(filter)

father.query.filter(father.name.startswith('h').all() # 查找所有名字首字母為h的記錄 

4).主鍵查詢(get)

father.query.get(1) # 查看id為1的記錄 

5).取反操作(not_)

from sqlalchemy import not_ 
father.query.filter(not_(father.name=='hw')).all() # 查找所有除了名字不是hw的記錄 

6).與操作(and_)

from sqlalchemy import and_ 
# 查找名字末尾是h并且年齡等于50的記錄 
father.query.filter(and_(father.name.endswith('h'),father.age==50)).all() 

7).或操作(or_)

from sqlalchemy import or_ 
# 查找名字末尾是h或者年齡等于50的記錄 
father.query.filter(or_(father.name.endswith('h'),father.age==50)).all() 

8).一對多正向查詢

son.query.filter_by(f_id=2).all() 

9).一對多反向查詢

son.query.filter_by(fa=use1).all() 

10).查詢第一個出現(xiàn)的數(shù)據(jù)

son.query.filter(son.age==10).first() 
son.query.filter(son.age==10)[0] 

11).查詢對象并返回指定數(shù)量的結(jié)果

son.query.filter(son.age==10).limit(10).all() # 返回十個查找到的對象 

12).查詢時指定偏移量

son.query.filter(son.age==10).offset(2).all() # 返回偏移了2的對象 

13).查找對象并排序

son.query.filter(son.age==10).order_by(son.create_time.desc()).all() # 返回按降序排序的記錄 

14).查找對象返回分組結(jié)果

son.query.filter(son.age==10).group_by(son.name).all() # 返回age為10的名字對象分組 

15).返回查詢結(jié)果的數(shù)量

son.query.filter(son.age==10).count() # son的年齡為10的數(shù)量 

16).返回切片結(jié)果

son.query(son).slice(10,40).all()   # son從10到40的記錄 
son.query(son)[10:40] 

17).分頁獲取數(shù)據(jù)

p=request.args.get('p') 
# 從請求的查詢字符串中獲取當前頁面，返回一個每頁顯示3條記錄的分頁對象 
paginate=son.query.paginate(p=int(p),per_page=3)  
paginate 屬性： 
pages     # 總共生成頁面數(shù)量 
page      # 當前頁數(shù) 
has_next  # 判斷是否有下一頁 
has_prev  # 判斷是否有上一頁 
next_num  # 獲取下一頁的頁碼數(shù) 
prev_num  # 獲取上一頁的頁碼數(shù) 
items     # 獲取當前頁的記錄 
total     # 查詢返回的記錄總數(shù) 

18).查詢僅顯示一條記錄

son.query(son).one() 

5.更新數(shù)據(jù)

ss=son.query.get(1) 
ss.name='fasd'     # 更改name的值來達到更新的目的 
db.session.commit() 

6.刪除數(shù)據(jù)

ss=son.query.get(1) 
db.session.delete(ss) 
db.session.commit() 

三、總結(jié)

Sqlalchemy支持很多表的建立和操作，通過對它的了解，我們可以很方便的操作數(shù)據(jù)庫的數(shù)據(jù)從而與前端頁面交互達到可視化的效果，通過這篇文章的學習，相信你可以獨立開發(fā)一個小網(wǎng)站了。

本文轉(zhuǎn)載自微信公眾號「Python爬蟲與數(shù)據(jù)挖掘」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系Python爬蟲與數(shù)據(jù)挖掘公眾號。