Curso de Python

Bienvenidos al curso de Python, donde aprenderemos los

fundamentos de este poderoso lenguaje de programación.
Este curso está diseñado para proporcionar una base sólida
en Python, cubriendo desde los conceptos básicos hasta
temas más avanzados. A lo largo de una sesión intensiva de
8 horas, exploraremos diversos aspectos de Python que te
ayudarán a comenzar tu viaje en la programación.

by Jesus R Romero Manzanilla

Introducción a Python

1 ¿Qué es Python?
Python es un lenguaje de programación versátil y potente, conocido por su simplicidad y legibilidad. En esta
sección, exploraremos las características fundamentales de Python y por qué es tan popular entre los
desarrolladores.

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

Aprenderemos cómo instalar Python en tu sistema y configurar un entorno de desarrollo adecuado para comenzar
a programar. Esto incluirá la instalación de un editor de código o un entorno de desarrollo integrado (IDE).

3 Tu primer programa: "¿Qué vamos hacer hoy?" " Vamos a conquistar el Mundo!"
Escribiremos nuestro primer programa en Python, que mostrará el mensaje "¿Qué vamos hacer hoy?" " Vamos a
conquistar el Mundo!". Este ejercicio te introducirá a la sintaxis básica de Python y te dará una idea de cómo se
estructura un programa simple.
¿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)
Pasos para instalar Python:
1. Visitar [Link]
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 [Link]
2. Descargar e instalar
3. Instalar la extensión de Python desde el marketplace de VS Code
• Pylint
• Python autopep8
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.
Fundamentos de Python: Variables y
Operadores
Variables y tipos de datos Operadores

Exploraremos los diferentes tipos de datos en Estudiaremos los diversos operadores disponibles
Python, como enteros, flotantes, cadenas y en Python, incluyendo operadores aritméticos, de
booleanos. Aprenderemos cómo declarar variables comparación, lógicos y de asignación.
y asignarles valores, así como las convenciones de Aprenderemos cómo utilizarlos en expresiones y
nomenclatura en Python. cálculos.
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 d os
variable
te de
explícitamente. e t ra
n dos
Tipos de datos básicos: c ua t e en
n t as v i er
a) Enteros
edad =(int):25 én ju con
es t ol a
año_actual = 2024 e bi
e qu cam
numero_negativo = -10 i er s ier
qu e ro l qu
e re ( _) ú m cua
s
o, rscore con n
n c pues
l e s bla nde able able
b) Números de punto flotante
r i a b (float): en
s e l u
v a ri v a ri
s va pa cio usar una a da
l a s e c
altura o br=e 1.75 j a r e puede re d ta de
i ps s
e de se
no mb exac
Tpi = 3.14159
p ued bras o ar el rafia
o se pala inici ipog
• N mas uede r la t
c) Cadenas ode textos e p(str): u i da
N o
e b e c le
•
S e d variab
nombre• = ra
t
"Ana"
o
apellido = 'García'
frase = """Este es un texto
que ocupa varias líneas"""
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)}")
Métodos de formateo de strings en Python
# 1. [Link]()
# Permite insertar valores en una cadena usando llaves {}
print("Hola, {}".format("mundo")) # Output: Hola, mundo

# 2. f-strings
# Usa el prefijo 'f' antes de la cadena, permite insertar expresiones
dentro de {}
nombre = "Ana"
print(f"Hola, {nombre}") # Output: Hola, Ana

# 3. % operador
# Estilo más antiguo, usa %s, %d, etc. como marcadores
print("Hola, %s" % "mundo") # Output: Hola, mundo

# 4. [Link]()
# Convierte la cadena a mayúsculas
print("hola".upper()) # Output: HOLA

# 5. [Link]()
# Convierte la cadena a minúsculas
print("HOLA".lower()) # Output: hola

# 6. [Link]()
# Convierte el primer carácter a mayúscula
print("hola mundo".capitalize()) # Output: Hola mundo

# 7. [Link]()
# Convierte la primera letra de cada palabra a mayúscula
print("hola mundo".title()) # Output: Hola Mundo

# 8. [Link]()
# Elimina espacios en blanco al inicio y al final
print(" hola ".strip()) # Output: hola

# 9. [Link]()
# Reemplaza una subcadena por otra
print("hola mundo".replace("mundo", "Python")) # Output: hola Python

# 10. [Link]()
# Rellena la cadena con ceros a la izquierda
print("42".zfill(5)) # Output: 00042
 2.2 Operadores con Enteros (int)
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
Fundamentos de Python:
Estructuras de Control
Estructuras de control: if, else, elif
Aprenderemos a utilizar las estructuras de control
condicionales en Python. Esto incluye las declaraciones if, else
y elif, que nos permiten tomar decisiones en nuestros
programas basadas en condiciones específicas.

Bucles: for y while

Exploraremos los bucles en Python, específicamente los bucles
for y while. Aprenderemos cómo utilizarlos para repetir
acciones y procesar datos de manera eficiente en nuestros
programas.
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.
 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")
elif calificacion >= 70:
print("C")
elif calificacion >= 60:
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:
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

Características importantes:
 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
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

Características importantes:
 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 [Link]() in ['s', 'n']:
break
print("Por favor, responde 's' o 'n'.")
print("Gracias por responder.")
 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.")
Estructuras de Datos en Python

Listas Tuplas Diccionarios Conjuntos

Las listas son una de las Estudiaremos las tuplas, que Los diccionarios son Exploraremos los conjuntos en
estructuras de datos más son similares a las listas pero estructuras de datos clave- Python, que son colecciones
versátiles en Python. inmutables. Veremos cuándo y valor en Python. no ordenadas de elementos
Aprenderemos cómo crear, cómo usar tuplas en nuestros Aprenderemos cómo crear y únicos. Veremos cómo crear y
modificar y manipular listas, programas. manipular diccionarios, y cómo manipular conjuntos, y cómo
así como las operaciones pueden ser útiles en diferentes pueden ser útiles para ciertas
comunes que podemos situaciones de programación. operaciones.
realizar con ellas.
3. Estructuras de datos
3.1 Listas
Las listas son colecciones ordenadas y mutables de elementos. Pueden contener elementos de
diferentes tipos.

Características principales:

 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
[Link]("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
[Link]()
print(numeros) # Imprime: [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]

# Invertir la lista
[Link]()
print(numeros) # Imprime: [9, 6, 5, 5, 4, 3, 3, 2, 1, 1]

# Contar ocurrencias
print([Link](5)) # Imprime: 2

# Encontrar índice
print([Link](4)) # Imprime: 4

# Insertar elemento en posición específica

[Link](0, 10)
print(numeros) # Imprime: [10, 9, 6, 5, 5, 4, 3, 3, 2, 1, 1]

# Remover primer ocurrencia de un elemento

[Link](5)
print(numeros) # Imprime: [10, 9, 6, 5, 4, 3, 3, 2, 1, 1]
# 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
[Link](["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.
Características principales:
 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
# 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([Link](5)) # Imprime: 2

# Encontrar índice
print([Link](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)
3.3 Diccionarios
Los diccionarios son colecciones no ordenadas de pares clave-valor. Son extremadamente
útiles para almacenar y recuperar datos de manera eficiente.

Características principales:

 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)
# 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([Link]()) # Imprime: dict_keys(['nombre', 'edad',
'profesion'])
print([Link]()) # Imprime: dict_values(['Ana', 29, 'Ingeniera'])
print([Link]()) # 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([Link]("altura", "No especificada")) # Imprime: No
especificada

# Método setdefault() para establecer un valor predeterminado si la clave

no existe
[Link]("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

[Link]({"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 = [Link]("profesion")
print(f"Profesión eliminada: {profesion}")
print(persona) # El diccionario ya no contiene 'profesion'
3.4 Conjuntos
Los conjuntos son colecciones no ordenadas de elementos únicos.

Características principales:

 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)
# Crear un conjunto
frutas = {"manzana", "banana", "cereza"}

# Añadir elementos
[Link]("naranja")
print(frutas) # Imprime un conjunto con los elementos en orden aleatorio

# Intentar añadir un elemento duplicado (no tendrá efecto)

[Link]("manzana")
print(frutas) # El conjunto no cambia

# Eliminar un elemento
[Link]("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 [Link](set2)

# Intersección
print(set1 & set2) # o [Link](set2)

# Diferencia
print(set1 - set2) # o [Link](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([Link](set1)) # True

# Superconjunto
print([Link](set3)) # True
Funciones en Python
1 Definición y llamada de funciones
Aprenderemos cómo definir nuestras propias funciones en Python y cómo
llamarlas en nuestros programas. Esto nos permitirá organizar y reutilizar
nuestro código de manera más eficiente.

2 Argumentos y parámetros
Exploraremos cómo pasar información a nuestras funciones a través de
argumentos y parámetros. Aprenderemos sobre diferentes tipos de
parámetros y cómo utilizarlos efectivamente.

3 Retorno de valores
Veremos cómo las funciones pueden devolver valores y cómo podemos
utilizar estos valores retornados en nuestros programas.

4 Funciones lambda
Introduciremos el concepto de funciones lambda, que son funciones
anónimas y de una sola línea en Python. Aprenderemos cuándo y cómo usar
estas funciones compactas.
4. Funciones
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
4.2 Argumentos y parámetros

Python ofrece varias formas de pasar argumentos a las funciones:

a) Argumentos posicionales :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.

Estructura:
def describir_persona(nombre, edad):
print(f"{nombre} tiene {edad} años.")

describir_persona("Ana", 28)
b) Argumentos con palabras clave (keyword arguments): Los argumentos con palabras
clave son valores que se pasan a una función especificando el nombre del parámetro al que
corresponden.
Estructura:
def describir_persona(nombre, edad):
print(f"{nombre} tiene {edad} años.")

describir_persona(edad=28, nombre="Ana")
En la llamada a la función, se especifica parametro=valor.

c) Argumentos por defecto:

En la definición de la función, se pueden establecer valores por defecto:
def describir_persona(nombre, edad, ciudad="Desconocida",
profesion="No especificada"):
print(f"{nombre} tiene {edad} años, vive en {ciudad} y trabaja como
{profesion}.")
# Combinación de argumentos posicionales y de palabras clave
describir_persona("Juan", 40, profesion="abogado")
d) Número variable de argumentos (*args y **kwargs):
*args (Argumentos Posicionales Variables): Permite a una función aceptar cualquier número de
argumentos posicionales. Se empaquetan en una tupla dentro de la funció[Link] usa el asterisco
* seguido de un nombre (convencionalmente args).
**kwargs (Argumentos de Palabras Clave Variables): Permite a una función aceptar cualquier
número de argumentos de palabras clave. Se empaquetan en un diccionario dentro de la
función. Se usan dos asteriscos ** seguidos de un nombre (convencionalmente kwargs).
Estructura:
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 [Link]():
print(f"{clave}: {valor}")

info_persona(nombre="Juan", edad=30, ciudad="Madrid")

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.

Estructura:
def es_par(numero):
return numero % 2 == 0

print(es_par(4)) # Imprime: True

print(es_par(7)) # Imprime: False

def suma(a, b):

return a + b

resultado = suma(5, 3)
print(resultado) # Imprime: 8
print(suma(5, 3)) # Imprime: 8
4.4 Funciones lambda
Las funciones lambda es una pequeña función anónima que puede tener cualquier
número de argumentos, pero solo puede tener una expresión. Generalmente se usan
para operaciones simples y rápidas. Son funciones de primer orden: Pueden ser
pasadas como argumentos a otras funciones.
Usos comunes
En funciones como map(), filter() y reduce()
En ordenamiento personalizado (como key en sort() o sorted()

Estructura:
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]
Manejo de Excepciones
en Python
1 Try, except, else, finally
Aprenderemos cómo manejar errores y excepciones
en Python utilizando los bloques try, except, else y
finally. Esto nos permitirá escribir código más robusto
que pueda manejar situaciones inesperadas.

2 Lanzar excepciones con raise

Exploraremos cómo lanzar excepciones mediante la
palabra clave raise en Python. Esto nos permitirá
definir y manejar errores específicos de nuestra
aplicación de manera más efectiva.
5. Manejo de excepciones
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
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 básico:
Ejemplo con múltiples excepciones:
try:
def dividir_lista(lista, indice, divisor):
numero = int(input("Introduce un número: "))
try:
resultado = 10 / numero resultado = lista[indice] / divisor
except ValueError: return resultado
print("Error: Debes introducir un número válido.") except IndexError:
except ZeroDivisionError: print(f"Error: El índice {indice} está fuera del rango de la
print("Error: No se puede dividir por cero.") lista.")
else: except TypeError:
print(f"El resultado es: {resultado}") print("Error: No se puede dividir el elemento por el divisor
finally: dado.")
print("Operación finalizada.") 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.
 # Ejemplos de excepciones comunes en Python

# 1. TypeError # 5. KeyError
def tipo_error(): def clave_error():
return "5" + 5 diccionario = {"a": 1, "b": 2}
# Intenta concatenar str y int return diccionario["c"]
# Intenta acceder a una clave que no existe

# 2. ValueError
def valor_error(): # 6. ZeroDivisionError
return int("abc") def division_cero():
# Intenta convertir una cadena no numérica a int return 10 / 0
# Intenta dividir por cero
# 3. NameError
def nombre_error():
# 7. FileNotFoundError
return variable_no_definida
def archivo_no_encontrado():
# Intenta usar una variable no definida
open("archivo_inexistente.txt", "r")
# Intenta abrir un archivo que no existe
# 4. IndexError
def indice_error(): lista = [1, 2, 3] # 8. IOError
return lista[5] def error_io():
# Intenta acceder a un índice que no existe open("/ruta/no/accesible/[Link]", "w")
# Intenta escribir en una ubicación sin permisos
 # Ejemplos de excepciones comunes en Python

# 9. AttributeError
def atributo_error():
"hola".append("mundo")
# Intenta usar un método que no existe para el tipo de dato

# 10. ImportError
def importacion_error():
import modulo_inexistente
# Intenta importar un módulo que no existe
Conclusión del Curso
de Python
Felicidades por completar este curso intensivo de Python. A
lo largo de estas 8 horas, hemos cubierto los fundamentos
esenciales de Python, desde la introducción básica hasta
conceptos más avanzados como funciones y manejo de
excepciones. Ahora tienes una base sólida para continuar tu
viaje en la programación con Python. Recuerda, la práctica
es clave para dominar cualquier lenguaje de programación,
así que continúa explorando y creando proyectos con
Python. ¡Buena suerte en tu futuro como programador de
Python!