La viga completa
Este es el capítulo donde la historia se cierra. Tenemos datos, un cálculo, una decisión y una salida. Lo juntamos en un programa de unas treinta y cinco líneas que se lee de arriba abajo y que puedes ejecutar ahora mismo.
En una línea
Sección titulada «En una línea»Un programa completo es una historia con cuatro actos y nombres en cada uno.
Los datos
Sección titulada «Los datos»vigas = [ {"nombre": "V-1", "luz": 6.0, "carga": 20.0, "capacidad": 120.0}, {"nombre": "V-2", "luz": 7.5, "carga": 18.0, "capacidad": 150.0}, {"nombre": "V-3", "luz": 5.0, "carga": 30.0, "capacidad": 90.0}, {"nombre": "V-4", "luz": 8.0, "carga": 15.0, "capacidad": 140.0},]Una lista de diccionarios, como la del capítulo 06: cada viga es un registro con campos con nombre. Es la estructura más sencilla para empezar y la que sale al leer un archivo CSV. Las unidades son las de siempre: luz en m, carga en kN/m y capacidad en kN·m.
Las funciones
Sección titulada «Las funciones»def momento_maximo(carga, luz): """Momento de una viga simplemente apoyada con carga repartida (kN·m).""" return carga * luz ** 2 / 8
def aprovechamiento(momento, capacidad): """Fracción de la capacidad utilizada. Menor o igual que 1 es aceptable.""" return momento / capacidad
def estado(uso): """Clasifica el aprovechamiento en tres niveles.""" if uso > 1.0: return "REVISAR" if uso > 0.9: return "al límite" return "aceptable"Cada función responde a una pregunta del problema, y su docstring incluye las unidades. Ese detalle evita el error más caro en ingeniería: confundir kN con kN·m.
El informe
Sección titulada «El informe»print(f"{'Viga':6} {'Luz':>5} {'Carga':>6} {'M':>8} {'Uso':>6} Estado")print("-" * 48)
for viga in vigas: momento = momento_maximo(viga["carga"], viga["luz"]) uso = aprovechamiento(momento, viga["capacidad"]) print( f"{viga['nombre']:6} {viga['luz']:5.1f} {viga['carga']:6.1f} " f"{momento:8.1f} {uso:6.0%} {estado(uso)}" )Salida:
Viga Luz Carga M Uso Estado------------------------------------------------V-1 6.0 20.0 90.0 75% aceptableV-2 7.5 18.0 126.6 84% aceptableV-3 5.0 30.0 93.8 104% REVISARV-4 8.0 15.0 120.0 86% aceptableLa tabla no es un adorno: es el acto 4 de la historia. Un programa que calcula y no informa obliga a quien lo usa a leer el código.
Las columnas quedan alineadas por los formatos del capítulo 05, ahora con ancho:
| En el código | Qué hace | Resultado |
|---|---|---|
{'Viga':6} |
Texto en 6 caracteres, pegado a la izquierda | Viga |
{'Luz':>5} |
Texto en 5 caracteres, pegado a la derecha (>) |
Luz |
{viga['luz']:5.1f} |
Número con un decimal, en 5 caracteres | 6.0 |
{momento:8.1f} |
Lo mismo, en 8 caracteres | 90.0 |
{uso:6.0%} |
Porcentaje sin decimales, en 6 caracteres | 75% |
Tres detalles de escritura que conviene ver una vez:
- Texto entre llaves.
{'Viga':6}no calcula nada: mete el texto'Viga'entre llaves solo para poder darle un ancho. Así la cabecera usa los mismos anchos que las filas. - Comillas simples dentro de dobles. La f-string empieza y acaba con
", así que dentro se usa':viga['nombre']. Con las mismas comillas dentro y fuera, las versiones anteriores a Python 3.12 danSyntaxError. - Dos cadenas seguidas se pegan. Dentro del
print(...)hay dos f-strings, una debajo de otra y sin coma: Python las une en una sola. Es la forma de partir una línea demasiado larga.
El resumen
Sección titulada «El resumen»a_revisar = sum( 1 for viga in vigas if aprovechamiento(momento_maximo(viga["carga"], viga["luz"]), viga["capacidad"]) > 1)
print()print(f"{a_revisar} de {len(vigas)} vigas necesitan revisión")Salida: 1 de 4 vigas necesitan revisión.
Se lee: «suma un 1 por cada viga cuyo aprovechamiento supere 1». Es el contador del capítulo 06 escrito en el estilo declarativo del capítulo 03; len(vigas) es cuántos elementos tiene la lista. Si te resulta más claro el contador con a_revisar += 1 dentro del bucle, úsalo: hace lo mismo.
Por qué esto es un programa y no una hoja de cálculo
Sección titulada «Por qué esto es un programa y no una hoja de cálculo»- Se lee. Alguien que no sabe Python entiende los nombres y la tabla.
- Se prueba.
assert momento_maximo(20.0, 6.0) == 90.0comprueba la fórmula sin abrir Excel. - Se cambia. Otra viga es una línea en
vigas; otro criterio es una línea enestado. - Se versiona. Un cambio queda registrado con fecha y autor.
Lo que no es: un programa de diseño estructural. El modelo es didáctico —carga repartida, simplemente apoyada, capacidad dada— y no comprueba hormigón, flecha, cortante ni normativa. Para eso están las herramientas de verdad.
La trampa
Sección titulada «La trampa»Ejercicio
Sección titulada «Ejercicio»Añade una quinta viga con luz 9 m, carga 12 kN/m y capacidad 130 kN·m. Después cambia el criterio de «al límite» de 0.9 a 0.85 y observa qué vigas cambian de estado.
Solución
Añadir la viga es una línea en la lista, y cambiar el criterio es una línea en estado. La versión completa, ejecutable:
vigas = [ {"nombre": "V-1", "luz": 6.0, "carga": 20.0, "capacidad": 120.0}, {"nombre": "V-2", "luz": 7.5, "carga": 18.0, "capacidad": 150.0}, {"nombre": "V-3", "luz": 5.0, "carga": 30.0, "capacidad": 90.0}, {"nombre": "V-4", "luz": 8.0, "carga": 15.0, "capacidad": 140.0}, {"nombre": "V-5", "luz": 9.0, "carga": 12.0, "capacidad": 130.0},]
def momento_maximo(carga, luz): return carga * luz ** 2 / 8
def aprovechamiento(momento, capacidad): return momento / capacidad
def estado(uso): if uso > 1.0: return "REVISAR" if uso > 0.85: return "al límite" return "aceptable"
for viga in vigas: m = momento_maximo(viga["carga"], viga["luz"]) uso = aprovechamiento(m, viga["capacidad"]) print(f"{viga['nombre']}: {uso:.0%} -> {estado(uso)}")Salida:
V-1: 75% -> aceptableV-2: 84% -> aceptableV-3: 104% -> REVISARV-4: 86% -> al límiteV-5: 93% -> al límiteEl momento de la viga nueva, la V-5, es 12.0 × 9.0² / 8 = 121.5 kN·m y su aprovechamiento 121.5 / 130 = 0.935: con el criterio antiguo (0.9) ya salía «al límite», y con 0.85 también.
Con 0.85, la V-4 (86 %) pasa de «aceptable» a «al límite». Ese es exactamente el valor de tener el criterio en una función: cambiar una regla es cambiar una línea, y el informe se regenera entero.
Lo que no cambia: el cálculo. Y esa separación —cálculo estable, criterio configurable— es la misma que usa cualquier software de ingeniería serio.
Y ahora qué
Sección titulada «Y ahora qué»Ya sabes escribir un programa completo: datos, cálculo, decisión e informe. Desde aquí hay tres salidas, y el orden recomendado es este:
- Primero, el capítulo 09. Es el último de esta parte y explica con calma lo que aquí has usado de pasada —listas y diccionarios— más
importy los errores. Todo lo que viene después lo da por sabido. - Después, tu disciplina. Las rutas de estudio dicen qué capítulos leer, en qué orden y con qué prueba al final de cada etapa:
- Python para estructuras: de esta viga a un pórtico resuelto por el método de rigidez.
- Python para geotecnia: zapatas, muros y taludes con su factor de seguridad.
- Python para hidráulica: canales, tuberías y bombas.
- Python para hidrología: el caudal de proyecto de una cuenca.
- Y si quieres el porqué, la Parte I · El modelo de objetos explica cómo funciona por dentro lo que has usado: qué es exactamente una variable, por qué
6.0 * 1.1no da6.6. Es más densa que esta parte y no hace falta para seguir una ruta: se puede leer después, o a la vez.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed., capítulo 7.
- Lott, S. F. Modern Python Cookbook, 3ª ed., capítulos 2 y 3.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 07 · Funciones: las piezas que aquí se juntan.
- 09 · Listas, diccionarios,
importy errores: el siguiente paso. - Rutas de estudio: el camino a tu disciplina.
- Parte I · El modelo de objetos: por qué todo esto funciona por dentro.
- Parte II · Estructuras de datos: cómo guardar diez mil vigas sin que el programa se ahogue.