Listas, diccionarios, import y errores
En los capítulos 06 y 08 usaste listas y diccionarios de oído: bastaba con leerlos. Para escribir tus propios programas hay que saber manejarlos, y hacen falta dos piezas más: traer herramientas que ya están hechas y decidir qué pasa cuando un dato viene mal. Con eso se termina la Parte 0 y se puede seguir cualquier ruta del manual.
En una línea
Sección titulada «En una línea»Una lista guarda cosas en orden; un diccionario las guarda por nombre; import trae herramientas ya hechas; try decide qué pasa cuando algo falla.
Listas: varios valores en orden
Sección titulada «Listas: varios valores en orden»Una lista se escribe entre corchetes. Cada elemento tiene una posición, y la primera es la 0:
luces = [6.0, 7.5, 5.0, 8.0] # m
print(luces[0]) # 6.0 el primeroprint(luces[1]) # 7.5 el segundoprint(luces[-1]) # 8.0 el últimoprint(len(luces)) # 4 cuántos hayUna lista se puede cambiar después de crearla:
luces.append(9.0) # añade al finalluces[2] = 5.5 # sustituye el terceroprint(luces) # [6.0, 7.5, 5.5, 8.0, 9.0]Y hay funciones que reciben la lista entera:
print(max(luces)) # 9.0 la mayorprint(min(luces)) # 5.5 la menorprint(sum(luces) / len(luces)) # 7.2 la mediaprint(sorted(luces)) # [5.5, 6.0, 7.5, 8.0, 9.0] ordenada, sin tocar la originalRecorrer una lista
Sección titulada «Recorrer una lista»Es el for del capítulo 06. En cada vuelta, el nombre que eliges apunta al elemento siguiente:
carga = 20.0 # kN/m, la misma en todas las vigas
for luz in luces: momento = carga * luz ** 2 / 8 print(f"L = {luz:4.1f} m M = {momento:6.1f} kN·m")L = 6.0 m M = 90.0 kN·mL = 7.5 m M = 140.6 kN·mL = 5.5 m M = 75.6 kN·mL = 8.0 m M = 160.0 kN·mL = 9.0 m M = 202.5 kN·mPara guardar los resultados en lugar de imprimirlos, se empieza con una lista vacía y se va llenando:
momentos = []for luz in luces: momentos.append(carga * luz ** 2 / 8)
print(max(momentos)) # 202.5Ese patrón —lista vacía, bucle, append— es tan frecuente que tiene una forma corta, la que viste en el capítulo 03:
momentos = [carga * luz ** 2 / 8 for luz in luces]Hace exactamente lo mismo. Se lee: «el momento, para cada luz de la lista».
Diccionarios: valores con nombre
Sección titulada «Diccionarios: valores con nombre»Una lista sirve cuando todos los elementos son la misma clase de cosa. Cuando son datos distintos de un mismo objeto —el ancho, el calado y la pendiente de un canal—, la posición no dice nada y hace falta un nombre. Eso es un diccionario: pares clave: valor entre llaves.
canal = {"nombre": "C-1", "ancho": 2.0, "calado": 0.8, "pendiente": 0.001}
print(canal["ancho"]) # 2.0 se pide por su clave
canal["calado"] = 0.9 # cambia un valor que ya estabacanal["rugosidad"] = 0.014 # añade un par nuevo
area = canal["ancho"] * canal["calado"]print(f"Área mojada: {area:.2f} m²") # Área mojada: 1.80 m²Las claves son texto, y van entre comillas. Para saber si una clave existe antes de pedirla, in:
print("rugosidad" in canal) # Trueprint("caudal" in canal) # FalseUna lista de diccionarios es una tabla
Sección titulada «Una lista de diccionarios es una tabla»Juntando las dos piezas sale la estructura del capítulo 08. Cada diccionario es una fila; cada clave, una columna. Es una hoja de cálculo escrita en texto:
canales = [ {"nombre": "C-1", "ancho": 2.0, "calado": 0.9}, {"nombre": "C-2", "ancho": 3.0, "calado": 1.2}, {"nombre": "C-3", "ancho": 1.5, "calado": 0.6},]
for c in canales: area = c["ancho"] * c["calado"] print(f"{c['nombre']}: {area:.2f} m²")C-1: 1.80 m²C-2: 3.60 m²C-3: 0.90 m²canales[1]["ancho"] se lee de izquierda a derecha: el segundo canal, y de él, el ancho. Da 3.0.
Tuplas: valores que van juntos
Sección titulada «Tuplas: valores que van juntos»Una tupla es una lista que no se puede cambiar. Se escribe entre paréntesis y sirve para valores que solo tienen sentido juntos, como las coordenadas de un nudo:
nudo = (12.5, 3.0) # x, y en metros
x, y = nudo # desempaquetar: un nombre para cada valorprint(f"x = {x} m, y = {y} m")La segunda línea se llama desempaquetar, y donde más se usa es en las funciones que devuelven dos resultados:
def seccion_rectangular(ancho, calado): """Área (m²) y perímetro mojado (m) de un canal rectangular.""" area = ancho * calado perimetro = ancho + 2 * calado return area, perimetro # devuelve una tupla de dos valores
area, perimetro = seccion_rectangular(2.0, 0.9)radio = area / perimetro # radio hidráulico, mprint(f"A = {area:.2f} m² P = {perimetro:.2f} m Rh = {radio:.3f} m")A = 1.80 m² P = 3.80 m Rh = 0.474 mEra la segunda trampa del capítulo 07: return a, b devuelve una tupla, y se recoge con dos nombres a la izquierda del =.
import: herramientas ya hechas
Sección titulada «import: herramientas ya hechas»Python trae cientos de módulos: archivos con funciones que alguien ya escribió y probó. No están cargados de entrada; se piden con import, al principio del archivo:
import math
print(math.sqrt(16)) # 4.0print(f"{math.pi:.4f}") # 3.1416print(f"{math.sin(math.radians(30)):.3f}") # 0.500math.sqrt se lee «la función sqrt del módulo math». Con ella, la velocidad del canal anterior por la fórmula de Manning, v = (1/n) · Rh^(2/3) · √S:
n = 0.014 # rugosidad de Manning del hormigón, s/m^(1/3)pendiente = 0.001 # m/m
velocidad = radio ** (2 / 3) * math.sqrt(pendiente) / ncaudal = velocidad * area
print(f"v = {velocidad:.2f} m/s Q = {caudal:.2f} m³/s")v = 1.37 m/s Q = 2.47 m³/sEn el resto del manual verás otras dos formas de la misma orden:
| Se escribe | Se usa después como | Qué hace |
|---|---|---|
import math |
math.sqrt(16) |
Trae el módulo entero |
from math import sqrt |
sqrt(16) |
Trae solo una función |
import numpy as np |
np.array(...) |
Trae el módulo con un nombre corto |
math viene con Python: es de la biblioteca estándar. Otros módulos, como NumPy, hay que instalarlos antes; cada capítulo que los necesita lo dice.
Un apunte: SimpleNamespace
Sección titulada «Un apunte: SimpleNamespace»En los capítulos 02 y 03 las vigas se escribían viga.nombre, con punto, y en el 06 y el 08, viga["nombre"], con corchetes. Son dos formas de la misma idea: un objeto con campos con nombre.
from types import SimpleNamespace
viga_a = SimpleNamespace(nombre="V-1", luz=6.0)print(viga_a.luz) # 6.0 con punto
viga_b = {"nombre": "V-1", "luz": 6.0}print(viga_b["luz"]) # 6.0 con corchetes y comillasPara empezar, usa el diccionario: es lo que devuelve la lectura de un archivo y lo que usan los capítulos de ingeniería en sus primeros ejemplos. La forma con punto se lee mejor, y la versión seria —dataclass, que además comprueba que no falte ningún campo— está en la Parte II, capítulo 09.
Cuando un dato viene mal: try y except
Sección titulada «Cuando un dato viene mal: try y except»Los datos casi nunca llegan como números: llegan como texto, de un formulario o de un archivo. float convierte texto en número, y falla si el texto no lo es:
print(float("6.5")) # 6.5Con float("cinco"), en cambio, el programa se detiene y Python escribe:
ValueError: could not convert string to float: 'cinco'Eso es una excepción: Python no sabe qué hacer y para. La última línea dice el tipo de error (ValueError, un valor no válido) y el motivo. Si prefieres que el programa siga, se lo dices con try y except:
lecturas = ["6.0", "7,5", "cinco", "8.0"] # como llegan de un formularioluces = []
for texto in lecturas: try: luces.append(float(texto)) except ValueError: print(f"Dato descartado: '{texto}' no es un número")
print(luces)Dato descartado: '7,5' no es un númeroDato descartado: 'cinco' no es un número[6.0, 8.0]Se lee: «intenta esto; si salta un ValueError, haz esto otro». Lo que hay dentro de try se ejecuta con normalidad, y solo si falla se pasa al bloque de except.
Fíjate en el 7,5: en Python los decimales van con punto. Un número con coma, copiado de una hoja de cálculo en español, no es un número. Lo mismo pasa con input(), la función que pide un dato por teclado: siempre devuelve texto, y hay que convertirlo con float.
Tus funciones también pueden avisar. Una luz negativa no tiene sentido, y es mejor un error claro que un momento calculado con un dato absurdo:
def momento_maximo(carga, luz): """Momento de una viga simplemente apoyada con carga repartida (kN·m).""" if luz <= 0: raise ValueError(f"la luz debe ser positiva, y es {luz}") return carga * luz ** 2 / 8
try: print(momento_maximo(20.0, -6.0))except ValueError as error: print(f"No se puede calcular: {error}")No se puede calcular: la luz debe ser positiva, y es -6.0raise lanza el error; as error le pone nombre al mensaje para poder mostrarlo. Los capítulos de ingeniería usan este patrón para rechazar datos imposibles.
Los errores que vas a ver más a menudo, y qué significan:
| Error | Qué pasó | Ejemplo |
|---|---|---|
ValueError |
El valor no sirve para eso | float("cinco") |
KeyError |
Esa clave no está en el diccionario | canal["caudal"] |
IndexError |
Esa posición no existe en la lista | luces[10] |
TypeError |
Se mezclan tipos que no casan | "luz: " + 6.0 |
ZeroDivisionError |
División entre cero | 10 / 0 |
NameError |
Ese nombre no existe; suele ser una errata | print(luzz) |
La trampa
Sección titulada «La trampa»Ejercicio
Sección titulada «Ejercicio»Tienes cuatro canales rectangulares: tres de hormigón y uno, el C-4, excavado en tierra. De cada uno se sabe el ancho b (m), el calado y (m), la pendiente S (m/m) y la rugosidad de Manning n. El tercero trae un calado de 0: es un error de la toma de datos.
| Canal | Ancho | Calado | Pendiente | n |
|---|---|---|---|---|
| C-1 | 2.0 | 0.9 | 0.001 | 0.014 |
| C-2 | 3.0 | 1.2 | 0.0005 | 0.014 |
| C-3 | 1.5 | 0.0 | 0.002 | 0.014 |
| C-4 | 1.5 | 0.6 | 0.002 | 0.025 |
Escribe un programa que:
- guarde los canales en una lista de diccionarios;
- tenga una función
caudal_manning(ancho, calado, pendiente, n)que devuelva dos valores, la velocidad y el caudal, y que lanceValueErrorsi el calado no es positivo; - recorra la lista e imprima una tabla, sin detenerse en el canal con el dato malo;
- diga al final qué canal lleva más caudal.
Las fórmulas, por si no las tienes a mano: área A = b·y, perímetro mojado P = b + 2y, radio hidráulico Rh = A/P, velocidad v = (1/n)·Rh^(2/3)·√S y caudal Q = v·A.
Solución
import math
def caudal_manning(ancho, calado, pendiente, n): """Velocidad (m/s) y caudal (m³/s) de un canal rectangular, por Manning.""" if calado <= 0: raise ValueError(f"el calado debe ser positivo, y es {calado}") area = ancho * calado # m² perimetro = ancho + 2 * calado # m radio = area / perimetro # m velocidad = radio ** (2 / 3) * math.sqrt(pendiente) / n return velocidad, velocidad * area
canales = [ {"nombre": "C-1", "ancho": 2.0, "calado": 0.9, "pendiente": 0.001, "n": 0.014}, {"nombre": "C-2", "ancho": 3.0, "calado": 1.2, "pendiente": 0.0005, "n": 0.014}, {"nombre": "C-3", "ancho": 1.5, "calado": 0.0, "pendiente": 0.002, "n": 0.014}, {"nombre": "C-4", "ancho": 1.5, "calado": 0.6, "pendiente": 0.002, "n": 0.025},]
print(f"{'Canal':6} {'v (m/s)':>8} {'Q (m³/s)':>9}")print("-" * 25)
nombre_mayor = ""caudal_mayor = 0.0
for canal in canales: try: velocidad, caudal = caudal_manning( canal["ancho"], canal["calado"], canal["pendiente"], canal["n"] ) except ValueError as error: print(f"{canal['nombre']:6} dato no válido: {error}") continue
print(f"{canal['nombre']:6} {velocidad:8.2f} {caudal:9.2f}") if caudal > caudal_mayor: caudal_mayor = caudal nombre_mayor = canal["nombre"]
print()print(f"Mayor caudal: {nombre_mayor}, con {caudal_mayor:.2f} m³/s")Salida:
Canal v (m/s) Q (m³/s)-------------------------C-1 1.37 2.47C-2 1.22 4.39C-3 dato no válido: el calado debe ser positivo, y es 0.0C-4 0.86 0.77
Mayor caudal: C-2, con 4.39 m³/sAquí están las cuatro piezas del capítulo trabajando juntas: la lista de diccionarios guarda la tabla, la función devuelve una tupla que se desempaqueta en velocidad, caudal, math pone la raíz cuadrada y el try deja que un dato malo cueste una línea de aviso en lugar del informe entero.
Dos detalles. El continue del capítulo 06 salta al canal siguiente, así que las líneas de debajo solo se ejecutan con datos buenos. Y el C-4 no lleva poco caudal solo por ser pequeño: su n = 0.025 es el de un canal de tierra. Cambia ese número por 0.014 y vuelve a ejecutar: el caudal pasa de 0.77 a 1.38 m³/s. La rugosidad pesa tanto como la geometría, y con los datos en una tabla comprobarlo cuesta cambiar un número.
Comprueba un canal a mano antes de fiarte, como en el capítulo 08. Para el C-1: A = 1.80, P = 3.80, Rh = 0.474, y v = 0.474^(2/3) · √0.001 / 0.014 = 1.37 m/s.
Con esto termina la Parte 0
Sección titulada «Con esto termina la Parte 0»Ya tienes lo que el resto del manual da por sabido: variables, decisiones, bucles, funciones, listas, diccionarios, import y errores. El siguiente paso es tu disciplina, con una ruta de estudio:
Las rutas mandan a capítulos de las Partes II a IV que están escritos a nivel profesional: explican cómo funciona cada pieza por dentro y cuánto cuesta. No te asustes: para seguir la ruta basta con el principio de cada uno —«En una línea» y los primeros ejemplos—, y cada ruta dice hasta dónde leer.
Referencias
Sección titulada «Referencias»- El tutorial de Python (documentación oficial), secciones 5 «Estructuras de datos», 6 «Módulos» y 8 «Errores y excepciones».
- Ramalho, L. Fluent Python, 2ª ed., capítulos 2 y 3.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 06 · Decisiones y repeticiones: el
fory elcontinueque aquí se usan. - 08 · La viga completa: la lista de diccionarios dentro de un programa entero.
- Rutas de estudio: lo que viene ahora.
- Parte II · Registros:
dataclass, el paso siguiente al diccionario. - Parte X · Canales y Manning: el canal del ejercicio, en serio.