En programación, una función es un bloque de código que agrupa un conjunto de instrucciones que se pueden ejecutar de forma repetida y reutilizable. Su objetivo principal es llevar a cabo una tarea específica, y se pueden utilizar tantas veces como sea necesario, sin tener que escribir el mismo código una y otra vez. Este concepto es crucial para la organización y simplificación de los programas, ya que permite dividir un programa complejo en pequeñas unidades de trabajo llamadas funciones, cada una encargada de realizar una tarea específica.

Una de las grandes ventajas de las funciones es que permiten modularizar el código, haciendo que sea más fácil de leer, mantener y depurar. Las funciones también ayudan a evitar la duplicación de código, lo que mejora la eficiencia y la claridad en los programas.

En Python, las funciones pueden aceptar parámetros como entradas, lo que les permite recibir valores desde el exterior, y pueden devolver un resultado utilizando la palabra clave return. Al hacer esto, las funciones no solo realizan una acción, sino que también pueden interactuar con el resto del programa, entregando resultados que pueden ser utilizados en otras partes del código.

La sintaxis básica para definir una función en Python es bastante sencilla y se compone de los siguientes componentes:

                        
def nombre_funcion(parametro1, parametro2):
    # Código a ejecutar
    return resultado

                        
                    

• def es la palabra clave que indica que estamos definiendo una función.
• nombre_funcion es el nombre que le damos a la función, y debe seguir las reglas estándar de los identificadores en Python.
• parametro1, parametro2, ... son los parámetros que la función acepta. Son valores que se pasan a la función cuando se llama.
• return es utilizado para devolver un valor desde la función al programa principal.

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

resultado = suma(5, 3)
print(resultado)  # Imprime 8

                        
                    

• Definición de la función:
  • La función suma se define con def, y toma dos parámetros a y b.
  • Dentro de la función, la operación a + b se realiza y el resultado se retorna con return.
• Llamada de la función:
  • Cuando llamamos suma(5, 3), los valores 5 y 3 son pasados como parámetros a la función.
  • El resultado de la suma de 5 y 3 es 8, y ese valor es retornado por la función.
• Uso de return:
  • La palabra clave return envía el resultado fuera de la función, permitiendo que el valor sea capturado en la variable resultado para su uso posterior.

Los parámetros son los valores que las funciones reciben para realizar sus operaciones. En el ejemplo anterior, los parámetros son a y b en la función suma. Los parámetros pueden ser cualquier tipo de dato válido en Python (números, cadenas, listas, etc.).

1. Parámetros Posicionales: Son los parámetros más comunes. Los valores se asignan a los parámetros de la función según el orden en que se pasan.

Ejemplo:

                        
def saludar(nombre, edad):
    print(f"Hola, {nombre}. Tienes {edad} años.")

saludar("Juan", 25)  # Imprime: Hola, Juan. Tienes 25 años.

                        
                    

2. Parámetros con Valores Predeterminados: Los parámetros pueden tener valores predeterminados. Si no se pasa un valor al llamar a la función, se usará el valor predeterminado.

Ejemplo:

                        
def saludar(nombre="Estudiante"):
    print(f"Hola, {nombre}.")

saludar()  # Imprime: Hola, Estudiante.
saludar("Carlos")  # Imprime: Hola, Carlos.

                        
                    

3. Parámetros Variables (Argumentos Arbitrarios): Usamos *args para permitir que una función reciba un número variable de argumentos posicionales.

Ejemplo:

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

print(sumar_todos(1, 2, 3, 4))  # Imprime 10

                        
                    

La palabra clave return es esencial porque permite que la función devuelva un valor al código que la llamó. Sin return, la función simplemente ejecutará su código sin enviar nada de vuelta al resto del programa.

Ejemplo de Función con return:

                        
def multiplicar(a, b):
    return a * b

resultado = multiplicar(4, 3)
print(resultado)  # Imprime 12

                        
                    

En este ejemplo:

• La función multiplicar toma dos parámetros, a y b, y retorna el producto de estos dos.
• El valor retornado por la función se almacena en la variable resultado y se imprime.

Figura 1: Diagrama de flujo para una función básica Fuente: Creación de autor, D. Nicolalde.

×

Descripción: Este diagrama muestra cómo el flujo de ejecución se mueve hacia una función, recibe parámetros y retorna un valor.

En programación, el alcance de una variable hace referencia a la parte del programa donde esa variable puede ser utilizada. Existen dos tipos de alcance principales para las variables: local y global. La distinción entre estas dos es fundamental para el diseño y la correcta funcionalidad de los programas, ya que influye en la accesibilidad, manipulación y gestión de los datos dentro del código.

En Python, las variables pueden ser locales, globales o no locales, dependiendo de dónde se definen y cómo se accede a ellas.

Las variables locales son aquellas que se definen dentro de una función y solo son accesibles dentro de esa función. Esto significa que su existencia está limitada al bloque de código donde fueron creadas. Una vez que la función termina su ejecución, las variables locales dejan de existir.

En el siguiente ejemplo, la variable x se define dentro de la función ejemplo_local(), por lo que solo puede ser utilizada dentro de esa función:

                        
def ejemplo_local():
    x = 10  # Variable local
    print(x)

ejemplo_local()  # Imprime 10
# print(x)  # Esto causaría un error, ya que x es local

                        
                    

• La variable x es local a la función ejemplo_local().
• Dentro de la función, podemos acceder y modificar x sin problemas.
• Sin embargo, si tratamos de acceder a x fuera de la función, como en el comentario de la línea siguiente (print(x) fuera de la función), Python lanzará un error NameError, porque x no existe fuera del alcance de la función.

Este concepto de alcance local es importante para evitar conflictos entre variables, ya que no se pueden sobrescribir ni alterar desde otras partes del programa.

• Accesibilidad limitada: Solo son accesibles dentro de la función donde se definieron.
• Duración de vida: Existen únicamente durante la ejecución de la función. Una vez que la función termina, la variable local se destruye.
• Evitan conflictos: Dado que las variables locales no afectan a otras partes del programa, no hay riesgo de que se sobrescriban accidentalmente.

Figura 2: Diagrama de flujo de variable local Fuente: Creación de autor, D. Nicolalde.

×

Descripción: Este diagrama muestra cómo las variables locales solo están accesibles dentro de su función respectiva.

Las variables globales son aquellas que se definen fuera de todas las funciones, generalmente al principio del programa. A diferencia de las variables locales, las variables globales son accesibles desde cualquier parte del código, incluyendo dentro de las funciones.

En el siguiente ejemplo, la variable x es global, ya que está definida fuera de cualquier función. Esto permite que pueda ser accedida y modificada tanto dentro como fuera de las funciones:

                        
x = 10  # Variable global

def ejemplo_global():
    print(x)  # Accede a la variable global x

ejemplo_global()  # Imprime 10
print(x)  # Imprime 10 fuera de la función

                        
                    

• La variable x se define fuera de cualquier función, por lo que se considera una variable global.
• Dentro de la función ejemplo_global(), podemos acceder a x sin problemas y la función imprime su valor correctamente.
• Además, fuera de la función, podemos seguir accediendo a x, ya que la variable global sigue existiendo en el programa.

• Accesibilidad global: Son accesibles desde cualquier parte del programa, tanto dentro como fuera de las funciones.
• Duración de vida: Existen durante toda la ejecución del programa, desde el inicio hasta el final.
• Pueden ser modificadas dentro de las funciones: Si se desea modificar una variable global dentro de una función, se debe utilizar la palabra clave global.

Figura 3: Diagrama de flujo de variable global Fuente: Creación de autor, D. Nicolalde.

×

Descripción: Este diagrama muestra cómo las variables globales pueden ser accedidas desde cualquier parte del código, incluyendo dentro de funciones.

Para modificar una variable global dentro de una función, es necesario usar la palabra clave global. Esto le dice a Python que la variable que se está utilizando dentro de la función debe referirse a la variable global, no a una variable local.

                        
 x = 10  # Variable global

def modificar_global():
    global x  # Indica que queremos modificar la variable global x
    x = 20  # Cambia el valor de x

modificar_global()
print(x)  # Imprime 20

                        
                    

• La variable x es global y su valor inicial es 10.
• Dentro de la función modificar_global(), usamos la palabra clave global para referirnos a la variable global x.
• La asignación x = 20 cambia el valor de la variable global a 20.
• Al imprimir x después de llamar a la función, veremos que su valor ha cambiado a 20.

• Uso preferido de variables locales: Siempre que sea posible, utiliza variables locales para evitar problemas de modificación no deseada de datos en otras partes del programa.
• Evita el uso excesivo de variables globales: El uso de variables globales puede hacer que el programa sea difícil de depurar, ya que las variables pueden ser modificadas en múltiples lugares, lo que puede causar efectos secundarios difíciles de rastrear.
• Uso de global con precaución: Si necesitas modificar una variable global dentro de una función, usa la palabra clave global con cuidado y asegúrate de que la lógica del programa justifique la necesidad de hacerlo.

                        
# Lista global
nombres = ["Juan", "Ana", "Luis"]

def agregar_nombre(nombre):
    global nombres
    nombres.append(nombre)  # Agrega un nuevo nombre

agregar_nombre("Marta")
print(nombres)  # Imprime ['Juan', 'Ana', 'Luis', 'Marta']

                        
                    

• Definimos la lista global nombres y la función agregar_nombre para añadir nombres a la lista. Usamos global para modificar la lista.

Nombre_de_la_figura

×

Descripción: Este diagrama muestra cómo modificar variables globales dentro de funciones usando la palabra clave global.

                        
# Función para calcular el promedio
def calcular_promedio(calificaciones):
    return sum(calificaciones) / len(calificaciones)

# Función para clasificar a los estudiantes
def clasificar_estudiante(nombre, calificaciones):
    promedio = calcular_promedio(calificaciones)
    if promedio >= 9:
        estado = "Excelente"
    elif promedio >= 6:
        estado = "Aprobado"
    else:
        estado = "Reprobado"
    return nombre, promedio, estado

# Procesar varios estudiantes
def procesar_estudiantes():
    estudiantes = {
        "Juan": [8, 7, 6, 9],
        "Ana": [9, 10, 8, 9],
        "Luis": [5, 4, 6, 4]
    }
    for nombre, calificaciones in estudiantes.items():
        estudiante, promedio, estado = clasificar_estudiante(nombre, calificaciones)
        print(f"{estudiante}: Promedio = {promedio:.2f}, Estado = {estado}")

procesar_estudiantes()

                        
                    

• calcular_promedio calcula el promedio de las calificaciones.
• clasificar_estudiante determina si el estudiante está "Excelente", "Aprobado" o "Reprobado".
• procesar_estudiantes maneja varios estudiantes y muestra su clasificación.

Figura 5: Diagrama de flujo para el cálculo de promedios Fuente: Creación de autor, D. Nicolalde.

×

Descripción: Este diagrama muestra cómo las funciones se conectan para calcular el promedio y clasificar a los estudiantes.

                        
 # Inventario inicial
inventario = [
    {"producto": "Camiseta", "cantidad": 10, "precio": 15.5},
    {"producto": "Pantalón", "cantidad": 5, "precio": 25.0},
    {"producto": "Zapatos", "cantidad": 0, "precio": 40.0}
]

 # Función para agregar productos
def agregar_producto(nombre, cantidad, precio):
    inventario.append({"producto": nombre, "cantidad": cantidad, "precio": precio})

 # Función para mostrar el inventario
def mostrar_inventario():
    for producto in inventario:
        print(f"Producto: {producto['producto']}, Cantidad: {producto['cantidad']}, Precio: {producto['precio']}")

 # Función para vender productos
def vender_producto(nombre, cantidad):
    for producto in inventario:
        if producto["producto"] == nombre and producto["cantidad"] >= cantidad:
            producto["cantidad"] -= cantidad
            print(f"Se vendieron {cantidad} {nombre}(s).")
            return
    print(f"No hay suficiente stock de {nombre}.")

 # Ejemplo de uso
mostrar_inventario()
agregar_producto("Chaqueta", 3, 35.0)
vender_producto("Camiseta", 2)
mostrar_inventario()

                        
                    

• El inventario está compuesto por una lista de diccionarios donde cada producto tiene un nombre, cantidad y precio.
• La función agregar_producto añade productos nuevos al inventario.
• mostrar_inventario imprime el inventario completo.
• vender_producto disminuye la cantidad de un producto cuando se vende.

Figura 6: Diagrama de flujo para el manejo del inventario Fuente: Creación de autor, D. Nicolalde.

×

La tabla 1 resume los aspectos más importantes de las funciones en Python, como su definición, los parámetros que pueden recibir y cómo retornan valores. También se mencionan ejemplos básicos de su uso.

La tabla 2 compara las diferencias entre las variables locales y globales en Python, mostrando cómo se definen y cómo se accede a ellas, además de los casos donde se pueden modificar.

A lo largo de esta clase, hemos cubierto los conceptos esenciales de funciones, alcance de variables, y arreglos multidimensionales en Python. Vimos cómo definir y utilizar funciones, cómo se pueden manejar las variables locales y globales, y cómo manipular matrices y listas para resolver problemas complejos. Al integrar estas herramientas, los estudiantes podrán desarrollar programas más eficientes, organizados y escalables, lo cual es esencial para resolver problemas de programación de mediana y alta complejidad.