GUÍA DE LABORATORIO

ASIGNATURA: LENGUAJE DE PROGRAMACIÓN II

Ciclo: III
Ambiente: Laboratorio
Docente: Mg. Ing. Eva M. Vasquez Valle
Correo: [email protected]

PRÁCTICA - SEMANA N.º 03

TEMA: Funciones y Modularidad en Python

OBJETIVOS

• Comprender el concepto de modularidad y su importancia en el desarrollo de

software.
• Diseñar e implementar funciones definidas por el usuario para resolver problemas
específicos.
• Aplicar funciones anónimas (lambda) y funciones de orden superior para operaciones
avanzadas.
• Entender los diferentes tipos de parámetros y mecanismos de retorno de valores en
funciones.
• Desarrollar habilidades para la descomposición de problemas complejos en
subproblemas mediante funciones.

INTRODUCCIÓN

¿Qué son las funciones en programación?

Las funciones son bloques de código reutilizables diseñados para realizar una tarea específica.
En programación, una función es una sección de código que procesa entradas, realiza
operaciones específicas y puede devolver resultados. Las funciones permiten descomponer
problemas complejos en tareas más pequeñas y manejables, facilitando la legibilidad,
mantenimiento y reutilización del código.

Importancia de la modularidad en el desarrollo de software

La modularidad es un principio de diseño que divide un sistema en partes más pequeñas

(módulos), cada una con una responsabilidad específica. En Python, las funciones son la
unidad básica de modularidad. Esta aproximación ofrece múltiples ventajas:

1. Reutilización de código: Las funciones permiten ejecutar el mismo código desde

diferentes partes del programa.
2. Mantenibilidad: El código modular es más fácil de mantener, ya que los cambios
pueden localizarse en componentes específicos.
 3. Legibilidad: La descomposición en funciones mejora la comprensión del código,
especialmente en proyectos grandes.
4. Colaboración: Diferentes desarrolladores pueden trabajar en diferentes funciones
simultáneamente.
5. Testabilidad: Las funciones facilitan la implementación de pruebas unitarias.

Tipos de funciones en Python

1. Funciones integradas (built-in): Son funciones proporcionadas por Python (ej.

print(), len(), max()).
2. Funciones definidas por el usuario: Creadas para satisfacer necesidades específicas
del programa.
3. Funciones anónimas (lambda): Funciones compactas definidas en una sola línea.
4. Funciones de orden superior: Funciones que pueden recibir otras funciones como
parámetros o devolverlas como resultado.

FUNCIONES Y MODULARIDAD EN PYTHON

Creación y uso de funciones definidas por el usuario

Las funciones definidas por el usuario en Python siguen esta estructura básica:

def nombre_funcion(parametro1, parametro2, ...):

"""Docstring: Documentación de la función"""
# Cuerpo de la función
# Instrucciones
return resultado # Opcional

Ejemplo de una función simple:

def saludar(nombre):
"""Esta función saluda a la persona cuyo nombre recibe como
parámetro"""
mensaje = f"Hola, {nombre}. ¡Bienvenido/a!"
return mensaje

# Llamada a la función
saludo = saludar("María")
print(saludo) # Imprime: Hola, María. ¡Bienvenido/a!

Parámetros y retorno de valores

Python ofrece diferentes mecanismos para pasar parámetros a las funciones:

1. Parámetros posicionales:

def suma(a, b):

return a + b

resultado = suma(5, 3) # a=5, b=3

2. Parámetros con valores predeterminados:

 def potencia(base, exponente=2):
return base ** exponente

cuadrado = potencia(4) # exponente toma su valor predeterminado 2

cubo = potencia(4, 3) # exponente recibe el valor 3

3. *Parámetros de longitud variable (args):

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

resultado = sumar_varios(1, 2, 3, 4, 5) # Puede recibir cualquier

cantidad de argumentos

4. **Parámetros de palabras clave de longitud variable (kwargs):

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

describir_persona(nombre="Ana", edad=25, profesion="Ingeniera")

Funciones anónimas (lambda) y de orden superior

1. Funciones lambda: Son funciones anónimas, definidas en una sola línea.

# Función lambda que eleva un número al cuadrado

cuadrado = lambda x: x**2

# Equivalente a:
# def cuadrado(x):
# return x**2

print(cuadrado(5)) # Imprime: 25

2. Funciones de orden superior: Funciones que reciben otras funciones como

argumentos o las devuelven como resultado.

# Funciones integradas de orden superior: map, filter, reduce

# map: aplica una función a cada elemento de un iterable

numeros = [1, 2, 3, 4, 5]
cuadrados = list(map(lambda x: x**2, numeros))
print(cuadrados) # Imprime: [1, 4, 9, 16, 25]

# filter: filtra elementos de un iterable según una función

pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares) # Imprime: [2, 4]

# reduce: aplica una función a pares de elementos acumulativamente

from functools import reduce
producto = reduce(lambda x, y: x * y, numeros)
print(producto) # Imprime: 120 (1*2*3*4*5)
EJERCICIOS PROPUESTOS Y DESARROLLADOS

Ejercicio 1: Calculadora de funciones

Problema: Crear una calculadora utilizando funciones para cada operación y una función
principal que llame a las demás según la elección del usuario.

Solución:

def suma(a, b):

return a + b

def resta(a, b):

return a - b

def multiplicacion(a, b):

return a * b

def division(a, b):

if b == 0:
return "Error: División por cero"
return a / b

def calculadora():
"""Función principal que implementa una calculadora básica"""
print("Calculadora de funciones")
print("1. Suma")
print("2. Resta")
print("3. Multiplicación")
print("4. División")

try:
opcion = int(input("Seleccione una operación (1-4): "))
num1 = float(input("Ingrese el primer número: "))
num2 = float(input("Ingrese el segundo número: "))

if opcion == 1:
resultado = suma(num1, num2)
operacion = "+"
elif opcion == 2:
resultado = resta(num1, num2)
operacion = "-"
elif opcion == 3:
resultado = multiplicacion(num1, num2)
operacion = "*"
elif opcion == 4:
resultado = division(num1, num2)
operacion = "/"
else:
return "Opción no válida"

if isinstance(resultado, str):
return resultado
return f"Resultado: {num1} {operacion} {num2} = {resultado}"

except ValueError:
return "Error: Ingreso inválido"
# Ejemplo de uso
print(calculadora())

Ejercicio 2: Convertidor de temperaturas con funciones y valores predeterminados

Problema: Crear funciones para convertir entre diferentes unidades de temperatura, con
valores predeterminados.

Solución:

def celsius_a_fahrenheit(celsius):
"""Convierte grados Celsius a Fahrenheit"""
return (celsius * 9/5) + 32

def fahrenheit_a_celsius(fahrenheit):
"""Convierte grados Fahrenheit a Celsius"""
return (fahrenheit - 32) * 5/9

def celsius_a_kelvin(celsius):
"""Convierte grados Celsius a Kelvin"""
return celsius + 273.15

def kelvin_a_celsius(kelvin):
"""Convierte Kelvin a grados Celsius"""
return kelvin - 273.15

def convertidor_temperatura(valor, origen="C", destino="F"):

"""
Convierte temperaturas entre diferentes escalas

Parámetros:
valor: Temperatura a convertir
origen: Escala de origen (C=Celsius, F=Fahrenheit, K=Kelvin)
destino: Escala de destino (C=Celsius, F=Fahrenheit, K=Kelvin)
"""
# Convertir cualquier entrada a Celsius primero
if origen.upper() == "C":
celsius = valor
elif origen.upper() == "F":
celsius = fahrenheit_a_celsius(valor)
elif origen.upper() == "K":
celsius = kelvin_a_celsius(valor)
else:
return "Escala de origen no válida"

# Convertir de Celsius a la escala de destino

if destino.upper() == "C":
return celsius
elif destino.upper() == "F":
return celsius_a_fahrenheit(celsius)
elif destino.upper() == "K":
return celsius_a_kelvin(celsius)
else:
return "Escala de destino no válida"

# Ejemplos de uso
agua_hirviendo = convertidor_temperatura(100) # De Celsius a Fahrenheit
por defecto
print(f"100°C = {agua_hirviendo}°F")

temperatura_ambiente = convertidor_temperatura(68, "F", "C") # De

Fahrenheit a Celsius
print(f"68°F = {temperatura_ambiente}°C")

temperatura_absoluta = convertidor_temperatura(0, "C", "K") # De Celsius a

Kelvin
print(f"0°C = {temperatura_absoluta}K")

Ejercicio 3: Filtrado de datos usando funciones lambda y de orden superior

Problema: Filtrar una lista de diccionarios de estudiantes según diferentes criterios utilizando
funciones lambda y de orden superior.

Solución:

def filtrar_estudiantes(estudiantes, criterio):

"""
Filtra una lista de estudiantes según el criterio especificado

Parámetros:
estudiantes: Lista de diccionarios con información de estudiantes
criterio: Función que define el criterio de filtrado
"""
return list(filter(criterio, estudiantes))

# Lista de estudiantes con sus datos

estudiantes = [
{"nombre": "Ana", "promedio": 18.5, "carrera": "Ingeniería
Electrónica", "semestre": 5},
{"nombre": "Luis", "promedio": 15.2, "carrera": "Ingeniería Eléctrica",
"semestre": 3},
{"nombre": "Carlos", "promedio": 12.8, "carrera": "Ingeniería
Electrónica", "semestre": 7},
{"nombre": "María", "promedio": 19.1, "carrera": "Ingeniería
Eléctrica", "semestre": 5},
{"nombre": "Jorge", "promedio": 16.4, "carrera": "Ingeniería
Electrónica", "semestre": 3},
{"nombre": "Sofía", "promedio": 17.9, "carrera": "Ingeniería
Eléctrica", "semestre": 7}
]

# Aplicando diferentes criterios de filtrado

electronicos = filtrar_estudiantes(
estudiantes,
lambda e: e["carrera"] == "Ingeniería Electrónica"
)

aprobados_excelencia = filtrar_estudiantes(
estudiantes,
lambda e: e["promedio"] >= 17.0
)

electronicos_tercer_semestre = filtrar_estudiantes(
estudiantes,
lambda e: e["carrera"] == "Ingeniería Electrónica" and e["semestre"] ==
3
)

# Mostrar resultados
print("Estudiantes de Ingeniería Electrónica:")
for e in electronicos:
print(f"- {e['nombre']} (Promedio: {e['promedio']})")

print("\nEstudiantes con promedio de excelencia (≥17):")

for e in aprobados_excelencia:
print(f"- {e['nombre']} (Promedio: {e['promedio']})")

print("\nEstudiantes de Electrónica en tercer semestre:")

for e in electronicos_tercer_semestre:
print(f"- {e['nombre']} (Promedio: {e['promedio']})")

Ejercicio 4: Función de orden superior para cálculos matemáticos

Problema: Crear una función de orden superior que aplique diferentes operaciones
matemáticas a una lista de números.

Solución:

def aplicar_operacion(numeros, operacion):

"""
Aplica una operación a cada número de una lista

Parámetros:
numeros: Lista de números
operacion: Función que define la operación a aplicar
"""
return [operacion(num) for num in numeros]

# Definición de operaciones como funciones lambda

cuadrado = lambda x: x**2
raiz_cuadrada = lambda x: x**0.5
valor_absoluto = lambda x: abs(x)
reciproco = lambda x: 1/x if x != 0 else "Indefinido"

# Lista de números para probar

numeros = [4, 9, 16, 25, -3, 0]

# Aplicar diferentes operaciones

resultados_cuadrado = aplicar_operacion(numeros, cuadrado)
resultados_raiz = aplicar_operacion(numeros, raiz_cuadrada)
resultados_absoluto = aplicar_operacion(numeros, valor_absoluto)
resultados_reciproco = aplicar_operacion(numeros, reciproco)

# Mostrar resultados
print(f"Números originales: {numeros}")
print(f"Cuadrados: {resultados_cuadrado}")
print(f"Raíces cuadradas: {resultados_raiz}")
print(f"Valores absolutos: {resultados_absoluto}")
print(f"Recíprocos: {resultados_reciproco}")

# Ejemplo usando map (alternativa a aplicar_operacion)

cuadrados_map = list(map(cuadrado, numeros))
print(f"Cuadrados (usando map): {cuadrados_map}")
Ejercicio 5: Función recursiva con memorización

Problema: Implementar la secuencia de Fibonacci utilizando una función recursiva con

técnica de memorización para mejorar la eficiencia.

Solución:

def fibonacci_memo(n, memo={}):

"""
Calcula el n-ésimo número de Fibonacci utilizando recursividad con
memorización

Parámetros:
n: Posición del número de Fibonacci a calcular (0-indexado)
memo: Diccionario para almacenar resultados ya calculados
"""
# Verificación de casos base
if n <= 0:
return 0
elif n == 1:
return 1

# Verificar si ya calculamos este valor antes

if n in memo:
return memo[n]

# Calcular y almacenar el resultado

memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)
return memo[n]

# Función para generar la secuencia completa

def secuencia_fibonacci(cantidad):
"""Genera una secuencia de 'cantidad' números de Fibonacci"""
return [fibonacci_memo(i) for i in range(cantidad)]

# Ejemplos de uso
print(f"Fibonacci(10) = {fibonacci_memo(10)}")
print(f"Primeros 15 números de Fibonacci: {secuencia_fibonacci(15)}")

# Comparación de tiempos para demostrar la eficiencia

import time

def fibonacci_simple(n):
"""Versión recursiva simple (sin memorización)"""
if n <= 0:
return 0
elif n == 1:
return 1
return fibonacci_simple(n-1) + fibonacci_simple(n-2)

# Medir tiempo con memorización

inicio = time.time()
fibonacci_memo(30)
fin = time.time()
tiempo_memo = fin - inicio

# Medir tiempo sin memorización

inicio = time.time()
try:
# Limitamos a 30 para evitar tiempos excesivos
fibonacci_simple(30)
except RecursionError:
print("Error de recursión en versión simple")
fin = time.time()
tiempo_simple = fin - inicio

print(f"Tiempo con memorización: {tiempo_memo:.6f} segundos")

print(f"Tiempo sin memorización: {tiempo_simple:.6f} segundos")
print(f"Mejora de velocidad: {tiempo_simple/tiempo_memo:.2f} veces más
rápido")

EJERCICIOS PROPUESTOS

1. Ejercicio 6: Implemente un generador de contraseñas utilizando funciones con

parámetros opcionales para especificar la longitud y los tipos de caracteres a incluir
(mayúsculas, minúsculas, números, símbolos).
2. Ejercicio 7: Cree una función de orden superior que permita ordenar una lista de
diccionarios según cualquier campo utilizando una función lambda como criterio de
ordenamiento.
3. Ejercicio 8: Desarrolle un programa que utilice funciones recursivas para calcular el
máximo común divisor (MCD) y el mínimo común múltiplo (MCM) de dos números.
4. Ejercicio 9: Implemente un sistema de validación de datos utilizando funciones para
verificar diferentes tipos de entrada (email, teléfono, DNI, etc.) y funciones de orden
superior para aplicar múltiples validaciones a un mismo dato.
5. Ejercicio 10: Cree un conjunto de funciones que permitan analizar un texto e informar
sobre su estadística (cantidad de palabras, frecuencia de cada palabra, longitud
promedio, etc.) utilizando funciones lambda y de orden superior para el
procesamiento.

CUESTIONARIO

a) ¿Cuáles son las ventajas principales de utilizar funciones en lugar de repetir código?
Proporcione ejemplos específicos.

b) Explique las diferencias entre los distintos tipos de parámetros en Python: posicionales, con
valores predeterminados, *args y **kwargs. ¿Cuándo es apropiado usar cada uno?

c) ¿Qué limitaciones tienen las funciones lambda en comparación con las funciones definidas
por el usuario? ¿En qué contextos son más apropiadas?

d) Explique el concepto de clausura (closure) en Python y cómo se relaciona con las

funciones anidadas y de orden superior.

e) Compare las ventajas y desventajas de la recursividad frente a los métodos iterativos en

términos de legibilidad, eficiencia y consumo de memoria. ¿Cómo afecta la técnica de
memorización al rendimiento de las funciones recursivas?