En Python, las funciones son bloques de código reutilizables que realizan tareas específicas. Permiten organizar el código, mejorar la legibilidad y evitar la duplicación.

1. Definición y Llamada de Funciones

Las funciones se definen utilizando la palabra clave def, seguida del nombre de la función, paréntesis () y dos puntos :. El cuerpo de la función debe estar indentado. Para ejecutar una función, se llama por su nombre seguido de paréntesis.

def calcular_suma_hasta(limite):
    suma_total = 0
    for i in range(1, limite + 1):
        suma_total += i
    print(f"La suma es: {suma_total}")

calcular_suma_hasta(100)

2. Parámetros de Funciones

Los parámetros permiten pasar valores a las funciones.

2.1. Parámetros Posicionales

Los argumentos se pasan en el orden en que se definen los parámetros.

def mostrar_info_usuario(nombre, edad):
    print(f"Nombre: {nombre}, Edad: {edad}")

mostrar_info_usuario("Alice", 30)

2.2. Parámetros de Palabra Clave (Keyword Arguments)

Los argumentos se pasan especificando el nombre del parámetro.

def mostrar_info_usuario(nombre, edad):
    print(f"Nombre: {nombre}, Edad: {edad}")

mostrar_info_usuario(edad=25, nombre="Bob")

Se pueden combinar parámetros posicionales y de palabra clave, pero los posicionales deben ir primero.

2.3. Parámetros con Valor por Defecto

Se asigna un valor por defecto a un parámetro en la definición de la función.

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

saludar("Charlie") # Usará el saludo por defecto
saludar("David", "Buenos días") # Usará el saludo proporcionado

2.4. Parámetros de Número Variable

2.4.1. Parámetros Posicionales Variables (*args)

Permite pasar un número variable de argumentos posicionales, que se reciben como una tupla.

def procesar_elementos(*elementos):
    print(type(elementos))
    for elem in elementos:
        print(elem)

procesar_elementos(10, 20, 30)
lista_datos = [40, 50]
procesar_elementos(*lista_datos) # Desempaqueta la lista como argumentos

2.4.2. Parámetros de Palabra Clave Variables (**kwargs)

Permite pasar un número variable de argumentos de palabra clave, que se reciben como un diccionario.

def configurar_opciones(**config):
    print(type(config))
    for clave, valor in config.items():
        print(f"{clave}: {valor}")

configuracion = {"modo": "debug", "nivel": "info"}
configurar_opciones(**configuracion) # Desempaqueta el diccionario como argumentos de palabra clave

3. Valor de Retorno de Funciones

La palabra clave return se utiliza para devolver un valor desde una función. Si no se especifica return, la función devuelve None por defecto.

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

valor_devuelto = sumar(5, 7)
print(f"Resultado de la suma: {valor_devuelto}")

Una función puede devolver múltiples valores, los cuales se empaquetan como una tupla.

def analizar_numeros(n):
    impares = 0
    pares = 0
    total = 0
    for i in range(1, n + 1):
        if i % 2 != 0:
            impares += i
        else:
            pares += i
        total += i
    return impares, pares, total

resultado_analisis = analizar_numeros(10)
print(f"Tipo del resultado: {type(resultado_analisis)}")
print(f"Análisis: {resultado_analisis}")

4. Ámbito de Varibales

4.1. Variables Locales

Las variables definidas dentro de una función son locales a esa función y solo existen mientras la función se está ejecutando.

def operacion_local():
    variable_local = 50
    print(f"Dentro de la función: {variable_local}")

operacion_local()
# print(variable_local) # Esto generaría un error NameError

4.2. Variables Globales

Las variables definidas fuera de cualquier función son globales y accesibles desde cualquier parte del programa. Para modificar una variable global dentro de una función, se usa la palabra clave global.

variable_global = 100

def modificar_global(a, b):
    # Para modificar la variable_global, necesitamos declararla
    global variable_global
    variable_global = 200 # Modifica la variable global
    suma_parcial = variable_global + a + b
    return suma_parcial

print(f"Valor global inicial: {variable_global}")
resultado_mod = modificar_global(10, 5)
print(f"Resultado después de modificar global: {resultado_mod}")
print(f"Valor global después de la llamada: {variable_global}")

# Si el nombre de la variable local coincide con la global sin usar 'global'
variable_global_ejemplo = 100
def sin_modificar_global(a, b):
    variable_global_ejemplo = 50 # Crea una nueva variable local
    suma_total = variable_global_ejemplo + a + b
    return suma_total

resultado_sin_mod = sin_modificar_global(10, 5)
print(f"Resultado sin modificar global: {resultado_sin_mod}") # Muestra 65
print(f"Variable global original sin afectar: {variable_global_ejemplo}") # Muestra 100

5. Funciones Anónimas (Lambda)

Son funciones pequeñas y de una sola expresión, definidas con la palabra clave lambda. Son útiles para operaciones rápidas donde no se necesita definir una función completa.

sumar_lambda = lambda x, y: x + y
print(f"Suma lambda: {sumar_lambda(5, 10)}")

# Uso en ordenación
lista_estudiantes = [
    {"nombre": "Ana", "nota": 88},
    {"nombre": "Luis", "nota": 95},
    {"nombre": "Carlos", "nota": 92},
]
lista_estudiantes.sort(key=lambda estudiante: estudiante.get("nota"), reverse=True)
print(f"Estudiantes ordenados por nota: {lista_estudiantes}")

6. Recursión

La recursión ocurre cuando una función se llama a sí misma. Requiere una condición de parada (caso base) para evitar bucles infinitos.

# Cálculo de factorial
def factorial(n):
    if n == 1: # Caso base
        return 1
    else:
        return n * factorial(n - 1) # Llamada recursiva

print(f"Factorial de 4: {factorial(4)}")

# Secuencia de Fibonacci (ejemplo conceptual, puede ser ineficiente)
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

# print(f"Fibonacci de 7: {fibonacci(7)}") # Ejemplo para mostrar la idea

7. Funciones Integradas Comunes

• bool(x): Convierte un valor a booleano. Las colecciones vacías (listas, tuplas, diccionarios, cadenas vacías) y None se evalúa como False.
• str(x): Convierte un objeto a su representación de cadena.
• int(x): Convierte un objeto a un entero.
• list(iterable): Cnovierte un iterable (como una cadena o una tupla) en una lista.

Ejemplo con str() y list()

mi_lista = [1, 'a', 3.14]
cadena_lista = str(mi_lista)
print(f"Lista convertida a cadena: {cadena_lista}, Tipo: {type(cadena_lista)}")

cadena_ejemplo = "Python"
lista_desde_cadena = list(cadena_ejemplo)
print(f"Cadena convertida a lista: {lista_desde_cadena}")