Funciones en Python: Guía Completa [Sintaxis, Parámetros y Ejemplos]

¿Qué son las funciones en Python?

Las funciones son bloques de código reutilizables que realizan una tarea específica. Son uno de los conceptos fundamentales de la programación y te permiten organizar tu código de manera más clara, evitar repetición y facilitar el mantenimiento.

Piensa en una función como una receta de cocina: defines los ingredientes (parámetros), los pasos a seguir (el cuerpo de la función) y obtienes un resultado (el valor de retorno). Una vez que tienes la receta, puedes usarla tantas veces como quieras sin tener que escribir todos los pasos nuevamente.

Ventajas de usar funciones:

• Reutilización de código – Escribe una vez, usa muchas veces
• Organización – Divide problemas complejos en partes más pequeñas
• Mantenibilidad – Cambios en un solo lugar afectan todos los usos
• Legibilidad – Código más claro y autodocumentado
• Testing – Más fácil probar unidades individuales de código

Sintaxis básica de una función en Python

La sintaxis para definir una función en Python es simple y elegante. Usamos la palabra clave def seguida del nombre de la función y paréntesis:

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

# Llamar a la función
saludar()
# Salida: ¡Hola, mundo!

Anatomía de una función

Veamos las partes que componen una función:

def nombre_funcion(parametro1, parametro2):  # 1. Definición
    """Docstring: descripción de la función"""  # 2. Documentación (opcional)
    # 3. Cuerpo de la función (indentado)
    resultado = parametro1 + parametro2
    return resultado  # 4. Retorno (opcional)

Componentes:

1. def – Palabra clave que inicia la definición
2. Nombre – Debe ser descriptivo y seguir snake_case
3. Parámetros – Variables que recibe la función (opcionales)
4. Docstring – Documentación de la función (opcional pero recomendado)
5. Cuerpo – Código indentado que se ejecuta
6. return – Devuelve un valor (opcional)

Funciones con parámetros

Los parámetros permiten que las funciones sean más flexibles y reutilizables. Puedes pasar información a la función para que trabaje con diferentes datos.

Parámetros posicionales

Los parámetros se pasan en el orden en que están definidos:

def calcular_area_rectangulo(ancho, alto):
    """Calcula el área de un rectángulo"""
    area = ancho * alto
    return area

# Llamar a la función
resultado = calcular_area_rectangulo(5, 10)
print(resultado)  # Salida: 50

# El orden importa
resultado2 = calcular_area_rectangulo(10, 5)
print(resultado2)  # Salida: 50 (mismo resultado en este caso)

Parámetros con nombre (keyword arguments)

Puedes especificar los parámetros por nombre, lo que hace el código más claro:

def crear_usuario(nombre, edad, ciudad):
    return f"{nombre}, {edad} años, de {ciudad}"

# Usando parámetros posicionales
usuario1 = crear_usuario("Ana", 25, "Madrid")

# Usando parámetros con nombre (más claro)
usuario2 = crear_usuario(nombre="Carlos", edad=30, ciudad="Barcelona")

# Puedes cambiar el orden si usas nombres
usuario3 = crear_usuario(ciudad="Valencia", nombre="Laura", edad=28)

print(usuario1)  # Ana, 25 años, de Madrid
print(usuario2)  # Carlos, 30 años, de Barcelona
print(usuario3)  # Laura, 28 años, de Valencia

Parámetros con valores por defecto

Puedes definir valores predeterminados para parámetros opcionales:

def saludar(nombre, saludo="Hola"):
    """Saluda a una persona con un saludo personalizable"""
    return f"{saludo}, {nombre}!"

print(saludar("María"))  # Hola, María!
print(saludar("Pedro", "Buenos días"))  # Buenos días, Pedro!
print(saludar("Ana", saludo="Qué tal"))  # Qué tal, Ana!

Importante: Los parámetros con valores por defecto deben ir después de los parámetros obligatorios:

# Correcto
def funcion(param_obligatorio, param_opcional="valor"):
    pass

# Incorrecto - SyntaxError
def funcion(param_opcional="valor", param_obligatorio):
    pass

La sentencia return

La palabra clave return se usa para devolver un valor desde una función. Cuando Python encuentra un return, la función termina inmediatamente y devuelve el valor especificado.

Return simple

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

resultado = sumar(5, 3)
print(resultado)  # 8

Return múltiple (tuplas)

Python permite devolver múltiples valores usando tuplas:

def calcular_estadisticas(numeros):
    """Calcula suma, promedio y máximo de una lista"""
    total = sum(numeros)
    promedio = total / len(numeros)
    maximo = max(numeros)
    return total, promedio, maximo  # Devuelve una tupla

# Desempaquetado de valores
suma, prom, max_val = calcular_estadisticas([10, 20, 30, 40, 50])
print(f"Suma: {suma}, Promedio: {prom}, Máximo: {max_val}")
# Salida: Suma: 150, Promedio: 30.0, Máximo: 50

Funciones sin return

Si una función no tiene return, devuelve None implícitamente:

def imprimir_mensaje(mensaje):
    print(mensaje)
    # No hay return

resultado = imprimir_mensaje("Hola")
print(resultado)  # None

Return anticipado

Puedes usar return para salir de una función antes de tiempo:

def es_par(numero):
    """Verifica si un número es par"""
    if numero % 2 == 0:
        return True  # Sale aquí si es par
    return False  # Solo se ejecuta si no es par

print(es_par(4))   # True
print(es_par(7))   # False

Ámbito de variables (scope)

El ámbito o «scope» de una variable determina desde dónde se puede acceder a ella. Python tiene dos ámbitos principales:

Variables locales

Las variables definidas dentro de una función solo existen dentro de esa función:

def calcular_impuesto(precio):
    impuesto = precio * 0.21  # Variable local
    return impuesto

resultado = calcular_impuesto(100)
print(resultado)  # 21.0

# Esto da error - NameError
print(impuesto)  # impuesto no existe fuera de la función

Variables globales

Las variables definidas fuera de funciones son accesibles desde cualquier parte:

tasa_iva = 0.21  # Variable global

def calcular_precio_final(precio):
    # Podemos leer variables globales
    return precio * (1 + tasa_iva)

print(calcular_precio_final(100))  # 121.0

Modificar variables globales

Para modificar una variable global dentro de una función, usa global:

contador = 0  # Variable global

def incrementar_contador():
    global contador  # Declara que vamos a modificar la global
    contador += 1

incrementar_contador()
print(contador)  # 1

incrementar_contador()
print(contador)  # 2

Buena práctica: Evita usar variables globales cuando sea posible. Es mejor pasar valores como parámetros y devolver resultados con return.

*args y **kwargs

Python ofrece formas flexibles de trabajar con número variable de argumentos.

*args – Argumentos posicionales variables

Permite pasar cualquier número de argumentos posicionales:

def sumar_todos(*numeros):
    """Suma cualquier cantidad de números"""
    total = 0
    for num in numeros:
        total += num
    return total

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

Internamente, *args crea una tupla con todos los argumentos:

def mostrar_args(*args):
    print(f"Tipo: {type(args)}")
    print(f"Valores: {args}")

mostrar_args(1, 2, 3, "cuatro")
# Tipo: <class 'tuple'>
# Valores: (1, 2, 3, 'cuatro')

**kwargs – Argumentos con nombre variables

Permite pasar cualquier número de argumentos con nombre:

def crear_perfil(**datos):
    """Crea un perfil de usuario con datos variables"""
    print("Perfil de usuario:")
    for clave, valor in datos.items():
        print(f"  {clave}: {valor}")

crear_perfil(nombre="Ana", edad=25, ciudad="Madrid")
# Perfil de usuario:
#   nombre: Ana
#   edad: 25
#   ciudad: Madrid

crear_perfil(nombre="Carlos", profesion="Ingeniero", pais="España", hobby="Ciclismo")
# Perfil de usuario:
#   nombre: Carlos
#   profesion: Ingeniero
#   pais: España
#   hobby: Ciclismo

Combinando todo

Puedes combinar parámetros normales, *args y **kwargs:

def funcion_completa(param_obligatorio, param_opcional="default", *args, **kwargs):
    print(f"Obligatorio: {param_obligatorio}")
    print(f"Opcional: {param_opcional}")
    print(f"Args adicionales: {args}")
    print(f"Kwargs adicionales: {kwargs}")

funcion_completa(
    "valor1",
    "valor2",
    "extra1",
    "extra2",
    clave1="valor_clave1",
    clave2="valor_clave2"
)
# Obligatorio: valor1
# Opcional: valor2
# Args adicionales: ('extra1', 'extra2')
# Kwargs adicionales: {'clave1': 'valor_clave1', 'clave2': 'valor_clave2'}

Funciones anidadas

Puedes definir funciones dentro de otras funciones. Esto es útil para organizar código auxiliar que solo se usa dentro de una función específica.

def calcular_precio_con_descuento(precio, porcentaje_descuento):
    """Calcula precio final con descuento e IVA"""

    def aplicar_descuento(p, descuento):
        """Función auxiliar interna"""
        return p * (1 - descuento / 100)

    def aplicar_iva(p):
        """Función auxiliar interna"""
        return p * 1.21

    # Usar las funciones internas
    precio_con_descuento = aplicar_descuento(precio, porcentaje_descuento)
    precio_final = aplicar_iva(precio_con_descuento)

    return precio_final

print(calcular_precio_con_descuento(100, 10))  # 108.9

Las funciones internas tienen acceso a las variables de la función externa (closure):

def crear_multiplicador(factor):
    """Retorna una función que multiplica por 'factor'"""

    def multiplicar(numero):
        return numero * factor  # Accede a 'factor' de la función externa

    return multiplicar

# Crear funciones especializadas
duplicar = crear_multiplicador(2)
triplicar = crear_multiplicador(3)

print(duplicar(10))   # 20
print(triplicar(10))  # 30

Profundiza en funciones avanzadas

En el libro Python a fondo encontrarás decoradores, generadores, funciones de orden superior y patrones avanzados con ejercicios resueltos.

Ver el libro

Documentación con docstrings

Los docstrings son cadenas de documentación que describen qué hace una función. Se escriben justo después de la definición usando triple comillas:

def calcular_imc(peso, altura):
    """
    Calcula el Índice de Masa Corporal (IMC).

    Args:
        peso (float): Peso en kilogramos
        altura (float): Altura en metros

    Returns:
        float: El IMC calculado

    Examples:
        >>> calcular_imc(70, 1.75)
        22.86
    """
    return peso / (altura ** 2)

# Acceder al docstring
print(calcular_imc.__doc__)

Formatos populares de docstrings:

• Google Style – Usado en ejemplos anteriores
• NumPy/SciPy Style – Para proyectos científicos
• reStructuredText – Para Sphinx

Funciones como objetos de primera clase

En Python, las funciones son objetos de primera clase, lo que significa que puedes:

Asignar funciones a variables

def saludar(nombre):
    return f"Hola, {nombre}"

# Asignar la función a una variable
mi_saludo = saludar

print(mi_saludo("Ana"))  # Hola, Ana

Pasar funciones como argumentos

def aplicar_operacion(a, b, operacion):
    """Aplica una función a dos números"""
    return operacion(a, b)

def sumar(x, y):
    return x + y

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

print(aplicar_operacion(5, 3, sumar))        # 8
print(aplicar_operacion(5, 3, multiplicar))  # 15

Retornar funciones

def elegir_operacion(tipo):
    """Retorna una función según el tipo de operación"""

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

    def restar(a, b):
        return a - b

    if tipo == "suma":
        return sumar
    elif tipo == "resta":
        return restar

# Obtener la función deseada
operacion = elegir_operacion("suma")
resultado = operacion(10, 5)
print(resultado)  # 15

Casos de uso prácticos

Validación de datos

def validar_email(email):
    """Valida formato básico de email"""
    if "@" not in email:
        return False
    if "." not in email.split("@")[1]:
        return False
    return True

print(validar_email("usuario@ejemplo.com"))    # True
print(validar_email("usuario@ejemplo"))        # False
print(validar_email("usuario.ejemplo.com"))    # False

Cálculos reutilizables

def calcular_descuento(precio, porcentaje):
    """Calcula el precio con descuento aplicado"""
    descuento = precio * (porcentaje / 100)
    return precio - descuento

# Usar en múltiples escenarios
precio_camisa = calcular_descuento(50, 20)      # 40.0
precio_pantalon = calcular_descuento(80, 15)    # 68.0
precio_zapatos = calcular_descuento(100, 30)    # 70.0

Procesamiento de listas

def filtrar_pares(numeros):
    """Retorna solo los números pares de una lista"""
    pares = []
    for num in numeros:
        if num % 2 == 0:
            pares.append(num)
    return pares

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(filtrar_pares(lista))  # [2, 4, 6, 8, 10]

Sistema de menú

def mostrar_menu():
    """Muestra las opciones del menú"""
    print("\n=== MENÚ PRINCIPAL ===")
    print("1. Opción 1")
    print("2. Opción 2")
    print("3. Salir")

def procesar_opcion(opcion):
    """Procesa la opción seleccionada"""
    if opcion == "1":
        return "Ejecutando opción 1..."
    elif opcion == "2":
        return "Ejecutando opción 2..."
    elif opcion == "3":
        return "¡Hasta luego!"
    else:
        return "Opción no válida"

# Uso
mostrar_menu()
# opcion = input("Selecciona una opción: ")
# print(procesar_opcion(opcion))

Errores comunes y cómo evitarlos

1. Olvidar los paréntesis al llamar a la función

def saludar():
    return "Hola"

# Incorrecto - devuelve el objeto función
print(saludar)    # <function saludar at 0x...>

# Correcto - ejecuta la función
print(saludar())  # Hola

2. Modificar parámetros mutables por defecto

# Incorrecto - comportamiento inesperado
def agregar_item(item, lista=[]):
    lista.append(item)
    return lista

print(agregar_item(1))  # [1]
print(agregar_item(2))  # [1, 2] - ¡Usa la misma lista!

# Correcto
def agregar_item(item, lista=None):
    if lista is None:
        lista = []
    lista.append(item)
    return lista

print(agregar_item(1))  # [1]
print(agregar_item(2))  # [2] - Nueva lista cada vez

3. No retornar nada cuando se espera un valor

def calcular_doble(numero):
    resultado = numero * 2
    # Olvidamos el return

valor = calcular_doble(5)
print(valor)  # None - ¡no es lo que queríamos!

# Correcto
def calcular_doble(numero):
    resultado = numero * 2
    return resultado

4. Confundir print con return

# Solo imprime, no devuelve
def sumar_mal(a, b):
    print(a + b)

# Devuelve el valor (mejor)
def sumar_bien(a, b):
    return a + b

# La diferencia
resultado1 = sumar_mal(2, 3)    # Imprime: 5
print(resultado1)                # None

resultado2 = sumar_bien(2, 3)    # No imprime nada
print(resultado2)                # 5

Puntos clave para recordar

Las funciones son bloques fundamentales en Python que te permiten escribir código más organizado, reutilizable y mantenible:

1. Sintaxis básica – Usa def nombre(parámetros): seguido de código indentado
2. Parámetros flexibles – Posicionales, con nombre, valores por defecto, *args, **kwargs
3. Return – Devuelve valores con return, puedes devolver múltiples valores como tupla
4. Scope – Variables locales vs globales, evita modificar globales
5. Docstrings – Documenta tus funciones con triple comillas
6. Primera clase – Las funciones son objetos: puedes asignarlas, pasarlas y retornarlas
7. Funciones anidadas – Define funciones dentro de funciones para código auxiliar
8. Buenas prácticas – Nombres descriptivos, funciones pequeñas que hacen una cosa bien

Pepitas de conocimiento

• Usa parámetros con nombre para mayor claridad en llamadas complejas
• Los parámetros con valores por defecto van al final
• *args captura argumentos posicionales variables, **kwargs captura argumentos con nombre
• Evita usar listas/diccionarios como valores por defecto de parámetros
• print() muestra información, return devuelve valores para usar después
• Las funciones sin return devuelven None implícitamente

Próximos pasos

Ahora que dominas las funciones básicas, es momento de explorar funciones lambda y programación funcional en Python para escribir código aún más elegante y conciso.

¿Listo para el siguiente nivel?

Descubre cómo usar funciones lambda, map, filter y reduce en Python:

Lambdas en Python: Funciones Anónimas

¿Te ha resultado útil esta guía? Compártela con otros pythonistas que estén aprendiendo a programar.

Para proyectos reales, ejercicios avanzados y patrones profesionales con funciones, consulta Python a fondo.