Curso de Flask

Curso de Flask

Bernardo Cassina

Bernardo Cassina

Hello World Flask

5/36
Recursos

Estos son los conceptos principales que debes entender antes de hacer un Hello World en Flask:

  • virtualenv: es una herramienta para crear entornos aislados de Python.

  • pip: es el instalador de paquetes para Python.

  • requirements.txt: es el archivo en donde se colocará todas las dependencias a instalar en nuestra aplicación.

  • FLASK_APP: es la variable para identificar el archivo donde se encuentra la aplicación.

Aportes 122

Preguntas 24

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Si estás en Windows, la ruta para activar el venv es

venv\scripts\activate

Y para declarar la variable FLASK_APP (en Windows):

set FLASK_APP=main.py

para sacar lo que hay en el virtualenv y agregarlo en el requirements tambien podemos usar esta linea:

pip freeze >> requirements.txt

Crear el Entorno Virtual en windows:

Para crear un nuevo virtualenv, necesitas abrir una terminal command prompt y ejecutar

python3 -m venv myvenv

Se verá así:

C:\Users\Name\platzi-flask> python3 -m venv myvenv

Donde myvenv es el nombre de tu virtualenv.

Puedes utilizar cualquier otro nombre, pero asegúrate de usar minúsculas y no usar espacios, acentos o caracteres especiales. También es una buena idea mantener el nombre corto. ¡Vas utilizarlo muchas vecesl!

Inicia el entorno virtual ejecutando:

C:\Users\Name\platzi-flask> myvenv\Scripts\activate

Fuente de texto: https://tutorial.djangogirls.org/es/django_installation/

En windows no usen export, usen set
set FLASK_APP=main.py

<h1>Alto aquí!</h1>

Para que no tengas problemas en videos posteriores instala la version de flask del profe. Aquí te dejo el requirements.txt

flask==1.0.2
click==7.0
jinja2==2.10
itsdangerous==1.1.0
markupsafe==1.1.1
werkzeug==0.14.1
flask-bootstrap==3.3.7.1
flask-wtf==0.14.2

Si ya creaste tu venv inicia uno nuevo en un nuevo directorio y ejecuta el requirements que te deje arriba.

Excelente si estas en windows lee esto:
Para activar el ambiente es:
venv\Scripts\actvate

para exportar la app es

set FLASK_APP=main.py

y revisa la documentación aquí
https://flask.palletsprojects.com/en/1.1.x/cli/

Sigamos aprendiendo 😎

Yo, por mi parte, evité crear la variable ejecutando el siguiente código, utilizando la variable instanciada app para ejecutar el método run e indicarle un número de puerto:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World Flask'

if __name__ == "__main__":
    app.run(port=8080)

La asignacion del la variable de entorno FLASK_APP se puede hacer de las siguientes formas en Windows:
Usando CMD

> set FLASK_APP=hello
> flask run

Usando Powershell

> $env:FLASK_APP = "hello"
> flask run

Taken from here

Para crear un entorno virtual con Python 3 también se puede de la siguiente manera:

python3 -m venv <nombre-del-entorno>
pip freeze

para ver las dependencias del proyecto

export FLASK_APP=main.py

es necesario declarar una variable de ambiente para que flask conozca donde está la instancia de flask y así poder correr flask run

Para crear un archivo .txt desde windows (CMD) usamos en comando “copy con” en lugar de “touch”.

Hola, el comando export FLASK_APP=main.py hace lo mismo que incluir if __name__ == '__main__': app.run() en el archivo del código? a mi me funciono e las dos formas.

en el cdm.exe de windows
py -3 -m venv venv
venv\Scripts\activate

tuve muchos problemas para lograrlo , pero alfin , alfiiiin

virtualenv venv --python=python3.7

Algunas veces es necesario instalar versiones anteriores. Para eso se debe especificar la versión de la dependencia a instalar:::

  • Instalación con requirement.txt:
  1. Creamos un archivo de texto:$touch requirements.txt

  2. Cargamos nuestras dependencias a instalar:
    flask==1.0.2 django==2.1.7 sqlalchemy -U #Para ultima versión es con -U

  3. Ejecutamos pip install:
    $pip install –r requirements.txt

Para los que no pudieron declarar la variable FLASK_APP, el equivalente de ‘export’ en windows es ‘set’ 👋

Hace poquito acaba de salir una herramienta llamada Pipenv, es una herramienta que une virtualenv y pip, me gustó tanto la facilidad de uso y las características extras que escribí un tutorial, se los comparto en caso de que a alguien le sirva: tutorial de pipenv

A mi me funciono lo siguiente en Windows:

  1. py -3 -m venv venv
  2. venv\Scripts\activate
  3. pip install Flask

Ceen un botón para poder resetear el inicio de un video ya visualizado. Si quiero repasar un curso todos se visualizan solo 1 seg ya que empiezan por el final. ¬¬!

Resumen de esta clase

En esta clase se crearon los directorios necesarios para poder instalar Flask y asi correr el primer Hello World desde Flask.

  1. Crear directorio “platzi-flask”
  2. Crear entorno virtual con python3 -m venv venv
  3. Activar entorno virtual con source env/bin/activate
  4. Para desactivar entorno virtual se escribe deactivate
  5. Instalar flask con pip install flask
  6. Para ver dependencias instaladas en el entorno virtual con pip freeze
  7. Crear el archivo touch requirements.txt para instalar las dependencias de forma más facil con el comando pip install -r requirements.txt
  8. Crear el archivo main.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World Flask'
  1. Exportar la variable con export FLASK_APP=main.py y para comprobar que se creo con echo $FLASK_APP main.py
  2. Correr nuevo servidor con flask run


Por si alguien esta usando ubuntu o la terminal de ubuntu con WSL2

para los de sistema operativo linux, desde una consola en la carpeta que vas a desarrollar su proyecto puedes usar los siguientes comando

python3 -m venv env

para activar el entorno virtual en sistemas operativos linux

source env/bin/activate

Recomendación:

Siempre que se quiera instalar una dependencia con el manejador de paquetes PIP, se debe actualizar la versión, para que así, de igual forma instale las dependencias con sus ultimas versiones:

  1. Activamos nuestro entorno virtual
    Par windows:
venv\Scripts\activate
  1. Porcedemos a actualizar PIP
py -m pip install pip --upgrade

Y listo, ya puedes instalar todas tus dependencias.

Para un ambiente virtual de desarrollo en sistema operativo Windows, realizar los siguientes pasos:

1.- Crear un directorio o carpeta donde se va a desarrollar el proyecto.

2.- Ingresar por el CMD y ubicar dicho directorio o carpeta , una vez que nos ubiquemos ingresaremos el siguiente comando : python -m venv env1

3.- Mediante el comando DIR podremos ver que se creo simultáneamente una carpeta con el nombre env1, la cual tiene dentro un bagaje de archivos.

4.- Ingresar a la carpeta Scripts e ingresar en la linea de comandos activate.bat para activar el ambiente de desarrollo.

5.- Para salir del mismo ingresar activate.bat.

Puff, esta clase fue brutal. Aprendi a usar VirtualEnv, a trabajar dentro del entorno virtual, a declarar un requiments.txt y a instalar paquetes desde el mismo requirements.txt. Muy muy PRO.

Despues de tres dias con errores finalmente tuve que instalar otras dependencias adicionales para que python3.7(el main es 3.8) funcionara

sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev libffi-dev libbz2-dev

creas tu directoria de tu proyecto

mkdir flask

cd flask

crear un ambiente virtual

virtualenv venv --python=python3

source venv/bin/activate

instalar flask

pip install flask

pip freeze

cremos nuestro archivo de dependencias

touch requirements.txt

cada que quieras actualizar o instalar las dependencias que están ahí en deberas correr el siguiente comando

pip install -r requirements.txt

creamos un archivo llamado main .py con el síguete código

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello world Flack'

creamos una variable de ambiente llamada FLASK_APP

export FLASK_APP=main.py
echo $FLASK_APP

y entonces corremos el server con

flask run

Pueden crear el archivo “requirements.txt” y al mismo tiempo meter allí la lista de dependencias introduciendo el siguiente comando en terminal:

pip freeze > requirements.txt

Y si les tocara alguna vez instalar en su virtual enviroment los requirements para colaborar en un proyecto que necesita dependencias de pip, usan el siguiente comando:

pip install -r requirements.txt

En mi caso, usando Windows 10 y PowerShell 7 me funciono lo siguiente:

  • Crear el directorio
<code> 
  • Acceder al Directorio
cd platzi-flask
  • Crear el Virtual Enviroment
py -3 -m venv myenv
  • Activar el Virtual Enviroment (VE)
.\myenv\Scripts\Activate.ps1
  • Activar el VE (es importante el punto y el diagonal en la ruta)
.\myenv\Scripts\Activate.ps1
  • Actualizar el pip dentro del VE
python -m pip install --upgrade pip
  • Instalar flask
python -m pip install flask
  • Verificar paquetes instalados
pip freeze
  • Crear variable del VE para saber cual es el archivo de arranque
$env:FLASK_APP = "main.py"
  • Correr el servidor Flask
python -m flask run

Quería saber como crear un entorno virtual con una versión especifica de Python en Windows y la respuesta es:

<
py -'version de python' -m venv 'nombre entorno virtual'
>
Ejemplo:
<
py -3.7 -m venv venv
> 

…Para el que le pueda interesar.

Por si a alguien mas le pasa…
Hice todo lo que decian en la clase pero al abrir el browser la pagina siempre se mostraba cargando.
Para poder hacer el hello world tuve que abrir un nuevo puerto, aca esta el tutorial de como hacerlo: https://windowsreport.com/open-firewall-ports/

En el paso 5 seleccione TCP y Specific local port:5000. Me funciono bien y pude resolver el problema. Uso windows 10 y WSL.

Al fin he llegado a este curso, que emoción aprender Flask 😃

no puedo acceder a la IP:3000 desde otro dispositivo…

Alguien ya lo puso abajo pero se esta perdiendo y asi se evita que alguien se quede trabado;
en windows para ejecutar el entorno virtual es:
venv\Scripts\activate

para activar el ambiente virtual en windows

> cd venv/scripts
> activate

A los que quieran el IDE del profesor (PyCharm), pueden tener una licencia de un año gratis si tienen un correo de estudiante @*.edu, y se crean una cuenta en JetBrains https://www.jetbrains.com/shop/eform/students

En windows para activar el entorno la ruta es :
vnv\Scripts\activate

Por si sirve de ayuda

#Lista los elementos de nuestro entorno virtual
pip list

#Crear archivo con instrucciones para instalar los requisitos de nuestro entorno virtual
pip3 freeze > requirements.txt

Estoy teniendo el siguiente problema, no me deja crear el entorno con pytohn3.7 alguien sabe qué puede ser?

Vengo del futuro 2022/05 vamos a ver si no hay problemas, estas son las versiones que se instalaron:

click==8.1.3
Flask==2.1.2
importlib-metadata==4.11.3
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.1
Werkzeug==2.1.2
zipp==3.8.0

😬 Si salen problemas en videos posteriores ire dejando los comentarios, de solución… (Si es que hay 😂)

Mago!!!

Si colocas al final del codigo

if name == “main”:
app.run(port=8080)

Podrás correr el servidor tranquilamente 😃, esto lo vi en un aporte y quería colocarlo aquí arriba para que cualquiera lo pudiera leer 😃

Para crear el entorno virtual en windows

python -m venv python=python3.7

A las personas que tengan instalado otra versión de Python (En mi caso python3.8) y les arroje este error al crear el entorno virtual:

$ virtualenv venv --python=python3.7

$ RuntimeError: failed to find interpreter for Builtin discover of python_spec=‘python3.7’

De este error entendí que no se ha encontrado el intérprete de Python3.7, pero puedes descargar el código fuente y compilarlo para poder obtener el intérprete de la versión que quieras usar para tus proyectos:

Descargas:

Todas las versiones de Python disponibles

La versión que descargué para el curso

En internet encontrarán formas de compilar para su Sistema Operativo y luego podrán crear su entorno virtual con el mismo comando que el profesor:

$ virtualenv venv --python=python3.7

$ created virtual environment CPython3.7.13.final.0-64 in 248ms ...

Aquí un tutorial para compilar el código fuente de Python en Ubuntu 20.04 😃

ya me siento poderoso :v

En la linea

from flask import Flask

me sale error. Me sudeció lo mismo en todos los imports cuando usaba Django. Siempre sucede el error cuando esta activado el virtualenv (aunque el codigo esté bien y el servidor corra sin problema).

Esto no afecta al rendimiento de la app pero es molesto ver errores. Alguien sabe como solucionarlo?

For bash do this:

set FLASK_APP=<app_name>

For powershell do this:

$env FLASK_APP=<app_name>

Run it like this

flask run

para windows pueden usar

$env:FLASK_APP = "main.py"

Para los que estan comenzando el curso en el 2022 aca les dejo como me salen las versiones con pip freeze

Con virtualenv venv --python=python2.7 se instala la versión de Python 2.7 dentro de ese entorno virtual?

O recién está instalando python?

para los de sistemas operativos linux, puedes crear el archivo requeriments.txt con el siguiente comando

pip freeze > requirements.txt

En los Cursos de Facundo se suele crear así en Windows:

py -m venv venv

Y se Activa así

.\venv\Scripts\activate

Luego se instalan las librerías.

Para abrir el proyecto en VSCODE se escribe:
code .

Para la creación de la variable de entorno en windows se hace uso del siguiente comando dentro de la terminal o consola

$env:FLASK_APP="main.py"

donde ‘main’ es el nombre del archivo principal del proyecto.
Luego de tener la variable creada se puede ejecutar el programa con:

flask run

La opción “-r” de pip no significa “recursivamente” como explica Bernardo.
Significa que a continuación se va a facilitar un “requirements file”, en este caso requirements.txt

Instalandolo hoy las dependencias fueron muchisimas mas

Si estas en ubuntu u otro sistema linux

python3 -m venv venv

Si tiene problemas con el venv aquí un video super dimple de como solucionarlo

Si no encuentra virtualenv, me funciono esto

pip uninstall virtualenv

y luego

sudo pip install virtualenv

Para activar el venv en windows aveces tendrán que poner despues del activate un .bat:
venv\scripts\activate.bat

Si tienes Mac o Linux para activar entorno virtual:

. nombre_de_tu_entorno/bin/activate

a mi me funcionò este comando para windows

py 3.7 -m venv venv

Si estas en linux o mac puedes agregar la siguiente linea al final del archivo .bashrc o .zshrc (dependiendo de cual uses) para crear un alias y que el comando para activar el entorno virtual sea mas sencillo.

alias avenv=‘source venv/bin/activate’

En windows lo hice con venv de la siguiente manera:

py -3.7 -m venv flask

Si no quieres crear una variable de entorno para correr el server, puedes crear un archivo “.env” y dentro poner la variable que necesitas

.env

FLASK_APP=main.py

En esta clase, el profesor Facundo explica cómo crear un entorno virtual 😄

Hola este aporte es para que a otro no le pase, uso Powershell y cuando declare la variable FLASK_APP lo hice así:

$flaskenv:FLASK_APP='main.py'

mi error fue pensar que tenia que poner el nombre del ambiente virtual que creee el cual fue flaskenv y no solo era así:

$env:FLASK_APP='main.py'

Saludos.

Para extraer todas las dependencias que se instalaron en nuestro entorno virtual y agregarlo a un archivo txt:

pip freeze > requeriments.txt

venv\scripts\activate no sirve

En windows como se activa? el comando “source” me sale como erroneo

Hola Comunidad.
.
Muchos compañeros están publicando la forma en cómo se debe ‘setear’ la variable de ambiente FLASK_APP antes de correr el servidor (Gracias). Indican que se debe hacer de la siguiente manera:
.

(myenv) PS C:\tu_ruta\python\flask> set FLASK_APP=main.py

.
He podido verificar y esto es correcto si utilizas cmd.exe, sin embargo si estás usando PowerShell, la forma respectiva de crear esta variable es:
.

(myenv) PS C:\tu_ruta\python\flask> $env:FLASK_APP='main.py'

.
Con esto ya deberíamos poder correr el servidor y recibir algo similar a esto:

(myenv) PS C:\xampp\python\flask> flask run
 * Serving Flask app "main.py"
 * Environment: production
   WARNING: This is a development server. 
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

.
Adicionalmente pueden ver estas configuraciones según su SO ingresando a la documentación de Flask.
.
Espero les sirva.
.
¡Saludos!

Para quienes quieren hacerlo con docker aquí les dejo recurso para revisar.

hola cuando le doy flask run me cambia a un entorno virtual de flask (que prometo no haberlo creado), y no corre mi app, me podrían ayudar?

A mi me arroga un error como este
RuntimeError: failed to find interpreter for Builtin discover of python_spec=‘python3.7’

Al intentar correr el servidor me aparece este error. Pensé que ya tenia isntalado python. como instalo python en el entorno virtuaol?
(myenv) C:\Users\diego\platziflask>flask run No Python at '/usr/bin\python.exe'

Muy intuitivo

¿Soy yo o se parece mucho a Express.js? 😂

Que deberia hacer para instalar python 3.7?
Tengo el siguiente error
![](

archivo requeriments.txt para instalar todo con respecto a pip

archivo requeriments.txt para instalar todo con respecto a pip

Según el error me salió, mirando el debug dice que al main hay que nombrarlo como “app.py”, así se me solucionó

Hola, ¿cada vez que inicie el entorno virtual debo ejecutar ‘$ export FLASK_APP=main.py’?
Muchas gracias.

Como suugerencia recomiendo aprende a usar pipenv, es muy practico a la hora de hacer entornos virtuales y manejo de dependencias

hay otros que usan conda, pero personalmente prefiero usar pipenv

Para usar los mismos comandos del video, recomiendo usar git for windows. Si desea trabajar con el shell de python desde git bash :

python -i
Para el archivo requirements.txt se puede usar "pip freeze > requirements.txt" y todo lo que tengamos instalado en el entorno virtual se escribe en ese archivo sin necesidad de hacerlo uno por uno.

Todo en orden!

Como aporte toda aplicación de Flask es una instancia WSGI de la clase Flask, cuando se escribe este codigo:

app = Flask(__name__)

Se declara esa instancia cuyo primer argumento es el nombre del modulo con la palabra reservada name

Así Flask conoce la ubicación de los templates o archivos estaticos que se usen en la app.

Excelente clase, gracias.

from flask import Flask 

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello world Flask!'

Uso una consola de ubuntu en mi máquina local y las variables de entorno no persisten cuando la cierro. Para que ocurra lo contrario, puedes editar el archivo “.bash_profile”, que al igual que “.bashrc”, correrán cuando abras tu consola.
puedes correr los siguientes comandos para que tus variables de entorno persistan:

  1. vim ~/.bash_profile (te abrirá un editor de texto).
  2. oprimir la tecla i para que puedas insertar texto.
  3. export variable_name=value.
  4. oprimir esc+mayus+z+z. (para guardar los cambios en tu editor de texto)
  5. source ~/.bash_profile.

Hola, alguein prodía echarme una mano con el siguiente error?

The path python3.7 (from --python=python3.7) does not exist

I’ve got errors running python with flask, I couldn’t create the environment variable FLASK_APP, so I did this:
instead of running the server with flask run, I did it with python main.py, but in the file I had to add the next code:

if __name__ == "__main__":
	app.run()

Si no quieren escribir el comando para levantar el servidor local de flask pueden activarlo desde el código agregando este fragmento al final del archivo

if __name__ == "__main__":
    app.run()```

Si presenta problemas con el comando pip, ejecuten la siguiente linea

python -m pip install --upgrade pip

a mi no me servía
ni export FLASK_APP= main.py
ni set FLASK_APP= main.py
pero me sirvió esto:
$env:FLASK_APP = “main.py”

Si estas en Windows

  • Para crear tu venv:
py -3 -m venv venv
  • Para activarlo (desde el cmd en tu folder):
 venv\Scripts\activate
  • Información del venv desde la documentación de Flask:

Virtual environments

Use a virtual environment to manage the dependencies for your project, both in development and in production.

What problem does a virtual environment solve? The more Python projects you have, the more likely it is that you need to work with different versions of Python libraries, or even Python itself. Newer versions of libraries for one project can break compatibility in another project.

Virtual environments are independent groups of Python libraries, one for each project. Packages installed for one project will not affect other projects or the operating system’s packages.

Python 3 comes bundled with the venv module to create virtual environments. If you’re using a modern version of Python, you can continue on to the next section.

If you’re using Python 2, see Install virtualenv first.

PARA MÁS INFORMACIÓN VISITA LA DOCUMENTACIÓN OFICIAL.

El comando Source de donde sale?