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:
- Planificación: Definir
el objetivo del programa.
- Escritura
del Código: Aplicar variables, bucles, condicionales y
funciones.
- Pruebas: Ejecutar
y depurar el código desde la terminal de VS Code.
- 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:
- Explorador
de Archivos (Barra lateral izquierda): Aquí crearemos y
veremos nuestras carpetas y archivos .py.
- Editor
de Texto (Área principal): Aquí escribiremos nuestro
código Python.
- 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:
- 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).
- 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!
- 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
- Crea un
nuevo archivo llamado ficha_personal.py.
- 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))
- Guarda
el archivo y ejecútalo en la terminal: python ficha_personal.py.
- 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)
- Crea un
archivo llamado calculadora_imc.py.
- 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}")
- Guarda y
ejecuta el script: python calculadora_imc.py.
- 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
- Crea un
archivo llamado verificador_acceso.py.
- 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 ---")
- 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)
- Crea un
archivo tabla_multiplicar.py.
- 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)
- Crea un
archivo menu.py.
- 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.")
- 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)
- Crea un
archivo todo_list.py.
- 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.")
- 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
- Crea un
archivo calculadora_funciones.py.
- 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)}")
- 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
- Crea un
archivo juego_adivina.py.
- 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()
- ¡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.
