PLAN DE CLASES PYTHON BASICO

PLAN DE CLASES: PYTHON BÁSICO CON VISUAL STUDIO CODE

Objetivo General: Al finalizar el curso, el estudiante será capaz de escribir y ejecutar scripts básicos de Python, comprender los conceptos fundamentales del lenguaje y utilizar Visual Studio Code como su entorno de desarrollo.

Requisitos Previos:

• Computadora con Visual Studio Code instalado.
• Python instalado en el sistema.
• Conocimientos básicos de manejo de archivos y carpetas.

---

Módulo 1: Introducción y Configuración del Entorno (2 horas)

Objetivo: Familiarizar al estudiante con Visual Studio Code, la terminal integrada y asegurarse de que el entorno de Python esté correctamente configurado.

Contenido:

• 1.1. Bienvenida y Presentación del Curso:
• Introducción a Python: ¿Qué es y para qué se utiliza?
• Introducción a Visual Studio Code (VS Code): un editor de código potente.
• Metodología del curso: enfoque práctico desde la terminal.
• 1.2. Configuración de Visual Studio Code para Python:
• Instalación de la extensión de Python de Microsoft.
• Recorrido por la interfaz de VS Code: explorador de archivos, editor de texto y terminal.
• Cómo abrir y usar la terminal integrada (Ctrl+ñ o View > Terminal).
• 1.3. "¡Hola, Mundo!" en Python:
• Crear la primera carpeta de proyecto y el primer archivo (hola_mundo.py).
• Escribir la primera línea de código: print("¡Hola, Mundo!").
• Ejecutar el script desde la terminal de VS Code usando el comando python nombre_del_archivo.py.
• Verificar la instalación de Python y su versión con python --version o python3 --version.

---

Módulo 2: Fundamentos de Python (4 horas)

Objetivo: Introducir los conceptos básicos del lenguaje de programación Python.

Contenido:

• 2.1. Variables y Tipos de Datos:
• ¿Qué es una variable? Reglas para nombrar variables.
• Tipos de datos primitivos:
• Strings (cadenas de texto): nombre = "Juan"
• Integers (números enteros): edad = 25
• Floats (números flotantes): precio = 19.99
• Booleans (booleanos): es_estudiante = True
• Uso de la función print() para mostrar variables.
• La función type() para verificar el tipo de dato de una variable.
• 2.2. Operadores:
• Aritméticos: +, -, *, /, % (módulo), ** (potencia).
• De comparación: ==, !=, >, <, >=, <=.
• Lógicos: and, or, not.
• Práctica: Escribir un script que realice cálculos básicos y los muestre en la terminal.
• 2.3. Entrada del Usuario:
• Uso de la función input() para capturar datos desde la terminal.
• Conversión de tipos de datos (casting): int(), float(), str().
• Práctica: Crear un programa que pida el nombre y la edad al usuario y muestre un saludo personalizado.

---

Módulo 3: Estructuras de Control (4 horas)

Objetivo: Enseñar a los estudiantes cómo controlar el flujo de ejecución de sus programas.

Contenido:

• 3.1. Condicionales if, elif, else:
• Sintaxis y uso para la toma de decisiones.
• Indentación: la regla fundamental de Python.
• Práctica: Escribir un programa que determine si un número es par o impar, o que verifique si un usuario es mayor de edad.
• 3.2. Bucles for:
• Iterar sobre secuencias (como rangos de números con range()).
• Sintaxis y ejemplos prácticos.
• Práctica: Crear un script que imprima los números del 1 al 10 o una tabla de multiplicar.
• 3.3. Bucles while:
• Ejecutar un bloque de código mientras una condición sea verdadera.
• Importancia de la condición de parada para evitar bucles infinitos.
• Práctica: Desarrollar un pequeño juego de adivinar un número.

---

Módulo 4: Estructuras de Datos (4 horas)

Objetivo: Introducir las colecciones de datos más comunes en Python.

Contenido:

• 4.1. Listas:
• Creación de listas y almacenamiento de múltiples elementos.
• Acceso a elementos mediante índices.
• Métodos comunes: append(), len(), pop().
• Uso de bucles for para recorrer listas.
• Práctica: Crear una lista de compras y permitir al usuario agregar y quitar elementos.
• 4.2. Diccionarios (Opcional, según el ritmo):
• Estructura de clave-valor.
• Creación y acceso a valores a través de sus claves.
• Práctica: Modelar un objeto simple como un "usuario" con nombre, edad y email usando un diccionario.

---

Módulo 5: Funciones y Modularidad (3 horas)

Objetivo: Enseñar a los estudiantes a organizar su código en bloques reutilizables.

Contenido:

• 5.1. Definición y Llamada de Funciones:
• Sintaxis: def nombre_funcion():.
• La importancia de no repetir código (principio DRY).
• 5.2. Parámetros y Retorno de Valores:
• Pasar información a las funciones a través de parámetros.
• Uso de return para devolver un resultado.
• Práctica: Crear funciones que realicen operaciones matemáticas (sumar, restar) y devuelvan el resultado.
• 5.3. Importación de Módulos (Básico):
• Introducción a la biblioteca estándar de Python.
• Cómo importar y usar módulos, por ejemplo, el módulo random para generar números aleatorios.
• Práctica: Mejorar el juego de adivinar el número usando random.randint().

---

Módulo 6: Proyecto Final (2-3 horas)

Objetivo: Aplicar todos los conceptos aprendidos en un pequeño proyecto práctico.

Ideas de Proyectos:

• Calculadora Básica en la Terminal: Que solicite dos números y una operación (+, -, *, /) y muestre el resultado.
• Generador de Historias Cortas: Que pida al usuario varias palabras (un sustantivo, un verbo, un adjetivo) y las inserte en una plantilla de historia.
• Pequeño Quiz: Un programa que haga una serie de preguntas y al final muestre la puntuación del usuario.

Pasos del Proyecto:

1. Planificación: Definir el objetivo del programa.
2. Escritura del Código: Aplicar variables, bucles, condicionales y funciones.
3. Pruebas: Ejecutar y depurar el código desde la terminal de VS Code.
4. Presentación: Cada estudiante muestra y explica su proyecto.

 

 

 DESARROLLO DEL PLAN

Módulo 1: Introducción y Configuración del Entorno

Teoría:

• ¿Qué es Python? Es un lenguaje de programación de alto nivel, muy popular por su sintaxis simple y legible, que se asemeja al inglés. Se usa en desarrollo web, análisis de datos, inteligencia artificial, scripting y mucho más.
• ¿Qué es Visual Studio Code (VS Code)? Es un editor de código fuente gratuito y muy potente. No es un IDE completo como otros, pero se puede personalizar con "extensiones" para que funcione con casi cualquier lenguaje.
• Nuestro Entorno de Trabajo:
1. Explorador de Archivos (Barra lateral izquierda): Aquí crearemos y veremos nuestras carpetas y archivos .py.
2. Editor de Texto (Área principal): Aquí escribiremos nuestro código Python.
3. Terminal Integrada (Panel inferior): Es una línea de comandos dentro de VS Code. La usaremos para darle a Python la orden de ejecutar nuestros archivos de código. Es nuestro centro de operaciones.

Práctica y Ejercicios:

1. Configurar el Entorno:
• Abre VS Code.
• Ve al icono de Extensiones (parecen 4 cuadrados).
• Busca "Python" y instala la extensión oficial de Microsoft (generalmente la primera).
• Abre la terminal con el atajo Ctrl + ñ (o desde el menú View > Terminal).
2. Ejercicio 1: Tu Primer Script "Hola, Mundo"
• En tu computadora, crea una carpeta llamada curso_python.
• En VS Code, ve a File > Open Folder... y abre la carpeta curso_python.
• En el explorador de archivos de VS Code, haz clic en el icono de "Nuevo Archivo" y nómbralo hola_mundo.py.
• En el editor, escribe la siguiente línea de código:

codePython

print("¡Hola, Mundo desde la terminal de VS Code!")

• Guarda el archivo (Ctrl + S).
• Ahora, ve a la terminal. Asegúrate de que estás dentro de la carpeta curso_python. Deberías ver algo como PS C:\Users\TuUsuario\curso_python>.
• Escribe el siguiente comando y presiona Enter:

codeBash

python hola_mundo.py

(Nota: Si usas macOS o algunas distribuciones de Linux, puede que necesites usar python3 en lugar de python).

• Resultado esperado: La terminal deberá imprimir el texto: ¡Hola, Mundo desde la terminal de VS Code!
2. Ejercicio 2: Verificar la Versión de Python
• En la misma terminal, escribe el comando:

codeBash

python --version

• Resultado esperado: La terminal te mostrará la versión de Python que tienes instalada (ej. Python 3.9.7). ¡Esto confirma que todo está listo para empezar!

---

Módulo 2: Fundamentos de Python

2.1. Variables y Tipos de Datos

Teoría:

Una variable es como una caja con una etiqueta donde guardamos información. La "etiqueta" es el nombre de la variable y lo que está "dentro" es el valor.

• String (str): Cadenas de texto. Siempre van entre comillas (" o '). Ejemplo: nombre = "Ana".
• Integer (int): Números enteros, sin decimales. Ejemplo: edad = 30.
• Float (float): Números con decimales. Se usa el punto . como separador. Ejemplo: altura = 1.75.
• Boolean (bool): Representa un valor de verdad. Solo puede ser True o False. Ejemplo: es_estudiante = True.
• Función type(): Nos dice de qué tipo es una variable.

Ejercicio: Ficha Personal

1. Crea un nuevo archivo llamado ficha_personal.py.
2. Escribe el siguiente código, reemplazando los valores con los tuyos:

codePython

# Declaramos variables con diferentes tipos de datos

nombre_completo = "Carlos Solis"

edad = 28

altura_metros = 1.82

es_programador = True

 

# Mostramos los valores y sus tipos por pantalla

print("Nombre:", nombre_completo)

print("Tipo de dato de nombre:", type(nombre_completo))

 

print("Edad:", edad)

print("Tipo de dato de edad:", type(edad))

 

print("Altura:", altura_metros)

print("Tipo de dato de altura:", type(altura_metros))

 

print("¿Es programador?:", es_programador)

print("Tipo de dato de es_programador:", type(es_programador))

3. Guarda el archivo y ejecútalo en la terminal: python ficha_personal.py.
4. Observa cómo el programa imprime cada valor y la clase a la que pertenece (<class 'str'>, <class 'int'>, etc.).

2.2. Entrada del Usuario y Conversión de Tipos

Teoría:

Para que nuestros programas sean interactivos, necesitamos pedirle información al usuario.

• Función input(): Detiene la ejecución del programa, muestra un mensaje en la terminal y espera a que el usuario escriba algo y presione Enter.
• ¡Importante! La función input() siempre devuelve el dato como un string (texto). Si necesitamos usarlo como un número, debemos convertirlo.
• Conversión de tipos (Casting):
• int(variable): Convierte la variable a un número entero.
• float(variable): Convierte la variable a un número flotante.
• str(variable): Convierte la variable a una cadena de texto.

Ejercicio: Calculadora de IMC (Índice de Masa Corporal)

1. Crea un archivo llamado calculadora_imc.py.
2. Escribe el siguiente código:

codePython

# Título del programa

print("--- Calculadora de Índice de Masa Corporal (IMC) ---")

 

# Pedimos al usuario su peso y lo convertimos a float

peso_str = input("Introduce tu peso en kg (ej: 70.5): ")

peso_kg = float(peso_str)

 

# Pedimos al usuario su altura y la convertimos a float

altura_str = input("Introduce tu altura en metros (ej: 1.75): ")

altura_m = float(altura_str)

 

# Fórmula del IMC: peso / (altura * altura)

imc = peso_kg / (altura_m ** 2)

 

# Mostramos el resultado. El :.2f formatea el número para mostrar solo 2 decimales.

print(f"Tu Índice de Masa Corporal (IMC) es: {imc:.2f}")

3. Guarda y ejecuta el script: python calculadora_imc.py.
4. Prueba a introducir tu peso y altura. ¿Qué pasa si introduces texto en lugar de números? (¡Dará un error, y eso está bien por ahora!).

---

Módulo 3: Estructuras de Control

3.1. Condicionales if, elif, else

Teoría:

Los condicionales nos permiten ejecutar un bloque de código solo si se cumple una cierta condición. Son la base para que nuestros programas tomen decisiones. La indentación (el espacio al principio de la línea) es crucial en Python; es la que define qué código pertenece al if.

• if condicion:: Si la condición es True, se ejecuta el bloque de código indentado debajo.
• elif otra_condicion:: (Contracción de "else if") Si el if anterior fue False, se comprueba esta nueva condición.
• else:: Si ninguna de las condiciones anteriores fue True, se ejecuta este bloque de código.

Ejercicio: Verificador de Acceso

1. Crea un archivo llamado verificador_acceso.py.
2. Escribe el código:

codePython

edad_usuario = int(input("Por favor, introduce tu edad: "))

 

if edad_usuario >= 18:

    print("¡Acceso permitido! Eres mayor de edad.")

    # Este bloque solo se ejecuta si la edad es 18 o más

    print("Bienvenido a la sección para adultos.")

else:

    print("Acceso denegado. Eres menor de edad.")

    # Este bloque solo se ejecuta si la edad es menor que 18

    diferencia = 18 - edad_usuario

    print(f"Te faltan {diferencia} años para poder entrar.")

 

print("--- Fin del programa ---")

3. Ejecútalo varias veces con diferentes edades (ej. 25, 18, 15) para ver cómo cambia el flujo del programa.

3.2. Bucles for y while

Teoría:

Los bucles nos permiten repetir un bloque de código varias veces.

• Bucle for: Se usa cuando sabemos cuántas veces queremos repetir el código. A menudo se usa con range(numero) para repetir el bucle un número específico de veces. range(1, 11) genera números del 1 al 10.
• Bucle while: Se usa cuando queremos repetir el código mientras una condición sea verdadera. Es fundamental que algo dentro del bucle pueda hacer que la condición se vuelva False para evitar un bucle infinito.

Ejercicio 1: Tabla de Multiplicar (con for)

1. Crea un archivo tabla_multiplicar.py.
2. Escribe este código:

codePython

numero = int(input("Introduce un número para ver su tabla de multiplicar: "))

 

print(f"--- Tabla del {numero} ---")

 

# El bucle for recorrerá los números del 1 al 10

for i in range(1, 11):

    resultado = numero * i

    print(f"{numero} x {i} = {resultado}")

```3.  Ejecútalo y prueba con diferentes números.

Ejercicio 2: Pequeño Menú Interactivo (con while)

1. Crea un archivo menu.py.
2. Escribe el código:

codePython

opcion = "" # Inicializamos la variable

 

# El bucle se repetirá mientras la opción no sea "salir"

while opcion.lower() != "salir":

    print("\n--- MENÚ ---")

    print("Escribe 'hola' para recibir un saludo.")

    print("Escribe 'adios' para una despedida.")

    print("Escribe 'salir' para terminar el programa.")

 

    opcion = input("Elige una opción: ")

 

    if opcion.lower() == "hola":

        print("¡Hola! ¿Qué tal estás?")

    elif opcion.lower() == "adios":

        print("¡Hasta la próxima!")

    elif opcion.lower() == "salir":

        print("Cerrando el programa...")

    else:

        print("Opción no reconocida, por favor intenta de nuevo.")

3. Ejecuta el programa y prueba las diferentes opciones. Observa cómo el bucle while mantiene el programa "vivo" hasta que escribes "salir".

---

Módulo 4: Estructuras de Datos - Listas

Teoría:

Las listas son colecciones ordenadas de elementos. Permiten guardar múltiples valores en una sola variable.

• Creación: Se crean con corchetes [], separando los elementos con comas. Ej: mis_frutas = ["manzana", "banana", "cereza"].
• Acceso: Se accede a los elementos por su índice (posición), que empieza en 0. Ej: mis_frutas[0] devuelve "manzana".
• Métodos útiles:
• lista.append(elemento): Añade un elemento al final de la lista.
• len(lista): Devuelve el número de elementos en la lista.
• lista.pop(): Elimina y devuelve el último elemento de la lista.

Ejercicio: Lista de Tareas (To-Do List)

1. Crea un archivo todo_list.py.
2. Escribe el código:

codePython

tareas = [] # Empezamos con una lista vacía

opcion = 0

 

while opcion != 4:

    # Imprimimos la lista de tareas actual en cada iteración

    print("\n--- TAREAS PENDIENTES ---")

    if len(tareas) == 0:

        print("No tienes tareas pendientes.")

    else:

        for i in range(len(tareas)):

            print(f"{i + 1}. {tareas[i]}")

 

    print("\n--- MENÚ ---")

    print("1. Agregar tarea")

    print("2. Completar última tarea")

    print("3. Ver tareas")

    print("4. Salir")

 

    opcion_str = input("Elige una opción (1-4): ")

 

    # Evitamos errores si el usuario no introduce un número

    if opcion_str.isdigit():

        opcion = int(opcion_str)

 

        if opcion == 1:

            nueva_tarea = input("Escribe la nueva tarea: ")

            tareas.append(nueva_tarea)

            print("¡Tarea añadida!")

        elif opcion == 2:

            if len(tareas) > 0:

                tarea_completada = tareas.pop()

                print(f"¡Tarea '{tarea_completada}' completada y eliminada!")

            else:

                print("No hay tareas que completar.")

        elif opcion == 3:

            # La lista ya se muestra al inicio del bucle

            continue

        elif opcion == 4:

            print("¡Adiós!")

        else:

            print("Opción no válida.")

    else:

        print("Por favor, introduce solo un número.")

3. Ejecuta el programa y prueba a añadir tareas, completarlas y salir. Este ejercicio integra listas, bucles y condicionales.

---

Módulo 5: Funciones y Modularidad

Teoría:

Las funciones son bloques de código reutilizables a los que les damos un nombre. Ayudan a organizar el código, hacerlo más legible y evitar la repetición.

• Definición: Se usa la palabra clave def, seguida del nombre de la función y paréntesis (). Ej: def saludar():.
• Parámetros (Inputs): Son variables que la función recibe para trabajar con ellas. Van dentro de los paréntesis. Ej: def saludar(nombre):.
• Retorno (Output): Una función puede devolver un valor usando la palabra clave return. Si una función no tiene un return, devuelve None por defecto.
• Módulos: Son archivos de Python con código que podemos importar en nuestros scripts para usar sus funciones. El módulo random es muy útil para generar aleatoriedad.

Ejercicio: Refactorizando la Calculadora con Funciones

1. Crea un archivo calculadora_funciones.py.
2. Escribe el código:

codePython

import random # Importamos el módulo random para un extra

 

# --- Definición de Funciones ---

def sumar(a, b):

    """Esta función recibe dos números y devuelve su suma."""

    return a + b

 

def restar(a, b):

    """Esta función recibe dos números y devuelve su resta."""

    return a - b

 

def multiplicar(a, b):

    """Esta función recibe dos números y devuelve su multiplicación."""

    return a * b

 

def dividir(a, b):

    """Esta función recibe dos números y devuelve su división.

       Maneja el error de división por cero."""

    if b == 0:

        return "Error: No se puede dividir por cero."

    else:

        return a / b

 

# --- Programa Principal ---

print("--- Calculadora con Funciones ---")

num1 = float(input("Introduce el primer número: "))

num2 = float(input("Introduce el segundo número: "))

operador = input("Introduce la operación (+, -, *, /): ")

 

if operador == "+":

    resultado = sumar(num1, num2)

elif operador == "-":

    resultado = restar(num1, num2)

elif operador == "*":

    resultado = multiplicar(num1, num2)

elif operador == "/":

    resultado = dividir(num1, num2)

else:

    resultado = "Operador no válido."

 

print(f"El resultado es: {resultado}")

 

# Extra: Usando el módulo random

print(f"Un número aleatorio entre 1 y 100: {random.randint(1, 100)}")

3. Ejecuta el programa. Ahora la lógica está mucho más organizada. Cada operación es una función independiente y el programa principal solo se encarga de llamar a la función correcta.

---

Módulo 6: Proyecto Final

Proyecto Sugerido: Juego "Adivina el Número"

Este proyecto integra todos los conceptos: variables, entrada de usuario, el módulo random, bucles while, y condicionales if/elif/else.

Ejercicio: Código Completo del Juego

1. Crea un archivo juego_adivina.py.
2. Escribe el código:

codePython

import random

 

def jugar_adivina_el_numero():

    """Función principal que contiene toda la lógica del juego."""

    print("==========================================")

    print("  ¡Bienvenido a Adivina el Número!  ")

    print("==========================================")

    print("He pensado en un número entre 1 y 100.")

    print("¿Podrás adivinarlo en el menor número de intentos?")

 

    # Generar un número aleatorio secreto

    numero_secreto = random.randint(1, 100)

    intentos = 0

    adivinado = False

 

    # El bucle principal del juego

    while not adivinado:

        # Pedir un número al usuario y manejar posibles errores

        try:

            intento_usuario = int(input("\nIntroduce tu número: "))

            intentos += 1 # Incrementar el contador de intentos

        except ValueError:

            print("Error: Debes introducir un número entero. Inténtalo de nuevo.")

            continue # Vuelve al inicio del bucle

 

        # Comparar el número del usuario con el secreto

        if intento_usuario < numero_secreto:

            print("¡Demasiado bajo! Prueba con un número más alto.")

        elif intento_usuario > numero_secreto:

            print("¡Demasiado alto! Prueba con un número más bajo.")

        else:

            adivinado = True

            print("\n*****************************************************")

            print(f"¡Felicidades! ¡Has adivinado el número {numero_secreto}!")

            print(f"Lo lograste en {intentos} intentos.")

            print("*****************************************************")

 

# --- Iniciar el juego ---

jugar_adivina_el_numero()

3. ¡A Jugar! Ejecuta el script python juego_adivina.py en la terminal y disfruta de tu primer programa completo. Anima al estudiante a modificarlo: cambiar el rango de números, añadir un límite de intentos, etc.