Python-Flask

時間 2020-04-01

標籤 python flask 欄目 Python 简体版

原文原文鏈接

Python-Flask

flask是Python的一個輕型Web框架.
使用pycharm自動建立項目,也能夠手動建立,如下是目錄的結構:html

├── app.py
├── static
└── templatespython

一建立一個簡單應用

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello_world():
    return "hello world "


if __name__ == '__main__':
    app.run()

其中，建立Flask實例時，能夠自定配置主要有：mysql

參數	說明
static_path	靜態文件訪問路徑(不推薦使用，使用 static_url_path 代替)
static_url_path	指定靜態文件的訪問路徑(默認爲 / + static_folder)
static_folder	指定存放靜態文件資源的文件夾的名稱（默認爲static）
template_folder	指定存放模板的文件夾的名稱（默認爲templates）

二路由規則

1 簡單路由

@app.route('/')
def hello_world():
    return "hello world "

2 帶參數路由

2.1 不限定類型

@app.route("/user/<username>")
def user_info(username):
    return "hello %s" % username

2.2 限定類型

@app.route("/user/<string:username>")
def user_info(username):
    return "hello %s" % username

注：這裏是string而不是str
其餘的類型有jquery

int 、 float、uuid、pathgit

3 正則路由

在Flask中是不能直接使用re的，須要使用轉換器。轉換器的做用就是：過濾指定用戶。
使用正則路由的步驟：web

一、導入轉換器基類（BaseConverter）
二、自定義轉換器（須要繼承BaseConverter）
三、把自定義的轉換器添加到轉換器字典中
四、在路由中使用轉換器sql

代碼：數據庫

from flask import Flask, render_template
# 第一步
from werkzeug.routing import BaseConverter
app = Flask(__name__)


# 第二步
class RegexConverter(BaseConverter):
    def __init__(self, url_map, *args):
        super(RegexConverter, self).__init__(url_map)
        # 正則參數
        self.regex = args[0]


# 第三步
app.url_map.converters['re'] = RegexConverter


# 第四步
@app.route("/user/<re('lcz.{2}'):username>")
def user_info(username):
    return "hello %s" % username


@app.route('/')
def hello_world():
    return render_template("index.html")


if __name__ == '__main__':
    app.run()

系統自帶的轉換器django

DEFAULT_CONVERTERS = {
'default': UnicodeConverter,
'path': PathConverter,
'string': UnicodeConverter,
'any': AnyConverter,
'int': IntegerConverter,
'float': FloatConverter,
'uuid': UUIDConverter,
}
其實不少都是參數路由的json

4 限定請求方式

加上一個methods參數限定請求的方式,注意methods應該是一個list

from flask import request


@app.route("/user", methods=["get", "post"])
def user():
    if request.method == "get":
        return "user"
    elif request.method == "post":
        pass
    else:
        pass

注意request是須要從falsk中導入的

三響應規則

1 HTML

1.1 HTML文本

@app.route("/user")
def user():
    return "<h1>User Info</h1>"

1.2 HTML文件

from flask import render_template

@app.route('/')
def hello_world():
    return render_template("index.html")

2 JSON

from flask import jsonify

@app.route("/user")
def user():
    data = {
        "user_name": "lczmx",
        "age": "18"
    }
    return jsonify(data)

3 重定向

from flask import redirect

@app.route("/index")
def index():
    return redirect("/")

4 跳轉視圖

from flask import redirect
from flask import url_for


@app.route("/user/<int:user_id>")
def user(user_id):
    if user_id > 200:
        return redirect(url_for("vip_user", user_id=user_id))
    else:
        return redirect(url_for("general_user"))


@app.route("/vip_user/<int:user_id>")
def vip_user(user_id):
    return "vip_user %s" % user_id


@app.route("/general_user")
def general_user():
    return "general_user"

5 狀態碼

@app.route('/')
def index():
    return render_template("index.html"), 200

200就是狀態碼,能夠是其餘的

四模板引擎

注:Flask的模板引擎是jinja2, 與django的很類似

1 變量

使用: {{ 變量名 }}
app.py中傳參

@app.route('/')
def index():
    return render_template("index.html", name="lczmx")

2 註釋

使用: {# 多行註釋 #}

3 過濾器

使用: {{ var|filter }}

3.1 經常使用的過濾器

設置默認值: {{ data.bool|default('我是默認值',boolean=True) }}
禁用轉義：{{ '<em>hello</em>' | safe }}
刪除標籤：{{ '<em>hello</em>'| striptags }}
首字母大寫：{{ 'hello' | capitalize }}
全部值小寫：{{ 'HELLO' | lower }}
首字母大寫：{{ 'hello world' | title }}
字符串反轉：{{ 'hello' | reverse }}
字符串截斷：{{ 'hello world' | truncate(5) }}
拼接成字符串: {{ [1,2,3,4] | join('') }}
字符的格式化: {{ '我叫%s '|format('lczmx') }}

獲取長度:{{ [1,2,3,4,5,6] | length }}
列表求和:{{ [1,2,3,4,5,6] | sum }}
列表排序:>{{ [6,2,3,1,5,4] | sort }}

3.2 自定義過濾器

方法1: 經過Flask對象(app)的add_template_filter方法

def add_suffix(line):
    return line + "--lczmx"

# 能夠給過濾器器一個名字，若是沒有，默認就是函數的名字
app.add_template_filter(add_suffix,'add_suffix')

方法2: 使用裝飾器來實現

# 使用裝飾器事項過濾器，
# 若是不傳入參數，默認過濾器名字就是函數的名字
@app.template_filter()
def add_suffix(line):
    return line + "--lczmx"

4 標籤

4.1 if

{% if user_info.nid == 10 %} <li>{{ user_info.msg1 }}</li> {% elif user_info.nid == 20%} <li>{{ user_info.msg2 }}</li> {% else %} <li>{{ user_info.msg3 }}</li> {% endif %}

4.2 for

{% for name in name_list %} <li>{{ name }}</li> {% endfor %}

不能使用continue和break

注:
在for中有一個關鍵字叫loop,使用loop能夠查看當前的迭代狀態
下面列出我認爲有用的loop方法

方法	說明
index0	獲取當前迭代的索引(從0開始)
index	獲取當前迭代的索引(從1開始)
first	是否爲第一次迭代
last	是否爲最後一次迭代
length	要迭代的數據長度
nextitem	下一項
previtem	前一項

使用:

{% for k,v in data.items() %} <li>{{ k }}--{{ v }}</li> <li>{{ loop.index }}</li> <li>{{ loop.index0 }}</li> <li>{{ loop.first }}</li> <li>{{ loop.last }}</li> <li>{{ loop.length }}</li> <li>{{ loop.nextitem}}</li> <li>{{ loop.previtem}}</li> <li>{{ loop.changed}}</li> <li>{{ loop.cycle}}</li> <li>{{ loop.revindex}}</li> <li>{{ loop.revindex0}}</li> {% endfor %}

5 導入

導入一個html文件,主要是導入一些可複用的.

{% include "layout.html" %}

6 繼承

好比我如今有一個模板base.html須要在index.html中繼承.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{% block title %}
{% endblock %}
<div>
    <h1>今天是個好日子</h1>
</div>
{% block  content%}
    <h3>我是內容</h3>
{% endblock %}
{% block js %}
<script src="../static/js/jquery.js"></script>
{% endblock %}
</body>
</html>

用block留出填充部分

{% extends "base.html" %} {% block title %} <h1>啦啦啦</h1> {% endblock %} {% block js %} {% endblock %}

在另一個html中就能夠繼承修改一些東西了
**注: block後面跟着名字

五獲取請求數據

注意: 須要先導入request
form flask import request
經常使用的request屬性有:

屬性名	說明
request.scheme	獲取請求協議
request.method	獲取本次請求的請求方式(GET / POST)
request.args	獲取以get請求方式提交的數據
request.form	獲取以post請求方式提交的數據
request.cookies	獲取cookies中的相關信息
request.headers	獲取請求信息頭的相關信息
request.files	獲取上傳的文件
request.path	獲取請求的資源具體路徑(不帶參數)
request.full_path	獲取完整的請求資源具體路徑(帶參數)
request.url	獲取完整的請求地址，從協議開始
request.files	獲取上傳的文件用（save進行保存）

注: arequest.args，request.form ，request.files 的返回值都是字典。

六會話控制

1 cookie

Cookie是由服務器端生成，發送給客戶端瀏覽器，瀏覽器會將Cookie的key/value保存，下次請求同一網站時就發送該Cookie給服務器（前提是瀏覽器設置爲啓用cookie）。Cookie的key/value能夠由服務器端本身定義。
Cookie是存儲在瀏覽器中的一段純文本信息，建議不要存儲敏感信息如密碼，由於電腦上的瀏覽器可能被其它人使用
Cookie基於域名安全，不一樣域名的Cookie是不能互相訪問的
如訪問huya.com時向瀏覽器中寫了Cookie信息，使用同一瀏覽器訪問 baidu.com時，沒法訪問到huya.com寫的Cookie信息
瀏覽器的同源策略針對cookie也有限制做用.
當瀏覽器請求某網站時，會將本網站下全部Cookie信息提交給服務器，因此在request中能夠讀取Cookie信息
使用場景: 登陸狀態, 瀏覽歷史, 網站足跡

1.1 設置cookie

from flask import make_response

@app.route('/set_cookie')
def set_cookie():
    res = make_response('set cookie page')
    res.set_cookie('username', 'lczmx', max_age=604800)  # max_age 是cookie有效期，單位爲秒, 這裏恰好設置一週時間
    return res

效果圖

1.2 獲取cookie

from flask import request

@app.route('/vip')
def resp_cookie():
     user_name = request.cookies.get('username')
     if user_name == "lczmx":
         return "vip"
     else:
         return "bye"

2 session

對於敏感、重要的信息，建議要存儲在服務器端，不能存儲在瀏覽器中，如用戶名、餘額、等級、驗證碼等信息
在服務器端進行狀態保持的方案就是Session
注意: Session依賴於Cookie,並且flask中使用session,須要配置SECRET_KEY選項,不然報錯.

2.1 配置SECRET_KEY

生成SECRET_KEY：

這裏使用操做系統的密碼隨機生成器生成
命令行輸入：
import os
os.urandom(24)

在config.py中：

CSRF_ENABLED = True
SECRET_KEY = 'SECRET_KEY粘貼在這裏'

在app.py中

import config

app.config.from_object(config)

其實,全部的配置都應該放在config文件中,而後導入

2.2 設置session

from flask import session

@app.route('/set_session')
def set_session():
     session['username'] = 'lczmx'
	 session['password'] = '123456'
     return 'success'

必定要先配置SECRET_KEY

2.3 獲取session

from flask import session, jsonify

@app.route('/login')
def login():
     user_name = session.get('username')
     pass_word = session.get('password')
     if user_name == "lczmx" and pass_word == "123456":
         return jsonify({"status": 1, "msg": "success"})
     else:
         return jsonify({"status": 0, "msg": "failed"})

七 Models

假如使用過django的orm,我相信通常人都不會直接寫sql語句操做數據庫了.那麼Flask有沒有一款orm呢?應該說是有吧.該ORM是SQLAlchemy, 首次發行於2006年2月，並迅速地在Python社區中最普遍使用的ORM工具之一，不亞於Django的ORM框架。

點擊查看Flask-SQLAlchemy的API

1 安裝

默認安裝Flask是不帶flask-sqlalchemy,須要手動安裝

pip install flask-sqlalchemy
# 若是鏈接的是 mysql 數據庫，須要安裝 flask-mysqldb
pip install flask-mysqldb
# 提示:若是flask-mysqldb安裝不上,安裝, pip install pymysql

2 配置

操做數據庫須要先建立一個db對象，一般寫在exts.py文件裏。
exts.py:

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

flask項目通常將數據庫配置寫入config.py文件裏面，配置在建立引擎前需寫好，不要在程序運行時修改配置，以下
config.py:

HOST = '127.0.0.1'
PORT = '3306'   # 在mysql中使用show global variables like 'port';查看端口
DATABASE = 'test'
USERNAME = 'root'
PASSWORD = '123456'

DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,
                                                                                        password=PASSWORD, host=HOST,
                                                                                        port=PORT, db=DATABASE)

SQLALCHEMY_DATABASE_URI = DB_URI
SQLALCHEMY_TRACK_MODIFICATIONS = False
SQLALCHEMY_ECHO = True

配置選項

名稱	說明
SQLALCHEMY_DATABASE_URI	鏈接的數據庫。示例：mysql://username:password@host/post/db?charset=utf-8
SQLALCHEMY_BINDS	一個將會綁定多種數據庫的字典
SQLALCHEMY_ECHO	是否調試
SQLALCHEMY_POOL_SIZE	數據庫池的大小，默認值爲5
SQLALCHEMY_POOL_TIMEOUT	鏈接超時
SQLALCHEMY_POOL_RECYCLE	自動回收鏈接的秒數
SQLALCHEMY_TRACK_MODIFICATIONS	默認爲True ，Flask-SQLAlchemy 將會追蹤對象的修改而且發送信號。(須要內存，能夠禁用)
SQLALCHEMY_MAX_OVERFLOW	控制在鏈接池達到最大值後能夠建立的鏈接數。當這些額外的鏈接回收到鏈接池後將會被斷開和拋棄。

3 使用

在app.py:

from flask import Flask
import config
from exts import db

app = Flask(__name__)


app.config.from_object(config)  # 加載配置文件
db.init_app(app)    # db綁定app


@app.route('/')
def index():
    return "Index"


if __name__ == '__main__':
    app.run()

4 ORM操做

4.1 表操做

4.1.1 建立一個表

# models文件中
from exts import db

class User(db.Model):
	__tablename__ = "User"    #設置表名
    uid = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True)
    email = db.Column(db.String(120), unique=True)

    def __init__(self, username, email):
        self.username = username
        self.email = email

    def __repr__(self):
        return '<User %r>' % self.username

在Flask-SQLAlchemy中,一張表其實就是一個類.跟Django的ORM很是類似.
注意: 類須要繼承db.Model

完整示例

建立一個表的過程，有不少坑。因此這裏詳細記錄一下
首先看一下tree圖
.
├── app.py
├── config.py
├── exts.py
├── models.py
把應用分紅4個py文件是爲了之後好維護。
app.py:

from flask import Flask
import config
from exts import db
from models import Article  # 坑一

app = Flask(__name__)
app.config.from_object(config) 

db.init_app(app)  # 坑二



@app.route('/')
def index():
    db.create_all()  # 坑三
    return "Index"


if __name__ == '__main__':
    app.run()

坑一: 你要建立那個表,你就得導入那個表所在的py文件(即便它在app.py中未被使用),否者不會建立表,且不會報錯
坑二: app.config.from_object(config) 必定要在db.init_app(app)以前,否者會報錯
坑三: db.create_all() 是建立一個表的命令(models中的類不會建立一個表,就比如django用命令行生成表同樣),注意必定要在view函數裏面寫,否則不會建立表,且不會報錯.建議在'/'中寫,不會重複建立,能夠在建立完後刪除

config.py:

HOST = '127.0.0.1'
PORT = '3306'   # 在mysql中使用show global variables like 'port';查看端口
DATABASE = 'test'
USERNAME = 'root'
PASSWORD = '123456'

DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,
                                                                                        password=PASSWORD, host=HOST,
                                                                                        port=PORT, db=DATABASE)

SQLALCHEMY_DATABASE_URI = DB_URI
SQLALCHEMY_TRACK_MODIFICATIONS = False
SQLALCHEMY_ECHO = True

跟以前的沒有區別,爲了方便寫下了
exts.py:

from flask_sqlalchemy import SQLAlchemy
#此時先不傳入app
db = SQLAlchemy()

models.py:

from exts import db


class Article2(db.Model):
    __tablename__ = 'article'
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
	def __init__(self, title, content):
	    self.title = title
		self.content = content

在這裏就能夠盡情寫表了,注意在app.py中引入就好了

__init__中記得寫上字段名,新增數據時要實例化

數據類型和約束條件在這裏:

# class類中
# 使用db.Column(數據類型, 約束條件)建立,好比:
uid = db.Column(db.Integer, primary_key=True)

數據類型

數據類型	說明
Integer	整形(通常是32位)
SmallInteger	整形(通常是16位)
BigInteger	不限制精度的整數
Float	浮點數
String	字符串
Text	文本
Unicode	Unicode 字符串
UnicodeText	Unicode 文本
Date	日期(datetime.date)
Time	時間(datetime.time)
DateTime	日期+時間(datetime.datetime)
Boolean	布爾值
LargeBinary	二進制文件
pickleType	pickle(Python的一個標準庫)後的對象

約束條件

約束條件	說明
primary_key	若是設爲 True，這列就是表的主鍵
autoincrement	若是設爲 True，主鍵自增加
unique	若是設爲 True，這列不容許出現重複的值
index	若是設爲 True，爲這列建立索引，提高查詢效率
nullable	若是設爲 True，這列容許使用空值；若是設爲 False，這列不容許使用空值
default	爲這列定義默認值
doc	字段說明

4.1.2 建立一條記錄

咱們如今已經有一張表了,假如咱們須要向表中添加數據那麼就須要用到

db.session.add(tab)
db.session.commit()

例子

注User表和render_template都要咱們導入

@app.route("/register", methods=["get", "post"])
def register():
    print(request.method)
    if request.method == "GET":
        return render_template("register.html")
    else:
        username = request.form.get("username")
        password = request.form.get("password")
        user_obj = User(username, password)
        db.session.add(user_obj)
        db.session.commit()
        return "ok!"

特別提示: db.session.add()的參數是一個model對象(表的對象),傳錯的話會報錯
對於一次性修改多個表的話,可使用db.session.add_all(), 參數是由表對象組成的可迭代對象(如:[user_obj, article_obj])

4.2 一對多關係

4.2.1創建一對多關係

一對多關係就是字表db.ForeignKey和主表db.relationship一塊兒創建
db.relationship很重要，後面查詢時用到

from exts import db


class User(db.Model):
    __tablename__ = 'user'
    nid = db.Column(db.Integer, primary_key=True, autoincrement=True)
    username = db.Column(db.String(16), nullable=False)
    password = db.Column(db.String(32), nullable=False)
	article = db.relationship("Article", backref="user")

    def __init__(self, username, password):
        self.username = username
        self.password = password

    def __repr__(self):
        return "<User %s>" % self.username


class Article(db.Model):
    __tablename__ = 'Article'
    nid = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(36), nullable=False)
    content = db.Column(db.Text, nullable=False)
    author_id = db.Column(db.Integer, db.ForeignKey("user.nid"))

    def __init__(self, title):
        self.title = title
		self.content = content

    def __repr__(self):
        return "<User %s>" % self.title

坑: 必定要注意db.ForeignKey的參數是 表名.xxx,並且表名是__tablename__,不是類名,大小寫敏感,寫錯會報錯

4.2.2 一對多——增

一對多增長條記錄,會同時修改兩個表,但只須要一次bd.session.add()和db.session.commit()

@app.route("/register", methods=["get", "post"])
def register():
    print(request.method)
    if request.method == "GET":
        return render_template("register.html")
    else:
        username = request.form.get("username")
        password = request.form.get("password")
        title = request.form.get("title")
        content = request.form.get("content")
		
        user_obj = User(username, password)
        art_obj = Article(title, content)
        user_obj.article = [art_obj]
        db.session.add(user_obj)
        db.session.commit()
        return "ok!"

注意: relationship字段接收的是一個list

4.2.3 一對多——刪

步驟：
一、找到要刪除的記錄
二、db.session.delete(a)刪除
三、db.session.commit()保存

@app.route('/delete_user')
def delete_user():
    a = db.session.query(User).filter(User.nid == 2).first()
    db.session.delete(a)
    db.session.commit()
    return "ok"

4.2.4 一對多——改

@app.route('/update_article')
def update_article():
    # 方法一
    a = db.session.query(Article).get(1)  # 先查詢出須要修改的條目
    print(a)
    Article.query.get(1)
    a.title = '母豬產後護理'  # 修改
    db.session.commit()

    # 方法二
    # 直接查詢出後修改，update採用字典修改{修要修改的列：'修改後的值'}
    db.session.query(Article).filter(Article.nid == 3).update({Article.title: '母豬產後護理'})
    db.session.commit()
	return 'ok'

4.2.5 一對多——查

先看代碼

@app.route('/get_article')
def get_article():
    # 子查主
    # 方法一
    user1 = db.session.query(Article).filter(Article.title == '母豬產後護理').first().user
    # 方法二
    user2 = Article.query.filter(Article.title == '母豬產後護理').first().user
    print("user1", user1.username)
    print("user2", user2)

    # 主查子
    # 方法一
    article1 = db.session.query(User).filter(User.username == 'lczmx').first().article
    # 方法二
    article2 = User.query.filter(User.username == 'lczmx').first().article
    print(article1)
    print(article2)
    return "ok"

這裏須要注意的是:
一、query.filter()後的數據是BaseQuery對象，不能經過‘.外鍵’的方式取值，要把其變爲表的對象後才能‘.’
二、這裏的跨表查詢實際上用到的是主表的relationship

relationship的參數：backref
圖示：

關係

補充：
relationship的關鍵字參數cascade

值	說明
save-update	默認選。在添加一條數據的時候，會把其餘和它相關聯的數據都添加到數據庫中。這種行爲就是save-update屬性影響的。
delete	表示當刪除某一個模型中的數據的時候，是否也刪除掉使用relationship和它關聯的數據。
delete-orphan	表示當對一個ORM對象解除了父表中的關聯對象的時候，本身便會被刪除掉。固然若是表中的數據被刪除，本身也會被刪除。這個選項只能用在一對多上，不能用在多對多以及多對一上。而且還須要在子模型中的relationship中，增長一個single_parent=True的參數。
merge	默認選項。當在使用session.merge，合併一個對象的時候，會將使用了relationship相關聯的對象也進行merge操做
expunge	移除操做的時候，會將相關聯的對象也進行移除。這個操做只是從session中移除，並不會真正的從數據庫中刪除。
all	是對save-update，merge，refresh-expire，expunge，delete幾種的填寫

好比：

articles = relationship("Article",cascade="save-update,delete")

來源：點擊這裏

4.2.6 查（不跨表）

對於普通的單表查找知道在哪裏寫好，只好這這裏記錄了。
假如已經import了User表

命令	說明
User.query.all()	查詢全部用戶數據
User.query.count()	查詢有多少個用戶
User.query.first()	查詢第1個用戶
User.query.get(1)	根據id查詢
User.query.filter_by(id=1).all()	根據id查詢，簡單查詢，使用關鍵字實參的形式來設置字段名
User.query.filter(User.id == 1).all()	根據id查詢，複雜查詢，使用恆等式等其餘形式來設置條件
User.query.filter(User.name.startswith("l")).all()	開頭
User.query.filter(User.name.endswith("x")).all()	結尾
User.query.filter(User.name.contains("lcz")).all()	包含
User.query.filter(User.name.like("%cz%")).all()	模糊查詢，點擊查看多關鍵字過濾查詢
User.query.filter(not_(User.name == "lczmx")).all()	取反查詢
User.query.filter(User.name != "lczmx").all()	取反查詢
User.query.filter(User.id.in_([1, 3, 5, 7, 9])).all()	查詢id爲[1, 3, 5, 7, 9]的用戶
User.query.group_by(User.role_id).all()	分組查詢
User.query.order_by(User.role_id).all()	排序
.distinct()	去重
.limit(n)	取結果的前n個
.offset(n)	跳過前n個
pn = User.query.paginate((page,per_page,False)	分頁查詢,age:哪一頁 per_page:每頁多少條，False：查詢不到不報錯。pn.items 獲取該頁的數據 pn.page 獲取當前的頁碼 pn.pages 獲取總頁數

這篇文章寫得很好
注：和django的ORM同樣.all()的是一個由query對象組成的列表，.get()和.first()以及.last()都是query對象

4.3 一對一關係

一對一須要設置relationship中的uselist=Flase，其餘數據庫操做同樣。

4.4 多對多關係

若是你想要用多對多關係，你須要定義一個用於關係的輔助表。對於這個輔助表，強烈建議不使用模型，而是採用一個實際的表

4.4.1 創建多對多關係

使用db.Table

student2course = db.Table('student2course', db.Column('student_id', db.Integer, db.ForeignKey('student.id')),
                db.Column('course_id', db.Integer, db.ForeignKey('course.id')))


class Student(db.Model):
    __tablename__ = 'student'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(12))
    course = db.relationship('Course', secondary=student2course)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "name:%r" % self.name


class Course(db.Model):
    ___tablename__ = 'course'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(30), unique=True)

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "name:%r" % self.name

注：添加多對多的反向引用,必須使用secondary指定中間關聯表

4.4.2 多對多——增

@app.route("/add")
def add():
    stu1 = Student("盧來佛祖")
    stu2 = Student("喬碧蘿")
    cou1 = Course("語文")
    cou2 = Course("數學")
    cou3 = Course("英語")
    stu1.course = [cou1, cou2]
    stu2.course = [cou1, cou2, cou3]
    db.session.add_all([stu1, stu2])
    db.session.commit()
    return "ok"

能夠發現，使用的就是一對多的方法，實際上多對多就是兩個一對多
另外一種狀況
假如爲已經在表中的數據添加關係

@app.route("/update")
def update():
    cou1 = Course.query.filter_by(id=2).first()
    stu1 = Student.query.get(1)
    stu1.course.append(cou1)
    db.session.add(stu1)
    db.session.commit()
    return "ok"

4.4.3 多對多——刪

@app.route("/delete")
def delete():
    cou = Course.query.get(2)
    stu = Student.query.get(1)
    stu.course.remove(cou)
    db.session.commit()
    return "ok"

假如使用Student.query.filter(Student.id == 2).first().course.remove(cou)，這樣一條代碼寫完的話會報錯，不知道爲何
報錯提示：sqlalchemy.orm.exc.ObjectDereferencedError: Can't emit change event for attribute 'Student.course' - parent object of type has been garbage collected.

5 db的方法總結

方法	說明
.create_all()	建立全部表
.drop_all()	刪除全部表
.init_app(app)	初始化應用程序

相關標籤/搜索

Python

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

Python-Flask

Python-Flask

一 建立一個簡單應用

二 路由規則

1 簡單路由

2 帶參數路由

2.1 不限定類型

2.2 限定類型

3 正則路由

4 限定請求方式

三 響應規則

1 HTML

1.1 HTML文本

1.2 HTML文件

2 JSON

3 重定向

4 跳轉視圖

5 狀態碼

四 模板引擎

1 變量

2 註釋

3 過濾器

3.1 經常使用的過濾器

3.2 自定義過濾器

4 標籤

4.1 if

4.2 for

5 導入

6 繼承

五 獲取請求數據

六 會話控制

1 cookie

1.1 設置cookie

1.2 獲取cookie

2 session

2.1 配置SECRET_KEY

2.2 設置session

2.3 獲取session

七 Models

1 安裝

2 配置

3 使用

4 ORM操做

4.1 表操做

4.1.1 建立一個表

完整示例

4.1.2 建立一條記錄

例子

4.2 一對多關係

4.2.1創建一對多關係

4.2.2 一對多——增

4.2.3 一對多——刪

4.2.4 一對多——改

4.2.5 一對多——查

4.2.6 查（不跨表）

4.3 一對一關係

4.4 多對多關係

4.4.1 創建多對多關係

4.4.2 多對多——增

4.4.3 多對多——刪

5 db的方法總結

一建立一個簡單應用

二路由規則

三響應規則

四模板引擎

五獲取請求數據

六會話控制