Alto Código

Curso de django

2024-04-14T21:56:00.001+02:00

Este es un índice de los diferentes apartados del curso.

Django Shell

2024-04-11T18:21:00.005+02:00

Veamos lo que se puede hacer desde la Shell de Python para crear datos en la base de datos, consultarlos y manejarlos. Esto nos dará idea de cómo luego lo haremos desde django.

python manage.py shell
>>> from myapp.models import Project, Task
>>> p = Project(name="aplicacion movil")
>>> p
<Project: Project object (None)>
>>> p.save()  # guardamos en la base de datos el nuevo dato
>>>

Hemos accedido al shell de Python usando python manage.py shell

Hemos importado las dos clases que previamente habíamos creado. Para hacer la importación escribimos from myapp.models import Project, Task

Creamos nuestro primer dato en la tabla Project y en el campo name. El datos es "aplicacion movil" y una vez creado se lo asignamos a una variable que hemos llamado, por ejemplo, p, así:

p = Project(name="aplicacion movil")

Si imprimimos p no da error y nos muestra lo siguiente:

<Project: Project object (None)>

Usando p.save() lo que hacemos es grabar el dato en la base de datos.

Podemos actualizar con F5 la aplicación DB Browser for SQLite y así veremos que se ha creado el nuevo campo de Id 1 cuyo campo name es "aplicacion movil".

Vamos a crear ahora un segundo campo.

>>> p = Project(name="aplicacion web usando Django")
>>> p.save()

Actualizamos con F5 para ver el nuevo campo.

Django database models

2024-04-07T10:00:00.007+02:00

La base de datos incluida por defecto en django es db.sqlite3.

Al lanzar el servidor es habitual ver un mensaje similar a este "You have 18 unapplied migration(s)".

Las migraciones son una forma de actualizar nuestra base de datos desde código Python.
Desde código Python interaccionaremos con la base de datos creando las tablas, las relaciones, los usuarios, ...

Las migraciones nos permiten ahorrar trabajo ya que nos ayudan a crear las tablas y relaciones de la base de datos.

DB Browser for SWLite

Descargar este programa.

Está disponible para varios sistemas operativos, incluso para macOS (Apple Silicon).

Para actualizar la base de datos, detenemos el servidor y ejecutamos el comando:

python manage.py makemigrations
python manage.py migrate

Observamos la estructura que aparece con una serie de tablas e índices. Si aparecen cero tablas y cero índices lo que tenemos que hacer es abrir la base de datos con Archivo/Abrir base de datos. Navegamos hasta nuestro archivo que en mi caso está en:

/Users/apa/Documents/github/djangoproject/db.sqlite3

Estando dentro de la aplicación BD Browser for SQLite, pulsamos F5 para actualizar y ahora deberíamos observamos la estructura que aparece con una serie de tablas e índices ya creados por defecto.

Sobre la tabla de usuarios pedimos con el botón derecho del ratón Mostrar datos, en inglés aparece como Browse Table.

Esto nos permitirá ver los campos de la tabla de usuarios.

Unamos la aplicación myapp con la configuración del proyecto en mysite.

Django nos da unas tablas por defecto pero posteriormente nosotros desearemos hacer nuestras propias tablas para nuestro proyecto. Para hacer esto nosotros tenemos que poder crear lo que se llama un MODELO. Este modelo es código de Python que se va a transformar en una tabla de SQL. Ahora estamos trabajando en SQLite pero este script de Python se podrá ejecutar en otras base de datos, por ejemplo en postgreSQL, siempre y cuando le hayamos dado la conexión correcta.

Mi aplicación myapp va a tener una serie de modelos específicos para esta aplicación. Para ello nos vamos al archivo models.py que está dentro de la carpeta myapp.

Estando en myapp/models.py voy a crear un modelo específico.

from django.db import models

# Create your models here.
class Project(models.Model):
    # los atributos de la clase serán los campos de la tabla
    name = models.CharField(max_length=200)

Conectar la APP con el proyecto

Para que nuestra aplicación de django conozca nuestros modelos tenemos que conectar el modelo creado, para lo cual vamos a la carpeta principal del proyecto (mysite) y vamos al archivo settings.py y buscamos la sección que contiene la variable INSTALLED_APPS que ya trae, por defecto una serie de conexiones.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',
]

Hemos añadido al final de la lista 'myapp' y esto ya permite conectar el modelo creado en mi aplicación myapp con el proyecto django.

Ejecutamos las migraciones:

Ahora lanzamos nuevamente el servidor y en otra terminal ejecutamos:

python manage.py makemigrations
python manage.py migrate myapp

Añadir myapp después de migrate es optativo y se hace en caso de querer ejecutar únicamente las migraciones de esa APP.

Se ha generado un archivo myapp/migrations/0001_initial.py. Este archivo no debemos tocarle y contiene el código necesario para que django consiga hacer los cambios necesarios en la base de datos sin nuestra intervención. Este archivo crea por nosotros la tabla con sus campos. Pero no debemos tocarlo.

Si volvemos a consultar ahora la aplicación "DB Browser for SQlite" veremos que se ha agregado una nueva tabla.

Si ya tenías abierta esta aplicación puedes refrescar la tablas pulsando F5.

La nueva tabla que se ha creado se llama myapp_project que tiene el nombre de la aplicación (myapp) y el nombre del modelo, ya que nosotros le habíamos llamado Project, recordemos que habíamos llamado así a la clase (Class Project).

Con botón derecho del ratón y Browse Table o Mostrar Datos veremos los campos creados Id y name. El Id se crea automáticamente de forma auto-incremental si no se pone otra cosa. El name se crea debido a que nosotros habíamos creado ese atributo en la clase Project.

Creamos otra clase

Vamos a crear otra clase en myapp/models.py:

from django.db import models

# Create your models here.
class Project(models.Model):
    name = models.CharField(max_length=200)

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    project =  models.ForeignKey(Project, on_delete=models.CASCADE)

El atributo project indicamos que está relacionado con otro proyecto denominado Project, por eso ponemos que se necesita una clave foránea: models.ForeignKey(Project).

Se añade on_delete=models.CASCADE para que cuando se elimine el objeto al que se hace referencia, elimine también los objetos que tengan referencias con él.

En Django, una foreign key (clave foránea) es un campo utilizado para establecer una relación entre dos modelos en una base de datos relacional. Este campo sirve para crear una relación uno a muchos entre dos modelos, donde un modelo tiene una clave que apunta a otro modelo.

Ahora volvemos a ejecutar los comandos para hacer las migraciones.

python manage.py makemigrations
python manage.py migrate

Veremos que se ha creado un nuevo archivo denominado myapp/migrations/0002_initial.py que contiene las nuevas migraciones y que tampoco debemos tocar.

Al refrescar la estructura de la base de datos con F5 en el programa DB Browser for SQLite podemos ver que se ha creado una nueva tabla para las tareas Task.

La nueva tabla se llama myapp_task y si punsamos con el botón derecho del ratón y elegimos Browse Table o Mostrar datos veremos los campos que se corresponden con los atributos creados en la clase Task que hemos creado previamente.

Vemos que aparece project_id ya que cuando se creó el atributo project lo hicimos relacionándolo con otro proyecto (con el que denominamos Project).

Sección DATABASES en settings.py

Ya tenemos, por defecto esta sección en el archivo settings.py que está en mysite.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Ahora no lo voy a hacer, pero en el futuro podré modificar esta configuración con otra que me permita utilizar otra base de datos, por ejemplo postgreSQL.

Organizar mejor las URLs en django usando el método include

2024-04-07T09:01:00.005+02:00

Anteriormente hemos ido incluyendo las rutas en el archivo urls.py de la carpeta principal donde esta nuestro proyecto que es mysite. Pero sucede que cuando aumente el número de APPs que tengamos y no solo esté myapp, se irán acumulando muchas rutas o URLs a las que queramos ir, por lo que es mejor que cada APP tenga su propio archivo conteniendo las URLs propias de esa APP.

Ahora tendremos un archivo urls.py en cada APP que tengamos, más el archivo urls.py de la carpeta principal del proyecto que es mysite. Veamos cómo quedan ambos ficheros.

mysite/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

Además de importar el método path importamos también el método include que es el que nos permite luego incluir las rutas que se indiquen include('myapp.urls')

Cuando colocamos un string vacío ('') en la línea path('', include('myapp.urls')) indica que antes de las urls a las que estamos haciendo referencia no va nada.

Si en lugar de poner un string vacío pusiera algo, por ejemplo 'home/' lo que sucedería es que ahora sería necesario poner esto para visitar las rutas que se referencian en myapp. Si hicieramos esto las rutas raiz y about serían así:

http://127.0.0.1:8000/home/
http://127.0.0.1:8000/home/about

En ese caso, si hubiéramos puesto 'home/' diríamos que esto es un prefijo y se debería añadir antes de las urls que importemos.

Nosotros en nuestro ejemplo, dejaremos el string vacío. Si bien, conviene entender que este prefijo puede ser útil para preceder la ruta de cada aplicación que tengamos para distinguirlas, por ejemplo, 'blog/' o 'tasks/' o 'store/', etc.

myapp/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.hello),
    path('about/', views.about),
]

Escribimos el punto después de from para indicar que views está en el mismo directorio que en el que estamos que es myapp.

Podemos reestablecer el servidor y ver que las rutas raiz y about funcionan bien, igual que antes.

Hello World en django

2024-04-06T18:50:00.007+02:00

Creación de las vistas

Las vistas se crean mediante la creación de unas funciones.

Iremos a la carpeta de nuestra aplicación que se llama myapp y dentro de ella encontraremos el archivo views.py.

En el archivo views.py crearemos nuestra primera función que retornará un mensaje al cliente (al navegador).

La función puede llamarse como queramos, en nuestro caso se llamará hello.

La función recibirá un parámetro que nos lo pasará django y se llamará request.

La función retornará una respuesta al cliente de tipo HTTP. Será un texto que el navegador va a recibir.

Para enviar la respuesta de tipo HTTP tendremos que importar de la librería django.http el método HttpResponse.

De momento quitaremos la otra linéa que por defecto nos muestra django que es from django.shortcuts import render que posteriormente ya utizaremos, pero que ahora quitamos.

El código quedaría así:

from django.http import HttpResponse

# Create your views here.
def hello(request):
    return HttpResponse("Hello World")

La ruta

Ahora necesitamos indicar en que ruta se ha de mostrar el resultado de nuestra función. Las rutas están en el archivo urls.py de la carpeta del proyecto mysite

Por defecto, al inicial django el archivo urls.py viene así:

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

Inicialmente ya aparece la ruta admin/ y ahora añadiremos la nuestra.

Nuestra ruta se añadirá indicando el paht como vacío (comillas comillas) '' lo que indica que se trata de la ruta principal o raiz del proyecto.

Luego pondremos la función hello, pero para que funcione tenemos que importarla con la línea from myapp.views import hello que indica dónde se encuentra esa función y cómo se llama. La función se llama hello y está situada en myapp.views

Finalmente el código queda así:

from django.contrib import admin
from django.urls import path
from myapp.views import hello

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', hello),
]

Grabamos archivos y lanzamos el servidos o actualizamos la página localhost si ya estaba lanzado el servidor.

También es posible escribir en código HTML dentro de la respuesta. Por ejemplo, poniendo una etiqueta h1 y en cursiva.

from django.http import HttpResponse

# Create your views here.
def hello(request):
    return HttpResponse("<h1><i>Hello World</i></h1>")

Recargamos la página y vemos el resultado.

Otra forma de importar la vista que proporciona la función hello consiste en importar todas las vistas con from myapp import views y luego indicar que la función hello pertenece a views poniéndolo así views.hello

El código en el archivo urls.py quedaría así.

from django.contrib import admin
from django.urls import path
from myapp import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.hello),
]

Añadiendo una nueva ruta

Vamos a añadir una nueva ruta denominada about. Para ello necesitamos modificar los archivos myapp/views.py y mysite/urls.py

Veamos estos archivos.

myapp/views.py

from django.http import HttpResponse

# Create your views here.
def hello(request):
    return HttpResponse("<h1>Hello World</h1>")

def about(request):
    return HttpResponse("Esta es la página de about")

mysite/urls.py

from django.contrib import admin
from django.urls import path
from myapp import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.hello),
    path('about/', views.about),

La ruta la hemos llamado "about/" y esta ruta se visita desde "http://127.0.0.1:8000/about/".

Actualizamos la página y pulsamos en el navegador Chrome F12. Así, en "Elementos" veremos el código de nuestra página.

Estructura de una app en django

2024-04-05T20:08:00.008+02:00

Hemos creado una app en django que se llama myapp, que queda recogida en una carpeta con el mismo nombre. Esta carpeta contiene una serie de archivos que vamos a describir.

views.py

Podemos considerarle el archivo principal de nuestra app ya que aquí podemos definir lo que vamos a ejecutar o lo que queremos enviar al cliente (al navegador) para que se pueda ver en pantalla. Aquí podemos enviar archivos HTML.

init.py

Se genera vacío y sirve para que esta carpeta sea considerada como un módulo de Python.

migrations

Carpeta que de entrada solo tiene un archivo __init__.py y que posteriormente se ira llenando cuando modifiquemos la base de datos.

En django no tenemos que estar escribiendo consultas SQL sino que ya viene con un módulo de ORM (Object Relational Mapping). Esto permite abstraer la base de datos y posibilita que las consultas a la base de datos se realicen en el lenguaje en el que trabaja el framework, en nuestro caso Python. De esta forma se facilita la tarea del programador que no tiene que estar escribiendo código SQL, aunque si se desea para realizar una consulta compleja también se puede utilizar código SQL.

admin.py

Permite añadir a nuestras aplicaciones un panel de administrador, que permite administrar nuestras aplicaciones. Permite administrar datos, crear usuarios, crear roles para los usuarios, podemos decir si a un usuario le pertenece un dato. Todo ello con un panel que ya está creado por parte del framework. Para poder integrarlo es para lo que tendremos que usar este archivo ademin.py.

apps.py

Permite configurar esta aplicación. Es similar al settings.py que tenemos en la carpeta mysite.

models.py

Aquí podemos crear clases que finalmente se convertirán en tablas SQL. Contamos con la ventaja de que django ya tiene ese ORM que se encargará de crear esas tablas. Cuando modifiquemos ese código, django también se encargará de modicar esas tablas. Para ello django creará unos archivos que se llaman migraciones, que creará en la carpeta migrations, que sirve para actualizar código de la base de datos.

tests.py

Archivo que nos permite realizar testing de las vistas que enviaremos al navegador y poder comprobar lógica. Para ver si hemos consultado bien un dato, si hemos ejecutado correctamente una función.

Creación de Apps en django

2024-04-05T19:02:00.005+02:00

Los proyectos en django están conformados por aplicaciones que son partes del proyecto que se ocupan de tareas específicas. Por ejemplo, podemos tener en nuestro proyecto:

un blog
una sección para autenticar usuarios
una sección para poder hacer pagos
una sección para poder tener artículos
etc.

De esta forma podemos dividir el proyecto grande es múltiples partes. Esas partes se llaman aplicaciones.

Las apps que integran un proyecto las determino yo, y al ser modulares se pueden integrar al proyecto o desacoplar de él. De esta forma tendremos un proyecto dividido en partes y personalizado.

Vamos a crear una app que se llame myapp:

python manage.py startapp myapp

La estructura del proyecto se verá ahora así.

Observamos que se ha creado una carpeta que se llama myapp, que es el nombre que hemos elegido, y dentro de ella se encuentran ya múltiples archivos para el correcto funcionamiento de la aplicación.

Podríamos haber creado muchas otras aplicaciones y el procedimiento para todas ellas sería el mismo.

Por ejemplo, aplicaciones de blog, de encuestas (polls), tienda (store), tareas (tasks), ...

python manage.py startapp blog
python manage.py startapp polls
python manage.py startapp store
python manage.py startapp tasks

De momento solo crearemos una app que hemos denominado myapp dentro de mi proyecto que he llamado mysite.

myapp es una parte del proyecto y mysite contiene las configuraciones globales del proyecto.

Estructura del proyecto django

2024-04-03T13:56:00.012+02:00

Archivos y carpetas

Esta es la estructura del proyecto de django nada más crearlo.

Archivo `manage.py`

El archivo manage.py nos ayuda a ejecutar comandos administrativos. Por ejemplo, podemos ejecutar un help.

python manage.py --help

Archivo `db.sqlite3`

Es la base de datos de nuestra aplicación. sqlite3 es una base de datos de tipo SQL.

Es una base de datos simple que se usa habitualmente para pruebas, pero no para desarrollo.

django oficialmente soporta las siguientes bases de datos:

PostgreSQL
MariaDB
MySQL
Oracle
SQLite

Carpeta `mysite`

Contiene el código fuente de nuestra aplicación.

Archivo `pycache`

Este archivo solo sirve para guardar código que ya compiló Python


Este archivo es imprescindible que exista aunque esté vacío.
Este archivo solo sirve para decirle a Python que la carpeta mysite es un módulo de python.
Este archivo está más relacionado con el funcionamiento de Python que con el de Django.



Archivo settings.py
Este archivo permite configurar nuestro proyecto.
Este archivo solo sirve para decirle a Python que la carpeta mysite es un módulo de python.
Veamos algún ejemplo de instrucciones de configuración.



Variable ALLOWED_HOSTS = []
Le indica al servidor qué direcciones tiene permitido consultar.



Propiedad DEBUG = True
Le indica si estamos en modo desarrollo o en modo producción.
Cuando esté como DEBUG = True nos permite obtener más información cuando estemos desarrollando.



Propiedad SECRET_KEY
Permite mejorar la encriptación de los usuarios o permite mejorar la seguridad de los datos compartidos entre el navegador y el servidor.
Contiene valores generados aleatoriamente.
SECRET_KEY = 'django-insecure-xe-ryt5i.../...87cek$' 



Variable BASE_DIR = Path(__file__).resolve().parent.parent
Indica los directorios que contiene el proyecto.
Contiene valores generados aleatoriamente.


 
Variable INSTALLED_APPS
Es una variable en forma de lista que contiene las aplicaciones que contiene nuestro proyecto.
django permite dividir un proyecto en diferentes partes que aquí se llaman aplicaciones.
La lista contiene las aplicaciones que se instalan por defecto.
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]  



Variable MIDDLEWARE
Es una variable en forma de lista que indica a Django si va a procesar algún tipo de datos de alguna forma específica.
Esta es la lista que se ha instalado inicialmente.
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]  


  
Variable TEMPLATES
Aquí podremos establecer nuestros Templates.


  
Variable WSGI_APPLICATION
Aquí podremos indicar módulos extra cuando estemos en modo de producción.
WSGI_APPLICATION = 'mysite.wsgi.application' 


  
Variable DATABASES
Es una variable en forma de diccionario que contiene las bases de datos a las que está conectado nuestro proyecto.
Por defecto la base de datos es SQLITE3.
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}  


  
Variable AUTH_PASSWORD_VALIDATORS
Es una variable en forma de lista que contiene las formas de validar contraseñas al autenticar usuarios.
Por defecto la base de datos es SQLITE3.
AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]  


  
Variable STATIC_URL
Aquí podremos establecer en que directorio se encuentran los archivos estáticos, por defecto se establece que esta carpeta será 'static'.
La carpeta 'static' no viene creada por defecto, pero lo habitual es que nosotros la creemos y en ella guardemos los llamados archivos estáticos.
El contenido estático es cualquier archivo que se almacena en un servidor y es el mismo cada vez que se entrega a los usuarios. Se consideran estáticos los archivos HTML, CSS, JS, las imágenes, mp3, mp4, ico y otros elementos que no cambian dinámicamente en función de las interacciones del usuario..
STATIC_URL = 'static/' 


  
Archivo urls.py
Aquí se indican las URLs que los clientes pueden visitar.
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]code>
 
Por defecto, solo viene la ruta "admin/' pero posteriormente iremos añadiendo otras.



Archivos asgi.py y wsgi.py
Estos archivos están más relacionados con la forma de servir nuestro proyecto en producción.
django se ocupa de crear el proyecto pero no del despliegue, para lo cual tendremos que tocar estos archivos.



Comenzando con django
2024-04-02T14:31:00.016+02:00
Veamos django desde cero. Seguiremos algunos vídeos y páginas y tomaremos nota de lo principal.
Curso de Django para Principiantes 
Instalación de django en Ubuntu
Sigue estos pasos en la terminal:
Paso 1. Actualiza tu sistema
sudo apt update -y

sudo apt upgrade -y
Paso 2. Actualiza Python3
Actualiza a la última versión disponible de Python 3.
Este paso puedes hacerlo ahora y así Python 3 quedará actualizado para todo tu sistema operativo o bien puedes hacerlo dentro del entorno virtual que crearemos más adelante y una vez que lo tengas activado, de esta forma la última versión de Python 3, quedará establecida en ese entorno virtual concreto, sin interferir con la versión que tiene el sistema operativo.
Primero
Descarga de la página oficial (https://www.python.org/downloads) la última versión disponible para Linux, por ejemplo Python-3.12.2.tar.xz
Segundo
Instala las dependencias necesarias para compilar Python desde la fuente:
sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev wget
Tercero
Extrae el archivo tar.xz descargado
tar -xf Python-3.12.2.tar.xz
Cuarto
Accede al directorio Python-3.12.2
cd Python-3.12.2
Quinto
Configura la compilación
./configure --enable-optimizations
Sexto
Compila e instala Python
sudo make altinstall
Séptimo
Verifica la instalación:
python3.12 --version
Octavo
Es posible que al hacer python3 --version se continúe mostrando una versión anterior a la 3.12 que es la que has instalado como versión más reciente. En ese caso se puede conseguir que Ubuntu muestre la versión última que acabas de instalar. Para ello vamos a crear manualmente un enlace simbólico para python3.12 que apunte a python3.
Vamos a conseguirlo siguiendo estos dos puntos:
Octavo. Punto 1
Primero, identifica la ruta completa del intérprete de Python 3.12.2 que instalaste. Puedes hacerlo con el siguiente comando:
which python3.12
Esto te mostrará la ruta completa del intérprete de Python 3.12.2.
Octavo. Punto 2
Luego, crea un enlace simbólico para python3.12 que apunte a python3 con el siguiente comando (reemplaza /ruta/a/python3.12 con la ruta que obtuviste en el paso anterior):
sudo ln -sf /ruta/a/python3.12 /usr/bin/python3
Este comando crea un enlace simbólico llamado python3 que apunta al intérprete de Python 3.12.2.
Una vez completados estos pasos, al ejecutar python3 --version deberías obtener la versión 3.12.2.
Paso 3. Crea un nuevo directorio para tu proyecto
Sitúate en la carpeta que quieras, en Documents o en una carpeta llamada github si la tienes creada, y alli podrás crear el nuevo directorio.
Después de crear el directorio, muévete hacia él en la terminal.
mkdir djangoproject

cd djangoproject
Paso 4. Comprueba la versión de Python 3 que tienes instalada en tu sistema.
python3 --version 
Paso 5. Crea un entorno virtual
Dentro del directorio del proyecto crearemos un entorno virtual.
python3 -m venv venv
Paso 6. Activa el entorno virtual
Estando en el directorio del proyecto activa tu entorno virtual. Si tu entorno virtual no se llama venv sustituye en la siguiente línea venv por el nombre que tenta tu entorno virtual.
source venv/bin/activate
Cuando el entorno virtual queda activado verás a la izquierda del prompt en la terminal que pone (venv) o el nombre que hubieras dado a tu entorno virtual.
La forma de activarlo en Windows es bastante diferente (.\venv\Scripts\activate).
Paso 7. Actualiza a la última versión de Python3
Si no lo hiciste en el Paso 2, ahora dentro del entorno virtual, vamos a instalar o actualizar a la última versión de Python 3.
python3 -m venv venv
Paso 8. Ver la versión de Python dentro del entorno virtual
Si tenemos activado el entorno virtual podemos ver la versión de Python que tenemos en este entorno virtual escribiendo en la terminal lo siguiente
python --version
Observe que ahora no es necesario poner el número 3 después de la palabra python.
Puedes comprobar también la versión del gestor de paquetes pip.
pip --version
Paso 9. Desactivar el entorno virtual
Estando con el entorno virtual activado escribimos:
deactivate
Al desactivarse el entorno virtual ya no aparece a la izquierda del promt (venv) o el nombre que hubiéramos dado a nuestro entorno virtual.



Usar Visual Studio Code
Extensiones
Instalar la extensión de Python más habitual que es la de Microsoft.
Seleccionar el intérprete de Python
Estamos dentro de VSC, tenemos abierta una terminal dentro de VSC y estamos con el entorno virtual activado.
Pulsamos F1 y buscamos Python Select Interpreter. Al pulsar sobre esa opción nos saldrán varias opciones de Python, elegiremos la del entorno virtual y no la denominada Global.
En mi caso elijo la que pone:
Python 3.12.2 ('venv'; venv) ./venv/bin/python     Recomended




Instalar django
Instalación
Estando en VSC, con una terminal abierta en VSC y con el entorno virtual activado, escribimos:
pip install django
Comprobar si está instalado
Podemos comprobar la versión instalada de django por alguno de estos tres métodos.
Método 1
django-admin --version
Método 2
python -m django --version
Método 3
Entramos en Python.
python
Ya estamos dentro del Shell de Python y aquí escribimos:
import django

django.get_version()
Con esto ya hemos obtenido la versión de django y ahora salimos del Shell de Python:
exit()



Crear un proyecto con django
El proyecto se llamará mysite. No usar nombres de proyecto como django, python, test.
Estamos en VSC, y tenemos abirta una terminal en VSC con el entorno virtual activado y estamos  en el directorio djangoproject que se creó anteriormente.
django-admin startproject mysite .
Observe que la línea anterior termina es espacio punto. Ese punto hace referencia a la carpeta actual, que es en la que estoy djangoproject, para que cree el proyecto en ella. Si todo va bien habrá creado la carpeta mysite dentro de la carpeta djangoproject.



El archivo manage.py sirve para establecer los archivos de configuración de nuestro proyecto. Vamos a ejecutar ese archivo con Python y le pasamos un parámetro (runserver) para arrancar el servidor.
python manage.py runserver
En nuestro navegador web, en la siguiente ruta podremos ver corriendo la página inicial de nuestro proyecto.
http://127.0.0.1:8000/
Esto es lo que veremos.




Cambiar el puerto del servidor
Podemos terminar el servidor pulsando Control + C.
Lanzamos nuevamente el servidor, en esta ocasión en el puerto 3000:
python manage.py runserver 3000
Luego pulsamos son Control + Click sobre el enlace que aparece en la terminal: http://127.0.0.1:3000/
También se puede conseguir la página web en local pidiendo en nuestro navegador la página cuya URL es: localhost:3000


Factorial con recursividad en Python
2023-04-30T20:20:00.004+02:00
Ya hemos tratado el tema del factorial sin recursividad en este post:
Factorial de un número en Python
En esta ocasión vamos a utilizar una función recursiva.
El código se puede descargar en el siguiente enlace:
Gist
def factorial(n):
    if n > 1:
        n *= factorial(n - 1)
    return n

factorial(5)

El factorial de 5 es:
5! = 5 * 4 * 3 * 2 * 1 = 120

La función recursiva se llama a si misma hasta que se llega a la condición de parada que en este caso es cuando n vale 1 y en ese caso se retorna el valor que ha alcanzado la propia variable


doctest en Python para documentar funciones
2023-04-20T12:34:00.002+02:00

Es aconsejable decir que hace cada función con un comentario que se denomina doctest. Supongamos la siguiente función que suma dos números enteros.


Al añadir el doctest se hace entre comillas triples y se pueden poner casos de uso que se comprueban con la siguiente línea de código en la terminal. Si al ejecutar esta línea no da error quiere decir que la función ha pasado correctamente estos casos de uso. No llegan a tener la categoría de 'pruebas unitarias' pero nos ayudan a comprobar que esos casos de uso son correctos.


  
  
    python3 -m doctest sumando.py
    
  
  











El guión bajo en Python  ( ·_·)
2023-04-20T10:48:00.003+02:00
En la terminal podemos correr python3 y experimentar con el guión bajo. En las líneas de comando de Python3 el guión bajo actúa recordando lo impreso en la última línea.
 


Actúa de forma similar a la tecla Ans de algunas calculadoras que recuerdan el último valor calcualdo y pueden seguir operando con él.


Podemos utilizar el guion bajo como una variable auxiliar en un bucle.




  
  
  


Curso de Flask 1
2022-05-28T20:10:00.001+02:00
Utilizaremos un servidor Flask que nos permitirá disponer de la página web programando en Python.
Vamos a trabajar viendo la web en nuestro propio ordenador, esto es, la página se verá en localhost y posteriormente se podría desplegar en un servidor Flask externo.
Utilizaremos un Linux de tipo Ubuntu o cualquier otro basado en Debian.
Esto también nos debería funcionar en un MAC ya que su sistema operativo (macOS) también deriva de Unix, siendo comunes la mayoría de los comandos que podemos ejecutar en la terminal. La terminal de MAC viene inicialmente muy poco operativa, conviene que busques como "Install command line developer tools in macos". Para terminar de mejorar tu terminal en MAC deberías instalar Homebrew. Con esto tu terminal en MAC operará de forma similar a un Linux.
Si utilizamos Windows lo que haremos es instalar Windows Subsystem for Linux (WSL) en su versión actual WSL2. Esto nos permitirá disponer de una terminal de Linux dentro de Windows. Concretamente instalaremos una distribución Ubuntu desde la tienda de software de Windows.
También se podría instalar Flask directamente en Windows. Existen varias páginas que explican esta posibilidad, puedes buscar alguna actualizada en tu buscador favorito.
Cuando ya tengamos la terminal de Linux, crearemos un entorno virtual para poder instalar la versión de Python que queramos, así como las librerías necesarias. No es obligatorio crear un entorno virtual pero es recomendable para evitar mezcla de versiones de Python y sus librerías.
Paso 1. Actualiza tu sistema

sudo apt update -y
sudo apt upgrade -y



 
Paso 2. Comprueba que está instalado Python3 y pip3


python3 --version


Si fuera necesario instalar Python3

sudo apt install python3


Podemos comprobar si ya tenemos instalado el gestor de paquetes pip3:

pip --version


Si no lo tenemos instalado hemos de instalarlo:
 

sudo apt install python3-pip

Podemos ejecutar Python3 y así, ver también la versión disponible.

python3

para salir de Python:

exit()


Tecleando pip3 podemos ver los comandos disponibles:

pip3

Para borrar la pantalla de la terminal:

clear

Paso 3. Instalación del entorno virtual
Este paso es optativo, pero recomendable para aislar las versiones instaladas de las que tenemos en otros proyectos o en el ordenador. De esta forma si se corrompen las librerías, no tendremos que instalar todo en el sistema, bastará con hacer otro entorno virtual.
Primero crea la carpeta del proyecto y haz la instalación del entorno virtual dentro de la carpeta del proyecto.
Aquí podemos hacer dos cosas:
1. O bien, clonamos el proyecto

git clone https://github.com/financieras/flasksum.git

2. O bien, creamos la carpeta y luego vamos haciendo los demás ficheros


mkdir flasksum

Nosotros elegiremos el camino largo, creando todo desde cero. Crearemos el directorio con mkdir.
Entraremos en la carpeta creada:

cd flasksum


 
Crearemos el entorno virtual con estas dos líneas de consola:

sudo apt install python3-venv -y
python3 -m venv venv

El segundo venv es el nombre de nuestro entorno virtual, también podemos llamarlo con otro nombre, o incluso podemos tener varios entornos viruatales, con diferentes versiones de Python.


Y el entorno virtual se activa así:

. venv/bin/activate


El promt ha cambiado y a la izquierda aparece entre paréntesis el nombre de nuestro entorno virtual: (venv)

Para desactivar el entorno virtual:

deactivate


Si quisiéramos activar el entorno virtual desde la carpeta del propio entorno virtual haríamos lo siguiente:

cd venv/bin
source activate

El entorno virtual funciona bastante bien salvo con update y con upgrade, que se han de ejecutar cuando estemos fuera del entorno virtual.

Para instalar librerías en el entorno virtual éste debe estar activado.

Para activar el entorno virtual no es necesario estar dentro de estas carpetas basta con teclear la ruta:

source Documentos/github/flasksum/venv/bin/activate


Paso 4. Instalar Flask estando dentro de nuestro entorno virtual
Estando dentro del entorno virtual:

pip install Flask




Podemos comprobar que, estando dentro de nuestro entorno virtual, si tecleamos python se va a la versión 3 que tengamos instalada. No pasa como cuando tecleamos python fuera del entorno virtual que se va a la versión 2 o no reconoce el comando.
Ahora tecleando python contestará con la versión 3 que tengamos instalada. 

python
exit()




Paso 5. Instalar sqlite3
Este paso no es necesario si luego no vas a usar una base de datos. 
Para instalar la base de datos sqlite3 nos introducimos en nuestro entorno virtual y tecleamos:

sudo apt install sqlite3




Entramos y vemos la versión instalada.

sqlite3
.exit

Para salir se pone punto seguido de exit.

Paso 6. Creamos la 1ª versión del archivo app.py
Estamos dentro del entorno virtual en la carpeta del proyecto flasksum y vamos a crear nuestra primera versión del archivo app.py que es la que permitirá ejecutar el servidor flask.
Para crear el archivo necesitamos un editor de texto plano, o un editor de código, por ejemplo Visual Studio Code. Nosotros lo haremos usando un editor muy básico de Linux, que funciona en terminal y que se llama nano. También funciona en las nuevas versiones de Windows 10 y Windows 11, ejecutado desde PowerShell

nano app.py


El contenido del archivo será el siguiente.

from flask import Flask

app = Flask(__name__)

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

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


El código anterior con comentarios.

from flask import Flask  # del módulo de flask importamos la clase Flask

app = Flask(__name__)

@app.route("/")    # decorador de ruta
                   # el decorador está esperando una cadena de texto que
                   # será la ruta con al que accederemos con nuestro navegador

def hello():       # al entrar en la página web se ejecutará el código de esta función
    return "Hello World"   # el nombre de la función es hello pero puede ser otro

if __name__ == "__main__":
    app.run()             # establece el servidor local y
                          # ejecuta nuestra aplicación sobre él.


Paso 7. Lanzamos el servidor Flask en local
Estando en el entorno virtual en la carpeta flasksum vamos a lanzar el servidor Flask. Para ello, simplemente tecleamos:

python app.py

Como estamos dentro del entorno virtual no es necesario poner python3 ya que se sobreentiende que estamos en la versión 3, ya que estamos dentro del entorno virtual.
Al lanzar el servidor Flask, si todo ha ido bien, podremos ver en una pestaña de nustro navegador corriendo la página web creada con el saludo de Hello World.
Si no se abre automaticamente la pestaña en nuestro navegador podemos pulsar sobre el enlace que se muestra en la terminal, apretando la tecla Control y pulsando con el puntero del ratón sobre el enlace. Se abrirá un nustro localhost la página:
http://127.0.0.1:5000
La dirección del localhost es 127.0.0.1 y luego se ponen dos puntos y el puerto, que por defecto es el puerto 5000.

 
Alternativamente, también podríamos poner la dirección del localhost que es:
http://localhost:5000
 
Ya hemos conseguido correr nuestro servidor de Flask en local.
Para detener el servidor se pulsa CONTROL+c

Para salir del entorno virtual pulsamos: 


deactivate

Para salir de la consola pulsamos:
 

exit

Paso 8. Activamos el modo debug
Entramos en el entorno virtual.
Modificamos el archivo app.py añadiendo el modo debug que hace que las modificaciones en el archivo app.py que hagamos en el futuro se apliquen inmediatamente en la web que estamos corriendo en local, sin necesidad de que se interrumpa el servidor y tengamos que lanzarlo nuevamente después de cada cambio.
El nuevo archivo app.py quedará modificado en su última línea.

from flask import Flask

app = Flask(__name__)

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

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


Ahora podemos ver en la terminal que el modo debug está activo.
La ventaja de tener el debug activo es que cuando estamos desarrollando, al hacer cambios en nuestro código, no tenemos que detener el servidor y volverlo a reiniciar, ya que los cambios en el código se reflejarán de forma automática.
Por ejemplo, incorporemos a la función hola() una nueva línea justo debajo de su creación con def hola():
La nueva línea es:

print((__name__))  # imprimirá el valor por consola de __name__ que es __main__

 
Grabando el archivo modificado app.py y recargando la página podremos ver en la consola que se ha recargado el servidor y aparece impresa la palabra __main__.




Paso 9. Cambiamos el puerto
Aunque tengamos el debug activado, el cambio de puerto hace que el servidor se tenga que detener para luego poderlo reiniciar en el puerto nuevo.
Abrimos una nueva terminal y modificamos el archivo app.py para añadir al final el puerto que ahora será el 5042, que es diferente al puerto por defecto.
Grabamos el archivo app.py
En la terminal que tenemos corriendo el servidor, lo detenemos con Control+C
Lanzamos nuevamente con python app.py
Podemos ver ahora corriendo la página en el nuevo puerto en alguna de estas dos direcciones.

http://localhost:5042
http://127.0.0.1:5042

Hemos tenido que detener el servidor y reiniciarlo pese a tener activado el modo debug ya que este soporta cambios de desarrollo que no sean drásticos como es el cambio de puerto.
Parámetro host
Otro parámetro que acepta app.run() es el parámetro host que si es host='0.0.0.0' conseguimos que la página web esté en modo de producción y no de desarrollo. Así, será menos segura y conseguiremos que sea visible por otros ordenadores de nuestra red teclaendo por ejemplo http://192.168.1.157:5000 siendo esta la IP interna donde corre nuestro servidor web.



Paso 10. Ruta principal y otras rutas
La ruta principal es "/" pero podemos crear nuevas rutas, por ejemplo la ruta "/hola".
Nuestro nuevo archivo app.py será el siguiente.

from flask import Flask

app = Flask(__name__)

@app.route("/")                    # ruta principal
def hello():
    return "<h1>Hello World</h1>"  # podemos incluir etiquetas html

@app.route("/hola")
def hola():                        # nombre relacionado con la ruta por costumbre
    return("<p>Hola</p>")

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


Podemos incluir etiquetas html en el return de la ruta tales como:
títulos <h1>,<h2>,...
párrafo <p>
negrita <b> o <strong>
italic <i>
etc.
El nombre de la función, es costumbre que sea el mismo que el de la ruta o que esté relacionado con esta para poder identificarlo. En nuestro código la función se ha definido con "def hola():" ya que la ruta es "/hola".
De esta forma, hemos conseguido dos rutas en nuestro ejemplo:
la ruta principal y
la ruta hola
veamos las dos páginas que sirve nuestro servidor Flask.

 
 
 




Paso 10. Añadiendo variables
Cramos una nueva ruta "/user" y dentro de ella añadimos la variable user.
El archivo app.py quedará ahora así.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1>Hello World</h1>"

@app.route("/hola")
def hola():
    return("<p>Hola.</p>")

@app.route("/user/<string:user>")
def user(user):
    return "Hola " + user

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




El tipo de variable es "string".
Veamos la nueva ruta funcionando.
 
Con esto hemos conseguido que podamos saludar a alguien tecleando la url:)

http://127.0.0.1:5000/user/Alex

Tipos de variables que podemos usar
En la siguiente web vemos los tipos de variables que usa flask.

https://flask.palletsprojects.com/en/2.0.x/quickstart/#variable-rules


Capturando un número en una variable
Ahora añadimos una nueva ruta al código, la ruta "/numero".
El archivo app.py quedará así:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1>Hello World</h1>"

@app.route("/hola")
def hola():
    return("<p>Hola.</p>")

@app.route("/user/<string:user>")
def user(user):
    return "Hola " + user

@app.route("/numero/<int:n>")
def numero(n):
    return f"El número es {n}."

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




Grabamos el archivo y con el servidor Flask corriendo, tecleamos la siguiente url:
http://localhost:5000/numero/100 
El resultado en la web es:



Capturando un nombre y un número
Supongamos que nos piden un nombre y un número de socio, por ejemplo Alex y 200. Vamos a capturar las dos variables y a mostrarlas en página web.
El código del archivo app.py es el siguiente.




from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1>Hello World</h1>"

@app.route("/hola")
def hola():
    return("<p>Hola.</p>")

@app.route("/user/<string:user>")
def user(user):
    return "Hola " + user

@app.route("/numero/<int:n>")
def numero(n):
    return f"El número es {n}."

@app.route("/user/<string:username>/<int:id>")
def socio(username, id):
    return f"Nombre: {username}<br>Socio número: {id}."

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





La URL que tenemos que teclear es:
http://localhost:5000/user/Alex/200




Suma de dos números tipo float
El archivo app.py quedaría así:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1>Hello World</h1>"

@app.route("/hola")
def hola():
    return("<p>Hola.</p>")

@app.route("/user/<string:user>")
def user(user):
    return "Hola " + user

@app.route("/numero/<int:n>")
def numero(n):
    return f"El número es {n}."

@app.route("/user/<string:username>/<int:id>")
def socio(username, id):
    return f"Nombre: {username}<br>Socio número: {id}."

@app.route("/suma/<float:n1>/<float:n2>")
def suma(n1,n2):
  return f"La suma de {n1} y {n2} es: {n1+n2}."

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



Los números introducidos en la URL tienen que llevar coma de decimales necesariamente.
http://localhost:5000/suma/9.0/3.0
 
Asignar valores por defecto
Asignar un valor por defecto a una variable requiere añadir un doble decorador y requiere añadir un valor por defecto a la variable.


from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1>Hello World</h1>"

@app.route("/hola")
def hola():
    return("<p>Hola.</p>")

@app.route("/user/<string:user>")
def user(user):
    return "Hola " + user

@app.route("/numero/<int:n>")
def numero(n):
    return f"El número es {n}."

@app.route("/user/<string:username>/<int:id>")
def socio(username, id):
    return f"Nombre: {username}<br>Socio número: {id}."

@app.route("/suma/<float:n1>/<float:n2>")
def suma(n1,n2):
  return f"La suma de {n1} y {n2} es: {n1+n2}."

@app.route("/ciudad")     # doble decorador
@app.route("/ciudad/<string:dft>")
def ciudad(dft = "Madrid"):
    return "La ciudad de destino es " + dft

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



Veamos actuar el valor por defecto en la siguiente URL:
 http://localhost:5000/ciudad
 

Veamos como añadir un valor concreto para que no actúe el valor por defecto.
http://localhost:5000/ciudad/Roma





Sumar números de un formulario web con Python y Flask
2022-05-27T18:32:00.065+02:00
Puede consultar el código de este proyecto en GitHub: flasksum.
Vamos a crear un formulario web sencillo, usando HTML, con un par de cajas de texto donde el usuario introduzca los valores numéricos y un botón. Al pulsar sobre el botón, se lanza un procedimiento programado en Python, que permitirá sumar los dos números y mostrar el resultado en esa misma página web.
Utilizaremos un servidor Flask, programando en Python y usaremos Jinja2 para hacer la operación matemática con las variables.

Antes de introducir valores.
Sumando dos números.
Estructura de directorios y archivos




Archivo app.py 


from flask import Flask, request, render_template

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        vals = request.form.getlist('misvalores')
        val1 = float(vals[0])
        val2 = float(vals[1])
        result = val1 + val2
    else:
        val1 = ''
        val2 = ''
        result = ''
    return render_template('index.html', val1=val1, val2=val2, result=result)

if __name__ == "__main__":
    app.run(debug=True, port=5000)


Archivo index.html


<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Página Flask</title>
    <link href="../static/css/style.css" rel="stylesheet" type="text/css">
</head>
<body>
    <h1>Operaciones matemáticas con Flask</h1>
    <h2>Suma de dos números</h2>
    <p>Introduzca dos números y pulse el botón para obtener la suma.</p>
    <form action="/" method="POST">
        <p>Input 1: <input name="misvalores" value="{{ val1 }}"></p>
        <p>Input 2: <input name="misvalores" value="{{ val2 }}"></p>
        <input type="submit" value="Sumar">
    </form>
    <br>
    <p>Resultado: {{ result }}</p>
</body>
</html>




Archivo style.css


body {
    background-color: rgb(225, 255, 240);
  }

h1   {color: blue;}


Dentro de la carpeta static dejamos praparadas para una posible ampliación las carpetas imgs y js. 



Diccionario con Tupla
2022-03-20T12:15:00.006+01:00
 
Reto: Diccionario con Tupla

Crear un diccionario donde la clave sean los números del 1 al 100, y 
para cada uno de los números tenemos una tupla como valor, donde la 
tupla contiene el cuadrado de ese número, e indica si el número es primo
 o no.


Método 1 
 

Método 1
Usando una fucción que ya enseñamos en el blog que retorna si el numero es primo o no, y recorriendo los 100 numeros

 from math import sqrt  
   
   
 # Funcion que determina si es un numero primo  
 def sera_primo(n):  
   primo = True # inicialmente un número es primo hasta que no se demuestre lo contrario  
   for j in range(3, int(sqrt(n)+1), 2):  
     if (n % j == 0): # si el módulo es cero se debe a que es divisible y por tanto no es primo  
       primo = False  
       break  
   return primo  
   
 miDiccionario = {}  
 for i in range(1, 101):  
   # Añadimos a la lista el cuadrado y comprobamos si es primo  
   miDiccionario[i] = (i ** 2,sera_primo(i^2))  
   
 print(miDiccionario)  





Prompt personalizado
2022-03-13T00:17:00.003+01:00
 Vamos a personalizar el prompt en Windows 10 o en Windows 11 de la terminal Powershell.
Paso 0, instalar winget
Es un paso opcional, pero nos hace la instalación de Oh My Posh mucho más fácil. Tambíen se pueden usar otros gestores de paquetes como chocolatey o scoop. 
Winget es el gestor oficial de paquetes para Windows que necesitaremos tenerlo instalado como paso previo opcional.
 Documentación de instalación y uso de winget: https://docs.microsoft.com/es-es/windows/package-manager/winget/
Paso 1, descargar el software Oh My Posh
Usando winget: 

  
 winget install JanDeDobbeleer.OhMyPosh

Si no se quiere usar winget se puede instalar de manera manual. La documentación oficial de instalación: https://ohmyposh.dev/docs/windows




Rebotar el PC.
Para probar que funciona, escribir en PowerShell:

 oh-my-posh.exe  


Paso 3, instalar Windows Terminal 
Windows Terminal es un programa que nos da más funcionalidad con nuestras terminales. Como poder tener pestañas para las diferentes terminales, pantalla dividida con nuestras terminales.

Para instalarlo podemos hacerlo directamente desde la la Tienda de Microsoft buscando Windows Terminal.
Paso 4, el tipo de Font
Necesitaremos instalar un font que soporte todos los caracteres que vamos a usar.
Para ello escogeremos alguno de los disponibles en NerdFonts: https://www.nerdfonts.com/

Yo voy a usar uno llamado Caskaydia Cove Nerd Font. Puedes elegir cualquiera de los disponibles en la página.

Lo descargamos e instalamos todos los ficheros de font que contenga la descarga.





Ya tenemos nuestro font instalado. Ahora tendremos que configurarlo en los programas que usemos.
Yo lo cambiaré en 3 programas:
Powershell
Windows Terminal
Visual Studio Code
Powershell
Abrimos una nueva ventana de Powershell. Click derecho en el título del programa. Propiedades.
En propiedades podremos cambiar el font a nuestro NerdFont.
 
Windows Terminal 
En Windows Terminal hacemos ctrl+,
En el apartado de Default, Apariencia cambiamos el font a nuestro font instalado.
Ahora si abrimos una terminal nueva y volvemos a comprobar nuestro prompt, el font se ve perfectamente. 
 

 
 
 
 
Visual Studio Code 
Ctrl+, para ir a ajustes. Buscamos el font de la terminal y escribimos: "CaskaydiaCove NF"

 
 
 Paso 5, el perfil de PowerShell 
Ahora tenemos nuestra terminal configurada con el Font que queremos y todo instalado correctamente, pero cuando abrimos PowerShell no nos aparece nuestro prompt de OhMyPosh, vamos a configurarlo.
 
En un PowerShell escribimos:
 code $profile  

Dentro de este archivo pegamos el siguiente codigo:
 oh-my-posh --init --shell pwsh --config https://raw.githubusercontent.com/JanDeDobbeleer/oh-my-posh/v$(oh-my-posh --version)/themes/nu4a.omp.json | Invoke-Expression  

Si ahora abrimos un PowerShell no podemos encontrar con este error:

 
 
Si este es el caso, abrimos una terminal en modo administrador y ejecutamos el siguiente comando:
 
 Set-ExecutionPolicy -ExecutionPolicy bypass  
 
Este comando nos permite ejecutar scripts en PowerShell. Más información: https://docs.microsoft.com/es-es/powershell/module/microsoft.powershell.core/about/about_execution_policies?view=powershell-7.1
 Paso 5, personalizar el tema
Con todo esto ya tenemos todo configurado y funcionando. Cuando abrimos la terminal funciona todo como debería.
 
 
 
Este último paso es por personalizar y cambiar la estética de la terminal.
 
OhMyPosh  tiene muchos temas que vienen por defecto. En el caso de nuestra instalación he elegido el tema nu4a  pero si quieres puedes cambiar el tema a uno de los por defecto, e incluso crear el tuyo propio.

Te recomiendo ir a la página de temas de OhMyPosh para ver los diferentes temas que hay disponibles.

Pagina de temas OhMyPosh: https://ohmyposh.dev/docs/themes
 
 
 



2022-03-11T21:54:00.004+01:00
Reto: Tuplas

Crear una tupla con las cuatro estaciones del año. Imprimir la tupla, 
imprimir su longitud e imprimir los elemento de la tupla uno a uno.

Método 1
Utilizamos una tupla en lugar de una lista para contener las estaciones del año.
Las tuplas a diferencia de los arrays se declaran usando parentesis (), en lugar de corchetes [].
 

Método 1
Definimos nuestra variable tipo tupla. Imprimimos su valor y su longitud. Finalmente la recorremos con un for para imprimir cada una en una linea diferente.

 tupla = ("Invierno", "Primavera", "Verano", "Otoño")
 print(*tupla)
 print(f"Longitud: {len(tupla)}")
 for estacion in tupla:
     print(estacion)  





Twitter embebido
2021-10-27T12:59:00.001+02:00
 Veamos un Twitt embabido de la ESA (Agencia Espacial Europea).



No te pierdas esta imagen interactiva de @HUBBLE_space de los Pilares de la Creación (M16) en #ESASky https://t.co/J50BwV7eEz
— ESA España (@esa_es) October 26, 2021
 


Bot de Telegram para consultar cotizaciones de Bitcoin, Ethereum, Tesla y otros valores
2021-09-05T00:53:00.004+02:00
Veamos, paso a paso, lo que necesitamos para realizar un bot de Telegram y para implementar el código necesario que nos permita consultar el precio de valores cotizados.
Paso 1. Necesitamos una cuenta de Telegram
Es posible que ya tengas una cuenta de Telegram, que es un medio de comunicación similar a WhatsApp, aunque tiene grandes ventajas: creemos que guarda mejor la privacidad, dispone de canales de difusión y permite la creación de Bots. 
Si no tienes cuenta, consulta este enlace: https://telegram.com.es
Puedes instalar Telegram en Android, en iOS y además puedes utilizarlo como aplicación web, con Telegram Web, o la versión de escritorio con Telegram Desktop.
En este post las imágenes que vamos a mostrar están tomadas de la aplicación de Telegram Desktop que puedes instalar tanto en Windows,  Linux o Mac. Para seguir los pasos de esta entrada del blog lo recomendable es que te instales en tu ordenador Telegram Desktop.
Paso 2. Acceder a BotFather
BotFather es un bot de Telegram que permite controlar todos los bots que se creen en esta aplicación de mensajería instantánea.
Para acceder por primera vez a BotFather pulsa el siguiente enlace: https://telegram.me/botfather
Cuando ya has entrado en el BotFather puedes interactuar con él pulsando los comandos:
/start
/help




Paso 3. Crear un nuevo bot con BotFather
Para crear un nuevo bot, estando en BotFather tecleamos el siguiente comando.
/newbot

Te pedirá que introduzcas el nombre de tu bot, nosotros hemos llamado al bot: BolsaBot.
Luego te pedirá que introduzcas un usuario para el bot. Debe terminar en 'bot' y no debe estar ya inscrito previamente. Nosotros hemos encontrado libre el nombre: mercadosbot.




Observe que en la imagen anterior hemos borrado el Token que nos dan. Este gran string deberíamos custodiarle bien y no permitir que nadie malicioso lo conozca. Cuidado con subirlo, a un repositorio público de GitHub, ya que algunos malintencionados se dedican a buscar estos token de forma automática por todos los repositorios de GitHub.

Esto supone que para acceder a nuestro bot desde fuera, podamos hacerlo con el enlace: 

https://telegram.me/mercadosbot

Podemos pinchar sobre nuestro bot y pedir que nos muestre su perfil (View Profile).


Nuestro bot ya existe, aunque de momento no sabe hacer nada. Necesitamos programarle.

Paso 4. Clona el repositorio con el bot
Previamente tenemos que tener instalado en nuestro ordenador git.

Puedes clonar el repositorio que ya tenemos creado con el bot.

git clone https://github.com/financieras/TelegramCryptoBot.git



Paso 5. Crea un entorno virtual (opcional)
Este paso es optativo. Habitualmente en Python se aconseja trabajar en los proyectos con entornos virtuales que delimitan la versión de Python con la que se trabaja concretamente en ese proyecto, y las versiones de las librerías que instalamos, usando normalmente el gestor de paquetes pip.

El riesgo que corremos si no trabajamos con un entorno virtual es que se un proyecto que teníamos funcionando correctamente con ciertas versiones de las librerías utilizadas y cierta versión concreta de Python, deje de funcionar cuando en el sistema operativo hemos actualizado las versiones. Podríamos preguntarnos, ¿cómo es posible que si este proyecto funcionaba bien el año pasado, y no lo he vuelto a tocar, ahora no funcione?, y la respuesta puede ser que el motivo por el que tenemos errores es porque hemos actualizado las versiones de algunas librerías, o del propio Python. 

Otra pregunta que nos podemos hacer: ¿cómo es posible que si el proyecto corría bien en mi ordenador, al llegar a la oficina del cliente e instalarlo en su sistema, ahora no corra y de varios errores?

Para evitar estos conflictos de versiones, se recomienda usar entornos virtuales, y definir exactamente las versiones con las que estamos trabajando. Para ello disponemos del archivo requirements.txt donde se recogen las librerías utilizadas y sus versiones, así como la versión de Python con la que se probó el proyecto.

Para crear un entorno virtual en Python se puede lograr por varios métodos, siendo el más sencillo el siguiente.



sudo apt install python3-venv
python3 -m venv venv

El segundo venv es el nombre que hemos querido dar a nuestro entorno virtual.
El entorno virtual se activa así.
. venv/bin/activate


Para lanzar Visual Studio Code desde el directorio en el que estemos se teclea:


code .


Paso 6. Poner nuestro Token
Para evitar que se pueda subir el Token a GitHub, a un repositorio público, se han de tener en cuenta varios puntos.
El token se pondrá en un archivo denominado .env 

Para evitar que ese archivo se suba a GitHub se añade en el .gitignore 

Para recordarnos que se han de realizar estos pasos, se añade un archivo denominado .env.example cuya única finalidad es hacer ese recordatorio. 



Paso 7. Instalar las librerías del archivo requirementes.txt
En el archivo de texto requirements.txt tenemos una relación de librerías a instalar con sus versiones. Algunas librerías que se usan en el proyecto, como por ejemplo, os que ya viene instalada cuando se instala Python, pero otras requieren que usemos el gestor de paquetes pip. Pero para no estar, instalando una a una e instalar las versiones que no correspondan y luego puedan dar problemas, lo que hacemos es instalar con pip todas las librerías recogidas en el archivo requirements.txt con el siguiente comando.

pip install -r requirements.txt

Este comando se ha de escribir en el directorio donde se encuentre el propio archivo requirements.txt o en caso contrario poner la ruta.
La bandera (flag) -r  significa "instalar desde un archivo de requisitos", y es un atajo para --requirement.

Paso 8. Ejecutar el bot
Lanzamos el bot ejecutando el archivo bot.py. En nuestro caso lo hacemos desde Visual Studio Code.


 Vemos que ahora el bot está corriendo.

Paso 8. Probando el bot
Preguntamos por la cotización del Bitcoin.


Preguntamos por la cotización de Ethereum (ETH) y de Tesla.



Ya tenemos funcionando nuestro bot. Mientras el archivo bot.py esté ejecutándose el bot seguirá funcionando.

¿Cuál es el siguiente reto?
Nos gustaría poder tener el bot corriendo en algún servidor de forma que podamos apagar nuestro PC y el bot continúe ejecutándose.

Ese servidor podría ser una Raspberry Pi que tuviéramos en casa, pero lo ideal es que el servidor fuera externo y gratuito.

Esto se puede lograr si ponemos a correr el bot en replit.com, aunque existe el inconveniente de que si la sesión que tenemos en replit.com no está activa, al cabo de unos minutos, se cierra y nuestro bot dejaría de funcionar. Para conseguir que la sesión no se cierre, podemos recurrir a otra página externa y gratuita que envía peticiones cada cierto número de minutos, programables, que hace que nuestro replit.com con el bot corriendo permanezcan activos, en teoría, de forma indefinida.

Pero esto lo contaremos en otro momento.


Instalar y ejecutar Anaconda en Linux y lanzar Jupyter Notebook
2021-07-09T12:10:00.006+02:00
Estamos en un Linux Mint 20.2 Cimmamon que está basado en Ubuntu, que a su vez pertenece a las distribuciones de tipo Debian. Queremos instalar Anaconda Individual (la versión gratuita) para poder trabajar con Jupyter Notebook. También podríamos trabajar directamente con Jupyter Notebook instalando este y sin necesidad de instalar Anaconda, pero en esta ocasión hemos optado por esta alternativa debido a que Anaconda aporta más de 7.500 ya compilados y preparados para su uso. En ordenadores con poco espacio puede ser interesante instalar Miniconda que usa menos paquetes. 
La ventaja es que podemos usar un manejador de paquetes denominadado conda que incluye algunas ventajas respecto al manejador de paquetes pip que es el tradicional en Python.

Paso 1
Vamos a la página de Anaconda y descargamos la versión Individual (que es gratuita) para sistema operativo Linux.

https://www.anaconda.com/products/individual

Después de la instalación se nos ofrece y a PyCharm Pro que es la versión de pago de un editor de texto especializado en Python. La versión gratuita de este editor se denomina Community que para programar en Python está bastante bien, pero no es adecuada para trabajar con ficheros de Jupyter Notebook, por lo que no la instalaremos, salvo que queramos pagar por la versión Pro. Nuestro flujo de trabajo no utilizará PyCharm.
Paso 2
Seguiremos las ideas básicas del siguiente enlace para la instalación de Anaconda en Linux.

Documentación de Anaconda para instalar en Linux

En nuestro caso el archivo se descargó en la carpeta Downloads con el nombre:

Anaconda3-2021.05-Linux-x86_64.sh

Por ese motivo en la terminal tuvimos que teclear:


bash ~/Downloads/Anaconda3-2021.05-Linux-x86_64.sh


Ver los comentarios de la página anteriormente citada para ver que responder a las preguntas del instalador.

Paso 3
Después de terminada la instalación, en la terminal tecleamos:

source ~/.bashrc

Paso 4
Y para comenzar Jupyter, vamos a la carpeta de nuestro proyecto y tecleamos:

jupyter notebook


Así podremos ver en una pestaña de nuestro navegador web una sesión de localhost con el proyecto de Jupyter Notebook.
Activar y desactivar el entorno virtual
Podemos activar o desactivar el entorno virtual con comando conda.
conda activate

conda deactivate




El Subsistema de Windows para Linux (WSL y WSL2)
2021-07-04T20:16:00.003+02:00
En Windows 10 podemos instalar WSL o mejor WSL2 que nos permitirá disponer de una distribución de Linux ejecutable desde Windows. Por ejemplo, podremos disponer de la terminal de Ubuntu desde Windows 10.
Podemos instalarlo siguiendo este enlace de Microsoft:
Guía de instalación del Subsistema de Windows para Linux para Windows 10
Hay varias distribuciones disponibles, en nuestro caso hemos instalado Ubuntu 20.04 que es una distribución LTS (Long Term Support).
También es recomendable instalar desde la tienda de Windows el programa Windows Terminal que permite tener diferentes terminales en diferentes pestañas. Por ejemplo, podríamos tener en varias pestañas: la terminal de Ubuntu, el cmd de Windows, el Power Shell de Windows, una terminal de la nube de Windows (Azure), entre otras.

Podemos acceder desde Windows a los archivos que tenemos en el home de Ubuntu.
En el Explorador de Windows ponemos la ruta:
\\wsl$\

De esta forma podremos acceder a los archivos que tengamos en Ubuntu. Por ejemplo, podremos editar con NotePad ++ un archivo de Python que tengamos dentro de nuestro repositorio clonado en algún directorio de Ubuntu.
Desde NotePad ++ pedimos abrir el archivo constantes.py que está en la ruta de red:
\\wsl$\Ubuntu-20.04\home\apa\github\pyCourse\jupyter\mypy

En el siguiente ejemplo conseguimos abrir nuestro editor por defecto (Visual Studio Code) para editar un archivo concreto.





Antes de instalar
Se recomienda actualizar y poner al día tu Ubuntu.


sudo apt update -y && supo apt upgrade -y && sudo apt autoremove


Ver nuestra versión instalada y nuestro usuario
Para ver la versión que tenemos instalada.


lsb_release -a


Para ver la versión del Subsistema de Windows para el kernel de Linux con el que estamos trabajando.

uname -r



Para ver los recursos que consume la máquina y los procesos que están corriendo.


htop




Números primos en Flask
2021-06-15T11:41:00.003+02:00
Disponemos de varios métodos para generar números primos en Python y deseamos crear una página web con Flask para mostrarlos.
Los números primos se pueden ver en la siguiente entrada del blog.
Números primos en Python
Elegimos el último método que contiene el código más breve y montamos con él un fichero llamado genera.py.
genera.py
def generaPrimos(n):
 lista=[i for i in range(2,n+1)]
 for i, k in enumerate(lista):
  if i<=int(n**.5):
   for j in lista[i+1:]:
    if j % k == 0:
     lista.remove(j)
 return lista


Creamos el archivo app.py que lanza la aplicación y el servidor Flask.

app.py

from genera import generaPrimos
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def index():
 n=1000
 titulo="Números primos hasta " + '{:,}'.format(n).replace(',', '.')
 return render_template("index.html", titulo=titulo, lista=generaPrimos(n))

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

Veamos la estructura de ficheros.


Los archivos style.css y main.js están vacíos. El archivo favicon.ico es un icono muy pequeñito creado en la siguiente web, aunque pudiera ser cualquier otro fichero de imagen, tipo icono, muy pequeño.

https://www.ionos.es/tools/crear-favicon

Veamos el archivo index.html.

index.html
<!DOCTYPE html>
<html>
 <head>
  <meta charset="utf-8">
  <title>Home</title>
  <link rel="shortcut icon" href="../static/imgs/favicon.ico">
 </head>
 <body>
  <h1>{{ titulo }}</h1>
  <ul>
  {% for value in lista %}
  <li>{{ value }}</li>
  {% endfor %}
  <ul>
 </body>
</html>

Se lanza la aplicación app.py con python y así podremos ver la página en local.






Maquina de Galton en Python
2021-06-13T21:02:00.006+02:00
 Podemos ver una entrada que habla sobre el tema desarrollada en Excel.
Máquina de Galton en Excel
En esta ocasión vamos a crear un procedimiento en Python.
https://github.com/magnitopic/galtonboard
https://replit.com/@valoro/GaltonBoard



import numpy as np
import matplotlib.pyplot as plt
from random import randint
levels = int(input("How many levels do you want?(min 1/ 20 by default) ") or 20)
if levels >= 1:
  lanes = [0]*(levels)
else:
  print("The value of levels can't be lower than 1.")
  exit()
for h in range((levels)**2*100):
  stored = -1
  for j in range(levels):
    stored += randint(0, 1)
  lanes[stored] += 1
print((levels)**2*100, "balls were used in totall")
print(lanes)
X = np.arange(-((len(lanes)/2)-.5), (len(lanes)/2)+.5)
plt.suptitle('Galton Board')
plt.bar(X + 0.00, lanes, width=0.25)
plt.show()
plt.savefig("BellCurve.png")



La clave del algoritmo está en la línea:


stored += randint(0, 1)

Esta línea lo que hace es añadir un 1 o un 0 con una probabilidad de ½. Esto representa lo que hacen las bolas al tropezar con uno de los pivotes, donde pueden ir a la derecha o a la izquierda con una probabilidad del 50%. Si una bola baja 10 niveles y va la derecha en seis ocasiones y a la izquierda en cuatro ocasiones, el valor de la variable stored sería 6.




Hola mundo con Node JS y Express
2021-06-12T11:49:00.002+02:00
Vamos a crear una página web con un sencillo Hello World programado en Node.JS usando el framework Express. Lo podremos ver en local en nuestra página web de localhost.

Paso 1
Instalamos Node.JS e instalamos el gestor de paquetes npm.

sudo apt install nodejs
sudo apt install npm





Paso 2
Vamos a Documents y creamos un par de carpetas, una para los proyectos Node y otra para el proyecto actual de Hola Mundo.

mkdir node && cd $_
mkdir holamundo && cd "$_"

Con $_ repetimos la última parte del comandando anterior.Si esa última parte lleva espacios se debe usar entre comillas "$_".
El operador $_ se puede sustituir por  !#:1

Paso 3
Instalamos el framework Express que nos hará más sencilla la programación en Node.JS.
También vamos a instalar nodemon que nos ayudará a desarrollar puesto que la modificaciones de código que hagamos se irán mostrando automáticamente en la página que estamos creando.


npm init
npm install express
npm install nodemon
Paso 4
Desde la terminal, estando en el directorio holamundo tecleamos code . (el punto es importante) y nos llevará a nuestro editor por defecto, que en nuestro caso es Visual Studio Code.

Estando en Visual Studio Code creamos el archivo index.js




const express = require('express')
const app = express()
const port = 8080

app.get('/', (_req, res) => {
 res.send('Hello World!')
})

app.listen(port, () => {
 console.log(`Example app listening at http://localhost:${port}`)
})
Paso 5
En el archivo package.json se ha creado un archivo JSON con las variables de entorno y otras características de nuestro proyecto. En la parte de Scripts se añade un script llamado dev, pero el nombre lo elegimos nosotros.Se pone una coma y se añade el script.

{
 "name": "helloworld",
 "version": "1.0.0",
 "description": "Esto es un hola mundo",
 "main": "index.js",
 "scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "dev": "nodemon index"
 },
 "author": "apa",
 "license": "ISC",
 "dependencies": {
  "express": "^4.17.1",
  "nodemon": "^2.0.7"
 }
}
  Hemos añadido la línea:
"dev": "nodemon index" 
y hemos añadido también la coma previa a esta línea.
  
  Paso 6
Corremos el proyecto con:



npm run dev
Ya tenemos corriendo el proyecto en local, en localhost.







Flask en PythonAnywhere con despliegue continuo usando GitHub
2021-06-10T21:04:00.014+02:00
Este es el tercer, y ultimo, artículo en una serie de tres que muestran cómo disponer de una aplicación sencilla de Flask en PyuthonAnywhere.
Hola Mundo en PythonAnywhere con Flask
PythonAnywhere subiendo una aplicación Flask desde GitHub
Flask en PythonAnywhere con despliegue continuo usando GitHub ← (es el post en el que estamos)

Cambiando nombres seguiremos los pasos de la entrada:
PythonAnywhere subiendo una aplicación Flask desde GitHub
Lo que haremos en este caso es comenzar con una cuenta nueva en PyhthonAnywhere denominada universo que nos permitirá desplegar la página web:
https://universo.pythonanywhere.com
El objetivo es emplear una cuenta gratuita de PythonAnywhere y desplegar una aplicación web en Flask manteniendo nuestro repositorio en GitHub, usando despliegue continuo.
El flujo de trabajo será el siguiente.
Visual Studio Code (local ) → GitHub  → PythonAnywhere

Referencias
Un artículo de Medium (el código del artículo contiene errores)
Stackoverflow
Paso 1
Vamos a crear un nuevo repositorio en GitHub con un 'Hola mundo' en Flask.
Se llamará flaskanywhere.
https://github.com/financieras/flaskanywhere
Si al crear el repositorio no se indica que se añadirán los ficheros readme, licencia y gitignore, GitHub nos ofrece una pantalla con ayuda para comenzar a trabajar con git. En esa página vemos una serie de instrucciones de git para subir los archivos.

Reproducimos el código sugerido en la imagen anterior.

Crear un nuevo repositorio en la línea de comandos.

echo "# flaskanywhere" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/financieras/flaskanywhere.git
git push -u origin main
Enviar un repositorio existente desde la línea de comandos.

git remote add origin https://github.com/financieras/flaskanywhere.git
git branch -M main
git push -u origin main




Paso 2
Podemos "enviar" (push) nuestro código a GitHub, y luego "tirarlo" (pull) a PythonAnywhere, o enviarlo desde PythonAnywhere hacia GitHub.
En PythonAnywhere, usaremos una Consola Bash y así podremos acceder a git y clonar nuestro repositorio, pudiendo luego hacer push (enviar, empujar) y pull (tirar, traer).
Veamos el código que queremos subir a GitHub.
El archivo se llamará app.py

  
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from flask import Flask, request
from flask.wrappers import Response
import git

app = Flask(__name__)

@app.route('/git_update', methods=['POST'])
def git_update():
  repo = git.Repo('./flaskanywhere')
  origin = repo.remotes.origin
  repo.create_head('main', 
  origin.refs.main).set_tracking_branch(origin.refs.main).checkout()
  origin.pull()
  return '', 200

@app.route('/')
def hello():
  return '<h1>Hello from Flask</h1><p>Continuous Deployment.</p>'


En la línea


  
    repo = git.Repo('./flaskanywhere')
 
  
  
no olvide sustituir flaskanywhere por el nombre de su repositorio.

Crearemos un entorno virtual.

El archivo anterior app.py ha sido creado en VSCode y subido a GitHub. Para ello, cambiando los nombres necesarios, seguiremos los pasos de la entrada:
PythonAnywhere subiendo una aplicación Flask desde GitHub


En PythonAnywhere nuestro nombre de dominio que estaba disponible es universo.

Paso 3
Creamos la cuenta universo en PythonAnywhere.














Activamos el protocolo SSH para tener página https.




Veamos a seleccionar la:
 WSGI configuration file: /var/www/universo_pythonanywhere_com_wsgi.py


Vemos que la ruta (path) está correcta y que el nombre de la aplicación es app.



Clonamos nuestro repositorio desde una terminal Bash, desde PythonAnywhere
git clone https://github.com/financieras/flaskanywhere.git

Cambiamos la ruta Source code añadiendo al final flaskanywhere.

Editamos el archivo:

WSGI configuration file:/var/www/universo_pythonanywhere_com_wsgi.py

para que en la línea 11 contenga la ruta actualizada.

project_home = '/home/universo/flaskanywhere'


Recargamos, pulsando el botón verde, y mostramos la página.



Hagamos un ligero cambio en nuestro código de la aplicación Flask. Pondremos el texto en español.




Pulsando el botón verde de recarga y actualizando la página ya vemos los cambios.


En este momento ya hemos conseguido automatizar el proceso más allá de lo que quedó descrito en el post anterior, ya que gracias al Webhook y al nuevo código del archivo app.py ya hemos conseguido despliegue contínuo.

Ahora nos gustaría que no fuera necesario recargar la página pulsando el botón verde, y que la página se recargara sola al subir los cambios desde nuestro Visual Studio Code.

Recarga automática
En la consola Bash de PythonAnywhere introducimos los siguientes comandos estando en el directorio correspondiente.

En nuestro caso, estamos en flaskanywhere/.git/hooks



  
  
  
  
  cat>post-merge
touch /var/www/universo_pythonanywhere_com_wsgi.py
  
  
  
  

  Después de introducir este código en la consola pulsamos Control+C
  Podemos consultar si se ha creado correctamente el archivo post-merge.

cat post-merge
  
  
  
  
Otra forma de consultarlo consiste en ir a la página de PythonAnywhere y mirar el archivo con post-merge que estará en la ruta que se muestra en la siguiente imagen.



La siguiente imagen muestra los comando introducidos en la consola Bash de PythonAnywhere.


El último comando da permisos de ejecución al archivo creado.


chmod +x post-merge



Finalmente hacemos algún cambio más en en código Flask, en nuestro Visual Studio Code. Se suben los cambios a GitHub y sin necesidad de hacer nada más ya tendremos nuestras modificaciones en la web. Simplemente actualizando la página ya veremos los cambios.



En el artículo de Medium que hemos utilizado también se habla de la seguridad, por si quieres implementarla, si bien, al tratarse de una cuenta gratuita en PythonAnywhere ya existen sistemas que interrumpirán el servicio de la página en caso de sobrepasarse el uso de la CPU.

¿Cuál es el siguiente paso?
Lo siguiente es poder desarrollar páginas web en Flask más complejas usando Templates y usando Jinja2.

Alto Código

Curso de django

Django Shell

Django database models

DB Browser for SWLite

Conectar la APP con el proyecto

Creamos otra clase

Sección DATABASES en settings.py

Organizar mejor las URLs en django usando el método include

mysite/urls.py

myapp/urls.py

Hello World en django

Creación de las vistas

La ruta

Añadiendo una nueva ruta

myapp/views.py

mysite/urls.py

Estructura de una app en django

views.py

__init__.py

migrations

admin.py

apps.py

models.py

tests.py

Creación de Apps en django

Estructura del proyecto django

Archivos y carpetas

Archivo manage.py

Archivo db.sqlite3

Carpeta mysite

Archivo __pycache__

Archivo __init__py©

Archivo settings.py

Variable ALLOWED_HOSTS = []

Propiedad DEBUG = True

Propiedad SECRET_KEY

Variable BASE_DIR = Path(__file__).resolve().parent.parent

Variable INSTALLED_APPS

Variable MIDDLEWARE

Variable TEMPLATES

Variable WSGI_APPLICATION

Variable DATABASES

Variable AUTH_PASSWORD_VALIDATORS

Variable STATIC_URL

Archivo urls.py

Archivos asgi.py y wsgi.py

Comenzando con django

Instalación de django en Ubuntu

Paso 1. Actualiza tu sistema

Paso 2. Actualiza Python3

Primero

Segundo

Tercero

Cuarto

Quinto

Sexto

Séptimo

Octavo

Octavo. Punto 1

Octavo. Punto 2

Paso 3. Crea un nuevo directorio para tu proyecto

Paso 4. Comprueba la versión de Python 3 que tienes instalada en tu sistema.

Paso 5. Crea un entorno virtual

Paso 6. Activa el entorno virtual

Paso 7. Actualiza a la última versión de Python3

Paso 8. Ver la versión de Python dentro del entorno virtual

Paso 9. Desactivar el entorno virtual

Usar Visual Studio Code

Extensiones

Seleccionar el intérprete de Python

Instalar django

Instalación

Comprobar si está instalado

Método 1

Método 2

Método 3

Crear un proyecto con django

Cambiar el puerto del servidor

Factorial con recursividad en Python

init.py

Archivo `manage.py`

Archivo `db.sqlite3`

Carpeta `mysite`

Archivo `pycache`

Archivo `initpy©`

Archivo `settings.py`

Variable `ALLOWED_HOSTS = []`

Propiedad `DEBUG = True`

Propiedad `SECRET_KEY`

Variable `BASE_DIR = Path(file).resolve().parent.parent`

Variable `INSTALLED_APPS`

Variable `MIDDLEWARE`

Variable `TEMPLATES`

Variable `WSGI_APPLICATION`

Variable `DATABASES`

Variable `AUTH_PASSWORD_VALIDATORS`

Variable `STATIC_URL`

Archivo `urls.py`

Archivos `asgi.py` y `wsgi.py`