So schreiben Sie Python-Anwendungen mit Flask Blueprint und SQLAlchemy

Installationsvorbereitung

python3 -V && pip3 -V
pip3 install pipenv

pipenv

pipenv shell

Die Umgebungskonfiguration von PyCharm wird hier nicht allzu ausführlich erläutert. Hier finden Sie eine Erklärung des folgenden Codes.

Beginnen Sie mit dem Üben

Das Prinzip von Flask besteht darin, den Blueprint und die App zu binden, um die Web-Routing-Funktion zu implementieren, wenn die App initialisiert wird. Die Implementierung des Routings ist der erste Schritt in allen Projekten.

Eintragsdatei

Bevor Sie das Projekt starten, definieren Sie eine Eintragsdatei, damit Anforderungen die App instanziieren können. Die Eintragsdatei muss lediglich die Konfigurationsdatei initialisieren, den Controller einführen, die Datenbank initialisieren und andere Vorgänge ausführen.

def create_app():
    app = Flask(__name__)
    # 导入config中的配置文件
    app.config.from_object('app.config.setting')
    app.config.from_object('app.config.secure')
    return app

Das Urteil muss zur Startdatei hinzugefügt werden. Der Grund wird später erläutert.

from app.app import create_app
app = create_app()
if __name__ == '__main__':
    app.run(debug =True,port=81,host= '0.0.0.0')

Routing

Flask ist eine Routing-Funktion, die mithilfe von Blueprints implementiert wird. Fügen Sie eine Methode zum Registrieren von Blueprints in der Eintragsdatei hinzu, um Einführung und Registrierung zu implementieren.

from flask import Blueprint
login = Blueprint('login', __name__)
@login.route('/login')
def loginIndex():
    return "login Hello"

Führen Sie das Blueprint-Modul ein, wenn die App-Instanz initialisiert wird.

from flask import Flask
def create_app():
    app = Flask(__name__)
    # 导入config中的配置文件
    app.config.from_object('app.config.setting')
    app.config.from_object('app.config.secure')
    # 注册并导入蓝图
    register_blue(app)
    return app
def register_blue(app):
    from app.api.login import login
    app.register_blueprint(login)

Optimieren Sie den Router.

Sie können jedem Router einen Loader hinzufügen und die Blueprints während der Initialisierung nacheinander in Flask laden, um den Zweck der Optimierung des Routers zu erreichen.

class BaseRoutes:
    def __init__(self, name):
        self.name = name
        self.loader = []
    def route(self, rule, **options):
        def decorator(f):
            self.loader.append((f, rule, options))
            return f
        return decorator
    def register(self, bp, url_prefix=''):
        # 依次注册蓝图
        for f, rule, options in self.loader:
            endpoint = options.pop("endpoint", f.__name__)
            bp.add_url_rule(url_prefix + rule, endpoint, f, **options)

Der in der API-Datei verwendete optimierte Ladecode lautet wie folgt:

from app.libs.BaseRoutes import BaseRoutes
api = BaseRoutes('login')
@api.route('/login/loginHandle', methods=['GET', 'POST'])
def loginHandle():
    return "login Hello"

SQLAlchemy

Nachdem wir das Routing des Webs abgeschlossen hatten, begannen wir, das Hinzufügen, Löschen, Ändern und Abfragen der Datenbank weiter zu üben und zu untersuchen verwendet SQLAlchemy, um den Datenbankoptimierungsvorgang durchzuführen. Hier nehmen wir die MySQL-Datenbank als Beispiel.

Um SQLAlchemy verwenden zu können, müssen Sie zwei Komponenten installieren: Datenbank + Treiberpaket. Durch die Installation von Flask-SQLAlchemy + PyMySQL wird unsere Entwicklung einfacher und bequemer.

Definition der Datenbankklasse

Für alle Flask-Anwendungen und Plug-Ins müssen sie in App Power registriert werden und Objekte zum Betrieb verwenden. Definieren Sie zunächst die Basisklasse für Datenbankoperationen und lassen Sie andere Module in Base registrieren.

Öffentliche Methoden in allen DBs werden in Base geschrieben, um den Prozess der Neuerfindung des Rades zu reduzieren.

Instanziieren Sie SQLAlchemy in Base

from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class Base(db.Model):
    # 忽略基类的主键
    __abstract__ = True

Gewöhnliche Datenklassen erben die Basisklasse. Nehmen Sie die Benutzerklasse als Beispiel und führen Sie das Datenbankpaket ein, bevor Sie es verwenden.

from app.models.base import Base
class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50), nullable=False, default="")
    email = Column(String(120), nullable=False, default="")
    _password = Column('password',String(64))
    @property
    def password(self):
        return self._password
    @password.setter
    def password(self, raw):
        self._password = generate_password_hash(raw)

Die Eintragsdatei lädt die Datenbank.

Beim Laden von Daten müssen Sie laden In der Datenbankinitialisierungskonfiguration wird SQLALCHEMY_DATABASE_URI angegeben und hat ein angegebenes Format. SQLALCHEMY_DATABASE_URI指定，有指定的格式。

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:123456@127.0.0.1:3306/admin?charset=utf8'

SQLALCHEMY_DATABASE_URI =数据库+驱动名称://用户名:密码@ip地址:端口号/数据库名称

def create_app():
    app = Flask(__name__)
    app.config.from_object('app.config.secure')
    # 初始化数据库
    db.init_app(app)
    with app.app_context():
        db.create_all()
    return app

说明和解释一下with关键字的作用，在python中主要使用的是栈数据结构来运行App实例，with关键字能很好的区分上下文，当资源断开时会自动释放和回收，对程序能启到优化的作用。

mysql的驱动可以使用cymysql,也可以使用pymysql，网上使用pymysql的教程会偏多一点，使用驱动时，如果拿不定主意去github上使用stat数多的插件，选大众型的，这样解决方案也会多一点。

模块中定义方法

model中可以定义模型，常量，直接操作数据库的原子方法，也可以使用db.session的形式来读取数据。

from sqlalchemy import Column, Integer, String, SmallInteger
from app.models.base import Base, db
class tp_manager(Base):
    STATUS_NORMAL = 1
    STATUS_STOP = 0
    # ...
    @classmethod
    def get_manager_by_name(cls, username):
        r = cls.query.filter(cls.username == username, cls.status == cls.STATUS_NORMAL).one()
        return r
    @classmethod
    def get_db(cls):
        r = db.session.query(cls).filter(cls.status == cls.STATUS_NORMAL).all()
        return r

在路由中的使用

在路由中使用时，需要引入models中对应的model包，下面是一个简单使用的Demo，用户的权限可以使用falsk-login组件来存储用户信息。

from flask import request, session, jsonify
from app.libs.BaseRoutes import BaseRoutes
from app.validators.form.login import LoginForm
from app.models.admin.tp_manager import tp_manager
api = BaseRoutes('login')
@api.route('/login/loginHandle', methods=['POST'])
def loginHandle():
    form = LoginForm(request.form)
    if form.validate():
        # 验证通过的逻辑
        r = tp_manager.get_manager_by_name(form.username.data)
        if r:
            msg = '操作成功'
            session['manager_id'] = r.id
        else:
            msg = '账号和密码错误'
        return jsonify({"code": 200, "data": [], "msg": msg})
    else:
        # 错误暂时忽略...
        return form.errors

顺便写一句，flask在使用session前，在配置文件中需要配置SECRET_KEY,不然会报错,key值自定义即可。

SECRET_KEY = '需要加密的key值'

SQLAlchemy实现mysql编码、列类型

在SQLAlchemy 对Mysql实现了基本操作以后，我发现设置出来的默认值没有生效，字符集编码也被设置成了默认的latin1，优化Mysql的列类型，实现Mysql连接池、接入mongo、redis等NoSql数据库成了下一步要研究的问题。

默认值和索引设置

python源码包里的解释很清晰 还附带了例子 ，在Column中是这样设置的：

Column(Integer, index=True, nullable=False,  server_default="0",comment="昵称")

server_default Orm设置初始化Mysql的值，unique指定的是否为唯一索引，default是在SQLAlchemy进行CURD操作时进行的默认值,server_defaul和default的值必须是字符串类型的。

index是设置索引，nullable设置是否为空，comment设置的是备注信息。

兼容Mysql列类型

但是摆在眼前一个问题，你想使用tinyint类型，字符集怎么设置？

from sqlalchemy.dialects.mysql import VARCHAR, TEXT, BIGINT, INTEGER, SMALLINT, TINYINT, DECIMAL, FLOAT, \
    DOUBLE, DATETIME, TIMESTAMP, DECIMAL

以使用最多的int和varchar为例,使用之前要导入对应的包：

from sqlalchemy import Column, Index, Integer
from sqlalchemy.dialects.mysql import VARCHAR, TEXT, BIGINT, INTEGER, SMALLINT, TINYINT, DECIMAL, FLOAT, \
    DOUBLE, DATETIME, TIMESTAMP, DECIMAL
from app.models.base import Base, db
class wm_user_user(Base):
    STATUS_NORMAL = 1
    __tablename__ = 'wm_user_user'
    user_status = Column(TINYINT(display_width=1,unsigned=True), nullable=False, server_default="1",
                         comment="1为正常,0为审核中")
    user_nickname = Column(VARCHAR(length=50), index=True, nullable=False, comment="昵称")
    # 添加配置设置编码
    __table_args__ = {
        'mysql_charset': 'utf8mb4',
        'mysql_collate': 'utf8mb4_general_ci'
    }

TINYINT类型中有三个参数：

display_width 设置的是列类型宽度，设置完以后会显示tinyint(1)

"""Construct a TINYINT.
:param display_width: Optional, maximum display width for this number.
:param unsigned: a boolean, optional.
:param zerofill: Optional. If true, values will be stored as strings
  left-padded with zeros. Note that this does not effect the values
  returned by the underlying database API, which continue to be
  numeric.
"""

SQLALCHEMY_DATABASE_URI =Datenbank + Treibername://Benutzername:Passwort@IP-Adresse:Portnummer/Datenbankname

__tablename__ = 'wm_user_user'
# ...
__table_args__ = {
    'mysql_charset': 'utf8mb4',
    'mysql_collate': 'utf8mb4_general_ci'
}

Erklären und erläutern Sie die Funktion des Schlüsselworts with, das hauptsächlich in Python verwendet wird Die Stapeldatenstruktur wird zum Ausführen der App-Instanz verwendet. Das Schlüsselwort „with“ kann den Kontext sehr gut unterscheiden. Wenn die Ressource getrennt wird, wird sie automatisch freigegeben und recycelt, wodurch das Programm optimiert werden kann. 🎜🎜Der MySQL-Treiber kann cymysql oder pymysql verwenden. Wenn Sie sich nicht sicher sind, wie Sie den Treiber verwenden, verwenden Sie ein Plug-in mit einer großen Anzahl von Statistiknummern beliebt. Das ist die Lösung. Es wird noch ein bisschen mehr geben. 🎜🎜Im Modul definierte Methoden🎜🎜model kann Modelle, Konstanten und atomare Methoden definieren, die die Datenbank direkt betreiben, und Sie können auch die Form von db.session zum Lesen von Daten verwenden. 🎜rrreee🎜Verwendung im Routing🎜🎜Bei Verwendung im Routing müssen Sie das entsprechende Modellpaket in Modelle einführen. Nachfolgend finden Sie eine einfache Demo, mit der Benutzerinformationen mit der Falsk-Login-Komponente gespeichert werden können. 🎜rrreee🎜Übrigens, bevor Flask die Sitzung verwendet, müssen Sie SECRET_KEY in der Konfigurationsdatei konfigurieren. Andernfalls wird ein Fehler gemeldet. Passen Sie einfach den Schlüsselwert an. 🎜rrreee🎜SQLAlchemy implementiert MySQL-Codierung und Spaltentypen🎜🎜Nachdem SQLAlchemy grundlegende Vorgänge in MySQL implementiert hatte, stellte ich fest, dass der Standardwertsatz nicht wirksam wurde und die Zeichensatzcodierung ebenfalls auf den Standardcode latin1gesetzt war > , die Optimierung des Spaltentyps von MySQL, die Implementierung des MySQL-Verbindungspools und der Zugriff auf NoSQL-Datenbanken wie Mongo und Redis sind zu Themen geworden, die im nächsten Schritt untersucht werden müssen. 🎜🎜Standardwert- und Indexeinstellungen🎜🎜Die Erklärung im Python-Quellcodepaket ist sehr klar und enthält Beispiele. In Spalte ist es wie folgt festgelegt: 🎜rrreee🎜server_default Orm-Einstellungen Initialisieren Sie den Wert von Mysql. Es gibt an, ob es sich um einen eindeutigen Index handelt, wenn SQLAlchemy CURD-Operationen ausführt /code> Der Wert muss vom Typ Zeichenfolge sein. 🎜🎜index dient zum Festlegen des Index, nullable dient zum Festlegen, ob er leer ist, und comment dient zum Festlegen der Kommentarinformationen. 🎜🎜Kompatibel mit dem MySQL-Spaltentyp🎜🎜Aber es stellt sich uns die Frage: Wenn Sie den Typ tinyint verwenden möchten, wie stellen Sie den Zeichensatz ein? 🎜rrreee🎜Nehmen Sie die am häufigsten verwendeten int und varchar als Beispiel. Vor der Verwendung müssen Sie das entsprechende Paket importieren: 🎜rrreee🎜Es gibt drei Parameter im TINYINT-Typ: 🎜🎜display_width legt die Spaltentypbreite fest. tinyint wird angezeigt (1), ob die zweite vorzeichenlose Zahl ein positiver Wertebereich ist, ob die dritte Nullfüllung gefüllt ist, der Wert ein numerischer Typ ist, im Folgenden finden Sie die Anweisungen zur Verwendung des Quellcodes von TINYINT. 🎜rrreee🎜 Lassen Sie mich den String-Typ kurz mit varchar als Code vorstellen. Der String-Typ muss die String-Länge explizit deklarieren, was durch die Länge implementiert wird. Wenn der Wert von length nicht hinzugefügt wird, tritt bei der Initialisierung ein Fehler auf. 🎜

自定义数据库名和字符集编码

__tablename__设置的是自定义数据表名，底下的设置的是数据表字符集编码，要使用utf8mb4编码和utf8mb4_general_ci编码，这里就不做过多的解释了。

__tablename__ = 'wm_user_user'
# ...
__table_args__ = {
    'mysql_charset': 'utf8mb4',
    'mysql_collate': 'utf8mb4_general_ci'
}

Das obige ist der detaillierte Inhalt vonSo schreiben Sie Python-Anwendungen mit Flask Blueprint und SQLAlchemy. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!