Welcome to the first part of the Learning Flask series. In this part, you'll be creating a very basic web application, just so you can see how simple and basic a Flask application can be.
We're going to be creating a virtual environment and using it throughout this series. So let's get started.
Creating a project directory and virtual environment
First of all, we need to create our new project directory. We're going to a new directory called
app in our home directory.
Tip - I advise using the same names for your project so it's easier to follow along
Go ahead and create the directory with the following:
Next, let's move into the
Now we need create out Python virtual environment. Do so with the following command:
python -m venv env
This will create a new virtual environment called
You'll see a new directory appear inside the
app directory called
env. Now we need to activate our virtual environment before we install Flask.
Go ahead and run the following command to activate the environment:
You should see
(env) appear in front of your terminal prompt indicating the virtual environment is activated!
It's best practice to update pip (Python's package manager) after creating a new virtual environment. We can do so with the following:
pip install --upgrade pip
You should see a success message like the following
Collecting pip Using cached https://files.pythonhosted.org/packages/46/dc/7fd5df840efb3e56c8b4f768793a237ec4ee59891959d6a215d63f727023/pip-19.0.1-py2.py3-none-any.whl Installing collected packages: pip Found existing installation: pip 18.1 Uninstalling pip-18.1: Successfully uninstalled pip-18.1 Successfully installed pip-19.0.1
Now we're ready to install Flask!
You install Flask just as you would any other Python package.
pip install flask
If we now run
pip list, you'll see the following:
Package Version ------------ ------- Click 7.0 Flask 1.0.2 itsdangerous 1.1.0 Jinja2 2.10 MarkupSafe 1.1.0 pip 19.0.1 setuptools 40.6.2 Werkzeug 0.14.1
Note - Flask comes with several other packages so don't be alarmed when you see
Ok so we've got everything we need to start building our very simple application. Let's get to it.
Creating a Flask app
This guide is just to show you the most basic Flask application possible. You'll learn the correct way to structure a Flask application over the next couple of parts in this series.
The most basic Flask app can be just a single file. We're going to call it
app.py. Make sure you're in the
app directory and run the following to create it:
Let's write some code! Go ahead and open up
app.py in your favourite editor and follow along.
First of all, we need to import
from flask import Flask
Now we need to create our
Flask application. We're going to pass
Flask and assign it to the variable
Don't worry about exactly why we're doing this. We'll cover it in a more advanced episode in this series.
from flask import Flask app = Flask(__name__)
Next up, we need to create a route or view (route and view are used interchangeably)
Let's create a route and explain it line by line after:
from flask import Flask app = Flask(__name__) @app.route("/") def index(): return "Hello world!"
Let's talk through the 3 lines we just added:
Routes in Flask are created using the
@app.route decorator and passing in a URL or path.
In this example, we've passed
"/" into the
"/" is the root of the website or application.
This route will be triggered when someone goes to the root or index of our website, for example
def index(): return "Hello world!"
@app.route decorator, we simply write a standard Python function with a
Flask will return whatever we pass to the
return statement! In this case, just a short
"Hello world!" string.
We need to add 2 more lines of code before we can run our app. Add the following:
from flask import Flask app = Flask(__name__) @app.route("/") def index(): return "Hello world!" if __name__ == "__main__": app.run()
Let's take a look at what we added:
if __name__ == "__main__": app.run()
Again, I don't want you to worry too much about what's happening here. For now just know that
__name__ is a special variable used by the Python interpreter to understand if a file is the main program.
Just as we passed
__name__ into the
Flask() class, the special variable
__name__ is equal to
__main__. You'll learn more about this principle as you advance through the series.
Running the Flask app
Time to see the app in action! We can run our Flask app in a couple of ways.
In your terminal, make sure you're in the same directory as
app.py and run the following:
You'll see the following message in your terminal to let you know Flask is running:
* Serving Flask app "app" (lazy loading) * Environment: production WARNING: Do not use the development server in a production environment. Use a production WSGI server instead. * Debug mode: off * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) 127.0.0.1 - - [03/Feb/2019 14:35:04] "GET / HTTP/1.1" 200 - 127.0.0.1 - - [03/Feb/2019 14:35:04] "GET /favicon.ico HTTP/1.1" 404 -
Great, our app is running! Ignore any of the warning messages in your terminal and open up a new browser tab and head to the following URL:
You should see
Hello world! in your browser!
Head back over to your terminal and stop the app by hitting
Ctrl + c
So you've seen one way to run your Flask app but it's not recommended. There's a better way.
Flask environment variables
To make running our app even easier, we're going to set a couple of environment variables in our shell. Run the following commands and we'll talk through them after:
export FLASK_APP=app.py export FLASK_ENV=development
export FLASK_APP=app.py will set the
FLASK_APP variable to
export FLASK_ENV=development tells Flask we want to run our app in development mode
Warning - Never run a live Flask application in production using development mode
We're quite a way from deploying our app to the web but I want to drill it home early, just so you know. We'll cover the reasons why later in the series.
We can now run our app using the following simple command:
* Serving Flask app "app.py" (lazy loading) * Environment: development * Debug mode: on * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) * Restarting with stat * Debugger is active! * Debugger PIN: 201-167-879
You'll notice we don't get any of the warnings and that
Environment is set to
Head back to http://127.0.0.1:5000/ and you'll see the same
Hello world! message as before.
Ctrl + c in your terminal to stop the app when you're ready.
To deactivate your virtual environment, simply enter:
You now know how to create and run a very basic Flask application, along with some best practices for setting environment variables and using the
flask run command.
Next up, learning how to structure your Flask application properly!