Conceptos Clave de Python: Funciones, Scope y Manejo de Errores

Funciones en Python

Las funciones son bloques de código reutilizables que se definen una vez y solo se ejecutan cuando son llamadas. Permiten estructurar el código de manera modular y organizada.

Sintaxis básica:

def nombre_de_la_funcion(parametro1, parametro2):
    # Cuerpo de la función
    resultado = parametro1 + parametro2
    return resultado

Una función puede retornar valores utilizando la palabra clave return o no retornar ninguno (en cuyo caso, implícitamente retorna None).

Argumentos por palabra clave (Keyword Arguments)

Es posible llamar a una función especificando el nombre de cada argumento. Por ejemplo, para una función f(nombre, apellido, edad):

funcion(nombre='Juan', apellido='Pérez', edad=30)

Al usar argumentos por palabra clave, el orden en que se pasan los parámetros es irrelevante.

Ámbito de las Variables (Scope)

El 'ámbito' o scope se refiere al contexto en el que una variable es definida y puede ser accedida. Python busca las variables siguiendo un orden de prioridad conocido como la regla LEGB:

• Local: Dentro de la función actual.
• Enclosing (Cercano): En el ámbito de las funciones envolventes (para funciones anidadas).
• Global: En el nivel superior del módulo o script.
• Built-in (Integrado): Nombres predefinidos en Python (ej. print, len).

a) Ámbito Local

Una variable definida dentro de una función es local a esa función. Solo puede ser accedida desde su interior.

b) Ámbito Global

Son las variables definidas en el nivel principal del script. Pueden ser accedidas desde cualquier parte del programa. Sin embargo, para modificar una variable global desde dentro de una función, se debe usar la palabra clave global.

hola = 1

def cambia_hola():
    global hola  # Indicamos que usaremos la variable global
    hola = 2
    print(f"Dentro de la función: {hola}")

cambia_hola()
print(f"Fuera de la función: {hola}") # Imprime 2

Sin la línea global hola, la función crearía una nueva variable local llamada hola, sin afectar a la global.

c) La palabra clave `nonlocal`

Se utiliza en funciones anidadas para indicar que una variable se refiere a otra en el ámbito de la función externa más cercana (ámbito enclosing), pero que no es global.

def externa():
    x = 10  # Variable en el ámbito 'enclosing'

    def interna():
        nonlocal x
        x += 5
        print(f"Dentro de interna: {x}")

    interna()
    print(f"Dentro de externa: {x}")

externa() # Imprimirá 15 en ambos casos

Argumentos Flexibles: `*args` y `**kwargs`

`*args` para argumentos posicionales

El parámetro *args permite a una función recibir un número variable de argumentos posicionales. Estos se empaquetan automáticamente en una tupla.

def sumar_todo(*args):
    total = 0
    for numero in args: # Recorremos la tupla creada
        total += numero
    return total

print(sumar_todo(1, 2, 6, 3, 8)) # Imprime 20

Nota: El nombre args es una convención. Lo importante es el asterisco (*); podrías usar *numeros o cualquier otro nombre válido.

`**kwargs` para argumentos de palabra clave

De forma similar, **kwargs permite pasar un número variable de argumentos por palabra clave. Estos se empaquetan en un diccionario.

def saludar(**kwargs):
    print(f"Hola, {kwargs['nombre']} {kwargs['apellido']}")
    # También se puede recorrer el diccionario:
    for clave, valor in kwargs.items():
        print(f"{clave}: {valor}")

saludar(nombre='Ana', apellido='García', ciudad='Madrid')

Formateo de Cadenas (Strings)

Método `str.format()`

El método format() es una manera versátil de formatear cadenas de texto. Las variables se insertan en los marcadores {} en el orden en que aparecen.

nombre = 'Rodrigo'
apellido = 'González'
print('Hola, mi nombre es {} y mi apellido es {}'.format(nombre, apellido))

F-Strings (Cadenas literales formateadas)

Introducidas en Python 3.6, las f-strings ofrecen una sintaxis más concisa, legible y eficiente. Se prefijan con la letra f.

nombre = 'Rodrigo'
apellido = 'González'
print(f"Hola, mi nombre es {nombre} y mi apellido es {apellido}")

El Módulo `random` para Números Aleatorios

Este módulo proporciona funciones para generar números pseudoaleatorios. Para usarlo, primero debe importarse con import random.

• random.randint(a, b): Genera un número entero aleatorio N tal que a <= N <= b.
• random.random(): Genera un número de punto flotante aleatorio en el intervalo [0.0, 1.0).
• random.choice(secuencia): Elige un elemento aleatorio de una secuencia no vacía (como una lista).
• random.shuffle(lista): Mezcla los elementos de una lista in-place (modifica la lista original y no retorna un nuevo valor).

Manejo de Excepciones con `try...except`

El manejo de excepciones permite controlar los errores que pueden ocurrir durante la ejecución de un programa, evitando que se detenga abruptamente. Se utiliza la estructura try...except.

try:
    numerador = int(input("Ingrese el numerador: "))
    denominador = int(input("Ingrese el denominador: "))
    resultado = numerador / denominador
    print(resultado)
except ZeroDivisionError:
    print("Error: No puedes dividir por cero.")
except ValueError:
    print("Error: Debes ingresar un número válido.")

La cláusula `finally`

El bloque de código dentro de finally se ejecutará siempre, sin importar si ocurrió una excepción o no. Es ideal para tareas de limpieza, como cerrar archivos o conexiones de red.

try:
    # Código que puede fallar
    pass
except Exception as e:
    # Manejo del error
    print(f"Ocurrió un error: {e}")
finally:
    # Este bloque se ejecuta siempre
    print("Ejecución finalizada.")

Es una buena práctica especificar el tipo de error que se espera en el bloque except (ej. except ValueError:) para manejar diferentes errores de forma distinta y conocer las excepciones integradas de Python.