CÓMO LLAMAR FUNCIONES EN PYTHON CON EJEMPLOS PRÁCTICOS

November 7, 2025

Introducción a las Funciones en Python

Las funciones son un pilar fundamental en la programación, ya que permiten reutilizar código, reducir la repetición y mejorar la organización de los programas. En Python, las funciones se definen con la palabra clave def y se llaman utilizando su nombre seguido de paréntesis. Este tutorial está diseñado para programadores principiantes y avanzados que deseen dominar la creación y el uso de funciones en Python, incluyendo casos más complejos como funciones anidadas. A lo largo del artículo, exploraremos la sintaxis básica, cómo definir una función y cómo llamarla correctamente, con ejemplos prácticos que ilustran cada concepto. También abordaremos errores comunes y cómo evitarlos, asegurando que tu código sea claro y eficiente. Al final, tendrás una comprensión sólida de cómo trabajar con funciones en Python y cómo aplicarlas en tus proyectos.

Definición de una Función en Python

Para crear una función en Python, se utiliza la palabra clave def, seguida del nombre de la función y paréntesis. El nombre debe ser descriptivo y seguir las convenciones de Python, como usar minúsculas y guiones bajos para nombres compuestos. Después de los paréntesis, se coloca un dos puntos (:) para indicar el inicio del bloque de código que define lo que hace la función. Este bloque debe estar indentado, ya que Python utiliza la indentación para delimitar el alcance.

El siguiente ejemplo muestra cómo definir una función simple:

def saludar_usuario():
    print("¡Hola, bienvenido a Python!")

En este caso, la función saludar_usuario imprime un mensaje en la consola. La función no toma parámetros, ya que los paréntesis están vacíos, y su única tarea es mostrar el texto especificado. Es importante notar que definir una función no ejecuta su código; para que se ejecute, debe ser llamada explícitamente.

La sintaxis general para crear una función es:

def nombre_funcion():
    # Código que ejecuta la función

La elección de un nombre claro y descriptivo es crucial para que el código sea legible y mantenible. Por ejemplo, calcular_suma es un nombre más descriptivo que cs, ya que indica claramente la acción que realiza la función.

Llamada a una Función en Python

Una vez definida una función, se puede ejecutar o “llamar” utilizando su nombre seguido de paréntesis. Llamar una función ejecuta el bloque de código definido dentro de ella. Siguiendo el ejemplo anterior, para ejecutar la función saludar_usuario, simplemente escribimos:

saludar_usuario()
# Salida:
# ¡Hola, bienvenido a Python!

La llamada a la función debe realizarse fuera del bloque de la función. Un error común es intentar llamar a la función dentro de su propio bloque, lo que puede causar un comportamiento inesperado o errores de recursión infinita si no se maneja correctamente.

Por ejemplo, el siguiente código es incorrecto:

def saludar_usuario():
    print("¡Hola, bienvenido a Python!")
    saludar_usuario()  # Error: recursión infinita

En este caso, la función se llamaría a sí misma indefinidamente, lo que provocaría un error de desbordamiento de pila. Para evitar esto, asegúrate de que las llamadas a funciones se realicen fuera del bloque de definición, como en el siguiente ejemplo correcto:

def saludar_usuario():
    print("¡Hola, bienvenido a Python!")

saludar_usuario()
# Salida:
# ¡Hola, bienvenido a Python!

Funciones con Parámetros

Las funciones en Python pueden aceptar parámetros, que son valores que se pasan a la función para que los utilice en su ejecución. Los parámetros se definen dentro de los paréntesis en la definición de la función. Esto permite que las funciones sean más flexibles y reutilizables.

Por ejemplo, consideremos una función que calcula el cuadrado de un número:

def calcular_cuadrado(numero):
    resultado = numero * numero
    print(f"El cuadrado de {numero} es {resultado}")

calcular_cuadrado(5)
# Salida:
# El cuadrado de 5 es 25

En este caso, numero es un parámetro que la función utiliza para realizar el cálculo. Al llamar a calcular_cuadrado(5), el valor 5 se pasa como argumento y la función imprime el resultado. Puedes llamar a la misma función con diferentes valores:

calcular_cuadrado(3)
# Salida:
# El cuadrado de 3 es 9
calcular_cuadrado(7)
# Salida:
# El cuadrado de 7 es 49

También es posible definir funciones con múltiples parámetros. Por ejemplo:

def sumar_numeros(a, b):
    resultado = a + b
    print(f"La suma de {a} y {b} es {resultado}")

sumar_numeros(10, 20)
# Salida:
# La suma de 10 y 20 es 30

En este ejemplo, la función sumar_numeros toma dos parámetros, a y b, y calcula su suma. Los parámetros hacen que la función sea más dinámica, ya que puede trabajar con diferentes valores cada vez que se llama.

Devolución de Valores con return

Hasta ahora, los ejemplos han utilizado print para mostrar resultados, pero en muchos casos es preferible que una función devuelva un valor utilizando la palabra clave return. Esto permite que el resultado de la función se almacene en una variable o se utilice en otras partes del programa.

Por ejemplo, modifiquemos la función calcular_cuadrado para que devuelva el resultado en lugar de imprimirlo:

def calcular_cuadrado(numero):
    return numero * numero

resultado = calcular_cuadrado(4)
print(f"El cuadrado es {resultado}")
# Salida:
# El cuadrado es 16

La instrucción return finaliza la ejecución de la función y envía el valor especificado al punto donde se llamó la función. Esto es útil para realizar cálculos y luego usar los resultados en otras operaciones. Por ejemplo:

def calcular_cuadrado(numero):
    return numero * numero

cuadrado = calcular_cuadrado(5)
doble_cuadrado = cuadrado * 2
print(f"El doble del cuadrado es {doble_cuadrado}")
# Salida:
# El doble del cuadrado es 50

En este caso, el valor devuelto por calcular_cuadrado(5) se almacena en la variable cuadrado y luego se utiliza para calcular doble_cuadrado.

Funciones Anidadas en Python

En Python, es posible definir una función dentro de otra función, lo que se conoce como una función anidada. Estas funciones solo son accesibles dentro del ámbito de la función externa, lo que las hace útiles para encapsular lógica específica que no necesita ser utilizada en otros lugares del programa.

Consideremos el siguiente ejemplo:

def procesar_datos():
    print("Procesando datos principales...")

    def procesar_detalles():
        print("Procesando detalles adicionales...")

    procesar_detalles()

procesar_datos()
# Salida:
# Procesando datos principales...
# Procesando detalles adicionales...

En este caso, la función procesar_detalles está anidada dentro de procesar_datos. Para que procesar_detalles se ejecute, debe ser llamada dentro del bloque de procesar_datos. Si intentas llamarla desde fuera, obtendrás un error porque la función no está definida en el ámbito global:

def procesar_datos():
    print("Procesando datos principales...")

    def procesar_detalles():
        print("Procesando detalles adicionales...")

procesar_detalles()  # Error: NameError: name 'procesar_detalles' is not defined

El error ocurre porque procesar_detalles solo existe dentro del ámbito de procesar_datos. Para ejecutar ambas funciones, debes asegurarte de que la función interna sea llamada dentro de la función externa, como se mostró en el primer ejemplo.

Las funciones anidadas son útiles para dividir la lógica en partes más pequeñas y mantener el código organizado. Por ejemplo, podrías usar una función anidada para realizar un cálculo intermedio:

def calcular_promedio(numeros):
    print("Calculando promedio...")

    def suma_total():
        return sum(numeros)

    total = suma_total()
    promedio = total / len(numeros)
    return promedio

resultado = calcular_promedio([10, 20, 30, 40])
print(f"El promedio es {resultado}")
# Salida:
# Calculando promedio...
# El promedio es 25.0

En este caso, la función suma_total se utiliza internamente para calcular la suma de los números, lo que hace que el código sea más modular y fácil de entender.

Manejo de Errores Comunes al Llamar Funciones

Al trabajar con funciones, es común cometer errores que pueden dificultar la depuración del código. A continuación, se presentan algunos errores frecuentes y cómo evitarlos.

Llamar una Función Antes de Definirla

En Python, las funciones deben definirse antes de ser llamadas. Si intentas llamar a una función antes de su definición, obtendrás un error NameError:

mi_funcion()  # Error: NameError: name 'mi_funcion' is not defined

def mi_funcion():
    print("Esto no se ejecutará")

Para evitar este error, asegúrate de que la definición de la función esté antes de la llamada en el código.

Olvidar los Paréntesis al Llamar una Función

Si omites los paréntesis al intentar llamar a una función, Python no ejecutará la función, sino que devolverá una referencia a ella:

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

print(saludar)  # Salida: <function saludar at ...>
saludar()       # Salida: ¡Hola!

En este caso, print(saludar) muestra información sobre la función en lugar de ejecutarla. Asegúrate de incluir los paréntesis (()) para llamar a la función correctamente.

Pasar el Número Incorrecto de Argumentos

Si una función espera un número específico de argumentos y le pasas más o menos, Python arrojará un error TypeError:

def sumar(a, b):
    return a + b

sumar(1)  # Error: TypeError: sumar() missing 1 required positional argument: 'b'
sumar(1, 2, 3)  # Error: TypeError: sumar() takes 2 positional arguments but 3 were given

Para evitar este error, verifica que la cantidad y el tipo de argumentos que pasas coincidan con los parámetros definidos en la función.

Buenas Prácticas para Funciones en Python

Para escribir funciones claras y eficientes, sigue estas recomendaciones:

Usa nombres descriptivos para las funciones y parámetros. Por ejemplo, calcular_area_circulo es mejor que cac, ya que describe claramente su propósito.
Mantén las funciones cortas y enfocadas en una sola tarea. Si una función realiza múltiples tareas, considera dividirla en funciones más pequeñas.
Utiliza return para devolver resultados en lugar de depender únicamente de print, ya que esto hace que las funciones sean más versátiles.
Documenta tus funciones con docstrings para explicar su propósito, parámetros y valores de retorno. Por ejemplo:

def calcular_area_circulo(radio):
    """Calcula el área de un círculo dado su radio.

    Args:
        radio (float): El radio del círculo.

    Returns:
        float: El área del círculo.
    """
    return 3.1416 * radio ** 2

Evita efectos secundarios innecesarios, como modificar variables globales dentro de una función, a menos que sea estrictamente necesario.

Estas prácticas no solo mejoran la legibilidad del código, sino que también facilitan su mantenimiento y depuración.

Funciones con Valores Predeterminados

Python permite definir parámetros con valores predeterminados, lo que hace que las funciones sean más flexibles. Si no se proporciona un argumento para un parámetro con valor predeterminado, se utiliza el valor especificado.

Por ejemplo:

def saludar(nombre="Usuario"):
    print(f"¡Hola, {nombre}!")

saludar()          # Salida: ¡Hola, Usuario!
saludar("Ana")     # Salida: ¡Hola, Ana!

En este caso, el parámetro nombre tiene un valor predeterminado de "Usuario". Si no se pasa un argumento al llamar a la función, se utiliza este valor.

Los parámetros con valores predeterminados deben definirse después de los parámetros sin valores predeterminados para evitar errores de sintaxis:

def describir_persona(nombre, edad=30):
    print(f"{nombre} tiene {edad} años")

describir_persona("Carlos")      # Salida: Carlos tiene 30 años
describir_persona("Ana", 25)     # Salida: Ana tiene 25 años

Funciones con Argumentos Arbitrarios

En algunos casos, es útil definir funciones que acepten un número variable de argumentos. Python permite esto usando *args para argumentos posicionales y **kwargs para argumentos con nombre.

Por ejemplo, una función que suma un número variable de valores:

def sumar_todos(*args):
    return sum(args)

print(sumar_todos(1, 2, 3))       # Salida: 6
print(sumar_todos(10, 20, 30, 40)) # Salida: 100

La variable *args recoge todos los argumentos posicionales en una tupla. De manera similar, **kwargs recoge argumentos con nombre en un diccionario:

def describir_config(**kwargs):
    for clave, valor in kwargs.items():
        print(f"{clave}: {valor}")

describir_config(color="azul", tamano="grande")
# Salida:
# color: azul
# tamano: grande

Estas características hacen que las funciones sean extremadamente flexibles para manejar diferentes casos de uso.

Conclusiones

Las funciones en Python son una herramienta poderosa para escribir código modular, reutilizable y fácil de mantener. Al dominar cómo llamar una función, definirla con parámetros, devolver valores y manejar funciones anidadas, puedes optimizar tus programas y hacerlos más robustos. Además, al seguir buenas prácticas como usar nombres descriptivos, documentar el código y evitar errores comunes, mejorarás la calidad de tu código. Los ejemplos proporcionados en este tutorial, desde funciones simples hasta funciones anidadas y con argumentos variables, te ayudarán a aplicar estos conceptos en tus proyectos. Python ofrece una sintaxis clara y flexible para trabajar con funciones, lo que las convierte en una de las características más valiosas del lenguaje. Practica con estos ejemplos y experimenta creando tus propias funciones para consolidar tu aprendizaje.