Django vs Flask vs FastAPI: Full Breakdown & Transcript

[00:00] which python web framework is the best

[00:02] flask is considered the most popular

[00:03] beginner framework django is the most

[00:05] popular full stack framework offering

[00:07] the most functionality and is used by

[00:09] many companies in production and fast

[00:12] api has only been around for three years

[00:14] but it took the hearts of the python

[00:15] developer community by storm

[00:17] facilitating rapid development and

[00:19] offering a tremendous web app speed when

[00:21] comparing google trends flask is on top

[00:24] closely followed by django but fast api

[00:26] is rising quickly based on github stars

[00:28] django is the winner but also closely

[00:30] followed by flask and fast api catching

[00:33] up quickly and in the speed benchmark

[00:35] test fast api is the clear winner

[00:37] outperforming the other frameworks by a

[00:39] factor of two or even three so which one

[00:41] should you use it's hard to give one

[00:43] clear recommendation because as always

[00:45] the answer depends each framework has

[00:47] its own strengths and weaknesses and all

[00:50] of them are great so in this video i

[00:52] created the same to-do app with all

[00:53] three frameworks in the process you

[00:56] learn how to use each framework and

[00:57] hopefully get a better feel for the

[00:59] trade-offs between each of these so in

[01:01] the end you can make the best choice for

[01:03] your next project the project we are

[01:05] going to build is a simple to do app

[01:07] providing functionality to add update

[01:10] and delete to-do's for each app you'll

[01:12] learn how to use a database use html

[01:14] templates and implement the api routes

[01:17] so let's get started let's start with

[01:19] flask flask is well established in the

[01:21] python community it is loved by

[01:22] beginners and experts for its simple

[01:25] syntax while still being capable of

[01:27] managing full-blown production-ready web

[01:29] apps so let's see how to do it first i

[01:31] recommend to create a virtual

[01:32] environment and then activate it then we

[01:34] need to install flask and also flask sql

[01:37] alchemy to work with a database then we

[01:39] create one file app.pi and import all

[01:42] classes and functions from flask that we

[01:44] need the convention is always to create

[01:46] an app instance with a double underscore

[01:48] name and then creating a route is as

[01:51] simple as defining a function and using

[01:53] the appropriate decorator here we say

[01:56] app.get and then a simple forward slash

[01:58] since this is our home page this would

[02:00] now display hello world on the website

[02:03] in order to use the database we import

[02:05] sql alchemy now we have to set some

[02:08] configuration variables for example the

[02:11] name or path to the database here we

[02:13] simply use a sqlite file and then we

[02:16] create a database instance by using sql

[02:19] alchemy and passing the app to it now we

[02:21] create a model for the database so we

[02:23] create a class to do that inherits from

[02:26] db.model and we give it three columns

[02:28] with the appropriate data type we want

[02:31] an id a title and a complete flag for

[02:34] the to-do item and then we call

[02:36] db.createall to create and initialize

[02:38] our database

[02:40] now of course we want to use this so in

[02:42] the home route we call

[02:44] db.session.query2do to retrieve all

[02:46] to-do items and then we use the render

[02:49] template function from flask with a

[02:51] template file name and the to-do list is

[02:53] additional arguments so that we can use

[02:55] it in the html code of course we need to

[02:58] create the template so we have to create

[03:00] a folder named templates and then a file

[03:02] that we call base.html

[03:04] and here we can use normal html code

[03:07] that displays a form and all to do items

[03:10] now what is special here are these curly

[03:12] braces with percent characters this is

[03:15] special ginger 2 template syntax that

[03:17] basically allows us some python-like

[03:19] logic for example we can have a for loop

[03:22] where we iterate over all to-do's and

[03:24] show the id and title for each to-do

[03:26] then we have an if-else statement to

[03:28] check the complete flag and show the

[03:30] label in a different style and then we

[03:32] also need closing statements for the if

[03:34] and also for the for loop we also create

[03:36] two links that are the buttons to update

[03:39] and delete a to do and the important

[03:41] part is that the ahref points to the

[03:43] update and delete route for this

[03:45] particular to-do id please note that

[03:48] these will be get requests which is not

[03:50] a best practice for updating and

[03:51] deleting data but it works and for

[03:53] simplicity i will use it like this now

[03:55] we go back to the app.pi and can

[03:57] implement the remaining routes first

[04:00] let's create a route to add a new item

[04:02] this has the

[04:03] app.postdecorator since it should be a

[04:06] post request we get the title

[04:08] wirerequest.form and then we create a

[04:10] new to-do item and call

[04:13] and db.session.add.com the changes as

[04:15] last step in here i use the redirect

[04:17] function together with the url4 function

[04:19] to redirect and load the updated home

[04:21] page the update route works similar here

[04:24] we query the particular to-do item with

[04:26] the id remember that we also specified

[04:29] the id in the html code then we update

[04:32] the complete flag commit the changes and

[04:34] again redirect to the home page and the

[04:36] delete route is the very same code

[04:38] except that here we delete the to-do and

[04:40] that's it 49 lines of code is all we

[04:42] need super simple and straightforward

[04:44] this is where flask really shines it

[04:46] won't be that quick with the other two

[04:48] frameworks now to run the app we can

[04:50] export the environment variables flask

[04:52] app equals app.pi and flask n equals

[04:56] development to get hot reloading and

[04:58] then we say flask run to start their

[05:00] development server and now we can add

[05:02] new to-do's update them and also delete

[05:04] them

[05:05] next let's use fast api it's one of the

[05:08] fastest python web frameworks out there

[05:10] right now it also provides an easy

[05:12] syntax allows for rapid development and

[05:14] offers some more nice to have features

[05:16] like automatic interactive documentation

[05:18] and type validation that's why

[05:20] developers love it and it's rising so

[05:22] fast in popularity that i think it will

[05:24] soon catch up with flask and django

[05:26] let's create a new virtual environment

[05:27] for this project then we need to install

[05:30] fast api we also need an asgi server for

[05:33] example uv corn and for the template

[05:36] files and database support we need

[05:38] python multipart sql alchemy and ginger

[05:41] 2. these are essentially the same

[05:43] dependencies as we get with the flask

[05:45] and flask sql installation here we

[05:47] create three files app.pi models.pi and

[05:50] database.pi we need a little bit more

[05:52] code for each compared to flask and we

[05:54] want to maintain a clean project

[05:56] structure the basic app will be very

[05:58] similar to before we import fast api

[06:01] create an app instance and create a

[06:03] function that we decorate with app.get

[06:05] here we return a dictionary which will

[06:08] be automatically converted to a json

[06:10] response one cool thing to mention here

[06:12] is that we could also declare the

[06:14] function as async dev since fast api

[06:16] supports asynchronous programming out of

[06:19] the box and allows for an extremely fast

[06:21] web app but for simplicity i'll stick

[06:23] with a normal function here fast api

[06:26] heavily relies on tie pins so if we want

[06:28] a dynamic route we use this syntax we

[06:31] put the argument in curly braces in the

[06:33] route and then we use the same name as

[06:36] function argument together with a type

[06:38] hint in this case it should be an

[06:39] integer this is concise reduces bugs and

[06:42] gives us automatic type checking which

[06:44] we will see later so let's continue with

[06:47] our to-do app we need a few more imports

[06:49] from fast api we also import a few

[06:52] requirements from starlet this is the

[06:54] asgi framework that fast api is built on

[06:57] top of then we specify our template

[07:00] directory and use a template response in

[07:02] the home function we pass the request as

[07:04] argument and also the database which is

[07:07] a session object that depends on another

[07:09] function don't worry about this syntax

[07:11] yet it will become clear in a moment but

[07:13] note that again for each argument we are

[07:15] using typins here and then again we

[07:17] query the database for all to do's and

[07:20] return a template response that needs

[07:22] the html file the request and the to-do

[07:24] list in this case the arguments for the

[07:27] template file are passed as dictionary

[07:29] now we also create a template directory

[07:31] and the base.html file and here we can

[07:34] use the exact same code as before since

[07:36] we are also using ginger 2 templating

[07:39] syntax now let's set up the database we

[07:41] get the imports and set up the path to

[07:43] the sqlite database then we need to

[07:45] create an engine we also need to create

[07:48] a session instance and lastly we declare

[07:50] the base class from which the model will

[07:52] inherit in the next step for the model

[07:54] we import the database and this base

[07:56] class we just declared and then we

[07:58] create a to-do class that looks very

[08:00] similar to the one from the flask app

[08:02] but now we inherit from base then we

[08:04] define a table name and use the same

[08:07] fields as before now we can go back to

[08:09] app.pi and make use of all of this we

[08:12] import the session class so we can use

[08:14] it as type hint we import the models the

[08:16] session local object and the engine then

[08:19] we create all database tables and then

[08:21] we create a helper function to access

[08:23] the data by session this will now be

[08:25] passed to the home function as a

[08:27] dependency which means if the database

[08:30] cannot be accessed then also the request

[08:32] to this route throws an error and this

[08:34] is already handled for us by fast api so

[08:37] you can see we need a little bit more

[08:39] code here but in return we get a lot

[08:41] more functionality already and a safer

[08:44] code now inside the function we can use

[08:47] the session object and query the

[08:48] database with the same syntax as in the

[08:50] flask app let's continue and add the add

[08:53] route which must be a post request

[08:56] as parameter we also use the request and

[08:58] the database and now as new argument we

[09:01] also put in the title which is a string

[09:04] that comes from the form and then again

[09:06] we create a new to-do added to the

[09:08] database and commit the change and then

[09:10] i get the url of the home page and

[09:12] return a redirect response i also

[09:14] specify a particular status code which

[09:17] is needed because we now change from a

[09:19] post route to a get route very similar

[09:21] we now add the update route and as

[09:23] mentioned before we use the to do id as

[09:26] dynamic argument with a tie hint then we

[09:28] query the to do change the complete flag

[09:31] commit the change and again redirect to

[09:33] the home page and finally we use the

[09:35] same code for the delete route but here

[09:37] we delete the to-do item and that's it

[09:39] we can now start a server by saying

[09:41] uvicorn app colon app the first is the

[09:44] file name and the second is the app

[09:46] instance we also use minus minus reload

[09:49] while we are in development mode and

[09:50] then we can go to this address and have

[09:52] a working to-do app one more cool

[09:54] feature we also get out of the box with

[09:57] fast api is automatic api documentation

[10:00] so we can go to the slash docs route and

[10:03] here we see all the different api

[10:05] endpoints together with the type for

[10:07] example we can click on the add post

[10:10] endpoint and then we see more details

[10:12] like that it needs a title as string we

[10:14] can also try this out enter a title and

[10:17] execute the command and then we can

[10:19] inspect the result so here we see we get

[10:21] the response code 200 so all is good and

[10:24] we see the raw template response that is

[10:26] visible on the page we could also try

[10:29] another route so let's test the update

[10:31] route this needs a to-do id as integer

[10:34] so if we try to send a string here then

[10:36] it wouldn't let us and on the page we

[10:38] would see an error code and again all of

[10:41] this is handled for us by fast api and

[10:44] this is possible because we used the tie

[10:46] pins all right and that's the to-do app

[10:48] with fast api i hope i could demonstrate

[10:50] some of the cool features here now for

[10:52] the final app we use django while flask

[10:54] and fast api are considered to be more

[10:57] like a micro framework change is a full

[10:59] stack framework with many batteries

[11:01] included it's the backend framework of

[11:03] choice for many fortune 500 companies

[11:05] while the learning curve might be

[11:06] steeper than with the others it offers

[11:09] so many features that it makes your life

[11:11] easier once you know your way around it

[11:13] again i start by creating and activating

[11:15] a virtual environment then we only need

[11:17] to say pip install django this comes

[11:19] with all the requirements that we need

[11:21] now we say changu admin start project

[11:24] and give it the name to do app this

[11:26] creates a new folder and inside the

[11:28] folder we have the manage.py file and

[11:31] another subfolder with the same name and

[11:33] all the starter files we need we cd into

[11:36] the first folder and can run python

[11:38] manage.pi run server this starts the

[11:41] server and we have the initial app up

[11:43] and running for now we quit the server

[11:45] again and say python manage.pi start app

[11:48] and the name to do list an app is a

[11:51] component inside a project that is

[11:53] responsible for certain things like here

[11:55] for managing the to-dos in this simple

[11:58] project this is the only app we need but

[12:00] imagine if we add authentication then we

[12:03] could put this in another app to keep

[12:05] the logic separate and clean after

[12:07] creating an app we also need to add the

[12:09] app name to the installed apps in the

[12:11] settings.py file now we want to add the

[12:14] views so inside to do list.views pi we

[12:18] add a function that gets a request and

[12:20] then we return the render function with

[12:22] a template name and this dictionary all

[12:24] items we want to pass the missing to-do

[12:27] part will be implemented in a moment for

[12:29] each view we need to register a url so

[12:32] we create a urls.pi file inside the

[12:35] to-do-list folder import the path

[12:37] function the views module and then we

[12:39] define all url patterns we want to add

[12:42] in this case we leave the route of the

[12:44] path empty since this is our home page

[12:47] and then we use the corresponding

[12:48] function and can also give it a name now

[12:50] we go to the to do app.urls.pi

[12:54] and use the include function to include

[12:56] all urls from the to do list app you can

[12:59] see that there already exists an admin

[13:01] path this is because django gives us an

[13:03] admin panel out of the box which we will

[13:05] see in a moment now we will need to

[13:07] create the template file so let's create

[13:09] a new templates folder in the top

[13:11] directory and then we again create the

[13:13] base html file and put in the same code

[13:16] django uses its own templating language

[13:19] which is similar but slightly different

[13:21] than the ginger 2 template but in this

[13:23] case we only have a for loop and an if

[13:26] statement and this is actually the very

[13:28] same syntax but there is one thing we

[13:30] need to change in the form part we need

[13:32] to add the csrf token this is a security

[13:36] mechanism that prevents attacks to the

[13:38] form but we don't need to do more than

[13:40] adding this here now we need to go back

[13:42] to the settings.py and add the templates

[13:45] folder to the directories key now we

[13:47] implement the model class so inside the

[13:49] to-do list models.py we create a class

[13:52] that inherits from models.model and then

[13:55] we again create the same fields with the

[13:57] correct data type and we also implement

[13:59] the string method to see an accurate

[14:01] description here we don't need to create

[14:03] an id since django does this for us now

[14:06] in the console we say python manage.pi

[14:09] make migrations followed by

[14:11] pythonmanage.pi migrate then we also

[14:14] create a super user because i want to

[14:16] show you the admin panel so we say

[14:18] python manage pi create super user we

[14:21] follow the instructions and put in a

[14:23] name and email and the password as next

[14:25] step we go to the admin.py and register

[14:28] the to-do model and now we go back to

[14:31] the views.pi import the to-do class and

[14:34] then query all to-do's in the index

[14:36] function let's run the server again and

[14:38] test this we see the home page with zero

[14:41] to-do's for now if we click on the add

[14:43] button we get an error since we haven't

[14:45] implemented this view yet but one cool

[14:47] feature that is already available is the

[14:49] admin panel so if we go to the slash

[14:52] admin route we can log in with the super

[14:54] user we created and here we can see

[14:57] different groups and users if we would

[14:59] add authentication we also see the to-do

[15:01] models with all the fields we specified

[15:04] and here we can interact with our

[15:06] database so we could add or modify the

[15:08] database entries right from the admin

[15:10] panel this is one very cool built-in

[15:13] feature that you don't get with the

[15:14] other frameworks so now let's log out

[15:17] again and implement the missing views so

[15:19] we import two more functions and then

[15:22] implement the add route we require that

[15:24] this should be a post method by using

[15:26] this decorator we could also check the

[15:29] type of the request inside the function

[15:31] but i wanted to show you this second way

[15:33] of doing it inside the function we then

[15:35] create and save a new to-do and redirect

[15:38] to the index page now we implement the

[15:40] update function this gets an additional

[15:43] parameter to do id which is then be used

[15:46] to query for this to do and then we

[15:48] change the complete flag and save it and

[15:50] again redirect the syntax for working

[15:52] with django models is slightly different

[15:55] than before but in my opinion it's even

[15:57] more simple and straightforward and the

[15:59] last view we need is the delete view

[16:01] which is very similar but here we delete

[16:03] the to do and now we only need to add

[16:05] all these views to the urls.py

[16:08] so in here we add all the paths with the

[16:10] corresponding route and view function we

[16:13] can use this syntax with a data type and

[16:16] parameter name to add dynamic views and

[16:18] that's it we can now go back to our app

[16:21] and we should be able to add new to-do's

[16:23] and then update and delete them awesome

[16:26] alright that's it you can find the code

[16:28] for all apps on github the link is in

[16:29] the description this video was a lot of

[16:31] work so if you enjoyed it please hit the

[16:33] like button i'm also interested to hear

[16:35] what's your favorite framework so please

[16:37] leave me a comment below and as always i

[16:39] hope to see you in the next video bye