Fundamentos del lenguaje Python

🎯 Objetivo

Aprender los bloques básicos de la programación moderna para construir programas funcionales y bien estructurados.

---

📚 Contenidos del Módulo

1. Tipos de Datos

Los tipos de datos son las categorías fundamentales de información que Python puede manejar.

Números

• Enteros (int): Números sin decimales

edad = 25
temperatura = -5
habitantes = 1000000

• Flotantes (float): Números con decimales

precio = 19.99
pi = 3.14159
temperatura_corporal = 36.5

Texto (Strings)

Cadenas de caracteres para representar texto.

nombre = "María"
mensaje = 'Hola, bienvenido al curso'
parrafo = """Este es un texto
que ocupa varias líneas"""

# Operaciones comunes con strings
saludo = "Hola " + nombre  # Concatenación
nombre_mayusculas = nombre.upper()  # MARÍA
longitud = len(mensaje)  # 26

Booleanos

Valores de verdad: True (verdadero) o False (falso)

esta_activo = True
tiene_descuento = False
es_mayor_edad = edad >= 18  # Resultado booleano

Listas

Colecciones ordenadas de elementos que pueden modificarse.

frutas = ["manzana", "banana", "naranja"]
numeros = [1, 2, 3, 4, 5]
mixta = [1, "texto", True, 3.14]

# Operaciones comunes
frutas.append("uva")  # Agregar al final
primera_fruta = frutas[0]  # Acceder por índice
cantidad = len(frutas)  # Longitud de la lista

Tuplas

Colecciones ordenadas e inmutables (no se pueden modificar).

coordenadas = (10, 20)
fecha = (2025, 10, 31)
datos_fijos = ("Python", 3.11, True)

Diccionarios

Colecciones de pares clave-valor para almacenar datos relacionados.

estudiante = {
    "nombre": "Carlos",
    "edad": 22,
    "carrera": "Ingeniería"
}

# Acceder a valores
nombre_est = estudiante["nombre"]
estudiante["edad"] = 23  # Modificar valor
estudiante["semestre"] = 5  # Agregar nueva clave

---

2. Variables

Las variables son como cajas etiquetadas donde guardamos información para usarla más adelante en nuestro programa.

Concepto clave: Una variable tiene un nombre y almacena un valor que puede cambiar durante la ejecución del programa.

# Asignación simple
nombre = "Ana"
edad = 30

# Reasignación
edad = 31  # El valor cambia

# Múltiples asignaciones
x, y, z = 10, 20, 30

# Intercambio de valores
a, b = 5, 10
a, b = b, a  # Ahora a=10 y b=5

Reglas para nombrar variables:

• Deben comenzar con letra o guión bajo (_)
• Pueden contener letras, números y guiones bajos
• No pueden contener espacios
• No usar palabras reservadas de Python (if, for, while, class, etc.)
• Se recomienda usar minúsculas y guiones bajos (snake_case)
• Usar nombres descriptivos y significativos

# ✅ Correcto
nombre_completo = "Juan Pérez"
edad_usuario = 25
total_ventas_2024 = 50000
_variable_privada = "dato interno"

# ❌ Incorrecto
2nombre = "Error"  # No puede empezar con número
mi-variable = "Error"  # El guion no está permitido
class = "Error"  # Palabra reservada
for = 10  # Palabra reservada

---

3. Estructuras de Control

A. Condicionales (if, elif, else)

Permiten que el programa tome decisiones basadas en condiciones.

Sintaxis básica:

if condicion:
    # Código si la condición es verdadera
elif otra_condicion:
    # Código si la segunda condición es verdadera
else:
    # Código si ninguna condición anterior es verdadera

Operadores de comparación:

• == igual a
• != diferente de
• > mayor que
• < menor que
• >= mayor o igual
• <= menor o igual

Operadores lógicos:

• and – ambas condiciones deben ser verdaderas
• or – al menos una condición debe ser verdadera
• not – invierte el valor de verdad

Ejemplos prácticos:

# Ejemplo 1: Verificar edad
edad = 18

if edad >= 18:
    print("Eres mayor de edad")
else:
    print("Eres menor de edad")

# Ejemplo 2: Múltiples condiciones
nota = 85

if nota >= 90:
    print("Excelente - A")
elif nota >= 80:
    print("Muy Bueno - B")
elif nota >= 70:
    print("Bueno - C")
elif nota >= 60:
    print("Aprobado - D")
else:
    print("Reprobado - F")

# Ejemplo 3: Condiciones compuestas
temperatura = 25
es_fin_de_semana = True

if temperatura > 20 and es_fin_de_semana:
    print("Perfecto para ir a la playa")
elif temperatura > 20 and not es_fin_de_semana:
    print("Buen día para trabajar con las ventanas abiertas")
else:
    print("Mejor quedarse en casa")

# Ejemplo 4: Verificar pertenencia
frutas_disponibles = ["manzana", "banana", "naranja"]
fruta_deseada = "mango"

if fruta_deseada in frutas_disponibles:
    print(f"Tenemos {fruta_deseada}")
else:
    print(f"Lo sentimos, no tenemos {fruta_deseada}")

B. Bucles (for, while)

Los bucles permiten repetir acciones de forma controlada sin escribir el mismo código múltiples veces.

Bucle for: Se usa cuando sabemos cuántas veces queremos repetir algo o cuando queremos iterar sobre una colección.

# Ejemplo 1: Iterar sobre una lista
frutas = ["manzana", "banana", "naranja"]

for fruta in frutas:
    print(f"Me gusta la {fruta}")

# Salida:
# Me gusta la manzana
# Me gusta la banana
# Me gusta la naranja

# Ejemplo 2: Rango de números
for i in range(5):
    print(f"Número: {i}")
# Salida: 0, 1, 2, 3, 4

for i in range(1, 6):
    print(f"Número: {i}")
# Salida: 1, 2, 3, 4, 5

for i in range(0, 10, 2):
    print(f"Número: {i}")
# Salida: 0, 2, 4, 6, 8

# Ejemplo 3: Iterar sobre diccionario
estudiante = {
    "nombre": "Luis",
    "edad": 20,
    "carrera": "Medicina"
}

for clave, valor in estudiante.items():
    print(f"{clave}: {valor}")

# Solo claves
for clave in estudiante.keys():
    print(clave)

# Solo valores
for valor in estudiante.values():
    print(valor)

# Ejemplo 4: Enumerar elementos (obtener índice y valor)
frutas = ["manzana", "banana", "naranja"]

for indice, fruta in enumerate(frutas):
    print(f"{indice + 1}. {fruta}")

# Salida:
# 1. manzana
# 2. banana
# 3. naranja

Bucle while: Se usa cuando no sabemos exactamente cuántas veces repetir, pero tenemos una condición.

# Ejemplo 1: Contador simple
contador = 0

while contador < 5:
    print(f"Contador: {contador}")
    contador += 1

print("Bucle terminado")

# Ejemplo 2: Validación de entrada
password_correcta = "1234"
intentos = 0
max_intentos = 3

while intentos < max_intentos:
    password = input("Ingresa la contraseña: ")
    if password == password_correcta:
        print("Acceso concedido")
        break
    else:
        intentos += 1
        print(f"Contraseña incorrecta. Intentos restantes: {max_intentos - intentos}")

if intentos == max_intentos:
    print("Máximo de intentos alcanzado. Acceso bloqueado.")

# Ejemplo 3: Menú interactivo
opcion = ""

while opcion != "4":
    print("\n=== MENÚ ===")
    print("1. Ver perfil")
    print("2. Editar perfil")
    print("3. Configuración")
    print("4. Salir")
    
    opcion = input("Selecciona una opción: ")
    
    if opcion == "1":
        print("Mostrando perfil...")
    elif opcion == "2":
        print("Editando perfil...")
    elif opcion == "3":
        print("Abriendo configuración...")
    elif opcion == "4":
        print("¡Hasta luego!")
    else:
        print("Opción no válida")

Instrucciones de control de bucles:

• break – Sale del bucle inmediatamente
• continue – Salta a la siguiente iteración
• pass – No hace nada (placeholder)

# Ejemplo de break y continue
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# break: detener cuando se encuentra el número 5
for num in numeros:
    if num == 5:
        print("Número 5 encontrado, deteniendo...")
        break
    print(num)

# continue: saltar números pares
for num in numeros:
    if num % 2 == 0:
        continue  # Salta los números pares
    print(f"Número impar: {num}")

---

4. Funciones

Las funciones son bloques de código reutilizables que realizan tareas específicas. Nos ayudan a organizar el código, evitar repeticiones y hacer el programa más mantenible.

Concepto clave: «Don’t Repeat Yourself» (DRY). Si escribes el mismo código más de dos veces, probablemente necesitas una función.

Sintaxis básica:

def nombre_funcion(parametros):
    """Docstring: descripción de lo que hace la función"""
    # Código de la función
    return resultado

Ejemplos prácticos:

# Ejemplo 1: Función simple sin parámetros
def saludar():
    """Imprime un mensaje de bienvenida"""
    print("¡Hola, bienvenido!")

saludar()  # Llamada a la función

# Ejemplo 2: Función con parámetros
def saludar_persona(nombre):
    """Saluda a una persona por su nombre"""
    print(f"¡Hola, {nombre}!")

saludar_persona("María")
saludar_persona("Carlos")

# Ejemplo 3: Función que retorna un valor
def sumar(a, b):
    """Suma dos números y retorna el resultado"""
    resultado = a + b
    return resultado

total = sumar(5, 3)
print(f"El total es: {total}")  # El total es: 8

# Uso directo del retorno
print(f"10 + 20 = {sumar(10, 20)}")

# Ejemplo 4: Función con parámetros por defecto
def crear_perfil(nombre, edad, ciudad="Lima"):
    """Crea un perfil de usuario con ciudad por defecto"""
    return f"{nombre}, {edad} años, vive en {ciudad}"

perfil1 = crear_perfil("Ana", 25)
perfil2 = crear_perfil("Luis", 30, "Arequipa")

print(perfil1)  # Ana, 25 años, vive en Lima
print(perfil2)  # Luis, 30 años, vive en Arequipa

# Ejemplo 5: Función con múltiples retornos
def dividir(a, b):
    """Divide dos números y maneja el caso de división por cero"""
    if b == 0:
        return None, "Error: No se puede dividir por cero"
    else:
        return a / b, "Operación exitosa"

resultado, mensaje = dividir(10, 2)
print(f"Resultado: {resultado}, {mensaje}")

resultado, mensaje = dividir(10, 0)
print(f"Resultado: {resultado}, {mensaje}")

# Ejemplo 6: Función más compleja
def calcular_promedio(notas):
    """Calcula el promedio de una lista de notas"""
    if len(notas) == 0:
        return 0
    
    suma = sum(notas)
    promedio = suma / len(notas)
    return round(promedio, 2)  # Redondear a 2 decimales

mis_notas = [85, 90, 78, 92]
resultado = calcular_promedio(mis_notas)
print(f"Tu promedio es: {resultado}")

# Ejemplo 7: Función con *args (argumentos variables)
def sumar_todos(*numeros):
    """Suma cualquier cantidad de números"""
    return sum(numeros)

print(sumar_todos(1, 2, 3))  # 6
print(sumar_todos(10, 20, 30, 40))  # 100

# Ejemplo 8: Función con **kwargs (argumentos con nombre)
def crear_usuario(**datos):
    """Crea un usuario con datos flexibles"""
    print("Usuario creado:")
    for clave, valor in datos.items():
        print(f"  {clave}: {valor}")

crear_usuario(nombre="Ana", edad=25, ciudad="Lima", profesion="Ingeniera")

Buenas prácticas con funciones:

• Usa nombres descriptivos que indiquen qué hace la función
• Una función debe hacer una sola cosa y hacerla bien
• Incluye docstrings para documentar la función
• Evita funciones muy largas (más de 20-30 líneas)
• Usa parámetros por defecto cuando sea apropiado

---

5. Clases (Programación Orientada a Objetos)

Las clases son plantillas para crear objetos. Permiten agrupar datos (atributos) y comportamientos (métodos) relacionados en una sola estructura.

Concepto clave: Una clase es como un molde o plano, y los objetos son las instancias concretas creadas a partir de ese molde.

Sintaxis básica:

class NombreClase:
    """Docstring: descripción de la clase"""
    
    def __init__(self, parametros):
        """Constructor: inicializa los atributos del objeto"""
        self.atributo = valor
    
    def metodo(self):
        """Método: comportamiento del objeto"""
        # Código del método
        pass

Ejemplos prácticos:

# Ejemplo 1: Clase básica
class Perro:
    """Representa un perro con nombre y edad"""
    
    def __init__(self, nombre, edad):
        """Constructor de la clase Perro"""
        self.nombre = nombre
        self.edad = edad
    
    def ladrar(self):
        """El perro ladra"""
        print(f"{self.nombre} dice: ¡Guau guau!")
    
    def cumplir_años(self):
        """Incrementa la edad del perro"""
        self.edad += 1
        print(f"{self.nombre} ahora tiene {self.edad} años")
    
    def __str__(self):
        """Representación en string del objeto"""
        return f"Perro: {self.nombre}, {self.edad} años"

# Crear objetos (instancias de la clase)
mi_perro = Perro("Max", 3)
tu_perro = Perro("Luna", 5)

mi_perro.ladrar()  # Max dice: ¡Guau guau!
mi_perro.cumplir_años()  # Max ahora tiene 4 años
print(mi_perro)  # Perro: Max, 4 años

# Ejemplo 2: Clase Estudiante
class Estudiante:
    """Representa un estudiante con sus notas y datos personales"""
    
    # Variable de clase (compartida por todas las instancias)
    institucion = "Universidad Nacional"
    
    def __init__(self, nombre, edad, carrera):
        """Constructor de la clase Estudiante"""
        self.nombre = nombre
        self.edad = edad
        self.carrera = carrera
        self.notas = []
    
    def agregar_nota(self, nota):
        """Agrega una nota a la lista de notas"""
        if 0 <= nota <= 100: self.notas.append(nota) print(f"Nota {nota} agregada correctamente") else: print("Error: La nota debe estar entre 0 y 100") def calcular_promedio(self): """Calcula el promedio de las notas""" if len(self.notas) == 0: return 0 return round(sum(self.notas) / len(self.notas), 2) def obtener_estado(self): """Determina si el estudiante está aprobado""" promedio = self.calcular_promedio() if promedio >= 70:
            return "Aprobado"
        else:
            return "Reprobado"
    
    def presentarse(self):
        """Retorna una presentación del estudiante"""
        return f"Hola, soy {self.nombre}, estudio {self.carrera} en {self.institucion}"
    
    def __str__(self):
        """Representación en string del estudiante"""
        return f"{self.nombre} - {self.carrera} - Promedio: {self.calcular_promedio()}"

# Uso de la clase
estudiante1 = Estudiante("Carlos", 20, "Ingeniería")
estudiante1.agregar_nota(85)
estudiante1.agregar_nota(90)
estudiante1.agregar_nota(78)

print(estudiante1.presentarse())
print(f"Promedio: {estudiante1.calcular_promedio()}")
print(f"Estado: {estudiante1.obtener_estado()}")
print(estudiante1)  # Usa __str__

# Ejemplo 3: Clase CuentaBancaria
class CuentaBancaria:
    """Representa una cuenta bancaria con operaciones básicas"""
    
    def __init__(self, titular, saldo_inicial=0):
        """Constructor de la cuenta bancaria"""
        self.titular = titular
        self.saldo = saldo_inicial
        self.historial = []
    
    def depositar(self, monto):
        """Deposita dinero en la cuenta"""
        if monto > 0:
            self.saldo += monto
            self.historial.append(f"Depósito: +${monto}")
            print(f"Depósito exitoso. Nuevo saldo: ${self.saldo}")
        else:
            print("Error: El monto debe ser positivo")
    
    def retirar(self, monto):
        """Retira dinero de la cuenta"""
        if monto <= 0: print("Error: El monto debe ser positivo") elif monto > self.saldo:
            print(f"Fondos insuficientes. Saldo actual: ${self.saldo}")
        else:
            self.saldo -= monto
            self.historial.append(f"Retiro: -${monto}")
            print(f"Retiro exitoso. Nuevo saldo: ${self.saldo}")
    
    def consultar_saldo(self):
        """Muestra el saldo actual"""
        print(f"Saldo actual de {self.titular}: ${self.saldo}")
        return self.saldo
    
    def ver_historial(self):
        """Muestra el historial de transacciones"""
        print(f"\n=== Historial de {self.titular} ===")
        if len(self.historial) == 0:
            print("No hay transacciones registradas")
        else:
            for transaccion in self.historial:
                print(f"  {transaccion}")
    
    def transferir(self, otra_cuenta, monto):
        """Transfiere dinero a otra cuenta"""
        if monto <= self.saldo:
            self.retirar(monto)
            otra_cuenta.depositar(monto)
            print(f"Transferencia de ${monto} a {otra_cuenta.titular} exitosa")
        else:
            print("Fondos insuficientes para la transferencia")

# Crear y usar cuentas bancarias
cuenta1 = CuentaBancaria("María García", 1000)
cuenta2 = CuentaBancaria("Juan Pérez", 500)

cuenta1.consultar_saldo()
cuenta1.depositar(500)
cuenta1.retirar(300)
cuenta1.retirar(2000)  # Intentará retirar más de lo disponible
cuenta1.transferir(cuenta2, 200)

cuenta1.ver_historial()
cuenta2.ver_historial()

# Ejemplo 4: Herencia
class Animal:
    """Clase base para animales"""
    
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    
    def hacer_sonido(self):
        """Método genérico para hacer sonido"""
        print("El animal hace un sonido")
    
    def describir(self):
        """Describe al animal"""
        return f"{self.nombre} tiene {self.edad} años"

class Gato(Animal):
    """Clase derivada de Animal para gatos"""
    
    def hacer_sonido(self):
        """Sobrescribe el método de la clase padre"""
        print(f"{self.nombre} dice: ¡Miau!")
    
    def ronronear(self):
        """Método específico de gatos"""
        print(f"{self.nombre} está ronroneando...")

# Usar herencia
mi_gato = Gato("Michi", 2)
mi_gato.hacer_sonido()  # ¡Miau!
mi_gato.ronronear()  # Está ronroneando...
print(mi_gato.describir())  # Michi tiene 2 años

Conceptos clave de Programación Orientada a Objetos:

• Encapsulamiento: Agrupar datos y métodos relacionados en una clase
• Abstracción: Ocultar la complejidad y mostrar solo lo necesario
• Herencia: Crear nuevas clases basadas en clases existentes
• Polimorfismo: Objetos de diferentes clases pueden responder al mismo método
• Reutilización: Crear múltiples objetos a partir de una clase
• Organización: Código más estructurado y mantenible

Cuándo usar clases:

• Cuando necesitas representar entidades del mundo real
• Cuando tienes datos y comportamientos relacionados
• Cuando necesitas crear múltiples instancias con el mismo comportamiento
• Cuando quieres organizar mejor tu código en proyectos grandes

---

✅ Resultado Esperado

Al completar este módulo, el alumno será capaz de:

1. Identificar y utilizar los diferentes tipos de datos en Python (int, float, str, bool, list, tuple, dict)
2. Declarar y manipular variables de forma correcta siguiendo las convenciones de Python
3. Implementar lógica condicional para que los programas tomen decisiones usando if/elif/else
4. Crear bucles eficientes con for y while para automatizar tareas repetitivas
5. Definir funciones reutilizables que organicen el código y sigan el principio DRY
6. Diseñar clases básicas para estructurar programas con Programación Orientada a Objetos
7. Aplicar herencia para reutilizar código entre clases relacionadas
8. Comprender cómo se construye la lógica dentro de un programa real y escalable
9. Escribir código limpio y bien documentado con buenas prácticas

---

🎓 Ejercicios Prácticos Sugeridos

Ejercicio 1: Variables y Tipos de Datos

Crea un programa que pida nombre, edad y ciudad del usuario, y muestre un mensaje personalizado. Además, calcula en qué año la persona cumplirá 100 años.

Ejercicio 2: Condicionales

Programa que calcule el precio final de un producto aplicando descuentos según el monto de compra:

• Compras mayores a $100: 10% de descuento
• Compras mayores a $200: 15% de descuento
• Compras mayores a $500: 20% de descuento

Ejercicio 3: Bucles

Crea una tabla de multiplicar del 1 al 10 para un número dado por el usuario. Formatea la salida de manera clara y legible.

Ejercicio 4: Funciones

Crea un conjunto de funciones para convertir temperaturas:

• Celsius a Fahrenheit
• Fahrenheit a Celsius
• Celsius a Kelvin
• Kelvin a Celsius

Ejercicio 5: Listas y Funciones

Crea una función que reciba una lista de números y retorne:

• El promedio
• El número mayor
• El número menor
• La mediana

Ejercicio 6: Diccionarios

Crea un programa de agenda telefónica que permita:

• Agregar contactos (nombre y teléfono)
• Buscar contactos por nombre
• Eliminar contactos
• Listar todos los contactos

Ejercicio 7: Clases – Nivel Básico

Diseña una clase Libro con atributos: título, autor, páginas, año_publicacion, y métodos para:

• Mostrar información del libro
• Marcar como leído/no leído
• Calcular la antigüedad del libro

Ejercicio 8: Clases – Nivel Intermedio

Crea una clase Tienda que gestione un inventario de productos. Debe poder:

• Agregar productos (nombre, precio, cantidad)
• Vender productos (reducir cantidad)
• Mostrar inventario
• Calcular el valor total del inventario
• Alertar cuando un producto tenga stock bajo (menos de 5 unidades)

Ejercicio 9: Proyecto Integrador

Crea un sistema de gestión de estudiantes que combine todo lo aprendido:

• Clase Estudiante con nombre, edad, notas
• Clase Curso que contenga una lista de estudiantes
• Funciones para agregar/eliminar estudiantes
• Calcular promedio del curso
• Listar estudiantes aprobados/reprobados
• Generar reporte con estadísticas

---

📖 Recursos Adicionales

• Documentación oficial de Python: https://docs.python.org/es/3/
• PEP 8 – Guía de estilo de Python: https://peps.python.org/pep-0008/
• Python Tutor: Visualiza la ejecución de código paso a paso
• Real Python: Tutoriales avanzados y artículos

---

💡 Consejos para el Aprendizaje

• Practica diariamente: La programación se aprende haciendo, no solo leyendo
• Comete errores: Los errores son oportunidades de aprendizaje
• Lee código de otros: Aprende de proyectos open source
• Comenta tu código: Explica el «por qué», no solo el «qué»
• Usa nombres descriptivos: El código se lee más veces de las que se escribe
• Empieza simple: Construye programas pequeños antes de proyectos grandes
• Busca ayuda: La comunidad de Python es muy amigable

IMPORTANTE: Para que tu progreso quede registrado y puedas avanzar en el curso, recuerda hacer clic en el botón «Completar» al terminar esta lección.

• Solo al marcar la lección como completada se desbloquearán las siguientes lecciones.
• Es necesario marcar todas las lecciones de este módulo como completadas para poder pasar al Módulo 02.

Cuando termines de revisar el contenido, baja hasta el final de la página y haz clic en «Completar» antes de continuar.