Saltearse al contenido

Funciones, dar nombre a un paso

Cuando un cálculo se repite o necesita un nombre, se convierte en función. Una función recibe unos datos (parámetros), hace su trabajo y devuelve un resultado. Es el mecanismo que convierte un programa de treinta líneas en cinco párrafos legibles.

Una función es un paso con nombre: entra algo, sale algo, y el nombre dice qué pasa en medio.

def momento_maximo(carga, luz):
"""Momento de una viga simplemente apoyada con carga repartida."""
return carga * luz ** 2 / 8
resultado = momento_maximo(20.0, 6.0)
print(resultado) # 90.0

Cuatro piezas:

Pieza Qué es
def «voy a definir una función»
momento_maximo el nombre, en minúsculas y con guiones bajos
(carga, luz) los parámetros: lo que entra
return lo que sale

La línea entre triples comillas es el docstring: la explicación de qué hace. No es un comentario; Python la guarda y las herramientas la leen.

Es el error número uno de quien empieza:

def mal(carga, luz):
print(carga * luz ** 2 / 8) # muestra, pero no devuelve
def bien(carga, luz):
return carga * luz ** 2 / 8 # devuelve el valor
x = mal(20.0, 6.0) # imprime 90.0, y x vale None
y = bien(20.0, 6.0) # no imprime nada, y y vale 90.0

print sirve para mirar; return sirve para seguir calculando. Una función que solo imprime no se puede usar dentro de otra.

# sin funciones
m1 = 20.0 * 6.0 ** 2 / 8
m2 = 15.0 * 7.0 ** 2 / 8
m3 = 25.0 * 5.0 ** 2 / 8
# con funciones
m1 = momento_maximo(20.0, 6.0)
m2 = momento_maximo(15.0, 7.0)
m3 = momento_maximo(25.0, 5.0)

Tres razones, y ninguna es estética:

  • Un cambio, un sitio. Si la fórmula cambia (por ejemplo, un voladizo), se cambia la función y no las tres líneas.
  • Se puede probar. assert momento_maximo(20.0, 6.0) == 90.0 comprueba el cálculo sin mirar la pantalla.
  • Se puede leer. El nombre dice qué calcula; la fórmula queda dentro, para quien la necesite.
momento_maximo(carga=20.0, luz=6.0)

Llamar con nombres evita el error clásico de invertir dos números del mismo tipo. Python no puede saber que has puesto la luz donde iba la carga; el nombre sí.

Y un valor por defecto, cuando hay un caso habitual:

def cumple(momento, capacidad, limite=1.0):
"""True si el aprovechamiento no supera el límite."""
return momento / capacidad <= limite
print(cumple(90.0, 120.0)) # True: 0.75 no supera 1.0
print(cumple(90.0, 120.0, limite=0.7)) # False: 0.75 supera 0.7

Si al llamar no se da limite, vale 1.0; si se da, manda el que se da. Así el caso habitual se escribe corto y el caso especial sigue siendo posible.

Escribe aprovechamiento(momento, capacidad) que devuelva el cociente, y úsala para imprimir el estado de dos vigas: una con 90 kN·m y capacidad 120, otra con 150 y capacidad 120. El estado es «aceptable» si el cociente no supera 1 (es decir, menor o igual que 1) y «revisar» en caso contrario.

Solución
def aprovechamiento(momento, capacidad):
"""Fracción de la capacidad que se usa. Hasta 1 es aceptable."""
return momento / capacidad
def estado(momento, capacidad):
"""Clasifica la viga: "aceptable" o "revisar"."""
uso = aprovechamiento(momento, capacidad)
if uso <= 1.0:
return "aceptable"
return "revisar"
uso_1 = aprovechamiento(90.0, 120.0)
print(f"90/120 = {uso_1:.2f} -> {estado(90.0, 120.0)}")
uso_2 = aprovechamiento(150.0, 120.0)
print(f"150/120 = {uso_2:.2f} -> {estado(150.0, 120.0)}")

Salida:

90/120 = 0.75 -> aceptable
150/120 = 1.25 -> revisar

Dos funciones pequeñas, cada una con un nombre que dice qué hace. estado usa aprovechamiento, y ese es el patrón: las funciones se componen. En estado no hace falta else: si la condición se cumple, el primer return termina la función y la última línea ya no se ejecuta.

Las dos vigas se escriben con dos llamadas, y se nota la repetición. Con cuatro vigas pide a gritos una lista y un for: es lo que hace el capítulo 08, que junta varias funciones así para contar la historia completa.

  • Ramalho, L. Fluent Python, 2ª ed., capítulo 7.
  • Lott, S. F. Modern Python Cookbook, 3ª ed., capítulo 3.