Para no programadores
David García Garzón
Introducir el lenguaje de programación Python a personas del ET que no hayan programado nunca
Dos sesiones estilo manos a la obra (hands-on)
Meta: Leer una hoja de cálculo, procesarla y generar un informe con cara y ojos
Los ejemplos de la presentación los podeis copiar en vuestros ordenadores de la versión on-line
Programamos para decirle al ordenador qué hacer
El ordenador solo entiende código máquina:
01000111001… binario ininteligible para humanos
…para casi todos
(El resto) usamos lenguajes intermedios
para comunicarnos con la máquina
Los lenguajes de programación nos abstraen de la máquina para concentrarnos en el problema,
y, así, llegar más lejos:
¿Cómo se pasa de Código fuente a Código máquina?
Compilador
Traductor de libros
Genera un ejecutable
Se ejecuta el binario, sin código ni compilador
C, C++, Java, Pascal…
Intérprete
Traducción simultanea
Ejecuta mientras interpreta
Necesitas interprete y código para ejecutar
Python, Perl, Bash, PHP…
Es muy fácil de aprender
No te limita cuando quieres crecer
No (solo) para jugar: ciencia, negocios…
Hay librerías para todo
Mucha comunidad
Se llama así por los Monty Python
Tiene huevos de pascua…
Lenguaje: Tutorial oficial
Librería estandard: Referencia
Librerías no estándards: Repositorio
Tened los enlaces a mano para consulta
Disclaimer: todo en inglés
Linux
Windows
Intérprete interactivo: ipython3
Ideal para pruebas rápidas
Completa o explora con el tabulador
Recupera la historia con el cursor arriba
Cuando el código se complica,
mejor meterlo en un fichero (script)
Se ejecuta:
# Despues de la almohadilla son comentarios, los ignora
print("Hola Mundo") # Una sentencia por línia
print("Hola caracola")
# Sentencias con ':' empiezan subsentencias indentadas
if True:
print("Primera subsentencia")
print("Segunda subsentencia")
print("Esta ya esta fuera")
if True:
if False:
print("Dentro del if False")
print("Dentro del if True")
# Los signos que abren y cierran permiten partir líneas
print(
"Hola mundo"
)
# A muy malas con la contrabarra al final de línea
print \
("Hola mundo")
# Punto y coma para juntar dos sentencias
print("Marco"); print("Polo")
# Tambien podemos poner en una ĺínia las subsentencias
if True: print("subsentencia rápida")
Las sentencias más simples, se evalúan
Usemos ipython3
como calculadora
4
, 5
y 9
son literales
Los literales representan datos directos
El +
es un operador
Como en mates:
Exponenciación
Multiplicaciones y divisiones
Sumas y restas
Paréntesis para romperlo
Variable: nombre que referencia un valor
Mantiene valores para usarlos después
Porfa, no uses nombres tontos a
, b
…
Usa nombres que expliquen la variable
como consumoEnKwh
.
Lower Case: todojuntosinseparar
Camel Case: mayusculasAlInicioDePalabra
Underscore: separadas_con_subrayados
Sirven para actualizar el valor de una variable operando el valor original.
Script para calcular la factura de una 2.0A
Arriba los valores de entrada en variables
Pon a las variables nombres decentes
consumoEnKwh
, precioPorKwDia
…
Ves calculando poco a poco valores intermedios
Haz un print
del importe final.
>>> max(30,500) # le pasamos dos parámetros, retorna un valor
500
>>> min(30,500) + 4 # usamos el valor retornado en una expresión
34
>>> min(max(30,400),100) # el resultado de una como parametro
30
>>> round(30.3262342, 2) # redondea a 2 decimales
30.33
round
, max
y min
son funciones built-in
Podemos importar otras funciones de librerias
o definir las nuestras
>>> -12 # un número entero (int)
-12
>>> 12.34 # un número con decimales (float)
12.34
>>> 2+3j # un número complejo (complex)
(2+3j)
>>> 'un texto' # un texto (str)
'un texto'
>>> None # el no-objeto (NoneType), el intérprete ni lo imprime
>>> True # un valor lógico (bool), su antitesis es False
True
>>> 12, 23 # una tupla (tuple) con dos enteros
(12, 23)
>>> [1, 2, 3, 1] # una lista (list) con 4 enteros
[1, 2, 3, 1]
>>> {1, 2, 3, 1} # un conjunto (set) con 4... ops, 3 enteros
{1, 2, 3}
>>> # un diccionario (dict) 2 con parejas clave: valor
>>> { 'David': 40, 'Aitor': 25 }
{ 'David': 40, 'Aitor': 25 }
course = {
"name": "Python for non-programers",
"sessions": [
{
"name": "Session 01: Basics",
"teacher": "David",
"durationMinutes": 120,
"content": [
"Programming: the Python interpreter",
"Calculator, managing numbers",
"Data types",
"Managing strings",
]
},
{
"name": "Session 01: Tooling",
...
}
],
}
str
# Varios delimitadores, útil si contiene comillas
print('Comillas simples')
print("Comillas dobles")
print'''Triples comillas simples''') # Para texto multilínia
print("""Triples comillas dobles""")
# Útiles si el texto tiene comillas
print('Me dijo: "Adios" y se fue')
print("Castellar de N'Hug")
# Tambien podemos escapar con la contrabarra
print('Usando la contrabarra para \'escapar\' la comilla')
# Carácteres especiales indicados con contrabarra y una letra
print("Primera linia\nSegunda linia") # Salto de linia \n
print("Primer campo\tSegundo campo") # Tabulador \t
print("La contra barra: \\") # Contrabarra se escapa a si misma
Ojo, indicando ficheros en Windows:
>>> a[2:6] # de la tercera (2) a la sexta letra (5)
'rcie'
>>> a[:6] # Si no ponemos el inicio se deduce desde el principio
'murcie'
>>> a[2:] # si no pones el final se deduce que hasta el fin
'rcielago'
>>> a[:] # copia entera
'murcielago'
>>> a[:5] + a[5:] # ¿porque el índice 5 no esta repetido?
'murcielago'
El índice final no se incluye
>>> s = 'abracadabra'
>>> s.count('bra') # Cuantas veces contiene el parámetro
2
>>> 'abrete sesamo'.capitalize() # primera letra mayúscula
'Abrete sesamo'
>>> 'abrete sesamo'.title() # iniciales en mayúsculas
'Abrete Sesamo'
>>> s.upper() # todo a mayusculas
'ABRACADABRA'
>>> 'AbRaCaDaBra'.lower() # todo a minúsculas
'abracadabra'
>>> s.replace('a', 'o')
'obrocodobro'
>>> s.replace('ab', 'XXX')
'XXXracadXXXra'
Textos y listas, ambos son secuencias de cosas.
Comparten algunas operaciones.
Ejercicio: Prueba en el interactivo:
>>> 'abracadabra'.split('a')
['', 'br', 'c', 'd', 'br', '']
>>> 'hola tu que tal'.split()
['hola', 'tu', 'que', 'tal']
>>> '-'.join(['hola', 'tu', 'que', 'tal'])
'hola-tu-que-tal'
Ejercicio: Convertir "una frase con palabras"
a un nombre de variable con underlines "una_frase_con_palabras"
o en camell case "unaFraseConPalabras"
Texto con prefijo f
: entre corchetes, expresión a substituir
>>> print(f"El importe de la factura es {importeFactura}€")
El importe de la factura es 48.447344323€
Indicando el formato. Mini lenguaje de formato
Las siguientes diapos contienen consolas animadas con audio que reproducen la sesión en vivo que se hizo en la formación.
No es video es texto animado.
Puedes seleccionar el texto de los comandos y copiarlos en tu intérprete.
PENDIENTE
El interprete interactivo ipython3
.
Para ejecutar comandos en vivo y explorar.
Histórico editable de comandos
Autocompletar con el tabulador
Los scripts: cuando la cosa se complica,
mejor tener los comandos en un fichero de texto .py
y lanzarlos de golpe con el intérprete
La sintaxis general: una línea por sentencia
La funcion print
Subsentencias, indentadas despues de los :
Ejemplos: def
y if
Importante: indentar igual las subsentencias
Si abrimos {
, [
, (
… podemos partir las líneas libremente hasta cerrarlos.
Comentarios: lo que venga detrás de #
se ignora
Numéricos: 10
(int
), 10.0
(float
)
Textos: "Hola mundo"
(str
)
Un poco de listas: [1,2,'tres',4]
(list
)
Apenas mostramos diccionarios, booleanos…
Hoy los veremos
Operadores: * + - / // % ** in
Asignación =
y actualización += *= ...
Llamar a funciones: round(importeFinal)
Llamar a métodos: palabra.count('a')
Indexado, rebanado y zancada: seq[i:r:z]
Formateo: f"Hola {nombre}"
Tomar decisiones
Recorrer estructuras
Usar librerías
Manipular ficheros
Evitar conversaciones cruzadas en teléfono
Las graellas usan la definición de mesa
Complicado que cada cual se lo configure
Joan nos ha pasado un fichero con las mesas.
Tomatic las necesita en otro formato.
bool
)True
y False
Sirven para tomar decisiones según lo que se encuentra el script
Es lo que da inteligencia al ordenador
¿Cómo los obtenemos?
Ya vimos los operadores in
y not in
Operadores < <= == != >= >
if
# Espera que se lo escribamos por la consola
name = input("¿Quien Vive?\n")
if name == 'Carme':
print("Hola Carme, bienvenida a casa")
Las subsentencias solo se ejecuta
si la condición se cumple
else
if name == 'Carme'
print("Hola Carme, bienvenida a casa")
if not(name == 'Carme'):
print("Fuera intruso!")
Se simplifica como:
elif
elif
guests = "Adria Lucia Manel Vero".split()
owner = "Carme"
name = input("¿Quien vive?\n")
if name == owner:
print(f"Hola {owner}, bienvenida a casa")
elif name in guests:
print(f"Hola {name}, sientate, {owner} no tardará en llegar")
elif name == "El de la luz":
print("Deje de intentar timarme que estoy en Som Energia")
else:
print("Fuera intruso!")
and not or
Combinan booleanos y generan booleanos
a | b | a or b |
---|---|---|
True | True | True |
True | False | True |
False | True | True |
False | False | False |
a | b | a and b |
---|---|---|
True | True | True |
True | False | False |
False | True | False |
False | False | False |
a | not a |
---|---|
True | False |
False | True |
Cada tipo tiene valores ‘falsos’, el resto son ‘ciertos’
Ceros: 0
, 0.0
, 0j
Estructuras vacías: ""
{}
[]
…
El no-objeto: None
for
milista = [1, 2, 3, 4, 5, 6]
for numero in milista: # Ojo, no olvides los dos puntos!
print(f"El numero es {numero}")
print(f"Su cuadrado es {numero*numero}")
numero
es una variable que va adoptando los sucesivos valores de milista
Para cada valor se ejecutan las subsentencias.
for
recorre listas…
o cualquier cosa que contenga o genere elementos.
¿Textos? Pruébalo:
range
Genera secuencias de números
Sin contruir una lista: range(2000000)
no crea una lista de 2000000 numeros en memoria
>>> guests = ["Vane", "Sergi", "Albert", "Pau"]
>>> list(sorted(guests))
["Albert", "Sergi", "Pau", "Vane"]
>>> list(reversed(guests))
["Pau", "Albert", "Sergi", "Vane"]
>>> list(enumerate(guests))
[(0,"Vane"), (1,"Sergi"), (2,"Albert"), (3,"Pau")]
>>> gustos = ["fresas", "tomates", "alcachofas", "chocolate" ]
>>> list(zip(guests, gustos)])
[ ("Vane", "fresas"),
("Sergi", "tomates"),
("Albert", "alcachofas"),
("Pau", "chocolate"),
]
Construyendo una lista a partir de otra (o un iterable)
pathlib
Es una libreria estandard
Provee objetos Path
La forma para ficheros grandes, no podemos cargarlos todos en memoria.
p = Path('/home/vokimon/Documents/manual.tar.gz')
p.parts # ('/', 'home', 'vokimon', 'Documents', 'manual.tar.gz')
p.root # '/'
p.parent # '/home/vokimon/Documents'
p.parents # [ '/home/vokimon', '/home', '/' ]
p.name # 'manualdepython.tar.gz'
p.suffix # '.gz'
p.suffixes # ['.tar', '.gz' ]
p.stem # 'manualdepython.tar'
p.with_suffix('.zip') # Path('/home/vokimon/Documents/manual.zip')
Pista: usar Path
y read_text
Asegúrate de que el fichero está en el directorio de trabajo actual.
Hay que partir el texto por los '\n'
(saltos de línea)
Pista: 'abracadabra'.split('a')
partía el texto con las 'a'
Obtendremos una lista
cada elemento será una línia
Hacemos un for
para las líneas y las imprimimos separadas
Haremos un continue
, si la linea esta vacía
Pista: el texto evalua falso cuando està vacio
Ojo: hay líneas no tan vacias, tienen espacios.
El método linea.strip()
quita espacios delante y detras.
Haremos un continue
también si la primera letra de línea es un '#'
Pregunta: ¿Lo miraremos antes o despues de mirar si la línea esta vacia?
Pista: Un split
sin parametros, separaba palabras.
Podemos usar enumerate
pero
¿Como saltamos las líneas ignoradas?
Acomulamos un texto de salida.
Un for
dentro del for
, para cada nombre en la linia.
Usamos .with_suffix
para obtener la ruta con la extensión cambiada.
Usamos write_text
.
El enumerate se cuela las mesas que se salta.
Construyamos una lista intermedia que solo tenga mesas y enumeremos esa.
Generar los grupos (salas)