Ir al contenido principal

Retorno de valores: return y valores múltiples

Introducción

Una de las características más potentes de las funciones en Python es su capacidad para devolver valores al código que las invoca. Esta funcionalidad permite crear bloques de código que no solo realizan acciones, sino que también producen resultados que podemos utilizar en otras partes de nuestro programa. El mecanismo de retorno de valores nos ayuda a construir funciones verdaderamente reutilizables y a organizar nuestro código de manera más eficiente. En este artículo, exploraremos cómo devolver valores desde nuestras funciones, desde el caso más simple hasta la devolución de múltiples valores simultáneamente, una característica distintiva de Python.

La sentencia return

La sentencia return es el mecanismo principal para devolver valores desde una función. Cuando Python encuentra esta sentencia, finaliza inmediatamente la ejecución de la función y devuelve el valor especificado al código que la invocó.

def calcular_area_rectangulo(base, altura):
    area = base * altura
    return area

# Llamada a la función y captura del valor retornado
resultado = calcular_area_rectangulo(5, 3)
print(f"El área del rectángulo es {resultado} unidades cuadradas.")
# El área del rectángulo es 15 unidades cuadradas.

En este ejemplo, calcular_area_rectangulo calcula el área y la devuelve. El valor retornado se asigna a la variable resultado.

Retorno implícito de None

Si una función no incluye una sentencia return o si el return no especifica un valor, la función devolverá automáticamente None (un objeto especial que representa la ausencia de valor).

def saludar(nombre):
    print(f"Hola, {nombre}!")
    # No hay return explícito

# La función devuelve None implícitamente
resultado = saludar("Miguel")
print(f"La función devolvió: {resultado}")
# Hola, Miguel!
# La función devolvió: None

Uso de return para terminar la ejecución

La sentencia return también se puede usar para finalizar la ejecución de una función sin devolver un valor significativo, algo útil para salir temprano de una función bajo ciertas condiciones.

def dividir(a, b):
    # Salir de la función si el denominador es cero
    if b == 0:
        print("Error: No se puede dividir por cero.")
        return  # Equivalente a return None
    
    # Esta línea solo se ejecuta si b != 0
    resultado = a / b
    return resultado

print(dividir(10, 2))  # 5.0
print(dividir(10, 0))  # Error: No se puede dividir por cero.
                       # None

Retorno condicional

Podemos utilizar diferentes sentencias return basadas en condiciones:

def evaluar_nota(puntuacion):
    if puntuacion >= 9:
        return "Sobresaliente"
    elif puntuacion >= 7:
        return "Notable"
    elif puntuacion >= 5:
        return "Aprobado"
    else:
        return "Suspenso"

print(evaluar_nota(9.5))  # Sobresaliente
print(evaluar_nota(7.5))  # Notable
print(evaluar_nota(4.5))  # Suspenso

Retorno de múltiples valores

Una característica poderosa de Python es la capacidad de devolver múltiples valores desde una función. En realidad, lo que ocurre es que Python empaqueta los valores en una tupla automáticamente.

def obtener_dimensiones_rectangulo(area, proporcion):
    # Calcula el ancho y alto basados en el área y la proporción ancho:alto
    ancho = (area * proporcion) ** 0.5
    alto = area / ancho
    return ancho, alto  # Devuelve dos valores

# Los valores se pueden capturar en variables separadas
ancho, alto = obtener_dimensiones_rectangulo(50, 2)
print(f"Ancho: {ancho:.2f}, Alto: {alto:.2f}")
# Ancho: 10.00, Alto: 5.00

En este ejemplo, obtener_dimensiones_rectangulo devuelve dos valores. Python los empaqueta en una tupla y luego los desempaqueta en las variables ancho y alto.

Desempaquetado de valores retornados

Podemos desempaquetar los valores retornados de varias maneras:

def obtener_estadisticas(numeros):
    """Calcula algunas estadísticas básicas para una lista de números."""
    minimo = min(numeros)
    maximo = max(numeros)
    promedio = sum(numeros) / len(numeros)
    return minimo, maximo, promedio

# Método 1: Desempaquetar en variables separadas
minimo, maximo, promedio = obtener_estadisticas([1, 2, 3, 4, 5])
print(f"Mínimo: {minimo}, Máximo: {maximo}, Promedio: {promedio}")
# Mínimo: 1, Máximo: 5, Promedio: 3.0

# Método 2: Capturar como una tupla
resultados = obtener_estadisticas([10, 20, 30, 40, 50])
print(f"Mínimo: {resultados[0]}, Máximo: {resultados[1]}, Promedio: {resultados[2]}")
# Mínimo: 10, Máximo: 50, Promedio: 30.0

# Método 3: Desempaquetar selectivamente con *
minimo, *resto = obtener_estadisticas([5, 15, 25, 35, 45])
print(f"Mínimo: {minimo}, Otros valores: {resto}")
# Mínimo: 5, Otros valores: [45, 25.0]

Retorno de estructuras de datos

También es común devolver estructuras de datos como listas, diccionarios o conjuntos:

def analizar_texto(texto):
    """Realiza un análisis básico de un texto."""
    palabras = texto.split()
    resultados = {
        "num_caracteres": len(texto),
        "num_palabras": len(palabras),
        "primera_palabra": palabras[0] if palabras else "",
        "ultima_palabra": palabras[-1] if palabras else ""
    }
    return resultados

analisis = analizar_texto("Python es un lenguaje versátil y potente.")
print(f"Caracteres: {analisis['num_caracteres']}")
print(f"Palabras: {analisis['num_palabras']}")
print(f"Primera palabra: {analisis['primera_palabra']}")
print(f"Última palabra: {analisis['ultima_palabra']}")
# Caracteres: 42
# Palabras: 6
# Primera palabra: Python
# Última palabra: potente.

Retorno de funciones

En Python, las funciones son objetos de primera clase, lo que significa que pueden ser devueltas por otras funciones:

def crear_multiplicador(factor):
    """Crea y devuelve una función que multiplica por un factor dado."""
    def multiplicador(x):
        return x * factor
    return multiplicador

duplicar = crear_multiplicador(2)
triplicar = crear_multiplicador(3)

print(duplicar(5))  # 10
print(triplicar(5))  # 15

En este ejemplo avanzado, crear_multiplicador devuelve una función que multiplica su argumento por un factor específico.

Buenas prácticas al retornar valores

  1. Documentación clara: Documenta qué valores devuelve tu función en sus docstrings.
def calcular_distancia(x1, y1, x2, y2):
    """
    Calcula la distancia euclidiana entre dos puntos.
    
    Args:
        x1, y1: Coordenadas del primer punto
        x2, y2: Coordenadas del segundo punto
        
    Returns:
        float: La distancia euclidiana entre los puntos
    """
    return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

  1. Consistencia en los tipos retornados: Intenta que una función siempre devuelva el mismo tipo de datos o tipos compatibles.

  2. Nombres descriptivos al desempaquetar: Usa nombres significativos para las variables cuando desempaquetes valores múltiples.

# Bueno
ancho, alto = obtener_dimensiones_rectangulo(50, 2)

# Evitar
x, y = obtener_dimensiones_rectangulo(50, 2)
  1. Evita efectos secundarios: Las funciones que devuelven valores deberían centrarse en calcular y devolver ese valor, evitando efectos secundarios como modificar variables globales.

Resumen

El retorno de valores en Python, mediante la sentencia return, permite a nuestras funciones proporcionar resultados que podemos utilizar en otras partes del código. Python ofrece una gran flexibilidad al permitirnos devolver múltiples valores, estructuras de datos e incluso otras funciones. Este mecanismo es fundamental para construir código modular, reutilizable y mantenible. En el próximo artículo, exploraremos el ámbito de las variables en Python, un concepto estrechamente relacionado con el funcionamiento de las funciones y sus valores de retorno.

Volver arriba