Saltearse al contenido

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.

Un programa completo es una historia con cuatro actos y nombres en cada uno.

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.

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.

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% aceptable
V-2 7.5 18.0 126.6 84% aceptable
V-3 5.0 30.0 93.8 104% REVISAR
V-4 8.0 15.0 120.0 86% aceptable

La 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 dan SyntaxError.
  • 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.
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.0 comprueba la fórmula sin abrir Excel.
  • Se cambia. Otra viga es una línea en vigas; otro criterio es una línea en estado.
  • 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.

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% -> aceptable
V-2: 84% -> aceptable
V-3: 104% -> REVISAR
V-4: 86% -> al límite
V-5: 93% -> al límite

El 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.

Ya sabes escribir un programa completo: datos, cálculo, decisión e informe. Desde aquí hay tres salidas, y el orden recomendado es este:

  1. 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 import y los errores. Todo lo que viene después lo da por sabido.
  2. 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:
  3. 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.1 no da 6.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.
  • Ramalho, L. Fluent Python, 2ª ed., capítulo 7.
  • Lott, S. F. Modern Python Cookbook, 3ª ed., capítulos 2 y 3.