Je viens de créer une application flask et jusqu'à présent, j'ai un routeur pour mon modèle "Hello world!".
Je voudrais ajouter un peu (beaucoup) de fonctionnalités supplémentaires, mais je me demande comment structurer le répertoire de l'application.
Quelle est la manière la plus courante de structurer une application Flask? Par exemple, dois-je créer un routes.py
pour tous mes itinéraires? Où va le truc SQLAlchemy? Les modèles doivent-ils être en models.py
?
Vous devriez consulter la page Applications plus grandes dans la section Modèles des documents Flask: http://flask.pocoo.org/docs/patterns/packages/ . Il semble que ce soit le modèle que la plupart des gens suivent lorsque leur application appelle un package au lieu d'un module.
Je crois views.py
est ce que vous appelez routes.py
. Après cela, les modèles iraient dans models.py
, les formulaires iraient dans forms.py
, etc.
Un exemple de répertoire FlaskApp:
yourapp/
/yourapp
/run.py
/config.py
/yourapp
/__init__.py
/views.py
/models.py
/static/
/main.css
/templates/
/base.html
/requirements.txt
/yourappenv
run.py
- contient le code python réel qui importera l'application et démarrera le serveur de développement).config.py
- stocke les configurations de votre application.__init__.py
- initialise votre application en créant une instance d'application Flask.views.py
- c'est là que routes
sont définis.models.py
- c'est ici que vous définissez les modèles pour votre application.static
- contient des fichiers statiques, c'est-à-dire CSS, Javascript, imagestemplates
- c'est ici que vous stockez vos html
modèles, c'est-à-dire index.html
, layout.html
requirements.txt
- c'est ici que vous stockez les dépendances de vos packages, vous pouvez utiliser pip
yourappenv
- votre environnement virtuel pour le développement
Je pense que flask est un micro framework et maintenant vous devez décider comment créer des fichiers et des dossiers.
j'utilise de cette façon:
c'est proche de la structure Django
je vous suggère de voir un projet pour vous donner ce que vous voulez
Je dirais que si vous divisez l'application, utilisez une structure divisionnaire plutôt que fonctionnelle. Je préconise cela parce que vous êtes plus susceptible de travailler sur l'un de ces composants divisionnaires à tout moment.
Ce type de structure se prête bien au marché ou aux applications SaaS où différents groupes d'utilisateurs utilisent un type de vue différent. API uniquement flask app Je pourrais utiliser le fractionnement fonctionnel) .
Voici des exemples tirés de Flask Blueprints. Les Blueprints sont essentiellement des conseils documentés sur la façon de diviser Flask application pour des pièces plus faciles à gérer. Plus d'informations à ce sujet sur: http : //exploreflask.com/en/latest/blueprints.html
Voici un exemple de division divisionnaire. Découvrez comment chaque fonctionnalité est regroupée.
yourapp/
__init__.py
admin/
__init__.py
views.py
static/
templates/
home/
__init__.py
views.py
static/
templates/
control_panel/
__init__.py
views.py
static/
templates/
models.py
Voici l'exemple fonctionnel>
yourapp/
__init__.py
static/
templates/
home/
control_panel/
admin/
views/
__init__.py
home.py
control_panel.py
admin.py
models.py
Vous pouvez vous inspirer des modèles de cuisine ici pour lancer le développement de votre application
Toute personne à la recherche d'une structure simple pour les débutants pour le projet flask peut trouver cela utile:
|__movies
|__run.py
|__app
├── templates
│ └── index.html
│ └── signup.html
└── __init__.py
└── routes.py
Ici ' films ' est le nom donné à l'application principale. Il contient ' run.py ' et un dossier appelé ' app ' . Le dossier ' app ' contient tous les fichiers nécessaires flask tels que les modèles ' 'dossier' __ init __. py 'et' routes.py ".
Contenu de:
run.py:
from app import app
__ init.py __:
from flask import Flask
app = Flask(__name__)
from app import routes
app.run(debug=True)
routes.py:
from app import app
@app.route('/')
@app.route('/index')
def index():
return "Hello, World!"
La beauté de flask réside dans sa flexibilité. Vous pouvez facilement construire Django comme la structure d'un projet. Django abstraction vulgarisée de fonctionnalités) dans les applications et les rendre réutilisables, mais cela peut être une exagération pour de nombreux projets.
Mais avec flask vous pouvez aller dans les deux sens. Écrivez des applications réutilisables ou écrivez des applications simples. Vérifiez ces squelettes de cuisine -
myproject ├── config.py ├── instance │ └── config.py ├── myproject │ ├── commands.py │ ├── controllers.py │ ├── extensions.py │ ├── forms.py │ ├── __init__.py │ ├── models.py │ ├── routes.py │ └── ui │ ├── static │ │ ├── css │ │ │ └── styles.css │ │ └── js │ │ └── custom.js │ └── templates │ └── index.html ├── README.md ├── requirements.txt └── wsgi.py
myproject ├── config.py ├── development.py ├── instance │ └── config.py ├── myproject │ ├── auth │ │ ├── controllers.py │ │ ├── forms.py │ │ ├── __init__.py │ │ ├── models.py │ │ └── routes.py │ ├── helpers │ │ ├── controllers.py │ │ ├── __init__.py │ │ └── models.py │ ├── __init__.py │ └── ui │ └── templates │ ├── 404.html │ ├── 500.html │ └── base.html ├── README.md ├── requirements.txt ├── tests │ ├── auth │ │ ├── __init__.py │ │ └── test_controllers.py │ └── __init__.py └── wsgi.py
C'est un excellent article à ce sujet.