Introducción a Python

Fundamentos y masterclass

o Introducción a Python

o Fundamentos de Python

o Estructuras de control

o Estructuras de datos

o Funciones

o Manejo de errores y excepciones

o Entradas/salidas

o Importación y creación de módulos

Objetivos de aprendizaje

Comprender los conceptos básicos de programación utilizando Python, incluyendo variables,

tipos de datos, estructuras de control y funciones.

Desarrollar habilidades prácticas para resolver problemas utilizando Python, fomentando la

resolución de desafíos y la creatividad en la programación.

Proporcionar las habilidades necesarias para comprender y utilizar bibliotecas y módulos de

Python que les permitan ampliar sus capacidades de programación y explorar diferentes áreas

de aplicación.

Python fue creado por Guido van Rossum, un programador holandés, a finales de los años 80 y

principios de los 90. La primera versión de Python, la 0.9.0, fue lanzada en 1991. Guido van

Rossum nombró el lenguaje en honor al grupo de comedia británico Monty Python, del cual era

un gran fan.

Python se diseñó con el objetivo de ser un lenguaje fácil de leer y escribir, con una sintaxis

clara y concisa. A lo largo de los años, ha evolucionado y ganado popularidad hasta

convertirse en uno de los lenguajes de programación más utilizados en el mundo.

Características

Python tiene varias características que lo hacen atractivo tanto para principiantes como para

programadores experimentados:

Legibilidad
Python utiliza una sintaxis clara y sencilla, lo que facilita la lectura y comprensión del código.

Utiliza indentación (espacios o tabulaciones) para delimitar bloques de código, lo que

promueve un estilo de programación estructurado y legible.

Tipado dinámico

En Python, no es necesario declarar explícitamente el tipo de datos de las variables. Python

infiere automáticamente el tipo de datos en función del valor asignado a una variable, lo que

simplifica la escritura de código.

Interpretado

Python es un lenguaje interpretado, lo que significa que el código se ejecuta línea por línea en

tiempo real. Esto permite un ciclo de desarrollo rápido y facilita la depuración del código.

Multiplataforma

Python se puede ejecutar en diferentes sistemas operativos, como Windows, macOS y Linux,

sin necesidad de modificar el código. Esto lo convierte en un lenguaje versátil y portátil.

Amplia biblioteca estándar

Python viene con una extensa biblioteca estándar que proporciona una gran cantidad de

módulos y funciones para realizar diversas tareas, como manipulación de archivos, conexión a

bases de datos, procesamiento de texto, entre otros.

Comunidad activa
Python cuenta con una comunidad de desarrolladores grande y activa que contribuye con

bibliotecas, frameworks y herramientas adicionales. Esto significa que encontrarás una gran

cantidad de recursos y soporte disponibles.

Aplicaciones

Python se utiliza en una amplia gama de aplicaciones y dominios, algunos ejemplos son:

Desarrollo web

Python es ampliamente utilizado en el desarrollo web backend, con frameworks populares

como Django y Flask.

Ciencia de datos

Python es el lenguaje preferido para el análisis de datos y la ciencia de datos debido a

bibliotecas como NumPy, Pandas y Matplotlib.

Inteligencia artificial y machine learning

Python es la elección principal para proyectos de IA y machine learning, gracias a bibliotecas

como TensorFlow y Scikit-learn.

Automatización de tareas
Python se puede utilizar para automatizar tareas repetitivas, como procesamiento de archivos,

web scraping y pruebas de software.

El web scraping es una técnica que permite extraer datos de páginas web de manera

automatizada. Se utiliza con programas de software que simulan la navegación de un usuario.

Usos del web scraping

 Recopilar datos para investigaciones

 Comparar precios

 Generar bases de datos

 Automatizar tareas

 Monitorear redes sociales

 Generar listas de clientes potenciales

Cómo funciona

 El programa de software simula la navegación de un usuario

 Extrae información de los sitios web

 Almacena la información extraída

Desarrollo de juegos

Python se utiliza en el desarrollo de juegos simples, especialmente con bibliotecas como

Pygame.

Configuración del entorno de desarrollo

Un entorno de desarrollo integrado (IDE) es una herramienta que facilita la escritura, ejecución

y depuración de código. Si bien puedes usar un editor de texto simple para escribir código

Python, un IDE ofrece características adicionales que mejoran la productividad del desarrollo.

Algunos IDE populares para Python son:

 PyCharm: es un IDE potente y completo desarrollado por JetBrains. Ofrece funciones

avanzadas, como autocompletado de código, depuración, integración con sistemas de

control de versiones y más.

 Visual Studio Code: es un editor de código desarrollado por Microsoft. Con la extensión

de Python, se convierte en un IDE ligero y versátil para el desarrollo de Python.

 Sublime Text: es un editor de texto rápido y personalizable que admite la programación

en Python mediante el uso de plugins.

Para empezar, te recomendamos usar Visual Studio Code, ya que es ligero, fácil de usar y tiene

una gran cantidad de extensiones disponibles.

Otra alternativa es el uso de Jupyter Notebooks, una aplicación web interactiva que permite

crear y compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y

texto explicativo. Se utiliza habitualmente en ciencia de datos, análisis y aprendizaje de

Python.

Para usar Jupyter Notebook:

1. Abre la línea de comandos (Terminal en macOS/Linux o Command Prompt en

Windows).

2. Ejecuta el siguiente comando para instalar Jupyter Notebooks:

pip install jupyter notebooks

3. Una vez instalado, ejecuta el siguiente comando para iniciar Jupyter Notebook:

jupyter notebooks

Se abrirá una ventana del navegador con la interfaz de Jupyter Notebook.

4. Haz clic en "New" y selecciona "Python 3" para crear un nuevo cuaderno (notebook).

Importante

Jupyter Notebook es una excelente herramienta para explorar,

experimentar y compartir código Python de manera interactiva.

Primer programa en Python

"Hola Mundo"

Es una tradición en el mundo de la programación comenzar con un programa simple llamado

"Hola Mundo". Este programa simplemente muestra el mensaje "Hola Mundo" en la pantalla.

 Abre tu IDE o editor de texto preferido y crea un nuevo archivo.

 Nombra el archivo como "hola_mundo.py". La extensión ".py" indica que es un archivo

de Python.

 En el archivo, escribe el siguiente código:

print ("¡Hola, Mundo!")

 Guarda el archivo y ejecuta el programa. Si estás utilizando un IDE, busca la opción

"Run o "Execute".

Verás que el mensaje "¡Hola, Mundo!" se imprime en la pantalla.

Conceptos básicos de la sintaxis en Python

Antes de sumergirnos en conceptos más avanzados, es importante familiarizarse con algunos

aspectos básicos de la sintaxis de Python.

 Indentación

En Python, la indentación (espacios o tabulaciones al inicio de una línea) se utiliza para

delimitar bloques de código. A diferencia de otros lenguajes que utilizan llaves o palabras

clave, Python utiliza la indentación para determinar el alcance de las declaraciones. Por

ejemplo:

if condition:

# Bloque de código si la condición es verdadera

instrucción1

instrucción2

else:

# Bloque de código si la condición es falsa

instrucción3

instrucción4
 Importante

Es fundamental mantener una indentación consistente en todo el

código para evitar errores de sintaxis.

 Comentarios

Los comentarios son líneas de texto en el código que son ignoradas por el intérprete de Python.

Se utilizan para explicar o documentar el código. En Python, los comentarios de una sola línea

comienzan con el símbolo #, mientras que los comentarios de varias líneas se encierran entre

triples comillas """. Por ejemplo:

# Este es un comentario de una sola línea

""" Este es un comentario de varias líneas """

 Sensibilidad a mayúsculas y minúsculas

Python distingue entre mayúsculas y minúsculas. Por lo tanto, variable, Variable y VARIABLE

se consideran variables diferentes.

 Punto y coma

A diferencia de otros lenguajes, Python no requiere el uso de punto y coma (;) al final de cada

instrucción. Sin embargo, si deseas escribir varias instrucciones en una sola línea, puedes

separarlas con un punto y coma. Por ejemplo:

instruccion1; instruccion2; instruccion3

 Uso de paréntesis

Los paréntesis se utilizan para

1 agrupar expresiones,

2 definir funciones y

3 realizar llamadas a funciones.

Por ejemplo:

resultado = (a + b) * c
Fundamentos de Python
Tipos de datos básicos

En Python, los tipos de datos básicos son las categorías en las que se pueden clasificar los

valores que utilizamos en nuestros programas. Comprender los diferentes tipos de datos es

fundamental para trabajar con variables y realizar operaciones en Python. Los tipos de datos

básicos incluyen:

 Enteros (int)

Los números enteros son aquellos que no tienen parte decimal. En Python, se representan

simplemente escribiendo el número sin comillas ni puntos decimales. Por ejemplo:

edad = 25

cantidad = 100

 Flotantes (float)

Los números flotantes, también conocidos como números de punto flotante, son aquellos que

tienen una parte decimal. En Python, se representan utilizando un punto para separar la parte

entera de la parte decimal. Por ejemplo:

precio = 9.99

altura = 1.75
  Cadenas de texto (strings)

Las cadenas de texto, o simplemente cadenas, son secuencias de caracteres encerradas entre

comillas simples ('...') o dobles ("..."). Se utilizan para representar texto en Python. Por ejemplo:

nombre = "Juan"

mensaje = '¡Hola, mundo!'

Puedes incluir caracteres especiales en las cadenas utilizando el carácter de escape \. Por

ejemplo, para incluir comillas dentro de una cadena, puedes usar \' o \". También puedes utilizar

la notación de triple comilla ('''...''' o """...""") para crear cadenas de varias líneas.

 Booleanos

Los valores booleanos representan los valores de verdad: True (verdadero) y False (falso). Se

utilizan comúnmente en expresiones condicionales y operaciones lógicas. Por ejemplo:

es_mayor_de_edad = True

tiene_descuento = False

Ten en cuenta
 Los valores booleanos en Python comienzan con una letra

mayúscula: True y False.

Estos son los tipos de datos básicos en Python. A lo largo de este módulo, aprenderás a trabajar

con estos tipos de datos, realizar operaciones y utilizarlos en diferentes contextos.

Variables

Las variables son contenedores que nos permiten

1 almacenar y

2 manipular datos en nuestros programas.

Puedes pensar en una variable como una etiqueta (rótulo) a la que asignas a un valor específico.

En Python, no es necesario declarar el tipo de datos de una variable de antemano, ya que

Python infiere el tipo de datos automáticamente en función del valor asignado.

Declaración y asignación de variables

Las variables son contenedores que nos permiten almacenar y manipular datos en nuestros

programas. Para declarar y asignar un valor a una variable en Python, utilizamos el operador de

asignación (signo igual) = El nombre de la variable va a la izquierda del operador, y el valor

que deseas asignar va a la derecha.

Por ejemplo:

(variable) nombre = "Juan" (valor) en palabras llevan “”

operador de asignación

edad = 25 (valor entero int) los números no llevan “”

altura = 1.75 (valor flotante float)

es estudiante = True (valor de verdad . booleanos) empiezan siempre con mayúscula

En el ejemplo, hemos declarado y asignado valores a las variables nombre, edad, altura y

es_estudiante. Python infiere automáticamente el tipo de datos de cada variable en función del

valor asignado.

También puedes asignar el mismo valor a múltiples variables en una sola línea utilizando el

operador de asignación múltiple:

a = b = c = 10

En este caso, las variables a, b y c tendrán el valor 10.

Normas para nombrar variables

Al nombrar variables en Python, es importante seguir algunas normas para mantener un código

legible y evitar errores:

Los nombres de las variables solo pueden contener:

1- letras (a-z, A-Z),

 2- números (0-9) y

3- guiones bajos (_). No pueden comenzar con un número.

Python distingue entre mayúsculas y minúsculas, por lo que nombre y Nombre son variables

diferentes.

No se pueden utilizar palabras clave reservadas de Python como nombres de variables (por

ejemplo, if, else, for, while, etc.).

Se recomienda utilizar nombres descriptivos para las variables, que indiquen claramente su

propósito: nombre, edad, total_ventas, etc.

Siguiendo estas normas, algunos ejemplos de nombres de variables válidos son:

edad

nombre_completo

total_ventas

_contador (puede comenzar con _ pero no puede comenzar con números)

Y algunos ejemplos de nombres de variables inválidos son:

1edad # Comienza con un número

nombre-completo # Utiliza un guion en lugar de un guion bajo

if # Palabra clave reservada de Python

 Ten en cuenta

Elegir nombres descriptivos para tus variables facilita la

lectura y comprensión del código, tanto para ti como

para otros desarrolladores que puedan trabajar en el mismo

proyecto.

Operadores

Los operadores son símbolos especiales que nos permiten realizar operaciones en variables y

valores. Python proporciona diferentes tipos de operadores para realizar operaciones

aritméticas, comparaciones y operaciones lógicas.

Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas básicas. Los

principales operadores aritméticos en Python son:

 Suma (+): suma dos valores.

 Resta (-): resta el segundo valor del primero.

 Multiplicación (*): multiplica dos valores.

  División (/): divide el primer valor por el segundo y devuelve un resultado de tipo

flotante.

 División entera (//): divide el primer valor por el segundo y devuelve un resultado de tipo

entero (se descarta la parte decimal).

 Módulo (%): devuelve el resto de la división entre el primer valor y el segundo.

 Exponenciación (**): eleva el primer valor a la potencia del segundo.

Ejemplos:

a = 10

b=3

suma = a + b # 13

resta = a - b #7

multiplicacion = a * b # 30

division = a / b # 3.333333333

división_entera = a // b # 3

modulo = a % b # 1

exponenciacion = a ** b # 1000
De comparación

Los operadores de comparación se utilizan para comparar dos valores y devuelven un valor

booleano (True o False) según el resultado de la comparación. Los operadores de comparación

en Python son:

 Igual a (==): devuelve True si ambos valores son iguales.

 Diferente de (!=): devuelve True si los valores son diferentes.

 Mayor que (>): devuelve True si el primer valor es mayor que el segundo.

 Menor que (<): devuelve True si el primer valor es menor que el segundo.

 Mayor o igual que (>=): devuelve True si el primer valor es mayor o igual que el

segundo.

 Menor o igual que (<=): devuelve True si el primer valor es menor o igual que el

segundo.

Ejemplos:

a = 10

b=3

igual = a == b # False

diferente = a != b # True

mayor que = a > b # True

menor que = a < b # False

mayor o igual = a >= b # True

menor o igual = a <= b # False

Lógicos

Los operadores lógicos se utilizan para combinar expresiones condicionales y evaluar múltiples

condiciones. Los operadores lógicos en Python son:

 AND (and): devuelve True si ambas condiciones son verdaderas.

 OR (or): devuelve True si al menos una de las condiciones es verdadera.

 NOT (not): invierte el valor de una condición, devuelve True si la condición es falsa y

False si la condición es verdadera.

Ejemplo:

a = 10

b=3

resultado_and = (a > 5) and (b < 5) # True

resultado_or = (a > 15) or (b < 5) # True

resultado_not = not (a > 5) # False

Puedes utilizar estos operadores para realizar cálculos, tomar decisiones basadas en

comparaciones y combinar condiciones lógicas en tus programas.

 Importante

Python sigue las reglas de precedencia de operadores,

donde ciertos operadores tienen prioridad sobre otros.

En general, la precedencia sigue el orden: paréntesis,

exponenciación, multiplicación/división, suma/resta,

operadores de comparación y operadores lógicos.

Estructuras de control
Las estructuras de control nos permiten controlar el flujo de ejecución de nuestros programas.

En Python, las estructuras de control más comunes son las

1- estructuras condicionales y (operadores lógicos =/= estructuras condicionales)

2- bucles.

Estas estructuras nos permiten tomar decisiones y repetir bloques de código según ciertas

condiciones.
Estructuras condicionales

Las estructuras condicionales nos permiten ejecutar diferentes bloques de código según se

cumpla o no una determinada condición. En Python, las estructuras condicionales más

utilizadas son if (si), if-else (si-sino) y if-elif-else.

 IF

La estructura if se utiliza para ejecutar un bloque de código si una condición es verdadera. La

sintaxis básica es la siguiente:

if condicion:

# Bloque de código a ejecutar si la condición es verdadera

instrucciones

Ejemplo:

edad = 18

if edad >= 18: # acá la condiciones es (edad >= 18:)

print ("Eres mayor de edad.")

En este ejemplo, si la variable edad es mayor o igual a 18, se ejecutará el bloque de código

dentro del if y se imprimirá el mensaje "Eres mayor de edad."

 IF-ELSE
La estructura if-else nos permite especificar un bloque de código alternativo que se ejecutará si

la condición del if es falsa. La sintaxis básica es la siguiente:

edad = 15

if edad >= 18:

print ("Eres mayor de edad.")

else:

print ("eres menor de edad.")

En este ejemplo, si la variable edad es mayor o igual a 18, se ejecutará el bloque de código

dentro del if y se imprimirá el mensaje "Eres mayor de edad." De lo contrario, se ejecutará el

bloque de código dentro del else y se imprimirá el mensaje "Eres menor de edad."

 IF-ELIF-ELSE

La estructura if-elif-else nos permite especificar múltiples condiciones y bloques de código

alternativos. La sintaxis básica es la siguiente:

if condicion1:

# Bloque de código a ejecutar si la condicion1 es verdadera

instrucciones
elif condicion2:

# Bloque de código a ejecutar si la condicion2 es verdadera

instrucciones

else:

# Bloque de código a ejecutar si ninguna condición anterior es verdadera

instrucciones

Ejemplo:

calificacion = 85

if calificacion >= 90:

print ("Excelente")

elif calificacion >= 80:

print ("Muy bueno")

elif calificacion >= 70:

print ("Bueno")
else:

print ("Necesita mejorar")

En este ejemplo, se evalúan múltiples condiciones en orden. Si la variable calificación es mayor

o igual a 90, se imprime "Excelente". Si no se cumple la primera condición, pero calificación es

mayor o igual a 80, se imprime "Muy bueno". Si no se cumplen las condiciones anteriores, pero

calificación es mayor o igual a 70, se imprime "Bueno". Si ninguna de las condiciones

anteriores es verdadera, se ejecuta el bloque else y se imprime "Necesita mejorar".

Las estructuras condicionales más comunes son:

1. if

Se usa para ejecutar un bloque de código si una condición se cumple.

edad = 18

if edad >= 18:

print("Eres mayor de edad")

2. if-else

Se usa cuando queremos ejecutar un bloque de código si la condición se cumple y otro bloque

si no se cumple.

edad = 16

if edad >= 18:

print("Eres mayor de edad")

else:

print("Eres menor de edad")

3. if-elif-else (si-sino-entoces)

Se usa cuando hay múltiples condiciones a evaluar.

edad = 15

if edad >= 18:

print("Eres mayor de edad")

elif edad >= 13:

print("Eres un adolescente")

else:

print("Eres un niño")

4. Condicionales en una línea (Operador Ternario)

Es una forma compacta de escribir un if-else.

edad = 20

mensaje = "Mayor de edad" if edad >= 18 else "Menor de edad"

print(mensaje)
5. Condiciones combinadas (and, or, not)

Se pueden combinar múltiples condiciones usando operadores lógicos.

temperatura = 25

humedad = 60

if temperatura > 20 and humedad < 70:

print("El clima es agradable")

6. Estructuras condicionales anidadas

Un if dentro de otro if.

edad = 25

tiene_identificacion = True

if edad >= 18:

if tiene_identificacion:

print("Puedes entrar al evento")

else:

print("Necesitas una identificación")

else:
 print("No puedes entrar")

Sí, los operadores lógicos y las estructuras condicionales están relacionadas, pero no son lo

mismo.

Los operadores lógicos (and, or, not) se usan para combinar condiciones, mientras que las

estructuras condicionales (if, if-else, if-elif-else) deciden qué código ejecutar en función de

esas condiciones.

📌 Cómo se relacionan

Las estructuras condicionales dependen de expresiones lógicas, y dentro de esas expresiones

lógicas se pueden usar operadores lógicos.

Ejemplo simple de estructura condicional:

edad = 20

if edad >= 18:

print("Eres mayor de edad")

Aquí la condición edad >= 18 es una expresión lógica.

Si queremos combinar varias condiciones, usamos operadores lógicos:

edad = 20

tiene_identificacion = True

if edad >= 18 and tiene_identificacion:

print("Puedes entrar al evento")

else:

print("No puedes entrar")

👉 Aquí el and (operador lógico) une dos condiciones “mayor o igual a 18 y tiene

identificación” (expresiones lógicas) dentro del if (estructura condicional).

🔹 Operadores lógicos más comunes

and (y) → Ambas condiciones deben ser verdaderas.

if edad >= 18 and tiene_identificacion:

print("Puedes entrar")
Si edad es 20 y tiene_identificacion es True, entra.

or (o) → Basta con que una condición sea verdadera.

if edad >= 18 or tiene_identificacion:

print("Puedes entrar")

Aquí, aunque no tenga identificación, si la edad es suficiente, entra.

not (negación) → Invierte el valor lógico.

If (estructurante condicional) not (operador lógico) tiene_identificacion (expresión lógica o

condición):

print("No puedes entrar")

Si tiene_identificacion es False, se imprime "No puedes entrar".

🔹 Ejemplo con elif y operadores lógicos

hora = 14

es_finde = False

if hora < 12:

print("Buenos días")

elif hora < 18 and not es_finde:

print("Buenas tardes, día laboral")

else:

print("Buenas noches o fin de semana")

✅ Aquí usamos elif, and y not juntos en una estructura condicional.

📌 Conclusión

Los operadores lógicos y las estructuras condicionales están relacionados porque los primeros

se usan para construir condiciones dentro de los if, elif y else. No son lo mismo, pero trabajan

juntos para tomar decisiones en el código

Bucles/loops

Los bucles nos permiten repetir un bloque de código varias veces. En Python, los bucles más

comunes son for y while.

For

El bucle for (para, en) se utiliza para iterar sobre una secuencia (como una lista, una tupla o una

cadena) o cualquier objeto iterable. La sintaxis básica es la siguiente:

for variable in secuencia:

# Bloque de código a repetir

instrucciones

Ejemplo:

frutas = ["manzana", "banana", "naranja"]

for fruta in(en) frutas:

print(fruta)

En este ejemplo, el bucle for itera sobre la lista frutas. En cada iteración, la variable fruta toma

el valor de un elemento de la lista, y se ejecuta el bloque de código dentro del bucle. En este

caso, se imprime cada fruta en una línea separada.

While (mientras que, mientras)

El bucle while se utiliza para repetir un bloque de código mientras una condición sea verdadera.

La sintaxis básica es la siguiente:

while condicion:

# Bloque de código a repetir

instrucciones

Ejemplo:

contador = 0

while contador < 5:

print(contador)

contador += 1

En este ejemplo, el bucle while se ejecuta mientras la variable contador sea menor que 5. En

cada iteración, se imprime el valor de contador y luego se incrementa en 1 mediante la

instrucción contador += 1. El bucle se detendrá cuando contador alcance el valor de 5.

Es importante tener cuidado al usar el bucle while, ya que, si la condición nunca se vuelve

falsa, el bucle se ejecutará indefinidamente, lo que se conoce como un bucle infinito.

 Break
La instrucción break se utiliza para salir prematuramente de un bucle, independientemente de la

condición. Cuando se encuentra un break, el bucle se detiene y el flujo de ejecución continúa

con la siguiente instrucción fuera del bucle.

contador = 0

while True:

print(contador)

contador += 1

if contador == 5:

break

En este ejemplo, el bucle while se ejecuta indefinidamente debido a la condición True. Sin

embargo, dentro del bucle se utiliza una estructura condicional if para verificar si contador es

igual a 5. Cuando se cumple esta condición, se ejecuta la instrucción break, lo que hace que el

bucle se detenga y el flujo de ejecución continúe con la siguiente instrucción fuera del bucle.

 Continue
La instrucción continue se utiliza para saltar el resto del bloque de código dentro de un bucle y

pasar a la siguiente iteración.

Ejemplo:

for i in range(10):

if i % 2 == 0:

continue

print(i)

En este ejemplo, el bucle for itera sobre los números del 0 al 9 utilizando la función range().

Dentro del bucle, se verifica si el número es divisible por 2 utilizando el operador de módulo %.

Si el número es divisible por 2 (es decir, si es par), se ejecuta la instrucción continue, lo que

hace que se salte el resto del bloque de código y se pase a la siguiente iteración del bucle. Como

resultado, solo se imprimirán los números impares.

 Pass

La instrucción pass es una operación nula que no hace nada. Se utiliza como marcador de

posición cuando se requiere una instrucción sintácticamente, pero no se desea realizar ninguna

acción.

Ejemplo:
for i in range(5):

pass

En este ejemplo, el bucle for itera sobre los números del 0 al 4, pero no se realiza ninguna

acción dentro del bucle debido a la instrucción pass. Esto puede ser útil cuando se está

desarrollando un programa y se desea reservar un bloque de código para implementarlo más

adelante.

Conclusión

Las estructuras de control son herramientas poderosas que

nos permiten controlar el flujo de ejecución de nuestros

programas.

Con las estructuras condicionales (if, if-else, if-elif-else)

podemos tomar decisiones basadas en condiciones, mientras que

con los bucles (for, while) podemos repetir bloques de código

varias veces.

Además, las instrucciones break, continue y pass nos brindan

un control adicional sobre el comportamiento de los bucles.

En Python, los bucles (loops) permiten ejecutar un bloque de código varias veces. Los más

comunes son:

🔄 1. Bucle for

Se usa para iterar sobre secuencias (listas, tuplas, cadenas, rangos, diccionarios).

🔹 Recorrer una lista:

productos = ["Laptop", "Teléfono", "Tablet"]

for producto in productos:

print(producto)

🔹 Recorrer un rango de números:

for i in range(5): # De 0 a 4

print(i)

🔹 Recorrer un diccionario:

precios = {"Laptop": 1000, "Teléfono": 500, "Tablet": 300}

for producto, precio in precios.items():

print(f"{producto}: ${precio}")

🔄 2. Bucle while

Se ejecuta mientras una condición sea verdadera.

contador = 0

while contador < 5:

print(contador)

contador += 1

⏭ 3. Control de bucles (break, continue, pass)

🔹 break (rompe el bucle)

for i in range(10):

if i == 5:
 break # Se detiene cuando i es 5

print(i)

🔹 continue (salta la iteración actual)

for i in range(5):

if i == 2:

continue # Salta el 2 y sigue con el 3

print(i)

🔹 pass (no hace nada, se usa como marcador de posición)

for i in range(5):

if i == 2:

pass # Se puede usar para escribir código luego

print(i)
🔄 4. Bucles anidados

Se pueden combinar bucles dentro de otros.

for i in range(3):

for j in range(2):

print(f"Fila {i}, Columna {j}")

Control de bucles

Python proporciona algunas instrucciones especiales para controlar el flujo de ejecución dentro

de los bucles:

 Break

La instrucción break se utiliza para salir prematuramente de un bucle, independientemente de la

condición. Cuando se encuentra un break, el bucle se detiene y el flujo de ejecución continúa

con la siguiente instrucción fuera del bucle.

contador = 0
while True:

print(contador)

contador += 1

if contador == 5:

break

En este ejemplo, el bucle while se ejecuta indefinidamente debido a la condición True. Sin

embargo, dentro del bucle se utiliza una estructura condicional if para verificar si contador es

igual a 5. Cuando se cumple esta condición, se ejecuta la instrucción break, lo que hace que el

bucle se detenga y el flujo de ejecución continúe con la siguiente instrucción fuera del bucle.

 Continue

La instrucción continue se utiliza para saltar el resto del bloque de código dentro de un bucle y

pasar a la siguiente iteración.

Ejemplo:

for i in range(10):
 if i % 2 == 0:

continue

print(i)

En este ejemplo, el bucle for itera sobre los números del 0 al 9 utilizando la función range().

Dentro del bucle, se verifica si el número es divisible por 2 utilizando el operador de módulo %.

Si el número es divisible por 2 (es decir, si es par), se ejecuta la instrucción continue, lo que

hace que se salte el resto del bloque de código y se pase a la siguiente iteración del bucle. Como

resultado, solo se imprimirán los números impares.

 Pass

La instrucción pass es una operación nula que no hace nada. Se utiliza como marcador de

posición cuando se requiere una instrucción sintácticamente, pero no se desea realizar ninguna

acción.

Ejemplo:

for i in range(5):

pass

En este ejemplo, el bucle for itera sobre los números del 0 al 4, pero no se realiza ninguna

acción dentro del bucle debido a la instrucción pass. Esto puede ser útil cuando se está

desarrollando un programa y se desea reservar un bloque de código para implementarlo más

adelante.
 Cnclusión

Las estructuras de control son herramientas poderosas que nos permiten

controlar el flujo de ejecución de nuestros programas. Con las estructuras

condicionales (if, if-else, if-elif-else) podemos tomar decisiones basadas en

condiciones, mientras que con los bucles (for, while) podemos repetir bloques

de código varias veces. Además, las instrucciones break, continue y pass nos

brindan un control adicional sobre el comportamiento de los bucles.

Tuplas

Una tupla es una estructura de datos inmutable y ordenada que permite almacenar una

colección de elementos. Los elementos de una tupla se encierran entre paréntesis (), separados

por comas.

 Creación y acceso

Para crear una tupla, encierra los elementos entre paréntesis:

punto = (3, 4)
Para acceder a los elementos de una tupla, utiliza el índice del elemento entre corchetes, similar

a las listas:

print(punto[0]) # Imprime 3

print(punto[1]) # Imprime 4

A diferencia de las listas, las tuplas son inmutables, lo que significa que no se pueden modificar

una vez creadas. No se pueden agregar, eliminar o cambiar elementos en una tupla existente.

Las tuplas son útiles cuando necesitas almacenar una colección de elementos que no deben

modificarse, como coordenadas o datos de configuración.

 Métodos de tuplas

Aunque las tuplas son inmutables, Python proporciona varios métodos útiles para trabajar con

ellas:

 count(elemento): devuelve el número de veces que aparece un elemento en la tupla.

 index(elemento): devuelve el índice de la primera aparición de un elemento en la tupla.

Opcionalmente, se puede especificar el inicio y fin de la búsqueda.

 len(tupla): aunque no es un método de tupla propiamente dicho, esta función

incorporada devuelve la longitud de la tupla.

mi_tupla = (1, 2, 3, 2, 4, 2)

print (mi_tupla.index(2)) # Salida: 1

print (mi_tupla.index(2, 2)) #Salida: 3

print (mi_tupla.index(2, 2, 4)) #Salida: 3

Una tupla es una estructura de datos inmutable, lo que significa que sus elementos no pueden

modificarse después de su creación. Se utilizan para almacenar múltiples elementos en un solo

contenedor.

🔹 1. Crear una tupla

Las tuplas se definen con paréntesis () o sin ellos.

# Tupla con paréntesis

productos = ("Laptop", "Teléfono", "Tablet")

# Tupla sin paréntesis (empaquetado automático)

precios = 1000, 500, 300

print(productos) # ('Laptop', 'Teléfono', 'Tablet')

print(precios) # (1000, 500, 300)

🔹 2. Acceder a elementos

Se usa la indexación como en las listas.

print(productos[0]) # Laptop

print(productos[-1]) # Tablet

🔹 3. Slicing (Rebanado)

print(productos[0:2]) # ('Laptop', 'Teléfono')

print(productos[:2]) # ('Laptop', 'Teléfono')

print(productos[1:]) # ('Teléfono', 'Tablet')

🔹 4. Desempaquetado de tuplas

producto1, producto2, producto3 = productos

print(producto1) # Laptop

print(producto2) # Teléfono

También se puede usar * para capturar múltiples valores:

primero, *resto = productos

print(primero) # Laptop

print(resto) # ['Teléfono', 'Tablet']

🔹 5. Operaciones con tuplas

✅ Longitud de una tupla:

print(len(productos)) # 3

✅ Concatenación:

nueva_tupla = productos + ("Smartwatch",)

print(nueva_tupla) # ('Laptop', 'Teléfono', 'Tablet', 'Smartwatch')

✅ Repetición:

repetida = ("Oferta",) * 3

print(repetida) # ('Oferta', 'Oferta', 'Oferta')

✅ Comprobar si un elemento está en la tupla:

print("Laptop" in productos) # True

🔹 6. Conversión entre tuplas y listas

Si necesitas modificar una tupla, conviértela en lista y luego de nuevo en tupla.

lista = list(productos) # Convertir a lista

lista.append("Smartwatch") # Modificar

productos = tuple(lista) # Convertir de nuevo a tupla

print(productos)

🔹 7. Cuándo usar tuplas en vez de listas

✅ Inmutabilidad: Si los datos no deben cambiar.

✅ Mayor rendimiento: Son más rápidas que las listas.

✅ Mayor seguridad: Se usan en estructuras de datos que no deben modificarse por error.

Diccionarios

Un diccionario es una estructura de datos mutable y no ordenada que permite almacenar pares

de clave-valor. Cada elemento en un diccionario consiste en una clave única y su valor

correspondiente. Los diccionarios se encierran entre llaves {}, y los pares clave-valor se

separan por comas.

 Creación y acceso

Para crear un diccionario, utiliza llaves y separa las claves y valores con dos puntos.

persona = {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"}

Para acceder a los valores de un diccionario, utiliza la clave correspondiente entre corchetes:

print(persona["nombre"]) # Imprime "Juan"

print(persona["edad"]) # Imprime 25

print(persona["ciudad"]) # Imprime "Madrid"

También puedes utilizar el método get() para obtener el valor de una clave. Si la clave no

existe, devuelve un valor predeterminado (por defecto, None).

 Métodos de diccionarios

Los diccionarios en Python tienen varios métodos incorporados para manipular y acceder a los

elementos. Algunos métodos comunes son:

 keys(): devuelve una vista de todas las claves del diccionario.

 values(): devuelve una vista de todos los valores del diccionario.

 items(): devuelve una vista de todos los pares clave-valor del diccionario.
  update(otro_diccionario): actualiza el diccionario con los pares clave-valor de otro

diccionario.

Ejemplo:

persona = {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"}

print(persona.keys()) # Imprime dict_keys(["nombre", "edad", "ciudad"])

print(persona.values()) # Imprime dict_values(["Juan", 25, "Madrid"])

print(persona.items()) # Imprime dict_items([("nombre", "Juan"), ("edad", 25), ("ciudad",

"Madrid")])

persona.update({"profesion": "Ingeniero"})

print(persona) # Imprime {"nombre": "Juan", "edad": 25, "ciudad": "Madrid", "profesion":

"Ingeniero"}

Un diccionario es una estructura de datos que almacena pares clave-valor, lo que permite

acceder a los valores mediante una clave en lugar de un índice. Se define con llaves {}.

🔹 1. Crear un diccionario
producto = {

"nombre": "Laptop",

"precio": 1000,

"stock": 5

print(producto)

# {'nombre': 'Laptop', 'precio': 1000, 'stock': 5}

🔹 2. Acceder a valores

print(producto["nombre"]) # Laptop

print(producto["precio"]) # 1000

También se puede usar .get() para evitar errores si la clave no existe:

print(producto.get("marca", "No especificado")) # No especificado

🔹 3. Modificar valores

producto["precio"] = 1200

producto["stock"] -= 1 # Reduce el stock en 1

print(producto)

🔹 4. Agregar y eliminar elementos

producto["marca"] = "HP" # Agregar

del producto["stock"] # Eliminar

print(producto)

También se puede usar .pop() para eliminar y obtener el valor eliminado:

precio_eliminado = producto.pop("precio")

print(precio_eliminado) # 1200
🔹 5. Recorrer un diccionario

✅ Recorrer solo claves:

for clave in producto:

print(clave) # nombre, marca

✅ Recorrer claves y valores:

for clave, valor in producto.items():

print(f"{clave}: {valor}")

🔹 6. Métodos útiles

# Obtener solo las claves

print(producto.keys()) # dict_keys(['nombre', 'marca'])

# Obtener solo los valores

print(producto.values()) # dict_values(['Laptop', 'HP'])

# Verificar si una clave existe

print("precio" in producto) # False

🔹 7. Diccionarios anidados

Se pueden almacenar diccionarios dentro de diccionarios.

productos = {

"Laptop": {"precio": 1000, "stock": 5},

"Teléfono": {"precio": 500, "stock": 10}

print(productos["Laptop"]["precio"]) # 1000

🔹 8. Convertir entre diccionarios y listas

Convertir diccionario a lista de claves:

lista_claves = list(producto.keys())

print(lista_claves) # ['nombre', 'marca']

Convertir lista de pares clave-valor a diccionario:

lista_pares = [("nombre", "Tablet"), ("precio", 300)]

nuevo_producto = dict(lista_pares)

print(nuevo_producto)

Conjuntos (set)

Un conjunto es una estructura de datos mutable y no ordenada que permite almacenar una

colección de elementos únicos. Los conjuntos se encierran entre llaves {} o se crean utilizando

la función set().

 Creación y operaciones básicas

Para crear un conjunto, utiliza llaves o la función set():

frutas = {"manzana", "banana", "naranja"}

numeros = set([1, 2, 3, 4, 5])

Los conjuntos admiten operaciones matemáticas de conjuntos, como la unión (|), la intersección

(&), la diferencia (-) y la diferencia simétrica (^).

conjunto1 = {1, 2, 3}

conjunto2 = {3, 4, 5}

union = conjunto1 | conjunto2

print(union) # Imprime {1, 2, 3, 4, 5}

interseccion = conjunto1 & conjunto2

print(interseccion) # Imprime {3}

diferencia = conjunto1 - conjunto2

print(diferencia) # Imprime {1, 2}

diferencia_simetrica = conjunto1 ^ conjunto2

print(diferencia_simetrica) # Imprime {1, 2, 4, 5}

  Métodos de conjuntos

Los conjuntos en Python tienen varios métodos incorporados para manipular y acceder a los

elementos. Algunos métodos comunes son:

 add(adjuntar): agrega un elemento al conjunto.

 remove(remover): elimina un elemento del conjunto. Si el elemento no existe, genera un

error.

 discard(eliminar): elimina un elemento del conjunto si está presente. Si el elemento

no existe, no hace nada.

 clear(extermiño): elimina todos los elementos del conjunto.

Ejemplo:

frutas = {"manzana", "banana", "naranja"}

frutas.add("pera")

print(frutas) # Imprime {"manzana", "banana", "naranja", "pera"}

frutas.remove("banana")

print(frutas) # Imprime {"manzana", "naranja", "pera"}

frutas.discard("uva")

print(frutas) # Imprime {"manzana", "naranja", "pera"}

frutas.clear()

print(frutas) # Imprime set()

Las estructuras de datos en Python nos brindan una gran flexibilidad y potencia para almacenar

y manipular datos en nuestros programas. Las listas son útiles para colecciones ordenadas y

mutables, las tuplas para colecciones ordenadas e inmutables, los diccionarios para almacenar

pares clave-valor y los conjuntos para colecciones no ordenadas de elementos únicos.

Conjuntos (set) en Python

Un conjunto es una estructura de datos no ordenada que no permite duplicados. Se usa para

almacenar elementos únicos y realizar operaciones matemáticas como unión, intersección y

diferencia.

🔹 1. Crear un conjunto

Se define con llaves {} o usando set().

productos = {"Laptop", "Teléfono", "Tablet"}

print(productos)

# {'Laptop', 'Tablet', 'Teléfono'} (el orden puede cambiar)

✅ Se eliminan duplicados automáticamente:

duplicados = {"Laptop", "Teléfono", "Laptop", "Tablet"}

print(duplicados)

# {'Laptop', 'Teléfono', 'Tablet'}

🔹 Crear un conjunto vacío

conjunto_vacio = set() # Ojo: {} crea un diccionario vacío

🔹 2. Agregar y eliminar elementos

productos.add("Smartwatch") # Agregar un elemento

productos.remove("Teléfono") # Eliminar un elemento (da error si no existe)

productos.discard("Tablet") # Elimina sin error si no existe

print(productos)

✅ pop() elimina un elemento aleatorio:

elemento = productos.pop()

print(elemento) # Algún elemento aleatorio eliminado

✅ clear() vacía el conjunto:

productos.clear()

print(productos) # set()

🔹 3. Operaciones con conjuntos

✅ Unión (| o union())
Une dos conjuntos (sin duplicados).

set1 = {"Laptop", "Teléfono"}

set2 = {"Tablet", "Smartwatch"}

union = set1 | set2

print(union) # {'Laptop', 'Teléfono', 'Tablet', 'Smartwatch'}

✅ Intersección (& o intersection())

Devuelve los elementos en común.

set1 = {"Laptop", "Teléfono", "Tablet"}

set2 = {"Tablet", "Smartwatch"}

interseccion = set1 & set2

print(interseccion) # {'Tablet'}
✅ Diferencia (- o difference())

Elementos en un conjunto pero no en el otro.

diferencia = set1 - set2

print(diferencia) # {'Laptop', 'Teléfono'}

✅ Diferencia simétrica (^ o symmetric_difference())

Elementos que están en un conjunto o en el otro, pero no en ambos.

dif_simetrica = set1 ^ set2

print(dif_simetrica) # {'Laptop', 'Teléfono', 'Smartwatch'}

🔹 4. Verificar relaciones

✅ Subconjunto (<=) → Verifica si un conjunto está dentro de otro.

setA = {"Laptop", "Teléfono"}

setB = {"Laptop", "Teléfono", "Tablet"}

print(setA <= setB) # True

✅ Superconjunto (>=) → Verifica si un conjunto contiene a otro.

print(setB >= setA) # True

✅ Conjuntos disjuntos (isdisjoint()) → Verifica si no tienen elementos en común.

setC = {"Smartwatch", "Auriculares"}

print(setA.isdisjoint(setC)) # True

🔹 5. Convertir entre conjuntos y otras estructuras

✅ Convertir una lista a conjunto (para eliminar duplicados):

lista = ["Laptop", "Teléfono", "Laptop", "Tablet"]

set_sin_duplicados = set(lista)

print(set_sin_duplicados) # {'Laptop', 'Teléfono', 'Tablet'}

✅ Convertir un conjunto en lista o tupla:

lista_productos = list(set_sin_duplicados)

tupla_productos = tuple(set_sin_duplicados)

print(lista_productos, tupla_productos)

📌 Cuándo usar conjuntos

✅ Eliminar duplicados rápidamente.

✅ Operaciones matemáticas (uniones, intersecciones, diferencias).

✅ Verificar pertenencia (in es más rápido en set que en list).

Funciones
Las funciones son bloques de código reutilizables que nos permiten encapsular tareas

específicas y ejecutarlas cuando sea necesario. Las funciones nos ayudan a organizar nuestro

código, evitar la repetición y hacer que nuestros programas sean más modulares y fáciles de

mantener.

Definición y llamada de funciones

Para definir una función en Python, utilizamos la palabra clave def seguida del nombre de la

función y paréntesis. Opcionalmente, podemos especificar parámetros dentro de los paréntesis.

El bloque de código de la función se indenta después de los dos puntos.

Para llamar a una función, simplemente escribimos el nombre de la función seguido de

paréntesis:

def saludo():

print("¡Hola, mundo!")

saludo() # Imprime "¡Hola, mundo!"

Parámetros y argumentos

Las funciones pueden aceptar parámetros, que son valores que se pasan a la función cuando se

la llama. Los parámetros se especifican dentro de los paréntesis en la definición de la función.

def saludo(nombre):

print(f"¡Hola, {nombre}!")

Al llamar a la función, proporcionamos los argumentos correspondientes a los parámetros:

saludo("Juan") # Imprime "¡Hola, Juan!"

saludo("María") # Imprime "¡Hola, María!"

Parámetros vs. Argumentos en funciones

Parámetros → Son variables definidas en la función que reciben valores cuando se llama.

Argumentos → Son los valores reales que se pasan a los parámetros al llamar la función.

✅ Ejemplo:

def saludar(nombre): # "nombre" es un parámetro

print(f"¡Hola, {nombre}!")
saludar("Carlos") # "Carlos" es un argumento

📌 Explicación:

nombre es un parámetro que recibe un valor.

"Carlos" es el argumento que se pasa cuando se llama la función.

¿Qué significa que un parámetro "recibe un valor"?

Cuando una función es llamada, los argumentos proporcionan valores específicos que se

asignan a los parámetros definidos en la función.

✅ Ejemplo simple:

def duplicar(numero): # "numero" es el parámetro

return numero * 2 # "numero" recibe un valor al llamar la función

resultado = duplicar(5) # Aquí el argumento es 5

print(resultado) # 10
📌 Explicación:

1️⃣ numero es el parámetro, una variable dentro de la función.

2️⃣ Al llamar duplicar(5), el argumento 5 se asigna al parámetro numero.

3️⃣ numero * 2 se evalúa como 5 * 2, devolviendo 10.

💡 En resumen:

🔹 El parámetro actúa como un contenedor vacío.

🔹 El argumento proporciona el valor real en cada llamada.

💡 Resumen:

➡️Parámetro = variable dentro de la función.

➡️Argumento = dato real que se pasa al llamar la función.

Valores de retorno

Las funciones pueden devolver valores utilizando la palabra clave return. El valor de retorno

puede ser utilizado por el código que llama a la función.

def suma(a, b):

return a + b
resultado = suma(3, 4)

print(resultado) # Imprime 7

Funciones anónimas (lambda)

Python permite crear funciones anónimas o funciones lambda, que son funciones sin nombre

definidas en una sola línea. Se utilizan comúnmente para funciones pequeñas y concisas.

cuadrado = lambda x: x ** 2

print(cuadrado(5)) # Imprime 25

Alcance de las variables (local vs. global)

Las variables definidas dentro de una función tienen un alcance local, lo que significa que solo

son accesibles dentro de la función. Por otro lado, las variables definidas fuera de cualquier

función tienen un alcance global y pueden ser accedidas desde cualquier parte del programa.

def funcion():

variable_local = 10

print(variable_local) # Accesible dentro de la función

variable_global = 20
def funcion2():

print(variable_global) # Accesible desde cualquier lugar

funcion() # Imprime 10

funcion2() # Imprime 20

print(variable_global) # Imprime 20

print(variable_local) # Genera un error, la variable no está definida en este alcance.

Funciones definidas por el usuario

 Documentación de funciones (docstrings; docfun me inventé el nombre yo)

Es una buena práctica documentar nuestras funciones utilizando docstrings. Los docstrings son

cadenas de texto que describen el propósito, los parámetros y el valor de retorno de una

función. Se colocan inmediatamente después de la definición de la función y se encierran entre

triples comillas dobles.

def area_rectangulo(base, altura):

"""

Calcula el área de un rectángulo.

 Args:

base (float): La base del rectángulo.

altura (float): La altura del rectángulo.

Returns:

float: El área del rectángulo.

"""

return base * altura

 Funciones con número variable de argumentos

Python permite definir funciones que acepten un número variable de argumentos. Esto se logra

utilizando el operador * antes del nombre del parámetro.

def suma_variable(*numeros):

total = 0

for numero in numeros:

total += numero

return total
print(suma_variable(1, 2, 3)) # Imprime 6

print(suma_variable(4, 5, 6, 7)) # Imprime 22

Las funciones son una herramienta fundamental en la programación y nos permiten estructurar

y modularizar nuestro código. Con la capacidad de definir funciones personalizadas, podemos

encapsular tareas específicas y reutilizarlas en diferentes partes de nuestro programa.

Además de las funciones definidas por el usuario, Python también proporciona una amplia

gama de funciones incorporadas que podemos utilizar directamente, como print(), len(),

range(), entre otras.

Funciones en Python

Las funciones son bloques de código reutilizables que permiten estructurar mejor los

programas, evitando la repetición de código y facilitando su mantenimiento.

🔹 1. Definir una función

En Python, las funciones se definen con la palabra clave def, seguida del nombre de la función

y paréntesis ().

def saludar():

print("¡Hola, Mundo!")
📌 Explicación:

def → Define la función.

saludar → Nombre de la función.

() → Paréntesis donde se pueden definir parámetros.

print("¡Hola, Mundo!") → Acción que ejecutará la función.

🔹 Llamar a una función

Para ejecutar una función, simplemente se escribe su nombre seguido de paréntesis:

saludar() # ¡Hola, Mundo!

🔹 2. Funciones con parámetros

Las funciones pueden recibir valores llamados parámetros para personalizar su ejecución.
def saludar(nombre):

print(f"¡Hola, {nombre}!")

saludar("Juan") # ¡Hola, Juan!

📌 Explicación:

nombre es un parámetro, que se reemplaza con el valor "Juan" cuando se llama la función.

✅ Múltiples parámetros

def sumar(a, b):

return a + b # Devuelve la suma de a y b

resultado = sumar(5, 3)

print(resultado) # 8
📌 Explicación:

La función sumar toma dos valores (a y b) y devuelve su suma con return.

🔹 3. Parámetros con valores por defecto

Podemos definir valores predeterminados para los parámetros.

def saludar(nombre="Invitado"):

print(f"¡Hola, {nombre}!")

saludar() # ¡Hola, Invitado!

saludar("Carlos") # ¡Hola, Carlos!

📌 Explicación:
 Si no se pasa un valor, se usa "Invitado" como predeterminado.

🔹 4. Funciones con retorno de valores

Una función puede devolver un valor con return, lo que permite almacenar y reutilizar el

resultado.

def cuadrado(numero):

return numero ** 2

resultado = cuadrado(4)

print(resultado) # 16

📌 Explicación:

return devuelve el resultado de numero ** 2.

resultado almacena el valor devuelto (16).

🔹 5. Funciones con múltiples valores de retorno

Podemos devolver más de un valor usando tuplas.

def operaciones(a, b):

suma = a + b

resta = a - b

return suma, resta

resultado_suma, resultado_resta = operaciones(10, 5)

print(resultado_suma) # 15

print(resultado_resta) # 5

📌 Explicación:

Se devuelve una tupla con dos valores: (suma, resta).

Se desempaquetan los valores en resultado_suma y resultado_resta.

🔹 6. Funciones con argumentos variables (*args y **kwargs)

✅ *args (argumentos posicionales variables)

Permite pasar un número indefinido de argumentos a una función.

def sumar_todos(*numeros):

return sum(numeros)

print(sumar_todos(1, 2, 3, 4, 5)) # 15

📌 Explicación:

*numeros almacena múltiples valores en una tupla.

sum(numeros) suma todos los valores.

✅ **kwargs (argumentos nombrados variables)

Permite recibir argumentos con nombres clave-valor en forma de diccionario.

def mostrar_info(**datos):

for clave, valor in datos.items():

print(f"{clave}: {valor}")

mostrar_info(nombre="Ana", edad=25, ciudad="Madrid")

📌 Explicación:

**datos almacena pares clave-valor como un diccionario.

datos.items() permite recorrer el diccionario.

🔹 7. Funciones anónimas (lambda)

Las funciones lambda permiten definir funciones pequeñas en una sola línea.
doble = lambda x: x * 2

print(doble(5)) # 10

📌 Explicación:

lambda x: x * 2 es equivalente a def doble(x): return x * 2.

Son útiles en funciones que requieren parámetros como map(), filter(), sorted().

Ejemplo con map() para duplicar elementos de una lista:

numeros = [1, 2, 3, 4]

resultado = list(map(lambda x: x * 2, numeros))

print(resultado) # [2, 4, 6, 8]

🔹 8. Ámbito de variables (global y local)

Las variables dentro de una función son locales y no afectan variables externas.

def prueba():

x = 10 # Variable local

print(x)

prueba()

# print(x) # ERROR: x no existe fuera de la función

✅ Usando global para modificar una variable externa

contador = 0

def incrementar():

global contador

contador += 1

incrementar()
print(contador) # 1

📌 Explicación:

global contador indica que estamos modificando la variable externa.

🔹 9. Documentación de funciones (docstrings)

Se pueden agregar comentarios dentro de las funciones para documentarlas.

def sumar(a, b):

"""Esta función devuelve la suma de dos números."""

return a + b

print(sumar.__doc__) # Muestra la documentación

🔹 10. Funciones recursivas

Una función recursiva es aquella que se llama a sí misma.

Ejemplo: cálculo del factorial de un número (n!):

def factorial(n):

if n == 0 or n == 1:

return 1

return n * factorial(n - 1)

print(factorial(5)) # 120

📌 Explicación:

factorial(5) = 5 * factorial(4), que a su vez es 4 * factorial(3), y así sucesivamente hasta

factorial(1).

📌 Conclusión
Las funciones en Python son esenciales para organizar código y evitar repeticiones. Pueden

recibir parámetros, devolver valores, y manejar argumentos dinámicos con *args y **kwargs.

Además, se pueden crear funciones anónimas con lambda y documentarlas con docstrings.

💡 ¿Te gustaría ejemplos más avanzados o aplicados a ventas y análisis de datos? 😊

Dijiste:

qué quiere decir llamar una función?

ChatGPT dijo:

Dijiste:

se llama la función.

qué quiere decir "se llama la función"?

ChatGPT dijo:

📌 ¿Qué significa "llamar una función" en Python?

Llamar a una función significa ejecutarla para que realice su tarea. Cuando definimos una

función, solo estamos creando un bloque de código que se puede reutilizar, pero la función no

se ejecuta automáticamente. Para que se ejecute, debemos "llamarla" usando su nombre seguido

de paréntesis ().

🔹 Ejemplo de definición y llamada de función

def saludar(): # Definimos la función

print("¡Hola, Mundo!")

saludar() # Llamamos a la función

📌 Explicación:

1️⃣ def saludar(): → Se define la función, pero aún no se ejecuta.

2️⃣ saludar() → Aquí se llama la función, lo que hace que se ejecute el print("¡Hola,

Mundo!").

📌 Salida en pantalla:
¡Hola, Mundo!

🔹 Llamar una función con parámetros

Si una función tiene parámetros, debemos proporcionar valores al llamarla.

def saludar(nombre):

print(f"¡Hola, {nombre}!")

saludar("Carlos") # Se llama la función pasando "Carlos"

📌 Explicación:

saludar("Carlos") → Llama a la función saludar con el valor "Carlos", lo que imprime

"¡Hola, Carlos!".

📌 Salida en pantalla:
¡Hola, Carlos!

🔹 Llamar una función que devuelve un valor

Si una función usa return, podemos guardar su resultado en una variable al llamarla.

def sumar(a, b):

return a + b # Devuelve la suma

resultado = sumar(5, 3) # Llamamos a la función y guardamos el resultado

print(resultado) # 8

📌 Explicación:

sumar(5, 3) → Llama a la función con a=5 y b=3, y devuelve 8.

resultado = sumar(5, 3) → Guarda el valor 8 en la variable resultado.

📌 Salida en pantalla:

📌 Resumen

🔹 Definir una función crea un bloque de código reutilizable.

🔹 Llamar a una función hace que ese código se ejecute.

🔹 Si la función tiene parámetros, se deben pasar valores al llamarla.

🔹 Si la función tiene return, se puede guardar su resultado.

💡 ¿Te gustaría más ejemplos prácticos o una explicación más sencilla? 😊

Dijiste:

recordar brevemente que "tupla" y "diccionario"

ChatGPT dijo:
📌 Recordatorio breve sobre Tuplas y Diccionarios en Python

🔹 Tupla (tuple)

Una tupla es una estructura de datos ordenada e inmutable, lo que significa que no se pueden

modificar sus elementos después de su creación. Se usa cuando queremos almacenar datos que

no deben cambiar.

✅ Ejemplo de tupla:

colores = ("rojo", "verde", "azul")

print(colores[0]) # rojo

📌 Características:

Se definen con paréntesis ().

No se pueden modificar después de su creación.

Se pueden recorrer con un for.

🔹 Diccionario (dict)

Un diccionario es una estructura de datos desordenada y mutable, que almacena pares clave-

valor. Se usa cuando necesitamos acceder a los valores mediante una clave en lugar de un

índice.

✅ Ejemplo de diccionario:

persona = {"nombre": "Ana", "edad": 30}

print(persona["nombre"]) # Ana

📌 Características:

Se definen con llaves {}.

Cada elemento tiene una clave y un valor ("nombre": "Ana").

Se pueden modificar, agregar o eliminar elementos.

Diferencias clave:
Característica Tupla (tuple) Diccionario (dict)
Estructura Lista ordenada de valores Pares clave-valor
Mutabilidad Inmutable Mutable

Manejo de errores y excepciones

Cuando escribimos programas, es común encontrarnos con situaciones inesperadas o errores

durante la ejecución. Python proporciona un mecanismo para manejar estos errores de manera

controlada utilizando el manejo de excepciones. Esto nos permite capturar y manejar errores

específicos sin que el programa se detenga abruptamente.

Errores comunes en Python

Antes de sumergirnos en el manejo de excepciones, veamos algunos errores comunes que

puedes encontrar en Python

Error de sintaxis (SyntaxError)

Ocurre cuando el código no sigue las reglas de sintaxis de Python, como olvidar dos puntos

después de una declaración de función o un bucle.

def mi_funcion() # Falta los dos puntos

print("Hola")

Error de nombre (NameError)

Ocurre cuando se hace referencia a una variable o función que no ha sido definida.
print(variable_no_definida)

Error de tipo (TypeError)

Ocurre cuando se realiza una operación con tipos de datos incompatibles, como intentar sumar

un número y una cadena.

resultado = 5 + "10"

Error de índice (IndexError)

Ocurre cuando se intenta acceder a un índice fuera del rango válido de una lista o secuencia.

lista = [1, 2, 3]

print(lista[3]) # El índice 3 está fuera del rango

Estos son solo algunos ejemplos de errores comunes. Cuando ocurre un error, Python genera

una excepción y muestra un mensaje de error que incluye el tipo de excepción y una

descripción del problema.

Manejo de excepciones
El manejo de excepciones nos permite capturar y manejar errores de manera controlada

utilizando las declaraciones try, except y opcionalmente finally.

Try

El bloque try contiene el código que puede generar una excepción. Si ocurre una excepción

dentro del bloque try, el flujo de ejecución se transfiere al bloque except correspondiente.

try:

# Código que puede generar una excepción

resultado = 10 / 0 # División por cero

print(resultado)

except ZeroDivisionError:

print("Error: División por cero")

Except

El bloque except especifica el tipo de excepción que se desea capturar y manejar. Puedes tener

múltiples bloques except para manejar diferentes tipos de excepciones.

try:

# Código que puede generar una excepción

resultado = 10 / 0 # División por cero

print(resultado)

except ZeroDivisionError:

print("Error: División por cero")

except ValueError:

print("Error: Valor inválido")

Finally

El bloque finally es opcional y se ejecuta siempre, independientemente de si ocurrió una

excepción o no. Se utiliza comúnmente para realizar tareas de limpieza o liberación de recursos.

try:

# Código que puede generar una excepción

archivo = open("archivo.txt", "r")

# Realizar operaciones con el archivo

except FileNotFoundError:

print("Error: Archivo no encontrado")

finally:

archivo.close() # Cerrar el archivo siempre, incluso si ocurre una excepción

Excepciones personalizadas
Además de las excepciones incorporadas en Python, también puedes crear tus propias

excepciones personalizadas. Esto es útil cuando deseas manejar situaciones específicas de tu

programa.

Para crear una excepción personalizada, debes crear una clase que herede de la clase base

Exception o de una de sus subclases.

def funcion():

# Código que puede generar una excepción personalizada

if condicion:

raise Exception("Descripción del error")

try:

funcion()

except Exception as e:

print(f"Error: {str(e)}")

En este ejemplo, se define una función llamada funcion(). Dentro de la función, se verifica una

condición y, si se cumple, se genera una excepción utilizando la declaración raise. En lugar de

crear una clase personalizada, se utiliza directamente la clase base Exception para generar la

excepción.
Luego, se utiliza un bloque try-except para capturar y manejar la excepción. La variable e se

utiliza para acceder a la descripción del error proporcionada al generar la excepción.

El manejo de errores y excepciones es una parte fundamental de la programación en Python. Te

permite manejar situaciones inesperadas de manera controlada y evitar que tu programa se

bloquee o se detenga abruptamente.

Cuando ocurre un error en tu código, Python genera una excepción. Al utilizar bloques try-

except, puedes capturar y manejar estas excepciones de manera adecuada. Puedes especificar

diferentes bloques except para manejar distintos tipos de excepciones y realizar acciones

específicas en cada caso.

Además, el bloque finally te permite ejecutar código de limpieza o liberación de recursos,

independientemente de si ocurrió una excepción o no. Esto es útil para garantizar que ciertas

acciones se realicen siempre, como cerrar archivos o conexiones de base de datos.

 Importante

Considera los posibles errores que pueden ocurrir en tu código

y utiliza el manejo de excepciones adecuado para manejarlos

de manera apropiada. Esto hará que tus programas sean más

robustos y confiables.

Entradas/salidas
En Python, la entrada y salida de datos nos permite interactuar con el usuario y manipular

archivos. Podemos solicitar información al usuario, mostrar resultados en la pantalla y leer o

escribir datos en archivos externos.

Entrada de datos del usuario

Para obtener información del usuario durante la ejecución del programa, podemos utilizar la

función input(). Esta función muestra un mensaje en la pantalla y espera a que el usuario

ingrese un valor.

nombre = input("Ingresa tu nombre: ")

edad = input("Ingresa tu edad: ")

print("Hola, " + nombre + "!")

print("Tienes " + edad + " años.")

En este ejemplo, se solicita al usuario que ingrese su nombre y edad utilizando la función

input(). Los valores ingresados se almacenan en las variables nombre y edad, respectivamente.

Luego, se utilizan estas variables para mostrar un saludo personalizado en la pantalla.

Importante

La función input() siempre devuelve una cadena de texto.

Si deseas trabajar con otros tipos de datos, como números

enteros o flotantes, debes realizar una conversión explícita

utilizando funciones como int() o float().

edad = int(input("Ingresa tu edad: "))

if edad >= 18:

print("Eres mayor de edad.")

else:

print("Eres menor de edad.")

En este ejemplo, se solicita al usuario que ingrese su edad y se convierte el valor ingresado a un

número entero utilizando int(). Luego, se utiliza una estructura condicional para verificar si la

edad es mayor o igual a 18 y mostrar un mensaje correspondiente.

Salida de datos

Para mostrar información en la pantalla, utilizamos la función print(). Esta función toma uno o

más argumentos y los muestra en la consola.

Podemos utilizar la f-string (formateo de cadenas) para incrustar variables directamente dentro

de una cadena de texto.

nombre = "Juan"

edad = 25

print(f"Hola, mi nombre es {nombre} y tengo {edad} años.")

En este caso, las variables se incrustan dentro de la cadena utilizando llaves {} y se precede la

cadena con la letra f para indicar que es una f-string.

Lectura y escritura de archivos

Python nos permite leer y escribir datos en archivos externos. Podemos abrir archivos en

diferentes modos, como lectura ("r"), escritura ("w") o anexar ("a"), y realizar operaciones

de lectura y escritura.

Lectura de archivos

Para leer el contenido de un archivo, primero debemos abrirlo utilizando la función open() en

modo de lectura ("r"). Luego, podemos leer el contenido del archivo utilizando métodos

como read() o readlines().

archivo = open("datos.txt", "r")

contenido = archivo.read()

print(contenido)

archivo.close()

En este ejemplo, se abre el archivo "datos.txt" en modo de lectura utilizando open(). Luego, se

lee todo el contenido del archivo utilizando el método read() y se almacena en la variable

contenido. Finalmente, se muestra el contenido en la pantalla y se cierra el archivo utilizando el

método close().

Escritura de archivos
Para escribir datos en un archivo, lo abrimos en modo de escritura ("w") utilizando la función

open(). Si el archivo no existe, se creará automáticamente. Si el archivo ya existe, su contenido

se sobrescribirá.

archivo = open("datos.txt", "w")

archivo.write("Hola, mundo!")

archivo.close()

En este ejemplo, se abre el archivo "datos.txt" en modo de escritura utilizando open(). Luego,

se escribe la cadena "¡Hola, mundo!" en el archivo utilizando el método write(). Finalmente, se

cierra el archivo utilizando el método close().

Importante

Es importante cerrar siempre los archivos después de utilizarlos

para liberar los recursos del sistema.

También puedes utilizar la declaración with para manejar la apertura y cierre de archivos de

manera automática.
with open("datos.txt", "r") as archivo:

contenido = archivo.read()

print(contenido)

En este caso, el archivo se abre utilizando la declaración with y se cierra automáticamente una

vez que se sale del bloque with, incluso si ocurre una excepción.

La entrada y salida de datos en Python nos brinda una gran flexibilidad para interactuar con el

usuario y manipular archivos externos. Podemos solicitar información al usuario, mostrar

resultados en la pantalla y leer o escribir datos en archivos de texto. Recuerda siempre manejar

adecuadamente la apertura y cierre de archivos, y considerar las posibles excepciones que

pueden ocurrir durante las operaciones de entrada/salida.

Importación y creación de módulos

En Python, un módulo es un archivo que contiene definiciones de funciones, clases y variables

que se pueden utilizar en otros programas. La importación de módulos nos permite acceder a la

funcionalidad definida en otros archivos y reutilizar código de manera eficiente. Además,

podemos crear nuestros propios módulos para organizar y modularizar nuestro código.

Ten en cuenta
 Python viene con una amplia biblioteca estándar de

módulos que proporcionan funcionalidades adicionales.

Estos módulos están disponibles sin necesidad de instalarlos

por separado.

Importar módulos

Para utilizar un módulo en nuestro programa, debemos importarlo utilizando la declaración

import. Podemos importar un módulo completo o funciones específicas de un módulo.

import math

resultado = math.sqrt(25)

print(resultado) # Imprime 5.0

En este ejemplo, se importa el módulo math utilizando la declaración import. Luego, se utiliza

la función sqrt() del módulo math para calcular la raíz cuadrada de 25.

También podemos importar funciones específicas de un módulo utilizando la sintaxis from

módulo import función.

from math import sqrt

resultado = sqrt(25)

print(resultado) # Imprime 5.0

En este caso, se importa solo la función sqrt() del módulo math, lo que nos permite utilizarla

directamente sin tener que precederla con el nombre del módulo.

Funciones y clases de módulos estándar

La biblioteca estándar de Python ofrece una amplia gama de módulos con funciones y clases

útiles. Algunos ejemplos comunes incluyen:

MATH: Proporciona funciones matemáticas, como sqrt() (raíz cuadrada), sin() (seno), cos() (coseno), entre otras.

RANDOM: Ofrece funciones para generar números aleatorios, como random() (número aleatorio entre 0 y 1), randint()

(número entero aleatorio en un rango), entre otras.

DATATIME: Permite trabajar con fechas y horas, como datetime.now() (fecha y hora actual), datetime.date() (fecha),

datetime.time() (hora), entre otras.

import random

import datetime

numero_aleatorio = random.randint(1, 10)

print(numero_aleatorio) # Imprime un número entero aleatorio entre 1 y 10

fecha_actual = datetime.datetime.now()

print(fecha_actual) # Imprime la fecha y hora actual

Estos son solo algunos ejemplos de los muchos módulos disponibles en la biblioteca estándar de Python. Puedes

consultar la documentación oficial de Python para obtener más información sobre los módulos y sus funcionalidades.

Creación de módulos propios

Además de utilizar los módulos estándar de Python, también podemos crear nuestros propios módulos para organizar y

reutilizar nuestro código.

Crear y utilizar módulos personalizados

Para crear un módulo personalizado, simplemente creamos un nuevo archivo Python con el nombre deseado y definimos

las funciones, clases y variables que queremos incluir en el módulo. Por ejemplo, creamos un archivo (en el mismo

directorio donde estamos ejecutando Python) llamado mi_modulo.py con el siguiente contenido:

#mi_modulo.py

def saludar(nombre):

print(f"Hola, {nombre}!")

def calcular_suma(a, b):

return a + b

Luego, podemos importar y utilizar las funciones definidas en mi_modulo.py en otro archivo Python.
import mi_modulo

mi_modulo.saludar("Juan") # Imprime "Hola, Juan!"

resultado = mi_modulo.calcular_suma(5, 3)

print(resultado) # Imprime 8

En este ejemplo, se importa el módulo mi_modulo y se utilizan las funciones saludar() y calcular_suma() definidas en él.

Organización del código en módulos separados

A medida que nuestros programas crecen en tamaño y complejidad, es una buena práctica organizar nuestro código en

módulos separados según su funcionalidad. Esto nos permite conservar un código más legible, agrupado en módulos y

fácil de mantener.

Por ejemplo, podemos tener un módulo operaciones.py que contenga funciones relacionadas con operaciones

matemáticas, y otro módulo utilidades.py que contenga funciones de uso general.

# operaciones.py

def sumar(a, b):

return a + b

def restar(a, b):

return a - b

# utilidades.py
def imprimir_mensaje(mensaje):

print(mensaje)

def obtener_nombre_usuario():

return input("Ingresa tu nombre: ")

Luego, podemos importar y utilizar estas funciones en nuestro programa principal.

import operaciones

import utilidades

resultado = operaciones.sumar(5, 3)

utilidades.imprimir_mensaje(f"El resultado de la suma es: {resultado}")

nombre = utilidades.obtener_nombre_usuario()

utilidades.imprimir_mensaje(f"Hola, {nombre}!")

Al organizar nuestro código en módulos, podemos reutilizar funciones y mantener un código más estructurado y

agrupado en módulos.

Paquetes
Un paquete es una forma de organizar módulos relacionados en una estructura jerárquica de directorios. Los paquetes

nos permiten agrupar módulos relacionados y evitar conflictos de nombres entre módulos.
Crear y utilizar paquetes

Para crear un paquete, creamos un directorio con el nombre deseado y agregamos un archivo especial llamado

__init__.py dentro del directorio. Este archivo puede estar vacío o contener código de inicialización del paquete.

Por ejemplo, creamos un directorio llamado mi_paquete con la siguiente estructura:

mi_paquete/

__init__.py

modulo1.py

modulo2.py

Luego, podemos importar y utilizar los módulos del paquete en nuestro programa.

from mi_paquete import modulo1, modulo2

modulo1.funcion1()

modulo2.funcion2()

En este ejemplo, se importan los módulos modulo1 y modulo2 del paquete mi_paquete y se utilizan las funciones

definidas en ellos.

La importación y creación de módulos y paquetes en Python nos permite organizar y reutilizar nuestro código de

manera eficiente. Al modularizar nuestro código, podemos mantener un código más legible, estructurado y fácil de

mantener.

Recuerda explorar la biblioteca estándar de Python y aprovechar los módulos existentes, que pueden facilitarte muchas

tareas comunes. Además, no dudes en crear tus propios módulos y paquetes para organizar y reutilizar tu código de

manera efectiva.