Curso de Python Sesion 1

Curso de básico de Python.
Prof. Ing. Jesús R. Romero Manzanilla
Sesión 1 (8 horas):
1. Introducción a Python (1 hora)

o ¿Qué es Python?
o Instalación y configuración del entorno de desarrollo
o Tu primer programa: "¿Qué vamos hacer hoy?" “ Vamos a conquistar el
Mundo!”
2. Fundamentos de Python (2 horas)
o Variables y tipos de datos
o Operadores
o Estructuras de control: if, else, elif
o Bucles: for y while
3. Estructuras de datos (2 horas)
o Listas
o Tuplas
o Diccionarios
o Conjuntos
4. Funciones (2 horas)
o Definición y llamada de funciones
o Argumentos y parámetros
o Retorno de valores
o Funciones lambda
5. Manejo de excepciones (1 hora)
o Try, except, else, finally
o Lanzar excepciones con raise
.
Desarrollo del contenido.

Sesión 1:
1. Introducción a Python (1 hora)
Contenido teórico detallado:
1.1 ¿Qué es Python? Python es un lenguaje de programación de alto nivel, interpretado y de

propósito general. Creado por Guido van Rossum y lanzado por primera vez en 1991,
Python se ha convertido en uno de los lenguajes más populares debido a su simplicidad y
versatilidad.
Características principales:
 Sintaxis clara y legible: Utiliza indentación para definir bloques de código.

 Tipado dinámico: No es necesario declarar el tipo de las variables.
 Multiplataforma: Funciona en Windows, macOS, Linux y otros sistemas operativos.
 Interpretado: No necesita ser compilado para ejecutarse.
 Orientado a objetos: Soporta programación orientada a objetos, pero también
permite otros paradigmas.
 Extensible: Puede integrarse con otros lenguajes y herramientas.
Aplicaciones comunes:
 Desarrollo web (Django, Flask)

 Ciencia de datos y análisis (NumPy, Pandas)
 Inteligencia artificial y aprendizaje automático (TensorFlow, PyTorch)
 Automatización y scripting
 Desarrollo de juegos (Pygame)
 Aplicaciones de escritorio (PyQt, Tkinter)
1.2 Instalación y configuración del entorno de desarrollo
Pasos para instalar Python:
1. Visitar www.python.org
2. Descargar la última versión estable para tu sistema operativo
3. Ejecutar el instalador y seguir las instrucciones (importante: marcar la opción "Add
Python to PATH")
4. Verificar la instalación abriendo una terminal y escribiendo: python --version
Instalación de un IDE (Entorno de Desarrollo Integrado):
 Visual Studio Code (alternativa ligera):

1. Visitar code.visualstudio.com
2. Descargar e instalar
3. Instalar la extensión de Python desde el marketplace de VS Code
1.3 Tu primer programa: "Qué vamos hacer hoy?!" “ Vamos a conquistar al mundo!”
Ejemplo ilustrativo:
# Este es un comentario. El intérprete de Python lo ignorará.
# La función print() muestra texto en la consola

print("¿Qué vamos hacer hoy?”)
print(“Vamos a conquistar al mundo?”)
# Podemos usar variables para almacenar valores

nombre = "Python"
print("Hola,", nombre)
# Podemos solicitar entrada del usuario

tu_nombre = input("¿Cómo te llamas? ")
print(f"Hola, {tu_nombre}. Bienvenido al mundo de la programación!")
Explicación:
 La función print() se usa para mostrar texto en la consola.

 Podemos usar comillas simples ('') o dobles ("") para cadenas de texto.
 Las variables se crean simplemente asignándoles un valor.
 La función input() permite obtener entrada del usuario.
 Usamos f-strings (cadenas formateadas) para incluir variables dentro de texto.
Tarea para los participantes:
1. Instalar Python y un IDE (VS Code).

2. Crear un nuevo archivo Python y escribir el programa "Inicio la aventura!".
3. Modificar el programa para que pregunte al usuario su nombre y su edad, y luego
imprima un mensaje personalizado como "Hola [nombre], tienes [edad] años y estás
aprendiendo Python!".
4. Experimentar con diferentes tipos de print: múltiples argumentos, f-strings,

concatenación con +.
2. Fundamentos de Python (2 horas)
2.1 Variables y tipos de datos
En Python, las variables son nombres que se refieren a valores almacenados en la memoria.
Python es un lenguaje de tipado dinámico, lo que significa que no es necesario declarar el
tipo de una variable explícitamente.
Tipos de datos básicos:
a) Enteros (int):
edad = 25
año_actual = 2024
numero_negativo = -10
b) Números de punto flotante (float):
altura = 1.75
pi = 3.14159
c) Cadenas de texto (str):
nombre = "Ana"
apellido = 'García'
frase = """Este es un texto
que ocupa varias líneas"""
d) Booleanos (bool):
es_estudiante = True
tiene_mascota = False
e) Valor nulo (None):
valor_desconocido = None
Ejemplo ilustrativo:
# Demostración de tipos de datos

edad = 30
altura = 1.75
nombre = "Carlos"
es_estudiante = False
print(f"Tipo de edad: {type(edad)}")

print(f"Tipo de altura: {type(altura)}")
print(f"Tipo de nombre: {type(nombre)}")
print(f"Tipo de es_estudiante: {type(es_estudiante)}")
# Conversión entre tipos

edad_str = str(edad)
altura_int = int(altura)
es_estudiante_str = str(es_estudiante)
print(f"Edad como string: {edad_str}, tipo: {type(edad_str)}")

print(f"Altura como entero: {altura_int}, tipo: {type(altura_int)}")
print(f"es_estudiante como string: {es_estudiante_str}, tipo:
{type(es_estudiante_str)}")
2.2 Operadores
a) Operadores aritméticos:
suma = 5 + 3 #8
resta = 10 - 4 #6
multiplicacion = 3 * 4 # 12
division = 15 / 4 # 3.75
division_entera = 15 // 4 # 3
modulo = 15 % 4 #3
potencia = 2 ** 3 #8
b) Operadores de comparación:
igual = (5 == 5) # True
diferente = (5 != 3) # True
mayor_que = (7 > 3) # True
menor_que = (2 < 8) # True
mayor_o_igual = (5 >= 5) # True
menor_o_igual = (4 <= 6) # True
c) Operadores lógicos:
and_logico = True and False # False

or_logico = True or False # True
not_logico = not True # False
2.3 Estructuras de control
a) Condicionales (if, else, elif):
La estructura if-elif-else permite ejecutar diferentes bloques de código basados en

condiciones.
Estructura básica:
if condicion1:
# código si condicion1 es verdadera
elif condicion2:
# código si condicion2 es verdadera
else:
# código si ninguna condición anterior es verdadera
Características importantes:
 Puedes tener múltiples bloques elif.

 El bloque else es opcional.
 La indentación es crucial para definir los bloques de código.
Ejemplos sencillos:
1. Determinar si un número es positivo, negativo o cero:
numero = float(input("Introduce un número: "))

if numero > 0:
print("El número es positivo")
elif numero < 0:
print("El número es negativo")
else:
print("El número es cero")
2. Calificación de un examen:
calificacion = int(input("Introduce la calificación (0-100): "))

if calificacion >= 90:
print("A")
elif calificacion >= 80:
print("B")
print("C")
print("D")
else:
print("F")
Ejemplo complejo: Determinar si un año es bisiesto:
año = int(input("Introduce un año: "))

if año % 4 == 0:
if año % 100 == 0:
if año % 400 == 0:
print("Es un año bisiesto")
else:
print("No es un año bisiesto")
else:
print("Es un año bisiesto")
else:
print("No es un año bisiesto")
b) Bucle for:
El bucle for se utiliza para iterar sobre una secuencia (como una lista, tupla, diccionario,
conjunto o cadena) o cualquier objeto iterable.
Estructura básica:
for elemento in secuencia:

# código a ejecutar para cada elemento
 Puede usarse con la función range() para repetir un número específico de veces.
 Puede anidarse dentro de otros bucles.
 Puede usarse con else para ejecutar código cuando el bucle termina normalmente.
Ejemplos sencillos:
1. Imprimir los números del 1 al 5:
for i in range(1, 6):

print(i)
2. Calcular la suma de los elementos de una lista:
numeros = [1, 2, 3, 4, 5]
suma = 0
for numero in numeros:
suma += numero
print(f"La suma es: {suma}")
Ejemplos complejos:
1. Generar una tabla de multiplicar:
for i in range(1, 11):

for j in range(1, 11):
print(f"{i} x {j} = {i*j}")
print("-" * 15) # Separador entre tablas
2. Encontrar números primos en un rango:
inicio = 2
fin = 50
for num in range(inicio, fin + 1):
es_primo = True
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
es_primo = False
break
if es_primo:
print(num, end=" ")
c) Bucle while:
El bucle while se utiliza para repetir un bloque de código mientras una condición sea
verdadera.
Estructura básica:
while condicion:
# código a ejecutar mientras la condición sea verdadera
 La condición se evalúa antes de cada iteración.

 Es necesario asegurarse de que la condición eventualmente se vuelva falsa para
evitar bucles infinitos.
 Puede usarse con else para ejecutar código cuando el bucle termina normalmente.
Ejemplos sencillos:
1. Cuenta regresiva:
contador = 5
while contador > 0:
print(contador)
contador -= 1
print("¡Despegue!")
2. Validación de entrada de usuario:
while True:
respuesta = input("¿Quieres continuar? (s/n): ")
if respuesta.lower() in ['s', 'n']:
break
print("Por favor, responde 's' o 'n'.")
print("Gracias por responder.")
Ejemplos complejos:
1. Juego de adivinar un número:
import random
numero_secreto = random.randint(1, 100)

intentos = 0
while True:
intento = int(input("Adivina el número (1-100): "))
intentos += 1
if intento < numero_secreto:

print("Demasiado bajo")
elif intento > numero_secreto:
print("Demasiado alto")
else:
print(f"¡Correcto! Lo adivinaste en {intentos} intentos.")
break
2. Calculadora simple con bucle:

while True:
print("\nCalculadora Simple")
print("1. Suma")
print("2. Resta")
print("3. Multiplicación")
print("4. División")
print("5. Salir")
opcion = input("Elige una opción (1-5): ")
if opcion == '5':
print("¡Hasta luego!")
break
if opcion in ['1', '2', '3', '4']:

num1 = float(input("Introduce el primer número: "))
num2 = float(input("Introduce el segundo número: "))
if opcion == '1':
print(f"Resultado: {num1 + num2}")
elif opcion == '2':
print(f"Resultado: {num1 - num2}")
elif opcion == '3':
print(f"Resultado: {num1 * num2}")
elif opcion == '4':
if num2 != 0:
print(f"Resultado: {num1 / num2}")
else:
print("Error: No se puede dividir por cero")
else:
print("Opción no válida. Por favor, elige una opción del 1 al 5.")

1. Crear un programa que solicite al usuario su edad y determine en qué etapa de la

vida se encuentra (niño, adolescente, adulto joven, adulto, adulto mayor).
2. Implementar un juego de adivinanza donde el programa elige un número aleatorio
entre 1 y 100, y el usuario tiene que adivinarlo. El programa debe dar pistas si el
número es mayor o menor.
3. Crear una calculadora simple que permita al usuario elegir entre suma, resta,
multiplicación y división, y luego realizar la operación con dos números ingresados
por el usuario.
4. Escribir un programa que imprima los primeros 10 números de la secuencia de
Fibonacci.
3. Estructuras de datos (2 horas)
3.1 Listas
Las listas son colecciones ordenadas y mutables de elementos. Pueden contener elementos
de diferentes tipos.
 Se definen con corchetes []

 Son mutables (se pueden modificar después de crearse)
 Mantienen el orden de los elementos
 Permiten elementos duplicados
 Pueden contener diferentes tipos de datos
Ejemplos básicos:
# Crear una lista

frutas = ["manzana", "banana", "cereza"]
# Acceder a elementos
print(frutas[0]) # Imprime: manzana
print(frutas[-1]) # Imprime: cereza (último elemento)
# Modificar elementos
frutas[1] = "pera"
print(frutas) # Imprime: ['manzana', 'pera', 'cereza']
# Añadir elementos
frutas.append("uva")
print(frutas) # Imprime: ['manzana', 'pera', 'cereza', 'uva']
# Longitud de la lista
print(len(frutas)) # Imprime: 4
# Eliminar elementos
del frutas[2]
print(frutas) # Imprime: ['manzana', 'pera', 'uva']
Métodos útiles de listas:
numeros = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
# Ordenar la lista
numeros.sort()
print(numeros) # Imprime: [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
# Invertir la lista
numeros.reverse()
# Contar ocurrencias
print(numeros.count(5)) # Imprime: 2
# Encontrar índice
print(numeros.index(4)) # Imprime: 4
# Insertar elemento en posición específica

numeros.insert(0, 10)
print(numeros) # Imprime: [10, 9, 6, 5, 5, 4, 3, 3, 2, 1, 1]
# Remover primer ocurrencia de un elemento

numeros.remove(5)
Ejemplo avanzado - Lista de compras:
# Lista de compras con cantidad y precio

compras = [
["manzanas", 5, 0.5],
["pan", 2, 1.2],
["leche", 1, 2.5],
["queso", 1, 4.0]
]
# Calcular el total de la compra
total = 0
for item in compras:
total += item[1] * item[2]
print(f"El total de la compra es: ${total:.2f}")

# Añadir un nuevo item
compras.append(["huevos", 12, 0.2])
# Mostrar la lista de compras

print("\nLista de compras:")
for item in compras:
print(f"{item[0]}: {item[1]} x ${item[2]} = ${item[1] * item[2]:.2f}")
3.2 Tuplas
Las tuplas son colecciones ordenadas e inmutables de elementos.
 Se definen con paréntesis ()

 Son inmutables (no se pueden modificar después de crearse)
 Mantienen el orden de los elementos
 Pueden contener elementos duplicados
 Pueden contener diferentes tipos de datos
Ejemplos básicos:
# Crear una tupla

coordenadas = (10, 20)
# Acceder a elementos
print(coordenadas[0]) # Imprime: 10
# Intentar modificar una tupla (generará un error)

# coordenadas[0] = 15 # Esto causaría un TypeError
# Tupla con diferentes tipos de datos

persona = ("Juan", 30, "Madrid")
# Desempaquetar una tupla

nombre, edad, ciudad = persona
print(f"{nombre} tiene {edad} años y vive en {ciudad}")
# Longitud de la tupla
print(len(persona)) # Imprime: 3
Métodos útiles de tuplas:
numeros = (3, 1, 4, 1, 5, 9, 2, 6, 5, 3)
# Contar ocurrencias
print(numeros.count(5)) # Imprime: 2
# Encontrar índice
print(numeros.index(4)) # Imprime: 2
# Convertir tupla a lista

lista_numeros = list(numeros)
lista_numeros.append(7)
print(lista_numeros) # Imprime: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 7]
# Convertir lista a tupla

nueva_tupla = tuple(lista_numeros)
print(nueva_tupla) # Imprime: (3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 7)
Ejemplo avanzado - Registro de temperaturas:
# Registro de temperaturas diarias (máx, mín) para una semana
temperaturas = (
(28, 19), # Lunes
(30, 20), # Martes
(29, 21), # Miércoles
(27, 18), # Jueves
(31, 22), # Viernes
(32, 23), # Sábado
(29, 20) # Domingo
)
# Calcular promedio de temperaturas máximas y mínimas

max_total = sum(dia[0] for dia in temperaturas)
min_total = sum(dia[1] for dia in temperaturas)
promedio_max = max_total / len(temperaturas)
promedio_min = min_total / len(temperaturas)
print(f"Promedio de temperaturas máximas: {promedio_max:.1f}°C")

print(f"Promedio de temperaturas mínimas: {promedio_min:.1f}°C")
# Encontrar el día más caluroso y más frío

dia_mas_caluroso = max(temperaturas, key=lambda x: x[0])
dia_mas_frio = min(temperaturas, key=lambda x: x[1])
print(f"Día más caluroso: {temperaturas.index(dia_mas_caluroso) + 1} con

{dia_mas_caluroso[0]}°C")
print(f"Día más frío: {temperaturas.index(dia_mas_frio) + 1} con {dia_mas_frio[1]}°C")
3.3 Diccionarios
Los diccionarios son colecciones no ordenadas de pares clave-valor. Son extremadamente

útiles para almacenar y recuperar datos de manera eficiente.
 Se definen con llaves {}
 Cada elemento es un par clave-valor
 Las claves deben ser únicas e inmutables (típicamente strings o números)
 Los valores pueden ser de cualquier tipo y mutables
 No mantienen un orden específico (aunque en versiones recientes de Python,
mantienen el orden de inserción)
Ejemplos básicos:
# Crear un diccionario
persona = {
"nombre": "Ana",
"edad": 28,
"ciudad": "Barcelona"
}
# Acceder a valores
print(persona["nombre"]) # Imprime: Ana
# Modificar valores
persona["edad"] = 29
print(persona) # Imprime: {'nombre': 'Ana', 'edad': 29, 'ciudad': 'Barcelona'}
# Añadir nuevo par clave-valor

persona["profesion"] = "Ingeniera"
print(persona) # Imprime: {'nombre': 'Ana', 'edad': 29, 'ciudad': 'Barcelona',
'profesion': 'Ingeniera'}
# Eliminar un par clave-valor

del persona["ciudad"]
print(persona) # Imprime: {'nombre': 'Ana', 'edad': 29, 'profesion': 'Ingeniera'}
# Verificar si una clave existe

if "nombre" in persona:
print("La clave 'nombre' existe en el diccionario")
# Obtener todas las claves y valores
print(persona.keys()) # Imprime: dict_keys(['nombre', 'edad', 'profesion'])
print(persona.values()) # Imprime: dict_values(['Ana', 29, 'Ingeniera'])
print(persona.items()) # Imprime: dict_items([('nombre', 'Ana'), ('edad', 29),
('profesion', 'Ingeniera')])
Métodos útiles de diccionarios:
# Método get() para obtener un valor con un valor predeterminado si la clave no existe
print(persona.get("altura", "No especificada")) # Imprime: No especificada
# Método setdefault() para establecer un valor predeterminado si la clave no existe

persona.setdefault("pais", "España")
print(persona) # Imprime: {'nombre': 'Ana', 'edad': 29, 'profesion': 'Ingeniera', 'pais':
'España'}
# Método update() para actualizar el diccionario con otro diccionario

persona.update({"estado_civil": "Soltera", "edad": 30})
print(persona) # Imprime: {'nombre': 'Ana', 'edad': 30, 'profesion': 'Ingeniera', 'pais':
'España', 'estado_civil': 'Soltera'}
# Método pop() para eliminar y devolver un valor

profesion = persona.pop("profesion")
print(f"Profesión eliminada: {profesion}")
print(persona) # El diccionario ya no contiene 'profesion'
Ejemplo avanzado - Gestión de inventario:
inventario = {
"manzanas": {"cantidad": 50, "precio": 0.5},
"plátanos": {"cantidad": 30, "precio": 0.75},
"naranjas": {"cantidad": 40, "precio": 0.6}
}
def mostrar_inventario():
print("\nInventario actual:")
for producto, info in inventario.items():
print(f"{producto}: {info['cantidad']} unidades, Precio: ${info['precio']:.2f}")
def agregar_producto(nombre, cantidad, precio):

if nombre in inventario:
inventario[nombre]["cantidad"] += cantidad
else:
inventario[nombre] = {"cantidad": cantidad, "precio": precio}
print(f"\nProducto '{nombre}' agregado/actualizado en el inventario.")
def vender_producto(nombre, cantidad):

if nombre in inventario:
if inventario[nombre]["cantidad"] >= cantidad:
inventario[nombre]["cantidad"] -= cantidad
total = cantidad * inventario[nombre]["precio"]
print(f"\nVenta realizada: {cantidad} {nombre}(s) por ${total:.2f}")
else:
print(f"\nNo hay suficiente stock de {nombre}")
else:
print(f"\nEl producto {nombre} no existe en el inventario")
# Uso del sistema de inventario

mostrar_inventario()
agregar_producto("peras", 25, 0.8)
vender_producto("manzanas", 10)
mostrar_inventario()
3.4 Conjuntos
Los conjuntos son colecciones no ordenadas de elementos únicos.
 Se definen con llaves {} o la función set()

 No mantienen un orden específico
 No permiten elementos duplicados
 Los elementos deben ser inmutables (números, strings, tuplas)
 Son mutables (se pueden modificar después de crearse)
Ejemplos básicos:
# Crear un conjunto
frutas = {"manzana", "banana", "cereza"}
# Añadir elementos
frutas.add("naranja")
print(frutas) # Imprime un conjunto con los elementos en orden aleatorio
# Intentar añadir un elemento duplicado (no tendrá efecto)

frutas.add("manzana")
print(frutas) # El conjunto no cambia
# Eliminar un elemento
frutas.remove("banana")
print(frutas)
# Verificar si un elemento está en el conjunto

if "cereza" in frutas:
print("Hay cerezas en el conjunto")
# Longitud del conjunto

print(len(frutas))
Operaciones con conjuntos:
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# Unión
print(set1 | set2) # o set1.union(set2)
# Intersección
print(set1 & set2) # o set1.intersection(set2)
# Diferencia
print(set1 - set2) # o set1.difference(set2)
# Diferencia simétrica (elementos en cualquiera de los conjuntos, pero no en ambos)

print(set1 ^ set2) # o set1.symmetric_difference(set2)
# Subconjunto
set3 = {1, 2}
print(set3.issubset(set1)) # True
# Superconjunto
print(set1.issuperset(set3)) # True
Ejemplo avanzado - Análisis de texto:

def analizar_texto(texto):
# Convertir el texto a minúsculas y dividirlo en palabras
palabras = texto.lower().split()
# Crear un conjunto de palabras únicas

palabras_unicas = set(palabras)
# Contar la frecuencia de cada palabra

frecuencia = {palabra: palabras.count(palabra) for palabra in palabras_unicas}
# Encontrar las palabras más comunes

palabras_comunes = sorted(frecuencia, key=frecuencia.get, reverse=True)[:5]
print(f"Número total de palabras: {len(palabras)}")

print(f"Número de palabras únicas: {len(palabras_unicas)}")
print("Palabras más comunes:")
for palabra in palabras_comunes:
print(f" {palabra}: {frecuencia[palabra]} veces")
# Texto de ejemplo
texto_ejemplo = """
Python es un lenguaje de programación versátil y poderoso.
Python se utiliza en una variedad de aplicaciones, desde desarrollo web hasta
análisis de datos y aprendizaje automático. Muchos programadores eligen Python
por su sintaxis clara y legible.
"""
analizar_texto(texto_ejemplo)
Este ejemplo utiliza un conjunto para identificar palabras únicas y un diccionario para
contar la frecuencia de cada palabra, demostrando cómo diferentes estructuras de datos
pueden trabajar juntas en aplicaciones más complejas.
4. Funciones (2 horas)
Las funciones son bloques de código reutilizables que realizan una tarea específica.
Permiten organizar el código, evitar la repetición y hacer el programa más modular y fácil
de mantener.
4.1 Definición y llamada de funciones
Estructura básica:
def nombre_funcion(parametro1, parametro2, ...):

# Cuerpo de la función
# Código que realiza la tarea
return resultado # Opcional
Ejemplos básicos:
# Función simple sin parámetros

def saludar():
print("¡Hola, mundo!")
saludar() # Llamada a la función
# Función con parámetros

def suma(a, b):
return a + b
resultado = suma(5, 3)
print(resultado) # Imprime: 8
# Función con valor de retorno múltiple

def divmod(a, b):
cociente = a // b
resto = a % b
return cociente, resto
c, r = divmod(20, 3)
print(f"Cociente: {c}, Resto: {r}") # Imprime: Cociente: 6, Resto: 2
Funciones Integradas de Python

Función Definición Ejemplo
Devuelve la longitud de
len() len([1, 2, 3]) # Resultado: 3
un objeto
Devuelve el tipo de un
type() type(5) # Resultado: <class 'int'>
objeto
int() Convierte a entero int("10") # Resultado: 10
float() Convierte a float float("3.14") # Resultado: 3.14
str() Convierte a string str(123) # Resultado: "123"
list() Crea una lista list("abc") # Resultado: ['a', 'b', 'c']
dict(a=1, b=2) # Resultado: {'a': 1, 'b':
dict() Crea un diccionario 2}
set() Crea un conjunto set([1, 2, 2, 3]) # Resultado: {1, 2, 3}
max() Devuelve el máximo max(5, 10, 3) # Resultado: 10
min() Devuelve el mínimo min([1, 2, 3]) # Resultado: 1
sum() Suma elementos sum([1, 2, 3]) # Resultado: 6
Genera secuencia de
range() list(range(3)) # Resultado: [0, 1, 2]
números
input() Lee entrada del usuario nombre = input("Tu nombre: ")
open() Abre un archivo f = open("archivo.txt", "r")
sorted() Ordena un iterable sorted([3, 1, 2]) # Resultado: [1, 2, 3]
abs() Valor absoluto abs(-5) # Resultado: 5
round() Redondea un número round(3.14159, 2) # Resultado: 3.14
list(zip([1, 2], ['a', 'b'])) # [(1,
zip() Combina iterables 'a'), (2, 'b')]
list(enumerate(['a', 'b'])) # [(0, 'a'),
enumerate() Enumera un iterable (1, 'b')]
Verifica si todos son
all() all([True, 1, "a"]) # Resultado: True
verdaderos
Verifica si alguno es
any() any([False, 0, ""]) # Resultado: False
verdadero
4.2 Argumentos y parámetros
Python ofrece varias formas de pasar argumentos a las funciones:
a) Argumentos posicionales:
def describir_persona(nombre, edad):

print(f"{nombre} tiene {edad} años.")
describir_persona("Ana", 28)
Explicación de los argumentos posicionales:
1. Definición: Los argumentos posicionales son valores que se pasan a una función en
un orden específico. Su posición en la llamada a la función determina a qué
parámetro corresponden en la definición de la función.
2. Características principales:
o Orden: El orden en que se pasan los argumentos es crucial. El primer
argumento corresponde al primer parámetro, el segundo al segundo, y así
sucesivamente.
o Correspondencia uno a uno: Debe haber una correspondencia exacta entre
el número de argumentos posicionales y el número de parámetros (a menos
que se usen parámetros opcionales o *args).
o Sin nombres: A diferencia de los argumentos con palabra clave, no se
especifican los nombres de los parámetros al llamar a la función.
3. Uso en el código:
o En la definición de la función, los parámetros se listan en un orden
específico.
o Al llamar a la función, los argumentos se pasan en el mismo orden.
4. *Flexibilidad con args:
o Python permite usar *args para aceptar un número variable de argumentos
posicionales.
o Estos argumentos se empaquetan en una tupla dentro de la función.
5. Consideraciones:
o Legibilidad: Con muchos argumentos, puede ser difícil recordar el orden
correcto. En estos casos, los argumentos con palabra clave pueden ser más
claros.
o Mantenibilidad: Si cambias el orden de los parámetros en la definición de
la función, todas las llamadas a esa función deben ser revisadas y
posiblemente actualizadas.
6. Buenas prácticas:
o Usa argumentos posicionales para parámetros que tienen un orden natural o
cuando son pocos y su uso es claro.
o Considera usar argumentos con palabra clave para funciones con muchos
parámetros o cuando el orden no es intuitivo.
o Documenta claramente el orden y propósito de los argumentos posicionales
en la documentación de la función.
Los argumentos posicionales son una parte fundamental de las funciones en Python,
ofreciendo una forma sencilla y directa de pasar información a las funciones. Sin embargo,
es importante usarlos juiciosamente, especialmente en funciones complejas donde los
argumentos con palabra clave pueden ofrecer mayor claridad.
b) Argumentos con palabras clave (keyword arguments):
describir_persona(edad=28, nombre="Ana")
Explicación de los argumentos con palabras clave:
1. Definición: Los argumentos con palabras clave son valores que se pasan a una
función especificando el nombre del parámetro al que corresponden.
o Nombre explícito: Se especifica el nombre del parámetro seguido de un
signo igual y el valor.
o Orden flexible: El orden en que se pasan estos argumentos no importa.
o Claridad: Hacen el código más legible, especialmente cuando la función
tiene muchos parámetros.
o Valores por defecto: A menudo se usan en combinación con valores por
defecto en la definición de la función.
3. Uso en el código:
o En la llamada a la función, se especifica nombre_parametro=valor.
o En la definición de la función, se pueden establecer valores por defecto: def
funcion(parametro=valor_por_defecto).
4. **Flexibilidad con kwargs:
o Python permite usar **kwargs para aceptar un número arbitrario de
argumentos con palabras clave.
o Estos argumentos se empaquetan en un diccionario dentro de la función.
5. Ventajas:
o Legibilidad: Hace que las llamadas a funciones sean más claras,
especialmente con muchos argumentos.
oFlexibilidad: Permite omitir argumentos opcionales o pasarlos en cualquier

orden.
o Mantenibilidad: Facilita añadir nuevos parámetros opcionales sin romper el
código existente.
6. Consideraciones:
o Compatibilidad: Al modificar funciones, es más fácil añadir nuevos
parámetros con valores por defecto sin afectar el código existente.
o Sobrecarga de sintaxis: Para funciones simples con pocos argumentos, los
argumentos posicionales pueden ser más concisos.
o Usa argumentos con palabras clave para parámetros opcionales o cuando
hay muchos parámetros.
o Proporciona valores por defecto significativos cuando sea posible.
o Documenta claramente el propósito y los valores esperados de cada
parámetro.
Los argumentos con palabras clave ofrecen una gran flexibilidad y claridad en la
programación Python. Son especialmente útiles en funciones complejas o cuando quieres
hacer que ciertos argumentos sean opcionales. Combinados con argumentos posicionales,
proporcionan un sistema poderoso y flexible para diseñar interfaces de funciones.
c) Argumentos por defecto:
def saludar(nombre="Invitado"):
print(f"Hola, {nombre}!")
saludar() # Imprime: Hola, Invitado!

saludar("María") # Imprime: Hola, María!
d) Número variable de argumentos (*args y **kwargs):
def suma_total(*args):
return sum(args)
print(suma_total(1, 2, 3, 4, 5)) # Imprime: 15
def info_persona(**kwargs):
for clave, valor in kwargs.items():
print(f"{clave}: {valor}")
info_persona(nombre="Juan", edad=30, ciudad="Madrid")

Explicación de *args y **kwargs:
1. *args (Argumentos Posicionales Variables):

o Definición: Permite a una función aceptar cualquier número de argumentos
posicionales.
o Características:
 Los argumentos se empaquetan en una tupla dentro de la función.
 Se usa el asterisco * seguido de un nombre (convencionalmente
args).
 Puede capturar cero o más argumentos.
o Uso en el código:
 En la definición de la función: def funcion(*args):
 Dentro de la función, args se trata como una tupla.
2. **kwargs (Argumentos de Palabras Clave Variables):
o Definición: Permite a una función aceptar cualquier número de argumentos
de palabras clave.
o Características:
 Los argumentos se empaquetan en un diccionario dentro de la
función.
 Se usan dos asteriscos ** seguidos de un nombre
(convencionalmente kwargs).
 Cada argumento debe tener un nombre (clave).
o Uso en el código:
 En la definición de la función: def funcion(**kwargs):
 Dentro de la función, kwargs se trata como un diccionario.
3. Características comunes:
o Flexibilidad: Permiten crear funciones que pueden manejar un número
desconocido de argumentos.
o Extensibilidad: Facilitan la creación de funciones que pueden ser
extendidas en el futuro sin romper el código existente.
4. Usos típicos:
o *args: Cuando no sabes cuántos argumentos posicionales se pasarán a la
función.
o **kwargs: Cuando quieres permitir argumentos de palabras clave arbitrarios
o pasar diccionarios de opciones.
5. Consideraciones:
o Orden: Si se usan juntos, *args debe venir antes de **kwargs.
oLegibilidad: Aunque son poderosos, pueden hacer que el propósito de una

función sea menos claro si se abusa de ellos.
o Validación: Es importante validar los argumentos recibidos, ya que la
función no sabe de antemano qué recibirá.
o Usa nombres descriptivos: aunque args y kwargs son convencionales,
puedes usar nombres más descriptivos si es apropiado.
o Documenta claramente qué tipo de argumentos espera la función y cómo los
utilizará.
o Considera usar argumentos posicionales o de palabras clave normales para
los parámetros más comunes, y *args/**kwargs para extensibilidad
adicional.
*args y **kwargs son herramientas poderosas en Python que proporcionan gran

flexibilidad en el diseño de funciones. Permiten crear interfaces de función muy versátiles y
adaptables, pero deben usarse con criterio para mantener la claridad y la facilidad de uso de
tu código.
4.3 Retorno de valores
Las funciones pueden retornar valores usando la palabra clave return. Si no se especifica
un valor de retorno, la función retorna None por defecto.
def es_par(numero):
return numero % 2 == 0
print(es_par(4)) # Imprime: True

print(es_par(7)) # Imprime: False
4.4 Funciones lambda
Las funciones lambda en programación, también conocidas como funciones anónimas, son
una característica importante en muchos lenguajes, incluyendo Python. Aquí te explico de
qué se tratan y sus características principales:
1. Definición: Una función lambda es una pequeña función anónima que puede tener
cualquier número de argumentos, pero solo puede tener una expresión.
 Son anónimas: No tienen un nombre definido como las funciones regulares.

 Son de una sola línea: Solo pueden contener una expresión.
 Son funciones de corta duración: Generalmente se usan para operaciones simples y
rápidas.
 Son funciones de primer orden: Pueden ser pasadas como argumentos a otras
funciones.
3. Sintaxis básica (en Python):
lambda argumentos: expresión
Ejemplo simple:
# Función lambda que suma dos números

suma = lambda a, b: a + b
resultado = suma(5, 3)
print(resultado) # Imprime: 8
5. Usos comunes:
o En funciones como map(), filter(), y reduce().
o Para definir funciones simples en línea.
o En ordenamiento personalizado (como key en sort() o sorted()).
6. Limitaciones:
o No pueden contener múltiples expresiones o declaraciones complejas.
o No son ideales para funciones complejas o largas.
Las funciones lambda son útiles para escribir código conciso y funcional, especialmente
cuando se necesita una función simple para una operación rápida.
Las funciones lambda son funciones anónimas de una sola expresión.
cuadrado = lambda x: x ** 2
print(cuadrado(5)) # Imprime: 25
# Uso de lambda con funciones de orden superior

numeros = [1, 2, 3, 4, 5]
pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares) # Imprime: [2, 4]
Ejemplo avanzado - Calculadora de funciones:
def calculadora(operacion):
if operacion == 'suma':
return lambda a, b: a + b
elif operacion == 'resta':
return lambda a, b: a - b
elif operacion == 'multiplicacion':
return lambda a, b: a * b
elif operacion == 'division':

return lambda a, b: a / b if b != 0 else "Error: División por cero"
else:
return lambda: "Operación no válida"
# Uso de la calculadora
suma = calculadora('suma')
resta = calculadora('resta')
multiplicacion = calculadora('multiplicacion')
division = calculadora('division')
print(suma(5, 3)) # Imprime: 8

print(resta(10, 4)) # Imprime: 6
print(multiplicacion(2, 6)) # Imprime: 12
print(division(15, 3)) # Imprime: 5.0
print(division(10, 0)) # Imprime: Error: División por cero
La función filter() en Python es una función incorporada que se utiliza para filtrar
elementos de una secuencia, como una lista, mediante la aplicación de una función de filtro.
La función filter() toma dos argumentos: la función de filtro y la secuencia que se desea
filtrar.
La sintaxis general de filter() es la siguiente:
filter(función, secuencia)
 La función de filtro (función) es una función que devuelve True o False para cada
elemento de la secuencia.
 La secuencia es la colección de elementos que se van a filtrar.
La función filter() aplica la función de filtro a cada elemento de la secuencia y devuelve un

iterador que contiene solo los elementos para los cuales la función de filtro devuelve True.
Por ejemplo, supongamos que queremos filtrar una lista de números para obtener solo los
números pares:
python
Copiar
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def es_par(numero):
return numero % 2 == 0
numeros_pares = list(filter(es_par, numeros))
print(numeros_pares) # Salida: [2, 4, 6, 8, 10]

En este ejemplo, la función es_par() se utiliza como la función de filtro en filter(), y se

aplica a la lista de números. La función filter() devuelve un iterador que contiene solo los
números pares de la lista original.
La función filter() es una herramienta poderosa para filtrar elementos de una secuencia de
manera eficiente en Python
La función list() en Python es una función incorporada que se utiliza para crear una lista a
partir de una secuencia iterable, como una tupla, un rango, un conjunto, una cadena u otro
objeto iterable. La función list() toma como argumento la secuencia iterable y devuelve una
nueva lista que contiene los elementos de la secuencia en el mismo orden.
La sintaxis general de list() es la siguiente:
list(secuencia)
 La secuencia es el objeto iterable del cual se desea crear la lista.
Por ejemplo, si tenemos una tupla y queremos convertirla en una lista, podemos usar la
función list() de la siguiente manera:
función list() de la siguiente manera:
tupla = (1, 2, 3, 4, 5)
lista = list(tupla)
print(lista) # Salida: [1, 2, 3, 4, 5]

En este ejemplo, la función list() convierte la tupla (1, 2, 3, 4, 5) en una lista que contiene
los mismos elementos en el mismo orden.
La función list() es útil para convertir objetos iterables en listas, lo que puede facilitar el
manejo y la manipulación de datos en Python. Se puede utilizar en una variedad de
situaciones donde se requiere una lista a partir de una secuencia iterable.
4.5 Alcance de variables (Scope)
El alcance de una variable determina dónde es accesible en el código.
x = 10 # Variable global
def funcion():
y = 5 # Variable local
print(x) # Puede acceder a la variable global
print(y)
funcion()
print(x) # Imprime: 10
# print(y) # Esto causaría un error, y no es accesible fuera de la función
def modificar_global():
global x
x = 20
modificar_global()
print(x) # Imprime: 20
Ejemplo avanzado - Decoradores:
Los decoradores son funciones que modifican el comportamiento de otras funciones.
Los decoradores en Python son una forma de modificar o extender el comportamiento de

funciones o clases. Aquí te explico los conceptos clave:
1. Concepto básico:
o Un decorador es una función que toma otra función (o clase) como
argumento y devuelve una nueva función (o clase) con alguna funcionalidad
adicional.
2. Sintaxis:
o Se utilizan con el símbolo @ seguido del nombre del decorador, justo encima
de la definición de la función o clase que se quiere decorar.
3. Tipos de decoradores: a. Decoradores simples b. Decoradores con argumentos c.

Decoradores de clase
4. Funcionamiento:
o Cuando se aplica un decorador, la función o clase decorada se pasa como
argumento al decorador.
o El decorador devuelve una nueva función o clase que reemplaza a la
original.
5. Usos comunes:
o Logging (registro de eventos)
o Medición de tiempo de ejecución
o Verificación de autenticación
o Caching (almacenamiento en caché)
o Manejo de excepciones
def registrar_llamada(func):
def envoltorio(*args, **kwargs):
print(f"Llamando a la función: {func.__name__}")
resultado = func(*args, **kwargs)
print(f"La función {func.__name__} ha terminado")
return resultado
return envoltorio
@registrar_llamada
def saludar(nombre):
print(f"Hola, {nombre}!")
saludar("Ana")
Este ejemplo muestra cómo un decorador puede ser usado para añadir funcionalidad (en
este caso, registrar la llamada) a una función existente sin modificar su código.
1. Crear una función que calcule el factorial de un número usando recursión.

2. Implementar una función que tome una lista de números y retorne una nueva lista
con solo los números pares.
3. Escribir un decorador que mida el tiempo de ejecución de una función.
4. Crear una función que acepte un número variable de argumentos y retorne el
promedio de todos ellos.
5. Manejo de excepciones (1 hora)
El manejo de excepciones es una parte crucial de la programación en Python, ya que

permite manejar errores y situaciones inesperadas de manera elegante y controlada.
5.1 Try, except, else, finally
La estructura básica para el manejo de excepciones en Python es:
try:
# Código que puede generar una excepción
except TipoDeExcepcion:
# Código para manejar la excepción
else:
# Código que se ejecuta si no hay excepciones
finally:
# Código que se ejecuta siempre, haya o no excepciones
Ejemplo básico:
try:
numero = int(input("Introduce un número: "))
resultado = 10 / numero
except ValueError:
print("Error: Debes introducir un número válido.")
except ZeroDivisionError:
print("Error: No se puede dividir por cero.")
else:
print(f"El resultado es: {resultado}")
finally:
print("Operación finalizada.")
5.2 Tipos comunes de excepciones
Python tiene muchos tipos de excepciones predefinidas. Algunos de los más comunes son:
 ValueError: Cuando una función recibe un argumento del tipo correcto pero con
un valor inapropiado.
 TypeError: Cuando se realiza una operación en un objeto de tipo inapropiado.
 ZeroDivisionError: Cuando se intenta dividir por cero.
 FileNotFoundError: Cuando se intenta acceder a un archivo que no existe.
 IndexError: Cuando se intenta acceder a un índice que está fuera del rango de una
secuencia.
 KeyError: Cuando se intenta acceder a una clave que no existe en un diccionario.
Ejemplo con múltiples excepciones:
def dividir_lista(lista, indice, divisor):

try:
resultado = lista[indice] / divisor
return resultado
except IndexError:
print(f"Error: El índice {indice} está fuera del rango de la lista.")
except TypeError:
print("Error: No se puede dividir el elemento por el divisor dado.")
except ZeroDivisionError:
print("Error: No se puede dividir por cero.")
numeros = [10, 20, 30, 40, 50]

print(dividir_lista(numeros, 2, 2)) # Funciona correctamente
dividir_lista(numeros, 10, 2) # IndexError
dividir_lista(numeros, 0, 0) # ZeroDivisionError
dividir_lista(numeros, 1, "2") # TypeError
5.3 Lanzar excepciones
Puedes lanzar excepciones manualmente usando la palabra clave raise.
def verificar_edad(edad):
if edad < 0:
raise ValueError("La edad no puede ser negativa")
if edad > 120:
raise ValueError("La edad es demasiado alta")
print(f"La edad {edad} es válida")
try:
verificar_edad(150)
except ValueError as e:
print(f"Error: {e}")
La palabra clave raise en Python, que se utiliza para lanzar excepciones. Las excepciones
son eventos que ocurren durante la ejecución de un programa que interrumpen el flujo
normal de las instrucciones.
Conceptos clave sobre el uso de raise para lanzar excepciones en Python:
1. Propósito:
o raise se utiliza para lanzar (o "levantar") una excepción de forma explícita.
o Permite al programador indicar que ha ocurrido una situación excepcional o
un error.
2. Sintaxis básica:
raise ExcepcionTipo("Mensaje de error")

3. Usos comunes:
 Indicar errores en la lógica del programa.

 Manejar casos inesperados o inválidos.
 Forzar que ciertas condiciones se cumpla
4. Tipos de excepciones:
o Python tiene muchas excepciones incorporadas (ValueError, TypeError, etc.).

o También puedes crear tus propias excepciones personalizadas.
5. Características importantes:
o Puedes lanzar excepciones existentes o crear las tuyas propias.

o El mensaje de la excepción puede ser personalizado.
o Las excepciones pueden ser capturadas y manejadas con bloques
try/except.
o Usa excepciones específicas en lugar de genéricas cuando sea posible.

o Proporciona mensajes de error claros y útiles.
o Considera crear excepciones personalizadas para errores específicos de tu
aplicación.
En el artefacto de código que he creado, puedes ver ejemplos prácticos de cómo usar raise
en diferentes situaciones, incluyendo:
 Lanzar excepciones incorporadas de Python.

 Crear y lanzar excepciones personalizadas.
 Relanzar excepciones.
 Usar assert, que internamente utiliza raise.
El uso de excepciones y raise es fundamental para el manejo de errores en Python y ayuda

a crear programas más robustos y fáciles de depurar.
5.4 Creación de excepciones personalizadas
Puedes crear tus propias clases de excepción heredando de la clase base Exception.
class ErrorDeBalanceInsuficiente(Exception):
def __init__(self, balance, cantidad):
self.balance = balance
self.cantidad = cantidad
self.mensaje = f"Balance insuficiente. Tienes {balance}, pero intentas retirar
{cantidad}"
super().__init__(self.mensaje)
class CuentaBancaria:
def __init__(self, balance_inicial):
self.balance = balance_inicial
def retirar(self, cantidad):

if self.balance < cantidad:
raise ErrorDeBalanceInsuficiente(self.balance, cantidad)
self.balance -= cantidad
return self.balance
cuenta = CuentaBancaria(100)
try:
cuenta.retirar(150)
except ErrorDeBalanceInsuficiente as e:
print(f"Error en la transacción: {e}")
5.5 Uso de context managers (with)
Los context managers son útiles para manejar recursos que necesitan ser liberados o
cerrados después de su uso, como archivos o conexiones de red.
def leer_archivo(nombre_archivo):
try:
with open(nombre_archivo, 'r') as archivo:
contenido = archivo.read()
print(contenido)
except FileNotFoundError:
print(f"El archivo {nombre_archivo} no se encontró.")
except PermissionError:
print(f"No tienes permiso para leer el archivo {nombre_archivo}.")
leer_archivo("archivo_existente.txt")
leer_archivo("archivo_no_existente.txt")
Lista de Tipos de Excepción
Los tipos de excepciones en Python, incluyendo las que se muestran en el ejemplo y

algunas adicionales:
1. Excepciones básicas:
o Exception: La clase base para todas las excepciones incorporadas.
o ArithmeticError: Base para errores aritméticos.
o BufferError: Relacionado con operaciones de buffer.
o LookupError: Base para errores de búsqueda.
2. Excepciones de error operativo:
o TypeError: Operación aplicada a un objeto de tipo inapropiado.
o ValueError: Operación con un argumento de tipo correcto pero valor
inapropiado.
o NameError: Se usa una variable no definida.
o IndexError: Índice de secuencia fuera de rango.
o KeyError: Clave no encontrada en un diccionario.
o ZeroDivisionError: División o módulo por cero.
3. Excepciones de manejo de archivos y E/S:
o FileNotFoundError: Intento de abrir un archivo no existente.
o IOError: Error de entrada/salida general.
o PermissionError: Operaciones sin permisos suficientes.
4. Excepciones de importación:
o ImportError: Error al importar un módulo.
o ModuleNotFoundError: Módulo no encontrado (subclase de ImportError).
5. Excepciones de sintaxis y compilación:
o SyntaxError: Error de sintaxis en el código.
o IndentationError: Indentación incorrecta.
6. Excepciones de sistema y ambiente:
o EnvironmentError: Error relacionado con el entorno.
o OSError: Error relacionado con el sistema operativo.
7. Excepciones de ejecución:
o RuntimeError: Error genérico durante la ejecución.
o NotImplementedError: Método o función no implementada.
8. Otras excepciones comunes:
o AttributeError: Atributo de objeto no existente.
o MemoryError: Operación sin suficiente memoria.
o OverflowError: Resultado demasiado grande para ser representado.
o RecursionError: Profundidad máxima de recursión excedida.
9. Excepciones de advertencia:
o Warning: Clase base para advertencias.
o DeprecationWarning: Sobre características obsoletas.
Esta lista no es exhaustiva, pero cubre las excepciones más comúnmente utilizadas en
Python. Es importante notar que algunas de estas excepciones son subclases de otras (por
ejemplo, FileNotFoundError es una subclase de IOError).
Conocer estos tipos de excepciones te ayudará a manejar errores de manera más específica
en tu código, permitiéndote crear programas más robustos y fáciles de depurar. También te
permitirá usar raise de manera más precisa cuando necesites lanzar excepciones
específicas en tu propio código.
1. Crear un programa que solicite al usuario dos números y realice la división entre
ellos, manejando las posibles excepciones (división por cero, entrada no numérica).
2. Implementar una función que lea un archivo CSV y maneje las excepciones que
puedan ocurrir (archivo no encontrado, formato incorrecto).
3. Crear una excepción personalizada para validar una dirección de correo electrónico
y usarla en una función que verifique direcciones de correo.
4. Escribir un context manager personalizado que mida el tiempo de ejecución de un
bloque de código.

Curso de Python Sesion 1

Cargado por

Copyright:

Formatos disponibles

Curso de Python Sesion 1

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso de Python Sesion 1

Cargado por

Copyright:

Formatos disponibles

Curso de básico de Python.

Prof. Ing. Jesús R. Romero Manzanilla

1. Introducción a Python (1 hora)

Desarrollo del contenido.

1. Introducción a Python (1 hora)

Contenido teórico detallado:

1.1 ¿Qué es Python? Python es un lenguaje de programación de alto nivel, interpretado y de

 Sintaxis clara y legible: Utiliza indentación para definir bloques de código.

 Desarrollo web (Django, Flask)

1.2 Instalación y configuración del entorno de desarrollo

Pasos para instalar Python:

Instalación de un IDE (Entorno de Desarrollo Integrado):

 Visual Studio Code (alternativa ligera):

# Este es un comentario. El intérprete de Python lo ignorará.

# La función print() muestra texto en la consola

# Podemos usar variables para almacenar valores

# Podemos solicitar entrada del usuario

 La función print() se usa para mostrar texto en la consola.

Tarea para los participantes:

1. Instalar Python y un IDE (VS Code).

4. Experimentar con diferentes tipos de print: múltiples argumentos, f-strings,

2. Fundamentos de Python (2 horas)

2.1 Variables y tipos de datos

Tipos de datos básicos:

b) Números de punto flotante (float):

c) Cadenas de texto (str):

e) Valor nulo (None):

# Demostración de tipos de datos

print(f"Tipo de edad: {type(edad)}")

# Conversión entre tipos

print(f"Edad como string: {edad_str}, tipo: {type(edad_str)}")

and_logico = True and False # False

2.3 Estructuras de control

a) Condicionales (if, else, elif):

La estructura if-elif-else permite ejecutar diferentes bloques de código basados en

 Puedes tener múltiples bloques elif.

1. Determinar si un número es positivo, negativo o cero:

numero = float(input("Introduce un número: "))

calificacion = int(input("Introduce la calificación (0-100): "))

Ejemplo complejo: Determinar si un año es bisiesto:

año = int(input("Introduce un año: "))

for elemento in secuencia:

1. Imprimir los números del 1 al 5:

for i in range(1, 6):

2. Calcular la suma de los elementos de una lista:

1. Generar una tabla de multiplicar:

for i in range(1, 11):

2. Encontrar números primos en un rango:

 La condición se evalúa antes de cada iteración.

2. Validación de entrada de usuario:

numero_secreto = random.randint(1, 100)

if intento < numero_secreto:

2. Calculadora simple con bucle:

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

if opcion in ['1', '2', '3', '4']:

Tarea para los participantes:

1. Crear un programa que solicite al usuario su edad y determine en qué etapa de la

3. Estructuras de datos (2 horas)

 Se definen con corchetes []