盤點Flask與數據庫的交互插件--Flask-Sqlalchemy
作者：Python進階者
在我們做web開發的時候，經常需要用到與數據庫交互，因為我們的數據通常都是保存在數據庫中的，如果有人需要訪問，就必須與數據庫訪問，所以今天我們介紹一個Flask中與數據庫交互的插件---Flask-Sqlalchemy。
大家好，我是Python進階者。
前言
在我們做web開發的時候，經常需要用到與數據庫交互，因為我們的數據通常都是保存在數據庫中的，如果有人需要訪問，就必須與數據庫訪問，所以今天我們介紹一個Flask中與數據庫交互的插件---Flask-Sqlalchemy。
一、安裝并導入
- pip install flask-sqlalchemy
- from flask_sqlalchemy import SQLAlchemy
- import os
- import pymysql as p
- from flask import Flask
二、基本用法
今天我們要了解的是Mysql數據庫，所以這里重點介紹連接Mysql數據庫的方法。
1.連接數據庫
1).寫在配置文件中然后讀取
首先創建一個配置文件"config.py"，內容為：
- 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
然后在應用中導入配置文件：
- from flask_sqlalchemy import SQLAlchemy
- from flask import Flask
- import config
- app=Flask(__name__)
- app.config.from_object(config) # 連接數據庫配置文件
- db=SQLAlchemy(app)
- db.create_all() # 創建所有的數據庫
2).直接寫在應用中讀取
- 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 # 每次請求結束后都會自動提交數據庫中的變動
- app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # 動態追蹤修改設置，如未設置只會提示警告
- db = SQLAlchemy(app)
還有許多其它的配置參數，比如：
- SQLALCHEMY_NATIVE_UNICODE # 可以用于顯式禁用原生 unicode 支持
- SQLALCHEMY_POOL_SIZE # 數據庫連接池的大小，默認是引擎默認值（5）
- SQLALCHEMY_POOL_TIMEOUT # 設定連接池的連接超時時間，默認是 10
- SQLALCHEMY_POOL_RECYCLE # 多少秒后自動回收連接，mysql默認為2小時
- SQLALCHEMY_RECORD_QUERIES # 可以用于顯式地禁用或啟用查詢記錄
- SQLALCHEMY_ECHO # 為Ture時用于調試，顯示錯誤信息
- SQLALCHEMY_BINDS # 一個映射 binds 到連接 URI 的字典
3).使用獨特的創建引擎
- from sqlalchemy import create_engine
- # echo參數為True時，會顯示每條執行的SQL語句，為False時關閉
- engine = create_engine('mysql+pymysql://root:123456@127.0.0.1:3306/people',echo=True)
- engine.connect()
這樣我們就算與People數據庫建立連接了，接下來我們來建立一張表。
4).創建連接多個數據庫
- 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數據庫中的表：
- __bind_key__ = 'users'
- bind key 內部存儲在表的 info 字典中 即：info={'bind_key': 'users'}
2.建立數據表并插入值
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) # 整數類型的自增主鍵
- 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)
- # 請求鉤子,第一次請求之前執行
- @app.before_first_request
- def create_table():
- db.drop_all() # 刪除所有表
- db.create_all() # 創建新的表
- @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() # 提交數據
- return use1.__repr__() # 返回用戶1的值
- if __name__ == '__main__':
- app.run(debug=True)
- Column 參數列表
- name 列名
- type_ 類型
- *args 列表參數
- Constraint（約束）, ForeignKey（外鍵）, ColumnDefault（默認）, Sequenceobjects（序列）定義
- key 列名的別名
- primary_key 如果為True，則是主鍵
- nullable 如果是True，則可以為null
- default 設置默認值，默認是None
- index 是否是索引，默認是True
- unique 是否唯一鍵，默認是False
- onupdate 指定一個更新時候的值
- autoincrement 設置為整型自動增長
- quote 如果列明是關鍵字，則強制轉義，默認False
2).利用原始引擎來創建會話(稍微復雜點)
- 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()
- # 創建連接數據庫的引擎并且打開回顯
- engine = create_engine("mysql+pymysql://root:123456@localhost/people",echo=True)
- Session = sessionmaker(bind=engine) # 創建會話標記
- 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) # 刪除所有數據庫
- Base.metadata.create_all(engine) # 創建所有數據庫
- @app.route('/')
- def index():
- user= User("hwhrr","123321")
- session = Session() # 創建會話
- session.add(user) # 添加內容
- session.commit() # 提交
- return user.__repr__()
- if __name__ == '__main__':
- app.run(debug=True)
3.數據庫之間的關系
1). 一對一
只需讓兩張表都在同等的位置上，屬于雙向關系。
- 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)
- #主要是要在一個表上設置uselist 然后設置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)
- # 這里無需設置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’，然后需要建立外鍵和反射來互相引用建立一種關系，我們來看看：
- 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：動態加載，只有用到了才加載 只可以用在一對多和多對多關系中
- # 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')) # 建立外鍵關聯，指明表名和字段
- 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).多對一
就是將反射應用在子表上，與父表同時進行關聯。
- 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')) # 建立外鍵關聯
- # 表示另一端是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).多對多
設置一個關聯表來對兩個表同時進行管理。
- # 設置關聯表
- 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., primary_key=True,autoincrement=True)
- name= db.Column(db.String(100),nullable=False)
- age= db.Column(db.Integer,nullable=False)
- # 設置關聯表 動態加載
- 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)
可以看出我們已經創建出了一張關聯表，名字就是我們設置的“glb”。
4.查看數據
1).查看全部數據(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).查詢第一個出現的數據
- son.query.filter(son.age==10).first()
- son.query.filter(son.age==10)[0]
11).查詢對象并返回指定數量的結果
- 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).查找對象返回分組結果
- son.query.filter(son.age==10).group_by(son.name).all() # 返回age為10的名字對象分組
15).返回查詢結果的數量
- son.query.filter(son.age==10).count() # son的年齡為10的數量
16).返回切片結果
- son.query(son).slice(10,40).all() # son從10到40的記錄
- son.query(son)[10:40]
17).分頁獲取數據
- p=request.args.get('p')
- # 從請求的查詢字符串中獲取當前頁面，返回一個每頁顯示3條記錄的分頁對象
- paginate=son.query.paginate(p=int(p),per_page=3)
- paginate 屬性：
- pages # 總共生成頁面數量
- page # 當前頁數
- has_next # 判斷是否有下一頁
- has_prev # 判斷是否有上一頁
- next_num # 獲取下一頁的頁碼數
- prev_num # 獲取上一頁的頁碼數
- items # 獲取當前頁的記錄
- total # 查詢返回的記錄總數
18).查詢僅顯示一條記錄
- son.query(son).one()
5.更新數據
- ss=son.query.get(1)
- ss.name='fasd' # 更改name的值來達到更新的目的
- db.session.commit()
6.刪除數據
- ss=son.query.get(1)
- db.session.delete(ss)
- db.session.commit()
三、總結
Sqlalchemy支持很多表的建立和操作，通過對它的了解，我們可以很方便的操作數據庫的數據從而與前端頁面交互達到可視化的效果，通過這篇文章的學習，相信你可以獨立開發一個小網站了。
本文轉載自微信公眾號「Python爬蟲與數據挖掘」，可以通過以下二維碼關注。轉載本文請聯系Python爬蟲與數據挖掘公眾號。
責任編輯：武曉燕
來源：
Python爬蟲與數據挖掘
