Tu Primer Código: Fundamentos de Programación en Python

¡Da tus primeros pasos en el mundo de la programación con Python! En este tutorial completo te guiaré paso a paso para que aprendas los fundamentos esenciales, desde conceptos básicos hasta tu primer programa funcional.

Objetivo: Aprender los fundamentos de la programación usando Python, incluyendo variables, estructuras de control, funciones, estructuras de datos con ejemplos prácticos.

Índice

• Paso 1: ¿Qué es la Programación?
• Paso 2: Comentarios en Python
• Paso 3: Variables y Tipos de Datos
• Paso 4: Estructuras de Control y Bucles
• Paso 5: Funciones
• Paso 6: Estructuras de Datos
• Paso 7: Proyecto Práctico - Calculadora Básica
• Paso 8: Próximos Pasos en tu Aventura
• Conclusión
• 💡 Tip Importante

Paso 1: ¿Qué es la Programación?

Tema Principal: Introducción al mundo de la programación

• ¿Qué es la programación?: Arte de crear instrucciones para que las computadoras realicen tareas específicas
• Lenguajes de programación: Herramientas como Python, JavaScript, Java, C++ para diferentes propósitos
• Compiladores vs Intérpretes: Formas en que el código se convierte en acciones de la computadora
• Proceso de desarrollo: Pasos desde la idea hasta el programa funcional

Paso 2: Comentarios en Python

Tema Principal: Documentación y legibilidad del código

• Comentarios: Textos explicativos que Python ignora pero ayudan a los programadores
• Importancia: Mejora la comprensión, mantenimiento y trabajo en equipo
• Sintaxis: Uso del símbolo # para comentarios de una línea

Paso 3: Variables y Tipos de Datos

Tema Principal: Almacenamiento y manejo de información

• Variables: Contenedores nombrados para guardar datos en la memoria
• Reglas de nombres: Convenciones para crear nombres claros y válidos
• Tipos de datos básicos:
  • str (string): Texto y caracteres
  • int (integer): Números enteros
  • float: Números decimales
  • bool (boolean): Valores verdadero/falso
• Casting: Conversión entre diferentes tipos de datos
• Uso práctico: Aplicaciones reales de cada tipo de dato

Paso 4: Estructuras de Control y Bucles

Tema Principal: Toma de decisiones y repetición de tareas

• Operadores de comparación: Herramientas para evaluar condiciones (==, !=, >, <, >=, <=)
• Condicionales: Estructuras if, elif, else para ramificar la lógica del programa
• Bucles: Estructuras for y while para repetir acciones
• Control de flujo: break y continue para modificar el comportamiento de los bucles

Paso 5: Funciones

Tema Principal: Organización y reutilización del código

• Funciones: Bloques de código organizados que realizan tareas específicas
• Ventajas: Reutilización, modularidad, mantenimiento fácil
• Parámetros: Valores que recibe una función para trabajar
• Return: Valores que devuelve una función después de procesar
• Ámbito: Variables locales vs globales

Paso 6: Estructuras de Datos

Tema Principal: Formas eficientes de organizar información

• Listas: Colecciones ordenadas y modificables de elementos
• Tuplas: Colecciones ordenadas pero inmutables
• Conjuntos: Colecciones sin orden ni duplicados
• Diccionarios: Pares clave-valor para acceso rápido
• Comparación: Cuándo usar cada estructura según las necesidades

Paso 7: Proyecto Práctico

Tema Principal: Integración de todos los conceptos aprendidos

• Aplicación real: Calculadora que combina todos los conocimientos básicos
• Diseño modular: Organización del código en funciones
• Interacción con usuario: Entrada y salida de datos
• Manejo básico de errores: Validación de entrada del usuario

Paso 8: Próximos Pasos

Tema Principal: Continuación del aprendizaje

• Nivel intermedio: Manejo de errores, archivos, programación orientada a objetos
• Nivel avanzado: Desarrollo web, control de versiones, ciencia de datos
• Proyectos sugeridos: Aplicaciones prácticas para reforzar el aprendizaje
• Recursos recomendados: Plataformas, documentación y comunidades

Paso 1: ¿Qué es la Programación?

La programación es el arte de crear software mediante la escritura de instrucciones precisas que una computadora puede interpretar y ejecutar. Es como ser un chef que escribe una receta detallada: cada paso debe ser claro, lógico y perfectamente secuenciado. La programaciòn es un proceso creativo que involucra imaginación, lógica y resolución de problemas.

"Si lo puedes imaginar, lo puedes programar". Alan Kay

Lenguajes de Programación

Existen miles de lenguajes de programación, cada uno diseñado para propósitos específicos:

• Python: Ideal para principiantes, ciencia de datos y desarrollo web
• JavaScript: Esencial para desarrollo web y aplicaciones interactivas
• Java: Potente para aplicaciones empresariales y Android
• C++: Alto rendimiento para juegos y sistemas operativos

Compiladores vs Intérpretes

• Compiladores: Traducen todo el código a lenguaje máquina antes de ejecutarlo (C++, Java)
• Intérpretes: Ejecutan el código línea por línea en tiempo real (Python, JavaScript)

El Proceso de Desarrollo

1. Análisis: Entender el problema
2. Diseño: Planificar la solución
3. Implementación: Escribir el código
4. Pruebas: Verificar que funciona correctamente
5. Mantenimiento: Actualizar y mejorar el código

# Tu primer programa: imprimir un mensaje
print("¡Hola, mundo! Bienvenido a la programación.")

# Este programa demuestra la salida básica
# La función print() muestra texto en la consola

Paso 2: Comentarios en Python

Los comentarios son textos explicativos que el programador incluye en el código fuente para hacerlo más legible y comprensible. Python ignora completamente los comentarios durante la ejecución del programa; solo sirven para documentar y explicar el código.

¿Por qué son importantes los comentarios?

• Legibilidad: Ayudan a otros programadores (y a ti mismo en el futuro) a entender qué hace el código
• Mantenimiento: Facilitan la modificación y actualización del código
• Depuración: Ayudan a identificar rápidamente secciones específicas del código
• Documentación: Sirven como guía para entender la lógica del programa

Los comentarios son una herramienta esencial para escribir código profesional y mantenible. Aunque al principio puedas sentir que no son necesarios, a medida que tus programas crezcan en complejidad, los comentarios se convertirán en tus mejores aliados para mantener el código organizado y comprensible.

# este es un comentario

Paso 3: Variables y Tipos de Datos

Las variables son contenedores nombrados que almacenan datos en la memoria de la computadora. En Python, no necesitas declarar el tipo de variable explícitamente; el intérprete lo determina automáticamente.

Reglas para Nombres de Variables

• Deben comenzar con letra o guion bajo (_)
• Pueden contener letras, números y guiones bajos
• No pueden ser palabras reservadas (if, for, while, etc.)
• Convención: usar snake_case (palabras en minúscula separadas por guiones bajos)

# Variables básicas con diferentes tipos
nombre = "Ana"           # String (cadena de texto)
edad = 25               # Integer (número entero)
altura = 1.65           # Float (número decimal)
es_estudiante = True    # Boolean (verdadero/falso)

# Variables con nombres descriptivos
numero_estudiantes = 30
promedio_calificaciones = 8.5
curso_activo = False

# Impresión básica (sin f-strings por ahora)
print("Me llamo", nombre, "tengo", edad, "años")
print("y mido", altura, "metros.")

Tipos de Datos Principales

Conversión de Tipos (Casting)

El casting es el proceso de convertir un valor de un tipo de dato a otro. Es fundamental cuando necesitas operar con datos de diferentes tipos o cuando recibes datos de fuentes externas.

Funciones de Casting Principales

# Ejemplos de casting básico
numero_texto = "42"
numero_entero = int(numero_texto)  # "42" → 42

decimal = 3.14
entero = int(decimal)  # 3.14 → 3 (pierde decimales)

numero = 100
texto = str(numero)  # 100 → "100"

# Casting con booleanos
print(bool(0))      # False
print(bool(1))      # True
print(bool(""))     # False (string vacío)
print(bool("Hola")) # True (string no vacío)

# Verificar tipo de dato
print(type(nombre))    # <class 'str'>
print(type(edad))      # <class 'int'>

¿Cuándo Usar Casting?

1. Operaciones Matemáticas: Asegurar tipos compatibles
2. Concatenación: Mezclar números y texto
3. Comparaciones: Evitar errores de tipo
4. Almacenamiento: Convertir para diferentes usos

# Ejemplo práctico: operaciones con casting
texto1 = "10"
texto2 = "20"

# Convertir a números para operar
num1 = int(texto1)  # "10" → 10
num2 = int(texto2)  # "20" → 20
suma = num1 + num2  # 10 + 20 = 30

# Convertir resultado a texto para mostrar
resultado_texto = str(suma)  # 30 → "30"
print("El resultado es: " + resultado_texto)

Casting Implícito vs Explícito

# Casting implícito (automático)
x = 5       # int
y = 2.0     # float
resultado = x + y  # Python convierte automáticamente: 5 + 2.0 = 7.0

# Casting explícito (manual)
a = "10"
b = "20"
suma = int(a) + int(b)  # Necesitamos convertir manualmente

print("Resultado implícito:", resultado)
print("Tipo:", type(resultado))
print("Resultado explícito:", suma)
print("Tipo:", type(suma))

Paso 4: Estructuras de Control y Bucles

Las estructuras de control son las herramientas que permiten a tu programa tomar decisiones inteligentes y repetir tareas de manera eficiente. Son el "cerebro" lógico de cualquier aplicación.

Operadores de Comparación

Antes de usar condicionales, es importante conocer los operadores de comparación:

Condicionales

Los condicionales son estructuras que permiten a tu programa tomar decisiones basadas en condiciones específicas. Son como cruces en el camino: evalúan si algo es verdadero o falso y ejecutan diferentes acciones según el resultado.

¿Qué son los Condicionales?

• Estructuras de control que ejecutan código solo cuando se cumple una condición
• Basados en expresiones booleanas (True/False)
• Permiten ramificar la lógica del programa
• Esenciales para cualquier programa no trivial

# Ejemplo básico de condicional
edad = 18

if edad >= 18:
    print("Eres mayor de edad")
    print("Puedes votar y conducir")
elif edad >= 13:
    print("Eres adolescente")
    print("Puedes usar redes sociales con supervisión")
else:
    print("Eres niño")
    print("Disfruta tu infancia")

Sintaxis Básica

if condición:
    # Código que se ejecuta si la condición es True
    print("La condición se cumple")
elif otra_condición:
    # Código que se ejecuta si la primera es False pero esta es True
    print("La primera no, pero esta sí")
else:
    # Código que se ejecuta si ninguna condición anterior se cumple
    print("Ninguna condición se cumple")

Condicionales en Una Línea (Ternary Operator)

El operador ternario (o condicional en una línea) es una forma compacta de escribir condicionales simples en una sola línea. Es especialmente útil cuando necesitas asignar un valor basado en una condición sin necesidad de escribir múltiples líneas de código.

Sintaxis básica:

resultado = valor_si_verdadero if condición else valor_si_falso

Ventajas:

• ✅ Código más conciso y legible para condiciones simples
• ✅ Menos líneas de código
• ✅ Ideal para asignaciones condicionales

Ejemplos prácticos:

# Ejemplo básico
edad = 20
estado = "Mayor de edad" if edad >= 18 else "Menor de edad"

# Con operaciones matemáticas
precio = 100
descuento = precio * 0.1 if precio > 50 else precio * 0.05

# Condiciones anidadas
numero = -5
categoria = "positivo" if numero > 0 else "negativo" if numero < 0 else "cero"

¿Cuándo usar el operador ternario?

• Cuando tienes una condición simple con solo dos resultados posibles
• Cuando necesitas asignar un valor basado en una condición
• Cuando quieres hacer el código más compacto y legible
• Especialmente útil en listas por comprensión y expresiones lambda

¿Cuándo NO usar el operador ternario?

• Cuando la condición es compleja o tiene múltiples ramas
• Cuando necesitas ejecutar múltiples instrucciones en cada caso
• Cuando el código resultante sería menos legible que un if-else tradicional

# Sintaxis: resultado = valor_si_true if condición else valor_si_false
edad = 20
mensaje = "Mayor de edad" if edad >= 18 else "Menor de edad"
print(mensaje)  # "Mayor de edad"

# Más ejemplos
numero = -5
tipo = "positivo" if numero > 0 else "negativo" if numero < 0 else "cero"
print(f"El número es {tipo}")

• Ver en Github

Condiciones Múltiples con elif

Las condiciones múltiples con elif permiten evaluar varias condiciones en cadena. Cada condición se evalúa solo si las anteriores fueron falsas, creando una estructura de decisión jerárquica que es más eficiente que múltiples if independientes.

# Sistema de calificaciones
calificacion = 85

if calificacion >= 90:
    print("Excelente - A")
elif calificacion >= 80:
    print("Muy bien - B")
elif calificacion >= 70:
    print("Bien - C")
elif calificacion >= 60:
    print("Suficiente - D")
else:
    print("Necesitas mejorar - F")

• Ver en Github

Condicionales en Una Línea (Ternary Operator)

# Sintaxis: resultado = valor_si_true if condición else valor_si_false
edad = 20
mensaje = "Mayor de edad" if edad >= 18 else "Menor de edad"
print(mensaje)  # "Mayor de edad"

# Más ejemplos
numero = -5
tipo = "positivo" if numero > 0 else "negativo" if numero < 0 else "cero"
print(f"El número es {tipo}")

• Ver en Github

Operadores Lógicos

Combina condiciones usando operadores lógicos:

• and: Ambas condiciones deben ser verdaderas
• or: Al menos una condición debe ser verdadera
• not: Invierte el valor de verdad

edad = 25
tiene_licencia = True

# Usando AND
if edad >= 18 and tiene_licencia:
    print("Puedes conducir legalmente")

# Usando OR
if edad < 18 or not tiene_licencia:
    print("No puedes conducir")

# Usando NOT
if not (edad < 18):
    print("Eres mayor de edad")

Bucles

Los bucles permiten ejecutar código repetidamente hasta que se cumpla una condición.

# Bucle for - ideal para iterar sobre secuencias
frutas = ["manzana", "banana", "naranja", "uva"]
for fruta in frutas:
    print(f"Me gusta comer {fruta}")

# Bucle for con range() - para contar
for i in range(1, 6):  # Del 1 al 5
    print(f"Número: {i}")

# Bucle while - se ejecuta mientras la condición sea verdadera
contador = 1
while contador <= 5:
    print(f"Contador: {contador}")
    contador += 1  # Importante: actualizar la variable de control

# Esta línea muestra el valor actual del contador en cada iteración

# Bucle con break y continue
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for num in numeros:
    if num == 5:
        print("¡Encontré el 5! Deteniendo...")
        break  # Sale del bucle
    if num % 2 == 0:
        continue  # Salta a la siguiente iteración
    print(f"Número impar: {num}")

• Ver en Github

Bucles Anidados

# Tabla de multiplicar del 1 al 3
for i in range(1, 4):
    print(f"\nTabla del {i}:")
    for j in range(1, 11):
        resultado = i * j
        print(f"{i} x {j} = {resultado}")

Paso 5: Funciones

Las funciones son bloques de código organizados y reutilizables que realizan tareas específicas. Son como "máquinas" que reciben entradas (parámetros), procesan información y devuelven resultados.

Ventajas de las Funciones

• Reutilización: Escribe una vez, usa muchas veces
• Modularidad: Divide problemas complejos en partes manejables
• Mantenimiento: Cambios en un lugar afectan toda la aplicación
• Legibilidad: Código más fácil de entender y mantener

Parámetros y Argumentos

# Función sin parámetros
def saludar_simple():
    """Función que saluda de manera genérica"""
    return "¡Hola! Bienvenido."

# Función con un parámetro
def saludar(nombre):
    """Función que saluda a una persona específica"""
    return f"¡Hola, {nombre}! Bienvenido."

# Función con múltiples parámetros
def saludar_completo(nombre, edad, ciudad="Madrid"):
    """Función con parámetros obligatorios y opcionales"""
    return f"¡Hola, {nombre}! Tienes {edad} años y vives en {ciudad}."

# Usar las funciones
print(saludar_simple())
print(saludar("Carlos"))
print(saludar_completo("Ana", 25))
print(saludar_completo("Pedro", 30, "Barcelona"))

Funciones con Return vs Sin Return

# Función que devuelve un valor
def calcular_area_circulo(radio):
    """Calcula el área de un círculo"""
    import math
    area = math.pi * radio ** 2
    return area

# Función que no devuelve valor (solo ejecuta acciones)
def imprimir_tabla_multiplicar(numero, limite=10):
    """Imprime la tabla de multiplicar de un número"""
    print(f"Tabla de multiplicar del {numero}:")
    for i in range(1, limite + 1):
        resultado = numero * i
        print(f"{numero} x {i} = {resultado}")

# Uso de ambas funciones
area = calcular_area_circulo(5)
print(f"Área del círculo: {area:.2f}")

imprimir_tabla_multiplicar(7, 5)

Ámbito de Variables (Scope)

# Variable global
mensaje_global = "Hola desde fuera"

def funcion_con_scope():
    # Variable local (solo existe dentro de la función)
    mensaje_local = "Hola desde dentro"
    print(mensaje_local)  # ✅ Accesible
    print(mensaje_global)  # ✅ Accesible

    # Modificar variable global dentro de función
    global mensaje_global
    mensaje_global = "Modificado desde dentro"

funcion_con_scope()
print(mensaje_global)  # Muestra: "Modificado desde dentro"

# print(mensaje_local)  # ❌ Error: mensaje_local no existe fuera de la función

Funciones Lambda (Anónimas)

# Función lambda simple
cuadrado = lambda x: x ** 2
print(cuadrado(5))  # 25

# Función lambda con múltiples parámetros
suma = lambda a, b: a + b
print(suma(3, 7))  # 10

# Uso común: como argumento de otras funciones
numeros = [1, 2, 3, 4, 5]
cuadrados = list(map(lambda x: x ** 2, numeros))
print(cuadrados)  # [1, 4, 9, 16, 25]

Documentación de Funciones

def calcular_promedio(notas):
    """
    Calcula el promedio de una lista de notas.

    Args:
        notas (list): Lista de números (notas)

    Returns:
        float: Promedio de las notas

    Raises:
        ValueError: Si la lista está vacía
        TypeError: Si algún elemento no es numérico

    Example:
        >>> calcular_promedio([8.5, 9.0, 7.5])
        8.333333333333334
    """
    if not notas:
        raise ValueError("La lista de notas no puede estar vacía")

    if not all(isinstance(nota, (int, float)) for nota in notas):
        raise TypeError("Todas las notas deben ser números")

    return sum(notas) / len(notas)

# Usar la función documentada
mis_notas = [8.5, 9.0, 7.5, 10.0]
promedio = calcular_promedio(mis_notas)
print(f"Promedio: {promedio:.2f}")

# Acceder a la documentación
help(calcular_promedio)

Paso 6: Estructuras de Datos

Las estructuras de datos son formas organizadas de almacenar y manipular información. Python ofrece varias estructuras nativas poderosas que facilitan el trabajo con datos.

Listas (Mutables)

Las listas son colecciones ordenadas y modificables de elementos.

# Crear y manipular listas
tareas = ["estudiar", "ejercicio", "leer"]
print(f"Primera tarea: {tareas[0]}")
print(f"Total de tareas: {len(tareas)}")

# Agregar elementos
tareas.append("programar")      # Agrega al final
tareas.insert(1, "desayunar")   # Inserta en posición específica
tareas.extend(["duchar", "vestir"])  # Agrega múltiples elementos

print(f"Todas las tareas: {tareas}")

# Eliminar elementos
tarea_completada = tareas.pop(0)  # Elimina y devuelve el primer elemento
tareas.remove("leer")             # Elimina elemento específico
# del tareas[2]                   # Elimina por índice

print(f"Tarea completada: {tarea_completada}")
print(f"Tareas restantes: {tareas}")

# Operaciones útiles
numeros = [3, 1, 4, 1, 5, 9, 2, 6]
numeros.sort()                    # Ordena la lista
print(f"Ordenados: {numeros}")

numeros.reverse()                 # Invierte el orden
print(f"Invertidos: {numeros}")

# Slicing (rebanado)
print(f"Primeros 3: {numeros[:3]}")
print(f"Últimos 2: {numeros[-2:]}")
print(f"Del 2 al 5: {numeros[1:5]}")

Tuplas (Inmutables)

Las tuplas son similares a las listas pero no se pueden modificar después de crearlas.

# Crear tuplas
coordenadas = (10, 20, 30)
colores_rgb = (255, 128, 0)

# Tupla con un solo elemento (necesita coma)
tupla_unica = (42,)

# Desempaquetado de tuplas
x, y, z = coordenadas
print(f"X: {x}, Y: {y}, Z: {z}")

# Tuplas útiles para devolver múltiples valores de funciones
def obtener_dimensiones():
    ancho = 1920
    alto = 1080
    return ancho, alto

w, h = obtener_dimensiones()
print(f"Resolución: {w}x{h}")

Conjuntos (Sets)

Los conjuntos son colecciones no ordenadas de elementos únicos.

# Crear conjuntos
numeros_pares = {2, 4, 6, 8, 10}
numeros_impares = {1, 3, 5, 7, 9}

# Operaciones con conjuntos
union = numeros_pares | numeros_impares          # Unión
interseccion = {2, 4, 6} & {4, 6, 8}           # Intersección
diferencia = {1, 2, 3, 4} - {3, 4, 5}          # Diferencia

print(f"Unión: {union}")
print(f"Intersección: {interseccion}")
print(f"Diferencia: {diferencia}")

# Eliminar duplicados de una lista usando set
lista_con_duplicados = [1, 2, 2, 3, 3, 3, 4, 5, 5]
lista_sin_duplicados = list(set(lista_con_duplicados))
print(f"Lista original: {lista_con_duplicados}")
print(f"Sin duplicados: {lista_sin_duplicados}")

Diccionarios

Los diccionarios almacenan pares clave-valor para acceso rápido.

# Crear un diccionario
persona = {
    "nombre": "María",
    "edad": 30,
    "ciudad": "Madrid",
    "habilidades": ["Python", "JavaScript", "SQL"]
}

print(f"Nombre: {persona['nombre']}")
print(f"Edad: {persona['edad']}")

# Agregar/modificar valores
persona["profesion"] = "Desarrolladora"
persona["edad"] = 31

# Acceder a valores anidados
habilidades = persona['habilidades']
print(f"Primera habilidad: {habilidades[0]}")

# Métodos útiles
print(f"Claves: {list(persona.keys())}")
print(f"Valores: {list(persona.values())}")
print(f"Pares: {list(persona.items())}")

# Verificar existencia
if "email" in persona:
    print(f"Email: {persona['email']}")
else:
    print("No tiene email registrado")

# Iterar sobre diccionarios
for clave, valor in persona.items():
    print(f"{clave}: {valor}")

# Diccionario de diccionarios
empleados = {
    "emp001": {"nombre": "Ana", "salario": 50000},
    "emp002": {"nombre": "Carlos", "salario": 55000}
}

ana_datos = empleados['emp001']
print(f"Salario de Ana: {ana_datos['salario']}")

Comparación de Estructuras

*Los diccionarios en Python 3.7+ mantienen el orden de inserción **Las claves deben ser únicas, los valores pueden duplicarse

Paso 7: Proyecto Práctico - Calculadora Básica

Vamos a crear una calculadora simple que integre los conceptos básicos que hemos aprendido hasta ahora: variables, tipos de datos, operadores de comparación, condicionales y operaciones matemáticas básicas.

Características de Nuestra Calculadora

• Operaciones básicas: suma, resta, multiplicación, división
• Validación de entrada de usuario
• Manejo básico de errores
• Uso de funciones simples

# Función para mostrar el menú
def mostrar_menu():
    print("\n" + "="*30)
    print("🧮 CALCULADORA BÁSICA")
    print("="*30)
    print("Operaciones disponibles:")
    print("1. Suma (+)")
    print("2. Resta (-)")
    print("3. Multiplicación (*)")
    print("4. División (/)")
    print("5. Salir")
    print("="*30)

# Función para obtener un número del usuario
def obtener_numero(mensaje):
    while True:
        try:
            entrada = input(mensaje)
            return float(entrada)
        except ValueError:
            print("Error: Ingresa un número válido")

# Función para realizar el cálculo
def calcular(operacion, num1, num2):
    if operacion == '+':
        return num1 + num2
    elif operacion == '-':
        return num1 - num2
    elif operacion == '*':
        return num1 * num2
    elif operacion == '/':
        if num2 == 0:
            print("Error: No se puede dividir por cero")
            return None
        return num1 / num2

# Función principal de la calculadora
def calculadora():
    print("¡Bienvenido a la Calculadora Básica!")

    while True:
        mostrar_menu()

        opcion = input("Selecciona una opción (1-5): ")

        if opcion == '5':
            print("¡Gracias por usar la calculadora!")
            break

        if opcion in ['1', '2', '3', '4']:
            # Obtener números
            num1 = obtener_numero("Ingresa el primer número: ")
            num2 = obtener_numero("Ingresa el segundo número: ")

            # Realizar operación
            if opcion == '1':
                resultado = calcular('+', num1, num2)
                operacion = '+'
            elif opcion == '2':
                resultado = calcular('-', num1, num2)
                operacion = '-'
            elif opcion == '3':
                resultado = calcular('*', num1, num2)
                operacion = '*'
            elif opcion == '4':
                resultado = calcular('/', num1, num2)
                operacion = '/'

            # Mostrar resultado
            if resultado is not None:
                print("Resultado: " + str(num1) + " " + operacion + " " + str(num2) + " = " + str(resultado))
        else:
            print("Opción no válida")

        # Preguntar si continuar
        continuar = input("\n¿Quieres realizar otra operación? (s/n): ").lower()
        if continuar != 's':
            print("¡Hasta luego!")
            break

# Ejecutar la calculadora
calculadora()

Explicación del Código

Este proyecto integra todos los conceptos aprendidos:

1. Variables: Usamos variables para almacenar números y resultados
2. Tipos de datos: Trabajamos con números (int, float) y texto (str)
3. Casting: Convertimos entrada de texto a números usando float()
4. Condicionales: Usamos if, elif para tomar decisiones
5. Bucles: Usamos while True para mantener el programa ejecutándose
6. Funciones: Organizamos el código en funciones reutilizables
7. Operadores: Usamos operadores matemáticos y de comparación

Funcionalidades Adicionales Sugeridas

Una vez que domines lo básico, puedes agregar:

1. Operaciones trigonométricas: seno, coseno, tangente
2. Conversión de unidades: grados a radianes, etc.
3. Memoria: almacenar resultados para usarlos después
4. Funciones estadísticas: promedio, mediana, moda
5. Interfaz gráfica: usando tkinter o PyQt
6. Historial persistente: guardar operaciones en archivo

Desafío Extra

Modifica la calculadora para que:

• Acepte expresiones matemáticas completas (ej: "2 + 3 * 4")
• Maneje constantes matemáticas (π, e)
• Incluya validación más sofisticada de entradas
• Guarde el historial en un archivo de texto (aprende más en el Tutorial de Manejo de Archivos y Tutorial de Manejo de Errores)

Paso 8: Próximos Pasos en tu Aventura

¡Felicidades! Has completado los fundamentos básicos de la programación. Ahora tienes las herramientas esenciales para crear programas funcionales. El viaje apenas comienza, y hay un mundo fascinante de conocimientos por explorar.

Ruta de Aprendizaje Recomendada

Nivel Intermedio

1. Manejo de Errores en Python

   • Try-except y excepciones
   • Tipos de errores comunes
   • Mejores prácticas
   • Tutorial: Manejo de Errores

2. Manejo de Archivos en Python

   • Operaciones básicas de archivos
   • Persistencia de datos
   • Manejo de errores en archivos
   • Tutorial: Manejo de Archivos

3. Programación Orientada a Objetos (POO)

   • Clases y objetos
   • Herencia y polimorfismo
   • Encapsulamiento
   • Tutorial: POO en Python

4. Algoritmos y Estructuras de Datos

   • Complejidad algorítmica (Big O)
   • Árboles, grafos y algoritmos de búsqueda
   • Ordenamiento y búsqueda avanzada
   • Tutorial: Algoritmos y Pensamiento Lógico
   • Tutorial: Estructuras de Datos Avanzadas

5. Bases de Datos

   • SQL y bases de datos relacionales
   • MongoDB y bases de datos NoSQL
   • Diseño de esquemas
   • Tutorial: Introducción a SQL

Nivel Avanzado

6. Desarrollo Web

   • HTML, CSS y JavaScript
   • Frameworks backend (Django, Flask)
   • APIs RESTful
   • Tutorial: Desarrollo Web con Python

7. Control de Versiones

   • Git y GitHub
   • Flujos de trabajo colaborativos
   • Ramas y fusiones
   • Tutorial: Git Avanzado

8. Ciencia de Datos y Machine Learning

   • NumPy, Pandas y Matplotlib
   • Análisis de datos
   • Algoritmos de ML básicos
   • Tutorial: Procesamiento de Lenguaje Natural
   • Tutorial: Análisis de Datos con Pandas

Proyectos para Practicar

Principiante a Intermedio

1. Sistema de Gestión de Biblioteca

   • Clases para libros y usuarios
   • Base de datos simple
   • Interfaz de consola

2. Juego de Adivinanza

   • Números aleatorios
   • Entrada/salida de usuario
   • Lógica condicional

3. Analizador de Texto

   • Contar palabras y caracteres
   • Análisis de frecuencia
   • Generar estadísticas

Intermedio a Avanzado

4. API REST con Flask/Django

   • Endpoints CRUD
   • Autenticación
   • Base de datos

5. Aplicación de Lista de Tareas

   • Interfaz web
   • Base de datos
   • Autenticación de usuarios

6. Analizador de Datos

   • Procesar archivos CSV
   • Generar gráficos
   • Exportar reportes

Recursos de Aprendizaje

Plataformas Educativas

• freeCodeCamp: Cursos gratuitos con certificación
• Codecademy: Lecciones interactivas
• Coursera: Cursos universitarios
• edX: Plataforma de aprendizaje abierta

Documentación Oficial

• Python Documentation: Referencia completa
• PEP 8: Guía de estilo oficial
• Real Python: Tutoriales de calidad

Comunidades

• Stack Overflow: Preguntas y respuestas
• Reddit r/learnpython: Comunidad activa
• Python Discord: Chat en tiempo real
• GitHub: Código abierto y colaboración

Consejos para Continuar Aprendiendo

1. Establece Metas Realistas

   • Aprende un concepto nuevo cada semana
   • Completa un proyecto pequeño cada mes
   • Contribuye a proyectos open source

2. Practica Consistente

   • Codifica diariamente, aunque sea 30 minutos
   • Revisa y refactoriza tu código anterior
   • Participa en challenges de programación

3. Aprende de los Demás

   • Lee código de otros desarrolladores
   • Participa en code reviews
   • Únete a comunidades locales

4. Mantén la Curiosidad

   • Experimenta con nuevas tecnologías
   • Lee blogs y newsletters técnicas
   • Asiste a conferencias y meetups

5. Documenta tu Progreso

   • Mantén un portafolio de proyectos
   • Escribe sobre lo que aprendes
   • Comparte conocimientos con otros

Certificaciones Recomendadas

• PCEP - Python Entry-Level Certification
• PCAP - Python Associate Certification
• AWS Certified Cloud Practitioner
• Google IT Support Professional Certificate

Mantén el Momentum

Recuerda: el aprendizaje de la programación es un maratón, no un sprint. Cada línea de código que escribes te acerca más a convertirte en un desarrollador competente. No te desanimes por los desafíos; son parte del proceso de crecimiento.

¡Sigue adelante, continúa practicando y nunca dejes de aprender! 🚀

Conclusión

¡Has dado tus primeros pasos en la programación! Practica diariamente, construye pequeños proyectos y no tengas miedo de cometer errores. La programación es una habilidad que se desarrolla con la práctica constante.

Para más tutoriales sobre fundamentos de programación y Python, visita nuestra sección de tutoriales.

¡Sigue programando y creando cosas increíbles!

💡 Tip Importante

📝 Mejores Prácticas para Principiantes

• Practica diariamente: La consistencia es clave en el aprendizaje.
• Escribe código: No solo leas, implementa lo que aprendes.
• Depura paso a paso: Aprende a identificar y solucionar errores.
• Comenta tu código: Haz que sea legible para ti y otros.
• Experimenta: Modifica ejemplos y observa qué sucede.
• Únete a comunidades: Comparte tu progreso y aprende de otros.
• Construye proyectos: Aplica lo aprendido en proyectos reales.
• Mantén la curiosidad: Siempre pregunta "por qué" y "cómo".

📚 Recursos Recomendados:

• Documentación Oficial de Python
• freeCodeCamp - Cursos gratuitos
• Codecademy - Lecciones interactivas
• Stack Overflow - Comunidad de programadores

¡Tu viaje en la programación apenas comienza. Sigue adelante y nunca dejes de aprender!