comacero_apuntes

77 KiB

Raw Blame History

weight

title

date

draft

summary

Gestores de paquetes

pip: El gestor de paquetes por defecto de python
pipx: Un instalador pensado para aplicaciones CLI en Python, se encarga de instalar cada aplicación en un virtualenv independiente.; Cosas instaladas con pipx en mi sistema son por ejemplo: pypisearch, ranger o kikit; Los virtualenv creados por pipx quedan en ~/.local/pipx/venvs
conda: El instalador de las distribuciones Anaconda y Miniconda

Gestores de entornos virtuales

En cualquier distribución de Linux disponemos de un Python del Sistema, es el Python que viene instalado por defecto con el S.O. (podemos averiguar cual es ejecutando: which python y/o python -V) En mi caso concreto, usando Linux Mint el Python del sistema es el 2.7.18. Una versión anticuada, pero que es mejor no tocar ya que habrá partes del sistema operativo que dependan de ella.

Podemos tener más versiones de Python instaladas en nuestro S.O. (yo ahora mismo tengo disponibles python3, python3.8 y python3.9) pero solo una de ellas es el Python del Sistema, el Python que se ejecuta por defecto.

Instalar paquetes de Python en el Python del Sistema no es nada recomendable. Si instalamos versiones incompatibles de paquetes o actualizamos versiones instaladas podemos perturbar el funcionamiento de alguna parte del propio sistema operativo. Desinstalar paquetes en Python siempre es una aventura (a menudo imposible) así que si tenemos problemas la solución puede ser extremadamente complicada (a mi ya me tocó reinstalar Linux entero por enredar sin saber).

{{< admonition type=tip title="Módulos Python que si que instalo" open=true >}} Hay algunos paquetes, como veremos en el siguiente punto, que si que nos conviene tenerlos siempre instalados. Son justo los que nos facilitan la gestión de los virtualenvs, como por ejemplo venv, virtualenv o pipx. {{< /admonition >}}

Además de todo lo anterior es muy probable que la versión del Python del Sistema no sea la versión que queremos usar con nuestro proyecto. O podemos estar interesados en usar varias versiones diferentes de Python, ya sea para desarrollo o para ejecutar distintas aplicaciones.

Un gestor de entorno python nos permitirá:

Instalar python en un entorno aislado
Instalar multiples versiones de python; cada una en su propio entorno, de forma que no interfieran entre si
Instalar distintas combinaciones de paquetes
Cambiar de versión de python sin más que cambiar de entorno

virtualenv y virtualenvwrapper

virtualenv es probablemente la herramienta más básica para crear entornos virtuales para Python y virtualenvwrapper es un frontend que facilita mucho su uso.

La idea es muy simple, se crea una instalación de Python independiente en un directorio dedicado y se modifica el PATH para que ese Python sea prioritario.

virtualenvwrapper centraliza todos los entornos virtuales (es decir los directorios con los distintos python), en un único directorio de entornos (especificado con $WORKON_HOME)

En el Python 3 que viene con mi Linux Mint yo instalo:

sudo apt install python-all-dev
sudo apt install python3-all-dev
sudo apt install virtualenv virtualenvwrapper python3-virtualenv

En el fichero ~/.profile añadimos:

# WORKON_HOME for virtualenvwrapper
if [ -d "$HOME/.virtualenvs" ] ; then
WORKON_HOME="$HOME/.virtualenvs"
fi

Además en zsh uso el bundle virtualenvwrapper y tengo parcheado el prompt del tema del zsh y el prompt del zsh-git-prompt (Ver dotfiles) para visualizar en el prompt el entorno virtual activo (si hay alguno activado claro)

Este bundle de zsh también se encarga de activar automáticamente el entorno virtual si cambiamos a un directorio de proyecto con el mismo nombre (se considera directorio de proyecto si está controlado por git). Aunque también hay formas de asociar un directorio de proyecto al crear un entorno virtual, como veremos.

#-------------------
# virtualenv
virtualenv <nombreEntorno>   # Crea el entorno como un directorio en el
                             # directorio donde lo hemos invocado (es típico llamarlo .env)
source env/bin/activate      # Activar el entorno
deactivate                   # desactivar el entorno


#-------------------
# virtualenvwrapper
mkvirtualenv -p /usr/bin/python3  <nombreEntorno>                  # Crear un entorno virtual y activarlo
mkvirtualenv -p /usr/bin/python3  -a <dirPry> <nombreEntorno>      # Crear un entorno virtual y asociar el directorio de proyecto
deactivate                                                         # Salir del entorno virtual
lsvirtualenv                                                       # ver la lista de entornos virtuales
workon <nombreEntorno>                                             # activar un entorno ya definido
rmvirtualenv <nombreEntorno>                                       # borrar un entorno virtual
cpvirtualenv <origen> <destino>                                    # copiar un entorno virtual
lssitepackages                                                     # listar paquetes instalados en el entorno activo

pyenv

No confundir con pyenv con pyvenv

pyenv es mucho más potente que virtualenv y además podemos integrar tanto virtualenv como virtualenvwrapper con pyenv.

Mi ciclo de trabajo con pyenv:

Instalar versiones de Python en mi máquina con pyenv
Crear entornos virtuales basados en esas versiones, con el plugin virtualenv de pyenv
Asignar los entornos virtuales a proyectos (normalmente con pyenv local <entorno>

Instalamos las dependencias en el sistema:

sudo apt-get update
sudo apt-get install --no-install-recommends make build-essential \
libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev \
wget curl llvm libncurses5-dev xz-utils tk-dev \
libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev

Y a continuación instalamos el pyenv-bundle en Antigen, añadiendo la linea:

antigen bundle mattberther/zsh-pyenv

a nuestro fichero ~/.zshrc

La instalación que hace el plugin de zsh es muy completa, instala pyenv con todos los plugins.

Evidentemente este método de instalación solo vale si usas zsh, aquí tienes una alternativa (que no he probado) o puedes currarte una instalación siguiendo las instrucciones oficiales en el github del proyecto pyenv

zsh-pyenv se encargará de la instalación de pyenv

Tenemos que asegurarnos de dejar configurada la activación de pyenv en nuestros fichero .profile y .zshrc (o .bashrc)

En ~/.profile añadimos las siguientes lineas (las lineas comentadas se dejan como referencia por que ya lo configura el plugin de zsh):

# pyenv
if [ -d "$HOME/.pyenv" ] ; then
    export PYENV_ROOT="$HOME/.pyenv"
#    export PATH="$PYENV_ROOT/bin:$PATH"
#    eval "$(pyenv init --path)"
fi

En ~/.zshrc no debería ser necesario añadir nada por que se supone que el plugin de oh-my-zsh se encarga de activar todo pyenv, pero en mi instalación el autocompletado de comandos de pyenv solo funciona si añado este código:

# pyenv activation
if command -v pyenv 1>/dev/null 2>&1; then
  eval "$(pyenv init -)"
fi

Si quieres echar un ojo a las versiones de Python que puedes instalar en tu sistema ejecuta pyenv install --list (hay 490 versiones en el momento de escribir esto)

pyenv commands                            # La lista de comandos disponibles (¡son muchos!)
pyenv <cmd> --help                        # Ayuda para un comando
pyenv install --list                      # Versiones de python disponibles
pyenv versions                            # Versiones de python instaladas en nuestro sistema

pyenv global <version>                    # Establece la version de python global
pyenv local <version>                     # Establece la versión de python local
pyenv shell <version>                     # Establece la versión para el shell
pyenv virtualenv <version> <env_name>     # Crea un entorno virtual basado en la versión especificada

pyenv global

Me he creado un entorno virtual para usar como pyenv global:

Creamos un entorno basado en la versión oficial de Python más reciente (3.9.6 al escribir esto)
En el nuevo entorno instalamos las últimas versiones de pip, setuptools, pipx, virtualenv y virtualenvwrapper

pyenv virtualenv 3.9.6 ve_sys39
pyenv which python
/home/salvari/.pyenv/versions/ve_sys39/bin/python
pip install --upgrade pip
pip install --upgrade setuptools
pip install --upgrade pipx
pip install --upgrade virtualenv virtualenvwrapper

Parece que los plugins pyenv y virtualenvwrapper de oh-my-zsh no son compatibles. El plugin de oh-my-zsh para virtualenvwrapper intenta activar el virtualenvwrapper haciendo un source virtualenvwrapper.sh, pero ahora tenemos un shimm que intercepta la llamada y no funciona correctamente, de hecho aborta el terminal.

No parece aconsejable activar simultaneamente los dos plugins así que el plugin de virtualenvwrapper queda desactivado en el fichero .zshrc {{< /admonition >}}

Para poder activar el virtualenvwrapper correctamente via el shimm, añadimos el siguiente alias:

# virtualenvwrapper activation
alias myvw='source `pyenv which virtualenvwrapper.sh`'

Esto funcionará correctamente siempre y cuando en el python activo tengamos instalado virtualenvwrapper claro está.

pyenv y emacs

Referencias

Una referencia muy completa Getting started with lsp-mode for Python

En Emacs usamos [LSP]^(Language Server Protocol). Para Python necesitamos instalar python-lsp-server Mucho ojo, no hay que instalar Palantir (python-language-server), que se considera obsoleta.

Con el siguiente comando instalamos en nuestro Python activo (por ejemplo el Python global) el servidor pylsp y todos sus providers (ver el github del proyecto)

pip install 'python-lsp-server[all]'

Si queremos que nuestro editor Emacs edite código Python a plena potencia necesitaremos instalar este paquete en el Python activo del proyecto en el que trabajemos.

Para simplificar la creación de nuevos entornos creamos el alias myve que podemos invocar una vez creado nuestro nuevo entorno virtual para instalar los paquetes mínimos:

myve(){
	if [ `pyenv which python` = "/usr/bin/python" ]
	then
		echo "This is main python. Abort installation"
	else
		echo "OK, looks like you are in some venv"
		pip install --upgrade pip setuptools wheel pipx virtualenv virtualenvwrapper
		pip install 'python-lsp-server[all]'
	fi
}

pyenv y conda

Ojo, por que los entornos virtuales de Anaconda y Miniconda parece que hay que crearlos con conda para que funcionen bien. (ver artículo).

Supongamos que tenemos instalada la versión anaconda3-2021.11. Ejecutaríamos:

pyenv shell anaconda3-2021.11
conda info -e
conda create -n py4web_env python=3.7
conda info -e
# Con esto hemos creado un virtualenv basado en Python 3.7 con conda, podemos activarlo con pyenv
pyenv activate anaconda3-2021.11/envs/py4web_env

pyenv y poetry

PENDIENTE DE MIRAR

pyenv y pip-tools

PENDIENTE DE MIRAR

Instalando paquetes en Python

Muy importante leerse el tutorial oficial Installing Packages

Instalando un paquete desde el shell de python

Modulos en Python

Todos los lenguajes de programación modernos soportan la programación modular. Cualquier programa minimamente complicado hace uso de "módulos" que encapsulan diferentes funcionalidades.

En Python cualquier fichero con código Python puede considerarse un módulo. Podríamos acceder a cualquier código de cualquier fichero mediante un import (hay muchas formas de hacer el import)

Por ejemplo si en un programa hacemos un import math podremos acceder a los simbolos (math.pi) o funciones (math.sin(math.pi/2)) definidos en ese módulo desde nuestro código (usando el prefijo del módulo que es math. en este ejemplo)

Diferentes tipos de import

Packages (Paquetes)

El siguiente nivel de modularidad en Python es el package. Cuando una aplicación o biblioteca se complica y empieza a tener un gran número de módulos podemos organizarlos en paquetes (package)

Basicamente un package es un directorio en el que dejamos módulos (ficheros con código Python) pero cumpliendo ciertas condiciones.

Exceptions in python

    try:
        dom_rq = MD.parse(os.path.join(d, 'request_{}.xml'.format(t)))
        dom_rs = MD.parse(os.path.join(d, 'response_{}.xml'.format(t)))
    except Exception as e:
        print('ERROR in some xml file {}'.format(e))
        print(sys.exc_info()[0])
        return None

Reverse string in Python

y = x[::-1]

Minidom

Acceder a un atributo

req_hotel_avail = dom_rq.getElementsByTagNameNS('*', 'OTA_HotelAvailRQ')
    if(req_hotel_avail):
        try:
            test = req_hotel_avail[0].getAttribute('xmlns')
            print(test)
        except Exception as e:
            print('Error {}'.format(e))

Acceder a la lista de atributos

req_hotel_avail = dom_rq.getElementsByTagNameNS('*', 'OTA_HotelAvailRQ')

    if(req_hotel_avail):
        try:
            test = req_hotel_avail[0].attributes.items()
            print(test)
        except Exception as e:
            print('Error {}'.format(e))

tkinter

tkinter (Tk interface) es una biblioteca de Python para usar el Tcl/Tk GUI Toolkit. Un conjunto de herramientas clásico para desarrollar interfaces gráficos de usuario, y que está disponible en practicamente todas las distribuciones de *nix, incluyendo macOS, también hay disponibles versiones para Windows.

Es bastante probable que tkinter esté incluido en tu Python de sistema (el python que venga por defecto en tu Linux), o que se haya instalado como dependencia de otros programas de tu Linux lo puedes probar rápidamente sin más que ejecutar desde el terminal:

python
>>> import tkinter
>>> tkinter._test()
>>>

Deberías ver una ventana gráfica con la versión de Tcl/Tk (en mi linux es la 8.6) y un par de botones de demostración (con el botón Quit terminas el programa de demo)

En el caso de que no esté instalado te fallará el import, si lo quieres instalar en el python de sistema en Debian y derivadas el comando debería ser algo parecido al siguiente comando, que es el que hay que ejecutar en Ubuntu y derivadas:

sudo apt install python3-tk

Aprendiendo tkinter

Creamos un virtualenv:

mkvirtualenv tkinter

Probamos que todo va bien

#!/usr/bin/env python

import tkinter
tkinter._test()

Vamos a echar un ojo a un programa completo

#!/usr/bin/env python

# Importamos tkinter entero en nuestro espacio
# Opcionalmente podriamos hacer
# import tkinter as tk
from tkinter import *
from tkinter import ttk   # Esta linea importa el submodulo ttk,
                          # un conjunto de widgets incorporado en 8.5


def calculate(*args):
    try:
        value = float(feet.get())
        meters.set(int(0.3048 * value * 10000.0 + 0.5) / 10000.0)
    except ValueError:
        pass

# Creamos la ventana raiz y le ponemos un título
root = Tk()
root.title("Feet to Meters")

# Creamos un 'frame' para el contenido,
# esto es importante para usar widgets de un tema
# grid, columnconfigure y rowconfigure determinan
# el comportamiento cuando se cambia el tamaño de
# la pantalla

mainframe = ttk.Frame(root, padding="3 3 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)

# Creamos un widget de tipo 'Entry' que será hijo de 'mainframe'
# o sea está dentro del marco principal

feet = StringVar()
feet_entry = ttk.Entry(mainframe, width=7, textvariable=feet)
feet_entry.grid(column=2, row=1, sticky=(W, E))

meters = StringVar()
ttk.Label(mainframe, textvariable=meters).grid(column=2, row=2, sticky=(W, E))

ttk.Button(mainframe, text="Calculate", command=calculate).grid(column=3,
                                                                row=3,
                                                                sticky=W)

ttk.Label(mainframe, text="feet").grid(column=3, row=1, sticky=W)
ttk.Label(mainframe, text="is equivalent to").grid(column=1, row=2, sticky=E)
ttk.Label(mainframe, text="meters").grid(column=3, row=2, sticky=W)

for child in mainframe.winfo_children():
    child.grid_configure(padx=5, pady=5)

feet_entry.focus()
root.bind("<Return>", calculate)

root.mainloop()

Lo mismito pero con OOP

from tkinter import *
from tkinter import ttk

class FeetToMeters:

    def __init__(self, root):

        root.title("Feet to Meters")

        mainframe = ttk.Frame(root, padding="3 3 12 12")
        mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
        root.columnconfigure(0, weight=1)
        root.rowconfigure(0, weight=1)

        self.feet = StringVar()
        feet_entry = ttk.Entry(mainframe, width=7, textvariable=self.feet)
        feet_entry.grid(column=2, row=1, sticky=(W, E))
        self.meters = StringVar()

        ttk.Label(mainframe, textvariable=self.meters).grid(column=2, row=2, sticky=(W, E))
        ttk.Button(mainframe, text="Calculate", command=self.calculate).grid(column=3, row=3, sticky=W)

        ttk.Label(mainframe, text="feet").grid(column=3, row=1, sticky=W)
        ttk.Label(mainframe, text="is equivalent to").grid(column=1, row=2, sticky=E)
        ttk.Label(mainframe, text="meters").grid(column=3, row=2, sticky=W)

        for child in mainframe.winfo_children():
            child.grid_configure(padx=5, pady=5)

        feet_entry.focus()
        root.bind("<Return>", self.calculate)

    def calculate(self, *args):
        try:
            value = float(self.feet.get())
            self.meters.set(int(0.3048 * value * 10000.0 + 0.5)/10000.0)
        except ValueError:
            pass

root = Tk()
FeetToMeters(root)
root.mainloop()

widgets

Todos los widgets tienen un padre (excepto la ventana root)
Todos los widgets son de alguna clase Widget roundup
Las opciones de un widget controlan su comportamiento (incluida su visualización) Evidentemente dependen también de cual es su clase. Se intenta que los nombres de los atributos sean consistentes entre clases.
Puedes ver toda la configuración de un widget con button.configure()
Puedes cambiar una opción con button['text']=newvalue o con button.configure(text=newvalue)

Con este programilla podemos ver toda la jerarquía de widgets

def print_hierarchy(w, depth=0):
    print('  '*depth + w.winfo_class() + ' w=' + str(w.winfo_width()) + ' h=' + str(w.winfo_height()) + ' x=' + str(w.winfo_x()) + ' y=' + str(w.winfo_y()))
    for i in w.winfo_children():
        print_hierarchy(i, depth+1)
print_hierarchy(root)

Gestión de la geometría

grid es más moderno que pack usa grid

Event handling

Los eventos son tratados por el event handling loop que no debe ser bloqueado.

Las cosas interesantes se consiguen asociando command callbacks a eventos

from tkinter import *
from tkinter import ttk
root = Tk()
l =ttk.Label(root, text="Starting...")
l.grid()
l.bind('<Enter>', lambda e: l.configure(text='Moved mouse inside'))
l.bind('<Leave>', lambda e: l.configure(text='Moved mouse outside'))
l.bind('<ButtonPress-1>', lambda e: l.configure(text='Clicked left mouse button'))
l.bind('<3>', lambda e: l.configure(text='Clicked right mouse button'))
l.bind('<Double-1>', lambda e: l.configure(text='Double clicked'))
l.bind('<B3-Motion>', lambda e: l.configure(text='right button drag to %d,%d' % (e.x, e.y)))
root.mainloop()

Ejemplos

Un campo entrada de texto

#!/usr/bin/env python

import tkinter as tk  # Lo importamos con un alias para que quede claro que es de tk
from tkinter import ttk  # Esta linea importa el submodulo ttk, un conjunto de widgets incorporado en 8.5
'''Imprime el valor de la entrada de texto. Y lo muestra en una etiqueta'''


class App():
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("Práctica 2.2")
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)

        self.frm_root = ttk.Frame(self.root, padding="3 3 12 12")
        self.frm_root.grid(column=0, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        self.frm_entry = ttk.Frame(self.frm_root,
                                   borderwidth=2,
                                   relief='sunken',
                                   padding="3 3 12 12")
        self.frm_entry.grid(column=0, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        self.var_entry = tk.StringVar()
        self.ent_text = ttk.Entry(self.frm_entry, textvariable=self.var_entry)
        self.ent_text.grid(column=0, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        self.frm_label = ttk.Frame(self.frm_root,
                                   borderwidth=2,
                                   relief='sunken',
                                   padding="3 3 12 12")
        self.frm_label.grid(column=0, row=1, sticky=(tk.N, tk.W, tk.E, tk.S))

        self.lbl_showEntry = ttk.Label(self.frm_label,
                                       text="No hay valor leido")
        self.lbl_showEntry.grid(column=0,
                                row=0,
                                sticky=(tk.N, tk.W, tk.E, tk.S))

        self.frm_button = ttk.Frame(self.frm_root, padding="3 3 12 12")
        self.frm_button.grid(column=1, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        self.but_show = ttk.Button(self.frm_button,
                                   text="Print entry",
                                   command=lambda: self.update_print())
        self.but_show.grid(column=0, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        self.root.mainloop()

    def update_print(self):
        print(self.var_entry.get())
        self.lbl_showEntry['text'] = f"Valor leido: {self.var_entry.get()}"


app = App()

Checkbuttons

#!/usr/bin/env python

import tkinter as tk  # Lo importamos con un alias para que quede claro que es de tk
from tkinter import ttk  # Esta linea importa el submodulo ttk, un conjunto de widgets incorporado en 8.5
'''Imprime el valor de la entrada de texto. Y lo muestra en una etiqueta'''


class App():
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("Práctica 2.3")
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)

        # Creamos el frame ppal en la ventana root
        self.frm_root = ttk.Frame(self.root, padding="3 3 12 12")
        self.frm_root.grid(column=0, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        # Creamos un frame para los checks dentro del frm_root
        self.frm_checks = ttk.Frame(self.frm_root, padding="3 3 12 12")
        self.frm_checks.grid(column=0, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        # Creamos cuatro checks con sus variables para almacenar estado
        # Les metemos algo de padding para que no queden apelotonados
        self.var_check1 = tk.IntVar(value=0)

        self.chk_check1 = ttk.Checkbutton(self.frm_checks,
                                          text='Check 1',
                                          variable=self.var_check1,
                                          padding="3 3 12 12",
                                          command=self.update_chk1)

        self.var_check2 = tk.IntVar(value=0)
        self.chk_check2 = ttk.Checkbutton(self.frm_checks,
                                          text='Check 2',
                                          variable=self.var_check2,
                                          padding="3 3 12 12",
                                          command=self.update_chk2)
        self.var_check3 = tk.IntVar()
        self.chk_check3 = ttk.Checkbutton(self.frm_checks,
                                          text='Check 3',
                                          variable=self.var_check3,
                                          padding="3 3 12 12",
                                          command=self.update_chk3)
        self.var_check4 = tk.IntVar()
        self.chk_check4 = ttk.Checkbutton(self.frm_checks,
                                          text='Check 4',
                                          variable=self.var_check4,
                                          padding="3 3 12 12",
                                          command=self.update_chk4)
        # Colocamos los checks en su frame
        self.chk_check1.grid(column=0, row=0)
        self.chk_check2.grid(column=0, row=1)
        self.chk_check3.grid(column=1, row=0)
        self.chk_check4.grid(column=1, row=1)

        # Creamos un frame para el botón
        self.frm_button = ttk.Frame(self.frm_root, padding="3 3 12 12")
        self.frm_button.grid(column=1, row=0, sticky=(tk.N, tk.W, tk.E, tk.S))

        # Creamos el boton y lo colocamos
        self.btn_readChecks = ttk.Button(self.frm_button,
                                         text="Read checks",
                                         command=lambda: self.update_status())
        self.btn_readChecks.grid(column=0, row=0)

        # Vamos a crear un par de frames más para eventos y para status
        # En vez de usar Frame usamos LabelFrame para presumir

        self.frm_events = ttk.LabelFrame(self.frm_root,
                                         padding="3 3 12 12",
                                         text='Events')
        self.frm_status = ttk.LabelFrame(self.frm_root,
                                         padding="3 3 12 12",
                                         text='Status')

        # Y los colocamos en su sitio
        self.frm_events.grid(column=0, row=1)
        self.frm_status.grid(column=1, row=1)

        # Y por ultimo los mensajes de eventos y de status
        self.lbl_events = ttk.Label(self.frm_events, text="Sin eventos")
        self.lbl_status = ttk.Label(self.frm_status, text="Sin status")

        # Los colocamos como siempre
        self.lbl_events.grid(column=0, row=0)
        self.lbl_status.grid(column=0, row=0)

        # Last but not less lanzamos el bucle para atender a todos los eventos
        self.root.mainloop()

    # Lo que sigue son los métodos que actualizan las etiquetas de eventos
    # y status, lo de tener cuatro métodos iguales queda feo, pero no da tiempo a mas
    def update_chk1(self):
        if (self.var_check1.get()):
            self.lbl_events['text'] = 'Set check1'
        else:
            self.lbl_events['text'] = 'Unset check1'

    def update_chk2(self):
        if (self.var_check2.get()):
            self.lbl_events['text'] = 'Set check2'
        else:
            self.lbl_events['text'] = 'Unset check2'

    def update_chk3(self):
        if (self.var_check3.get()):
            self.lbl_events['text'] = 'Set check3'
        else:
            self.lbl_events['text'] = 'Unset check3'

    def update_chk4(self):
        if (self.var_check4.get()):
            self.lbl_events['text'] = 'Set check4'
        else:
            self.lbl_events['text'] = 'Unset check4'

    def update_status(self):
        self.lbl_status[
            'text'] = f"Check1 = {self.var_check1.get()} Check2 = {self.var_check2.get()} \
Check3 = {self.var_check3.get()} Check4 = {self.var_check4.get()}"


app = App()

Estudio

Create http server

Comparte los ficheros de la carpeta

import os
from http.server import HTTPServer, CGIHTTPRequestHandler
# Make sure the server is created at current directory
os.chdir('.')
# Create server object listening the port 80
server_object = HTTPServer(server_address=('', 80), RequestHandlerClass=CGIHTTPRequestHandler)
# Start the web server
server_object.serve_forever()

Decorators

Static method vs Classmethod

Referencias

Python3 OOP (realpython)

Curso de Python

Info do curso

Sabados 11.00 - 13.00 horas

@caligari (é mais de práctica)
@salvari (é mais de teoría)

Estructura do curso

Teoría e práctica
Práctica "de deberes"
Preguntas dúbidas e tertulia

Dinámica do curso:

Non se graba
Non hai transparencias, o profe teórico é un vago (tamén intenta ser presumido e impaciente)
Apuntes colaborativos
Iremos incorporando ao libro exemplos e notas que vexamos útiles

Bricolabs

Documentación do curso

Gitlab de Ekaitz: https://gitlab.com/ElenQ/Publishing/python/-/tree/master/es
Tradución ao galego (coordinador: Rafa Gaioso Melisa)
https://pad.disroot.org/p/curso_python_memoria.md

Outros enlaces de interese

Itinerario formativo con ou sen mentorización: https://exercism.io/tracks/python

Apuntes sesión 01

Algo de Historia

Fai 30 anos... a explosión dos intérpretes:

Perl

Larry Wall (1987)

Killer app:

CGI perlcgi integrado no código de Apache.

Linguaxe pegamento para sysadmins

Perl Template Toolkit

Python

Guido Van Rosum (1991) Benevolent Dictator for Life (https://en.wikipedia.org/wiki/Benevolent_dictator_for_life), un título moi usado no mundo hacker e inventado para Guido

Killer app:

Zope, Plone, Django, Calibre, Web2py

Integración con Gimp, con KiCAD, con FreeCAD, con ....

Big Data, iPython (agora Jupyter), Machine Learning, Deep Learning

PHP

Rasmus Lerdorf (1995)

Killer app:

Wordpress

Milleiros de aplicacións web

Ruby

Matz Matsumoto (1995)

Killer app:

Ruby on rails

Pouco coñecido en occidente pero super implantado en Asia

Las tres virtudes del programador

(según Larry Wall, creador do Perl)

Pereza: "La virtud que te hace esforzarte para reducir tu gasto global de energía. Hace que escribas programas que te ahorran trabajo y te hace documentar esos programas para que no tener que contestar preguntas acerca de como funcionan."
Impaciencia: "El ansia que sientes cuando el ordenador remolonea. Esto hace que escribas programas que no sólo satisfacen tus necesidades si no que se anticipan a ellas. O al menos lo intentan."
Orgullo: "La virtud que te hace escribir (y mantener) programas intachables, de los que el resto de la gente no pueda hablar mal."

O lema de Perl: TIMTOWTDI "There is more than one way to do it", ou sexa, hai moitas formas de facelo (e ademais eso mola moito)

A resposta de Python (e decir, de Guido, que é colega de Larry)

"There should be one — and preferably only one — obvious way to do it." Normalmente hai unha forma obvia e óptima de facelo (é iso mola moito mais de cara a manter o software)

Qué é python?

Linguaxe de programación
Interpretado non compilado

Pros

Simplicidade
Versatilidade facilidade de uso e desenrolo rápido
Software libre e aberto, cunha comunidade moi activa
Un conxunto de bibliotecas enorme e super completo
Excelente para prototipos (código compacto)

Limitacións o Desventaxas do Python

Limitacións de velocidade (é interpretado e iso sempre penaliza a velocidade)
Problemas có Threading (estou empezando a programar, non me importa)
Non ten implantación destacable en dispositivos móbiles: Android e IOS (pero mira Kivy se estás moi interesado neste campo)

Pingas de Python:

Terminal vitaminado para python: bpython3 ou ptpython
Axuda interactiva: help('string')
Saber ruta do intérprete en linux: which python ou which python3
Script, empeza coa línea shebang, para decirlle que intérprete usar
```
#!/ruta al intérprete
```
Ou tamén
```
#!/usr/bin/env python3
```
Ver "posición da memoria" (en realidade id devolve un identificativo único) da variable
```
hex(id(a))
```
saber o tipo dunha variable: type(variable)

Mutabilidad:

A tupla e inmutable
A lista e mutable

Estilo de programación

Readability counts (the zen of python)
El código se lee mucho más a menudo de lo que se escribe
Reglas de estilo pep8
Reglas de docstring (los comentarios de documentación) pep257

Tipos de datos

TIPOS
        |
        |- Numéricos
        |            |- Enteros (int)
        |            |- Coma flotante (float)
        |            |- Complejos
        |
        |- Texto
        |
        |- Booleanos
                    |- True (Verdadero)
                    |- Falso (Falso)

Operadores

OPERADORES
        |
        |- Aritméticos
        |        |- Suma                                 +
        |        |- Resta                                 -
        |        |- Multiplicación                     *
        |        |- División                              /
        |        |- División entera                  //
        |        |- Módulo                             %
        |        |- Exponente                        **
        |
        |- Comparación
        |        |- Igual que                         ==
        |        |- Diferente que                   !=
        |        |- Mayor que                         >
        |        |- Menor que                         <
        |        |- Mayor o igual que            =>
        |        |- Menor o igual que            <=
        |
        |- Lógicos
        |        |- AND                                AND
        |        |- OR                                  OR
        |        |- NOT                                NOT
        |
        |- Asignación
        |        |- Igual                                =
        |        |- Incremento                        +=
        |        |- ?                                        *=
        |        |- ?                                        /=
        |        |- ?                                        %=
        |        |- ?                                        **=
        |        |- ?                                        //=
        |
        |- Especiales
                |- IS                                        IS
                |- IS NOT                                IS NOT
                |- IN                                        IN
                |- NOT IN                                NOT IN

Apuntes sesión 02

Bucle for

El bucle for clásico se puede conseguir facilmente con la función range()

for i in range(10):
  print(i)

En los bucles for y while se pueden usar las palabras clave continue, break y else:

for i in (iterable):
    .
    .
    .
    continue             # salta inmediatamente al siguiente bucle for
    .
    .
    break                # interrumpe el bucle for y sale de el
  else:
      # Este bloque de ordenes se ejecuta si el for
      # se completa sin ejecutar el break

OJO El else para bucles es una de las características más controvertidas de Python, el propio Guido dijo que nunca debió incluirla en la especificación del lenguaje, o al menos que se debió usar otra palabra que no fuera else

Para un while sería lo mismo

while(condicion):
    .
    .
    .
    continue             # salta al comienzo del siguiente bucle
    .
    .
    break                 # interrumpe el while y sale del bucle
    else:
        # Este bloque se ejecuta siempre que
        # la condición del while sea falsa
        # y no salgamos del mismo con break

Las sentencias de tratamiento de excepciones también tiene else y además una clausula finally

try:
    x = 1
except:
    print('Hay un erro, no se puede asignar x')
else:
    print('No hay excepciones')
finally:
    print('Siempre imprimimos esto')

Apuntes sesión 03

Sábado, 18/04/2020 Exercism

Neste enlace tedes a páxina de exercism, onde vos podedes dar de alta (opcional) para facer o track de Python.

https://exercism.io/tracks/python/exercises

Se vos dades de alta en exercism, veredes que hai instruccións para instalar un cliente de linea (de linea de comandos) que permite descargar os exercicios e subir as solucións. E moi doado de instalar non vos preocupedes. (Guía de instalación)

Lembrade traballar en un entorno virtual, se queredes instalar o módulo pytest que suxiren en exercism, facedeo dentro do voso virtualenv, poderíades facer algo como:

mkdir curso
cd curso
python3 -m venv .venv
source .venv/bin/activate
pip install pytest

Lembrade o comentado no curso, agora estamos escribindo "Baby Python", non vos preocupedes do estilo ou se o facedes ben ou mal, o importante é que funcione.

O voso python mellorará coa práctica e lendo código de outros.

Lembrade tamén que haberá bibliotecas para facer todo tipo de cousas, é imposible coñecelas todas. Có tempo coñeceredes as que usedes mais frecuentemente, pero non serán moitas. Sempre hai que apoiarse na documentación a través de internet.

Solución exercicio 1 (Adiviña o número)

#!/usr/bin/env python

from random import randint

sigue_xogando = True

def es_valida(entrada):

    try:
        x = int(entrada)
    except ValueError as e:
        print('Tes que introducir un número enteiro entre o 1 e o 100')
        return False
    except Exception as e:
        print('Erro descoñecido, contacta co autor do programa')
        return False

    if (x > 100 or x < 1):
        print('Error, o número está fora do rango de 1 a 100')
        return False

    return True

# Aquí empeza o programa principal


while sigue_xogando:
    mi_numero = randint(1, 100)
    intentos = 0

    finalizado = False
    while not finalizado:
        suposicion = input('Dime un número: ')
        if (es_valida(suposicion)):
            intentos += 1
            if (mi_numero > int(suposicion)):
                print('O meu número e maior, Proba outra vez')
            elif (mi_numero < int(suposicion)):
                print('O meu número e menor. Proba outra vez')
            else:
                print('Acertaches!. O meu número é: ' + str(mi_numero))
                print('E só necesitaches {} intentos'.format(intentos))
                finalizado = True

    outra_vez = input('Queres xogar outra vez) [s/n]')
    if (outra_vez in ['N', 'n']):
        sigue_xogando = False

Solución exercicio 2: Simular tiradas de dados

#!/usr/bin/env python

from sys import (argv, exit)
from random import randint

max_stars = 40

usage = '''Uso:
dados.py numtiradas [dados]

- numtiradas Parámetro obligatorio
             É o número de tiradas a simular, ten que ser un enteiro positivo.

- dados Parámetro opcional
        E o número de dados que imos usar, ten que ser un enteiro maior que 2
'''


def check_parameters():
    dados = 2

    if (not (len(argv) in [2, 3])):
        raise SystemExit(usage)

    try:
        tiradas = int(argv[1])
        if (len(argv) == 3):
            dados = int(argv[2])
    except ValueError as e:
        raise SystemExit(usage)
    except Exception as e:
        print(type(e))
        raise SystemExit(usage)

    return (tiradas, dados)


# -------------------- main --------------------

tiradas, dados = check_parameters()

# print('Simulando {} tiradas de {} dados'.format(tiradas, dados))
print(f'Simulando {tiradas} tiradas de {dados} dados')


results = {i: 0 for i in range(dados, (6 * dados) + 1)}

for i in range(tiradas):
    result = 0
    for i in range(dados):
        result += randint(1, 6)
    results[result] += 1

padd = len(str(max(results.values())))
for i in sorted(results):
    print(
        f'{i:02}: [{str(results[i]).zfill(padd)}] {"*" * int(results[i] * max_stars / max(results.values()))}')

Apuntes sesión 04

Módulo: Escritos normalmente para ser importados
Script: Escritos normalmente para ser ejecutados desde la linea de comandos
Programa: Seguramente compuesto por varios módulos

Importar módulos

import M                 # Hay que usar M.func para acceder a una f importada
from M import f          # No tenemos que calificar f para usarla
from M import (f, g, h)  # Podemos importar varios objetos del módulo al mismo tiempo

Scopes (LEGB)

Estrictamente hablando Python recorre los siguientes scopes cuando busca un símbolo

Local: Nombres asignados dentro de una función (también aplica a lambdas) y que no se preceden con la palabra clave global
Enclosing-function: Nombres asignados dentro de cualquier función padre en una cadena de funciones anidadas. De dentro hacia fuera e incluye lambdas
Global (a nivel de módulo): Nombres asignados en el nivel superior de un modulo (fichero) de python. O asignados dentro de una función pero precedidos de la palabra clave global
Built-in (Python): Nombre preasignados en el built-in por el intérprete de Python. P.ej: open, range, SyntaxError, etc

global y nonlocal

Algunos namespaces:

Global
Módulos
Clases
Generadores
Función

Utilizar .get para crear un contador cuando no has definido el número inicial del parámetro que quieres contar:

.get(loquesea, 0) : Devuelve lo que sea si existe, y si no, devuelve 0.

palabrainterna

Apuntes sesión 05

Flujo de programa

lambdas

Son funciones "telegráficas" que se usan a veces para acortar el código.

En general las lambdas deberían ser de un solo uso, y en casos muy particulares donde necesitamos una función muy simple (casí siempre como parámetro para otra función o una list comprehension

Si te encuentras peleando para implementar una lambda compleja, es casi seguro que deberías dejarlo y emplear una función normal.

Parámetros de funciones

Tenemos que distinguir entre dos escenarios: antes de Python 3.8 y después de Python 3.8.

Hasta ahora teníamos:

Aquí tenemos una funcíon definida con tres parámetros, uno de ellos (c) con un valor por defecto

Al llamar la función c es opcional puesto que tiene valor por defecto

Cualquier parámetro lo podemos pasar por posición, pero todos los posicionales tienen que ir desde el principio. En cuanto pasemos un parámetro por nombre ya no podemos añadir ninguno posicional.

Cualquier parámetro lo podemos pasar también por nombre, siempre dejando los posicionales (si los hay) al principio en su lugar. En cuanto pasemos un parámetro por nombre ya no podemos añadir ninguno posicional.

def fn (a, b, c = 1):          # a y b obligatorios, c opcional ya que
    return a * b + c           # tiene valor por defecto.

print(fn(1, 2))                # devuelve 3, a y b son posicionales
print(fn(1, 2, 3))             # devuelve 5, a, b y c son posicionales
print(fn(c = 5, b = 2, a = 2)) # devuelve 9, pasamos todos "con nombre"
print(fn(b = 2, a = 2))        # devuelve 5, pasamos a y b con nombre
print(fn(5, c = 2, b = 1))     # devuelve 7, a es posicional, b y c con
                               # nombre
print(fn(8, b = 0))            # devuelve 1, a es posicional,
                               # b lo pasamos con nombre y c toma el valor
                               # por defecto

Si definimos la función como

def fn(a, b, c = 0, *args):

Sigue en pie la regla de que TODOS los parámetros posicionales tienen que ir al principio. Podemos pasar todos los parámetros posicionales que queramos, los tres primeros se asignan a: a, b y c respectivamente el resto se capturan en la tupla args. Por convención se emplea la tupla llamada args. Podríamos emplear cualquier otro nombre para la tupla, pero dificultaríamos la inteligibilidad del código por parte de otros programadores.

def fn(a, b, **kargs):

Esta función admite dos párametros posicionales, el resto de parámetros adicionales tienen que ser con nombre y quedan capturados en el diccionario kargs

def fn(a, b, *args, **kargs)

Esta función admite dos o mas parámetros posicionales, los dos primeros se asignan a a y b, el resto se capturan en la tupla args. También podemos meter todos los parámetros que queramos con nombre, se capturan en el diccionario kargs

Desde Python versión 3.8 además tenemos dos separadores de paramétros / y *

En el caso de que usemos los separadores:

A la izquierda de / son parámetros posicionales puros, no se puede llamarlos por nombre
A la derecha de * son parámetros por nombre obligatoriamente
Lo que va en el medio de los dos simbolos, pueden ser usados posicionalmente o por nombre

def f(a=2, /)  # Parámetro posicional opcional
               #
`def f(a, /)`  # Parámetro posicional, obligatorio
               #
def f(*, a=1)  # Parámetro por nombre, opcional

def f(*, a)    # Parámetro por nombre, obligatorio

def f(a=1)     # Podemos pasar el parámetro por posición o por nombre y
               # además es opcional

def f(a)       # Podemos pasar el parámetro por posición o por nombre y
               # es obligatorio

OJO: ¡No usar parámetros mutables en la definicion de las funciones!

Algunos ejemplos de paso de parámetros con valor por defecto:

Con valor por defecto inmutable. No tiene problemas.

def banner(message, border='-')
    line = border * len(message)
    print(line)
    print(message)
    print(line)

Con un valor que varía a lo largo de la ejecución del programa (problema: no va a variar)

Pasamos como parámetro por defecto la hora actual, pero la llamada a ctime solo se ejecuta una vez al inicio del intérprete de python, no cada vez que llamamos a la función

import time

def show_default(arg=time.ctime())
    print(arg)

Pasamos como parámetro un valor mutable (muy mala idea, no lo hagais)

Pasamos como valor por defecto la lista vacía, en la práctica pasar un valor por defecto equivale a crear un closure, la función mantiene su contexto a lo largo del ciclo de vida del programa con una referencia al valor por defecto del parámetro alist (que es una lista y por tanto mutable)

Cada vez que llamamos a la función sin parámetros la función añade una nueva cadena 'uno' a la lista almacenada en el closure como "valor por defecto de alist"

Si pasamos un parámetro, la cosa cambia, python crea una nueva lista en memoria y asigna la referencia a esa lista como parámetro de la función, con lo cual se ejecuta como esperamos. Al terminar la referencia a esa lista que pasámos como parámetro no se almacena en el closure de la función y si no hay otras referencias a ella en el programa será reclamada por el garbage colector.

def return_list(alist=[]):
    alist.append('uno')
    return(alist)

Solución al problema anterior (probada)

def return_list(alist=None):
    if alist is None:
        alist = []
    alist.append('uno')
    return(alist)

Funciones pasadas como parámetros. Composición de funciones:

def is_even(value):
"""Return True if *value* is even."""
    return (value % 2) == 0

def count_occurrences(target_list, predicate):
    """Return the number of times applying the callable *predicate* to a
    list element returns True."""
    return sum([1 for e in target_list if predicate(e)])

my_predicate = is_even
my_list = [2, 4, 6, 7, 9, 11]
result = count_occurrences(my_list, my_predicate)
print(result)

Funciones anidadas:

def parent():
    print("Printing from the parent() function")
    a = 'uno'
    def first_child():
        a = 'dos'
        print("Printing from the first_child() function")

    def second_child():
        print("Printing from the second_child() function")
        b = 'dos'

    print(b)
    second_child()
    first_child()

Funciones anidadas y paso de funciones como parámetro

def surround_with(surrounding):
    """Return a function that takes a single argument and."""
    def surround_with_value(word):
        return '{}{}{}'.format(surrounding, word, surrounding)
    return surround_with_value

def transform_words(content, targets, transform):
    """Return a string based on *content* but with each occurrence
    of words in *targets* replaced with
    the result of applying *transform* to it."""
    result = ''
    for word in content.split():
        if word in targets:
            result += ' {}'.format(transform(word))
        else:
            result += ' {}'.format(word)
    return result

markdown_string = 'My name is Jeff Knupp and I like Python but I do not own a Python'
markdown_string_italicized = transform_words(markdown_string,
                                ['Python', 'Jeff'],
                                surround_with('*'))
print(markdown_string_italicized)

Closures (o cierres)

Los closures son funciones que mantienen un "entorno" en el que "recuerdan" variables. En el ejemplo de abajo

def create_incrementer_function(increment):
     def incrementer (val):
         # Recuerda que esta función puede ver el valor `increment` por
         # por haber nacido en un contexto superior (en su func. padre)
         return val + increment
    return incrementer
increment5 = create_incrementer(5)
print(increment5(3))     # Imprimirá 8 por la pantalla

Decoradores

def my_decorator(func):
    def wrapper(*args, **kargs):
        print("Something is happening before the function is called.")
        func(*args, **kargs)
        print("Something is happening after the function is called.")
    return wrapper

OOP - Programación orientada a objetos

La programación orientada a objetos se basa en cuatro principios básicos

Encapsulado
Abstracción
Herencia
Polimorfismo

Código de la sesión 06:

'''OOP sample code'''
class Flight:
    '''A flight with a particular aircraft'''

    def __init__(self, number, aircraft):
        if not number[:2].isalpha():
            raise ValueError(f'No airline code in {number}')
        if not number[:2].isupper():
            raise ValueError(f'Invalid airline code in {number}')
        if not (number[2:].isdigit() and int(number[2:]) <= 9999):
            raise ValueError(f'Invalid route number in {number}')
        self._number = number
        self._aircraft = aircraft
        rows, seats = self._aircraft.seating_plan()
        self._seating = [None] \
            + [{letter: None for letter in seats} for _ in rows]
    def number(self):
        return(self._number)
    def airline(self):
        return self._number[:2]
    def aircraft_model(self):
        return self._aircraft.model()
    def allocate_seat(self, seat, passenger):
        '''Allocates a seat for a passenger
        Args:
            seat: A seat designator such as '12C' or '21F'
            passenger: The passenger name
        Raises ValueError if seat is unavailable
        '''
        rows, seat_letters = self._aircraft.seating_plan()
        letter = seat[-1]
        if letter not in seat_letters:
            raise ValueError(f'Invalid seat letter: {letter}')
        row_text = seat[:-1]
        try:
            row = int(row_text)
        except ValueError:
            raise ValueError(f'Invalid seat row: {row_text}')
        if row not in rows:
            raise ValueError(f'Invalid row number: {row}')
        if self._seating[row][letter] is not None:
            raise ValueError(f'Seat {seat} already occupied')
        self._seating[row][letter] = passenger
class Aircraft:
    def __init__(self, registration, model, num_rows, num_seats_per_row):
        """Models an aircraft
        """
        self._registration = registration
        self._model = model
        self._num_rows = num_rows
        self._num_seats_per_row = num_seats_per_row
    def registration(self):
        '''Returns aircraft registration code
        '''
        return self._registration
    def model(self):
        '''Returns aircraft model
        '''
        return self._model
    def seating_plan(self):
        '''Returns seating plan for aircraft, as a tuple of rows numbers
        (range) and seats letters (list)'''
        return (range(1, self._num_rows + 1),
                "ABCDEFGHJK"[:self._num_seats_per_row])

Docker y Python

Podemos usar Docker para tener proyecto aislados en sus contenedores. Esto nos puede simplificar la vida a la hora de gestionar dependencias, versiones de Python o distintas configuraciones.

Containers

Vamos a crear un contenedor con una aplicación muy chorras. Para crear nuestro contenedor suponemos que creamos el directorio app en alguna parte de nuestro sistema de ficheros.

mkdir -p  app/src
touch app/{requirements.txt,dockerfile}
touch app/src/server.py
tree app
app
├── dockerfile
├── requirements.txt
└── src
    └── server.py

El contenido del fichero server.py tendría esta pinta:

from flask import Flask
server = Flask(__name__)

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

if __name__ == "__main__":
   server.run(host='0.0.0.0')

Como requisito necesitamos tener Flask instalado así que en requirements.txt tedremos

Flask==2.1.0

Ahora vamos a definir como se construye la imagen Docker con nuestro dockerfile:

# set base image (host OS)
FROM python:3.10.9

# set the working directory in the container
WORKDIR /code

# copy the dependencies file to the working directory
COPY requirements.txt .

# install dependencies
RUN pip install -r requirements.txt

# copy the content of the local src directory to the working directory
COPY src/ .

# command to run on container start
CMD [ "python", "./server.py" ]

Nuestro dockerfile:

parte de la imagen oficial para Python 3.10.9
define el directorio de trabajo /code (en el contenedor)
copia el fichero requirements.txt desde el host (nuestro ordenador) al directorio de trabajo del contenedor
copia el directorio src/ al directorio de trabajo del contenedor
define el comando de arranque de los contenedores basados en esta imagen como python ./server.py

Ya podemos construir nuestra imagen con el comando: docker build -t myimage . Y una vez construida (ver con docker images) podemos crear contenedores a partir de esta imagen:

# Launch container mapping port 5000 in host
docker run -d -p 5000:5000 myimage

# Launch container and open terminal
docker run -it myimage /bin/bash

Optimizando la construcción de imágenes Docker

Imagen Base: Por supuesto conviene usar siempre imágenes oficiales; La imagen que escojamos como base determina muchas de las propiedades de la imagen final. Generalmente hay opciones para construir imágenes ligeras (casi siempre basadas en Alpine Linux) Para Python podemos buscar las imágenes oficiales de tipo slim, por ejemplo python:3.10.9-slim
Orden de instrucciones en el dockerfile: Para acelerar las operaciones de recontrucción de imágenes, que serán muy frecuentes durante el desarrollo, Docker implementa mecanismos de caché. Para aprovechar esta funcionalidad es muy importante que dejemos las opciones más estables (que tengan menos cambios a lo largo del desarrollo) al principio del dockerfile. Por ejemplo nuestro dockerfile de ejemplo pone al principio los comandos de instalación de dependencias y despues copia los fuentes. Como las dependencias no cambiarán tan frecuentemente como el código fuente de nuestro proyecto se podran aprovechar las imágenes de la caché.
Construcción de imágenes por etapas: Esta técnica se usa más bien para preparar las imágenes para distribución, no en la fase de desarrollo. Por ejemplo veamos como contruir nuestra aplicación y preparar una imagen ligera para distribución:

# first stage
FROM python:3.10.9 AS builder
COPY requirements.txt .

# install dependencies to the local user directory (eg. /root/.local)
RUN pip install --user -r requirements.txt

# second unnamed stage
FROM python:3.10.9-slim
WORKDIR /code

# copy only the dependencies installation from the 1st stage image
COPY --from=builder /root/.local /root/.local
COPY ./src .

# update PATH environment variable
ENV PATH=/root/.local:$PATH

CMD [ "python", "./server.py" ]

Comprobar estas referencias y completar

Varios experimentos con interfaces de usuario

Tkinter

PySimpleGUI

NiceGUI

Textual

Miscelanea

Soluciones de exercism

Pistas para el ejercicio 'matrix'

Una matriz o array en python se puede representar como una 'lista de listas'

Asi la matriz

1 2 3 4 5 6 7 8 9

Podría representarse como una lista de python que almacenase una lista por cada fila

my_array = [
            [1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]
           ]

El método clásico de transponer (que las filas se conviertan en columnas) una matriz en python era:

my_array_in_rows = [
                    [1, 2],
                    [3, 4],
                    [5, 6]
                   ]
my_array_in_cols = list(map(list, zip(*my_array_in_rows)))

Que no es muy intuitivo ¬_¬

Pero en python moderno con las list comprehension podemos escribir:

elem_by_row = len(array_in_rows[0])
my_array_in_cols = [[linea[i] for linea in my_array_in_rows] for i in range(elem_by_row)]

Hemos supuesto que el array está "bien formado", es decir que todas las filas tienen el mismo número de elementos, asi que para calcular cuantos elementos hay por fila nos vale la logitud de cualquier fila (lo calculamos con la fila cero)

La 'comprehension' externa recorre los índices de los elementos de una fila (serían los números de columna) y para cada número de columna devuelve otra 'comprehension' (que llamaremos interna)

La 'comprehension' interna devuelve una lista formada por el elemento i-ésimo de cada linea del array, (es decir, los elementos de la columna i-ésima.

en nuestro ejemplo el contenido de my_array_in_cols, al final sería

[
 [1, 3, 5],
 [2, 4, 6]
]

Jupyter (antes conocido como iPython)

Por descontado, hay que instalarlo en un virtualenv

python3 -m venv venv-jupyter
pip install jupyter

En la sesión del curso instalamos tambien seaborn para ver gráficos:

# Asegurate de tener activo el virtualenv antes de instalar
pip install seaborn
pip install statsmodels

Expresiones Regulares en Python

Un par de páginas web (hay muchísimas) para probar nuestras expresiones regulares

Un buen recurso para aprender expresiones regulares con varias versiones, entre ellas castellano

https://github.com/ziishaned/learn-regex/blob/master/translations/README-es.md

Un muy buen tutorial de expresiones regulares en python:

Parte I https://realpython.com/regex-python/
Parte II https://realpython.com/regex-python-part-2/

Algunas librerias y frameworks interesantes

argparse

# -------------------- main --------------------
# Parse command line options
arg_parser = argparse.ArgumentParser(
    description='Process files from input dir. Writes results in output dir')
arg_parser.add_argument(
    '-i', '--idir', help='Input directory', required=True)
arg_parser.add_argument(
    '-o', '--odir', help='Output directory', required=True)

args = arg_parser.parse_args()

# Check directories
if not (os.path.isdir(args.idir)):
    print('Input dir <{}> is not a valid directory'.format(args.idir))
    exit()

if not (os.path.isdir(args.odir)):
    print('Output dir <{}> is not a valid directory'.format(args.odir))
    exit()

Toga https://toga.readthedocs.io/en/latest/ para hacer GUI (interfaces de usuario)
Kivy https://kivy.org/#home Interfaces de usuario, dispositivos móviles
Dash https://dash.plotly.com/ Para hacer cuadros de mandos, se basa en plotly que a su vez se basa en d3.js. Pese a la apariencia de la página web, es software libre con licencia MIT

Frameworks Web

Flask

El más simple de los frameworks, siempre es bueno dedicarle algún tiempo para ver los conceptos básicos. Se puede hacer cualquier aplicación web con Flask, pero los frameworks más potentes nos ahorrarán mucho trabajo.

Sigue siendo imbatible para aplicaciones sencillas

Un buen tutorial de Flask: El mega tutorial de Flask. Son 23 capitulos publicados en la web.

web2py

Un framework más potente que Flask y más sencillo que Django

El libro oficial de web2py (hay versión en español)

El capítulo 3 del libro es un buen punto de partida para autoformación

Un buen tutorial de web2py, son siete videos de unos 20 minutos cada uno:

Server Side programming with web2py
Los videos de Maximo di Pierro (el creador de web2py) un curso de 30 videos super-completo Aseguraos de empezar por el primer video (hay que ir hacia atrás en el historial del usuario) El primero sería este
Una guia (sin terminar) que puede valer para instalar web2py es esta

celery

Una cola de tareas para Python.

Una cola de tareas sirve para distribuir el trabajo en threads (hilos de ejecución concurrente) o entre distintas máquinas.

Las entradas para la cola de tareas son unidades de trabajo denominadas tareas (tasks). Trabajadores (workers) dedicados monitorizan la cola constantemente y ejecutan las tareas encoladas.

Celery se comunica mediante mensajes, normalmente usando un broker que hace de mediador entre clientes y workers. Los clientes (clients) ofertan tareas enviando mensajes a la cola. El broker facilita que esos mensajes lleguen a los workers.

Así pues un sistema Celery se compone de múltiples workers y brokers, lo que permite obtener alta disponibilidad y sistemas fáciles de escalar horizontalmente.

Celery está escrito en Python pero se ha hecho tan popular que se puede usar desde varios lenguajes de programación.

Celery necesita un broker para funcionar, tanto RabittMQ como Redis ofrecen soluciones completamente funcionales pero Celery soporta muchos más.

Adicionalmente podemos instalar un sistema que actúe como almacén de resultados (results store). Celery soporta muchos diferentes.

Montando un escenario sencillo con Celery

Lanzamos un RabittMQ dockerizado:

docker run -d -p 5672:5672 rabbitmq

Creamos nuestro entorno virtual como de costumbre e instalamos Celery

cd <pry_dir>
pyenv virtualenv 3.9.7 ve_celery
pyenv local ve_celery
myve
pip install celery

Creamos un fichero tasks.py:

from celery import Celery

app = Celery('tasks', broker='pyamqp://guest@localhost//')

@app.task
def add(x, y):
    return x + y

Con esto podríamos ya lanzar nuestro primer worker ejecutando el comando: celery -A tasks worker --loglevel=INFO

Esto nos vale para probar, en un entorno de producción nos interesa lanzar los workers como servicio (ver Daemonization)

Ahora podríamos abrir una sesión con el intérprete de Python y lanzar una tarea al worker con

from tasks import add
add.delay(4, 4)

Django

Como de costumber creamos un entorno virtual:

pyenv virtualenv 3.9.7 ve_django
myve
pip install Django

Creamos un directorio para las pruebas y le asignamos el virtualenv local.

amd Django
pyenv local ve_django

Para empezar hacemos el tuto oficial

python -m django version nos permite ver la versión de Django (la 4.0.5)
django-admin startproject mysite nos permite crear un nuevo directorio de proyecto con su estructura característica
python manage.py runserver ejecuta el server, en nuestro caso vale con ./manage.py runserver
python manage.py runserver 8000 ejecuta el server en el puerto 8000
python manage.py runserver 0:8000 ejecuta el server en el puerto 8000 en todas las IP del servidor
python manage.py startapp polls crea el directorio para la aplicación polls, las aplicaciones se crean todas en el mismo directorio donde reside el manage.py

views en Django

Para crear una vista:

definimos una función en el fichero views.py de nuestra aplicación
en el fichero urls.py de nuestra aplicación, asociamos la función a un path
en el fichero urls.py de nuestro site, tenemos que incluir el módulo polls.urls que se corresponde con el fichero polls/urls.py, para hacer esto siempre usamos include (from django.urls import include, path)

La funcion path tiene cuatro parámetros:

route: es un string que contiene un patrón para urls. Cuando Django recibe una petición (request) Django recorrerá todos los patrones de la lista urlpatterns hasta encontrar una que encaje. Al hacer esta búsqueda se busca solo el path no se comprueba el dominio que aparece en la petición ni el tipo (GET o POST) ni los parámetros.
view: cuando Django encuentra el patrón que encaja se invoca a la función view asociada a ese patrón, pasando el objeto HttpRequest y cualquier otro valor que haya sido capturado
kwargs: se pueden pasar parámetros adicionales en un diccionario
name: siempre es práctico asignar un nombre a las URL para poder referirnos a ellas desde cualquier parte

Establecer la base de datos

En el fichero mysite/settings.py es un módulo de Python normal y corriente que almacena distintos valores de configuración de Django en variables.

Por defecto tenemos configurado usar SQLite3 como motor de base de datos. Si queremos usar otra de las bases de datos soportadas tenemos que instalar el backend correspondiente (ver doc)

Si usamos SQLite3 en el parámetro NAME especificamos el fichero de la base de datos SQLite3

Una vez establecida la base de datos podemos empezar a definir nuestros modelos (models), básicamente son las tablas de la base de dawos con sus metadatos.

Los modelos se definen en el fichero polls/models.py, cada tabla en la base de datos se corresponde con una clase en el fichero.

Cuando tenemos los modelos definidos necesitamos ejecutar dos pasos adicionales:

Dar de alta nuestra app en el fichero mysite/settings.py
Activar los modelos, con la operación que en Django se denomina Migración. Las migraciones quedan codificadas en ficheros python en el directorio migrationsde la aplicación correspondiente.

Comandos:

python manage.py makemigrations polls prepara las migraciones y las deja listas para ejecutarse en el directorio migrations de la aplicación correspondiente.
python manage.py sqlmigrate polls 0001 nos dice que comandos sql corresponden a la migración. Son los comandos que se ejecutarán en la base de datos cuando ejecutemos la migración.
python manage.py check hace comprobaciones sin ejecutar la aplicación
python manage.py migrate ejecuta la migración (de hecho ejecuta todas las que haya pendientes)
python manage.py shell nos abre un shell para hacer experimentos

Django admin

python manage.py createsuperuser nos permite crear un usuario administrador para nuestra instancia de Django, podemos acceder al interfaz de administración en la dirección http://127.0.0.1:8000/admin/

Para que nuestra applicación sea accesible desde el interfaz de administración de Django, es necesario modificar el fichero polls/admin.py para que incluya las siguientes lineas:

from django.contrib import admin

from .models import Question

admin.site.register(Question)

Nuevas vistas

Para generar nuevas vistas:

Definimos la nueva función en el fichero polls/views.py
Añadimos las nuevas url a los urlpatterns definidos en el fichero polls/urls.py

Cada vista tiene que lograr uno de dos objetivos: o bien genera un HttpResponse válido o bien devuelve una excepción como por ejemplo Http404

A parte de eso la vista puede hacer todo tipo de cosas. Leer registros de una base de datos, generar ficheros de cualquier tipo, usar el sistema de Templates de Django, etc etc.

Bibliografía

El libro de Ekaitz que hemos "seguido" en este curso
La traducción al gallego del mismo libro, elaborada por asistentes al curso
El libro del Dr. Chuck. Los cursos de este hombre en Coursera se podían seguir como oyente de forma gratuita y están muy bien para empezar. En todo caso aquí tenéis un libro suyo (disponible en castellano)

Batiburrillo de enlaces

Para mais adiante:

Problemas instalando Kivy o Pygame:

En esta página en el web oficial, parece que se detallan las dependencias de kivy.
Para instalar pygame o kivy parece que hay dependencias con sdl2 En esta otra página explican como instalar pygame en python 3.8

No se vayan todavía...

77 KiB Raw Blame History

Gestores de paquetes

Gestores de entornos virtuales

virtualenv y virtualenvwrapper

pyenv

pyenv global

pyenv y emacs

pyenv y conda

pyenv y poetry

pyenv y pip-tools

Instalando paquetes en Python

Instalando un paquete desde el shell de python

Modulos en Python

Diferentes tipos de import

Packages (Paquetes)

Exceptions in python

Reverse string in Python

Minidom

tkinter

Aprendiendo tkinter

widgets

Gestión de la geometría

Event handling

Ejemplos

Un campo entrada de texto

Checkbuttons

Estudio

Create http server

Decorators

Static method vs Classmethod

Referencias

Curso de Python

Info do curso

Bricolabs

Documentación do curso

Outros enlaces de interese

Apuntes sesión 01

Las tres virtudes del programador

Estilo de programación

Tipos de datos

Operadores

Apuntes sesión 02

Bucle for

Apuntes sesión 03

Apuntes sesión 04

Importar módulos

Scopes (LEGB)

Apuntes sesión 05

Flujo de programa

lambdas

Parámetros de funciones

Funciones pasadas como parámetros. Composición de funciones:

Funciones anidadas:

Funciones anidadas y paso de funciones como parámetro

Closures (o cierres)

Decoradores

OOP - Programación orientada a objetos

Docker y Python

Containers

Optimizando la construcción de imágenes Docker

Varios experimentos con interfaces de usuario

Tkinter

PySimpleGUI

NiceGUI

Textual

Miscelanea

Soluciones de exercism

Jupyter (antes conocido como iPython)

Expresiones Regulares en Python

Algunas librerias y frameworks interesantes

argparse

Frameworks Web

celery

Montando un escenario sencillo con Celery

Django

views en Django

Establecer la base de datos

Django admin

Nuevas vistas

Bibliografía

77 KiB

Raw Blame History