Dominando las funciones en Python: definición, llamada, indentación, argumentos y valores de retorno

Dominando las funciones en Python: definición, llamada, indentación, argumentos y valores de retorno

Las funciones son los bloques fundamentales de cualquier aplicación en Python. Encapsulan lógica reutilizable, mantienen el código DRY (Don't Repeat Yourself) y hacen que los programas sean más fáciles de leer, probar y mantener. En esta guía recorreremos cada paso necesario para escribir, llamar y depurar funciones en Python 3, mencionando también las diferencias que encontrarás en Python 2.

¿Qué es una función en Python?

Una función en Python es un bloque de código autocontenido que se ejecuta cuando la invocas. Puedes pensarla como un miniprograma que realiza una única tarea bien definida y puede reutilizarse donde se necesite. Aunque Python incluye numerosas funciones integradas (como print(), input()), puedes crear las tuyas propias, dotando a tu código de la capacidad de evolucionar y escalar.

Definición y llamada de una función

Las funciones se declaran con la palabra clave def, seguida del nombre de la función y una lista de parámetros entre paréntesis. El cuerpo de la función comienza con dos puntos y debe estar indentado.

def saludar():
    print("¡Hola, Python!")

# Llamada a la función
saludar()

Salida: ¡Hola, Python!

Por qué importa la indentación

Python no usa llaves ni sentencias explícitas begin/end. En su lugar, la indentación define el ámbito. Cada bloque de código —funciones, bucles, condicionales— debe compartir un nivel de indentación consistente.

1. Se requiere al menos un nivel de indentación (típicamente cuatro espacios) tras la definición de la función.
2. Todas las sentencias dentro de esa función deben usar la misma indentación.
3. Mezclar tabulaciones y espacios, o variar la profundidad de indentación, provoca un IndentationError.

Ejemplo de indentación correcta:

def demo():
    print("Línea 1")
    print("Línea 2")

Y un error común:

def demo():
print("Ups")

Que genera: IndentationError: expected an indented block

Uso de la sentencia return

La palabra clave return devuelve un valor al llamador. Si una función llega al final sin encontrar un return, devuelve implícitamente None.

def cuadrado(x):
    return x * x

print(cuadrado(4))  # 16

Sin return:

def cuadrado(x):
    x * x

print(cuadrado(4))  # None

Además, imprimir el objeto función directamente (p. ej., print(cuadrado)) muestra su dirección de memoria, lo cual rara vez es útil en el código de aplicación.

Paso de argumentos a las funciones

Los argumentos suministran los datos que la función necesita para operar. Los parámetros son los marcadores de posición definidos en la firma de la función.

def multiplicar(x, y=1):
    return x * y

print(multiplicar(4))        # 4 (y toma el valor por defecto 1)
print(multiplicar(4, 2))     # 8
print(multiplicar(y=3, x=2)) # 6 (argumentos por nombre permiten reordenar)

Argumentos de longitud variable (*args y **kwargs)

A veces necesitas una función que acepte un número arbitrario de argumentos. Usa *args para argumentos posicionales y **kwargs para argumentos por nombre.

def resumir(*valores, **opciones):
    total = sum(valores)
    print(f"Total: {total}")
    if opciones.get("mostrar_detalles"):
        print("Valores:", valores)

resumir(1, 2, 3, 4, 5, mostrar_detalles=True)

Python 2 vs Python 3: diferencias clave

• Sintaxis de impresión: print "texto" en Python 2 frente a print("texto") en Python 3.
• Sobrecarga de funciones (múltiples firmas con el mismo nombre) no es compatible en Python 2, pero está disponible en Python 3 mediante functools.singledispatch o inspeccionando los tipos de argumentos.
• División entera: 5/2 produce 2 en Python 2 y 2.5 en Python 3 (usa // para división entera en ambas versiones).

Buenas prácticas para el diseño de funciones

• Mantén las funciones enfocadas: una función debe realizar una única tarea clara.
• Documenta con una docstring en la primera línea dentro de la función.

  def sumar(a, b):
      """Devuelve la suma de a y b."""
      return a + b

• Usa anotaciones de tipo (Python 3.5+) para aclarar los tipos esperados de argumentos y retorno.

  def sumar(a: int, b: int) -> int:
      return a + b

• Prefiere argumentos por nombre para parámetros opcionales, mejorando la legibilidad.

Ejemplo completo

# Ejemplo de script completo en Python 3
def saludar():
    """Imprime un saludo amistoso."""
    print("¡Hola, Python!")

def cuadrado(x: int) -> int:
    """Devuelve el cuadrado de x."""
    return x * x

def multiplicar(x: int, y: int = 1) -> int:
    """Devuelve el producto de x e y, con y por defecto 1."""
    return x * y

# Demostración
if __name__ == "__main__":
    saludar()
    print(cuadrado(4))        # 16
    print(multiplicar(4))     # 4
    print(multiplicar(4, 2))  # 8
    print(multiplicar(y=2, x=4))  # 8

Para una guía más detallada, consulta la documentación oficial de Python sobre definiciones de funciones.