Intro to Fullstack Flask

Intro

Building your first Flask Application

How to Install Flask and Python 3 With Virtual Environments

Building an stock quote application that uses an external API

How to Fetch Data From a REST API With Python and Flask

Deploying our Stock Quote application using Heroku

Deploy a Flask App with the Heroku CLI and a Procfile

Building Your First Flask Page Template With Jinja2 and Variables

Styling Flask Jinja2 Templates With Bootstrap, CSS, and IF Logic

Summary

Rendering Pages

An Intro to Building Modular Flask Applications With Blueprints

How to Add Blueprints and Routing to Flask

Growing our application with Blueprints

How to Build Scalable Apps With a Flask Application Factory

Application Factories & Configuration

How to Configure a Flask App for Unit Testing With PyTest

Getting to 100% Code Coverage With Flask Python Testing

Testing

Our Project: Yumroad

Set Up a Maintainable Flask Application in a Virtual Environment

Part II: Building Larger Flask Applications

Connect Databases to a Flask App With SQLAlchemy ORM

How to Query Data and Insert Database Rows With SQLAlchemy

Databases & ORMs

Combine Flask Blueprint Pages, Jinja Templates, and Databases

How to Test Flask Routes and Handle 404 Errors

Building pages using our models

Building HTML Forms and Validating Data in a Flask App

Build HTML Forms in a Flask App With Python and WTForms

Pre-populate a WTForms Form And Prevent CSRF Attacks

Handling Forms (with WTForms)

How to Add User Login and Authentication With Flask-Login

Flask-Login & Sessions

How to Log Out Users From a Flask App and Test Authentication

Logins

Database Relationships and Migrations in a Flask App

Using SQLAlchemy for relationships between models

Implementing Database Relationships in Flask With SQLAlchemy

Handle Database Migrations in Flask SQLAlchemy With Alembic

DB Relationships & Migrations

Send Email From Flask With Flask-Mail and Jinja Templates

Sending emails

Building a Payments UI in Flask

How to Integrate Stripe Checkout With Flask to Accept Payments

How to Add Unit Tests to a Flask Stripe Payments Integration

Payments

Organize Images, CSS, and JavaScript in Flask Asset Bundles

Assets

Part III: Deploying to Production

How to Debug Errors in a Flask App With Werkzeug and Sentry

Errors

How to Queue and Delay Python Jobs With RQ and Redis

Delayed Jobs

How to Improve Flask Performance With Flask Debug Toolbar

Improving Performance

How to Deploy a Flask App to Heroku With SSL and Redis Cache

Deployment

Yumroad To Ignite

Part IV: Ignite (SaaS Boilerplate)

Introducing Ignite

Ignite Demo

Getting Started with Ignite

Using Ignite

Appendix A: Installing Python on Windows, Mac, and Linux

Appendix B: Becoming a Flask Expert

Appendix C. Boilerplate Applications

Appendix

Changelog

Revision 1

In this course, we'll be creating ... whatever you want in markdown

In Fullstack Flask I will teach you how to use the full power and expressiveness of Python to build a fully functional income-generating web app from scratch using Flask.

Fullstack Flask: Build a Complete SaaS App with Flask

---
title: "How to Install Flask and Python 3 With Virtual Environments"
# description:
privateVideoUrl: https://fullstack.wistia.com/medias/sbr5wpxlpl
isPublicLesson: true
code: https://gitlab.com/fullstackio/books/newline-course-apps/sumukh-sridhara-fullstack-flask-app/-/tree/main/code/module_01/lesson_01.01/01-first-flask-app
---

# Getting started

### Installation

We'll need just a few things to get started with building Flask applications. Crucially we'll need Python 3, a terminal, and a text editor. Many systems come built in with Python 3. If you run into issues, Appendix A has some common issues and resolutions, including installation instructions for Windows.

:::tip

If you need a text editor, we use **[Visual Studio Code](https://code.visualstudio.com/)**. Like Flask it's free, and powerful out of the box but can be customized for power users.

:::

Let's start by creating a folder for our Flask projects. This is the folder where we will place each of the example applications we build throughout this book.

```bash
mkdir fullstack-flask
cd fullstack-flask
```

Then let's create a folder for our first Flask application.

```bash
mkdir 'first-flask-app'
cd 'first-flask-app'
```

Now that we have Python 3, we'll want to install Flask. Flask is packaged as a library that we can install using `pip`, a package manager for Python. Before we do that, we should set up an environment within our project folder where we can specify exactly which version of Python and libraries we would like to use. Python 3 comes built in with a tool to create "virtual environments" called `virtualenv`. What this will do is reference a version of Python and libraries installed within the specific project folder. Using `virtualenv` makes it easier to manage multiple projects that may have conflicting dependencies.

When we work without virtual environments and have multiple projects, we can quickly run into conflicts between versions of underlying libraries and Python versions.

![Projects will use the system default version of Python and libraries](https://d2uusema5elisf.cloudfront.net/courses/fullstack-flask-course/module_01/lesson_01.01/public/images/01-intro/WithoutVirtualEnvs.png)

When we use virtual environments, we can isolate the version of Python and which version the project uses.

![Virtual environment allows specifying versions on a project level](https://d2uusema5elisf.cloudfront.net/courses/fullstack-flask-course/module_01/lesson_01.01/public/images/01-intro/WithVirtualEnvs.png)

In order to make virtual environments work, we need to "activate" each one before running our application so that our terminal session will use the correct version before each

Within the `first-flask-app` folder, we are going to want to create a folder for the virtual environment which we can call `env`. We'll only need to do this once. By running this command, we create a folder and set up a virtualenv tied to the version of Python we are using. The `-m venv` flag tells Python to run the built in `virtualenv` module.

```bash
python3 -m venv env
```

Now that the environment is configured, we'll need to make sure our terminal session uses `virtualenv`'s configuration for Python instead of the defaults. To do so, we run a script to activate the virtual environment.

```bash
source env/bin/activate
```

This will prefix your terminal prompt with `(env)` to let you know that it has been activated. Now we can install Flask.

    pip install flask

### Hello World: Dice

Our goal for this part is to have a page that loads in our browser that displays a random number every time we load the page.

In order to have a page that displays a random number, we're going to have write some logic that we can later tell Flask to serve to the browser. Let's start by writing a function that returns the result of a dice roll. We're going to need to create a file to write the function in; we can use the same file to run the Flask web server as well. We'll call this file `hello_world.py`.

Sumukh Sridhara

Let's go ahead and build our first Flask app.

The first step is to go into our terminal and create a folder for all of our

So in our terminal, I've created a folder here called Flask.

Now within I'm going to make a new folder for our first Flask app.

Now that I'm here, one thing I want to do is I want to verify that we have

So I can type this to open up an interpreter and now I can run Python.

For example, I can do 1+1 or I can say print tola and that works.

So that means we have Python 3 installed and it's all set up.

Now I want to open this folder in our text editor and to do that, I'm going to

And what that does is that opens VS code in our current folder.

So once I hit this, I can take into VS code here and within VS code, I can

So I'm going to call my file server dot py.

So here in server dot py, I can write Python code.

For example, I can say print hello and then when I go back to my terminal, I

Now if you remember in our slides, we went over a really simple function of how

Let's go ahead and paste that into our own terminal.

So here I have the code to generate random dice and I can verify that by going

our terminal and running Python 3-i server and this runs interactively so I

and so now it can call the roll dice function and then that'll give me a random

Alright, so we now have a functioning Python script.

Now our job is actually to install Flask and turn this into a web server.

To do that, we're actually going to go and set up a virtual environment first.

So the way we're going to set up a virtual environment is by running Python 3-m

is the name of the virtual and module and we're going to create one inside of a

Now that I've done this, you can see that there's now a folder in n and I can

And now I'm inside a virtual environment.

So if I run Python here, it'll point me to the right version of Python.

I can also run which Python to see which version of Python is pointing to me to

see it's pointing me to a version of Python that's within this folder.

Now that we have Python and a virtual environment all configured, we can

and to do that, we're going to use the Python package manager and run pip

Now what this does is it installs Flask and all of its dependencies so that we

And this means that we can now import Flask.

And once we have that and that works, we can do that within our code as well.

So here in our VS code editor, we're going to want to also import Flask.

Now we're going to have to define our application.

So the way we can do that is we can say Flask and we have to initialize it with

The standard is to initialize it with the name of the Python module that we're

And the way we can do that is by using this double underscore name method that

in VS in Python that gives us the name of the module.

And so what we want to do here is we don't just want to import Flask, we

And then we've created an application here.

And then the last line of code we're going to need is app.route.

And so this is telling Flask to route all requests to our web server at the

function and then just return whatever gets returned here.

Now let's go ahead and try and run that within our terminal.

In order to run that, we're going to have to specify a few things for Flask.

Namely that our Flask app is in server and that our Flask environment is in

But once we specify those two environment variables, we can actually just type

So we can go ahead and check Firefox here and refresh a page that's going to

And then once we see that, we see the dice rolled one.

And then if we continue to refresh the page, we see random numbers here.

We've just been up a Flask application in three additional lines of code.

In the next few videos, we're going to go over building something a little more