Funciones con Parámetros: Organizando el Código Histórico

21. Funciones con Parámetros: Organizando el Código Histórico#

“La capacidad de crear una realidad imaginada a partir de palabras permitió que un gran número de extraños cooperaran de manera efectiva. Pero también significó que el éxito o el fracaso dependía de historias, no de hechos.”

—Yuval Noah Harari, De animales a dioses (2014)

21.1. 🎯 Objetivos de Aprendizaje#

Al finalizar este capítulo, serás capaz de:

  1. Crear funciones que reciben información (parámetros)

  2. Usar return para que las funciones devuelvan resultados

  3. Entender la diferencia entre parámetros y argumentos

  4. Organizar código en funciones reutilizables

  5. Combinar funciones con todo lo aprendido anteriormente

⏱️ Tiempo estimado

90 minutos de lectura y práctica

21.2. ¿Qué son las Funciones?#

Una función es un bloque de código reutilizable que realiza una tarea específica. Las funciones nos permiten:

  • Organizar el código en piezas más pequeñas

  • Reutilizar código sin tener que escribirlo varias veces

  • Abstraer la complejidad (usar sin saber cómo funciona internamente)

🏛️ Analogía Histórica

Imagina que las funciones son como departamentos en un museo: el departamento de arqueología, el de arte colonial, el de historia republicana. Cada uno tiene una tarea específica, pero trabajan juntos para el objetivo del museo.

21.2.1. Función simple (sin parámetros)#

# Definir una función
def saludar_historiador():
    print("¡Bienvenido al estudio de la Historia con Python!")
    print("Prepárate para analizar datos del pasado.")

# Llamar (usar) la función
saludar_historiador()

¡Bienvenido al estudio de la Historia con Python!
Prepárate para analizar datos del pasado.

21.2.2. Anatomía de una función#

def nombre_funcion(parametros):  # Definición
    """Descripción de lo que hace (docstring)"""  # Documentación
    # Código de la función
    return resultado  # Valor que devuelve (opcional)

Elemento

Descripción

def

Palabra clave para definir funciones

nombre_funcion

Nombre descriptivo (snake_case)

parametros

Información que recibe la función

docstring

Descripción de la función

return

Valor que devuelve la función

Tabla 19.1: Elementos de una función en Python

21.3. Funciones con Parámetros#

Los parámetros son como “espacios en blanco” que llenamos cuando usamos la función.

21.3.1. Un parámetro#

# Función que saluda a un prócer específico
def saludar_procer(nombre):
    """Saluda a un prócer de la independencia."""
    print(f"¡Honor al prócer {nombre}!")

# Usar la función con diferentes argumentos
saludar_procer("Bernardo O'Higgins")
saludar_procer("José de San Martín")
saludar_procer("Manuel Rodríguez")

¡Honor al prócer Bernardo O'Higgins!
¡Honor al prócer José de San Martín!
¡Honor al prócer Manuel Rodríguez!

21.3.2. Múltiples parámetros#

# Función para presentar información de un personaje histórico
def presentar_personaje(nombre, anio_nacimiento, cargo):
    """Presenta información básica de un personaje histórico."""
    print(f"Nombre: {nombre}")
    print(f"Año de nacimiento: {anio_nacimiento}")
    print(f"Cargo principal: {cargo}")
    print("-" * 40)

# Usar la función
presentar_personaje("Bernardo O'Higgins", 1778, "Director Supremo")
presentar_personaje("José Miguel Carrera", 1785, "Jefe del Gobierno")

Nombre: Bernardo O'Higgins
Año de nacimiento: 1778
Cargo principal: Director Supremo
----------------------------------------
Nombre: José Miguel Carrera
Año de nacimiento: 1785
Cargo principal: Jefe del Gobierno
----------------------------------------

21.4. La sentencia return#

La sentencia return permite que una función devuelva un valor que podemos usar después.

💡 Diferencia importante

  • print() solo muestra información en pantalla

  • return devuelve un valor que puede ser usado en otras operaciones

# Función que calcula años transcurridos
def calcular_anos_transcurridos(anio_evento):
    """Calcula cuántos años han pasado desde un evento."""
    anio_actual = 2025
    diferencia = anio_actual - anio_evento
    return diferencia  # Devuelve el resultado

# Usar el valor retornado
anos_independencia = calcular_anos_transcurridos(1818)
print(f"Han pasado {anos_independencia} años desde la Independencia")

anos_guerra = calcular_anos_transcurridos(1879)
print(f"Han pasado {anos_guerra} años desde la Guerra del Pacífico")

Han pasado 207 años desde la Independencia
Han pasado 146 años desde la Guerra del Pacífico

# Diferencia entre print y return
def sumar_con_print(a, b):
    print(a + b)  # Solo muestra, no devuelve

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

# Con print no podemos usar el resultado
resultado1 = sumar_con_print(5, 3)  # Imprime 8
print(f"resultado1 = {resultado1}")  # None (no hay return)

# Con return podemos usar el resultado
resultado2 = sumar_con_return(5, 3)
print(f"resultado2 = {resultado2}")  # 8
print(f"resultado2 * 2 = {resultado2 * 2}")  # Podemos operarlo

8
resultado1 = None
resultado2 = 8
resultado2 * 2 = 16

21.4.1. Retornar múltiples valores#

# Función que analiza un período histórico
def analizar_periodo(anio_inicio, anio_fin):
    """Analiza un período histórico y retorna estadísticas."""
    duracion = anio_fin - anio_inicio
    punto_medio = anio_inicio + (duracion // 2)
    return duracion, punto_medio  # Retorna dos valores

# Desempaquetar los valores retornados
duracion, medio = analizar_periodo(1810, 1830)
print(f"Período: 1810-1830")
print(f"Duración: {duracion} años")
print(f"Punto medio: {medio}")

Período: 1810-1830
Duración: 20 años
Punto medio: 1820

21.5. Parámetros con Valores por Defecto#

# Función con valor por defecto
def calcular_edad_en_anio(anio_nacimiento, anio_referencia=2025):
    """Calcula la edad que tendría alguien en un año dado."""
    return anio_referencia - anio_nacimiento

# Usando el valor por defecto
edad_ohiggins_hoy = calcular_edad_en_anio(1778)
print(f"O'Higgins tendría {edad_ohiggins_hoy} años hoy")

# Especificando el año de referencia
edad_ohiggins_1818 = calcular_edad_en_anio(1778, 1818)
print(f"O'Higgins tenía {edad_ohiggins_1818} años en 1818")

O'Higgins tendría 247 años hoy
O'Higgins tenía 40 años en 1818

21.6. Funciones Prácticas para Historia#

21.6.1. Clasificador de Siglos#

def obtener_siglo(anio):
    """Determina a qué siglo pertenece un año."""
    if anio <= 0:
        siglo = abs(anio) // 100 + 1
        return f"Siglo {siglo} a.C."
    else:
        siglo = (anio - 1) // 100 + 1
        return f"Siglo {siglo}"

# Probar la función
print(f"1492 → {obtener_siglo(1492)}")
print(f"1810 → {obtener_siglo(1810)}")
print(f"2025 → {obtener_siglo(2025)}")
print(f"-44 → {obtener_siglo(-44)}")

1492 → Siglo 15
1810 → Siglo 19
2025 → Siglo 21
-44 → Siglo 1 a.C.

21.6.2. Clasificador de Períodos Chilenos#

def clasificar_periodo_chileno(anio):
    """Clasifica un año en su período de la historia de Chile."""
    if anio < 1541:
        return "Período Precolombino"
    elif anio < 1810:
        return "Período Colonial"
    elif anio < 1818:
        return "Proceso de Independencia"
    elif anio < 1830:
        return "Organización de la República"
    elif anio < 1861:
        return "República Conservadora"
    elif anio < 1891:
        return "República Liberal"
    elif anio < 1925:
        return "República Parlamentaria"
    elif anio < 1973:
        return "República Presidencial"
    elif anio < 1990:
        return "Régimen Militar"
    else:
        return "Retorno a la Democracia"

# Probar con varios años
anios_prueba = [1500, 1750, 1814, 1879, 1970, 1985, 2020]
for anio in anios_prueba:
    print(f"{anio} → {clasificar_periodo_chileno(anio)}")

1500 → Período Precolombino
1750 → Período Colonial
1814 → Proceso de Independencia
1879 → República Liberal
1970 → República Presidencial
1985 → Régimen Militar
2020 → Retorno a la Democracia

21.6.3. Generador de Fichas Históricas#

def crear_ficha_historica(nombre, nacimiento, muerte, cargo, logro_principal):
    """Genera una ficha histórica formateada."""
    anos_vida = muerte - nacimiento
    
    ficha = f"""
{'='*50}
          FICHA HISTÓRICA
{'='*50}
Nombre: {nombre}
Vida: {nacimiento} - {muerte} ({anos_vida} años)
Cargo: {cargo}
Logro principal: {logro_principal}
{'='*50}
    """
    return ficha

# Crear fichas
ficha1 = crear_ficha_historica(
    "Bernardo O'Higgins",
    1778, 1842,
    "Director Supremo de Chile",
    "Consolidar la Independencia de Chile"
)
print(ficha1)

ficha2 = crear_ficha_historica(
    "Arturo Prat Chacón",
    1848, 1879,
    "Capitán de Fragata",
    "Heroísmo en el Combate Naval de Iquique"
)
print(ficha2)

==================================================
          FICHA HISTÓRICA
==================================================
Nombre: Bernardo O'Higgins
Vida: 1778 - 1842 (64 años)
Cargo: Director Supremo de Chile
Logro principal: Consolidar la Independencia de Chile
==================================================
    

==================================================
          FICHA HISTÓRICA
==================================================
Nombre: Arturo Prat Chacón
Vida: 1848 - 1879 (31 años)
Cargo: Capitán de Fragata
Logro principal: Heroísmo en el Combate Naval de Iquique
==================================================

21.7. 🏛️ Proyecto: Sistema de Consulta Histórica#

Combinemos todo lo aprendido en un proyecto completo:

# Sistema de Consulta Histórica de Chile

# Base de datos (diccionarios)
PERSONAJES = {
    "ohiggins": {
        "nombre": "Bernardo O'Higgins",
        "nacimiento": 1778,
        "muerte": 1842,
        "cargo": "Director Supremo"
    },
    "carrera": {
        "nombre": "José Miguel Carrera",
        "nacimiento": 1785,
        "muerte": 1821,
        "cargo": "Jefe del Gobierno"
    },
    "prat": {
        "nombre": "Arturo Prat",
        "nacimiento": 1848,
        "muerte": 1879,
        "cargo": "Capitán de Fragata"
    }
}

# Funciones del sistema
def mostrar_menu():
    """Muestra el menú principal."""
    print("\n" + "="*40)
    print("  SISTEMA DE CONSULTA HISTÓRICA")
    print("="*40)
    print("1. Buscar personaje")
    print("2. Calcular años desde evento")
    print("3. Clasificar año en período")
    print("4. Salir")

def buscar_personaje(clave):
    """Busca y muestra información de un personaje."""
    if clave.lower() in PERSONAJES:
        p = PERSONAJES[clave.lower()]
        edad = p["muerte"] - p["nacimiento"]
        print(f"\n📜 {p['nombre']}")
        print(f"   Vida: {p['nacimiento']}-{p['muerte']} ({edad} años)")
        print(f"   Cargo: {p['cargo']}")
        return True
    else:
        print("\n❌ Personaje no encontrado.")
        print(f"   Disponibles: {', '.join(PERSONAJES.keys())}")
        return False

def calcular_anos_desde(anio):
    """Calcula años transcurridos desde un evento."""
    return 2025 - anio

# Programa principal
print("¡Bienvenido al Sistema de Consulta Histórica!")

while True:
    mostrar_menu()
    opcion = input("\nElige una opción (1-4): ")
    
    if opcion == "1":
        nombre = input("Ingresa el nombre del personaje: ")
        buscar_personaje(nombre)
    
    elif opcion == "2":
        try:
            anio = int(input("Ingresa el año del evento: "))
            anos = calcular_anos_desde(anio)
            print(f"\n📅 Han pasado {anos} años desde {anio}")
        except:
            print("\n⚠️ Por favor ingresa un año válido.")
    
    elif opcion == "3":
        try:
            anio = int(input("Ingresa un año: "))
            periodo = clasificar_periodo_chileno(anio)
            print(f"\n📚 El año {anio} corresponde al: {periodo}")
        except:
            print("\n⚠️ Por favor ingresa un año válido.")
    
    elif opcion == "4":
        print("\n¡Hasta pronto, historiador! 📖")
        break
    
    else:
        print("\n❌ Opción no válida. Intenta de nuevo.")

21.8. 📝 Actividad de Cierre#

21.8.1. Ejercicio 1: Función de Área#

Crea una función calcular_area_rectangulo(base, altura) que retorne el área.

# Tu código aquí

21.8.2. Ejercicio 2: Verificador de Año Bisiesto#

Crea una función es_bisiesto(anio) que retorne True si es bisiesto, False si no.

# Tu código aquí

21.8.3. Ejercicio 3: Calculadora de Promedios#

Crea una función que reciba una lista de notas y retorne el promedio y si aprueba (promedio >= 4.0).

# Tu código aquí

21.9. 📚 Resumen del Capítulo#

Concepto

Descripción

def nombre():

Define una función

Parámetros

Variables que recibe la función

Argumentos

Valores que pasamos al llamar

return

Devuelve un valor de la función

Valores por defecto

def f(x=10):

Docstring

Documentación de la función

Tabla 19.2: Resumen de conceptos del capítulo

21.9.1. Conceptos Clave#

  • Reutilización: Escribir código una vez, usarlo muchas veces

  • Organización: Código más limpio y fácil de mantener

  • Abstracción: Usar funciones sin conocer su implementación interna

  • Modularidad: Dividir problemas grandes en problemas pequeños

21.10. 📖 Referencias#

Contents