Flask und Django sind die beiden führenden Python-Web-Frameworks und obwohl sie beide Entwicklern dabei helfen, Websites schnell zu erstellen, tun sie dies mit sehr unterschiedlichen Ansätzen. In diesem Artikel schauen wir uns an, was die einzelnen Frameworks tun, wie sie funktionieren und warum Entwickler sich für eines entscheiden. Um diese Unterschiede zu veranschaulichen, werden wir drei verschiedene Projekte von Grund auf entwickeln – die Hello World-App, die persönliche Website und ein To-Do-Projekt – damit Sie selbst sehen können, wie sie funktionieren, und die beste Entscheidung für Ihre Bedürfnisse treffen können.
Datenbankgesteuerte Websites haben bemerkenswert ähnliche Anforderungen: URL-Routing, Logik, Verbindung zu einer Datenbank, Rendern von HTML-Vorlagen, Benutzerauthentifizierung und so weiter. In den Anfängen des World Wide Web mussten Entwickler all diese Teile selbst erstellen, bevor sie überhaupt mit der Arbeit an der Website selbst begannen.
Bald entstanden Open-Source-Web-Frameworks, die es Entwicklergruppen ermöglichten, bei dieser Herausforderung zusammenzuarbeiten, Best Practices auszutauschen, Code zu überprüfen und im Allgemeinen nicht jedes Mal das Rad neu zu erfinden, wenn jemand eine neue Website erstellen wollte. Es gibt Web-Frameworks in allen wichtigen Programmiersprachen mit bemerkenswerten Beispielen, darunter Ruby on Rails, geschrieben in Ruby, Laravel, geschrieben in PHP, Spring, geschrieben in Java, und in Python die beiden Frameworks, die wir hier behandeln: Flask und Django.
Wenn Sie neu in der Programmierung sind, könnte es verwirrend sein, den Begriff Python „Framework“ vs. „Bibliothek“ zu hören. Beide beziehen sich auf Software, aber der Unterschied liegt in der Komplexität: Eine Bibliothek konzentriert sich auf ein bestimmtes Problem, während ein Framework eine größere Herausforderung angeht und dazu oft viele kleinere Bibliotheken einbezieht. Wie wir sehen werden, basieren sowohl Flask als auch Django auf einer ganzen Reihe von Python-Bibliotheken.
Wenn wir uns die GitHub-Stars ansehen, liegen Flask und Django relativ gleichauf, aber wir können das explosive Wachstum von FastAPI erkennen, das mittlerweile klar in den Top 3 der Python-Web-Frameworks etabliert ist.
Die Python-Entwicklerumfrage 2023 zeigt, dass Django im Jahr 2023 knapp vor Flask liegt, aber auch FastAPI gewinnt an Dynamik.
In der Stack Overflow-Umfrage 2023 unter Entwicklern aller Programmiersprachen liegt Flask leicht vorne, aber fast unmittelbar gefolgt von Django und FastAPI etwas dahinter.
Diese Vergleiche sind für Trends interessant anzusehen, berücksichtigen aber nicht viele Dinge. Nur weil ein Web-Framework beliebt ist, bedeutet das beispielsweise, dass es von echten Unternehmen und professionellen Entwicklern verwendet wird, oder ist es nur etwas, mit dem Anfänger gerne herumspielen?
Unabhängig von der Vergleichsmetrik ist klar, dass Flask und Django derzeit die beiden besten Python-Web-Frameworks sind.
Wenn Sie auf der Suche nach einem Job als Python-Webentwickler sind, ist Django die bessere Wahl. Auf großen Jobbörsen wie Indeed.com gibt es fast doppelt so viele Einträge für Django-Entwickler wie für Flask.
Diese Ungleichheit ist jedoch wahrscheinlich, weil Django eine viel spezifischere Wahl ist als Flask. Ein Startup oder ein Unternehmen kann fast alle seine Dienste nur auf Django ausführen, während Flask aufgrund seines geringen Platzbedarfs häufig zusammen mit anderen Technologien verwendet wird.
Der am besten umsetzbare Ansatz besteht darin, zuerst Python wirklich zu beherrschen und dann Webentwicklungskenntnisse mit entweder Django oder Flask (idealerweise beide!) hinzuzufügen.
Django hat die größere, besser organisierte Community von beiden. Es gibt über 1.800 Committer für die Django-Codebasis gegenüber rund 550 für Flask. Auf StackOverflow gibt es ca. 212.500 Django-Fragen im Vergleich zu ca. 31.500 Flask-Fragen.
Django veranstaltet auch jährliche Konferenzen in den Vereinigten Staaten, Europa und Australien. Flask hat kein vergleichbares Niveau an Konferenzen, obwohl es bei PyCon-Veranstaltungen aktive Diskussionen für beide Frameworks gibt.
Flask ist ein Mikro-Framework, das bewusst minimalistisch und flexibel gestaltet ist, was seinen Nutzen offensichtlich nicht einschränkt. Wie wir sehen werden, bringt diese Designentscheidung sowohl Stärken als auch Schwächen mit sich.
Flask begann 2010 als Aprilscherz von Armin Ronacher und wurde vom Sinatra Ruby-Framework inspiriert. FLask sollte einfach genug sein, um in eine einzige Python-Datei zu passen, und trotz seiner humorvollen Ursprünge gewann Flask aufgrund seiner Einfachheit und Flexibilität schnell an Popularität.
Flask selbst hat eine recht kleine Codebasis und stützt sich stark auf zwei große Abhängigkeiten: Werkzeug und Jinja, die beide ursprünglich von Armin Ronacher erstellt wurden.
Werkzeug ist ein WSGI-Toolkit (Web Server Gateway Interface), das die Kernfunktionalität für Flask bereitstellt. Es verarbeitet HTTP-Anfragen und -Antworten, ein URL-Routing-System, einen integrierten Entwicklungsserver, einen interaktiven Debugger, einen Test-Client und Middleware. Jinja ist eine Template-Engine zum Generieren dynamischer HTML-Dokumente, die über eine eigene Syntax für grundlegende Logik, Variablen, if/else-Schleifen, Template-Vererbung und mehr verfügt.
Obwohl Flask keine bestimmte Struktur angibt, wird es häufig in einem Model-View-Controller (MVC)-Muster verwendet, das in anderen Web-Frameworks wie Ruby on Rails üblich ist.
Die Mikro-Framework-Architektur von Flask bedeutet, dass es einige Aufgaben äußerst gut ausführt und für die Implementierung des Rests auf Bibliotheken von Drittanbietern (und den Entwickler) angewiesen ist. Dieser Ansatz eignet sich gut für kleinere Webanwendungen, die nicht den gesamten in Django integrierten Schnickschnack erfordern. Im anderen Extrem bevorzugen erfahrene Programmierer, die vollständige Kontrolle über ihre Anwendung benötigen, oft Flask, obwohl dies bedeutet, dass sie mehr Designentscheidungen treffen müssen, als sie es mit einem vollständigen Framework wie Django tun würden.
Django ist ein High-Level-Python-Webframework, das eine schnelle Entwicklung und ein klares, pragmatisches Design fördert. Es wurde in der Zeitung Lawrence Journal-World erstellt und 2005 öffentlich veröffentlicht. „High-Level“ bedeutet, dass Django so konzipiert ist, dass es den tatsächlichen Codierungsaufwand während des Webanwendungsprozesses minimiert, indem es für die meisten Anwendungsfälle integrierte „Batterien“ bereitstellt , einschließlich ORM (Object-Relational Mapper), URL-Routing, Vorlagen-Engine, Formularverarbeitung, Authentifizierungssystem, Admin-Schnittstelle und robusten Sicherheitsfunktionen. In Flask muss der Entwickler diese verschiedenen Funktionen auswählen und implementieren, aber in Django sind sie sofort enthalten.
Django wird von der gemeinnützigen Django Software Foundation verwaltet und verfügt über eine große und engagierte Community, die an neuen Versionen, umfangreicher Dokumentation, aktiven Online-Communitys und regelmäßigen, von der Community veranstalteten Konferenzen arbeitet.
Django folgt einer Variante der MVC-Architektur namens Model-View-Template (MVT)-Muster, die die Trennung von Belangen betont:
Eine vierte Komponente,URLs, ist ebenfalls enthalten und wird für die URL-Weiterleitung verwendet, indem sie eine Benutzeranfrage einer bestimmten Ansicht zuordnet, die dann eine Antwort generiert.
Python sollte bereits auf Ihrem Computer installiert sein, wir müssen also nur noch eine virtuelle Umgebung erstellen und Flask installieren.
# Windows $ python -m venv .venv $ .venv\Scripts\Activate.ps1 (.venv) $ python -m pip install flask # macOS/Linux $ python3 -m venv .venv $ source .venv/bin/activate (.venv) $ python -m pip install flask
Erstellen Sie mit Ihrem Texteditor eine neue Datei namens hello.py. Flask benötigt bekanntermaßen nur fünf Zeilen für eine Hello World-Webseite.
# app.py from flask import Flask app = Flask(__name__) @app.route("/") def hello_world(): return "Hello, World!
"
Dieser Code importiert die Flask-Klasse oben und erstellt in der nächsten Zeile eine Instanz namens app. Der Route()-Dekorator teilt Flask mit, welche URL die Funktion auslösen soll; hier wird auf die Homepage unter / gesetzt. Dann gibt die Funktion hello_world einen HTML-String zwischen Absatz
Tags mit unserer Nachricht.
Um den Code auszuführen, verwenden Sie den Befehl flask run.
(.venv) $ flask run * Debug mode: off WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:5000 Press CTRL+C to quit
Wenn Sie in Ihrem Webbrowser zu 127.0.0.1:5000 navigieren, ist die Meldung sichtbar. Flask verwendet standardmäßig Port 5000.
Das ist so einfach wie nur möglich und spiegelt sowohl die Wurzeln von Flask wider, als den Versuch, eine Webanwendung mit nur einer Datei zu erstellen, als auch ein Beispiel für die ihm innewohnende Flexibilität.
Die Django-Dokumente bieten keine ähnliche Schnellstartanleitung, aber wir können eine ähnliche Leistung mit nur ein paar weiteren Codezeilen erreichen. Tatsächlich ist dies unter erfahrenen Django-Entwicklern zu einer Art Spiel geworden, und es gibt ein ganzes Repo, django-microframework, das diesen Bemühungen gewidmet ist. Wir wählen Option 2, die nicht die prägnanteste ist, aber leichter zu verstehen ist als einige der anderen Ansätze.
Navigate to a new directory, perhaps called django on your Desktop, and create a virtual environment containing Django.
# Windows > cd onedrive\desktop\code > mkdir django > cd django > python -m venv .venv > .venv\Scripts\Activate.ps1 (.venv) > python -m pip install django # macOS % cd ~/desktop/code % mkdir django % cd django % python3 -m venv .venv % source .venv/bin/activate (.venv) % python3 -m pip install django
In your text editor create a hello_django.py file with the following code:
# hello_django.py from django.conf import settings from django.core.handlers.wsgi import WSGIHandler from django.core.management import execute_from_command_line from django.http import HttpResponse from django.urls import path settings.configure( ROOT_URLCONF=__name__, DEBUG=True, ) def hello_world(request): return HttpResponse("Hello, Django!") urlpatterns = [path("", hello_world)] application = WSGIHandler() if __name__ == "__main__": execute_from_command_line()
Django is designed for larger web application and typically relies on a global settings.py file for many configurations, however we can import what we need in a single file. The key points of reference are the hello_world function that returns the string, "Hello, Django!" and the urlpatterns defining our URL routes, namely at "", meaning the empty string, so the homepage.
Start up Django's built-in server using the runserver command
(.venv) > python hello_django.py runserver Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). July 17, 2024 - 13:48:54 Django version 5.0, using settings None Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.
Navigate to Django's standard port of 8000, http://127.0.0.1:8000/, to see the "Hello, Django!" message.
Django required tweleve lines of code rather than Flask's five, but both these examples are intended as quickstart guides; they are not how you structure a real-world Flask or Django app.
Now let's build a Personal Website with a home page and an about page. This will give a chance to introduce templates and repeat some of the patterns we saw around how routes are defined in Flask.
Update the app.py file as follows:
from flask import Flask, render_template app = Flask(__name__) @app.route('/') def home(): return render_template('home.html') @app.route('/about') def about(): return render_template('about.html') if __name__ == '__main__': app.run(debug=True)
Both the home and about View functions now return a template. We're also using the route() decorator again to define the URL path for each. We've also added debug=True at the bottom so that the development server runs now in debug mode.
The next step is creating our two templates. Flask will look for template files in a templates directory so create that now.
(.venv) $ mkdir templates
Within it add the two files with the following code:
Personal Website Welcome to My Website
About Me
About Me About Me
This is my personal website.
Home
Each file use the method url_for to define links based on the view function name.
Run the server again with flask run and navigate to the homepage:
Then click the "About Me" link.
This is a rudimentary example but you can start to see how templates and views interact in Flask. We still have only one main Python file powering the whole thing, but once we have many more pages and start to introduce logic, the single-file approach stops making sense and it's time to start organizing the Flask app in different ways. There are some common patterns used in the Flask community, however, it is ultimately up to the developer.
Django is designed for full-bodied web applications so building a Personal Website is a chance to see this in action. We'll start by creating a project, which is the central hub for our website, using the startproject command.
(.venv) $ django-admin startproject django_project .
We've named the project django_project here. Adding the period, ., means the new folder and files are installed in the current directory. If you don't have the period Django creates a new directory andthenadds the project folder and files there.
This is what your directory should look like now. The hello_django.py file remains and can either be left there or removed entirely: we will no longer use it. There is an entirely new django_project folder containing several files and a manage.py file used for running Django commands.
├── django_project │ ├── __init__.py │ ├── asgi.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── hello_django.py └── manage.py
We want to create an app now using thes startapp command which will be called pages. A single Django project typically has multiple apps for different functionality. If we added user registration that code should be in its own app, same for payments, and so on. This is a way to help developers reason better about their code.
(.venv) $ python manage.py startapp pages.
This command creates a pages directory with the following files:
└── pages ├── __init__.py ├── admin.py ├── apps.py ├── migrations │ └── __init__.py ├── models.py ├── tests.py └── views.py
Our first step is updating the django_project/settings.py file to tell Django about our new app. This is a global settings file for the entire project.
# django_project/settings.py INSTALLED_APPS = [ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.messages", "django.contrib.staticfiles", "pages", # new ]
Second, update the django_project/urls.py file. When a URL request comes in it will hit this file first and then be either processed or redirected to a specific app. In this case, we want to send requests to the pages app. To do this we'll import include and set a new path at "", meaning the homepage. Django defaults to including the URL configuration for the built-in admin, a powerful visual way to interact with your database.
# django_project/urls.py from django.contrib import admin from django.urls import path, include # new urlpatterns = [ path("admin/", admin.site.urls), path("", include("pages.urls")), # new ]
Within the pages app we need a view and a URLs file. Let's start with the view at pages/views.py.
# pages/views.py from django.shortcuts import render def home(request): return render(request, "home.html") def about(request): return render(request, "about.html")
In Django, views receive web requests and return web responses. The request parameter is an object containing metadata about the request from the user. We'll define two function-based views here, home and about, that use the shortcut function render to combine a template with an HttpResponse object sent back to the user. The two templates are home.html and about.html.
For the templates, we can create a templates directory within pages, then another directory with the app name, and finally our template files. This approach removes any concerns about confusing the Django template loader in larger projects.
(.venv) $ mkdir pages/templates (.venv) $ mkdir pages/templates/pages
Then in your text editor add two new files: pages/templates/pages/home.html and pages/templates/pages/about.html.
Personal Website Welcome to My Website
About Me
About Me About Me
This is my personal website.
Home
The final step is configuring the URLs for these two pages. To do this, create a urls.py file within the pages app with the following code.
# pages/urls.py from django.urls import path from . import views urlpatterns = [ path("", views.home, name="home"), path("about/", views.about, name="about"), ]
At the top we import our views and then set a URL path for each. The syntax is defining the URL path, the view name, and optionally adding a URL name that allows us to link to each path in our templates.
Start up the Django local server with the runserver command.
(.venv) $ python manage.py runserver
You can see the homepage:
Click the "About Me" to be redirected to the about page:
As you can see Django required more scaffolding than Flask, however this approach provides a consistent structure that is quite scaleable.
The true comparison of these web frameworks depends on your project's needs. Are you building a traditional web application that connects to a database, requires CRUD (Create-Read-Update-Delete) functionality, and user authentication? If yes, Django has built-in solutions for all of these needs. By comparison, Flask requires installing multiple third-party libraries: Flask-SQLAlchemy to connect to the database, Flask-Migrate to manage database migrations, Flask-WTF and WTForms for forms, Flask-Login for user authentication, FLask-Mail for email support, Flask-Security for security features, Flask-Admin for an admin interface to manage application data, Flask-Caching for caching support, Flask-BCrypt for password hashing and so on.
The power of Django is that you don't have to worry about any of these things. They are included, tested, and supported by the community. For Flask, the third-party libraries are not as tightly integrated and require more manual installation by the developer. This affords greater flexibility but also requires more programmer expertise.
Ultimately, you can't go wrong choosing Flask or Django for your web application needs. They both are mature, scaleable, and well-documented. This difference is in approach and the best way to determine what you prefer is to try each out by building more complex projects.
If you're interested in learning more about Django, check out Django for Beginners for a guide to building six progressively more complex web applications including testing and deployment. For Flask, the Flask Mega-Tutorial has a free online version. There are also two courses over at TestDriven.io worth recommending: TDD with Python, Flask and Docker and Authentication with Flask, React, and Docker. If you prefer video, there are many Flask courses on Udemy but the best video course I've seen is Build a SaaS App with Flask and Docker.
Das obige ist der detaillierte Inhalt vonFlask vs. Django in einem umfassenden Vergleich von Python-Web-Frameworks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Der Computer meldet, dass msvcr110.dll fehlt und wie man das Problem beheben kann
So verwenden Sie die Pip-Installation
Konvertieren Sie PDF-Dateien in CAD-Zeichnungen
Einführung in CLI-Befehle
Einführung in häufig verwendete Top-Level-Domain-Namen
wie man eine Website erstellt
Was bedeutet TS-Version?
Gründe, warum Computer oft Bluescreens haben
