Apuntes De Python

1
2
3

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

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#-------------------
# 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

1
2
3
4
5

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

1
2
3
4
5
6

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

1
2
3
4

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

1
2
3
4
5
6
7
8
9

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

1
2
3
4
5
6
7

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

1
2

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

1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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
}

1
2
3
4
5
6

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

1
2
3
4
5
6
7

    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

1

y = x[::-1]

1
2
3
4
5
6
7

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))

1
2
3
4
5
6
7
8

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))

1
2
3
4

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

1

mkvirtualenv tkinter

1
2
3
4

#!/usr/bin/env python

import tkinter
tkinter._test()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#!/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()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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()

1
2
3
4
5

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)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#!/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()

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

#!/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()

1
2
3
4
5
6
7
8

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()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

1
2

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

1
2
3
4
5
6
7
8

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

1
2
3
4
5

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#!/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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

#!/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()))}')

1
2
3

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

1

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

1

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

1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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

1
2
3
4
5

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

1
2
3
4

import time

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

1
2
3

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

1
2
3
4
5

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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)

1
2
3
4
5
6
7
8

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

1
2
3
4
5
6

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

'''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])

1
2
3
4
5
6
7
8
9

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

1
2
3
4
5
6
7
8
9

from flask import Flask
server = Flask(__name__)

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

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

1

Flask==2.1.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 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" ]