Getting Started with the Flask Micro Web Framework

Flask is an extensible microframework, meaning it comes with a small set of core features needed to create a web application, supporting extensions to extend Flask when required. For example, Flask doesn’t have a database layer, making a database decision for you. Instead, if you need a database for your project, you can choose a database extension.

This lean, minimalist approach is well suited for smaller projects where a large “batteries included” framework like Django might be overkill. That said, developers have used Flask to build large projects, including LinkedIn and Pinterest.

Though a micro framework, Flask became the most popular Python web framework in 2016.

Glossary

Route – the act of binding a URL to a view function

View function – a function that’s invoked by the URL specified by the route. Flask places no limit on the number of routes you can define. You can have routes for /about, /contact, /services, and so on.

Static route – A route returning static content such as an HTML file..

Dynamic route – A route comprised of one or more variables that change the content returned. For example, a user profile route would serve dynamic content, depending on the unique id of each user (the variable in this case).

Before you start

Flask works with both Python 2.x or 3.x but its best to start using Python 3.x for new projects. If you haven’t installed Python yet, see this <installing Python> article, and learn how to create virtual environments on your operating system. Virtual environments enable you to have a space to install packages and make other changes without affecting anything else.

You’ll want to know some Python basics before learning Flask. This <introduction to Python> will help.

Set up a virtual environment project

For Mac and Linux, you can use the pip package manager:

$ sudo pip install virtualenv

On Ubuntu Linux, you’ll likely use apt-get

$ sudo apt-get install python-virtualenv

On Windows install easy_install. Once you’ve installed easy_install, the process is the same as the Mac though there’s no need for “sudo”.

$ pip install virtualenv

Start the virtual environment for your project. Name your project whatever you want.

$ mkdir flask_project1
$ cd flask_project1
$ virtualenv venv

In your projects directory, flask_project1 in this case, start a virtual environment.

$ . venv/bin/activate

On windows:

$ venv\scripts\activate

And to deactivate:

$ venv\scripts\deactivate

Install Flask

Now it’s time to install Flask and get going with your first Flask project.

$ pip install Flask

Create your Flask “Hello World” program

Create and open a file called hello.py using your favorite text editor.

#!/usr/bin/env python3
# the "shebang" at the top tells the script where to find python3

#import the Flask class
from flask import Flask

# Create an instance of the flask class by assigning it to a variable
app = Flask(__name__)
# Use a route decorator that tells flask that the URL should trigger this function.
# You can use different route decorators to trigger other functions.
@app.route('/')
# Define the hello_world function, which returns the string whenever the function's triggered
def hello_world():
    return 'Hello World!'

Export your app.

$ export FLASK_APP=hello.py

Then run the app with Flask!

$ flask run

Unless there’s an error (it’s easy to make typos in scripts), you’ll get output that looks something like this:

* Serving Flask app “hello”

* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Now, open a browser and enter http://127.0.0.1:5000/

Congratulations, you’ve written your first Flask script! You can learn more and build on that as much as you want.

Running scripts on your virtual server with a public IP address.

Your local Mac or Windows machine probably isn’t set up as a web server to the outside world. A good next step would be to recreate the Hello World script on your VPS. Follow the same instructions above on your virtual server with a public IP address.

Except when you run the script make the server available through your public IP address by setting host=0.0.0.0.

flask run --host=0.0.0.0

Debug and automatic restart

To do this import the DEBUG module, setting debug mode to 1 (meaning true in the true/false boolean logic). This makes modifying and debugging your programs much easier.

$ export FLASK_DEBUG=1
$ flask run

Now your script will run in debug mode, providing you more helpful information if something goes wrong, and when you change your program, it will automatically restart, executing your changes with little to no downtime for your application.

Try running your app confirming that it’s returning Hello World in a browser. Then open another terminal, edit hello.py replacing “Hello World!” with “Hello Flask!” or whatever you want. Save the file. Then refresh your browser. The browser should seamlessly return “Hello Flask!”

Next, let’s see how debug mode helps you identify errors. Open your script, then intentionally introducing a syntax error. Remove the “e” from route so that it’s @app.rout(‘/’)

Then run your script.

If you’ve ever been baffled by an error returned by a computer or a program, you’re in for a pleasant surprise. An error page loads with a calming color scheme, a descriptive error message, and the ability to click on and interact with the error page. The error page will prompt you for a pin, which you can find in the console output returned when you flask run. The error page does everything but fix the syntax error for you!

#!/usr/bin/env python3

from flask import Flask
sapp = Flask(__name__)

@app.route("/")
def index():
    return "Welcome home!"
@app.route("/names/<string:name>/")
def getNames(name):
    return ("Hi " + name)
if __name__ == "__main__":
    app.run()

Then run the modified program.

$ flask run

Now enter your first name after http://127.0.0.1:5000/names/

It should return Hi followed by your name!

You now know the basics of serving dynamic content with Flask, enabling you to create applications that serve personalized, interactive content that respond to user input.

Conclusion

This introduction was meant to show you how easy it is to get started using Flask and give you a glimpse of its potential. To create web apps with Flask, you’ll want to delve deeper with more in-depth tutorials and practice building your apps.

A good next step would be to explore Flask’s Github page, which includes links to documentation, tutorials, and other excellent resources.

You’ll also get a sense of how Flask works with other packages such as the Jinja template engine and the Werkzeug (Web Server Gateway Interface) WSGI utility library. The great thing about Flask is the core of it is small enough that you’ll be able to learn it relatively fast and get started creating web applications quickly.