Clase N° 1 | Conceptos básicos

Temario:
●​ Introducción al curso: duración, objetivos, metodología, evaluación.
●​ Lenguajes de programación
●​ Concepto de algoritmo. Entrada-Proceso-Salida.
●​ Estrategias para la resolución de problemas.
●​ Introducción a Python: Origen, características del lenguaje, campo de aplicación.
●​ Instalación y configuración del entorno de desarrollo (Visual Studio Code + Python).
●​ Interfaz de Visual Studio Code.
●​ "Hola Mundo" en Python.

Objetivos de la clase
El principal objetivo de esta primera clase es proporcionar a los estudiantes una
introducción al curso y al entorno de programación, sentando las bases conceptuales y
prácticas para el aprendizaje de Python. Durante la clase, se busca que las y los
estudiantes comprendan qué es la programación y su importancia en el contexto actual,
además de familiarizarse con el concepto de algoritmos y el modelo Entrada-Proceso-Salida
como herramientas fundamentales para resolver problemas.

Adicionalmente, aprenderán a configurar su entorno de trabajo, instalando Python y Visual

Studio Code, dos herramientas esenciales que utilizarán a lo largo del curso. Como parte de
esta introducción, escribirán y ejecutarán su primer programa, el clásico "Hola, Mundo",
para asegurarse de que todo esté correctamente instalado y funcionando. Este ejercicio
inicial tiene como objetivo brindarles una primera experiencia práctica con Python,
fomentando su confianza y entusiasmo por el aprendizaje.
¡Talento Lab te está esperando!

Imaginá que recibís una invitación para participar en el proceso de selección de

Talento Lab una startup ubicada en Buenos Aires.​
¿Cuál sería el reto? Completar una pasantía de aprendizaje que pondrá a prueba
todas tus habilidades y aprendizaje. ​
A partir de este momento un equipo de expertos te guiarán en este emocionante
viaje.

¡Te damos la bienvenida a TechLab!

En TechLab, nuestra empresa de desarrollo de software, convertimos ideas en
herramientas digitales innovadoras y confiables, ofreciendo servicios de desarrollo
backend con un enfoque en la calidad y eficiencia. Nuestro compromiso es
desarrollar soluciones que optimicen procesos y potencien negocios, combinando
creatividad, tecnología de punta y un compromiso absoluto con la satisfacción de
nuestras y nuestros clientes. Tu éxito es nuestra prioridad, y nuestras soluciones
están diseñadas para marcar la diferencia.

Te presentamos al equipo de TechLab:

Luis Elena
Desarrollador Senior Desarrolladora Junior

Diego Sofía
Analista de Datos​ Especialista en UX/UI

Mariana
Gerente de Proyectos
¡Tu primer día en TechLab!
En TechLab, recibimos un nuevo proyecto de
un cliente que requiere el desarrollo de una
aplicación en Python capaz de gestionar
información de clientes, productos y pedidos.
La solución deberá incluir funcionalidades para
registrar, consultar, actualizar y eliminar datos,
utilizando una base de datos SQLite integrada
con el programa.

​
¡Vamos de a poco!

​
Antes de encarar este nuevo proyecto debemos capacitarte con los conceptos
básicos de programación. Leé con atención lo que sigue…
¿Qué es la programación?
La programación es un proceso fascinante y esencial en el mundo de la tecnología,
definida como la práctica de escribir instrucciones para que una computadora realice tareas
específicas. Aunque a primera vista parece ser simplemente la escritura de un código, la
programación es mucho más. Representa una manera única de pensar y abordar
problemas, transformando ideas abstractas en aplicaciones concretas y funcionales. La
programación no sólo se trata de conocer lenguajes de programación y sintaxis; implica
también un enfoque lógico y creativo para solucionar problemas, optimizar procesos y crear
nuevas posibilidades dentro del mundo digital. Es un campo dinámico que requiere una
constante actualización de conocimientos y adaptación a nuevas tecnologías y paradigmas.

Código fuente de un programa informático.

El objetivo principal de la programación es desarrollar programas que lleven a cabo tareas

específicas. Estas tareas pueden variar desde simples operaciones matemáticas hasta la
gestión de complejos sistemas operativos y aplicaciones avanzadas.

Lenguajes de programación
Sin embargo, las computadoras no entienden el lenguaje humano sino que debemos
redactar las instrucciones que queramos que realicen de una forma especial. ¿Cómo?
Mediante los lenguajes de programación. Estos son herramientas fundamentales en el
desarrollo de software, actuando como puente entre las y los programadores y las
computadoras. Estos lenguajes permiten escribir instrucciones de manera comprensible,
que luego son convertidas en código que la computadora puede ejecutar. Existen
numerosos lenguajes de programación, cada uno con sus propias reglas de sintaxis y
aplicaciones particulares. Estos lenguajes son diseñados para facilitar la creación de
programas eficientes y efectivos, abarcando desde operaciones básicas hasta complejas
aplicaciones.

Cada lenguaje de programación tiene sus propias fortalezas y se elige en función de las
necesidades específicas del proyecto en desarrollo.

Algunos de los lenguajes más populares son:

 Python es reconocido por su simplicidad y versatilidad, lo que lo
convierte en un lenguaje ideal para aquellas personas que se inician en
la programación. Su sintaxis clara y directa, junto con una extensa
biblioteca de recursos, facilita el desarrollo rápido de aplicaciones
complejas. Podés utilizar Python en una amplia gama de aplicaciones,
desde el desarrollo web hasta la ciencia de datos y la inteligencia
artificial, ofreciendo una gran flexibilidad para abordar diversos
proyectos.

Java, por otro lado, es un lenguaje ampliamente utilizado en el

desarrollo de aplicaciones empresariales y sistemas móviles,
especialmente en la plataforma Android. Es valorado por su robustez y
portabilidad, así como por su capacidad para manejar grandes
cantidades de datos, lo que lo hace ideal para proyectos a gran escala.
La fiabilidad y el rendimiento de Java lo convierten en una opción
preferida para aplicaciones que requieren una base sólida y escalable.

Los lenguajes C y C++ son conocidos por su eficiencia y su capacidad para

interactuar de manera cercana con el hardware. Estos lenguajes se utilizan
comúnmente en el desarrollo de sistemas operativos, juegos y otras
aplicaciones donde el rendimiento es crítico. La gestión detallada de los
recursos del sistema que permiten C y C++ es esencial en situaciones
donde la eficiencia y la velocidad son prioritarias.

Existen cientos de lenguajes de programación más, algunos muy populares como

JavaScript o los mencionados anteriormente y otros prácticamente desconocidos. Pero
todos cumplen la misma función: permitir la creación de programas que serán ejecutados
por una computadora.

Algoritmos
¿Cómo diseñaremos las instrucciones a seguir por la computadora? Por medio de un
algoritmo: se trata básicamente de una serie de pasos lógicos y ordenados que permiten
resolver un problema o realizar una tarea específica. Podés imaginarlo como una receta de
cocina: tenés ingredientes, seguís una secuencia de instrucciones y al final obtenés un plato
preparado.
El modelo de Entrada-Proceso-Salida nos ayuda a estructurar ese algoritmo de una
manera más clara:

1.​ Entrada: Son los datos o información que necesitamos para empezar. Por ejemplo,
si queremos calcular el área de un rectángulo, las entradas serían el ancho y el alto.
2.​ Proceso: Es donde ocurre el "trabajo". Aquí aplicamos operaciones o cálculos sobre
los datos de entrada. Siguiendo el ejemplo, multiplicarías el ancho por el alto para
obtener el área.
3.​ Salida: Es el resultado final después de procesar los datos. En este caso, el área
calculada del rectángulo.

Entender este modelo es fundamental porque nos permite planificar y estructurar nuestros
programas de manera lógica y eficiente. Cada vez que nos enfrentamos a un problema,
podemos descomponerlo en estas tres partes para encontrar la solución más adecuada.

Por ejemplo, cuando en TechLab necesitamos procesar datos de clientes, primero

identificamos qué información necesitamos (Entrada), luego definimos cómo vamos a
procesar esa información (Proceso) y finalmente determinamos qué resultados o reportes
queremos obtener (Salida).

En varias ocasiones en TechLab debemos generar aplicaciones que sólo deben poder
utilizar personas mayores de edad. ¿Podés imaginar cómo se vería el algoritmo de un
programa que resuelva este problema? Veamos cómo aplicamos el modelo de
Entrada-Proceso-Salida en este caso.

Entrada:

●​ La usuaria o usuario ingresa su edad en años.

Proceso:

●​ El programa compara la edad ingresada con el número 18.

●​ Si la edad es mayor o igual a 18, se considera mayor de edad.
●​ Si la edad es menor a 18, se considera menor de edad.
Salida:

●​ El programa muestra un mensaje indicando si la persona es mayor o menor de

edad.

Ahora, detallando los pasos del algoritmo:

1.​ Pedir que se ingrese su edad.

2.​ Capturar y almacenar el valor ingresado.
3.​ Comparar la edad con 18:
○​ Si la edad es mayor o igual a 18:
■​ Mostrar el mensaje "Sos mayor de edad."
○​ De lo contrario:
■​ Mostrar el mensaje "Sos menor de edad."

Este ejemplo es sencillo pero nos sirve para que veas cómo estructuramos un algoritmo.
Descomponemos el problema en pasos lógicos que el programa puede seguir para llegar a
una solución. Además, este tipo de lógica es muy común en desarrollo de software, ya que
frecuentemente necesitamos tomar decisiones basadas en la información que recibimos del
usuario o usuaria.

Características de los algoritmos

1.​ Claridad y precisión:
○​ Un algoritmo debe ser detallado y comprensible, evitando
ambigüedades y asegurando la correcta ejecución de cada paso.
2.​ Finitud:
○​ Debe concluir después de un número determinado de pasos, evitando
bucles infinitos o procesos sin fin.
3.​ Definición y estructura:
○​ Cada paso y su secuencia deben estar claramente definidos y bien
organizados.
4.​ Orden:
○​ El orden de los pasos es crucial, ya que determina la forma en que se
ejecutan las instrucciones para alcanzar el resultado deseado de
manera eficiente.
5.​ Efectividad:
○​ Un algoritmo debe ser capaz de resolver el problema planteado en un
tiempo razonable y con un uso adecuado de recursos.
 6.​ Generalidad:
○​ Un buen algoritmo debe aplicarse a un rango de problemas similares,
no solo a un caso específico.

Estas características hacen que los algoritmos sean herramientas poderosas en

diversas disciplinas, permitiendo la estructuración lógica de ideas y el desarrollo de
soluciones efectivas en programación, análisis de datos, inteligencia artificial y más.
Continuaremos trabajando pero, más adelante también, trabajaremos con Luis y el
equipo de desarrollo senior de TechLab para ver ejemplos más específicos en torno
a la aplicación de los algoritmos… ¡Vamos bien! Continuemos un poco más.

Representación de algoritmos.
La representación de algoritmos se puede realizar de diversas maneras: cada una
adecuada para diferentes etapas del desarrollo o para diferentes públicos. Las tres formas
más comunes son los diagramas de flujo, el pseudocódigo y el código fuente.

Diagramas de flujo: Son representaciones gráficas de los pasos de un algoritmo. Utilizan

símbolos estándar para representar diferentes tipos de instrucciones o acciones, como
operaciones de entrada/salida, decisiones y procesos. Son especialmente útiles para
visualizar el flujo lógico de un algoritmo y son ideales para explicar procesos complejos de
manera sencilla y clara. En el siguiente ejemplo vemos cómo cocinar un huevo se grafica
por medio del diagrama:

Diagrama de flujo.

Pseudocódigo: Es una forma de escribir algoritmos que utiliza un lenguaje cercano al

natural con algunas estructuras de lenguajes de programación. No sigue la sintaxis estricta
de ningún lenguaje específico, pero ayuda a planificar y estructurar el algoritmo de manera
clara y organizada. El pseudocódigo es un paso intermedio útil entre la formulación del
problema y la escritura del código fuente que luego interpretará el computador.

Algoritmo escrito en pseudocódigo

¡En TechLab te sugerimos que empieces por acá! Podés experimentar

escribiendo algoritmos en sitios como Gobstones

Código fuente: Es la representación de un algoritmo en un lenguaje de programación

específico. Aquí, el algoritmo se escribe siguiendo las reglas sintácticas y semánticas del
lenguaje elegido, como PSeInt, Python, Java o C++, entre otros. El código fuente es lo que
finalmente se ejecuta en una computadora.

Código fuente escrito en Python.

Cada una de estas representaciones tiene su propósito y su público objetivo. Mientras que
los diagramas de flujo y el pseudocódigo son excelentes para la enseñanza y la
planificación, el código fuente es necesario para la implementación efectiva de los
algoritmos en aplicaciones reales.
Introducción a Python

Python es un lenguaje de programación interpretado de alto nivel,

caracterizado por su énfasis en la simplicidad y legibilidad del código.
Creado a finales de 1989 por Guido van Rossum en el Centro para las
Matemáticas y la Informática (CWI) en los Países Bajos, Python se
concibió como un sucesor de un lenguaje anterior llamado ABC, capaz
de manejar excepciones y de interactuar con el sistema operativo
Amoeba.

La filosofía detrás de Python se centra en dos principios fundamentales: la legibilidad del

código y la simplicidad tanto en la escritura como en la lectura. Estos principios se
reflejan en el diseño del lenguaje, que promueve estructuras de código claras y un estilo de
programación que prioriza la facilidad de comprensión sobre la brevedad del código.
Esta filosofía se encapsula en el "Zen de Python", una colección de 19 aforismos que guían
el diseño del lenguaje.

Características claves de Python

Python se destaca por una serie de características que lo hacen accesible y poderoso tanto
para quienes recién comienzan a programar como para aquellas personas con más
experiencia.

1.​ Sintaxis clara y legible:

○​ Python tiene una sintaxis que se asemeja al lenguaje natural, lo que facilita la
escritura de código intuitivo y comprensible.
2.​ Tipado dinámico:
○​ Las variables (ya veremos qué son y cómo funcionan) en Python pueden
cambiar de tipo automáticamente según el valor asignado, eliminando la
necesidad de especificar el tipo de dato al declarar una variable.
3.​ Gestión de memoria automática:
○​ Python maneja automáticamente la reserva y liberación de memoria, lo que
reduce el riesgo de errores como fugas de memoria y simplifica el trabajo del
programador.
4.​ Extensa biblioteca estándar:
○​ Cuenta con una amplia gama de módulos y funciones predefinidas que
permiten realizar tareas comunes sin necesidad de escribir el código desde
cero, acelerando el desarrollo y garantizando soluciones robustas.
5.​ Lenguaje interpretado:
○​ El código de Python se ejecuta línea por línea, lo que facilita la depuración y
permite detectar y corregir errores en tiempo real.
 6.​ Multiplataforma:
○​ Los programas escritos en Python pueden ejecutarse en diferentes sistemas
operativos sin necesidad de modificaciones, lo que le confiere versatilidad y
accesibilidad.

Estas características hacen de Python un lenguaje altamente accesible y poderoso, tanto

para principiantes como para programadoras y programadores experimentados. ​
¡Es el lenguaje de programación más utilizado para el desarrollo de software en
TechLab!

Evolución y popularidad.

Desde su creación, Python ha experimentado un crecimiento constante en popularidad,

impulsado tanto por su facilidad de aprendizaje como por su poderosa funcionalidad. Su uso
abarca una amplia gama de aplicaciones, desde desarrollo web y automatización de tareas
hasta ciencia de datos, aprendizaje automático e inteligencia artificial. La adopción de
Python en la comunidad científica y de investigación ha sido particularmente notable,
gracias a su simplicidad y la disponibilidad de numerosas bibliotecas especializadas.

La comunidad de Python es una de las más activas y colaborativas en el mundo del

software libre y de código abierto. Con una amplia gama de conferencias, talleres y foros
dedicados a Python, las desarrolladoras y desarrolladores tienen muchas oportunidades
para aprender y contribuir al ecosistema de Python.

Python se distingue por ser un lenguaje que combina eficiencia, claridad y potencia,
ofreciendo un equilibrio ideal entre facilidad de aprendizaje y capacidad para realizar tareas
complejas. Su diseño orientado a mejorar la experiencia tanto de personas novatas como
experimentadas ha llevado a Python a ser uno de los lenguajes de programación más
enseñados en las universidades y más empleados en la industria hoy en día.
Instalación de Python
Tu primera tarea será instalar el intérprete Python desde su página oficial en tu
computadora de TechLab. ¡Veamos cómo!
●​ Ingresamos a Downloads y hacemos clic en el botón Download Python.
●​ Asegúrate de descargar la última versión (o como mínimo la versión 3.8.x).

Hacé clic acá para acceder a la página oficial de python

Procedemos con la instalación realizando los pasos típicos para instalar aplicaciones en
nuestro sistema operativo.

Si usás Windows, recordá instalar seleccionando la opción “Add [Link] to

PATH”.

Instalación de VSCode
Tu segunda tarea será instalar el entorno en el cual trabajarás en TechLab. ¿Sabías que
para escribir código utilizaremos un editor de texto llamado Visual Studio Code?
Lo descargamos desde su página oficial y seguimos los pasos necesarios para su
instalación, asegurándonos de crear un ícono de acceso en el escritorio o menú de nuestra
computadora. ¡Qué emoción!
 Hacé clic acá para acceder a la página oficial de VSCode

La pantalla principal de VSCode

El diseño de Visual Studio Code (VSCode) está dividido en cinco áreas principales:​

●​ Editor: Esta es la parte principal donde escribís tu código. Podés abrir varios
archivos al mismo tiempo y verlos en diferentes secciones, tanto vertical como
horizontalmente. Se parece bastante a la ventana de un navegador web y su
sistema de pestañas. Podés borrarlas, moverlas, abrir nuevas, etcétera.
●​ Barra lateral principal: En esta sección encontrarás varias herramientas que te
ayudan a trabajar en tu proyecto, como un explorador de archivos que te permite ver
y acceder a todos los archivos de tu proyecto. Este explorador es similar al
explorador de archivos que posee tu sistema operativo, pero está integrado en el
editor.
●​ Barra de estado: En la parte inferior de la ventana, una barra de estado muestra
información sobre tu proyecto y los archivos que estás editando, como el nombre del
archivo y el estado de [Link] la pierdas de vista: siempre hay información útil
en esa zona de VSCode.
●​ Barra lateral: Está ubicada en el lado izquierdo. Te permite cambiar entre diferentes
vistas y te muestra indicadores adicionales, como el número de cambios pendientes,
si tenemos compartido algún puerto de comunicaciones, etcétera. Quizás no nos sea
demasiado útil hasta dentro de un tiempo.
●​ Terminal: Este panel se encuentra en la parte inferior de la ventana, debajo del
editor. Muestra información adicional como resultados de pruebas, errores y
advertencias y una terminal integrada donde podés escribir comandos y ver el
 resultado de la ejecución de tus programas Python. Este panel es móvil, podés
ubicarlo a los lados izquierdo o derecho si preferís más espacio vertical en el editor.

Nuestra primera línea de código en VSCode

¡Tu primer programa en TechLab! Te queremos contar que escribir una línea de código en
VSCode es muy parecido a escribir texto en un procesador de textos, como Word o Google
Docs. Primero, necesitás abrir VS Code y, dentro de él, abrir un archivo donde quieras
escribir tu código. ​
​
No te olvides guardar el archivo luego de escribir tu código, es muy importante para no
perder tu trabajo. En VSCode, puedes hacer esto haciendo clic en el icono de guardar
(parece un disquete) en la parte superior de la ventana, o usando el atajo de teclado (Ctrl+S
en Windows o Cmd+S en Mac). También puedes activar la opción “Autoguardado” que
aparece en el menú “Archivo”, y VSCode se encargará de guardar por vos cada
modificación que hagas en el código.

Una vez que tu archivo esté abierto en VS Code, empezás a escribir código en el área
principal del editor. Hacé clic en el área donde quieras escribir y comenzá a tipear.

Primer programa en Python: "Hola, Mundo"

⚠️ ¡ATENCIÓN! ​
Mariana, la jefa de proyecto, nos pidió que te ayudemos a escribir tu primer programa para
acreditar lo que trabajamos hoy. Te dejamos una lista de los pasos a seguir para lograrlo.
¡Éxitos!

●​ Creá un nuevo archivo:

○​ Seleccioná en Archivo > Nuevo Archivo.
 ○​ Guardá el archivo como hola_mundo.py.
●​ Escribí el código exactamente de la siguiente manera:

print("¡Hola, Mundo!")

●​ Ejecutá el programa:
○​ Abrí la terminal integrada en VS Code (podés hacerlo con la tecla Ctrl+ñ o
Ctrl+Shift+).
○​ Asegurate de que la terminal esté en la carpeta correcta.
○​ Ejecutá el comando:

python hola_mundo.py

Si usás Linux, debés escribir “python3” en lugar de “python”:

python3 hola_mundo.py

●​ ¡Compartile tu resultado a Mariana!

¡Hola, Mundo!

Reflexión final
¡Felicitaciones por completar tu primer día! Ya lograste configurar tu entorno de desarrollo,
creado un proyecto y ejecutado tu primer programa. ¡No es poca cosa! Este es el primer
paso fundamental para el éxito de nuestro proyecto en TechLab, donde pronto
comenzaremos a construir soluciones más completas y útiles para satisfacer las
necesidades de nuestras y nuestros clientes. Clase a clase desarrollaremos más y más
herramientas que te ayuden a enfrentar los desafíos que vendrán. ​
¡Eso es todo por hoy!
Materiales y recursos adicionales:

UNIR Formación Profesional: Algoritmo: ¿qué es, para qué sirve, ejemplos de algoritmos y
cómo funciona
Cinco Noticias: Algoritmos cotidianos
Nate Gentile: ¿Cómo funciona una computadora y qué hace cada parte?
GCFAprendeLibre: |¿Qué es software y qué es hardware?
Sitio oficial de VSC: Visual Studio Code Online y Documentación de Visual Studio Code
[Link]: Python Online Compiler
El Blog de Aitana: Atajos de teclado en Visual Studio Code

Preguntas para reflexionar:

1.​ ¿Qué importancia creés que tienen los algoritmos en la resolución de problemas
cotidianos y cómo los podrías aplicar en situaciones fuera del ámbito de la
programación? ¿Qué ejemplos se te ocurren?
2.​ ¿Por qué considerás que Python es un lenguaje adecuado para iniciarte en la
programación? ¿Qué características de Python te resultaron más interesantes?
3.​ ¿Qué desafíos enfrentaste al configurar tu entorno de desarrollo y cómo los
superaste? ¡Contanos!

Ejercicio práctico:

Preparar tu computadora para trabajar con Python,, asegurando que todas las herramientas
estén correctamente instaladas y configuradas.

1.​ Instalación del IDE para la próxima clase:

○​ Objetivo: Asegurarte de que tenés instalado y configurado correctamente tu
IDE (Visual Studio Code).
○​ Tareas:
■​ Completá la instalación del IDE.
■​ Abrí el IDE y familiarízate con su interfaz.
■​ Asegurate que Python está correctamente integrado en el IDE.
2.​ Salida de texto por consola:
○​ Objetivo: Practicar la creación y ejecución de programas en Python.
○​ Tareas:
 ■​ Creá un nuevo archivo llamado [Link] y escribí un
programa que imprima una frase diferente a "Hola Mundo", por
ejemplo: "¡Bienvenides al mundo de Python!".
■​ Ejecutá el programa y verificá que el mensaje se muestre
correctamente en la consola

Código ejemplo:​

print("¡Bienvenides al mundo de Python!")

Próximos pasos
En la próxima capacitación de TechLab, vamos a dar un paso más en el desarrollo de
nuestras habilidades en Python. Aprenderemos cómo usar variables para almacenar
información, cómo interactuar con la usuaria o usuario mediante funciones como input() y
print() y cómo realizar operaciones aritméticas simples. Estos conceptos serán
fundamentales para empezar a construir programas más dinámicos y útiles.

Además, comenzaremos a trabajar con el modelo Entrada-Proceso-Salida de una manera

más práctica, aplicándolo para crear programas. Este será el primer paso para empezar a
manejar la información de manera estructurada, sentando las bases para lo que
desarrollaremos en los siguientes encuentros.

¡Nos vemos pronto para continuar avanzando!

Clase N° 2 | Variables y E/S de
datos
Temario:
●​ Variables y tipos de datos simples.
●​ Operador de asignación.
●​ Operadores aritméticos.
●​ Funciones print() e input().
●​ Conversión entre tipos de datos simples.
●​ Programas con entrada, procesamiento y salida de datos.

Objetivos de la clase

El objetivo principal de esta clase es introducir al grupo de estudiantes en el manejo de

variables, una herramienta fundamental para almacenar y gestionar información dentro de
un programa. Aprenderán a utilizar los tipos de datos básicos y el operador de asignación
para trabajar con información dinámica de manera eficiente.

Además, se presentarán las funciones print() e input(), esenciales para la interacción entre
el programa y quien lo utilice. A través de estas herramientas, comprenderán cómo
implementar el modelo Entrada-Proceso-Salida para crear programas simples y funcionales.

Finalmente, se explorará la conversión de tipos de datos, destacando su importancia para

asegurar que los programas puedan procesar la información correctamente. Estos
conceptos sentarán las bases para construir aplicaciones más complejas en las próximas
clases, aplicando lógica y estructura al desarrollo de software.

Cambia, todo cambia

¡Recibiste un correo de TechLab! Es un mensaje de Mariana, la Gerente de
Proyectos, que te recuerda que como parte del equipo necesitás aprender a
organizar y gestionar información con precisión. Por eso hoy habrá un proyecto
orientado específicamente al uso de las variables.
 Luis, que es desarrollador senior, te explica que una de tus
primeras tareas es registrar los datos de los y las clientes de
manera ordenada. Para eso, necesitas entender cómo almacenar
información (utilizando variables) y cómo mostrarla por pantalla. ​
​
Leé con atención lo que sigue…

Variables en Python

Variables en Python
El concepto de variable es uno de los pilares de la programación y es común a todos los
lenguajes por lo que entenderlo será fundamental para todas las personas que deseen
iniciarse en el desarrollo de software. Las mismas son centrales ya que nos permiten que
los programas sean dinámicos y flexibles. ¡Comencemos!

¿Qué es una variable?

En programación, una variable es como una "caja" donde podremos ingresar datos de
distinto tipo y origen. Es decir, se tratará de un contenedor en la memoria de tu
computadora donde almacenaremos datos temporales que tu programa pueda usar y
modificar mientras se ejecuta. Una variable es en resumidas cuentas un contenedor que
tiene una etiqueta con un nombre único; esta etiqueta te permite acceder al contenido de la
caja o cambiarlo.​
​
Por ejemplo, si yo estoy desarrollando la programación de un videojuego crearé o
“declararé” (en términos técnicos) la variable “puntos”, donde mi programa guardará los
puntos que cada equipo vaya acumulando. Esta misma variable (que guardará un tipo de
dato numérico) me servirá para, por ejemplo, finalizar el juego. Imaginemos que nuestro
videojuego es de volleyball, el pseudocódigo para ganar el set podría ser algo como: “si
puntos es igual a 25, entonces finalizar juego…”
¿Cómo funcionan las variables en Python?
En Python no necesitás declarar explícitamente el tipo de dato que una variable va a
almacenar (como números, texto, listas, etc.). Esto hace que trabajar con variables sea muy
fácil.

Veamos un ejemplo:

mensaje = "Hola, Mundo"

En este ejemplo, “mensaje” es una variable que contiene el texto "Hola, Mundo". El
operador de asignación en Python es el símbolo =: se utiliza para asignar un valor a una
variable. La forma en que funciona es bastante sencilla pero fundamental para casi
cualquier programa. La estructura básica de una asignación es:

Donde variable es el nombre de la variable que estás creando o actualizando, y valor es el

dato que deseas almacenar en dicha variable.

En el contexto de la programación, el significado del signo “=” (operador de

asignación) es diferente al significado que tiene en, por ejemplo, la matemática
(igualdad).

Formas de asignación.
Asignación única: Cada vez que usás el operador de asignación podés establecer o
cambiar el valor de una variable. Si la variable ya tiene un valor determinado, el mismo será
reemplazado por el nuevo valor asignado.

En el primer ejemplo, el número 30 se asigna a la variable edad. En el segundo ejemplo, la

cadena de caracteres "Juan" se asigna a la variable nombre:

edad = 30
nombre = "Juan"
Asignaciones múltiples: Python también permite la asignación múltiple, lo que te permite
asignar valores a varias variables en una sola línea de código. Veamos cómo se vería el
código de las asignaciones múltiples de varias variables:

x, y, z = 1, 2, 3

Aquí, x recibe el valor 1, y el valor 2, y z el valor 3.

Cambiando el valor de una variable

También podés modificar el valor actual de una variable. ¿Cómo? En el ejemplo siguiente,
se establece el valor de la variable contador a “0”. En la siguiente línea de código contador
recibe un nuevo valor, 1, por lo que el valor final de la variable será 1. Esto es útil para
actualizar el contenido de una variable cuando sea necesario:

contador = 0
contador = 1 # Actualiza el valor de contador a 1

El operador de asignación es crucial porque permite:

●​ Almacenar valores. Permite guardar valores para usarlos más tarde en tu

programa.
●​ Actualizar valores. Da lugar a cambios en los valores de las variables a medida que
tu programa se ejecuta, lo que es esencial para la lógica de programación dinámica
y los cálculos.

Además en Python, una variable puede comenzar almacenando un tipo de dato, como un
número, y luego cambiar para almacenar un tipo de dato diferente, como una cadena de
caracteres o una lista. Esto es posible gracias al tipado dinámico de Python. Por ejemplo:

dato = 100
dato = "Cien"
En este ejemplo, “dato” inicialmente almacena un valor numérico (100), pero luego cambia
para almacenar una cadena de caracteres ("Cien").

El operador de asignación = es esencial, porque te permite la manipulación y

gestión de datos dentro de un programa.

Nombres de las variables

Elegir nombres adecuados para las variables es super importante en la programación
porque mejora la legibilidad del código y facilita su mantenimiento. Al nombrar variables en
Python, hay varias reglas y buenas prácticas que te aconsejamos seguir para asegurarte de
que tu código sea claro y fácil de entender.

1.​ Caracteres permitidos: Los nombres de las variables pueden incluir letras
(mayúsculas y minúsculas), números y guiones bajos (_). Sin embargo, deben
comenzar con una letra o un guión bajo. Por ejemplo, _miVariable o miVariable son
válidos, pero 1miVariable no lo es.
2.​ Palabras reservadas: Python reserva un conjunto de palabras para su sintaxis y
estructura de lenguaje, conocidas como palabras reservadas. Estas no pueden ser
utilizadas como nombres de variables. Algunas de estas palabras incluyen if, for,
class, return, global, entre otras. Intentar usar una palabra reservada como nombre
de variable resultará en un error de sintaxis.
3.​ Sensibilidad a mayúsculas y minúsculas: Python diferencia entre mayúsculas y
minúsculas. Esto significa que variable, Variable y VARIABLE serían consideradas
tres variables distintas. Aunque técnicamente es posible tener variables con
nombres tan similares, esto no es recomendable ya que puede prestarse a la
confusión.

Buenas prácticas a la hora de nombrar tus variables:

Buenas prácticas a la hora de nombrar tus variables:
Elegir nombres adecuados para las variables es muy importante para escribir código que
sea claro y fácil de mantener. Una de las prácticas más recomendadas es usar nombres
significativos y descriptivos, ya que estos deben reflejar de manera clara los datos que
contienen. Por ejemplo, optar por edad o numero_de_edad en lugar de simplemente ‘e’ o ‘n’
hace que el código sea más legible y comprensible, no solo para quien lo escribe, sino
también para cualquier otra persona que trabaje con él en el futuro.
Cuando se trata de nombres largos, es común utilizar minúsculas y guiones bajos para
separar las palabras. Esta convención (conocida como snake_case), es la recomendada por
la guía de estilo de Python, PEP 8. Nombres como nombre_usuario o contador_intentos
son ejemplos de cómo esta práctica mejora la legibilidad del código.

Evita nombres cortos como “x” o “n", estos no proporcionan suficiente

información sobre el propósito o el tipo de datos que la variable contiene, lo que
puede dificultar la comprensión del código.

Además, en Python, el uso de un guión bajo (_) al principio del nombre de una variable,
como en _privado, tiene un significado especial. Esto refiere al alcance de la variable (o
método): significa que ésta es privada y está destinada para uso interno dentro de una
clase o módulo. Aunque Python no aplica esta privacidad de manera estricta, es una
convención ampliamente respetada entre las personas que desarrollan software.

Seguir estas reglas y buenas prácticas en la elección de nombres de variables

no sólo contribuye a la claridad del código, sino que también facilita su
mantenimiento y colaboración con colegas.

Tipos de datos simples en Python

Entender los tipos de datos es fundamental para manejar variables y realizar operaciones
eficientemente. Los tipos de datos determinan la clase de valor que una variable puede
almacenar, cómo se almacena ese valor en la memoria y las operaciones que son posibles
realizar con esos valores. Vamos a profundizar en los tipos de datos básicos en Python y
dejaremos para más adelante algunos tipos de datos más complejos.

1. Número entero (int)

Los enteros son números sin parte decimal, que pueden ser positivos o negativos. Python te
permite trabajar con ellos para realizar operaciones matemáticas básicas como suma, resta,
multiplicación y división, entre otras.

Ejemplos:

edad = 25
numero_de_estrellas = -100
años = 2023
Estos ejemplos muestran cómo asignar un número entero a una variable.

2. Número decimal (float)

Los números decimales o flotantes contienen una parte fraccionaria separada por un punto.
Son útiles para representar valores que requieren mayor precisión, como medidas o
cantidades financieras.
Ejemplos:

altura = 1.75
temperatura = -20.3
precio = 19.99
Cada ejemplo asigna un número decimal a una variable. Las operaciones con flotantes
siguen las reglas de la aritmética de punto flotante.

3. Cadena de caracteres (str)

Las cadenas de caracteres son secuencias de caracteres usadas para almacenar datos
textuales. Python las maneja con mucha flexibilidad, permitiendo operaciones como
concatenación, multiplicación y acceso a elementos individuales.

Ejemplos:

nombre = "Juan"
mensaje = "Hola, Mundo"
letra = 'A'

Aquí, nombre, mensaje y letra son variables que almacenan cadenas de texto.

4. Booleano (bool)
Los booleanos representan dos valores: Verdadero (True) y Falso (False). Como
comprobarás dentro de poco, son muy utilizados en estructuras de control.

Ejemplos:

es_mayor_de_edad = True
examen_aprobado = False
Los tipos de datos en Python son la base sobre la cual se construyen las estructuras de
datos y se realizan operaciones. Es importante que los conozcas y recuerdes, ya que van a
facilitar la manipulación de datos y la implementación de lógica compleja en los programas.
A medida que avances, trabajaremos con tipos de datos más complejos (como las listas y
diccionarios) y sus métodos asociados, lo que te permitirá construir programas más
potentes y eficientes.

Luis te envía esta tabla, que resume lo visto sobre tipos de datos simples:

Tipo de dato Abreviatura Descripción

Número int Los enteros son números sin parte decimal, que
entero pueden ser positivos o negativos.

Número con float Contienen una parte fraccionaria separada por un

decimales punto. Equivalen a los números racionales.

Cadena de str Son secuencias de caracteres usadas para almacenar

caracteres datos de texto, como nombres o descripciones.

Lógico o bool Sólo pueden almacenar uno de estos dos valores:

Booleano Verdadero (True) y Falso (False).

Entrada / Salida de datos:

La función print()
Una función es simplemente un conjunto de instrucciones que Python ya conoce y que
puede ejecutar cuando se lo pedís. Cuando usas print(), le estas diciendo a Python que
ejecute la función print. Podés pensar en una función como si fuese una receta, una serie
de pasos que te permiten lograr un resultado, como preparar un plato de comida. En
Python, las funciones hacen eso mismo: siguen una serie de pasos para realizar una tarea
específica.

Aunque aún no conocemos todos los detalles, la idea principal es que una función es algo
que puedes usar para realizar tareas en tu programa de manera sencilla. Dentro de poco
aprenderemos a crear nuestras propias funciones, pero por ahora, pensá en print() como un
ejemplo de cómo una función puede hacer que los programas sean útiles y poderosos.

La función print() es utilizada para imprimir datos en la terminal. Acepta múltiples valores
entre los paréntesis, los cuales pueden ser variables, literales (textos directos), o una
combinación de ambos separados por comas. Podés delimitar las cadenas de texto con
comillas simples (') o dobles ("), según prefieras. Por defecto, después de imprimir, print() se
añade un salto de línea, moviendo el cursor a la línea siguiente. Si se invoca print() sin
pasarle argumentos, simplemente imprimirá una línea en blanco.

Veamos las distintas posibilidades y cuáles serían sus resultantes o “salidas”:

nombre = "Mundo"
print("Hola,", nombre) # “Hola” y nombre son dos argumentos.
# Salida: Hola, Mundo

La línea de código de color verde, al final del código anterior, es un comentario. En Python,
los comentarios se crean utilizando el símbolo #. Cuando escribís “#” al comienzo de una
línea o en cualquier parte de ella, todo lo que sigue a la derecha del símbolo se considerará
un comentario. Python ignora cualquier texto que esté precedido por #, lo que significa que
esos comentarios no afectarán en absoluto el funcionamiento de tu código. Los comentarios
son útiles para dejar notas, explicar lo que hace una parte del código, o para desactivar
temporalmente una línea de código sin eliminarla. Por ejemplo, si deseás explicar qué hace
una sección específica de tu programa podés agregar un comentario justo encima de esa
sección o al final de la línea de código correspondiente. Es importante usar comentarios de
manera clara para que otras personas (o vos mismo en el futuro) puedan entender
fácilmente lo que el código está haciendo y el propósito detrás de ciertas decisiones. En
este caso, estamos usando los comentarios para indicar qué se mostrará en la terminal al
ejecutar el ejemplo propuesto.

Insertando nueva línea y tabulaciones

Si una cadena contiene los caracteres \n (Nueva línea), cuando print() muestre su contenido
en la pantalla insertará un salto de línea en ese punto:

print("Hola\nMundo")
# Salida:
# Hola
# Mundo

Y si la cadena contiene los caracteres \t (Tabulación), se añade una tabulación o un

conjunto fijo de espacios en blanco, algo útil para alinear texto:
print("Nombre:\tJuan\nEdad:\t30")
# Salida:
# Nombre: Juan
# Edad: 30

Consideraciones al usar \t
La tabulación (\t) inserta un número fijo de espacios, que puede variar según el entorno
donde se visualice el texto pero comúnmente equivale a 4 u 8 espacios. Su efectividad para
alinear texto depende de la longitud de las cadenas que lo preceden o siguen. Si las
cadenas son más largas o más cortas de lo esperado la alineación puede no ser la
deseada.

print("Producto\tPrecio")
print("Manzanas\t$ 1.00")
print("Peras\t\t$ 1.50")
# Salida:
# Producto Precio
# Manzanas $ 1.00
# Peras $ 1.50

Más adelante aprenderás otras maneras más efectivas y flexibles de dar formato a las
cadenas de texto.

Controlando el final de la línea con end

Si a print() le pasas un valor para end, le podés especificar qué se debe imprimir al final de
la cadena. Por defecto, end='\n', lo que significa que cada llamada a print() termina con un
salto de línea. Modificar este comportamiento te puede ser útil para imprimir algo más en la
misma línea o añadir un delimitador específico.

print("Hola,", end=' ')

print("Mundo")
# Salida: Hola, Mundo

La función print() es una de las herramientas más básicas y poderosas en Python, y es

esencial para la salida de nuestros datos. A través de end y la utilización de caracteres
especiales como \n y \t, podés tener un control detallado sobre cómo se formatea y
presenta la información en la pantalla.

La función input()

Esta función es una herramienta interactiva que permite a los programas utilizar datos
introducidos por el la persona que usa el programa a través del teclado. Cuando se
ejecuta, input() pausa la ejecución del programa y espera que la persona escriba algo,
devolviendo o “retornando” lo escrito como una cadena de caracteres (string) luego de que
se presione “enter”. Este mecanismo es indispensable para crear aplicaciones interactivas
que requieren la participación de nuestra persona usuaria. Input() tiene los siguientes
propósitos:

1.​ Interacción: recoger información de quien utiliza la aplicación, como su nombre,

preferencias, comandos, entre otros.
2.​ Control de flujo de programas: basar la lógica del programa en las decisiones de
quien interactúa con el mismo.
3.​ Entrada de datos para procesamiento: obtener números, cadenas de caracteres o
cualquier dato que necesite ser procesado posteriormente para su utilización.

Sintaxis básica
La sintaxis básica de input() es:

variable = input(prompt)

donde prompt es un string, una cadena de caracteres, que se muestra en la consola

indicando al usuario qué debe introducir. Recordamos que este último parámetro es
opcional. En el siguiente ejemplo, el prompt dirá: “Introduce tu nombre: “

Solicitar un nombre:

nombre = input("Introduce tu nombre: ")

print("Hola", nombre)

Este código pedirá a quien interactúe con él que introduzca su nombre y luego le saludará
personalmente. Si alguien introduce el nombre “Mariana”, se imprimirá: “Hola, Mariana”.
Pero no te olvides de algo fundamental: input() siempre devuelve cadenas de caracteres.
Si necesitamos que la persona introduzca un tipo de dato diferente, como por ejemplo un
número entero, necesitamos utilizar las funciones de conversión de tipos de datos.

Conversión entre tipos de datos

La conversión de tipos de datos, también conocida como casting, es una operación común
que consiste en transformar un valor de un tipo de dato a otro, como de un entero (int) a un
flotante (float), o de un número a una cadena de caracteres (str).

Conversión entre números enteros y números decimales

Podés convertir valores entre enteros y decimales para realizar operaciones aritméticas que
requieren precisión decimal o simplemente para cambiar la representación de un número.
Veamos cómo:

Ejemplo de int a float

entero = 10
decimal = float(entero)
print(decimal) # 10.0

En este caso float(entero) utiliza la función float para convertir el número entero 10 a un
número decimal 10.0.

Ejemplo de float a int

decimal = 3.14
entero = int(decimal)
print(entero) # 3

En el ejemplo precedente observamos el mismo caso a la inversa: int(decimal) convierte el

número decimal 3.14 a un número entero 3, descartando cualquier valor después del punto
decimal.
Conversión de números a cadenas de caracteres y viceversa

La conversión de números a cadenas de caracteres es útil para concatenar números con

texto, mientras que convertir cadenas de caracteres a números es necesario para realizar
operaciones matemáticas con datos que originalmente se ingresaron con input() o se
proporcionaron como texto.

Ejemplo de int a str:

edad = 25
mensaje = "Tengo " + str(edad) + " años."
print(mensaje) # Tengo 25 años.

Como podés ver, str(edad) convierte el número entero 25 a una cadena de caracteres "25",
permitiendo su concatenación con otras cadenas de caracteres. Si bien pareciera decir lo
mismo en ambos casos, recordá que lo importante es cómo interpreta Python el valor 25.
Al comenzar edad es un número entero y al finalizar es una cadena de caracteres.

Ejemplo de str a int:

cadena_numerica = "123"
numero = int(cadena_numerica)
print(numero + 7) # 130

En este caso int(cadena_numerica) convierte la cadena de caracteres "123" a un número

entero 123, permitiendo realizar operaciones matemáticas como la adición o suma.

Conversión entre booleanos y otros tipos de datos

Los booleanos también se pueden convertir a otros tipos de datos, y viceversa,

dependiendo de las necesidades lógicas del programa. Las expresiones booleanas pueden
ser traducidas a 1 (verdadero) y 0 (falso).

Ejemplo de bool a int:

valor_verdadero = True
valor_falso = False
print(int(valor_verdadero)) # 1
print(int(valor_falso)) # 0

Aquí, True se convierte a 1 y False a 0, lo cual es muy útil en cálculos que dependen de
condiciones lógicas.

Ejemplo de int a bool:

numero = 0
print(bool(numero)) # False
numero = 5
print(bool(numero)) # True

Cualquier número distinto de 0 se convertirá a True en una conversión a

booleano, mientras que 0 se convierte a False.

La conversión de tipos de datos es una herramienta poderosa en Python que permite

manipular la información de manera más flexible. Luis, que sigue con atención tus avances,
te alcanzar un resumen de las funciones que seguramente vas a usar todos los días:

Función Tipos de Descripción

datos
aceptados

int() float, str (si Convierte un valor en un número entero. Si el valor es

representa un un número decimal, lo trunca (sin redondear).
número), bool

float() int, str (si Convierte un valor en un número decimal (float).​

representa un
número), bool
 str() int, float, bool Convierte un valor en una cadena de texto (str).

bool() Cualquier tipo Convierte un valor en un booleano (True o False).

de dato

La función type()

Esta función es una herramienta de desarrollo retorna el tipo de dato consultado. ¿Cómo
funciona? Veámoslo con un ejemplo: Imaginate que necesitás saber cómo está
interpretando Python un dato. Para resolverlo le solicitás que imprima el tipo de dato de la
variable “numero”, es decir que nos devuelve su “clase” (<class>), asignando su nombre
como argumento. Se imprimirá “<class ‘int’>”, detectando qué tipo de dato es el objeto
“numero”: un entero. Esto incluye tipos de datos integrados como enteros, flotantes,
cadenas de texto, listas, diccionarios, y más. Veamos algunos otros ejemplos para ilustrar
cómo se utiliza type() verificando el tipo de datos básicos.

numero = 42
print(type(numero)) # <class 'int'>

precio = 19.99
print(type(precio)) # <class 'float'>

mensaje = "Hola, Mundo"

print(type(mensaje)) # <class 'str'>

esMayorDeEdad = True
print(type(esMayorDeEdad)) # <class 'bool'>

Cada llamada a type() te devuelve el tipo del valor asignado a la variable: int para enteros,
float para flotantes, str para cadenas de texto y bool para booleanos.

Solicitar un número con input():

Retomando, vimos que que input() devuelve un string, así que si necesitas tratar ese valor
como un número, primero tenés que convertirla al tipo de dato adecuado, ya sea int o float:
edad = input("Introduce tu edad: ")
edad = int(edad)
print("El próximo año tendrás" ,edad + 1, "años.")

¡Epa! ¿Qué hace ese “edad + 1” dentro del print()? En realidad, es bastante intuitivo: le
suma 1 al valor que tenga la variable edad. Algo que sólo se puede hacer si “edad” es una
variable de tipo numérico. Ese “+” es un operador aritmético.

Los operadores.
Se trata de carácteres que actúan sobre una, dos o más variables y/o literales para llevar a
cabo una operación de alguna clase, devolviendo un resultado.

Operadores aritméticos
Dentro de los más comunes están los operadores aritméticos, que son los que utilizamos
habitualmente para realizar cuentas con números en nuestra vida diaria. Python posee los
mismos que encontramos en una calculadora electrónica y agrega algunos más. También
podemos encontrar los operadores lógicos y los relacionales, que analizaremos más
adelante.
Los operadores aritméticos son fundamentales para realizar cálculos en cualquier programa
de Python, y permiten sumar, restar, multiplicar, dividir y mucho más. A continuación,
analizaremos cada uno de ellos con ejemplos:

Suma (+): Suma dos valores.

resultado = 5 + 3 # resultado = 8

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

resultado = 5 - 3 # resultado = 2

Multiplicación (*): Multiplica dos valores.

resultado = 5 * 3 # resultado = 15

División (/): Divide el primer valor entre el segundo.

resultado = 6 / 3 # resultado = 2.0

Esta operación siempre retorna un número flotante (float), incluso si el

resultado es un entero.

División entera (//): Divide el primer valor entre el segundo y redondea el resultado hacia
abajo para obtener un número entero (int).

resultado = 7 // 3 # resultado = 2

Módulo (%): Retorna o devuelve el sobrante de la división entre el primer y segundo valor.

resultado = 7 % 3 # resultado = 1

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

resultado = 2 ** 3 # resultado = 8

Ejercicio práctico.
Luego de haber aprendido qué son y cómo se utilizan las variables y cómo podés
interactuar con una persona a través de la terminal, ya podés resolver la tarea que
mencionaron Luis y Mariana. En su siguiente correo, ella te da detalles de lo que necesita
que hagas:
 ¡Hola!

En nuestro día a día, interactuamos con muchos clientes, y

uno de los pasos iniciales es recopilar y organizar su
información básica. Para eso, necesito que desarrolles un
pequeño programa en Python que haga lo siguiente:

●​ Solicite al cliente su nombre, apellido, edad y correo electrónico.

●​ Almacene estos datos en variables.
●​ Los muestre organizados en forma de una tarjeta de presentación en la
pantalla.

¡Espero ver el resultado de tu trabajo pronto!

Saludos,
Mariana”

Materiales y recursos adicionales:

El Pythonista: Variables en Python

Oregoom: Tipos de datos en Python
Tutoriales sobre ciencia y tecnología: Variables, tipos de datos, operadores aritméticos e
ingreso de datos en Python
Píldoras informáticas: Curso de Python |

Preguntas para reflexionar:

1.​ ¿Qué relación encontrás entre las variables y el modo en que organizamos
información en nuestra vida diaria?
2.​ ¿Por qué es fundamental elegir nombres descriptivos para las variables y qué
impacto tiene esto en la legibilidad del código?
Próximos pasos:
En la próxima clase, vamos a dar un salto importante en la construcción de programas
interactivos y funcionales. Aprenderemos cómo usar estructuras condicionales como if y
else, que nos permitirán tomar decisiones dentro de nuestros programas en función de los
datos ingresados. Estas herramientas son esenciales para validar la información y hacer
que nuestras aplicaciones sean más robustas y seguras.

Trabajaremos también con operadores lógicos y relacionales, lo que nos permitirá

realizar comparaciones y establecer condiciones más complejas. Además, comenzaremos a
incorporar comentarios en el código, una práctica fundamental para organizar y
documentar nuestro trabajo.

Estos conceptos serán aplicados para mejorar el programa que creaste hoy, validando que
los datos ingresados sean correctos y clasificando la información según las necesidades de
los usuarios y usuarias. Este es un paso clave hacia la creación de programas más
inteligentes y prácticos. ¡Nos vemos en la próxima clase!
Clase N° 3 | Condicionales I
Temario:
●​ Operadores lógicos y relacionales.
●​ Control de flujo: estructuras condicionales if y else.
●​ Comentarios en el código.

Objetivos de la clase
El principal objetivo de esta clase es introducir a las y los estudiantes en el uso de
estructuras condicionales en Python, herramientas clave para tomar decisiones dentro de
un programa. A través de la implementación de los bloques if y else, los estudiantes
aprenderán a controlar el flujo de ejecución según las condiciones definidas.

Además, se presentarán los operadores lógicos y relacionales, fundamentales para realizar

comparaciones y establecer condiciones en los programas. Así se comprenderá cómo
combinar estas herramientas para resolver problemas prácticos y crear aplicaciones más
dinámicas e inteligentes.

Finalmente, se destacará la importancia de los comentarios en el código como una práctica

esencial para mejorar la legibilidad y facilitar el mantenimiento del programa. Al finalizar la
clase, los y las estudiantes serán capaces de validar datos ingresados por las personas
usuarias, integrar lógica condicional en sus programas y desarrollar soluciones más
robustas y funcionales.
Te damos la bienvenida a tu jornada en TechLab 🎉
Al llegar, te encontrás con Mariana, la Gerente de Proyectos, quien te felicita por haber
completado tu primera asignación en torno a las variables con éxito, y aprovecha para
hacerte algunas sugerencias:

“Para que tu programa sea aún más robusto, me gustaría que

trabajemos en validar los datos que ingresan los usuarios (por
ejemplo, que los campos no queden en blanco) y agregar una
lógica para indicar si un cliente es mayor o menor de edad.”

Para ello, tendrás que interiorizarte en el concepto de condicionales (estructuras de

control de flujo) y los operadores lógicos y relacionales.​
​
¡Manos a la obra!
Operadores lógicos y relacionales.

Operadores relacionales
Los operadores relacionales en Python, que también se conocen como operadores de
comparación, sirven para algo clave: comparar valores. El resultado de esta comparación
siempre es un valor booleano, es decir, True (verdadero) o False (falso), dependiendo de si
la condición que estás evaluando es cierta o no.
Ahora, vayamos a lo importante: ¿qué operadores relacionales tenés a tu disposición en
Python?

Operador Significado Descripción

== Igual que Verifica si el valor o los valores de dos expresiones

son iguales.

!= No igual que Comprueba si dos valores son diferentes.

> Mayor que Evalúa si el valor de la izquierda es mayor que el valor

de la derecha.

< Menor que Determina si el valor de la izquierda es menor que el

valor de la derecha.

>= Mayor o igual que Verifica si el valor de la izquierda es mayor o igual al

valor de la derecha.

<= Menor o igual que Comprueba si el valor de la izquierda es menor o igual

al valor de la derecha.

Esto es súper importante, porque estos operadores son los que te permiten
tomar decisiones en tus programas. Los vas a usar un montón cuando trabajes
con estructuras como if, else y elif, o cuando necesites crear bucles con while o
controlar iteraciones con for.

Veamos unos ejemplos para que te quede más claro cómo funcionan:

print(3 > 4) # False

print(2 <= 4) # True
print(2 != 22) # True
print("Hola" == "hola") # False
print("Carlos" < "Ada") # False

Hasta acá, parece bastante sencillo, ¿no? Pero hay algo más interesante que vale la pena
mencionar: ¿cómo compara Python las cadenas de caracteres?

Acá viene lo interesante. Las cadenas de texto se comparan carácter por carácter,
siguiendo un orden basado en su codificación (ASCII o Unicode). Esto significa que Python
va a ir chequeando cada carácter de la cadena, de izquierda a derecha, hasta que
encuentra una diferencia o hasta que una de las cadenas se termine. Entonces, cuando
usás operadores relacionales con cadenas de texto, Python sigue estas reglas:

●​ == (igual que): Verifica si dos cadenas son exactamente iguales.

●​ != (no igual que): Comprueba si dos cadenas son diferentes.
●​ > (mayor que), < (menor que): Compara las cadenas según el valor de cada
carácter. Por ejemplo, en ASCII, las letras mayúsculas (A-Z) tienen un valor menor
que las letras minúsculas (a-z), lo que significa que, por ejemplo, "a" es mayor que
"A".

Este tipo de comparación se llama orden lexicográfico. Básicamente, Python va carácter

por carácter, desde el principio de las dos cadenas, comparando. Si encuentra una
diferencia, ahí se detiene y decide cuál es "mayor" o "menor". Si las cadenas son idénticas
hasta cierto punto pero una es más corta, entonces la más corta se considera "menor".

Vamos a ver un par de ejemplos para aclarar cómo se comportan las comparaciones de
cadenas:

print("apple" < "banana") # True

print("apple" > "Apple") # True
print("apple" < "apples") # True

print("python" == "python") # True

print("Python" != "python") # True

print("A" < "a") # True

print("z" > "Z") # True
Como ves, Python no sólo se fija en si las letras son iguales, sino también en si son
mayúsculas o minúsculas, o si una cadena tiene más o menos caracteres. ¡Esto es súper
útil cuando necesitás comparar nombres, palabras o cualquier tipo de texto en tus
programas!

Operadores lógicos.
Los operadores lógicos en Python son clave cuando querés trabajar con múltiples
condiciones al mismo tiempo. Imaginate que estás desarrollando una aplicación donde
necesitás verificar varias cosas a la vez, como si un usuario está logueado y además tiene
los permisos necesarios para acceder a cierta función. Es acá donde entran en juego los
operadores lógicos, que te permiten combinar distintas afirmaciones y evaluarlas juntas. Al
final, todo se reduce a si esas afirmaciones son True (verdaderas) o False (falsas).

En Python, tenés tres operadores lógicos principales: and, or y not. Cada uno tiene su
propio comportamiento, pero todos ellos trabajan sobre expresiones que resultan en valores
booleanos, es decir, True o False.

Estos operadores te permiten hacer evaluaciones complejas de una manera

súper simple.

Vamos a ver cómo funciona cada uno:

Operador “and”.
El operador and es bastante directo: sólo devuelve True si todas las condiciones que estás
evaluando son verdaderas. Basta con que una sola sea falsa para que el resultado total sea
False. Es como decir: "quiero que todo lo que estoy evaluando cumpla con la condición".

Fijate en estos ejemplos:

resultado = (5 > 3) and (8 > 6)

# True, porque ambas condiciones son verdaderas.

resultado = (5 > 3) and (8 < 6)

# False, porque una de las condiciones es falsa.
En el primer caso, ambas comparaciones son verdaderas, entonces and devuelve True.
Pero en el segundo ejemplo, aunque la primera parte (5 > 3) es verdadera, la segunda (8 <
6) es falsa, lo que hace que todo el resultado sea False.

Operador “or”.

El operador or, por otro lado, es un poco más relajado. Con él, alcanza con que una sola de
las condiciones sea verdadera para que el resultado total sea True. Sólo va a devolver
False si todas las condiciones son falsas. Es como decir: "si al menos una cosa cumple,
está bien".

Mirá estos ejemplos:

resultado = (5 > 3) or (8 < 6)

# True, porque al menos una condición es verdadera.

resultado = (5 < 3) or (8 < 6)

# False, porque ambas condiciones son falsas.

En el primer caso, aunque la segunda condición es falsa, la primera (5 > 3) es verdadera,

por lo que el resultado final es True. En el segundo ejemplo, las dos comparaciones son
falsas, por lo que el resultado es False.

Operador “not”.

Finalmente, tenemos el operador not. Este es el que invierte el valor de verdad de una
expresión. Si algo es True, not lo convierte en False, y viceversa. Es como un interruptor de
luz: lo que está prendido lo apaga, y lo que está apagado lo prende.

Acá van algunos ejemplos para que lo veas en acción:

resultado = not (5 > 3)

# False, porque 5 > 3 es True, y not lo invierte.

resultado = not (5 < 3)

# True, porque 5 < 3 es False, y not lo invierte.
En el primer caso, aunque 5 es efectivamente mayor que 3 (lo que sería True), not lo da
vuelta y lo convierte en False. En el segundo ejemplo, 5 no es menor que 3 (lo que sería
False), pero not invierte el resultado y nos da True.

Estos operadores lógicos son esenciales para cualquier lenguaje de programación y Python
los maneja de manera súper intuitiva. En tus futuros programas, vas a ver cómo te permiten
tomar decisiones más complejas, desde validar varias condiciones hasta hacer que tu
código responda de manera diferente dependiendo de múltiples factores.

Luis, como programador experimentado que es, te comparte unas tablas que usa para
recordar qué resultado se obtiene con cada operador en cada caso:

Condición 1 Condición 2 Y (and) O (or)

V V V V
V F F V
F V F V
F F F F

Condición NO (not)
V F
F V

Estructuras de control.
Imaginá que estás manejando un auto. No sólo te limitás a acelerar o frenar, sino que
también tomás decisiones según las señales de tránsito, girás cuando es necesario, y a
veces, das vueltas por el mismo lugar varias veces (¡ojo con eso!). En la programación pasa
algo parecido: las estructuras de control son esas herramientas que te permiten decidir por
dónde ir, repetir una acción o tomar un desvío según las condiciones. Son el volante y los
frenos de tu código.

Las estructuras de control en Python son clave porque te permiten tener un programa que
no simplemente corre una lista de instrucciones de manera secuencial, sino que puede
adaptarse a distintas situaciones. Dependiendo de las condiciones que se encuentren,
podés hacer que el programa ejecute una parte del código o repita una acción varias veces.
El propósito principal de estas estructuras es justamente darle esa flexibilidad a tu programa
para que pueda "tomar decisiones". En lugar de que todo el código se ejecute de forma
lineal, las estructuras de control le dicen al programa cuándo detenerse, repetir algo o saltar
a otro bloque de código dependiendo de lo que está ocurriendo en ese momento. Esto es lo
que hace que un programa pueda, por ejemplo, responder de manera diferente según la
entrada de un usuario, realizar tareas repetitivas automáticamente o procesar datos de
manera más eficiente.

Con estas herramientas, vas a poder hacer que tu programa no sólo funcione, sino que
también piense, decida y actúe por su cuenta, ajustándose a lo que necesite en cada
momento. ¡El verdadero poder de la programación está en estas estructuras!

Control de flujo: estructuras condicionales

Imaginá que estás caminando por la calle y, de repente, comienza a llover. En ese
momento, tenés que tomar una decisión rápida: si tenés paraguas, lo abrís; si no, salís
corriendo para no mojarte. Bueno, en programación, las estructuras condicionales son algo
muy parecido. Le dicen al programa qué hacer dependiendo de lo que esté ocurriendo en
ese instante. En Python, usamos estas estructuras para que el código pueda tomar
decisiones según lo que esté pasando o según los datos que reciba.

La forma más básica de hacer esto es con la palabra clave if. Con if, podés indicarle a
Python que ejecute cierto bloque de código sólo si se cumple una condición. Si esa
condición es verdadera (o sea, True), Python va a ejecutar el código que está indentado
justo debajo del if. Si no se cumple (o sea, es False), Python va a ignorar ese bloque y
seguirá con lo que venga después.

La estructura básica de un if es súper sencilla. Fijate en este ejemplo:

numero = 5

if numero > 0:
print("El número es positivo.")

Acá lo que estamos haciendo es preguntarle a Python: "¿Es el número mayor que 0?" Si la
respuesta es sí (o sea, True), se va a ejecutar la línea que está indentada justo después del
if, que imprime "El número es positivo.". Si el número hubiera sido 0 o negativo, ese bloque
de código se saltaría y Python seguiría con lo que venga después.
Esa simple verificación es como el cerebro del programa, que decide qué hacer según la
información que tiene. ¡Es lo que hace que los programas sean flexibles y puedan
adaptarse!

¿Cómo funciona exactamente?

Veamos más de cerca lo que pasa con un if:

1.​ Condición: Lo primero que necesita el if es una condición. Esto puede ser cualquier
expresión que Python pueda evaluar como True o False. Por ejemplo, numero > 0
es una condición que le pregunta a Python si numero es mayor que 0.

2.​ Dos puntos (:): Estos dos puntos que aparecen al final de la línea if son muy
importantes. Le dicen a Python que el bloque de código que sigue está relacionado
con esa condición.

3.​ Bloque de código indentado: Todo el código que esté indentado debajo del if se va
a ejecutar solo si la condición es True. Y ojo con esto: la indentación es obligatoria
en Python.

Esa pequeña sangría al principio de la línea no es sólo por estilo; le dice a Python que esas
líneas de código forman parte del bloque del if.

Vamos a poner otro ejemplo para que quede bien claro:

edad = 18

if edad >= 18:

print("Sos mayor de edad.")

En este caso, estamos verificando si alguien tiene 18 años o más. Si la condición es True,
Python va a imprimir "Sos mayor de edad". Si no, simplemente va a seguir con el resto del
programa, sin hacer nada especial con esa línea.

Recordá esto. ¡Te va a servir para poder resolver el pedido que te hizo Luis en
su correo!

Y esto es solo el principio. Ahora pronto vas a ver cómo podés manejar situaciones que no
cumplen ninguna condición con else.
Estructura condicional if...else
Hasta ahora vimos cómo if le da la capacidad a tu programa de tomar decisiones cuando
una condición es verdadera. Pero, ¿qué pasa cuando esa condición no se cumple? Ahí es
donde entra en juego else. Mientras que if se encarga de ejecutar un bloque de código
solo si algo es True, else viene al rescate cuando esa condición resulta ser False,
permitiéndote hacer algo diferente en ese caso. Es como decir: "Si pasa esto, hacé tal cosa,
y si no, hacé esto otro".

El else no necesita tener una condición propia. Se ejecuta solo si el if que lo precede da
como resultado False. Imaginá que estás manejando y, si tenés combustible, seguís
adelante, pero si no tenés, vas directo a cargar nafta. Esa es la idea detrás de if...else.

Veamos cómo funciona:

numero = -5

if numero > 0:
print("El número es positivo.")
else:
print("El número no es positivo.")

Acá, lo que está pasando es que le preguntamos a Python si numero es mayor que 0. Como
en este caso numero es -5, la condición es False, entonces Python se saltea el bloque del if
y salta directo al else, que imprime "El número no es positivo". Si el número hubiera sido
positivo, el else ni siquiera se ejecutaría.

¿Por qué es tan útil else?

El else es esa segunda oportunidad que tenés para manejar lo que pasa cuando tu
condición no se cumple. Es como tener un plan B. Al combinar if con else, podés crear
programas mucho más flexibles, que reaccionen de manera diferente según las
circunstancias. En lugar de simplemente ignorar las situaciones en las que la condición no
se cumple, con else podés hacer que tu programa actúe de otra forma, cubriendo todos los
posibles resultados.

Pensemos en otro ejemplo sencillo:

edad = 16

if edad >= 18:

print("Sos mayor de edad.")
else:
 print("Sos menor de edad.")

Acá estamos haciendo que Python verifique si alguien es mayor o igual a 18. Si la respuesta
es True, imprime "Sos mayor de edad", pero si es False, el programa no se queda sin hacer
nada: imprime "Sos menor de edad". Así, el código no solo evalúa la condición, sino que
también reacciona de manera diferente si la condición no se cumple.

¿Cuándo usar else?

El uso de else hace que tu código sea más claro y directo. En lugar de tener que escribir
más if o manejar los casos por separado, else te permite cubrir todos los escenarios
posibles en los que la condición no se cumpla, lo que hace que tu código sea más eficiente
y fácil de leer. Además, le da al programa la capacidad de reaccionar de manera distinta
según los datos que reciba o el estado en el que se encuentre.

Si combinás if con else, podés manejar cualquier situación que se te presente: desde validar
formularios, hasta hacer que un juego responda de manera diferente según las decisiones
del jugador. Todo depende de las condiciones que estés evaluando, y con else, tenés la
tranquilidad de que nada va a quedar sin manejar.

El uso de else le da a tus programas una dimensión extra. Con esto, ya no se

trata solo de ejecutar un bloque de código si algo es verdadero, sino también
de decirle al programa qué hacer cuando no lo es. ¡Es como tener un plan B,
listo para cualquier situación!

Veamos otro ejemplo con else. Supongamos que querés verificar si un producto tiene un
precio menor a $500. Podrías hacer algo así:

precio = 450
if precio < 500:
print("El producto es económico.")
else:
print("El producto es costoso.")

Y, por supuesto, podés construir condiciones que usen operadores lógicos. Por ejemplo, si
querés verificar si una persona puede votar en base a su edad y ciudadanía:
edad = 20
es_ciudadano = True

if edad >= 18 and es_ciudadano:

print("Podés votar.")
else:
print("No podés votar.")

Este ejemplo te muestra cómo combinar condiciones para evaluar múltiples criterios al
mismo tiempo

Comentarios en el código: más allá del #

En la clase anterior vimos que los comentarios en Python se crean usando el símbolo #. Los
comentarios son esenciales para explicar partes del código, documentar decisiones
importantes y hacer que el programa sea más fácil de entender, tanto para vos como para
cualquier otra persona que pueda trabajar con ese código en el futuro.

Además de los comentarios simples que empiezan con #, Python permite usar comentarios
multilínea, que sirven para explicar procesos o ideas más complejas que no entran en una
sola línea. A continuación, repasamos ambos tipos:

1. Comentarios simples con #

Como ya vimos, los comentarios simples se escriben anteponiendo el símbolo # a una línea
o parte de una línea. Son ideales para anotar explicaciones breves o desactivar
temporalmente líneas de código.

Ejemplo:

# Este programa calcula el área de un rectángulo

base = 5 # Base del rectángulo
altura = 10 # Altura del rectángulo
area = base * altura
print("El área es:", area) # Mostramos el resultado
En este ejemplo, cada comentario aclara el propósito de las variables y la salida del
programa, haciendo el código más fácil de entender.

2. Comentarios multilínea

Python no tiene un símbolo específico para comentarios multilínea, pero se pueden simular
utilizando cadenas de texto de varias líneas (tres comillas simples o dobles). Aunque estas
cadenas están diseñadas para definir textos largos dentro del código, se utilizan
comúnmente como comentarios para explicar procesos más complejos.

Ejemplo:

"""
Este programa calcula el área de un rectángulo.
Primero define la base y la altura,
luego multiplica ambos valores para obtener el área.
Finalmente, muestra el resultado en pantalla.
"""
base = 5
altura = 10
area = base * altura
print("El área es:", area)

Si bien estas cadenas no son técnicamente comentarios (ya que Python las
interpreta como texto), son ignoradas cuando no están asignadas a una
variable, por lo que se comportan como comentarios en la práctica.

Los comentarios multilínea son útiles para documentar módulos, funciones o partes
extensas del código. Y dado que estos comentarios son una cadena de texto, se pueden
reemplazar las triples comillas dobles por triples comillas simples.

Buenas prácticas al usar comentarios.

Sé claro y preciso: Los comentarios deben explicar el propósito del código, no describir lo
obvio. Por ejemplo, en lugar de:
x = 5 # Asignamos 5 a x

Es mejor:

x = 5 # Cantidad inicial de productos en stock

Actualizá los comentarios al modificar el código: Comentarios desactualizados generan

confusión y contradicen el objetivo de facilitar la comprensión.

Usá comentarios para documentar decisiones importantes: Por ejemplo:

# Elegimos este algoritmo porque es más eficiente para listas pequeñas

Evitá comentarios redundantes: El código debe ser lo suficientemente claro como para no
necesitar explicaciones obvias.

Los comentarios son una herramienta importante para escribir código comprensible y
mantenible. Usar comentarios de manera adecuada no sólo mejora la legibilidad del código,
sino que también facilita su mantenimiento y colaboración en proyectos.
Ejercicio práctico.
Luego de un día intenso en TalentoLab , y gracias a la ayuda inestimable de Luis, ya podés
intentar resolver la tarea que te encargó Mariana. Cómo siempre, te escribió un correo
explicando detalladamente que necesita que hagas:
¡Hola!

Necesito que desarrolles un pequeño programa en Python

que haga exactamente lo siguiente:
●​ Solicite al cliente su nombre, apellido, edad y correo
electrónico.
●​ Compruebe que el nombre, el apellido y el correo no
estén en blanco, y que la edad sea mayor de 18 años.
●​ Muestre los datos por la terminal, en el orden que se
ingresaron. Si alguno de los datos ingresados no
cumple los requisitos, sólo mostrar el texto “ERROR!”.

¡Espero ver el resultado de tu trabajo pronto!

Saludos,
Mariana
Materiales y recursos adicionales
Artículos:

El libro de Python: Bloques de código y sintaxis en Python

Oregoom: If y else en Python
Programació[Link]: Condicionales en Python
Pythones: Aprende los condicionales en Python con ejemplos

Videos:
Tutoriales sobre ciencia y tecnología: Estructura if y estructura if…else

Preguntas para reflexionar

1.​ ¿De qué manera los operadores lógicos y relacionales amplían las posibilidades de
resolver problemas en programación?
2.​ ¿Por qué creés que es importante escribir código que no sólo funcione, sino que
también sea fácil de leer y mantener?
3.​ ¿Cómo pensás que el uso de estructuras condicionales puede integrarse con otras
herramientas de programación para resolver problemas complejos?

Próximos pasos
En la próxima clase, vamos a profundizar en las estructuras condicionales, introduciendo
herramientas más avanzadas como elif y match, que nos permitirán manejar múltiples
escenarios en un solo bloque de código. Estas estructuras serán clave para tomar
decisiones más complejas y optimizar nuestros programas.

También trabajaremos con cadenas de texto, explorando cómo acceder a caracteres

específicos, concatenar textos, medir su longitud y aplicar métodos como .lower() o
.upper() para transformar su formato. Aprenderemos a utilizar estas herramientas en
conjunto con f-Strings para generar salidas claras y profesionales, mejorando la interacción
con los usuarios.

Todo esto nos ayudará a continuar desarrollando programas más dinámicos y adaptados a
las necesidades reales de posibles clientes.
Clase N° 4 | Condicionales II
Temario:
●​ Estructuras condicionales avanzadas: elif y match.
●​ Manipulación de cadenas: acceso a caracteres, concatenación, longitud.
●​ Métodos de cadenas: .lower(), .upper(), .title(), etc.
●​ Formateo de cadenas con f-Strings.
●​ Ruta de avance.

Objetivos de la clase
El principal objetivo de esta clase es ampliar el manejo de estructuras condicionales en
Python, introduciendo herramientas avanzadas como elif y match, que permiten gestionar
múltiples escenarios en un mismo programa de forma más clara y eficiente. Estas
estructuras son fundamentales para diseñar soluciones más completas y adaptativas.

Además, se busca que los estudiantes comprendan cómo manipular cadenas de texto,
accediendo a sus caracteres, concatenándolas, calculando su longitud y transformándolas
mediante métodos como .lower() y .upper(). Estas habilidades son esenciales para procesar
y presentar información de manera efectiva.

Por último, se trabajará en el formateo de cadenas utilizando f-Strings, una técnica que
simplifica la generación de salidas dinámicas y profesionales. Al finalizar la clase, estarán
en condiciones de combinar estas herramientas para construir programas que gestionen
datos textuales de manera avanzada, respondiendo a necesidades reales de las y los
usuarios.
TechLab: Jornada 4 ☀️

En lo que ya se está convirtiendo en una costumbre, ni bien ingresás a la sede de

TalentoLab, te encontrás con Mariana. Café en mano, te felicita por tus avances, y te
comenta que:

“Nuestro cliente nos pide que el programa formatee correctamente los

textos ingresados y que clasifique a las y los clientes por rango etario
(niña o niño, adolescente, adulto o adulta) basándose en su edad.”

Claramente, es algo que no podés hacer con tus conocimientos actuales. Afortunadamente,
Luis está ahí para ayudarte. Buscan un despacho libre, y comienzan a ver que necesitás
saber para poder resolver este nuevo desafío.
Estructuras condicionales avanzadas: elif
Estructuras condicionales avanzadas: elif

En la clase anterior aprendimos a usar las estructuras condicionales if y if...else, que nos
permiten tomar decisiones básicas dentro de un programa. Sin embargo, en situaciones
donde necesitamos manejar múltiples condiciones, escribir varios bloques if puede volver
nuestro código repetitivo y difícil de seguir. Ahí es donde entra en juego elif.

El bloque elif (abreviatura de "else if") nos permite manejar múltiples casos
dentro de una misma estructura condicional, evitando redundancias y haciendo
que nuestro código sea más eficiente y legible.

Python evalúa las condiciones de manera secuencial: si una condición if es verdadera,

ejecuta ese bloque y se saltea el resto; si no, pasa al siguiente elif y así sucesivamente,
hasta llegar al else (si está presente).

Sintaxis básica de elif

edad = 25

if edad < 13:

print("Sos menor a trece años.")
elif edad < 18:
print("Sos un o una adolescente.")
elif edad < 60:
print("Sos una persona adulta.")
else:
print("Sos una persona adulta mayor.")

En este ejemplo, el programa evalúa la edad del usuario o usuaria y muestra un mensaje
correspondiente al rango etario. Observá cómo elif simplifica el manejo de múltiples
condiciones, haciendo que el flujo del programa sea claro y directo.

Cuándo usar elif

Usamos elif cuando:

1.​ Hay múltiples condiciones mutuamente excluyentes (es decir, sólo una puede ser
verdadera).
 2.​ Queremos evitar escribir varios bloques if independientes que podrían complicar el
seguimiento del código.

Ejemplo práctico: Clasificación de notas

Imaginá que estás programando un sistema para clasificar notas escolares. El programa
debería asignar una categoría según el puntaje del estudiante:

nota = int(input("Ingresá la nota del o de la estudiante: "))

if nota >= 90:

print("Excelente.")
elif nota >= 75:
print("Muy bien.")
elif nota >= 60:
print("Bien.")
elif nota >= 40:
print("Suficiente.")
else:
print("Insuficiente.")

Este ejemplo muestra cómo elif permite manejar fácilmente varias categorías sin repetir
código innecesariamente.

Combinando elif con operadores lógicos

Podemos combinar elif con operadores lógicos para evaluar condiciones más complejas.
Por ejemplo:

# Solicitar al usuario o usuaria que ingrese su edad

edad = int(input("Ingresá tu edad: ")) # Convertimos a entero

# Solicitar que informe su ingreso mensual y convertimos

# el dato volcado a un número entero

ingreso = int(input("Escribí tu ingreso mensual: "))

# Evaluar las condiciones para clasificar al o a la usuario o usuaria

if edad < 18:
# Si la edad es menor a 18, es menor de edad
print("Sos menor de edad.")
elif edad >= 18 and ingreso < 50000:
# Si la edad es mayor o igual a 18 y el ingreso mensual
# es menor a $50,000
print("Sos mayor de edad, pero tenés ingresos bajos.")
elif edad >= 18 and ingreso >= 50000:
# Si la edad es mayor o igual a 18 y el ingreso mensual
# es igual o mayor a $50,000
print("Sos mayor de edad y tenés ingresos altos.")
else:
# En caso de que no se cumpla ninguna condición anterior
print("Datos no válidos.")

Este programa clasifica a las personas según su edad y nivel de ingresos, mostrando cómo
elif se combina con operadores para resolver problemas más realistas.

El uso de elif simplifica el manejo de múltiples escenarios en tus programas,

haciéndolos más fáciles de entender y mantener.

Estructura condicional avanzada: match

Estructura condicional avanzada: match

La estructura match fue introducida en la versión 3.10 de Python, como una alternativa más
clara y poderosa al uso de múltiples bloques if...elif...else, especialmente cuando queremos
comparar un valor específico con varias opciones posibles. Es similar a la estructura switch
de otros lenguajes de programación y se utiliza para simplificar el manejo de casos
múltiples.

¿Por qué usar match?

Aunque if...elif...else es muy versátil, en casos donde se necesita comparar un valor con
múltiples posibilidades, el código puede volverse más extenso y difícil de leer. Match aborda
esta limitación al permitir evaluar un valor contra diferentes patrones, ofreciendo:

●​ Claridad y legibilidad: Su sintaxis es más compacta y clara para casos múltiples.

●​ Flexibilidad: Puede trabajar con patrones avanzados, no solo con valores literales.
 ●​ Mantenibilidad: Simplifica el flujo del programa, especialmente cuando hay muchas
condiciones.

Comparación entre match y elif:

Característica match elif

Comparar un valor contra Resolver condiciones más

Propósito
múltiples patrones. generales.

Más claro para múltiples casos Puede volverse extenso y

Legibilidad
específicos. repetitivo.

Mejor para condiciones generales

Flexibilidad Permite patrones complejos.
o combinadas.

Introducción Python 3.10 y posteriores. Disponible en todas las versiones.

La sintaxis de match

La estructura match en Python se utiliza para comparar el valor de una variable con
diferentes patrones, ejecutando el bloque de código asociado al primer patrón que coincida.
Esta herramienta es especialmente útil cuando tenés que manejar múltiples opciones de
forma clara y organizada.

La sintaxis general de match es la siguiente:

match variable:
case valor1:
# Código si variable coincide con valor1
case valor2:
# Código si variable coincide con valor2
case _:
# Código si no coincide ningún caso (opcional)

●​ variable: Es el valor que queremos comparar. Puede ser de cualquier tipo, como
números, cadenas, tuplas, etc.
●​ case valor1: Define un caso específico. Si variable coincide con este valor, se
ejecuta el bloque de código asociado.
 ●​ _ (guión bajo): Representa el caso por defecto, que se ejecuta si no hay
coincidencia con ninguno de los casos anteriores. Es equivalente al else en un
bloque condicional.

Python evalúa los casos en orden, deteniéndose en el primero que coincide. Esto hace que
el flujo del programa sea eficiente y fácil de seguir. Pero veamos un ejemplo:

fruta = input("Ingresá una fruta: ")

match fruta:
case "manzana":
print("Es una fruta roja o verde.")
case "banana":
print("Es una fruta amarilla.")
case "naranja":
print("Es una fruta anaranjada.")
case _:
print("No tengo información sobre esa fruta.")

En este ejemplo:

1.​ La variable fruta es evaluada por match.

2.​ Cada case especifica un valor posible para fruta.
3.​ Si no hay coincidencia, se ejecuta el bloque del caso _.

Ahora, veamos un ejemplo más, para comparar elif con match. Supongamos que te piden
escribir un programa que reciba el número de un día de la semana (donde 1 corresponde a
Lunes, 2 a Martes, 3 a Miércoles, y así sucesivamente) e imprima el nombre del día
correspondiente. Si el número ingresado no corresponde a un día válido, el programa debe
mostrar el mensaje: "Día no válido". Esto puede resolverse tanto usando elif, como usando
match:

Con if...elif...else:

dia = 3

if dia == 1:
print("Lunes")
elif dia == 2:
print("Martes")
elif dia == 3:
print("Miércoles")
else:
print("Día no válido")

Con match:

dia = 3

match dia:
case 1:
print("Lunes")
case 2:
print("Martes")
case 3:
print("Miércoles")
case _:
print("Día no válido")

Usando match el código es más claro y evita la repetición de la variable en cada

comparación. Ahora, ya podemos resolver uno de los pedidos que nos ha hecho Luis:
Este código resuelve lo que te han solicitado:

peso = float(input("Ingresá el peso del paquete (en kg): "))

match peso:
case p if p <= 5:
print("Paquete pequeño.")
case p if 5 < p <= 20:
print("Paquete mediano.")
case p if p > 20:
print("Paquete grande.")
case _:
print("Peso no válido.")

Queda claro que match es una herramienta poderosa que complementa y, en algunos
casos, reemplaza al uso de múltiples bloques elif. Ofrece una sintaxis más limpia y legible,
especialmente útil cuando se necesita manejar múltiples casos específicos.

No olvides que para condiciones más generales o complejas, if...elif...else

sigue siendo una opción válida y flexible.

Manipulación de cadenas en Python

Manipulación de cadenas en Python

Ya sabés que en Python una cadena de caracteres (o simplemente cadena) es una

secuencia encerrada entre comillas simples (') o dobles ("). Además, son uno de los tipos de
datos más utilizados porque nos permiten trabajar con texto, desde nombres de personas
hasta mensajes más complejos. Pero para poder hacerlo correctamente, necesitamos saber
cómo manipularlas.

Concatenación de cadenas
La concatenación es el proceso de unir dos o más cadenas de texto para formar una
nueva. En Python, podés usar el operador + para lograrlo de manera sencilla.

Cuando trabajás con datos textuales, la concatenación es una herramienta clave. Por
ejemplo, podés combinar el nombre y el apellido de una persona para mostrar su nombre
completo en pantalla.
nombre = "María"
apellido = "González"

# Se agrega un espacio entre las cadenas

nombre_completo = nombre + " " + apellido

print(nombre_completo) # Salida: María González

En este ejemplo:

1.​ nombre y apellido son cadenas separadas que contienen diferentes partes de un
dato.
2.​ Usamos el operador + para unirlas, incluyendo un espacio " " entre ellas para que el
resultado sea legible.
3.​ La variable nombre_completo almacena la nueva cadena resultante.

Este tipo de operación es muy común cuando querés presentar información de

manera clara, como generar un mensaje personalizado o mostrar datos de
usuarios o usuarias.

Podés concatenar tantas cadenas como necesites en una sola línea. Por ejemplo:

saludo = "Hola"
nombre = "Lucía"
mensaje = saludo + ", " + nombre + ". ¿Cómo estás?"
print(mensaje) # Salida: Hola, Lucía. ¿Cómo estás?

En este caso combinamos tres cadenas: saludo, nombre y una cadena literal (el texto
dentro de comillas). Usamos comas, espacios y signos de puntuación para hacer que el
mensaje tenga sentido y sea amigable.

Si necesitás unir una cadena con otro tipo de dato, como un número o un valor booleano,
primero tenés que convertir ese dato en texto usando la función str(). Esto es necesario
porque, como sabés, Python no permite combinar distintos tipos de datos directamente.
edad = 30
mensaje = "Tenés " + str(edad) + " años."
print(mensaje) # Salida: Tenés 30 años

En este caso la variable edad es un número entero (tipo int), por lo que usamos str(edad)
para convertirlo en texto. Luego, concatenamos la cadena resultante con otras cadenas
para formar el mensaje final.

Longitud de una cadena de caracteres y la función

len()
Longitud de una cadena de caracteres y la función len()
La longitud de una cadena de caracteres es la cantidad total de caracteres que contiene.
Esto incluye letras, números, espacios, símbolos y cualquier otro carácter que forme parte
del texto. En Python, podés determinar la longitud de una cadena utilizando la función
incorporada len().

La función len() es muy útil para validar datos ingresados por la o el usuario,
analizar cadenas o asegurarte de que cumplen con ciertos requisitos, como una
cantidad mínima o máxima de caracteres.

La función len() toma como argumento una cadena y devuelve un número entero que
representa la cantidad de caracteres en esa cadena.

mensaje = "Hola, mundo"

print(len(mensaje)) # Salida: 11

La cadena "Hola, mundo" tiene 11 caracteres en total, contando el espacio y la coma.

Python incluye todos los caracteres visibles y no visibles (como los espacios) en la longitud.

Podés usar len() para asegurarte que se ingresa un dato válido. Por ejemplo, evitar que un
campo como "nombre" quede vacío:
nombre = input("Ingresá tu nombre: ")

if len(nombre) == 0:
print("El nombre no puede estar vacío.")
else:
print("¡Hola, " + nombre + "!")

Al no ingresarse ningún dato, aparece el mensaje: "El nombre no puede estar vacío." Si
ingresa un nombre, el programa le saluda con un mensaje personalizado.

Algunas aplicaciones requieren que un dato, como una contraseña, tenga cierta cantidad de
caracteres. Podés validar esto con len().

contraseña = input("Ingresá tu contraseña: ")

if len(contraseña) < 8:
print("La contraseña debe tener al menos 8 caracteres.")
else:
print("Contraseña válida.")

En este caso, si la contraseña tiene menos de 8 caracteres, el programa muestra un

mensaje avisando de esta situación. Si cumple con el requisito, el mensaje confirma que es
válida.

Rompiendo las cadenas

Rompiendo las cadenas

Las cadenas en Python no son más que una secuencia ordenada de caracteres. Cada letra,
número, espacio o símbolo ocupa una posición específica dentro de esa cadena, y
podemos acceder a ellos de forma individual utilizando un índice. Esta característica es muy
útil cuando necesitás trabajar con partes específicas de un texto, como extraer una letra,
analizar un segmento o incluso modificar el formato de ciertas secciones.

En Python, el índice de una cadena comienza en cero. Esto significa que el primer carácter
de la cadena está en la posición 0, el segundo en la posición 1, y así sucesivamente. Podés
utilizar la notación con corchetes [] para acceder a un carácter específico. Por ejemplo, si
tenés la cadena mensaje = "Hola", podés acceder al primer carácter escribiendo mensaje[0],
que en este caso te devolvería "H". Del mismo modo, si querés obtener el cuarto carácter,
podés usar mensaje[3], que devolvería "a".

mensaje = "Hola"

# Accedemos al primer carácter

print(mensaje[0]) # Salida: H

# Accedemos al cuarto carácter

print(mensaje[3]) # Salida: a

Una de las grandes ventajas de esta funcionalidad es que también podés usar índices
negativos. Cuando usás un índice negativo, Python empieza a contar desde el final de la
cadena. Por ejemplo, con la misma cadena "Hola", mensaje[-1] te daría el último carácter,
"a", mientras que mensaje[-2] te devolvería "l". Mirá este ejemplo:

mensaje = "Hola"

# Usamos un índice negativo para obtener el último carácter

print(mensaje[-1]) # Salida: a

# Obtenemos el penúltimo carácter

print(mensaje[-2]) # Salida: l

Podés extraer una porción de la cadena utilizando slicing (rebanado). Esto se hace
indicando un rango en los corchetes [inicio:fin]. El rango incluye el carácter en la posición de
inicio, pero no el del fin. Si escribís mensaje[0:2], vas a obtener "Ho", que incluye los
caracteres en las posiciones 0 y 1, pero no el de la posición 2 (el rango es exclusivo en el
límite superior). Si omitís el inicio o el final del rango, Python asume que querés ir desde el
principio o hasta el final de la cadena, respectivamente. Por ejemplo, mensaje[:2] te
devuelve "Ho", y mensaje[1:] te da "ola".

# Extraemos los dos primeros caracteres

print(mensaje[0:2]) # Salida: Ho

# Desde el segundo carácter hasta el final

print(mensaje[1:]) # Salida: ola

# Desde el inicio hasta el segundo carácter (sin incluirlo)

print(mensaje[:2]) # Salida: Ho

Esta herramienta podés utilizarla para validar texto, formatearlo o analizarlo con mucha
precisión. Por ejemplo, si quisieras verificar si una cadena empieza con cierta letra, podrías
hacer algo como mensaje[0] == "H", y eso te devolvería True si el primer carácter es
efectivamente "H".

Las cadenas son inmutables, lo que significa que no podés cambiar un

carácter directamente asignándole un nuevo valor usando los índices. Si
intentás algo como mensaje[0] = "J", Python va a generar un error.

Métodos de cadenas en Python

Métodos de cadenas en Python

Las cadenas en Python no solo son una secuencia de caracteres, sino que también son
objetos que vienen con una variedad de métodos incorporados. Los métodos son funciones
asociadas a las cadenas que podés utilizar para realizar operaciones comunes, como
cambiar el formato del texto, buscar contenido o realizar transformaciones específicas. Lo
interesante de los métodos de cadenas es que no modifican la cadena original, sino que
generan una nueva con los cambios aplicados.

Estos métodos son fáciles de usar y te permiten trabajar con texto de manera más eficiente.
Por ejemplo, podés convertir una cadena a minúsculas, mayúsculas o formatearla
automáticamente como un título. Cada método se invoca usando la notación de punto,
como [Link](), y muchos no requieren parámetros adicionales.

A continuación, vamos a ver algunos de los métodos más comunes que podés usar con las
cadenas en Python, junto con ejemplos prácticos para que veas cómo aplicarlos.

Método Ejemplo de uso Explicación

texto = "Hola Mundo" Convierte todos los

.lower() print([Link]()) caracteres de la cadena a
# Salida: hola mundo minúsculas. Ideal para hacer
 comparaciones insensibles a
mayúsculas y minúsculas.

Convierte todos los

texto = "Hola Mundo" caracteres de la cadena a
.upper() print([Link]()) mayúsculas. Útil para
# Salida: HOLA MUNDO normalizar texto antes de
guardarlo o procesarlo.

texto = "python es genial" Capitaliza la primera letra de

print([Link]()) cada palabra en la cadena.
.title()
Muy útil para formatear
# Salida: Python Es Genial
nombres o títulos.

Elimina los espacios en

texto = " Hola Mundo " blanco al principio y al final
.strip() print([Link]()) de la cadena. Perfecto para
# Salida: Hola Mundo limpiar entradas de usuarios
o datos importados.

texto = "Hola Mundo" Reemplaza una subcadena

print([Link]("Mundo", por otra dentro de la cadena.
.replace()
"Python")) Muy útil para realizar
# Salida: Hola Python modificaciones en texto.

Devuelve True si la cadena

texto = "Hola Mundo" comienza con la subcadena
.startswith() print([Link]("Hola")) especificada; de lo contrario,
# Salida: True devuelve False. Ideal para
validaciones.

texto = "Hola Mundo" Devuelve True si la cadena

print([Link]("Mundo")) termina con la subcadena
.endswith()
especificada; de lo contrario,
# Salida: True
devuelve False.

Devuelve la posición de la
texto = "Hola Mundo" primera aparición de una
.find() print([Link]("Mundo")) subcadena dentro de la
# Salida: 5 cadena, o -1 si no la
encuentra.

texto = "123" Devuelve un valor booleano

.isdigit() print([Link]()) True si todos los valores de
# Salida: True la cadena de entrada son
 dígitos; de lo contrario,
devuelve False

Acá tenés un ejemplo práctico que utiliza varios de los métodos mencionados, con
comentarios detallados para explicar cada paso:

# Texto inicial
texto = " Python es un LENGUAJE poderoso. "

# Convertimos todo el texto a minúsculas

texto_min = [Link]()
print("Texto en minúsculas:", texto_min)
# Salida: " python es un lenguaje poderoso. "

# Convertimos todo el texto a mayúsculas

texto_may = [Link]()
print("Texto en mayúsculas:", texto_may)
# Salida: " PYTHON ES UN LENGUAJE PODEROSO. "

# Eliminamos los espacios en blanco al principio y al final

texto_sin_espacios = [Link]()
print("Texto sin espacios:", texto_sin_espacios)
# Salida: "Python es un LENGUAJE poderoso."

# Reemplazamos la palabra "LENGUAJE" por "lenguaje"

texto_reemplazado = texto_sin_espacios.replace("LENGUAJE", "lenguaje")
print("Texto modificado:", texto_reemplazado)
# Salida: "Python es un lenguaje poderoso."

# Verificamos si el texto comienza con "Python"

comienza_con_python = texto_reemplazado.startswith("Python")
print("¿El texto comienza con 'Python'?", comienza_con_python)
# Salida: True

# Verificamos si el texto termina con un punto

termina_con_punto = texto_reemplazado.endswith(".")
print("¿El texto termina con un punto?", termina_con_punto) # Salida:
True
# Capitalizamos la primera letra de cada palabra
texto_titulo = texto_reemplazado.title()
print("Texto en formato título:", texto_titulo) # Salida: "Python Es
Un Lenguaje Poderoso."

Veamos otro ejemplo práctico. El código siguiente solicita confirmar si está seguro o no, y
utiliza algunos de los métodos explicados para procesar y evaluar la respuesta:

# Solicitamos al usuario que confirme si está seguro

respuesta = input("¿Estás seguro? (si/no): ")

# Convertimos la respuesta a minúsculas para evitar

# problemas con mayúsculas o minúsculas y quitamos
# espacios en blanco
respuesta = [Link]().lower()

# Evaluamos la respuesta
if respuesta == "si":
print("Confirmación recibida. Procedemos con la acción.")
elif respuesta == "no":
print("Cancelaste la acción.")
else:
print("No entendí tu respuesta. Por favor ingresá 'si' o 'no'.")

Usamos .strip() para eliminar espacios al principio o al final (en caso de que el usuario
presione la barra espaciadora antes o después de escribir). También aplicamos .lower()
para convertir todo a minúsculas, asegurándonos de que no importe si escribiste "Sí", "SÍ" o
"si".

Formateo de cadenas con f-Strings

Formateo de cadenas con f-Strings

El formateo de cadenas con f-Strings es una de las maneras más eficientes y legibles de
combinar texto con valores variables en Python. Introducidas en la versión 3.6, las f-Strings
permiten integrar directamente expresiones y variables dentro de una cadena, utilizando
llaves {} para delimitar el contenido dinámico. Esto hace que el código sea más claro y fácil
de mantener en comparación con otras técnicas de formateo. Su utilidad es enorme, ya que
podés generar mensajes personalizados, reportes dinámicos o simplemente mostrar
información formateada de manera profesional con un esfuerzo mínimo. Además, las
f-Strings soportan expresiones complejas, lo que las convierte en una herramienta poderosa
para la creación de cadenas dinámicas.

Las f-Strings permiten no solo incluir valores dinámicos en cadenas, sino también aplicar
comandos y formatos para presentar la información de manera clara y profesional. Estas
herramientas hacen que las f-Strings sean extremadamente versátiles para formatear
números, fechas y texto. Veamos los principales comandos y formatos que podés usar,
junto con algunos ejemplos:

1. Inclusión de variables
La forma básica de usar f-Strings es incluir variables directamente dentro de las llaves {}.

nombre = "María"
edad = 30
print(f"Hola, {nombre}. Tenés {edad} años.")
# Salida: Hola, María. Tenés 30 años.

Las variables se colocan dentro de las llaves y Python las reemplaza automáticamente por
su valor.

2. Expresiones dentro de las llaves

Podés incluir cálculos y expresiones directamente dentro de las llaves.

a = 5
b = 3
print(f"La suma de {a} y {b} es {a + b}.")
# Salida: La suma de 5 y 3 es 8.

Esto te permite realizar operaciones sin necesidad de calcular el valor antes de la f-String.

3. Formateo de números
Con las f-Strings, podés aplicar formatos para ajustar cómo se muestran los números.

Decimales: Podés limitar la cantidad de decimales utilizando :.nf, donde n es el número de

decimales deseados.

pi = 3.14159
print(f"El valor de π con 2 decimales es {pi:.2f}.")
# Salida: El valor de π con 2 decimales es 3.14.

Números grandes: Podés agregar separadores de miles con :,. (dos puntos seguidos del
separador, que puede ser un punto o una coma):

numero = 1000000
print(f"El número es {numero:,}.")
# Salida: El número es 1,000,000.

Porcentajes: Usá % para formatear como porcentaje.

porcentaje = 0.85
print(f"El porcentaje es {porcentaje:.0%}.")
# Salida: El porcentaje es 85%.

4. Formateo de texto
Podés usar especificadores para ajustar cómo se muestra el texto.

Alineación: Usá <, > o ^ para alinear texto a la izquierda, derecha o centro, respectivamente.

texto = "Python"
print(f"{texto:<10}") # Salida: Python (alineado a la izquierda)
print(f"{texto:>10}") # Salida: Python (alineado a la derecha)
print(f"{texto:^10}") # Salida: Python (centrado)

Relleno: Podés agregar un carácter de relleno antes de los especificadores de alineación.

print(f"{texto:*<10}") # Salida: Python****

print(f"{texto:*>10}") # Salida: ****Python
print(f"{texto:*^10}") # Salida: **Python**

5. Escapando llaves
Si necesitás incluir llaves {} como texto y no como parte de una f-String, simplemente
duplicalas.

print(f"Este es un ejemplo de llaves: {{y esta es una llave dentro de

la cadena}}.")
# Salida: Este es un ejemplo de llaves: {y esta es una llave dentro de
la cadena}.

Las f-Strings no sólo son prácticas para incluir variables, sino que también te permiten
formatear números, texto y otros tipos de datos con un control increíble. Ya sea que estés
creando reportes, mensajes personalizados o (como veremos más adelante) visualizando
datos complejos, las f-Strings te ofrecen las herramientas necesarias para hacerlo de
manera clara y simple.

Ruta de avance hacia el Trabajo Final Integrador

(TFI)
Ruta de avance hacia el Trabajo Final Integrador (TFI)

Ahora que llegaste a la clase 4, estás en una posición ideal para comenzar a trabajar en los
cimientos del programa que desarrollarás como parte del Trabajo Final Integrador (TFI).
Como sabés, en este proyecto, vas a crear una aplicación en Python que gestione
información sobre los productos de una tienda. Es importante que empieces a planificar
cómo integrar lo que aprendiste hasta ahora.

Con los conocimientos adquiridos en las clases anteriores, ya podés diseñar la estructura
básica del programa. Por ejemplo, podés usar cadenas de texto para almacenar nombres,
descripciones y cualquier otro dato textual. También podés aplicar los métodos de cadenas
para validar y formatear la información que se ingrese por la terminal, como convertir todo a
minúsculas o eliminar espacios en blanco innecesarios.

La validación de las entradas es otro aspecto fundamental que podés abordar con lo
aprendido en las clases 3 y 4. Las estructuras condicionales como if, elif y match te
permiten manejar diferentes escenarios. Por ejemplo, podés validar que un correo
electrónico incluya el carácter @ o que una edad ingresada sea un número positivo. Esto
hace que tu programa sea más robusto y resistente a errores de ingreso.

También es importante planificar cómo va a interactuar el usuario con tu programa. Podés

usar lo que aprendiste para mostrar menús simples que permitan elegir entre distintas
opciones, como registrar un cliente o consultar los datos ingresados. Pensá en aplicar
condicionales y métodos de cadenas para hacer más clara y amigable la presentación de
estas opciones.

Aunque todavía no aprendiste a trabajar con bases de datos ni a guardar datos de manera
persistente, no te preocupes. Más adelante en el curso, vamos a integrar estas
herramientas con bases de datos para completar la funcionalidad del proyecto.
Como tarea concreta, te sugerimos que crees un programa que solicite los datos de un
producto y los muestre en formato de tarjeta o ficha, utilizando f-Strings para formatear la
salida. Aprovechá los métodos de cadenas para validar las entradas y asegurarte de que
estén en el formato correcto.

Experimentá. Recordá que cada paso que avances ahora va a facilitar el

desarrollo del proyecto final. Es mejor empezar con algo pequeño e ir
construyendo sobre eso, en lugar de intentar resolver todo de una sola vez.

Ejercicio Práctico
Luego de haber pasado el día con Luis y aprendido a utilizar condicionales avanzados y los
métodos de las cadenas, estás en condiciones de resolver la tarea que te mencionó
Mariana y que acaba de formalizar mediante un correo electrónico:

Nuestro cliente nos pide que el programa ahora haga lo

siguiente:

●​ Formatee correctamente los textos ingresados en

“apellido” y “nombre”, convirtiendo la primera letra de
cada palabra a mayúsculas y el resto en minúsculas.
●​ Asegurarse que el correo electrónico no tenga espacios
y contenga solo una “@”.
●​ Que clasifique a sus clientes por rango etario
basándose en su edad (“Niño/a” para los y las
menores de 15 años, “Adolescente” de 15 a 18 y
“Adulto/a” para personas mayores de 18 años.)

El programa debe mostrar el apellido, nombre y dirección de

correo con el formato pedido, y el texto correspondiente a su
rango etario.

¡Estoy segura de que harás un excelente trabajo!

Materiales y Recursos Adicionales:
Artículos:

Python Docs: Más herramientas para control de flujo

FreeCodeCamp: Tutorial de f-strings en Python

El libro de Python: Cadenas Python

Preguntas para reflexionar:

1.​ ¿Cómo creés que las herramientas avanzadas como elif y match pueden simplificar
la lógica de un programa en comparación con los condicionales básicos? Pensá en
ejemplos concretos donde estas estructuras serían especialmente útiles.
2.​ ¿De qué manera los métodos de cadenas como .lower(), .upper() o .title() te
permiten mejorar la calidad de los datos ingresados por los y las usuarios? ¿Qué
impacto podría tener esto en programas más complejos o en aplicaciones del mundo
real?
Próximos pasos:
En la próxima clase, incorporaremos el manejo del flujo de control aprendiendo a trabajar
con los bucles while. Esta herramienta es indispensable para repetir acciones de forma
controlada, permitiéndote realizar tareas que antes requerían múltiples líneas de código con
estructuras condicionales. Aprenderás a usar contadores y acumuladores para procesar
datos de manera más eficiente, lo cual es fundamental para trabajar con listas y grandes
volúmenes de información.

También vas a explorar las sentencias break y continue, que te permiten salir
anticipadamente de un bucle o saltar a la siguiente iteración, adaptando el comportamiento
de tu programa a situaciones específicas. Estas herramientas, combinadas con las
estructuras condicionales que ya manejás, te darán el control necesario para construir
programas más dinámicos y robustos.

Por último, introduciremos las listas, una estructura poderosa para almacenar y manipular
múltiples valores. Esto te permitirá empezar a organizar datos de una manera más flexible,
como guardar la información de varios clientes o productos en un solo lugar, preparándote
para los desafíos más complejos del Trabajo Final Integrador.

¡Seguimos avanzando hacia programas más eficientes y completos! Llegar preparado con
una buena comprensión de las herramientas vistas hasta ahora hará que puedas
aprovechar al máximo las nuevas técnicas que vamos a desarrollar en la próxima clase.
Clase N° 5 | Bucles While
Temario:
●​ Control de flujo: bucles while.
●​ Concepto y uso de contadores y acumuladores.
●​ Sentencias break y continue.
●​ Introducción a listas como estructuras para almacenar múltiples valores.

Objetivos de la Clase
En esta clase, aprenderás a utilizar los bucles while, una herramienta fundamental para
repetir bloques de código bajo ciertas condiciones. Verás cómo relacionar las estructuras
condicionales que ya manejás con el control de flujo mediante bucles, lo que te permitirá
crear programas más dinámicos y eficientes.

También vas a incorporar los conceptos de contadores y acumuladores, entendiendo

cómo usarlos para realizar cálculos iterativos, procesar datos y resolver problemas que
requieran seguimiento de valores acumulativos. Además, explorarás las sentencias break y
continue, y descubrirás cómo estas pueden modificar el comportamiento de un bucle según
las necesidades de tu programa.

Finalmente, comenzarás a trabajar con listas, una estructura poderosa para almacenar
múltiples valores en un solo lugar. Aprenderás a crearlas, asignarles valores y recuperarlos,
preparando el camino para gestionar datos más complejos en tus futuros proyectos.
Otra mañana en TechLab 🚀

La primera reunión del día en TalentoLab te deja claro que todavía tenés un largo camino
por delante. Hasta ahora, hiciste un gran trabajo con los datos de una persona. Pero en el
mundo real, se necesitan procesar datos de muchas personas o incluso durante varios
períodos. Por eso, en la reunión de equipo Mariana te explica que necesitamos un software
que ayude a registrar y calcular información financiera básica para nuestras y nuestros
clientes.

“Necesitamos registrar los ingresos mensuales de una persona durante

6 meses. Además, hay que validar que éstos sean números positivos. Y,
por supuesto, calcular el importe total de los ingresos acumulados
durante los 6 meses.“

Como siempre, vas a necesitar aprender algunas nuevas características y estructuras de

control para poder realizar esta tarea. En ese momento, se abre la puerta de la sala de
reuniones y entra Luis, dispuesto como siempre a ayudarte. ¡Allá vamos!
Control de flujo: bucles while
Hasta ahora, aprendiste a manejar el flujo de un programa utilizando estructuras
condicionales como if, elif y else. Estas herramientas son esenciales para tomar
decisiones dentro de un programa, pero ¿qué pasa si necesitás que una acción se repita
varias veces? Acá es donde los bucles while entran en juego.

Un bucle while permite repetir un bloque de código mientras se cumpla una condición
específica. Esto significa que el programa va a evaluar esa condición antes de ejecutar cada
iteración del bucle. Si la condición es True, el código dentro del bucle se ejecuta; si es
False, el bucle termina y el programa continúa con las instrucciones que siguen.

La sintaxis básica de un bucle while es la siguiente:

while condición:
# Código que se ejecuta mientras la condición sea True

Es importante que dentro del bucle haya algo que eventualmente haga que la
condición sea False, porque si no, el programa entraría en lo que llamamos un
"bucle infinito". Un bucle infinito sigue ejecutándose sin detenerse y puede
hacer que tu programa deje de responder.

Veamos un caso sencillo para entender cómo funciona:

contador = 1

while contador <= 5:

print(f"Este es el intento número {contador}.")
contador += 1 # Incrementamos el valor de contador

print("Bucle terminado.")

En este ejemplo:

●​ El bucle comienza con la variable contador igual a 1.

●​ La condición contador <= 5 se evalúa al inicio de cada iteración.
●​ Dentro del bucle, imprimimos un mensaje con el valor actual de contador y luego lo
incrementamos en 1 usando contador = contador + 1.
 ●​ Cuando contador llega a 6, la condición contador <= 5 se vuelve False, y el bucle
termina.

Salida del programa:

Este es el intento número 1.

Este es el intento número 2.
Este es el intento número 3.
Este es el intento número 4.
Este es el intento número 5.
Bucle terminado.

Luis: “contador += 1 es una versión abreviada de contador = contador + 1,

que hace lo mismo, pero es más concisa y se usa comúnmente en Python.
Ambas son equivalentes, y podés usar cualquiera según tu preferencia o el
nivel de detalle que quieras mostrar en tu código.”

¿Cuándo usar un bucle while?

Un bucle while es ideal cuando no sabés de antemano cuántas veces se debe repetir una
acción. Por ejemplo:

●​ Pedir datos al usuario hasta que ingrese algo válido.

●​ Realizar cálculos hasta que se alcance un determinado resultado.
●​ Procesar datos en una lista mientras queden elementos por analizar.

En este ejemplo, vamos a pedirle a la persona que ingrese su nombre. Sin embargo,
queremos asegurarnos de que no deje el campo vacío. Usaremos un bucle while para
repetir la solicitud hasta que el usuario ingrese un nombre válido:

# Inicializamos una variable vacía para almacenar el nombre

nombre = ""

# Usamos un bucle while para seguir pidiendo un nombre hasta que

# el usuario ingrese algo válido

while nombre == "":

 # Solicitamos al usuario que ingrese su nombre.
# .strip() elimina espacios en blanco al principio y al final
​
nombre = input("Ingresá tu nombre: ").strip()

if nombre == "": # Verificamos si el nombre está vacío

print("El nombre no puede estar vacío. Intentá de nuevo.")

# Si el bucle termina, mostramos un mensaje con el nombre ingresado

print(f"¡Hola, {nombre}! Gracias por ingresar tu nombre.")

Este programa comienza inicializando la variable nombre con una cadena vacía. Luego,
establece un bucle while que seguirá ejecutándose mientras nombre esté vacío. Dentro del
bucle, se solicita a la persona que ingrese su nombre. La función .strip() se usa para
eliminar cualquier espacio en blanco al principio o al final de la entrada, asegurando que
incluso si se ingresaron śolo espacios, la validación detecte que no es un dato válido.

Si la entrada está vacía, el programa muestra un mensaje indicando que vuelva a intentarlo.
Una vez que se ingresa un nombre válido, el bucle se detiene y el programa muestra un
saludo personalizado. Esto garantiza que el flujo del programa continúe solo cuando los
datos ingresados sean adecuados.

Contadores en bucles while.

Un contador es una variable que se utiliza dentro de un bucle para realizar un seguimiento
de cuántas veces se repite. En los bucles while, los contadores son fundamentales porque
nos permiten controlar cuántas iteraciones se realizan, detener el bucle en el momento
correcto o realizar acciones específicas en cada repetición.

Por lo general, un contador se inicializa antes del bucle, se actualiza en cada iteración
(normalmente sumándole 1) y se utiliza como parte de la condición del bucle o para tomar
decisiones dentro de él. Vamos a analizar un par de ejemplos prácticos para entender cómo
funcionan.

Ejemplo 1: Mostrar los números del 1 al 5

Este ejemplo utiliza un contador para generar y mostrar una secuencia de números desde 1
hasta 5.

# Inicializamos el contador en 1
contador = 1

# Creamos un bucle que se ejecuta mientras el contador

# sea menor o igual a 5
while contador <= 5:
# Mostramos el valor actual del contador
print(f"Número: {contador}")

# Incrementamos el contador en 1
contador += 1

# Mensaje final una vez que el bucle termina

print("Bucle terminado.")

En este caso, el contador comienza en 1 y se incrementa en cada iteración con contador

+= 1. El bucle se ejecuta mientras la condición contador <= 5 sea verdadera. Cuando el
contador llega a 6, la condición se vuelve falsa y el bucle termina.

Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Bucle terminado.

Este tipo de bucle es ideal para ejecutar una acción un número fijo de veces.

Ejemplo 2: Solicitar un nombre de usuario con un máximo de 3 intentos

En este ejemplo, utilizamos un contador para limitar la cantidad de intentos que tiene la
persona para ingresar su nombre de usuario.

# Inicializamos el contador en 0
intentos = 0

# Establecemos el máximo de intentos permitidos

max_intentos = 3

# Usamos un bucle que se detendrá si el usuario

# ingresa un nombre válido o si se agotan los intentos
while intentos < max_intentos:
# Solicitamos al usuario que ingrese su nombre
nombre = input("Ingresá tu nombre de usuario: ").strip()

# Verificamos si el nombre ingresado no está vacío

if nombre != "":
print(f"Bienvenido/a, {nombre}!") # Mensaje de éxito
break # Salimos del bucle si se ingresa un nombre válido
else:
print("El nombre no puede estar vacío. Intentá de nuevo.")

# Incrementamos el contador de intentos

intentos += 1

# Verificamos si se agotaron los intentos

if intentos == max_intentos:
print("Se agotaron los intentos. Intente más tarde.")

En este programa, la variable intentos actúa como contador y se incrementa cada vez que
se ingresa un nombre no válido. Si se ingresa un nombre válido antes de alcanzar el
máximo de intentos (max_intentos), el programa muestra un mensaje de bienvenida y sale
del bucle con break. Si se alcanzan los 3 intentos y no se ingresó un nombre válido, el
programa finaliza mostrando un mensaje de error. Esta es una salida posible del programa:

Ingresá tu nombre de usuario:

El nombre no puede estar vacío. Intentá de nuevo.
Ingresá tu nombre de usuario:
El nombre no puede estar vacío. Intentá de nuevo.
Ingresá tu nombre de usuario: Pedro
Bienvenido/a, Pedro!

Este tipo de uso de contadores es especialmente útil en programas que

requieren limitar la cantidad de intentos para realizar una acción, como
autenticarse o completar un formulario.
Break.
La sentencia break en Python se utiliza para terminar un bucle de forma inmediata, sin
esperar a que se cumpla la condición del bucle. Esto significa que, cuando se ejecuta break,
el programa salta automáticamente a la siguiente línea de código después del bucle,
ignorando cualquier iteración restante.

Es especialmente útil cuando querés salir de un bucle antes de que su condición se vuelva
False, por ejemplo, al encontrar un resultado deseado o al detectar una situación específica
que hace innecesario continuar.

Luis: “En muchos casos es posible evitar el uso de break modificando la

condición del bucle. Aunque break es una herramienta válida, muchas
veces se puede lograr el mismo resultado con un diseño cuidadoso del
flujo lógico del programa.”

Por ejemplo, podemos reescribir el programa de solicitud de nombre de usuario con un

máximo de tres intentos sin usar break, ajustando la condición del bucle para que se
detenga automáticamente cuando se ingrese un nombre válido o se alcancen los intentos
permitidos.

# Inicializamos el contador en 0
intentos = 0

# Establecemos el máximo de intentos permitidos

max_intentos = 3

nombre = "" # Variable para almacenar el nombre

while intentos < max_intentos and nombre == "":
# Solicitamos al usuario que ingrese su nombre
nombre = input("Ingresá tu nombre de usuario: ").strip()

# Verificamos si el nombre ingresado está vacío

if nombre == "":
print("El nombre no puede estar vacío. Intentá de nuevo.")
intentos += 1 # Incrementamos el contador de intentos

# Verificamos si se ingresó un nombre válido o si se agotaron los

intentos
if nombre != "":
# Mensaje de éxito
print(f"Bienvenido/a, {nombre}!")
else:
# Mensaje de error
print("Se agotaron los intentos. Intente más tarde.")

Esta es una salida posible del programa anterior:

Ingresá tu nombre de usuario:

El nombre no puede estar vacío. Intentá de nuevo.
Ingresá tu nombre de usuario: Ana
Bienvenido/a, Ana!

La sentencia continue.
La sentencia continue se utiliza dentro de bucles para omitir el resto del código en la
iteración actual y pasar directamente a la siguiente iteración. A diferencia de break, que
termina el bucle por completo, continue sólo salta la ejecución restante en la iteración
actual, permitiendo que el bucle continúe funcionando como está diseñado.

Esto es útil cuando querés evitar ciertas condiciones específicas dentro del
bucle, pero sin detener todo el proceso.

En este ejemplo, vamos a pedirle al usuario que ingrese un número positivo. Si el número
ingresado es negativo, utilizaremos la sentencia continue para saltar el resto del código de
esa iteración y pedir otro número.

# Inicializamos una variable para controlar el bucle

numero = 0

print("Ingresá números positivos para sumarlos. Ingresá 0 para

terminar.")

# Usamos un bucle while que se ejecuta hasta que el usuario ingrese 0

suma = 0
while True:
# Solicitamos al usuario un número
numero = int(input("Ingresá un número: "))

# Verificamos si el número es negativo

if numero < 0:
 print("El número es negativo, se ignora. Intentá de nuevo.")
continue # Saltamos el resto del código en esta iteración

# Si el número es 0, salimos del bucle

if numero == 0:
break

# Sumamos el número positivo al total

suma += numero

# Mostramos el resultado final

print(f"La suma de los números positivos es: {suma}")

El programa solicita que ingrese números positivos para sumarlos. Si se ingresa un número
negativo, el programa utiliza la sentencia continue para saltar el resto del código en esa
iteración, evitando que el número negativo se sume al total. Si se ingresa 0, el programa
utiliza break para salir del bucle, ya que ese es el indicador de que se terminó de ingresar
datos.

Mientras se sigan ingresando números positivos, estos se suman en la variable suma.

Finalmente, el programa muestra el total de los números positivos ingresados.

Ingresá números positivos para sumarlos. Ingresá 0 para terminar.

Ingresá un número: 10
Ingresá un número: -1
El número es negativo, se ignora. Intentá de nuevo.
Ingresá un número: 20
Ingresá un número: 5
Ingresá un número: 0
La suma de los números positivos es: 35

Acumulador.
En el ejemplo anterior, la variable suma cumple el rol de un acumulador. Un acumulador es
una variable que se utiliza para almacenar un valor que va aumentando (o disminuyendo)
de manera progresiva a lo largo de las iteraciones de un bucle. Generalmente, se inicializa
con un valor base (por ejemplo, 0 para una suma o 1 para una multiplicación), y luego se le
van agregando o combinando valores durante cada iteración del bucle.
 El propósito de un acumulador es mantener un registro de un cálculo o un
resultado parcial que depende de los datos procesados en el bucle.

Introducción a las listas como estructuras para

almacenar múltiples valores.
Una lista es una estructura de datos en Python que te permite almacenar múltiples valores
en un solo lugar. A diferencia de las variables simples, que contienen un solo dato, las listas
pueden contener varios elementos, como números, cadenas o incluso otras listas. Las listas
son extremadamente útiles cuando querés trabajar con colecciones de datos, ya que te
permiten agrupar información relacionada y acceder a ella de manera sencilla.

Las listas en Python se definen utilizando corchetes [], y los elementos se separan por
comas. Podés agregar, modificar o eliminar elementos de una lista, lo que las convierte en
una herramienta muy flexible para manejar datos en tus programas, y que pronto
aprenderemos a utilizar a fondo. Por ahora, veremos cómo se crean y cómo podemos
utilizarlas con while.

Creación de listas y acceso a sus elementos.

Antes de usar listas dentro de un bucle while, es fundamental entender cómo se crean y
cómo acceder a los valores que contienen utilizando índices. Una lista es simplemente una
colección ordenada de elementos que podés manipular fácilmente. Los elementos de una
lista están numerados por su posición, empezando desde el índice 0.

Creación de listas
Para crear una lista en Python, usás corchetes [] y separás los elementos con comas. Una
lista puede contener cualquier tipo de dato, como números, cadenas o incluso otras listas.

# Ejemplo de lista de números

numeros = [10, 20, 30, 40, 50]

# Ejemplo de lista de cadenas

nombres = ["Ana", "Luis", "Carlos"]

# Lista vacía
lista_vacia = []
Acceso a los elementos de una lista
Podés acceder a los elementos de una lista utilizando su índice. El primer elemento tiene el
índice 0, el segundo el índice 1, y así sucesivamente.

# Lista de ejemplo
frutas = ["manzana", "banana", "cereza"]

# Accedemos a los elementos por índice

print(frutas[0]) # Salida: manzana
print(frutas[1]) # Salida: banana
print(frutas[2]) # Salida: cereza

Si intentás acceder a un índice que no existe, Python genera un error. Por ejemplo, frutas[3]
daría error porque la lista tiene solo tres elementos (0, 1, y 2).

El uso de índices en las listas seguramente te resulta familiar, ya que comparte

muchas de sus características con las cadenas de caracteres.

Índices negativos
Python también permite usar índices negativos para acceder a los elementos desde el final
hacia el principio. Por ejemplo, el índice -1 representa el último elemento de la lista.

# Lista de ejemplo
frutas = ["manzana", "banana", "cereza"]

# Acceso usando índices negativos

print(frutas[-1]) # Salida: cereza (último elemento)
print(frutas[-2]) # Salida: banana

Con este conocimiento, podés entender cómo manipular y trabajar con los elementos de
una lista. Ahora, veamos cómo integrar las listas con los bucles. Por ejemplo, podemos
usarlos para procesar valores de una lista en un bucle while:
# Lista de números
numeros = [10, 20, 30, 40, 50]

# Inicializamos un índice para recorrer la lista

indice = 0

# Usamos un bucle while para iterar sobre la lista

# len(numeros) = cantidad de elementos en la lista
while indice < len(numeros):
# Mostramos el valor actual
print(f"El valor en el índice {indice} es: {numeros[indice]}")

# Incrementamos el índice para pasar al siguiente elemento

indice += 1

print("Fin del bucle.")

En el código proporcionado, primero creamos una lista llamada números que contiene los
datos que queremos procesar. A continuación, inicializamos un índice que usaremos para
llevar el control de la posición actual dentro de la lista que estamos procesando.

El bucle while comienza con la condición indice < len(numeros), lo que significa que
seguirá ejecutándose mientras el valor de indice sea menor que la longitud de la lista
numeros.

Dentro del bucle, en cada iteración, accedemos al elemento de la lista que corresponde al
índice actual utilizando numeros[indice]. Luego, mostramos en pantalla el valor de ese
elemento junto con su índice correspondiente mediante la función print().

Después de imprimir el valor, incrementamos el valor de indice en 1 utilizando indice += 1

para avanzar al siguiente elemento de la lista en la próxima iteración del bucle. El bucle
continúa este proceso hasta que indice ya no sea menor que la longitud de la lista.
Finalmente, se imprime el mensaje "Fin del bucle." para indicar que el procesamiento ha
concluido. ¡Probalo!
Ejercicio Práctico.
El día ha sido largo, pero Luis ha conseguido que entiendas un montón de conceptos
nuevos. Conceptos poderosos, que seguramente vas a tener que profundizar pronto. Pero
lo importante es que con todo lo aprendido hoy, ya puedes resolver el pedido que Mariana
te hizo a la mañana. Como es usual, te lo ha formalizado mediante un correo electrónico:
¡Buenas tardes!

Necesitamos un software que ayude a registrar y calcular

información financiera básica para nuestros y nuestras clientes. Tu
tarea para esta semana es la siguiente:

●​ Registrar los ingresos mensuales de un cliente durante 6 meses. Usá un bucle

while para solicitar el ingreso de cada mes.
●​ Validar que los ingresos sean números positivos. Si se ingresa un valor negativo,
mostrá un mensaje indicando que el valor no es válido y volvé a pedir el dato.
●​ Calcular el ingreso total acumulado durante los 6 meses. Mostrá este resultado al
final del programa.

¡Estoy segura de que harás un excelente trabajo!

Materiales y Recursos Adicionales:

Artículos:

IONOS: Bucle while en Python

[Link]: Explicación del búcle While de Python

El libro de Python: Bucle while

Videos:

Tutoriales sobre Ciencia y Tecnología: Bucles while en Python y Acumulador en bucles while

Preguntas para reflexionar:

1.​ ¿Cómo podés asegurarte de que un bucle while no se convierta en un bucle infinito?
Pensá en la importancia de actualizar correctamente las variables involucradas en la
condición del bucle.
 2.​ Reflexioná sobre las diferencias entre usar las sentencias break y continue. ¿En qué
situaciones podrían ser más útiles cada una de estas herramientas?
3.​ Al recorrer una lista con un bucle while, ¿qué pasos considerás esenciales para
garantizar que cada elemento sea procesado correctamente y que el bucle finalice
en el momento adecuado?

Próximos pasos:
En la siguiente clase, ampliarás tu conocimiento sobre cómo manejar algunas tareas
repetitivas de manera más directa y eficiente con el bucle for. Esta herramienta te permitirá
recorrer estructuras como cadenas o listas sin necesidad de controlar manualmente cada
iteración, simplificando el código y haciéndolo más legible.

Además, explorararemos la función range() y profundizaremos en las diferencias entre los

bucles while y for. Por último, introduciremos las listas, una estructura poderosa para
almacenar y manipular múltiples valores.​
​
¡Seguimos avanzando hacia programas más eficientes y completos!
Clase N° 6 | Bucles For y Range()
Temario:
●​ Control de flujo: bucles for.
●​ Función range().
●​ Recorrer cadenas y listas con bucles while y for.

Objetivos de la Clase
Incorporar el uso del bucle for, una herramienta clave para recorrer estructuras de datos
como cadenas y listas de manera eficiente. Aprender cómo este tipo de bucle permite
simplificar y agilizar tareas repetitivas.

Explorar la función range(), que facilita la generación de secuencias numéricas, abriendo

nuevas posibilidades para iterar sobre rangos definidos de valores. Este concepto será
fundamental para abordar problemas de programación con soluciones más claras y
estructuradas.

Comparar el comportamiento y las aplicaciones de los bucles for y while, profundizando en

sus diferencias y usos específicos. ​
​
​
​
¡Sexto día en TalentoLab! 🚀

Llegás a TalentoLab con entusiasmo y, mientras disfrutás de tu café matutino, te reunís con
Mariana, la Gerente de Proyectos. Mariana, satisfecha con tu progreso, te motiva a
enfrentar un nuevo desafío que te ayudará a manejar mejor la validación y procesamiento
de datos.

“Necesitamos crear una lista con los nombres de los clientes que vamos
a procesar. Además, es necesario detectar si alguno de los nombres
está en blanco y mostrar una alerta en esos casos. Luego, para los
nombres válidos, nos aseguraremos que uno comience con una letra
mayúscula y el resto en minúsculas.”

Más tarde, te reunís con Luis, el desarrollador senior. Junto a él, revisan los conceptos
básicos que necesitarás para completar esta misión. Luis te muestra ejemplos prácticos de
cómo detectar cadenas vacías y aplicar métodos para formatear los nombres
adecuadamente.
Control de flujo: bucles for
Imaginemos que estás gestionando una pequeña tienda y creaste una lista con todos los
productos que posee el inventario. Cada vez que quieras ver los productos o procesar los
datos, sería tedioso hacerlo manualmente uno por uno. Aquí es donde el bucle for se
convierte en una herramienta fundamental. Nos permite recorrer automáticamente esa lista
y trabajar con cada elemento de manera rápida y eficiente.

A diferencia del bucle while, que sigue ejecutándose hasta que una condición se vuelva
falsa, el bucle for es ideal cuando ya sabés exactamente cuántas veces necesitás repetir
una acción. En el caso del inventario de productos, por ejemplo, podemos recorrer todos los
elementos de la lista de productos con for, mostrándolos uno a uno sin importar cuántos
productos haya.

¿Cómo funciona el bucle for?

El bucle for toma una secuencia (una lista, una cadena de texto, un rango numérico) y la
recorre de principio a fin, ejecutando un bloque de código para cada elemento en la
secuencia. Es como una cadena de montaje: cada elemento de la secuencia pasa por el
mismo proceso, uno tras otro. Esta es la sintaxis básica del bucle:

for variable in secuencia:

# Bloque de código

Supongamos que tenés una lista de productos en tu tienda, y querés mostrar cada uno de
ellos.

productos = ["manzanas", "naranjas", "bananas", "peras"]

for producto in productos:

print("Producto disponible:", producto)

Este ejemplo es súper simple, pero te permite ver el concepto en acción. En cada repetición
del bucle, la variable producto toma uno de los elementos de la lista y lo muestra en
pantalla.
Producto disponible: manzanas
Producto disponible: naranjas
Producto disponible: bananas
Producto disponible: peras

Por supuesto, podrías haber logrado lo mismo usando un bucle while, pero como se ve en
el código siguiente, se requieren algunas líneas más, y el uso de un contador para poder
hacer lo mismo:

productos = ["manzanas", "naranjas", "bananas", "peras"]

i = 0
while i < len(productos):
print("Producto disponible:", productos[i])
i += 1

Podés probarlo y comprobar que la salida por la terminal es la misma.

Bucle for: Iterando a través de cadenas.

Sabemos que una cadena de texto en Python es una secuencia de caracteres. Esto
significa que, usando for, podemos recorrerla carácter por carácter. Por ejemplo, si tenés un
nombre o cualquier palabra, el bucle puede procesar cada letra individualmente.
Imaginemos que querés imprimir cada letra del nombre "Python":
palabra = "Python"

for letra in palabra:

print("Letra:", letra)
Este bucle for va a recorrer la cadena "Python" una letra a la vez. En cada iteración, la
variable letra va a tomar un valor distinto, empezando por "P", luego "y", después "t", y así
sucesivamente hasta recorrer toda la palabra. El resultado en pantalla será:

Letra: P
Letra: y
Letra: t
Letra: h
Letra: o
Letra: n

Pero ¿cómo funciona esto? Es muy simple: cada vez que el bucle for itera toma el siguiente
elemento de la secuencia. En este caso, la secuencia es la cadena de texto "Python". El
bucle continúa hasta que no quedan más elementos (letras) para procesar. Este concepto
de "iteración" es central en el bucle for: siempre recorrerá un objeto secuencial elemento por
elemento.

Break
El uso de break en un bucle for, tal como ocurre cuando lo usamos con while, permite
interrumpir la ejecución del bucle antes de que haya terminado su recorrido completo. Esto
es útil cuando querés detener el bucle en el momento en que una condición específica se
cumple, evitando que siga iterando innecesariamente.

Por ejemplo, imaginate que estás buscando un producto específico en una lista de
productos. Una vez que encontrás ese producto, no tiene sentido seguir buscando, por lo
que podrías utilizar break para detener el bucle.

Ejemplo:

# Lista de productos
productos = ["P001", "P002", "P003", "P004", "P005"]

# Producto que queremos encontrar

producto_a_buscar = "P003"

# Recorremos la lista buscando el producto

for producto in productos:
if producto == producto_a_buscar:
print("Producto encontrado:", producto)
 break # Detenemos el bucle al encontrar el producto
print("Buscando...")

print("Fin de la búsqueda.")

En este ejemplo, primero creamos una lista llamada ‘productos’, que contiene varios
códigos de productos. Luego, utilizamos un bucle for para recorrer cada uno de estos
códigos dentro de la lista. Mientras recorremos los productos, se verifica con una condición
‘if’ si el producto actual es igual al que estamos buscando, almacenado en la variable
‘producto_a_buscar’. Si esta condición se cumple, el programa imprime que el producto ha
sido encontrado y usa la instrucción ‘break’ para detener la ejecución del bucle
inmediatamente, evitando que siga buscando entre los demás productos.

Gracias a break el bucle no continúa una vez que se ha encontrado el producto

deseado. Si el producto no se hubiera encontrado, el bucle habría seguido
recorriendo el resto de la lista.

El objetivo de ‘break’ es optimizar el proceso, evitando iteraciones innecesarias. Esta es la

salida por pantalla:

Buscando...
Buscando...
Producto encontrado: P003
Fin de la búsqueda.
¿Qué es range()?
La función range() es muy útil para generar secuencias de números, lo que nos permite
controlar cuántas veces queremos que un bucle se repita tanto como recorrer listas
utilizando índices numéricos. Se utiliza principalmente con bucles for para ejecutar un
bloque de código un número determinado de veces.

La sintaxis básica de range() es la siguiente:

range(inicio, fin, paso)

Veamos qué significa cada uno de estos términos:

●​ inicio: Es el número donde comienza la secuencia (es opcional, por defecto es 0).
●​ fin: Es el número donde termina la secuencia (no incluye este valor).
●​ paso: Es el intervalo entre cada número de la secuencia (opcional, por defecto es su
valor es 1).

La función range() es útil para controlar cuántas veces se repite un bucle for. Nos permite:

●​ Definir un rango de números.

●​ Controlar desde dónde comienza y termina la secuencia.
●​ Ajustar el paso entre los números de la secuencia.

El uso de range() es fundamental cuando trabajás con iteraciones en Python,

especialmente para recorrer listas, repetir tareas un número fijo de veces o
manejar secuencias de números de manera versátil.

Ahora vamos a ver varios ejemplos para que te quede claro cómo funciona.
Ejemplo 1: Uso básico de range().
En este primer ejemplo, generamos una secuencia de números desde 0 hasta 4. Notá que
el número de "fin" (5) no está incluido.

for i in range(5):
print(i)

Esto es lo que verás en la pantalla:

0
1
2
3
4

Acá range(5) genera los números del 0 al 4. Python ejecuta el bucle for una vez por cada
número en esa secuencia.

Ejemplo 2: Valor de inicio específico.

Si queremos que el bucle comience desde un número distinto de 0, podemos indicarlo
pasando dos argumentos a range(inicio, fin).

for i in range(3, 7):

print(i)

Esto es lo que verás en la pantalla:

3
4
5
6

En este caso, range(3, 7) genera los números del 3 al 6, porque 7 es el límite superior, pero
no está incluido.
Ejemplo 3: El parámetro paso.
Podemos controlar el intervalo entre cada número de la secuencia con el parámetro paso.
Esto es útil si queremos saltar números.

for i in range(0, 10, 2):

print(i)

Esto es lo que verás en la pantalla:

0
2
4
6
8

Acá range(0, 10, 2) genera números desde 0 hasta 8, saltando de 2 en 2.

Ejemplo 4: Secuencias decrecientes.

También podemos usar range() para generar secuencias decrecientes, indicando un valor
de paso negativo.

for i in range(10, 0, -2):

print(i)

Esto es lo que verás en la pantalla:

10
8
6
4
2

En este caso, range(10, 0, -2) genera números desde 10 hasta 2, restando de 2 en 2.

Ejemplo 5: El uso de range() para recorrer listas

Podemos usar range() para iterar sobre los índices de una lista y acceder a sus elementos.
frutas = ["manzana", "banana", "naranja"]
for i in range(len(frutas)):
print(f"Fruta {i + 1}: {frutas[i]}")

Esta es la salida de ese código:

Fruta 1: manzana
Fruta 2: banana
Fruta 3: naranja

Acá estamos utilizando range(len(frutas)) para generar índices del 0 al 2, y con esos
índices accedemos a los elementos de la lista frutas.

range() es muy versátil, pero es posible que te dé un poco de trabajo recordar todas sus
opciones. Para ayudarte, Luis te proporciona el siguiente resumen:

Uso de
Ejemplo Descripción
range()

for i in range(5): Genera una secuencia que

print(i) empieza en 0 y termina en fin -
range(fin)
# Salida: 0, 1, 2, 3, 4 1.
El paso predeterminado es 1.

for i in range(2, 6): Genera una secuencia desde

range(inicio, print(i) inicio hasta fin - 1.
fin) El paso predeterminado es 1.
# Salida: 2, 3, 4, 5

for i in range(1, 10, 2): Genera una secuencia desde

range(inicio, print(i) inicio hasta fin - 1, avanzando de
fin, paso) acuerdo con el valor del paso.
# Salida: 1, 3, 5, 7, 9
Comparación entre while y for.
Hemos visto cómo los bucles nos permiten manejar tareas repetitivas de manera eficiente.
Ahora es importante que reflexionemos sobre una de las grandes ventajas del bucle for: su
capacidad para simplificar tareas que, con un bucle while, pueden volverse más laboriosas.

Cuando usás un bucle while, generalmente tenés que controlar variables como contadores
o índices de forma manual. Esto significa que necesitás inicializarlos, actualizarlos en cada
iteración y asegurarte de que la condición del bucle sea correcta. Sin embargo, con un bucle
for, podés recorrer directamente los elementos de una lista o una secuencia sin preocuparte
por gestionar esas variables, ya que Python lo hace automáticamente por vos.

Esta simplicidad no solo reduce posibles errores, sino que también hace que tu
código sea más fácil de leer y mantener. Aprender a identificar cuándo usar for
en lugar de while es clave para optimizar tus programas y trabajar de manera
más eficiente.

La sentencia continue en los bucles for funciona de la misma manera que en los bucles
while. Cuando Python encuentra un continue dentro de un bucle for, salta inmediatamente al
siguiente elemento de la lista o secuencia, ignorando cualquier código que quede por
ejecutar en la iteración actual. Esto es útil cuando querés omitir ciertos elementos que no
cumplen con una condición específica, pero querés que el bucle siga procesando el resto de
los elementos normalmente.

El bucle for en la práctica.

El bucle for y la función range() son herramientas fundamentales para procesar y manejar
múltiples datos, como los ingresos mensuales de un cliente. Con lo has aprendido, ya estás
preparado para crear soluciones más claras y organizadas, lo que te permitirá trabajar con
listas y realizar cálculos sin necesidad de gestionar manualmente contadores o índices
como en el bucle while.

Por ejemplo, imaginá que necesitás calcular el promedio de una serie de valores. Usando
un bucle for, podés recorrer una lista de números y sumar los valores de forma automática,
mientras simplificás el código y reducís posibles errores.

Aunque no podés aplicar directamente este código al Trabajo Final Integrador,

te da una idea de cómo trabajar con listas y condiciones para extraer
información útil de los datos.
# Lista de ingresos mensuales
ingresos = [40000, 55000, 60000, 45000, 70000, 50000]

# Definimos un umbral
umbral = 50000

# Inicializamos un contador para los ingresos superiores al umbral.

contador_superiores = 0

# Usamos un bucle for para recorrer la lista

for ingreso in ingresos:
if ingreso > umbral:
# Incrementamos el contador si el ingreso es mayor al umbral
contador_superiores += 1

# Mostramos el resultado
print(f"Cantidad de ingresos superiores a ${umbral}:
{contador_superiores}")

Este programa, con esos datos, genera la siguiente salida:

Cantidad de ingresos superiores a $50000: 3

Otro caso interesante donde el bucle for puede simplificar tareas es cuando necesitás
realizar un seguimiento de ciertos elementos que cumplen con una condición específica.
Por ejemplo, imaginá que estás trabajando con un sistema que procesa nombres de
usuarios y usuarias registrados, y querés identificar cuáles comienzan con una letra en
particular. Supongamos que querés encontrar todos los nombres que empiezan con la letra
"A" y veamos cómo aplicar esta lógica:

# Lista de nombres de usuarios y usuarias

usuarios = ["Ana", "Luis", "Andrés", "María", "Alejandro", "Lucía"]

# Letra que queremos buscar

letra_buscada = "A"
print(f"Nombres que comienzan con la letra '{letra_buscada}':")

# Usamos un bucle for para recorrer la lista

for usuario in usuarios:
if [Link](letra_buscada): # Verificamos si el nombre
comienza con la letra buscada
print(usuario)

Este código utiliza el método .startswith() para comprobar si cada nombre en la lista
comienza con la letra especificada. La variable letra_buscada define qué letra estás
buscando, y el bucle for se encarga de recorrer la lista usuarios. Si el nombre cumple la
condición, se imprime en pantalla.

Nombres que comienzan con la letra 'A':

Ana
Andrés
Alejandro

Este enfoque no solo simplifica el manejo de datos, sino que también demuestra cómo el
bucle for puede combinarse con otros métodos de cadenas para realizar tareas específicas,
junto a listas y condiciones,para resolver problemas más complejos en tus proyectos.
Ejercicio Práctico.
Luis está haciendo un excelente trabajo. Al finalizar la jornada, lograste entender la sintaxis
y utilidad de los bucles for, y lo súper útil que son para recorrer estructuras de datos. Con
estas herramientas estás listo para resolver el pedido de Mariana:

¡Buenas tardes!
Espero que estés bien. Tu tarea es la siguiente:

●​ Crear una lista con los nombres de los clientes y clientas

que vamos a procesar. Algunos nombres pueden estar en
blanco por lo que debemos poder detectarlo.

●​ Recorrer la lista y mostrar el nombre de cada cliente, junto con su posición en la

lista (por ejemplo, Cliente 1, Cliente 2, etc.).
●​ Si encuentras un o una cliente cuyo nombre sea una cadena en blanco, mostrar
un mensaje de alerta indicando que ese dato no es válido.
●​ Para los nombres válidos, convertir cada uno a formato adecuado usando
.capitalize(), de modo que siempre tengan la primera letra en mayúscula y el resto
en minúscula.

¡Estoy segura de que harás un excelente trabajo!

Materiales y Recursos Adicionales:

Artículos:
IONOS: Bucle for en Python
[Link]: Explicación del búcle for de Python
El libro de Python: Bucle for

Videos:

Tutoriales sobre Ciencia y Tecnología: Bucles for en Python y una Tabla de multiplicar con
bucle for
Preguntas para reflexionar:
1.​ ¿Qué diferencias encontrás entre el bucle while y el bucle for? Pensá en situaciones
específicas sean de programación o de la vida cotidiana en las que elegirías uno
sobre el otro y por qué.
2.​ Al recorrer listas con un bucle for, ¿qué ventajas encontrás frente a la gestión
manual de índices en un bucle while? ¿Cómo influye esto en la legibilidad y
mantenibilidad del código?
3.​ ¿Cómo podés aplicar lo aprendido en esta clase al desarrollo de sistemas más
complejos, como el Trabajo Final Integrador? Pensá en validaciones, normalización
de datos y la eficiencia que aportan los bucles.

Próximos pasos:
En la próxima clase, profundizaremos en el manejo de listas y exploraremos una nueva
estructura de datos: las tuplas. Aunque ya conocés cómo crear y recorrer listas, vamos a
enfocarnos en las operaciones más comunes que podés realizar con ellas, como agregar,
eliminar y modificar elementos utilizando métodos específicos.

Además, aprenderás qué son las tuplas y cómo se diferencian de las listas. Las tuplas
tienen usos específicos que las hacen ideales para ciertos escenarios donde los datos no
deben cambiar. ​

Asegurate de repasar lo aprendido sobre bucles y listas, ya que estos conceptos serán
indispensables para sacar el máximo provecho de las nuevas herramientas que veremos. ​
​
¡Seguimos avanzando!
Clase N° 7 | Listas y Tuplas
Temario:
●​ Listas y tuplas: diferencias y similitudes.
●​ Uso de índices y slices.
●​ Métodos comunes de listas (append(), remove(), etc.) y tuplas.
●​ Iteración y manipulación de listas y tuplas.

Objetivos de la Clase.
En esta clase vas a profundizar tus conocimientos sobre listas, aprendiendo cómo usarlas
para almacenar, modificar y organizar datos de manera eficiente. También vas a conocer las
tuplas, una estructura similar a las listas pero con una característica clave: su contenido no
se puede modificar después de ser creado.

Aprenderás a identificar las diferencias y similitudes entre listas y tuplas, entendiendo

cuándo conviene utilizar una u otra según las necesidades de tu programa. Además,
veremos cómo trabajar con índices y slices para acceder y manipular partes específicas de
estas estructuras.

Por último, vas a explorar los métodos más comunes para trabajar con listas, como
append(), remove() y otros que te permitirán realizar operaciones de manera práctica y
rápida. También practicaremos cómo recorrer y procesar listas y tuplas utilizando bucles,
integrando lo aprendido en las clases anteriores.
Otra mañana en TechLab 🚀

Al revisar tu correo de TalentoLab recibís un mensaje de Mariana, la Gerente de Proyectos,

asignándote una nueva misión para mejorar tus habilidades en programación:

“Necesitamos implementar un registro ordenado de los nombres de las

empresas que trabajan con TalentoLab . Tu tarea hoy consistirá en
crear una lista, ordenada alfabéticamente, de todas ellas. Más tarde te
daré todos los detalles necesarios.“

Luis, el desarrollador senior, te guía y explica la manera de mantener un registro ordenado

de los y las clientes y cómo una buena gestión de datos puede mejorar la eficiencia del
equipo. ¡Manos a la obra!
Listas
Las listas en Python son muy flexibles. No solo podés acceder a sus elementos, sino
también modificarlos, agregar nuevos valores o eliminar los que ya no necesitás. Esta
capacidad de cambiar el contenido de una lista es lo que llamamos mutabilidad, y es una
de las características que hacen a las listas tan útiles para resolver problemas en tus
programas.

Método append()
El método append() te permite agregar un nuevo elemento al final de una lista. Es muy útil
cuando no conocés de antemano cuántos datos vas a manejar, ya que podés ir
añadiéndolos uno a uno según sea necesario.

Este método no modifica los elementos existentes, simplemente extiende la lista

con el nuevo valor.

A continuación, vamos a ver un ejemplo práctico. Vamos a pedir al usuario que ingrese los
montos de ventas realizadas, y vamos a almacenarlos en una lista utilizando append().
Cuando el usuario ingrese un "0", el programa terminará de recopilar datos y mostrará la
lista completa.

# Creamos una lista vacía para almacenar los montos de las ventas
ventas = []

print("Ingresá los montos de ventas. Escribí '0' para finalizar.")

# Usamos un bucle while para recopilar los datos

while True:
monto = int(input("Ingresá el monto de la venta: "))
if monto == 0:
break # Finalizamos el bucle si el monto es 0
[Link](monto) # Agregamos el monto a la lista

# Mostramos la lista completa de ventas

print("\nLista de ventas ingresadas:")
for venta in ventas:
print(f"- ${venta}")
Primero, creamos una lista vacía llamada ventas, que se usará para almacenar los datos
ingresados. Luego, un bucle while solicita al usuario que ingrese montos de ventas. Cada
valor ingresado se agrega a la lista utilizando el método append(). Si el usuario ingresa un
"0", el programa rompe el bucle con la instrucción break.

Después de recopilar todos los datos, un bucle for recorre la lista para mostrar cada monto
de manera ordenada y clara. Esto muestra cómo append() puede ser combinado con
bucles para manejar datos de forma dinámica.

Ingresá los montos de ventas. Escribí '0' para finalizar.

Ingresá el monto de la venta: 1000
Ingresá el monto de la venta: 1500
Ingresá el monto de la venta: 800
Ingresá el monto de la venta: 1200
Ingresá el monto de la venta: 0

Lista de ventas ingresadas:

- $1000
- $1500
- $800
- $1200

Método remove()
El método remove() se utiliza para eliminar el primer elemento de una lista que coincida con
un valor específico. Es importante destacar que este método solo elimina la primera
aparición del valor, por lo que, si el elemento se repite en la lista, las demás ocurrencias
permanecerán intactas. Si el valor no se encuentra en la lista, Python generará un error.

Para entender cómo funciona remove(), vamos a analizar con un ejemplo. En este caso,
crearemos una lista de productos vendidos y permitiremos al usuario eliminar productos
específicos de la lista, uno por uno, hasta que decida terminar.

Este ejemplo demuestra cómo remove() puede ser útil para gestionar
dinámicamente los elementos de una lista, permitiendo modificar contenido
según sea necesario.
# Creamos una lista inicial con productos vendidos
productos = ["pan", "leche", "queso", "pan", "yogur"]

print("Lista de productos actuales:")

print(productos)

print("\nPodés eliminar un producto de la lista. Escribí 'fin' para

salir.")

# Usamos un bucle while para permitir al usuario eliminar productos

while True:
producto_a_eliminar = input("Producto a eliminar: ").lower()
if producto_a_eliminar == "fin":
break # Finalizamos el bucle si el usuario escribe "fin"
if producto_a_eliminar in productos:
# Eliminamos el producto de la lista
[Link](producto_a_eliminar)
print(f"'{producto_a_eliminar}' fue eliminado. Lista
actualizada:")
print(productos)
else:
print(f"El producto '{producto_a_eliminar}' no está en la
lista.")

# Mostramos la lista final

print("\nLista final de productos:")
print(productos)

Primero, definimos una lista inicial llamada productos que contiene algunos artículos
repetidos. Luego, el programa muestra esta lista al usuario y le da la opción de eliminar
elementos uno por uno.

Usamos un bucle while para solicitar el nombre del producto a eliminar. Si la usuaria escribe
"fin", el programa termina. Si el producto está en la lista, utilizamos remove() para eliminar la
primera aparición de ese producto. Finalmente, mostramos la lista actualizada después de
cada eliminación. Si el producto no está en la lista, se muestra un mensaje de advertencia.
Lista de productos actuales:
['pan', 'leche', 'queso', 'pan', 'yogur']

Podés eliminar un producto de la lista. Escribí 'fin' para salir.

Producto a eliminar: pan
'pan' fue eliminado. Lista actualizada:
['leche', 'queso', 'pan', 'yogur']
Producto a eliminar: queso
'queso' fue eliminado. Lista actualizada:
['leche', 'pan', 'yogur']
Producto a eliminar: fin

Lista final de productos:

['leche', 'pan', 'yogur']

Métodos comunes para listas en Python

Estos métodos son útiles en diversas situaciones y pueden ayudarte a gestionar datos de
manera eficiente. Algunos, como append(), remove(), count() y sort(), son especialmente
relevantes para abordar los desafíos del TFI, donde tendrás que manipular y analizar listas
de datos.

Método Ejemplo de Uso Explicación

ventas = []
[Link](100) Agrega un elemento al final de
append()
print(ventas) la lista.
# Salida: [100]

productos = ["pan", "leche"] Elimina la primera aparición

[Link]("pan") de un valor en la lista. Si el
remove()
print(productos) valor no existe, genera un
# Salida: ["leche"] error.

valores = [10, 20, 30]

x = [Link]() Elimina y devuelve el último
pop() elemento de la lista (o el
print(x) # Salida: 30
índice especificado).
print(valores) # Salida: [10, 20]
 nombres = ["Ana", "Luis"]
[Link](1, "Carlos")
print(nombres) Inserta un elemento en una
insert()
posición específica de la lista.
# Salida:
# ["Ana", "Carlos", "Luis"]

lista1 = [1, 2]
lista2 = [3, 4] Extiende la lista añadiendo los
extend() [Link](lista2) elementos de otra lista o
print(lista1) iterable al final.
# Salida: [1, 2, 3, 4]

colores = ["rojo", "azul",

"verde"] Devuelve la posición de la
index() pos = [Link]("azul") primera aparición de un valor
print(pos) en la lista.
# Salida: 1

numeros = [1, 2, 2, 3]
ocurrencias = [Link](2) Cuenta cuántas veces
count()
print(ocurrencias) aparece un valor en la lista.
# Salida: 2

letras = ["a", "b", "c"]

[Link]() Invierte el orden de los
reverse()
print(letras) elementos en la lista.
# Salida: ["c", "b", "a"]

edades = [25, 18, 30] Ordena los elementos de la

[Link]() lista en orden ascendente (o
sort()
print(edades) descendente si se usa
# Salida: [18, 25, 30] reverse=True).

datos = [1, 2, 3]
[Link]() Elimina todos los elementos
clear()
print(datos) de la lista, dejándola vacía.
# Salida: []

El siguiente ejemplo muestra cómo un método como sort() puede integrarse fácilmente con
estructuras de control como for, permitiendo gestionar y presentar información de manera
eficiente:
# Lista inicial con nombres de productos
productos = ["yogur", "pan", "queso", "leche", "manteca"]

# Ordenamos los productos alfabéticamente

[Link]()

# Mostramos los productos ordenados

print("Lista de productos ordenados alfabéticamente:")
for producto in productos:
print(f"- {producto}")

Primero definimos una lista llamada productos que contiene nombres desordenados.
Luego, utilizamos el método sort() para ordenar los elementos alfabéticamente. Una vez
ordenada, recorremos la lista con un bucle for para mostrar cada producto en la terminal,
presentándolo de forma organizada.

Las tuplas en Python

Hasta ahora, trabajamos con listas y exploramos sus características, como su mutabilidad y
los métodos útiles para manipularlas. Sin embargo, Python también ofrece otra estructura
similar pero con diferencias importantes: las tuplas.

Ambas estructuras permiten almacenar múltiples valores, acceder a ellos mediante índices
y ser recorridas con bucles, pero la elección entre listas y tuplas depende del contexto. Si
necesitás manipular los datos, una lista es la mejor opción. Si buscás garantizar que los
datos permanezcan inalterados, una tupla será más adecuada.

Las tuplas son estructuras de datos similares a las listas, pero con una característica
principal que las diferencia: son inmutables. Esto significa que, una vez creada, una tupla
no se puede modificar. No podés agregar, eliminar ni cambiar los elementos que contiene.

Esta inmutabilidad las hace ideales para representar datos constantes o que no
deberían alterarse durante la ejecución de un programa, como coordenadas,
configuraciones o valores que necesitan mantenerse seguros.

Creación de tuplas
Las tuplas se definen utilizando paréntesis ( ), aunque también se pueden crear sin
paréntesis explícitos, separando los elementos por comas. Por ejemplo:
# Creación de una tupla
mi_tupla = (10, 20, 30)

# Creación sin paréntesis

otra_tupla = 40, 50, 60

# Tupla con un solo elemento (requiere una coma final)

tupla_unica = (100,)

Acceso a elementos
Al igual que las listas, los elementos de una tupla se acceden mediante índices,
comenzando en 0. También podés utilizar índices negativos para acceder desde el final:

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

print(colores[0]) # Salida: rojo
print(colores[-1]) # Salida: azul

Tuplas y métodos
Aunque las tuplas son inmutables, algunas operaciones y métodos aún se pueden aplicar.
Por ejemplo:

Conteo de elementos con count():

numeros = (1, 2, 2, 3)
print([Link](2)) # Salida: 2

Índice de un elemento con index():

frutas = ("manzana", "pera", "manzana")

print([Link]("pera")) # Salida: 1
Relación con las listas
Aunque listas y tuplas comparten características, como el acceso por índices y la capacidad
de ser recorridas con bucles, la decisión entre usar una u otra depende de la necesidad de
mutabilidad. Por ejemplo, si estás trabajando con datos que no necesitan cambiar, como
una tabla de constantes, una tupla es la mejor opción:

# Ejemplo de tupla para datos inmutables

coordenadas = (40.7128, -74.0060)
print(f"Latitud: {coordenadas[0]}, Longitud: {coordenadas[1]}")

Por otro lado, si necesitás agregar, eliminar o actualizar elementos, una lista será más
adecuada.

Los métodos de las tuplas están limitados comparados con las listas, lo que refleja su
naturaleza estática. Como siempre, Luis está atento a tus avances, y te proporciona una
tabla que contiene los métodos más comunes y si aplica o no a estos tipos de datos.

Método Listas Tuplas

✔️ Se aplica. Agrega un elemento al ❌ No se aplica. Las tuplas son

append() final de la lista. inmutables, por lo que no se pueden
agregar elementos.

✔️ Se aplica. Elimina la primera ❌ No se aplica. No se pueden

remove() aparición de un elemento específico. eliminar elementos de una tupla
debido a su inmutabilidad.

pop()
✔️ Se aplica. Elimina y devuelve un ❌ No se aplica. Las tuplas no
elemento de una posición específica. permiten eliminar elementos.

✔️ Se aplica. Inserta un elemento en ❌ No se aplica. No se pueden

insert() una posición específica. modificar las posiciones de los
elementos en una tupla.

✔️ Se aplica. Agrega múltiples ❌ No se aplica. Las tuplas no

extend() elementos al final de la lista. pueden extenderse con nuevos
elementos.

index()
✔️ Se aplica. Devuelve el índice de ✔️ Se aplica. Las tuplas permiten
la primera aparición de un elemento. buscar el índice de un elemento.
 ✔️ Se aplica. Cuenta cuántas veces ✔️ Se aplica. Las tuplas permiten
count() aparece un elemento. contar la cantidad de veces que
aparece un elemento.

✔️ Se aplica. Invierte el orden de los ❌ No se aplica. No se puede

reverse() elementos de la lista. modificar el orden de los elementos
en una tupla.

✔️ Se aplica. Ordena los elementos ❌ No se aplica. Las tuplas no

sort() de la lista en orden pueden modificarse ni ordenarse.
ascendente/descendente.

✔️ Se aplica. Elimina todos los ❌ No se aplica. Las tuplas no

clear() elementos de la lista. permiten eliminar elementos ni vaciar
su contenido.

Convertir entre listas y tuplas

A veces, podés necesitar convertir una lista en tupla o viceversa. Esto es posible utilizando
las funciones tuple() y list():

# Conversión de lista a tupla

mi_lista = [1, 2, 3]
mi_tupla = tuple(mi_lista)
print(mi_tupla) # Salida: (1, 2, 3)

# Conversión de tupla a lista

otra_tupla = (4, 5, 6)
otra_lista = list(otra_tupla)
print(otra_lista) # Salida: [4, 5, 6]

Las tuplas son una herramienta útil para cuando se requiere proteger la integridad de los
datos. Su inmutabilidad aporta seguridad y claridad en muchos escenarios, como definir
configuraciones o datos que no deben cambiar. A medida que avancemos, veremos cómo
combinarlas con listas y otros conceptos para manejar información de manera más
eficiente.
Slices en listas y yuplas
El concepto de slices (ya utilizado con las cadenas de caracteres) permite acceder a
porciones específicas de listas o tuplas, seleccionando un rango de elementos. Esto es útil
cuando necesitás trabajar con subconjuntos de datos, como extraer valores específicos
para un análisis o realizar operaciones sobre una parte de la estructura.

Sintaxis de slicing
La sintaxis básica para crear un slice es:

estructura[inicio:fin:paso]

●​ inicio: Es el índice donde comienza el slice (incluido).

●​ fin: Es el índice donde termina el slice (excluido).
●​ paso: Indica cuántos elementos avanzar en cada iteración (opcional).

Si no especificás alguno de estos valores, Python usará los predeterminados:

●​ inicio: El primer elemento de la estructura.

●​ fin: El último elemento.
●​ paso: 1 (recorre de a uno).

Ejemplo con Listas

Vamos a trabajar con una lista para extraer partes específicas de la misma:

numeros = [10, 20, 30, 40, 50, 60]

# Obtener los primeros tres elementos

print(numeros[:3]) # Salida: [10, 20, 30]

# Obtener los últimos dos elementos

print(numeros[-2:]) # Salida: [50, 60]

# Obtener todos los elementos con un paso de 2

print(numeros[::2]) # Salida: [10, 30, 50]

En estos ejemplos, podés ver cómo los slices permiten acceder fácilmente a diferentes
partes de la lista sin necesidad de recorrerla manualmente con bucles.
Ejemplo con tuplas
El slicing funciona de la misma manera en las tuplas, ya que comparten la misma lógica de
indexación:

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

# Obtener los dos primeros colores

print(colores[:2]) # Salida: ("rojo", "verde")

# Obtener los colores desde el tercero hasta el final

print(colores[2:]) # Salida: ("azul", "amarillo")

# Obtener los colores en orden inverso

print(colores[::-1]) # Salida: ("amarillo", "azul", "verde", "rojo")

Diferencias entre slicing y acceso directo

El slicing permite trabajar con múltiples elementos a la vez, mientras que el acceso directo
con índices individuales (estructura[indice]) se limita a un solo elemento por operación. Esto
hace que los slices sean más eficientes para procesar rangos de datos. En general, vas a
usar slices para:

●​ Dividir datos: Podés dividir listas grandes en partes más pequeñas, como separar
los datos de ventas en trimestres.
●​ Invertir datos: Usar slices con pasos negativos ([::-1]) es una forma eficiente de
invertir una lista o tupla.
●​ Extraer valores específicos: Seleccionar subconjuntos de datos con una lógica
clara, cómo extraer los valores impares de una lista.

Los slices son una herramienta fundamental para manejar listas y tuplas,
evitando bucles innecesarios y haciendo el código más limpio y legible, que
amplían significativamente las posibilidades de manipulación de datos en
Python.

Ejemplo práctico: Análisis de datos con slices

Luis te propone crear un programa que permita analizar los datos de ventas semanales
almacenados en una lista. El programa extraerá las ventas de los primeros tres días de la
semana, las ventas de los últimos dos días, y calculará el total de ventas de los días
intermedios utilizando slices. Esto te mostrará cómo trabajar con diferentes partes de una
lista.

# Lista que representa las ventas diarias de una semana

ventas_semanales = [150, 200, 250, 300, 100, 180, 220]

# Extraer las ventas de los primeros tres días

primeros_dias = ventas_semanales[:3]
print(f"Ventas de los primeros tres días: {primeros_dias}")

# Extraer las ventas de los últimos dos días

ultimos_dias = ventas_semanales[-2:]
print(f"Ventas de los últimos dos días: {ultimos_dias}")

# Calcular el total de ventas de los días intermedios (excluyendo los

primeros tres y últimos dos días)
dias_intermedios = ventas_semanales[3:-2]
total_intermedios = sum(dias_intermedios)
print(f"Ventas de los días intermedios: {dias_intermedios}")
print(f"Total de ventas de los días intermedios: ${total_intermedios}")

Esta es la salida del programa:

Ventas de los primeros tres días: [150, 200, 250]

Ventas de los últimos dos días: [180, 220]
Ventas de los días intermedios: [300, 100]
Total de ventas de los días intermedios: $400

Veamos que ocurre en este código. Primero, creamos una lista llamada ventas_semanales
que contiene los montos de ventas diarias de una semana. Utilizamos slices para dividir
esta lista en partes específicas según las necesidades:

1.​ Para obtener las ventas de los primeros tres días, usamos [:3], que selecciona desde
el inicio hasta el índice 2 (excluyendo el índice 3). Este resultado se almacena en
primeros_dias y se muestra en la pantalla.
2.​ Las ventas de los últimos dos días se extraen utilizando [-2:], que selecciona desde
el penúltimo hasta el último elemento de la lista. Este resultado se guarda en
ultimos_dias y se imprime.
 3.​ Finalmente, para analizar los días intermedios, usamos el slice [3:-2], que selecciona
los elementos entre el índice 3 (inclusive) y el índice -2 (excluido). Luego,
calculamos la suma de estos valores utilizando la función sum() y mostramos tanto
la lista de días intermedios como el total calculado.

Este ejemplo muestra cómo los slices facilitan la manipulación de datos en

listas, evitando la necesidad de recorrer la lista manualmente o crear múltiples
bucles. También muestra cómo combinarlos con otras funciones como sum()
para realizar cálculos útiles.

Ejercicio práctico.
Mariana te ha escrito un correo donde te explica claramente la tarea que debe resolver el
programa a desarrollar:

¡Hola!
En TalentoLab necesitamos llevar un registro ordenado de los
nombres de los nuevos clientes y clientas que se van incorporando.
Queremos asegurarnos de que los datos ingresados sean válidos y
estén bien organizados. Tu tarea es escribir un programa en Python
que haga lo siguiente:

1.​ Solicite al usuario o usuaria los nombres de los clientes y clientas uno por uno y
valide que cada nombre no esté vacío. Si se deja el campo vacío, mostrale un
mensaje de advertencia y volvé a pedir el nombre.
2.​ Guarde cada nombre válido en una lista, asegurándote de agregarlo con el
método .append().
3.​ Permití que la persona finalice la carga de nombres escribiendo la palabra "fin".
4.​ Una vez finalizada la carga, ordená alfabéticamente los nombres en la lista y
mostrá la lista ordenada de nombres utilizando un bucle for.

¡Es hora de demostrar tu crecimiento como especialista en desarrollo de software! 💪😊

Materiales y Recursos Adicionales:
Artículos:

Sitio oficial: Todo sobre las listas en Python

Pablo Londoño: Listas en Python: qué son, cómo crearlas y ordenarlas

El libro de Python: Listas en Python

Videos:

Byspel: Listas en Python - Parte 1 y Listas en Python - Parte 2

Sergio Castaño Giraldo: Listas en Python

Preguntas para reflexionar:

1.​ ¿Por qué es importante conocer los métodos más comunes de las listas, como
append() o remove()? ¿En qué situaciones prácticas podrían ayudarte estos
métodos en el desarrollo del TFI?
2.​ ¿Cómo pueden los slices simplificar la manipulación de datos en tus programas?
¿Qué beneficios tienen frente a otras formas de acceder a los elementos de una lista
o tupla?
3.​ ¿En qué escenarios el uso de una tupla puede ser preferible al de una lista? Pensá
en ejemplos donde la inmutabilidad sea una ventaja.

Próximos pasos:
En la próxima clase, vas a descubrir una estructura de datos fundamental que lleva el
manejo de información a otro nivel: los diccionarios. Aprenderás cómo crearlos y
manipularlos, cómo acceder a sus elementos mediante claves específicas y utilizar métodos
esenciales para agregar, modificar y eliminar datos.

Los diccionarios serán un aporte poderoso a tu caja de herramientas de programación,

especialmente para tareas que requieran manejar información organizada y etiquetada.
Este nuevo conocimiento te acercará aún más a completar con éxito el Trabajo Final
Integrador (TFI)
Clase N° 8 | Diccionarios
Temario:
●​ Concepto de clave y valor.
●​ Creación y manipulación de diccionarios.
●​ Métodos esenciales de diccionarios.
●​ Iteración sobre diccionarios.

Objetivos de la Clase
En esta clase, aprenderás a utilizar los diccionarios, una estructura de datos esencial en
Python que permite almacenar información de una manera más organizada y eficiente. Vas
a descubrir cómo funcionan los pares clave-valor y cómo esta característica facilita el
acceso rápido a los datos sin necesidad de recurrir a posiciones específicas como en las
listas.​
​
Explorarás cómo recorrer diccionarios con bucles y cómo estos recorridos pueden aplicarse
en situaciones prácticas, preparándote para desafíos más complejos. Este nuevo
conocimiento te permitirá gestionar datos de manera más clara y efectiva, una habilidad que
será clave para tu Trabajo Final Integrador (TFI).
Octava jornada en TechLab 🚀

El día comienza con el movimiento habitual en TalentoLab. Mientras llegás a tu escritorio,

una nota de Luis te indica que Mariana quiere verte en la sala de reuniones.

Mariana te explica que el equipo necesita una pequeña aplicación para

registrar productos y sus precios en pesos. Esta vez, vas a necesitar una
estructura eficiente para organizar y acceder rápidamente a los datos.

Te cuenta que la mejor opción es usar diccionarios en Python, una herramienta que
permite asociar claves con valores.
​
¡Veamos cómo funcionan!
Introducción a diccionarios
En Python, los diccionarios son una estructura de datos que permite almacenar
información en forma de pares clave-valor. A diferencia de las listas y las tuplas, donde los
elementos se acceden mediante un índice numérico, en los diccionarios cada elemento se
accede a través de una clave única que está asociada a un valor específico.

Para entender mejor los diccionarios en Python, podemos hacer una analogía con los
diccionarios del mundo real, como los diccionarios de idiomas.​

●​ Claves (Keys): En un diccionario de idiomas, las claves serían las palabras. Cada
palabra (clave) debe ser única para evitar confusiones y garantizar que se puede
encontrar rápidamente.
●​ Valores (Values): Los valores serían las definiciones o traducciones asociadas a
cada palabra. Estos valores proporcionan la información o el significado
correspondiente a cada clave.

Por ejemplo, en un diccionario de inglés a español:

●​ L​ a clave "apple" tiene el valor "manzana".

●​ ​La clave "book" tiene el valor "libro".

Un diccionario en Python se define utilizando llaves {} y cada par clave-valor se separa con
dos puntos :. Por ejemplo:

productos = {
"manzana": 150,
"banana": 120,
"naranja": 180
}

En este diccionario, "manzana", "banana" y "naranja" son las claves, mientras que 150, 120
y 180 son los valores asociados a cada clave. Esta estructura permite acceder rápidamente
al precio de un producto a través de su nombre, sin tener que recorrer toda la colección.

Para acceder a los valores de un diccionario, utilizamos las claves, de manera similar a
como usamos los índices en las listas. La diferencia es que, mientras en una lista los
índices son números enteros que representan la posición de cada elemento, en un
diccionario las claves pueden ser palabras u otros tipos de datos. Esta flexibilidad hace que
los diccionarios sean más intuitivos para ciertas tareas.

Por ejemplo, en una lista de precios, accederíamos al valor por su posición:

precios_lista = [150, 120, 180]
print(precios_lista[0]) # Salida: 150 (precio de la manzana)

En un diccionario, accedemos al valor usando una clave:

productos = {
"manzana": 150,
"banana": 120,
"naranja": 180
}
print(productos["manzana"]) # Salida: 150

En este ejemplo, en lugar de recordar que el precio de la manzana está en la posición 0,

simplemente usamos la clave "manzana" para obtener su precio. Esto hace que el código
sea más fácil de entender y menos propenso a errores, especialmente cuando trabajamos
con grandes cantidades de datos.

Comparación entre listas, tuplas y diccionarios

Luis, notando que no terminas de encontrar la relación entre cada uno de estos tipos de
datos, te proporciona un resúmen de sus características:

Estructura Descripción Ejemplo Acceso

Almacenan colecciones frutas = ["manzana", frutas[0] devuelve

ordenadas de "manzana"
Listas "banana", "naranja"]
elementos que se
pueden modificar.

Similares a las listas, colores = ("rojo", colores[1]

pero inmutables, es devuelve "azul"
Tuplas "azul", "verde")
decir, no se pueden
modificar.

Permiten acceder a los productos = productos["manza

Diccionarios elementos mediante {"manzana": 150, na"] devuelve 150
claves personalizadas, "banana": 120}
 facilitando búsquedas
más rápidas y
descriptivas.

Esta tabla resume de manera clara las diferencias entre listas, tuplas y diccionarios,
ayudándote a elegir la estructura adecuada según el tipo de datos que necesites manejar.

Características de los diccionarios en Python

Característic
Descripción Ejemplo
a

Estructura Cada entrada tiene una clave {"nombre": "Juan",

de única y un valor asociado. Los "edad": 25}
Clave-Valor valores pueden repetirse.

Permite acceder a los valores diccionario["nombre"]

Acceso
rápidamente mediante claves, lo
Rápido a los # devuelve "Juan"
cual es eficiente con grandes
Datos
volúmenes de datos.

Se puede modificar, agregar o diccionario["ciudad"] =

Mutable eliminar pares clave-valor
"Buenos Aires"
después de crear el diccionario.

Desde Python 3.7, mantiene el

orden de inserción; en versiones {"a": 1, "b": 2}
Orden
anteriores el orden no era
garantizado.

Las claves deben ser

Diversidad inmutables (cadenas, números, {"nombre": "Ana", 1: [2, 3],
de Tipos tuplas). Los valores pueden ser (1, 2): "Par ordenado"}
cualquier tipo de datos.

Puede crecer o reducirse

dinámicamente al agregar o
Extensible eliminar pares clave-valor [Link]("edad")
(veremos esto en detalle más
adelante)
Métodos esenciales de diccionarios en Python
Al igual que con las listas y las tuplas, los diccionarios cuentan con una serie de métodos
que facilitan su manipulación y te permiten realizar tareas comunes como agregar, eliminar,
buscar y modificar elementos. A continuación, Luis te muestra una tabla con los métodos
más importantes para trabajar con diccionarios en Python, junto con ejemplos prácticos y
una breve explicación de cada uno.

Método Ejemplo de uso Descripción

Devuelve el valor asociado a la

[Link]("nombre") clave especificada. Si la clave no
get()
existe, devuelve None o un valor
por defecto.

[Link]() Devuelve una vista de todas las

keys()
claves del diccionario.

[Link]() Devuelve una vista de todos los

values()
valores del diccionario.

[Link]() Devuelve una vista de todos los

items()
pares clave-valor como tuplas.

Elimina y devuelve el valor

[Link]("edad") asociado a la clave especificada.
pop()
Si la clave no existe, lanza un
error.

Elimina y devuelve el último par

popitem() [Link]() clave-valor insertado (desde
Python 3.7 en adelante).

[Link]({"ciudad Actualiza el diccionario con pares

update() clave-valor de otro diccionario o
": "Buenos Aires"})
iterable.

[Link]() Elimina todos los elementos del

clear()
diccionario, dejándolo vacío.

nuevo_diccionario = Devuelve una copia superficial del

copy()
[Link]() diccionario.

Estos métodos te permiten manejar diccionarios de forma eficiente y adaptarlos a las

necesidades específicas de tus programas. Entender cómo funcionan te ayudará a escribir
código más claro, conciso y robusto, habilidades que serán fundamentales para completar
tu Trabajo Final Integrador (TFI). Es por esto que Luis te invita a escribir un script que utilice
varios métodos de los diccionarios.

# Creamos un diccionario con información de una cliente

cliente = {
"nombre": "Lucía",
"edad": 30,
"ciudad": "Córdoba"
}

# Usamos get() para acceder a una clave existente y a una que no existe
print([Link]("nombre")) # Salida: Lucía
print([Link]("telefono")) # Salida: None

# Usamos keys() para ver todas las claves del diccionario

print([Link]())
# Salida: dict_keys(['nombre', 'edad', 'ciudad'])

# Usamos values() para ver todos los valores

print([Link]())
# Salida: dict_values(['Lucía', 30, 'Córdoba'])

# Usamos items() para ver los pares clave-valor

print([Link]())
# Salida: dict_items([('nombre', 'Lucía'), ('edad', 30), ('ciudad',
'Córdoba')])

# Agregamos una nueva clave con setdefault()

[Link]("telefono", "123-4567")
print(cliente)
# Salida: {'nombre': 'Lucía', 'edad': 30, 'ciudad': 'Córdoba',
'telefono': '123-4567'}

# Eliminamos una clave con pop()

[Link]("edad")
print(cliente)
# Salida: {'nombre': 'Lucía', 'ciudad': 'Córdoba', 'telefono':
'123-4567'}
Mientras mirás el código que acabas de escribir, Luis se acerca con su café y, con su tono
relajado de siempre, te dice que arrancaste creando un diccionario llamado cliente con
información básica como el nombre, la edad y la ciudad. Después, usaste get() para
acceder al valor de la clave "nombre", lo que te devolvió "Lucía", y también probaste con
una clave que no existía, "telefono", que por defecto te devolvió None en lugar de tirar un
error. Es una gran forma de manejar claves inexistentes sin que el programa se rompa.

Luis toma un sorbo de su café y sigue dando cuenta de lo trabajado: además le pediste a
Python que te muestre todas las claves con keys(), los valores con values(), y los pares
clave-valor con items(). Eso es re útil cuando necesitás ver qué hay en el diccionario sin
recorrerlo manualmente. También agregaste una nueva clave "telefono" usando
setdefault(), que solo la creó si no existía ya. Finalmente, eliminaste la clave "edad" con
pop(), lo que te permitió modificar el diccionario sin problemas. Todo esto te da flexibilidad
para manejar la información sin importar cuán compleja sea.

Ejemplo práctico 1: Registro de clientes con diccionarios y

listas
Ahora, vamos a crear un programa que registre la información de varios clientes. Se nos
pedirá ingresar el código del cliente, su nombre y su ciudad. Cada conjunto de datos se
almacenará en un diccionario, y todos estos diccionarios se agregarán a una lista. Al final,
mostraremos toda la información registrada. Vamos a ver cómo se hace.

Este ejemplo es una excelente manera de recordar que las listas pueden
contener cualquier tipo de dato, incluidos diccionarios.

# Creamos una lista vacía para almacenar los diccionarios

clientes = []

# Bucle para ingresar los datos de varios clientes

while True:
print("\nIngresá los datos del cliente.[vacío para finalizar]:")
codigo = input("Código del cliente: ")

# Condición para salir del bucle si el código está vacío

if codigo == "":
break

nombre = input("Nombre del cliente: ")

ciudad = input("Ciudad del cliente: ")

# Creamos un diccionario con los datos ingresados

 cliente = {
"código": codigo,
"nombre": nombre,
"ciudad": ciudad
}

# Agregamos el diccionario a la lista de clientes

[Link](cliente)

# Mostramos los datos de todos los clientes registrados

print("\n--- Clientes Registrados ---")
for cliente in clientes:
print(f"Código: {cliente['código']}, Nombre: {cliente['nombre']},
Ciudad: {cliente['ciudad']}")

Al ejecutarlo e interactuar con el programa, ves que una salida posible es la siguiente:

Ingresá los datos del cliente. Para finalizar, dejá el código vacío.
Código del cliente: 1
Nombre del cliente: Ana
Ciudad del cliente: CABA

Ingresá los datos del cliente. Para finalizar, dejá el código vacío.
Código del cliente: 3
Nombre del cliente: Juan
Ciudad del cliente: Rosario

Ingresá los datos del cliente. Para finalizar, dejá el código vacío.
Código del cliente: 8
Nombre del cliente: Luis
Ciudad del cliente: Quilmes

Ingresá los datos del cliente. Para finalizar, dejá el código vacío.
Código del cliente:

--- Clientes Registrados ---

Código: 1, Nombre: Ana, Ciudad: CABA
Código: 3, Nombre: Juan, Ciudad: Rosario
Código: 8, Nombre: Luis, Ciudad: Quilmes
Veamos la explicación detallada de lo que hace este código. El programa empieza creando
una lista vacía llamada clientes. Esta lista se usará para almacenar los diccionarios que
contienen los datos de cada cliente.

Luego, utilizamos un bucle while para permitir que la persona ingrese los datos de varios
clientes. En cada iteración, se le pide el código, el nombre, y la ciudad del cliente. Si se deja
el campo del código vacío y presiona Enter, el bucle se interrumpe gracias a la sentencia
break.

Una vez que se obtienen los datos, se crea un diccionario llamado cliente con las claves
"código", "nombre" y "ciudad", y se asignan los valores ingresados por el usuario a cada
una de estas claves. Este diccionario se agrega a la lista clientes usando el método
append().

Al final del programa, recorremos la lista de diccionarios con un bucle for. Para cada cliente
en la lista, mostramos la información usando una f-string para formatear la salida de
manera ordenada. Este ejemplo, dice Luis, te muestra cómo combinar listas y diccionarios
para gestionar datos más complejos. Es una técnica muy útil para tu Trabajo Final
Integrador (TFI) o cualquier proyecto donde necesites manejar múltiples registros de
información organizada.

Ejemplo práctico 2: Eliminando elementos de un

diccionario con un bucle
Analicemos, nos propone Luis, un último ejemplo. Esta vez partimos de un diccionario ya
definido con algunos productos y sus respectivos precios. Utilizaremos un bucle para
mostrar los productos disponibles y permitir que el usuario elija cuál quiere eliminar. Al
finalizar, el programa mostrará el estado final del diccionario con los productos restantes.

# Diccionario inicial con productos y precios

productos = {
"lápiz": 50,
"cuaderno": 200,
"goma": 30,
"marcador": 100
}

# Mostramos los productos disponibles al inicio

print("Productos disponibles:")
for nombre, precio in [Link]():
print(f"{[Link]()}: ${precio}")

# Bucle para permitir al usuario eliminar productos

while True:
print("\nIngresá el nombre del producto que querés eliminar (o
presioná Enter para terminar):")
eliminar = input("Producto a eliminar: ").lower()

# Si el usuario presiona Enter sin escribir nada, se sale del bucle

if eliminar == "":
break

# Verificamos si el producto está en el diccionario y lo eliminamos

if eliminar in productos:
[Link](eliminar)
print(f"El producto '{eliminar}' fue eliminado del inventario.")
else:
print(f"El producto '{eliminar}' no existe en el inventario.")

# Mostramos el estado actual del diccionario

print("\nProductos restantes:")
for nombre, precio in [Link]():
print(f"{[Link]()}: ${precio}")

# Estado final del diccionario

print("\n--- Estado final del inventario ---")
for nombre, precio in [Link]():
print(f"{[Link]()}: ${precio}")

El programa comienza con un diccionario llamado productos, que contiene algunos artículos
junto con sus precios. Utilizamos un bucle for para mostrar todos los productos disponibles
al inicio del programa.

Luego, entramos en un bucle while donde le pedimos al usuario que ingrese el nombre del
producto que quiere eliminar. La entrada se convierte a minúsculas con .lower() para evitar
problemas de mayúsculas o minúsculas. Si el usuario presiona Enter sin escribir nada, el
bucle termina gracias a la sentencia break.

Dentro del bucle, verificamos si el producto ingresado existe en el diccionario. Si existe, lo

eliminamos usando el método pop(). Si no existe, se muestra un mensaje indicando que el
producto no fue encontrado. Después de cada eliminación, mostramos el estado actual del
diccionario para que el usuario vea los productos restantes.
Al finalizar el bucle, mostramos el estado final del inventario con todos los productos que
quedan en el diccionario.

Esta línea: if eliminar in productos: comprueba si la clave almacenada en la

variable eliminar existe dentro del diccionario productos. La palabra clave in se usa para
verificar si una clave específica está presente en el diccionario. Si la clave se encuentra, la
condición se evalúa como True y se ejecuta el bloque de código que elimina ese elemento
del diccionario. Si la clave no está presente, la condición se evalúa como False y el
programa pasa a ejecutar el bloque correspondiente al caso en que el producto no existe.

Ruta de avance
Llegaste a un punto muy importante en tu aprendizaje dentro de TalentoLab. A lo largo de
las clases anteriores, adquiriste conocimientos fundamentales que te permiten gestionar
datos de manera más eficiente y estructurada. En esta clase, aprendiste a utilizar
diccionarios, una herramienta poderosa para asociar claves con valores, lo que facilita el
almacenamiento y la recuperación de información sin tener que depender de índices
numéricos.

Con lo que ya sabés, podés empezar a combinar listas y diccionarios para manejar
conjuntos más complejos de datos. Por ejemplo, podrías almacenar una lista de diccionarios
donde cada diccionario contenga información detallada de un producto, como su nombre,
precio y cantidad disponible. Esta estructura te permitirá llevar un registro más
organizado y fácilmente accesible de los datos que necesites en tu Trabajo Final
Integrador (TFI).

Hasta ahora, tus herramientas incluyen:

1.​ Listas para almacenar múltiples elementos ordenados y mutables.

2.​ Tuplas para almacenar elementos inmutables donde el orden es importante y no
necesitas modificar los datos.
3.​ Diccionarios para asociar claves con valores, facilitando búsquedas rápidas y
organizadas.
4.​ Bucles while y for para recorrer y manipular listas y diccionarios de manera
dinámica.
5.​ Condicionales para validar y procesar datos según distintos criterios.

Para tu TFI, podrías pensar en una aplicación que permita registrar clientes, productos o
cualquier otro conjunto de datos relevante. Algunas tareas que podrías implementar con lo
que aprendiste hasta ahora son:

●​ Agregar registros a una lista de diccionarios, donde cada diccionario represente un

cliente o un producto con información como nombre, código, y precio o datos de
contacto.
 ●​ Validar datos ingresados por el usuario, como asegurarte de que los campos no
estén vacíos o que los valores sean coherentes (por ejemplo, precios que no sean
negativos).
●​ Recorrer y mostrar registros usando bucles for para listar todos los clientes o
productos almacenados.
●​ Actualizar o eliminar registros existentes en la lista de diccionarios, asegurándote
de que el programa sea dinámico y permita gestionar la información sin reiniciar el
proceso.

Por ejemplo, podrías crear un programa que permita registrar una lista de productos con sus
precios, mostrar el inventario actual y permitir eliminar un producto si ya no está disponible.
Esta es una aplicación realista y práctica que te prepara para el desafío final.

Consejo de Luis: Recordá siempre pensar en cómo organizar tus datos para que sean
fáciles de acceder y modificar. Los diccionarios son ideales cuando necesitás buscar
elementos específicos sin recorrer toda la lista, mientras que las listas son útiles para
manejar conjuntos ordenados de datos.

🚀
Cada clase te acerca más al desarrollo de una aplicación completa. ¡Seguís por el camino
correcto y estás construyendo una base sólida para el Trabajo Final Integrador!

Ejercicio práctico.
Has aprendido y conocido todo sobre los diccionarios y su enorme importancia en el mundo
de la programación. Mariana te escribió una nota donde te explica claramente la tarea que
debe resolver el programa que deberás escribir el día de hoy:
¡Hola!

En TalentoLab nos han pedido desarrollar una aplicación que

registre productos y sus precios utilizando diccionarios.
Necesitamos que tu programa cumpla con estas
instrucciones:

●​ Crear un diccionario llamado productos donde las claves sean los nombres
de los productos y los valores sean sus precios.
●​ Permitir agregar productos y sus precios hasta que se decida finalizar.
●​ Mostrar el contenido del diccionario después de cada operación.

Consejo de Luis: Recordá que los diccionarios te permiten acceder a los datos
rápidamente usando claves y que podés modificar sus valores sin problemas. Aprovechá
esto para hacer que tu programa sea eficiente y fácil de usar.
Materiales y Recursos Adicionales:
Artículos:
El libro de Python: Diccionarios
Platzi: Cómo agregar, modificar y eliminar elementos de listas y diccionarios
Medium: Dominando los Diccionarios en Python

Videos:
La Geekipedia de Ernesto: Diccionarios en Python
Píldoras Informáticas: ¿Qué son los diccionarios?

Preguntas para Reflexionar:

1.​ ¿En qué situaciones es más útil usar un diccionario en lugar de una lista o una
tupla? Reflexioná sobre cómo los diccionarios facilitan el acceso a los datos cuando
necesitás buscar elementos específicos a partir de una clave.
2.​ ¿Cómo te ayuda la estructura de clave-valor de los diccionarios a organizar y
manejar información de manera más eficiente? Pensá en el tipo de problemas que
podrías resolver más rápidamente con esta estructura en comparación con otras.
3.​ ¿Qué ventajas ofrece el uso de diccionarios para registrar información en tu Trabajo
Final Integrador (TFI)? Considerá cómo podrías aplicar los diccionarios para
gestionar datos de clientes, productos u otra información relevante para tu proyecto.

Próximos pasos:
Llegaste al final de esta clase con una herramienta poderosa en tu haber: los diccionarios.
Ahora sabés cómo almacenar, acceder y manipular datos utilizando claves y valores, lo que
te permite gestionar información de una manera más eficiente y estructurada. Con estas
habilidades, estás mucho más cerca de construir una aplicación completa para el Trabajo
Final Integrador (TFI).

En la próxima clase, vas a dar un paso fundamental en tu camino como especialista en

desarrollo de software: aprenderás a crear funciones definidas por el usuario o usuaria.
Las funciones te permitirán organizar y modularizar tu código, dividiéndolo en bloques
más manejables y reutilizables. Esto hará que tus programas sean más claros, eficientes y
fáciles de mantener.

Descubrirás cómo definir funciones con y sin parámetros y entenderás el concepto de

alcance de variables, diferenciando entre variables locales y globales. Esta nueva
habilidad te ayudará a evitar la repetición de código y a estructurar tus proyectos de manera
más profesional.

🚀
¡Estás avanzando a pasos firmes y cada vez más cerca de dominar el desarrollo en Python!
Clase N° 9 | Funciones definidas
por el usuario I
Temario:
●​ Definición y uso de funciones.
●​ Funciones con y sin parámetros.
●​ Alcance de variables (variables locales y globales).

Objetivos de la Clase
En esta clase, vas a dar tus primeros pasos en el uso de funciones definidas por el usuario
en Python. Aprenderás a crear funciones que te permitirán dividir tu código en bloques más
organizados y fáciles de entender. Esto facilitará que tus programas sean más claros,
mantenibles evitando repetir el mismo código varias veces.

Vas a entender cómo se definen y utilizan funciones, tanto aquellas que no requieren
parámetros como aquellas que los utilizan para personalizar su comportamiento. Además,
explorarás el concepto de alcance de variables, comprendiendo la diferencia entre variables
locales y globales. Esta distinción es fundamental para controlar dónde y cómo se pueden
usar las variables en tu programa, ayudándote a evitar errores y conflictos de nombres.

Esta clase te preparará para profundizar en el uso de funciones en la próxima lección,

donde aprenderás a devolver resultados desde las funciones y a documentarlas
correctamente. ¡Estás por dar un gran paso hacia una programación más eficiente y
profesional! 🚀
Excitante jornada en TalentoLab 🚀

El día comienza con el habitual bullicio en la oficina de TalentoLab. Mientras encendés tu

computadora y revisás tus correos, un mensaje nuevo de Mariana aparece en tu bandeja
de entrada. El asunto es claro y directo: “Hora de organizar el código”. Abrís el correo y
leés:

Estás avanzando muy bien con las tareas del proyecto. Hasta ahora,
aprendiste a manejar datos con listas y diccionarios. Sin embargo, a
medida que tus programas crecen, se vuelven más largos y difíciles de
mantener.

Para que tu código sea más claro y fácil de manejar, es hora de que
aprendas a dividirlo en bloques más organizados. Necesitás utilizar
funciones, una herramienta esencial para cualquier programador o
programadora.

Sonreís mientras terminás de leer. En ese momento, Luis, el desarrollador senior, se asoma
por tu escritorio con una taza de café en la mano.

“Hoy vas a descubrir cómo las funciones te pueden salvar de que tu

código sea un caos. ¡Vas a ver que es un antes y un después! Nos
vemos en la reunión”.

Con la expectativa de un nuevo desafío por delante, cerrás el correo y te preparás para
sumergirte en el mundo de las funciones.
Funciónes.
En programación, una función es un bloque de código que se agrupa para realizar una
tarea específica. Las funciones permiten encapsular una serie de instrucciones que pueden
ejecutarse cuando se las necesita. En otras palabras, son como pequeñas unidades de
trabajo que se encargan de hacer algo en particular, como sumar dos números, mostrar un
mensaje por pantalla o realizar una operación más compleja.

Una función puede recibir datos de entrada y también puede devolver un resultado. Sin
embargo, no todas las funciones requieren parámetros (los datos de entrada mencionados
previamente) o devuelven un valor; algunas simplemente ejecutan una acción específica. Lo
importante es que las funciones ayudan a dividir un programa en partes más pequeñas y
manejables, facilitando la organización y el mantenimiento del código.

En Python, además de las funciones que el propio lenguaje nos

ofrece (como print() o len()), existen otras formas de crear funciones
para personalizar nuestras tareas y resolver problemas específicos.
Esta flexibilidad hace que el código sea más eficiente y fácil de
entender.

El concepto de Función Definida por el Usuario

(UDF).
Una función definida por el usuario o usuaria es una función creada por vos para
resolver una tarea específica dentro de tu programa. A diferencia de las funciones que ya
vienen incorporadas en Python, cómo print() o input(), estas funciones las diseñás según
las necesidades particulares de tu código. Básicamente, es una forma de decirle a Python
qué instrucciones debe ejecutar y cuándo hacerlo.

Definir una función implica darle un nombre y especificar qué acciones debe realizar.
También podés decidir si querés que la función reciba datos para trabajar con ellos.

Una vez que definís una función, la podés reutilizar en diferentes

partes de tu programa sin tener que volver a escribir el mismo código.
Esto no solo hace que el código sea más limpio y ordenado, sino que
también facilita el mantenimiento y la corrección de errores.

Por ejemplo, si necesitás calcular el total de una compra con impuestos varias veces en un
programa, en lugar de escribir el cálculo cada vez, podés definir una función y llamarla -por
ejemplo- calcular_total() que realice esa tarea. Luego, cada vez que necesites ese cálculo,
simplemente llamás a la función con los datos que corresponden.
Las funciones definidas por la usuaria o usuario permiten personalizar y modularizar el
código, haciéndolo más eficiente y adaptado a los requerimientos de cada proyecto. Al
usarlas, estás aplicando una de las mejores prácticas en programación, facilitando el
desarrollo de soluciones más claras y profesionales.

Ventajas del enfoque funcional.

El uso de funciones en programación tiene muchas ventajas que facilitan el desarrollo y
mantenimiento del código. Una de las principales ventajas es que permite dividir el
programa en bloques más pequeños y manejables, haciendo que sea más fácil entender
qué hace cada parte del código. En lugar de tener un programa largo y difícil de seguir,
podés estructurarlo en funciones específicas, donde cada una realiza una tarea concreta.
Esto ayuda a que el código sea más claro y lógico.

Además, las funciones promueven la reutilización del código. Cuando definís una función
para resolver un problema específico, podés llamarla tantas veces como necesites sin tener
que volver a escribir las mismas instrucciones. Esto no solo ahorra tiempo, sino que también
reduce el riesgo de cometer errores, ya que si necesitás hacer una corrección, solo tenés
que modificar la función una vez y el cambio se aplicará en todas partes donde la función se
utilice.

El enfoque funcional también facilita el mantenimiento y la depuración del código. Si algo

no funciona como esperabas, podés enfocarte en revisar una función específica en lugar de
buscar el problema en todo el programa. Esto hace que encontrar y corregir errores sea
mucho más sencillo. Además, si en el futuro necesitás agregar nuevas funcionalidades,
podés hacerlo creando nuevas funciones sin modificar el resto del código.

Otra ventaja importante es que las funciones ayudan a mejorar la legibilidad y

comprensión del código. Cuando alguien más (o vos en el futuro, después de un tiempo)
lee el programa, las funciones con nombres claros indican exactamente qué hace cada
parte del código. Esto hace que el programa sea más fácil de entender y mantener a largo
plazo.

Por último, el uso de funciones permite implementar prácticas de programación modular,

donde cada función actúa como un bloque independiente. Esta modularidad te permite
trabajar en equipo de manera más eficiente, ya que diferentes personas pueden desarrollar
y probar funciones específicas sin interferir en el trabajo de los demás.

Descomposición y abstracción.
Al profundizar en las ventajas del enfoque funcional, dos conceptos clave emergen como
pilares fundamentales: la descomposición y la abstracción. Estos conceptos son
esenciales para entender por qué las funciones son tan poderosas y útiles en la
programación.

La descomposición se refiere a dividir una tarea compleja en partes más pequeñas y

manejables. Cada una de estas partes puede resolverse de forma independiente, lo que
simplifica el proceso de desarrollo y hace que el código sea más ordenado. Las funciones
son la herramienta ideal para llevar a cabo esta descomposición porque permiten
encapsular comportamientos específicos en bloques de código separados. Por ejemplo, en
lugar de escribir todo el código para un programa de una sola vez, podés descomponerlo en
funciones individuales que realicen tareas concretas, como procesar datos, mostrar
información o calcular resultados.

Por otro lado, la abstracción implica ocultar los detalles internos de cómo funciona una
operación, mostrando solo lo necesario para utilizarla. En el contexto de las funciones, esto
significa que podés usar una función sin tener que saber exactamente cómo está
implementada por dentro. Lo único que necesitás conocer es su nombre, qué datos recibe
(los parámetros) y qué devuelve (el resultado). Esta capacidad de abstraer detalles hace
que el código sea más fácil de entender y reduce la cantidad de información que quien
desarrolla el software necesita manejar a la vez. Por ejemplo, si definís una función llamada
calcular_total() para sumar precios con impuestos, podés usar esa función sin preocuparte
por las fórmulas específicas que contiene.

La combinación de descomposición y abstracción permite desarrollar programas más

organizados y mantenibles. Dividir el código en funciones bien definidas ayuda a simplificar
el trabajo y facilita agregar nuevas funcionalidades sin afectar otras partes del programa.
Además, al abstraer los detalles de implementación, podés centrarte en el "qué hace" cada
función en lugar del "cómo lo hace", lo que mejora la claridad y legibilidad del código.

Funciones definidas por el usuario en Python

En Python, una función es un bloque de código que realiza una tarea específica y puede
reutilizarse en diferentes partes del programa. Para definir una función en Python, se usa la
palabra clave def, seguida del nombre de la función y un par de paréntesis. Después de los
paréntesis, se coloca un dos puntos : y se escribe el cuerpo de la función, que es el
conjunto de instrucciones que se ejecutarán cuando se llame a la función.

Es importante recordar que el cuerpo de la función debe estar indentado, es

decir, con una sangría de (generalmente) 4 espacios o un tabulador.
Ejemplo 1: Una función simple

def saludo():
print("¡Hola, mundo!")

# Llamada a la función
saludo()

En este ejemplo, saludo es una función que no acepta argumentos y su única acción es
imprimir el mensaje "¡Hola, mundo!" en la consola. Para llamar o ejecutar esta función,
simplemente usas su nombre seguido de paréntesis.

# Llamada a la función
saludo()

Ejemplo 2: Función para mostrar un mensaje predefinido

def mostrar_mensaje():
mensaje = "Este es un mensaje predefinido."
print(mensaje)

# Llamada a la función
mostrar_mensaje()

En este caso, mostrar_mensaje es otra función que no recibe datos externos. Dentro de su
cuerpo, se define una variable llamada mensaje con un texto predefinido y luego se muestra
ese mensaje en la consola. Al llamar a esta función, se ejecuta el código contenido en ella.

Estas funciones son una buena manera de empezar a organizar tu código en bloques
reutilizables, incluso si todavía no necesitás trabajar con datos externos ni devolver
resultados.
Funciones que reciben valores.
En Python, una función puede definirse para recibir datos externos. Estos datos se
especifican entre los paréntesis al definir la función y se llaman parámetros. Cuando llamás
a la función, debés pasarle valores específicos, conocidos como argumentos, que serán
utilizados dentro de la función para realizar alguna tarea.

Diferencia entre parámetro y argumento

Un parámetro es una variable que se define en la función y representa un valor que la

función espera recibir. Por otro lado, un argumento es el valor real que se le pasa a la
función cuando se la llama. Es importante que el número y el orden de los argumentos
coincidan con los parámetros definidos en la función.

Para definir una función que recibe datos, se escribe el nombre de la función seguido de
paréntesis que contienen los parámetros. Estos parámetros se comportan como variables
dentro de la función. Veamos un ejemplo:

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

# Llamada a la función con un argumento

saludar("Lucía")

En este ejemplo, nombre es un parámetro de la función saludar. Al llamar a la función y

pasar el argumento "Lucía", la función muestra el mensaje "¡Hola, Lucía!".

¡Hola, Lucía!

Podemos llamar a la función usando diferentes argumentos:

# Llamada a la función con distintos argumentos

saludar("Ana")
saludar("Martín")
Esta es la salida en la terminal:

¡Hola, Ana!
¡Hola, Martín!

Luis, que está viendo tus avances, te propone un ejemplo más interesante:

“Esta función recibe números, los suma y almacena su valor en la

variable resultado y, por último, lo muestra junto con un mensaje.¿Te
animás a probarla?”

def sumar(numero1, numero2):

resultado = numero1 + numero2
print(f"El resultado de la suma es: {resultado}")

# Llamada a la función con argumentos

sumar(10, 5)

En este caso, la función que te muestra Luis tiene dos parámetros: numero1 y numero2.

Acá tenés una tabla comparativa que muestra las diferencias entre funciones con
parámetros y funciones sin parámetros, destacando su utilidad en distintos contextos:

Aspecto Funciones sin parámetros Funciones con parámetros

No reciben valores al ser Reciben valores (argumentos) al ser

Definición
llamadas. llamadas.

def saludar(): def saludar(nombre):

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

Tareas que no requieren Tareas que dependen de datos

Uso típico datos externos para específicos para su ejecución.
ejecutarse.
 Limitada, siempre realiza la Flexible, se adapta a distintos datos
Flexibilidad
misma acción. según los argumentos.

Simplicidad y claridad. Útil Permite reutilizar la función con

Ventaja para operaciones estáticas o diferentes datos y contextos.
predeterminadas.

Ejemplo de Imprimir un mensaje fijo o Calcular el área de una figura o mostrar

aplicación una rutina de inicialización. información personalizada.

Parámetros predeterminados.
Las funciones en muchos lenguajes de programación, incluido Python, pueden diseñarse
para aceptar parámetros opcionales, también conocidos como parámetros
predeterminados u opcionales. Estos permiten que una función sea llamada con menos
argumentos de los que se especifican en su definición. Además, les podes pasar los
parámetros por su nombre, lo que aumenta la claridad y flexibilidad del código.

Los parámetros opcionales se definen asignando un valor

predeterminado al parámetro en la definición de la función. Si al llamar
a la función no se proporciona un argumento para ese parámetro, se
utiliza el valor predeterminado.

Veamos un ejemplo:

def saludar(nombre, mensaje="Hola"):

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

saludar("Ana")
saludar("Luis", "Buenos días")
En este ejemplo, el parámetro mensaje tiene un valor predeterminado de "Hola". Esto
significa que si al llamar a saludar() no se proporciona un argumento para mensaje, se
usará "Hola" por defecto. La salida del código anterior es la siguiente:

Hola, Ana!
Buenos días, Luis!

En este otro ejemplo, vamos a definir una función que construya una dirección completa a
partir de diferentes partes de una dirección, como la calle, el número, la ciudad, y el código
postal. Haremos opcionales el número y el código postal, proporcionándoles valores
predeterminados.

def crear_direccion(calle, numero='S/N', ciudad='Sin especificar',

codigo_postal='N/A'):
return f"Dirección: {calle} {numero}, {ciudad}. C.P.:
{codigo_postal}"

# Llamada con todos los parámetros especificados

print(crear_direccion("Avenida Corrientes", 1234, "Buenos Aires",
"1043"))

# Llamada sin especificar el número ni el código postal

print(crear_direccion("Calle Florida", ciudad="CABA"))

Luis te explica la función que tiene cada parámetro:

calle: Parámetro obligatorio que especifica el nombre de la calle.

numero (opcional): Número de la vivienda, con un valor predeterminado de 'S/N' (sin
número).
ciudad (opcional): Ciudad de la dirección, con un valor predeterminado de 'Sin especificar'.
codigo_postal (opcional): Código postal de la dirección, con un valor predeterminado de
'N/A' (no aplicable).

El código anterior produce la siguiente salida:

Dirección: Avenida Corrientes 1234, Buenos Aires. C.P.: 1043

Dirección: Calle Florida S/N, CABA. C.P.: N/A
En el primer caso, sólo se proporciona el nombre de la calle, y se usan los valores
predeterminados para el número, la ciudad y el código postal. En el segundo caso, se
especifican la calle, el número y la ciudad, pero se omite el código postal, por lo que se
utiliza el valor predeterminado.

Estos ejemplos te muestran cómo podés utilizar parámetros con valores por defecto para
flexibilizar las llamadas a funciones, facilitando su uso en diferentes situaciones sin
necesidad de proporcionar todos los datos cada vez.

Parámetros pasados por nombre.

Python te permite pasar argumentos a funciones especificando explícitamente el nombre del
parámetro, lo que es muy útil cuando se necesita ignorar el orden en que se definen los
parámetros en la función. Esto es particularmente importante en funciones con muchos
parámetros, ya que mejora la legibilidad del código:

def registrar_usuario(nombre, edad, ciudad):

print(f"Nombre: {nombre}, Edad: {edad}, Ciudad: {ciudad}")

registrar_usuario(edad=30, nombre="Carlos", ciudad="Madrid")

En este caso, los argumentos se pasan a la función registrar_usuario por su nombre, lo

que te permite cambiar el orden en que se especifican sin afectar el comportamiento de la
función. Esto es lo que ves en la terminal:

Nombre: Mateo, Edad: 30, Ciudad: Madrid

Algunas de las ventajas que tiene el uso de parámetros pasados por nombre incluyen:

El uso de parámetros opcionales y el paso de argumentos por nombre

Claridad hacen que el código sea más claro y fácil de entender, especialmente
cuando se trabaja con funciones que tienen muchos parámetros.

Permiten que una función sea más versátil y se adapte a diferentes

Flexibilidad situaciones sin necesidad de definir múltiples funciones para cada
variante de comportamiento.
 Reducen la necesidad de sobrecargar funciones o definir múltiples
Simplicidad
funciones para casos ligeramente diferentes.

El uso de parámetros opcionales y el paso de argumentos por nombre son características

muy poderosas que proporcionan flexibilidad y claridad al definir y llamar funciones. Te
permiten escribir código más limpio y mantenible, haciéndote más fácil la gestión de la
lógica de las funciones y la interacción con ellas.

¿Cómo nombrar las funciones definidas por el

usuario?
A la hora de nombrar funciones en Python, seguir convenciones y buenas prácticas es clave
para que el código sea fácil de leer, mantener y entender. Esto no solo ayuda a que puedas
organizarte mejor, sino que también facilita el trabajo en equipo y el mantenimiento del
código a futuro. A continuación, te detallo algunas pautas que te van a ayudar a elegir
nombres adecuados para tus funciones.

Los nombres de las funciones tienen que ser claros y descriptivos, reflejando de manera
precisa lo que hace la función. Por ejemplo, calcular_area() es mucho más entendible que
func1(). Elegir nombres que describan bien la acción de la función evita confusiones y hace
que el código sea más intuitivo.

En Python, lo más común es usar letras minúsculas y separar las palabras con guiones
bajos (underscores). Este estilo se llama snake_case. Por ejemplo, calcular_area_circulo()
es preferible a CalcularAreaCirculo o calcularAreaCirculo.

Es una buena idea empezar los nombres de las funciones con un verbo que
indique claramente qué acción realiza. Ejemplos de verbos comunes son:
obtener, calcular, mostrar, crear o imprimir. Por ejemplo,
obtener_nombre_completo() deja claro que la función se encarga de obtener
un nombre completo.

Tratemos de evitar abreviaturas y acrónimos que puedan ser confusos. Aunque a veces
los acrónimos son aceptables si son muy conocidos (como IMC para "Índice de Masa
Corporal"), siempre es mejor priorizar la claridad. Por ejemplo, calcular_imc() puede ser
entendible, pero calcular_indice_masa_corporal() es aún más claro. Pero si bien es
importante que los nombres sean descriptivos, no te excedas con la longitud. Nombres
excesivamente largos pueden dificultar la lectura. Encontrá un equilibrio entre ser claro y ser
breve.
Los nombres deben ser lo más específicos posible. En lugar de usar algo genérico como
procesar_datos(), un nombre más preciso sería filtrar_usuarios_activos(). Esto ayuda a
entender rápidamente qué hace exactamente la función sin necesidad de revisar su código.

Es importante evitar nombres que puedan confundirse con funciones integradas

de Python, como list(), str() o input(), ya que esto puede generar errores y
comportamientos inesperados. Elegí nombres que no entren en conflicto con
estos identificadores.

El alcance de las variables en Python.

Cuando trabajamos con funciones en Python, es fundamental entender el concepto de
alcance de las variables. El alcance determina en qué partes del programa una variable es
accesible y dónde no lo es. En otras palabras, define el "ámbito" en el que una variable
existe y se puede usar. Existen dos tipos principales de alcance: local y global.

Variables locales

Las variables locales son aquellas que se definen dentro de una función. Su alcance se
limita exclusivamente a esa función, lo que significa que sólo pueden ser usadas dentro de
ella. No se puede acceder a una variable local desde fuera de la función en la que fue
declarada. Estas variables se crean cuando se llama a la función y se eliminan
automáticamente cuando la función termina de ejecutarse.

Veamos un ejemplo claro:

def saludar():
mensaje = "¡Hola, mundo!" # 'mensaje' es una variable local
print(mensaje)

saludar()
print(mensaje)
# Esto da un error porque 'mensaje' no existe fuera de la función

En este caso, la variable mensaje sólo existe dentro de la función saludar(). Si intentás
acceder a mensaje fuera de esa función, obtenés un error porque su alcance es local.

Variables globales

Por otro lado, una variable global es aquella que se declara fuera de cualquier función.
Esto significa que puede ser utilizada tanto dentro como fuera de las funciones. Sin
embargo, si queremos modificar una variable global desde dentro de una función, debemos
declararla explícitamente como global usando la palabra clave global. De lo contrario,
Python interpretará que estamos creando una nueva variable local dentro de esa función.

Veamos un ejemplo de variable global:

# 'nombre' es una variable global

nombre = "Ana"

def saludar():
# Declaramos que queremos usar la variable global 'nombre'
global nombre
nombre = "María"
print(f"Hola, {nombre}")

saludar()
print(nombre)
# Esto imprime 'María' porque modificamos la variable global

En este caso, la variable nombre se define fuera de la función y puede ser accedida y
modificada dentro de saludar() gracias a la declaración global nombre. Si no hubiéramos
usado la declaración global, se hubiese creado una variable local dentro de la función, su
nombre fuera de la función, donde está el print(nombre), mostraria el mensaje “Ana”.
¡Probalo!

Mutabilidad y referencia en listas y diccionarios.

Cuando pasamos una lista o un diccionario a una función como parámetro, lo que realmente
se pasa es una referencia al objeto. Esto significa que si modificas el contenido de esa
lista o diccionario dentro de la función, esos cambios se reflejarán fuera de la función
porque estamos operando sobre el mismo objeto en memoria.

Ejemplo sin global:

def agregar_item(lista):
[Link]("nuevo elemento")

frutas = ["manzana", "banana"]

agregar_item(frutas)
print(frutas) # Salida: ['manzana', 'banana', 'nuevo elemento']
En este caso, se modifica la lista original porque estamos trabajando con su referencia
directa.

La cláusula global en funciones con listas y diccionarios.

La cláusula global permite declarar una variable global dentro de una función, lo que
significa que cualquier asignación hecha a esa variable dentro de la función afectará a la
variable global, no a una copia local.

Sin embargo, en el caso de listas y diccionarios, es importante distinguir entre:

1.​ Modificar el contenido del objeto (mutación): Esto no requiere global porque la
función está trabajando con la referencia al objeto.
2.​ Reasignar una lista o diccionario completo: Esto sí requiere global si se quiere
afectar la variable global.

Ejemplo con global para reasignar una lista:

frutas = ["manzana", "banana"]

def reemplazar_lista():
# Declaramos que queremos modificar la variable global
global frutas
frutas = ["naranja", "kiwi"]

reemplazar_lista()
print(frutas) # Salida: ['naranja', 'kiwi']

En este caso, sin global, se crearía una nueva variable local frutas dentro de la función y la
lista global no se vería afectada.

Ejemplo sin global para modificar el contenido:

frutas = ["manzana", "banana"]

def agregar_item():
# Modifica el contenido sin necesidad de 'global'
[Link]("naranja")

agregar_item()
print(frutas) # Salida: ['manzana', 'banana', 'naranja']
Aquí no es necesario declarar global porque sólo estamos modificando el contenido de la
lista global, no reasignándola.

Tuplas.
Las tuplas son estructuras inmutables, es decir, no se pueden modificar una vez creadas.
Si intentás cambiar una tupla dentro de una función, Python generará un error. Sin embargo,
si reasignás una tupla dentro de una función, la reasignación no afectará a la tupla original
fuera de la función.

# Tupla original
numeros = (1, 2, 3)

def cambiar_tupla():
# Creamos una nueva tupla, pero no modificamos la original
nueva_tupla = (4, 5, 6)
return nueva_tupla

# Llamamos a la función pero no reasignamos

cambiar_tupla()

print(numeros) # Salida: (1, 2, 3)

En este caso, la tupla numeros no cambia fuera de la función porque, aunque se crea una
nueva tupla dentro de la función, no se modifica la original.

Recomendación

Cuando trabajes con funciones y necesites pasar una lista o un diccionario, recordá que
las modificaciones dentro de la función afectarán al objeto original. Si no querés que esto
ocurra, podés crear una copia del objeto antes de pasarlo a la función:

def agregar_elemento(lista):
[Link]("nuevo elemento")

frutas = ["manzana", "banana"]

# Pasamos una copia de la lista
agregar_elemento([Link]())

print(frutas) # Salida: ['manzana', 'banana']

De esta manera, preservás el estado original de la lista. En cambio, con las tuplas, como
son inmutables, no hace falta preocuparse por este tipo de efectos secundarios.

La importancia del alcance.

Entender el alcance de las variables ayuda a evitar errores y a escribir código más
organizado y eficiente. Las variables locales permiten encapsular datos dentro de funciones
sin interferir con otras partes del programa. Por otro lado, las variables globales pueden ser
útiles para datos que necesitan ser compartidos en varias funciones, pero deben usarse con
cuidado para no generar confusión o errores inesperados.

Siempre que sea posible, usá variables locales dentro de tus funciones. Las variables
locales ayudan a que el código sea más modular, fácil de entender y mantener. Al limitar el
alcance de una variable a una función específica, evitás interferencias con otras partes del
programa y reducís la posibilidad de errores inesperados.

Además, el uso de variables locales facilita el proceso de depuración y hace que tus
funciones sean más reutilizables, ya que no dependen del estado global del programa. Si
necesitás que una función devuelva datos, es mejor hacerlo a través de un valor de
retorno en lugar de modificar variables globales. ¡Aprenderemos a hacer eso pronto!

De esta manera, combinando el uso de funciones con una buena gestión del alcance de las
variables, podrás desarrollar programas más organizados, claros y fáciles de mantener.

Implementación de un menú para gestionar

una lista de frutas con funciones.
Vamos a implementar un pequeño programa que utilice funciones para agregar, consultar y
borrar frutas de una lista. El programa presentará un menú que le permitirá al usuario elegir
qué acción desea realizar. Utilizaremos funciones definidas por el usuario para organizar el
código de manera modular, lo que facilita su lectura y mantenimiento.

En primer lugar, definimos una lista vacía llamada frutas que almacenará los nombres de
las frutas. Luego, crearemos tres funciones: una para agregar frutas, otra para consultar
la lista de frutas, y una más para borrar una fruta específica. Finalmente,
implementaremos una función para mostrar el menú y permitir que se seleccione una
opción.

Aquí está el código completo con los comentarios necesarios para entender cada parte:

# Lista vacía para almacenar las frutas

frutas = []

# Función para agregar una fruta a la lista

def agregar_fruta():
fruta = input("Ingresá el nombre de la fruta que querés
agregar: ").capitalize()
[Link](fruta)
print(f"Fruta '{fruta}' agregada con éxito.\n")

# Función para consultar (mostrar) todas las frutas en la lista

def consultar_frutas():
if frutas:
print("Lista de frutas:")
for i, fruta in enumerate(frutas, start=1):
print(f"{i}. {fruta}")
else:
print("La lista de frutas está vacía.")
print()

# Función para borrar una fruta de la lista

def borrar_fruta():
if frutas:
fruta = input("Ingresá el nombre de la fruta que querés
borrar: ").capitalize()
if fruta in frutas:
[Link](fruta)
print(f"Fruta '{fruta}' eliminada con éxito.\n")
else:
print(f"La fruta '{fruta}' no está en la lista.\n")
else:
print("La lista de frutas está vacía. No hay nada para
borrar.\n")
# Función para mostrar el menú y manejar las opciones del usuario
def mostrar_menu():
while True:
print("Menú de gestión de frutas:")
print("1. Agregar una fruta")
print("2. Consultar la lista de frutas")
print("3. Borrar una fruta")
print("4. Salir")

opcion = input("Elegí una opción (1-4): ")

if opcion == "1":
agregar_fruta()
elif opcion == "2":
consultar_frutas()
elif opcion == "3":
borrar_fruta()
elif opcion == "4":
print("¡Gracias por usar el programa! ¡Chau!")
break
else:
print("Opción no válida. Por favor, ingresá un número
del 1 al 4.\n")

# Llamada inicial para ejecutar el menú

mostrar_menu()

Luis ve la forma en la que mirás el código y te ayuda a interpretar cómo funciona:

“El programa comienza definiendo una lista vacía llamada frutas que servirá para
almacenar los nombres de las frutas ingresadas por quién usa el programa.

1.​ Función agregar_fruta: Esta función pide que se ingrese el nombre de una fruta, lo
convierte a mayúscula inicial con .capitalize() y la agrega a la lista con el método
.append(). Luego, muestra un mensaje confirmando que la fruta fue agregada.
2.​ Función consultar_frutas: Muestra todas las frutas almacenadas en la lista. Si la
lista está vacía, informa que no hay frutas para mostrar. Utiliza un bucle for con
enumerate para mostrar cada fruta con un número de posición.
3.​ Función borrar_fruta: Pide el nombre de una fruta para eliminarla. Si la fruta está
en la lista, la elimina con el método .remove(). Si no se encuentra en la lista, muestra
 un mensaje indicando que la fruta no existe. Si la lista está vacía, avisa que no hay
nada para borrar.
4.​ Función mostrar_menu: Muestra un menú con opciones numeradas del 1 al 4.
Dependiendo de la opción ingresada, llama a la función correspondiente. La opción
4 permite salir del programa, mientras que cualquier otra entrada no válida muestra
un mensaje de error.”

Este ejemplo te muestra cómo podés usar funciones para organizar

tu código y aplicar conceptos como listas y bucles while. Además,
muestra cómo estructurar un pequeño programa de manera modular y
reutilizable.

Ejercicio práctico:
Mariana te ha asignado una tarea clave para el proyecto de TalentoLab: desarrollar un
pequeño programa que permita gestionar una lista de productos utilizando funciones. El
objetivo es que la usuaria o usuario pueda agregar, consultar y eliminar productos,
aplicando lo que aprendiste sobre funciones y listas. Este ejercicio te ayudará a modularizar
el código y a practicar la interacción con el usuario. Así te lo ha comunicado Mariana:
¡Hola!

Tu tarea es crear un programa en Python con las siguientes

características:

●​ Agregar productos: Permite a la usuaria o usuario

agregar productos a una lista. Cada producto debe
tener un nombre y un precio.

●​ Consultar productos: Muestra todos los productos en la lista junto con sus
precios.
●​ Eliminar productos: Elimina un producto de la lista a partir de su nombre.
●​ Menú interactivo: El programa debe ofrecer un menú para que el usuario o
usuaria pueda elegir qué acción realizar. Debe incluirse una opción para
salir del programa.

¡Ponete a prueba y completá el desafío!

Materiales y recursos adicionales:
Artículos:
Escuela Superior Politécnica del Litoral: Funciones en Python
Pablo Londoño: Guía básica de funciones en Python

Videos:
Tutoriales sobre Ciencia y Tecnología: Funciones en Python
Píldoras informáticas: Funciones en Python (I) y Funciones en Python (II)

Preguntas para reflexionar:

1.​ ¿Por qué es útil dividir el código en funciones en lugar de escribir todo en un solo
bloque? Reflexioná sobre cómo las funciones ayudan a organizar y simplificar tareas
complejas en tu programa. ¿Qué ventajas notás al estructurar el código de esta
manera?
2.​ ¿Cómo podría mejorar el programa de gestión de productos que desarrollaste?
Considerá qué funcionalidades adicionales podrías agregar (por ejemplo, modificar
el precio de un producto o buscar productos específicos). ¿Cómo cambiaría el
código si implementaras estas mejoras?
3.​ ¿Cómo podrías aplicar lo aprendido sobre funciones en tu Trabajo Final Integrador
(TFI)? Pensá en qué partes del TFI podrías simplificar o mejorar usando funciones.
¿Qué beneficios tendría modularizar tu código para el proyecto final?
Próximos pasos:
En la próxima clase, vas a profundizar en el uso de funciones para llevar tu código al
siguiente nivel. Aprenderás a trabajar con la sentencia return, una herramienta fundamental
que permite a las funciones devolver resultados para ser utilizados en otras partes del
programa. Esto te permitirá crear funciones más flexibles y reutilizables, que no solo
ejecuten una tarea sino que también devuelvan valores útiles.

Además, explorarás cómo las funciones pueden devolver múltiples valores utilizando
tuplas, lo que te permitirá manejar varios datos de manera sencilla y eficiente. También
incorporarás buenas prácticas de programación con docstrings, una manera de
documentar tus funciones para que sean más fáciles de entender y mantener, tanto para
vos como para otros miembros del equipo de TechLab.
Clase N° 10 | Funciones definidas
por el usuario II
Temario:
●​ Uso de la sentencia return.
●​ Funciones que devuelven valores.
●​ Funciones que devuelven múltiples valores (tuplas).
●​ Documentación de funciones (docstrings).

Objetivos de la clase
En esta clase vas a explorar cómo las funciones pueden devolver resultados que se utilicen
en otras partes de tu programa. Aprenderás a emplear la sentencia return, una herramienta
fundamental para hacer que tus funciones sean más flexibles y útiles. Además, vamos a
introducir el concepto de funciones que devuelven múltiples valores, utilizando tuplas para
facilitar este tipo de operaciones.

También profundizaremos en las buenas prácticas de documentación mediante el uso de

docstrings, lo que te permitirá escribir código claro y fácil de entender, tanto para vos como
para cualquier persona que lo utilice en el futuro.

🚀
Al término de esta clase, podrás aplicar funciones en escenarios más complejos,
integrándolas con todo lo que ya aprendiste previamente en el curso.
Hermosa mañana en TalentoLab 🚀

Es una hermosa mañana en TalentoLab y el equipo se encuentra reunido en la sala común,

compartiendo café y algunas ideas sobre los proyectos en curso. Mientras organizás tus
materiales para el día, Luis, el desarrollador senior, se acerca y te cuenta:

Hoy vamos a llevar tus funciones al siguiente nivel. Hasta ahora,

aprendiste a estructurar tu código usando funciones definidas por vos.
Pero hay algo fundamental que no podés dejar pasar: el poder de
devolver valores desde una función. Imaginate esto: ¿qué pasaría si
cada vez que querés calcular un resultado, tenés que imprimirlo y no
podés usarlo en otra parte del programa? Sería un caos, ¿no? Por eso
hoy vas a aprender sobre la sentencia return.

Mariana aparece por la puerta y se suma a la conversación:

Necesitamos que te familiarices con funciones que devuelvan más de un
valor. También quiero que aproveches la oportunidad para incorporar
documentación a tus funciones. Es una práctica esencial, no solo para
trabajar en equipo, sino también para que vos puedas entender tu propio
código dentro de unos meses.

Con esa introducción, sabés que el día será un desafío interesante, y te entusiasma pensar
en cómo estas herramientas te van a ayudar en el desarrollo del Trabajo Final Integrador.

Introducción a la sentencia return.

En la clase anterior, aprendiste a definir y utilizar funciones para organizar tu código en
bloques reutilizables que realizan tareas específicas. Hasta ahora, las funciones que viste
ejecutaban acciones, pero no devolvían ningún resultado directamente. Es aquí donde entra
en juego la sentencia return, una herramienta fundamental en Python para que una función
pueda devolver un valor o un resultado a quien la llama.

La sentencia return marca el final de la ejecución de una función y, opcionalmente, puede

devolver un valor al código que llamó a la función. Esto permite que los resultados de los
cálculos o procesos realizados dentro de la función sean utilizados fuera de ella, ya sea
para mostrarlos, almacenarlos o procesarlos nuevamente.

La principal ventaja de return es que hace que las funciones sean

más flexibles y útiles. Podés encapsular una lógica compleja dentro de
una función y simplemente devolver el resultado, evitando repetir
código. Además, el uso de return fomenta el desarrollo de código más
modular y legible.

Return en una función simple.

Imaginá que queremos crear una función que calcule el cuadrado de un número y devuelva
el resultado para que pueda ser utilizado más adelante en el programa. A continuación
vemos una posible solución:

# Definimos una función que calcula el cuadrado de un número

def calcular_cuadrado(numero):
# Elevamos el número al cuadrado
resultado = numero ** 2
# Devolvemos el resultado
return resultado

# Llamamos a la función y almacenamos el valor devuelto

numero_ingresado = int(input("Ingresá un número: "))
cuadrado = calcular_cuadrado(numero_ingresado)

# Mostramos el resultado al usuario

print(f"El cuadrado de {numero_ingresado} es {cuadrado}")

“En este programa, primero definimos una función llamada

calcular_cuadrado, que toma un número como parámetro. Dentro de
la función, el número se eleva al cuadrado usando el operador **, y
luego el resultado se devuelve con la sentencia return.”

Cuando llamamos a la función, el valor devuelto se asigna a la variable cuadrado, que luego
utilizamos para mostrar el resultado a la usuaria o usuario”, finaliza Luis.
Este enfoque te permite reutilizar la lógica de calcular el cuadrado en diferentes partes de tu
programa, simplemente llamando a la función con un nuevo número como argumento.

Ejemplo práctico: calculadora simple.

En este ejemplo, crearemos una función para cada operación matemática básica (suma,
resta, multiplicación y división). Estas funciones serán llamadas desde un menú que permite
elegir la operación que desea realizar.

# Definimos funciones para cada operación matemática

def sumar(a, b):
return a + b

def restar(a, b):

return a - b

def multiplicar(a, b):

return a * b

def dividir(a, b):

if b != 0:
return a / b
else:
return "Error: No se puede dividir por cero."

# Función para mostrar el menú y ejecutar la calculadora

def calculadora():
print("Bienvenido/a a la calculadora simple.")
print("Elegí una operación:")
print("1. Suma")
print("2. Resta")
print("3. Multiplicación")
print("4. División")
print("5. Salir")

while True:
opcion = input("Ingresá el número de la operación que querés
realizar: ")

if opcion == "5":
 print("Gracias por usar la calculadora. ¡Hasta luego!")
break

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

num1 = float(input("Ingresá el primer número: "))
num2 = float(input("Ingresá el segundo número: "))

if opcion == "1":
print(f"Resultado: {sumar(num1, num2)}")
elif opcion == "2":
print(f"Resultado: {restar(num1, num2)}")
elif opcion == "3":
print(f"Resultado: {multiplicar(num1, num2)}")
elif opcion == "4":
print(f"Resultado: {dividir(num1, num2)}")
else:
print("Opción no válida. Por favor, elegí una opción entre 1
y 5.")

Luis te explica que "el corazón de esta calculadora son las funciones
que definimos para cada operación matemática. Cada función toma dos
argumentos (a y b) y devuelve el resultado correspondiente. Por
ejemplo, la función sumar simplemente retorna la suma de sus dos
parámetros.
Lo interesante acá es cómo integramos estas funciones dentro de un bucle para crear una
experiencia interactiva. En el menú principal, otorgamos la opción de elegir qué operación
realizar o salir del programa. Cuando se elige una operación válida (del 1 al 4), pedimos los
dos números necesarios, llamamos a la función correspondiente y mostramos el resultado.

El manejo de la división tiene una validación extra para evitar dividir por cero, que es un
caso común de error en programación. Este tipo de detalle demuestra la importancia de
anticiparse a posibles problemas y solucionarlos de antemano.

Por último, el uso del bucle while nos permite que la calculadora siga funcionando hasta que
se seleccione la opción salir. Este enfoque modular y reutilizable no solo hace el código más
legible, sino que también sienta una base sólida para futuras mejoras (¡y para implementar
en el TFI!), como agregar nuevas operaciones o implementar funciones más avanzadas.
Ejemplo práctico:
Veamos cómo en este caso podemos crear una función que calcule el precio total de un
producto en base a su precio unitario y cantidad, pero con un parámetro opcional que
permita aplicar un descuento.

# Definimos una función para calcular el precio total

def calcular_precio_total(precio_unitario, cantidad, descuento=0):
subtotal = precio_unitario * cantidad # Calculamos el subtotal
descuento_aplicado = subtotal * (descuento / 100) # Calculamos el
descuento
total = subtotal - descuento_aplicado # Calculamos el total con
descuento
return total # Devolvemos el precio total

# Solicitamos datos al usuario

precio = float(input("Ingresá el precio unitario del producto: "))
cantidad = int(input("Ingresá la cantidad de unidades: "))
descuento = input("Ingresá el descuento (en %), o presioná Enter para
no aplicar descuento: ")

# Convertimos el descuento si se ingresó algún valor

if [Link]() == "":
descuento = 0 # Sin descuento
else:
descuento = float(descuento)

# Llamamos a la función y mostramos el resultado

total = calcular_precio_total(precio, cantidad, descuento)
print(f"El precio total con un descuento de {descuento}% es:
${total:.2f}")

Esta función llamada calcular_precio_total tiene tres parámetros: precio_unitario,

cantidad y un parámetro opcional llamado descuento, que por defecto tiene un valor de 0.

●​ Calculamos el subtotal multiplicando el precio unitario por la cantidad.

●​ Si se aplica un descuento, lo calculamos como un porcentaje del subtotal.
●​ Luego, restamos el descuento al subtotal para obtener el total final.
Cuando llamamos a la función, el usuario o usuaria puede optar por no ingresar un
descuento, en cuyo caso se utiliza el valor predeterminado (0%). Esto hace que el programa
sea más flexible y permita resolver casos específicos del Trabajo Final Integrador.

Funciones que devuelven múltiples valores.

En Python, las funciones no están limitadas a devolver un solo valor. Podés devolver
múltiples valores usando tuplas. Esto es especialmente útil cuando una operación o cálculo
genera más de un resultado que necesitás utilizar después. ¡Veamos cómo!

Cuando una función necesita devolver varios resultados, Python agrupa automáticamente
esos valores en una tupla únicamente si separás por comas en la sentencia return.
Luego, al llamar a la función, podés asignar esos valores a variables individuales o
procesarlos directamente como una tupla.

Ejemplo práctico: cálculo combinado.

Imaginemos que necesitás una función para calcular el área y el perímetro de un rectángulo
y querés devolver ambos resultados al mismo tiempo. Podrías escribir un script como el
siguiente:

# Función que calcula el área y el perímetro de un rectángulo

def calcular_area_y_perimetro(base, altura):
area = base * altura
perimetro = 2 * (base + altura)
# Devolvemos ambos valores como una tupla
return area, perimetro

# Solicitamos al usuario los datos del rectángulo

print("Calculadora de área y perímetro de un rectángulo.")
base = float(input("Ingresá la base del rectángulo: "))
altura = float(input("Ingresá la altura del rectángulo: "))

# Llamamos a la función y asignamos los valores retornados

area, perimetro = calcular_area_y_perimetro(base, altura)
# Mostramos los resultados
print(f"El área del rectángulo es: {area}")
print(f"El perímetro del rectángulo es: {perimetro}")

En este ejemplo, la función calcular_area_y_perimetro toma dos parámetros: base y

altura. Calcula el área y el perímetro del rectángulo y devuelve ambos resultados utilizando
la sentencia return.

Cuando llamamos a la función, los valores devueltos se asignan a las variables area y
perimetro.

Esto es posible gracias a que Python empaqueta los valores en una tupla y
luego los descomprime al asignarlos. Este enfoque te permite manejar
múltiples resultados de manera clara y sencilla.

El uso de tuplas es especialmente útil en aplicaciones más complejas, donde una función
necesita devolver un conjunto de resultados relacionados sin requerir estructuras más
avanzadas o personalizadas como clases o diccionarios.

Documentación de funciones (docstrings).

En Python, los docstrings son una herramienta esencial para documentar tus funciones. Se
trata de cadenas de texto que se colocan justo al comienzo del cuerpo de una función y
explican de manera breve y clara qué hace la función, qué parámetros recibe (si los tiene) y
qué valores devuelve (si aplica). Esta documentación no solo es útil para otras personas
que puedan leer tu código, sino también para cuando necesites revisarlo en el futuro.

¿Qué son los docstrings y para qué sirven?

Un docstring es una cadena de texto delimitada por comillas triples (""") que se usa para
describir el propósito y uso de una función. Python lo reconoce automáticamente como
documentación asociada a esa función. Los docstrings también pueden ser utilizados en
clases y módulos para describir su propósito general.

La principal ventaja de los docstrings es que se pueden acceder programáticamente

mediante la función help() de Python. Esto facilita obtener información sobre cómo usar una
función sin necesidad de leer el código fuente.
 Documentar las funciones con docstrings es una buena práctica que ayuda a
que tu código sea más legible, comprensible y profesional.

Ejemplo básico de docstring.

def calcular_area_y_perimetro(base, altura):

"""
Calcula el área y el perímetro de un rectángulo.

Parámetros:
base (float): La base del rectángulo.
altura (float): La altura del rectángulo.

Retorna:
tuple: Una tupla que contiene el área y el perímetro del
rectángulo.
"""
area = base * altura
perimetro = 2 * (base + altura)
return area, perimetro

¿Cómo usar los docstrings?

Para consultar el docstring de una función en Python podés usar la función help():

help(calcular_area_y_perimetro)

Al ejecutar este código, Python mostrará la descripción contenida en el docstring,

incluyendo información sobre los parámetros y el valor de retorno:

Help on function calcular_area_y_perimetro in module __main__:

calcular_area_y_perimetro(base, altura)
Calcula el área y el perímetro de un rectángulo.

Parámetros:
base (float): La base del rectángulo.
altura (float): La altura del rectángulo.

Retorna:
tuple: Una tupla que contiene el área y el perímetro del
rectángulo.
(END)

Beneficios de los docstrings.

1.​ Claridad: Ayudan a que el propósito de la función sea claro para cualquier persona
que lea el código.
2.​ Accesibilidad: Podés acceder a la documentación directamente desde el intérprete
usando help().
3.​ Estándar de la comunidad: Los docstrings son una convención ampliamente
aceptada en Python, lo que facilita la colaboración en proyectos.
4.​ Mantenimiento: Cuando el código evoluciona, los docstrings permiten actualizar la
documentación sin tener que crear archivos separados.

Comparación entre funciones con y sin return.

En Python, las funciones pueden definirse para realizar tareas sin devolver un resultado
explícito, o para devolver un valor (o varios) mediante la sentencia return. Saber cuándo
usar una función con o sin return es muy importante para escribir código eficiente, modular
y reutilizable.

¿Cuándo usar funciones con return?

Las funciones con return son ideales cuando se necesita que una operación devuelva un
resultado que pueda ser usado en otras partes del programa. Por ejemplo, calcular un valor,
realizar una transformación de datos o extraer información. Estas funciones son
especialmente útiles en casos donde se requiere modularizar el código y permitir que las
funciones sean reutilizables en diferentes contextos.
Un ejemplo típico sería una función que calcula el precio final de un producto con
impuestos. Al devolver el resultado, este puede ser usado directamente en otras
operaciones:

def calcular_precio_final(precio, impuesto):

return precio + (precio * impuesto / 100)

Las funciones con return aportan modularidad y flexibilidad, ya que pueden integrarse en
flujos más complejos de lógica. Por otro lado, las funciones sin return son útiles para
ejecutar acciones específicas, como imprimir datos o modificar estructuras existentes, sin
necesidad de devolver un valor. Estas últimas son más adecuadas para tareas donde no se
espera que la función entregue un resultado para su reutilización.

Por ejemplo, una función sin return podría ser usada para mostrar un mensaje a quien usa
el programa:

def mostrar_bienvenida(nombre):
print(f"¡Bienvenido, {nombre}!")

Sin embargo, este tipo de funciones no permite que el resultado sea almacenado o
procesado más adelante, limitando su flexibilidad en flujos complejos.

Característica Funciones con return Funciones sin return

Devuelven un resultado que puede Ejecutan una acción específica

Propósito
ser reutilizado. sin devolver datos.

Cálculos, transformaciones y Mostrar mensajes, modificar

Uso común
extracción de información. estructuras in-place.

Pueden ser llamadas en otros Limitadas a la acción específica

Reutilización
contextos con diferentes datos. para la que se diseñaron.

Alta: pueden integrarse en flujos de Baja: no permiten almacenar o

Flexibilidad
lógica complejos. procesar resultados.
 “Esta comparativa te ayuda a identificar cuándo elegir un enfoque sobre
el otro según las necesidades de tu programa. Ambos tipos de funciones
tienen su lugar en la programación y, al combinarlos de manera
adecuada, podés escribir código más claro, modular y eficiente.”

Ejemplo práctico:
Como parte del proyecto de TalentoLab, parece que necesitamos hacer una mejora:
queremos que este código no sólo ejecute las acciones, sino que también devuelva
resultados que puedan ser utilizados en otras partes del programa.

“Queremos aprovechar este ajuste para incorporar las nuevas

habilidades que estás adquiriendo. Esto nos ayudará a seguir
construyendo programas cada vez más organizados y modulares."

Aquí está el código mejorado, adaptado para que las funciones devuelvan valores:

# Lista inicial de frutas

frutas = []

# Función para agregar una fruta

def agregar_fruta():
fruta = input("Ingresá el nombre de la fruta que querés agregar:
").capitalize()
[Link](fruta)
return fruta

# Función para consultar frutas

def consultar_frutas():
if frutas:
return frutas
else:
return []

# Función para borrar una fruta

def borrar_fruta():
 fruta = input("Ingresá el nombre de la fruta que querés borrar:
").capitalize()
if fruta in frutas:
[Link](fruta)
return fruta
else:
return None

# Función principal para manejar el menú

def mostrar_menu():
while True:
print("\nMenú de gestión de frutas:")
print("1. Agregar una fruta")
print("2. Consultar frutas")
print("3. Borrar una fruta")
print("4. Salir")
opcion = input("Elegí una opción (1-4): ")
if opcion == "1":
fruta = agregar_fruta()
print(f"Fruta '{fruta}' agregada con éxito.")
elif opcion == "2":
lista = consultar_frutas()
if lista:
print("Lista de frutas:")
for i, fruta in enumerate(lista, start=1):
print(f"{i}. {fruta}")
else:
print("La lista de frutas está vacía.")
elif opcion == "3":
fruta_eliminada = borrar_fruta()
if fruta_eliminada:
print(f"Fruta '{fruta_eliminada}' eliminada con éxito.")
else:
print("La fruta no está en la lista.")
elif opcion == "4":
print("¡Gracias por usar el programa! ¡Hasta luego!")
break
else:
print("Opción no válida. Por favor, ingresá un número del 1
al 4.")
mostrar_menu()
 "Este nuevo enfoque te permite obtener resultados de las funciones que
escribís. Por ejemplo, agregar_fruta devuelve el nombre de la fruta recién
agregada, lo que facilita confirmar al usuario su acción. consultar_frutas
devuelve una lista de frutas o una lista vacía, dependiendo del estado
actual de la lista. En tanto, borrar_fruta devuelve el nombre de la fruta
eliminada o None si no encuentra la fruta. Esto te da flexibilidad para
manejar estos datos en otras partes del programa, manteniendo la lógica encapsulada y el
código modular."

Con este diseño, no sólo estás aplicando buenas prácticas de programación, sino que
también estás construyendo un código más robusto, escalable y reutilizable. Estas mejoras
son muy importantes para que tu Trabajo Final Integrador sea un éxito.

Ejercicio práctico:
El día finaliza con otra reunión en la oficina de Mariana. Con su energía habitual, te felicita
por el progreso que estás logrando. "Luis me mostró el programa de gestión de frutas que
desarrollaste, y estoy muy impresionada con lo bien que aplicaste las funciones para
organizar el código. Sin embargo, quiero proponerte un desafío adicional:

Tu tarea es modificar el programa que escribiste la clase

anterior, para que realice las mismas tareas, pero utilizando
funciones que devuelvan valores cuando sea posible. Recordá
que el programa te permitía:

●​ Agregar productos: Cada producto debe tener un

nombre y un precio.

●​ Consultar productos: Muestra todos los productos en la lista junto con sus
precios.
●​ Eliminar productos: A partir de su nombre.
●​ Menú interactivo: Debe ofrecer un menú para que se pueda elegir qué
acción realizar.

¡Ponete a prueba y completá el desafío!

Materiales y recursos adicionales:
Artículos:
Escuela Superior Politécnica del Litoral: Funciones en Python
Pablo Londoño: Guía básica de funciones en Python

Videos:
Tutoriales sobre Ciencia y Tecnología: Funciones en Python
Píldoras informáticas: Funciones en Python (I) y Funciones en Python (II)

Preguntas para reflexionar:

1.​ ¿De qué manera las funciones que devuelven valores pueden hacer que tu código
sea más modular y reutilizable? Pensá en cómo podrías aplicar este concepto en
proyectos más grandes.
2.​ ¿Cómo te ayuda la posibilidad de devolver múltiples valores con tuplas a resolver
problemas de programación de forma más eficiente? ¿Podés pensar en un ejemplo
práctico donde esto sea útil?
3.​ ¿Qué importancia tiene documentar tus funciones con docstrings? Reflexioná sobre
cómo esto puede facilitar la colaboración en proyectos de equipo.

Próximos pasos
En la próxima clase, vas a dar un paso clave en la organización y ampliación de tus
proyectos de programación. Exploraremos cómo dividir el código en módulos para hacerlo
más ordenado, fácil de mantener y reutilizar en diferentes aplicaciones. Aprenderás a
importar módulos propios y externos, lo que te permitirá trabajar de manera más eficiente y
profesional.

Además, vamos a conocer algunos de los módulos estándar más útiles de Python, como
random y datetime, para resolver problemas comunes de manera práctica. También
haremos una introducción a módulos de terceros, como colorama, que aportan
herramientas interesantes para mejorar la experiencia del usuario en tus programas.

Asegurate de repasar lo aprendido sobre funciones y diccionarios, ya que estos conceptos

serán esenciales para los ejemplos y ejercicios de la próxima clase. ¡Nos vemos pronto para
seguir avanzando juntos!
Iniciación a la

Programación con
Python
Clase 11
Clase N° 11 | Módulos
Temario:
●​ Organización del código en módulos.
●​ Importación de módulos propios y externos.
●​ Uso de módulos estándar (random, datetime).
●​ Introducción a módulos de terceros (colorama).

Objetivos de la Clase
En esta clase, aprenderás a organizar y estructurar tu código mediante el uso de módulos
en Python. Aprenderás a dividir tu código en archivos y componentes reutilizables,
mejorando la mantenibilidad y facilitando la colaboración en proyectos.

Explorarás también la poderosa funcionalidad de los módulos estándar, como random y

datetime, y cómo aprovechar sus herramientas para resolver problemas comunes de
manera eficiente. Además, darás tus primeros pasos en el uso de módulos de terceros,
como colorama, lo que te permitirá enriquecer tus aplicaciones con funcionalidades
adicionales.

Al finalizar la clase, serás capaz de:

●​ Importar y utilizar módulos propios y externos en tus proyectos.

●​ Identificar cómo los módulos contribuyen a escribir un código más limpio y
organizado.
●​ Incorporar librerías estándar y de terceros para expandir las capacidades de tus
programas.

Este conocimiento te brindará una base sólida para construir soluciones modulares y
escalables, preparándote para enfrentar nuevos desafíos en el desarrollo de software.
Bienvenido a tu jornada en TalentoLab 🎉

El día comienza con la energía habitual en TalentoLab. Mariana te llama a su oficina

apenas llegás, con su característico entusiasmo. "Hoy es un gran día para profundizar en la
organización del código". Te explica qué vas a aprender a trabajar con módulos, una
herramienta esencial para dividir y organizar el código en partes más manejables y
reutilizables.

Luis, que pasa casualmente por la oficina, se suma a la charla. "¿Te

acordás del proyecto del TFI? Imaginate lo útil que sería dividir ese
código en partes", te dice con una sonrisa. “O potenciarlo utilizando
funciones o código escrito y probado por otras personas”, agrega.

Para empezar el día, te asignan una tarea sencilla: explorar cómo importar y usar módulos
ya disponibles en Python, como random y datetime. Además, te adelantan que vas a tener
la oportunidad de probar un módulo de terceros, colorama, para darle un toque de color a
tus aplicaciones de consola. "Es una herramienta genial para que tus programas sean más
atractivos visualmente", comenta Luis. Hoy, el enfoque está en aprender a organizar,

reutilizar y ampliar tu código con la ayuda de los módulos en Python.

Introducción a los módulos.
Un módulo es un archivo que contiene definiciones y declaraciones de funciones, clases o
variables, diseñado para ser reutilizado en otros programas. Los módulos permiten
organizar el código en componentes separados y reutilizables, lo que simplifica la lectura, el
mantenimiento y la escalabilidad de los proyectos. Python incluye una gran cantidad de
módulos estándar que cubren tareas comunes, desde matemáticas y manejo de fechas
hasta la generación de números aleatorios y la interacción con archivos.

Por ejemplo, cuando escribís un programa que necesita realizar cálculos matemáticos
avanzados, podés importar el módulo math en lugar de escribir todas las funciones
matemáticas desde cero. Si tu programa requiere generar números aleatorios, el módulo
random ofrece una solución rápida y eficiente.

¿Qué es un módulo y para qué sirve?

Los módulos sirven para dividir un programa en partes más pequeñas y manejables,
mejorando la estructura del código. Además, permiten reutilizar funcionalidades en múltiples
proyectos sin necesidad de reescribirlas. Por ejemplo, un módulo creado para calcular
impuestos puede ser usado en diferentes aplicaciones relacionadas con contabilidad o
ventas.

Además, los módulos ayudan a evitar problemas con nombres de variables y funciones al
encapsularlos en su propio espacio de nombres. Esto es especialmente útil en proyectos
grandes, donde diferentes partes del código podrían necesitar definiciones similares.

Ventajas de usar módulos en Python

Utilizar módulos en tus proyectos ofrece varias ventajas:

1.​ Reutilización de código: Podés escribir funciones y clases una vez en un módulo y
usarlas en múltiples programas, ahorrando tiempo y esfuerzo.
2.​ Organización: Los módulos dividen el código en bloques lógicos, haciendo que sea
más fácil entender qué hace cada parte de tu programa.
3.​ Mantenibilidad: Es más sencillo actualizar o corregir errores en un módulo
específico sin afectar otras partes del código.
 4.​ Escalabilidad: En proyectos grandes, los módulos permiten trabajar en equipo de
manera más eficiente, ya que cada integrante puede enfocarse en una parte del
proyecto.
5.​ Acceso a herramientas listas para usar: Python ofrece una amplia biblioteca
estándar con módulos que resuelven problemas comunes, y también podés instalar
módulos de terceros para ampliar las capacidades de tu proyecto.

Por ejemplo, si tu aplicación necesita calcular fechas futuras basadas en datos ingresados
por usuarios, podés usar el módulo datetime. Esto no solo te ahorra escribir el código
desde cero, sino que también asegura que estés usando herramientas probadas y
optimizadas.

¿Cómo dividir tu código en diferentes

archivos?
Dividir el código en diferentes archivos es una práctica fundamental en el desarrollo de
software que ayuda a mantener la organización, la claridad y la escalabilidad de tus
proyectos. En Python, cada archivo con la extensión .py se considera un módulo y puede
contener funciones, clases y variables que podés reutilizar en otros archivos de tu proyecto.

Para dividir tu código en diferentes archivos, seguí estos pasos básicos:

1.​ Identificá las partes del código que pueden agruparse: Analizá tu programa y
determiná qué funcionalidades o secciones podrían organizarse en módulos. Por
ejemplo, podrías tener un módulo para funciones matemáticas, otro para manejo de
bases de datos y uno más para la interfaz de usuario.
2.​ Creá archivos .py para cada módulo: Guardá las funciones, clases o variables
relacionadas en un archivo separado con un nombre que describa claramente su
contenido. Por ejemplo, un archivo llamado [Link] podría contener
funciones para sumar, restar, multiplicar y dividir.
3.​ Importá el módulo en tu programa principal: Usá la palabra clave import para
incluir el módulo en el archivo principal de tu programa. Esto te permitirá acceder a
las funciones y variables definidas en otros archivos.
Por ejemplo, supongamos que tenés un archivo principal [Link] y querés dividir una
sección del código en un módulo llamado [Link]. En el archivo [Link],
podrías definir una función como esta:

# [Link]
def saludar(nombre):
print(f"Hola, {nombre}. ¡Bienvenido!")

En tu archivo principal [Link], simplemente importás el módulo para usar esa

función:

# [Link]
import utilidades
[Link]("Mariana")

El código queda más organizado, y cualquier cambio en las funciones definidas en

[Link] se reflejará automáticamente en los programas que lo utilicen. Pero antes de
seguir, veamos qué es lo que hace y cómo se utiliza import.

La orden import: Sintaxis, uso y detalles.

La orden import es fundamental para aprovechar la modularidad del lenguaje. Permite
incorporar el contenido de otros módulos a tu programa actual, haciendo posible reutilizar
código y acceder a funciones, clases y variables definidas en otros lugares. La sintaxis
básica de import es simple:

import nombre_modulo
En este caso, nombre_modulo es el nombre del archivo .py que querés importar, sin incluir
la extensión .py. Una vez importado, podés acceder a las funciones, clases o variables del
módulo utilizando la notación nombre_modulo.elemento.

Por ejemplo:

# [Link]
def saludar(nombre):
print(f"Hola, {nombre}. ¡Bienvenido!")

# [Link]
import utilidades
[Link]("Luis")

Importar elementos específicos de un módulo

Si sólo necesitás ciertas funciones, clases o variables de un módulo, podés importarlas
directamente usando la sintaxis:

from nombre_modulo import elemento1, elemento2

Por ejemplo:

from utilidades import saludar

saludar("Mariana") # No es necesario usar [Link]
 Esto simplifica el código, pero tené cuidado con los posibles conflictos
de nombres si usás esta técnica con varios módulos.

Importar con un alias

Para facilitar la lectura o resolver conflictos de nombres, podés usar un alias con la palabra
clave as:

import utilidades as ut
[Link]("Diego")

Esto es útil cuando el nombre del módulo es largo o si querés estandarizar los nombres en
un equipo de desarrollo.

Importar todo el contenido de un módulo

También es posible importar todo el contenido de un módulo usando un asterisco *:

from utilidades import *

 Aunque esta técnica es conveniente en algunos casos, no se recomienda
porque puede generar conflictos de nombres y hacer que el código sea
más difícil de entender.

¿Cómo funciona import internamente?

Cuando usás import, Python busca el módulo en los directorios especificados en la variable
[Link]. Por defecto, incluye:

●​ El directorio del script que se está ejecutando.

●​ Directorios estándar del sistema donde están instaladas las librerías de Python.
●​ Directorios adicionales especificados por vos (si los agregás manualmente).

Si Python no encuentra el módulo, lanzará un error (ModuleNotFoundError).

Ventajas del uso de import

●​ Reutilización de código: Podés usar el mismo módulo en múltiples programas.

●​ Organización: Te permite dividir el código en archivos más pequeños y manejables.
●​ Colaboración: Facilita que varios desarrolladores trabajen en diferentes módulos de
un proyecto.

Con la orden import, estás desbloqueando una de las herramientas más poderosas de
Python para trabajar de manera modular, eficiente y escalable.
Módulos estándar.
Los módulos estándar son una parte esencial del ecosistema de Python. Estos módulos
vienen incluidos por defecto en cada instalación del lenguaje y están diseñados para ofrecer
una amplia variedad de herramientas que facilitan la resolución de problemas comunes y
optimizan el desarrollo de aplicaciones. Gracias a su disponibilidad inmediata, los módulos
estándar se convierten en aliados fundamentales para cualquier programador que utilice
Python, ya que no requieren instalación adicional y están listos para usarse mediante la
orden import.

A diferencia de los módulos creados por el usuario, que son específicos para un proyecto o
aplicación, los módulos estándar están diseñados para ser universales y aplicables en una
variedad de contextos. Por ejemplo, un módulo estándar como random permite generar
números aleatorios de manera sencilla, mientras que un módulo que creas vos podría
contener funciones personalizadas para resolver un problema específico de tu aplicación.
Ambos tipos de módulos son útiles, pero su alcance y propósito son diferentes: los estándar
son herramientas generalizadas, mientras que los módulos propios están orientados a
necesidades puntuales.

Por otro lado, los módulos estándar también se distinguen de los módulos creados por
terceros, como colorama. Estos últimos son desarrollados por la comunidad o empresas
externas y suelen resolver problemas más específicos que los módulos estándar no
abordan. A diferencia de los módulos estándar, los de terceros necesitan instalarse por
separado mediante herramientas como pip. Sin embargo, al igual que los módulos
estándar, amplían las capacidades de Python y se integran perfectamente con el lenguaje.
Por ejemplo, mientras el módulo estándar math ofrece operaciones matemáticas
avanzadas, un módulo de terceros como numpy lleva el cálculo numérico a otro nivel.
 Característica Módulos Estándar Módulos Propios​ Módulos de Terceros

Incluidos en la Creación específica Necesitan instalarse

instalación de para un proyecto. con herramientas
Disponibilidad Python, no requieren como pip.
configuración
adicional.

General y aplicable a Limitada a las Resolución de

diversos contextos. necesidades del problemas específicos
Aplicabilidad proyecto donde se o avanzados no
crean. cubiertos por los
módulos estándar.

random, datetime, Un archivo colorama para

math. [Link] con manejar colores en la
Ejemplo
funciones consola, requests
personalizadas. para solicitudes HTTP.

Gestionado por los Totalmente bajo la Mantenidos por la

desarrolladores de responsabilidad del comunidad o
Mantenimiento Python, con programador. empresas, con
documentación documentación
oficial. variable.

Los módulos estándar son herramientas confiables, versátiles y siempre

disponibles. Son diferentes a los módulos creados por el usuario, que tienen un
alcance limitado a las necesidades del proyecto, y a los de terceros, que
aportan funcionalidades adicionales a través de instalación externa.
Comprender estas diferencias te permitirá aprovechar cada tipo de módulo según el
contexto y las necesidades de tu proyecto.
Introducción al módulo random.
El módulo random es una herramienta estándar en Python que te permite trabajar con
números aleatorios de manera sencilla y eficaz. Este módulo es particularmente útil para
tareas como simulaciones, juegos, generación de datos de prueba, y mucho más. Con
random, podés generar números aleatorios enteros o flotantes, seleccionar elementos al
azar de una lista, barajar secuencias, entre otras funcionalidades.

Ejemplo: Juego de dados

A continuación, Luis te proporciona un ejemplo que utiliza el módulo random para simular el
lanzamiento de dos dados. Esto podría ser parte de un juego donde los participantes suman
los valores obtenidos para determinar el resultado:

# Importamos el módulo random

import random

# Simulamos el lanzamiento de dos dados

def lanzar_dados():
dado1 = [Link](1, 6) # Genera un número entre 1 y 6
dado2 = [Link](1, 6)
suma = dado1 + dado2

print(f"Lanzaste un {dado1} y un {dado2}. La suma es {suma}.")

# Ejecutamos el juego
lanzar_dados()
En este ejemplo, [Link](1, 6) genera un número entero aleatorio entre 1 y 6,
simulando el resultado de un dado. La suma de los valores muestra el resultado del
lanzamiento.

Tabla de funciones comunes del módulo random

Función Descripción Ejemplo de Uso​

Genera un número valor = [Link]()

[Link]() flotante aleatorio entre
0.0 y 1.0.

Devuelve un número dado = [Link](1, 6)

[Link](a, b) entero aleatorio entre a y
b (ambos inclusive).​

Selecciona un elemento elemento = [Link]([1,

[Link](seq) al azar de una secuencia 2, 3, 4, 5])
(lista, tupla, etc.).​

Mezcla los elementos de [Link](lista)

[Link](seq)
una lista en su lugar.​

Genera un número valor = [Link](5.5,

[Link](a, b) flotante aleatorio entre a y 10.5)
b.​

Devuelve una lista de k muestra =

[Link](pop, k) elementos seleccionados [Link](range(100), 5)
al azar de una población.

El módulo random no solo aporta un alto grado de flexibilidad en la generación de datos

aleatorios, sino que también facilita la creación de programas interactivos y cambiantes. Al
dominar sus funciones más comunes, podés agregar elementos de sorpresa y variabilidad a
tus aplicaciones, haciendo que sean más interesantes.
Introducción al módulo math
El módulo math en Python proporciona un conjunto de funciones matemáticas avanzadas y
constantes que son útiles para realizar cálculos científicos y matemáticos. Este módulo
también es parte de los módulos estándar de Python, lo que significa que no necesitas
instalarlo por separado.

Un ejemplo típico de uso del módulo math es calcular la raíz cuadrada de un número,
encontrar el valor del seno o coseno de un ángulo, o trabajar con constantes matemáticas
como π (pi) o e (la base del logaritmo natural).

Ejemplo práctico: Calcular el área de un círculo

Imaginá que querés calcular el área de un círculo dado su radio. Usando el módulo math,
podés hacer lo siguiente:

# Importamos el módulo math

import math

# Pedimos al usuario que ingrese el radio del círculo

radio = float(input("Ingresá el radio del círculo: "))

# Calculamos el área usando la fórmula: área = π * radio^2

area = [Link] * [Link](radio, 2)

# Mostramos el resultado
print(f"El área del círculo con radio {radio} es: {area:.2f}")

Este código comienza importando el módulo math, lo que permite acceder a sus funciones
y constantes, como el valor de π. Luego, se solicita el ingreso del radio del círculo para
proceder con el cálculo del área. Para ello, se utiliza la fórmula matemática del área del
círculo: π multiplicado por el radio elevado al cuadrado. En el código, esto se implementa
utilizando [Link] para obtener el valor de π y [Link]() para calcular el cuadrado del
radio. Finalmente, se muestra el área calculada en pantalla, formateada con dos decimales
para una presentación más clara.

Tabla de funciones comunes del módulo math

Función Uso Ejemplo​

[Link](x)​ Calcula la raíz cuadrada de x, [Link](16) devuelve 4.0.

[Link](x, y) Eleva x a la potencia y. [Link](2, 3) devuelve 8.0.

Devuelve el valor de π [Link] devuelve

[Link]
(constante matemática).​ 3.141592653589793.

Devuelve el valor de e (base de math.e devuelve

math.e
logaritmos naturales). 2.718281828459045.

Calcula el seno de x (en [Link]([Link] / 2)

[Link](x)
radianes). devuelve 1.0.

Calcula el coseno de x (en [Link](0) devuelve 1.0.

[Link](x)
radianes)

Calcula el logaritmo de x en la [Link](100, 10) devuelve

[Link](x, base) base especificada (por defecto, 2.0.
e).

Redondea x hacia arriba al [Link](3.2) devuelve 4.

[Link](x)
entero más cercano.

Redondea x hacia abajo al [Link](3.8) devuelve 3.

[Link](x)
entero más cercano.
 Con el módulo math, podés realizar cálculos precisos y rápidos, facilitando
tareas que serían más complejas sin estas herramientas.

Introducción al módulo datetime

El módulo datetime de Python es una herramienta esencial para trabajar con fechas y
horas de manera sencilla y eficiente. Proporciona una amplia gama de funciones para
manipular, formatear y realizar cálculos con fechas y tiempos. A diferencia de módulos
creados por el usuario o de terceros, datetime viene integrado con Python, lo que significa
que no requiere instalación adicional.

Ejemplo práctico: Obtener la fecha y hora actual y formatearlas

El siguiente código muestra cómo se puede usar datetime para obtener la fecha y hora
actual y presentarlas en diferentes formatos:

import datetime

# Obtener la fecha y hora actual

fecha_hora_actual = [Link]()

# Formatear y mostrar la fecha y hora

print("Fecha y hora actual:", fecha_hora_actual)
print("Solo la fecha:", fecha_hora_actual.strftime("%Y-%m-%d"))
print("Solo la hora:", fecha_hora_actual.strftime("%H:%M:%S"))

# Mostrar la fecha en formato legible

print("Fecha legible:", fecha_hora_actual.strftime("%d de %B de %Y"))
Este código comienza importando el módulo datetime. Luego, utiliza la función
[Link]() para obtener un objeto que representa la fecha y hora actual.
Este objeto se puede formatear utilizando el método .strftime(), que permite personalizar la
salida según un formato especificado. Por ejemplo, "%Y-%m-%d" produce una salida en
formato de fecha estándar, mientras que "%H:%M:%S" muestra únicamente la hora.
Además, se utiliza "%d de %B de %Y" para generar una fecha en un formato más legible,
como "26 de diciembre de 2024".

Tabla de funciones comunes del módulo datetime

Función Descripción Ejemplo​

Obtiene la fecha y hora [Link]()

[Link]()
actual del sistema.

Obtiene solo la fecha [Link]()

[Link]()
actual.

Convierte un objeto .strftime("%d/%m/%Y")

strftime(formato) datetime en un string
con el formato dado.​

Permite realizar [Link](days=5)

timedelta operaciones aritméticas
con fechas y tiempos.

Convierte un string a un [Link]("20

[Link](caden objeto datetime 24-12-26", "%Y-%m-%d")
a, formato) siguiendo un formato
dado.

El módulo datetime es parte de la biblioteca estándar de Python, lo que significa

que no es necesario instalarlo por separado. Este módulo está incluido de
manera predeterminada en cualquier instalación de Python, listo para ser
utilizado.
El módulo datetime es una herramienta fundamental para cualquier proyecto que necesite
trabajar con tiempo, como sistemas de registro de eventos, aplicaciones de calendario, o
análisis de datos temporales.

Introducción al módulo colorama

El módulo colorama es una librería de terceros que permite agregar colores y estilos al
texto mostrado en la consola. Esto es especialmente útil cuando querés destacar
información importante o hacer que tu programa sea más atractivo visualmente. A diferencia
de los módulos estándar como datetime, colorama no viene incluido por defecto en Python,
por lo que es necesario instalarlo antes de poder usarlo.

¿Por qué usar colorama?

En muchas aplicaciones, los mensajes en consola son fundamentales para la interacción

con el quién usa el programa o la depuración del código. Sin embargo, el texto plano puede
ser difícil de seguir o interpretar rápidamente. colorama permite agregar colores al texto,
haciéndolo más claro y visualmente organizado. Por ejemplo, podés resaltar mensajes de
error en rojo, advertencias en amarillo y mensajes de éxito en verde.

Instalación de colorama

Para instalar colorama, necesitás usar el gestor de paquetes de Python, pip. Asegurate de
tener una conexión a internet y seguí estos pasos:

1.​ Abrí tu terminal o consola.

2.​ Escribí el siguiente comando y presioná Enter:

pip install colorama

3.​ Verificá que la instalación se completó correctamente observando el mensaje que

aparece en la consola, donde deberías ver algo como "Successfully installed
colorama".
Si querés verificar que colorama está disponible en tu entorno, podés usar el siguiente
comando:

pip show colorama

Esto mostrará información sobre la versión instalada y su ubicación.

Cómo usar colorama

Para empezar a darle color a tus textos en la terminal con Colorama, el primer paso es
inicializar la biblioteca. Esto se logra mediante una llamada a la función init(). Al hacerlo,
colorama prepara tu entorno para que pueda interpretar y mostrar los colores
correctamente. Veamos cómo hacerlo:

from colorama import init

init()

Una vez que colorama está inicializado, cambiar el color del texto es tan simple como
utilizar una de las constantes de [Link].*. Por ejemplo, si deseas imprimir el texto
"Hola Mundo" en color verde, podés hacerlo de la siguiente manera:

from colorama import Fore, init

init()
print([Link] + "Hola Mundo")

Este código agrega el color verde al texto, resultando en una salida colorida y llamativa en
tu terminal.

Hola Mundo
Personalización avanzada con colorama.
Cambiar el fondo del texto

Al igual que modificamos el color del texto con [Link].*, cambiar el color de fondo
es igual de sencillo usando [Link].*. Por ejemplo, para establecer un fondo rojo,
harías lo siguiente:

from colorama import Fore, Back, init

init()
print([Link] + "Hola Mundo")

Salida:

Hola Mundo

Combinar colores de texto y fondo

Colorama también te permite combinar colores de texto y fondo en una misma impresión:

from colorama import Fore, Back, init

init()
print([Link] + [Link] + "Hola Mundo")

Salida:

Hola Mundo
Ejercicio Práctico
Cómo es habitual, finalizas el día con una reunión de trabajo en la oficina de Mariana, que
te felicita por tu progreso. "Luis me mostró el programa de gestión de frutas que
desarrollaste, y estoy muy impresionada con lo bien que aplicaste las funciones para
organizar el código. Sin embargo, es hora de mejorarlo:

Tu tarea es volver a modificar el programa que escribiste la

clase anterior, para que realice las mismas tareas, pero que
su interacción mediante la terminal esté mejorada utilizando
Colorama. También sería genial si agregas un dato a cada
producto que contenga la fecha y hora de la compra, usando
la librería datetime.

¡Estoy segura que te va a gustar el nuevo desafío!

Materiales y Recursos Adicionales:

Artículos:
Sitio oficial Python: Módulos estándar
Datacamp: Tutorial sobre cómo trabajar con módulos en Python

Videos:
Byspel: Cómo crear un módulo propio
Cosas de Informatica: Descubre cómo crear y utilizar módulos en Python
Preguntas para Reflexionar:
1.​ ¿Cómo creés que el uso de módulos puede ayudarte a mejorar la organización de
tus proyectos? Pensá en ejemplos concretos donde dividir el código en módulos
podría simplificar su mantenimiento.
2.​ Los módulos estándar como random y datetime ofrecen muchas funcionalidades
predefinidas. ¿Qué ventajas encontrás al usar estas herramientas en lugar de
desarrollar todo desde cero? ¿Podrías pensar en aplicaciones prácticas para estos
módulos en tus proyectos?
3.​ La biblioteca colorama permite personalizar la interacción en la consola con colores.
¿Cómo podría mejorar la experiencia del usuario en programas que diseñes? ¿Qué
otras aplicaciones creativas podrías imaginar para este módulo?
4.​ Ahora que entendiste cómo crear tus propios módulos, ¿cómo los usarías para
estructurar un proyecto más grande? ¿Qué partes del código podrías separar en
diferentes archivos para facilitar el trabajo en equipo?

Próximos Pasos:
En la próxima clase, vas a explorar un concepto fundamental en el desarrollo de software: la
persistencia de datos. Aprenderás cómo hacer que tu programa guarde información de
forma permanente, permitiendo que los datos ingresados se conserven incluso después de
cerrar la aplicación. Esta habilidad es indispensable para desarrollar aplicaciones que
gestionen información de manera útil y práctica.

Vamos a trabajar con archivos de texto, aprendiendo a leerlos y escribirlos directamente

desde Python. También aprenderás el manejo de excepciones con try-except, una
herramienta que te permitirá anticiparte a posibles errores y hacer tu código más robusto y
confiable. Además, comenzaremos a explorar el mundo de las bases de datos y SQL,
entendiendo cómo estas herramientas avanzadas amplían las posibilidades de
almacenamiento y gestión de información. Este nuevo conocimiento te acercará un paso
más a preparar tu Trabajo Final Integrador, dotándolo de las funcionalidades esenciales que
todo sistema profesional necesita. ¡Nos vemos en la próxima clase para seguir avanzando
juntos!
Iniciación a la

Programación con
Python
Clase 12
Clase N° 12 | Persistencia de
datos
Temario:
●​ Lectura y escritura de archivos de texto.
●​ Uso de archivos para almacenar datos de forma persistente.
●​ Introducción al manejo de excepciones (try-except).
●​ Conceptos fundamentales de bases de datos y SQL (visión general).

Objetivos de la Clase
En esta clase, aprenderás a gestionar datos de manera persistente utilizando archivos de
texto. Esto te permitirá guardar información generada por tu programa para que pueda ser
recuperada en ejecuciones futuras, una habilidad necesaria para construir sistemas más
prácticos y funcionales.

Explorarás cómo leer y escribir en archivos, aplicando estas herramientas para almacenar
información de manera eficiente. También introducirás el manejo de excepciones mediante
try-except, una técnica que te permitirá prever errores comunes, como archivos
inexistentes o datos corruptos, y asegurarte de que el programa siga funcionando de
manera adecuada.

Finalmente, tendrás una primera aproximación al uso de bases de datos y SQL,

entendiendo cómo estas herramientas avanzadas amplían las capacidades de
almacenamiento y gestión de datos de tus programas, abriendo nuevas posibilidades para
proyectos futuros.

Con estos conocimientos, estarás más cerca de desarrollar aplicaciones completas y listas
para el mundo real, cumpliendo con las demandas actuales del manejo de datos.
Bienvenido a tu jornada en TalentoLab 🎉

El día comienza en TechLab con una reunión de equipo liderada por Diego, el desarrollador
senior. Te recibe con entusiasmo y comienza a explicar el nuevo desafío que el cliente ha
planteado.

"Tenemos un pedido muy interesante para este proyecto. El cliente

necesita que la información de los usuarios y productos que registramos
no se pierda cada vez que cerramos el programa. Quiere que el sistema
sea capaz de guardar estos datos en un archivo, para que puedan ser
recuperados cuando sea necesario."

Diego continúa: "Hoy vamos a ver cómo leer y escribir en archivos de texto para guardar
información como nombres, precios y cualquier dato que consideremos importante. También
quiero que aprendan a manejar errores comunes, como intentar abrir un archivo que no
existe, usando una herramienta fundamental: try-except. Además, les voy a dar una
introducción al concepto de bases de datos y SQL, que son técnicas más avanzadas para
manejar grandes cantidades de datos de manera eficiente."
Persistencia de datos.
En el desarrollo de software, una de las necesidades más comunes es la capacidad de
guardar información que pueda ser utilizada nuevamente, incluso después de cerrar el
programa. Esto es lo que conocemos como persistencia de datos. Sin persistencia, toda la
información ingresada o procesada durante la ejecución del programa desaparece al
finalizarlo, lo que limita enormemente su utilidad.

Imaginemos un sistema de gestión de clientes o productos: sería poco práctico que los
datos se perdieran cada vez que se cierra la aplicación. La persistencia de datos permite
que los programas guarden información en archivos o bases de datos, para luego
recuperarla cuando sea necesario. Esto hace que las aplicaciones sean más funcionales en
escenarios del mundo real, donde la continuidad de la información es indispensable.

Exploraremos cómo podemos implementar la persistencia de datos en Python. Veremos

cómo leer y escribir archivos de texto, lo que representa el primer paso en esta dirección.
También aprenderemos a manejar errores que puedan surgir en este proceso y
conoceremos los fundamentos de bases de datos y SQL, una herramienta poderosa para
gestionar grandes volúmenes de datos de forma eficiente.

Archivos de texto.
Un archivo de texto es un tipo de archivo que almacena información en formato de texto
plano. Esto significa que su contenido está compuesto únicamente por caracteres, como
letras, números, símbolos y espacios, organizados en líneas. Estos archivos son legibles
tanto por humanos como por programas de computadora. A diferencia de otros tipos de
archivos, como imágenes o videos, que contienen datos binarios codificados para
representar píxeles, colores, sonido o movimiento, los archivos de texto no requieren ningún
software especializado para interpretarlos. Por ejemplo, un archivo de texto se puede abrir
con un bloc de notas o cualquier editor de texto básico, mientras que un archivo de imagen
necesita un visor gráfico.

En el contexto de la programación, los archivos de texto son muy útiles para guardar datos
simples como configuraciones, registros de actividad, listas o resultados procesados por un
programa. Al ser más livianos y fáciles de manejar, se utilizan ampliamente en proyectos
iniciales o en situaciones donde no se requiere almacenar grandes volúmenes de datos
estructurados.
Un archivo de texto suele tener extensiones como .txt, .csv o .log, dependiendo de su
contenido y propósito. Por ejemplo, un archivo .csv (Comma-Separated Values) es un
archivo de texto donde los datos están organizados en líneas y separados por comas, ideal
para manejar tablas o listas.

En Python, interactuar con archivos de texto es una habilidad indispensable para agregar
persistencia a los programas, permitiendo guardar información que luego se puede
recuperar. Esto incluye acciones como abrir un archivo para lectura o escritura, agregar
nuevos datos o procesar líneas específicas. A través de esta interacción, podemos extender
un montón las capacidades de cualquier programa, haciendo que la información sea
accesible más allá de la ejecución en tiempo real.

Archivos de texto en Python.

En Python, los archivos de texto se gestionan mediante funciones integradas que permiten
abrir, leer, escribir y cerrar archivos con facilidad. Para interactuar con un archivo, primero
es necesario abrirlo usando la función open(). Esta función requiere al menos dos
argumentos: el nombre del archivo y el modo en el que se desea abrir. Los modos más
comunes son:

●​ "r" para leer un archivo existente.

●​ "w" para escribir en un archivo (crea uno nuevo si no existe, y si existe, lo
sobrescribe).
●​ "r+" para lectura y escritura combinadas
●​ "a" para agregar contenido al final de un archivo existente.

Por ejemplo, si queremos abrir un archivo llamado "[Link]" para lectura, escribiríamos:

archivo = open("[Link]", "r")

La línea anterior es una instrucción en Python que abre un archivo llamado [Link] para
interactuar con él. La función open() crea un objeto que nos permite realizar operaciones
como leer, escribir o modificar su contenido.
En este caso, "[Link]" es el nombre del archivo que queremos abrir. Python buscará
este archivo en la misma carpeta donde se encuentra el script que estamos ejecutando. Si
el archivo no existe y estamos intentando abrirlo en modo de lectura, el programa generará
un error. El argumento "r" indica el modo en el que se abre el archivo, en este caso, solo
lectura. Esto significa que podremos leer su contenido, pero no modificarlo.

La variable archivo almacena el objeto de archivo que crea la función open(). Este objeto
es la necesario para interactuar con el contenido del archivo, ya que nos permite realizar
operaciones como leer líneas o recorrer su contenido. Sin embargo, si el archivo no está
disponible en la ubicación especificada, Python generará un error, lo que resalta la
importancia de manejar excepciones -como veremos en breve- para evitar que el programa
falle.

Una vez que terminamos de usar un archivo, es fundamental cerrarlo con el

método close(). Esto asegura que todos los cambios realizados se guarden
correctamente y que el sistema libere los recursos asociados al archivo.

Para leer el contenido de un archivo, Python ofrece varios métodos. Uno de los más
comunes es read(), que devuelve todo el contenido del archivo como una cadena. Por
ejemplo:

archivo = open("[Link]", "r")

contenido = [Link]()
print(contenido)
[Link]()
Si queremos procesar el archivo línea por línea, podemos usar readlines(), que devuelve
una lista donde cada elemento es una línea del archivo:

archivo = open("[Link]", "r")

lineas = [Link]()

for linea in lineas:

# Eliminamos los saltos de línea al final de cada línea
print([Link]())

[Link]()

Este código abre el archivo de texto llamado [Link] en modo lectura. La función open() ,
como antes, crea un objeto de archivo que se asigna a la variable archivo, permitiendo
interactuar con el contenido del archivo. Luego, con [Link](), se leen todas las
líneas del archivo y se almacenan en una lista llamada lineas, donde cada elemento de la
lista representa una línea del archivo.

A continuación, se utiliza un bucle for para recorrer cada línea almacenada en la lista.
Dentro del bucle, se usa el método .strip() para eliminar los saltos de línea o espacios
adicionales al principio y al final de cada línea antes de imprimir su contenido en pantalla.
Este método asegura que el texto se muestre limpio, sin caracteres de formato
innecesarios.

Finalmente, el archivo se cierra con [Link](), para liberar los recursos asociados al
archivo y garantizar que no queden archivos abiertos en el sistema. Este cierre explícito es
una buena práctica de programación cuando se trabaja con archivos.

Para escribir en un archivo, debemos abrirlo en modo escritura ("w") o agregar ("a"). El
método más usado para escribir es write(). Por ejemplo:

archivo = open("[Link]", "w")

[Link]("Hola, este es un archivo de prueba.\n")
[Link]("Segunda línea del archivo.")
[Link]()
Este código crea un archivo llamado "[Link]" (o sobrescribe uno existente) y guarda las
dos líneas de texto. Si queremos agregar contenido en lugar de sobrescribirlo, abrimos el
archivo en modo "a":

archivo = open("[Link]", "a")

[Link]("Tercera línea del archivo.")
[Link]()

Este último ejemplo agrega una nueva linea con el contenido “Tercera línea del archivo.” al
archivo creado en el ejemplo anterior. El contenido final del archivo “[Link]” es el
siguiente:

Hola, este es un archivo de prueba.

Segunda línea del archivo.
Tercera línea del archivo.

Ejemplo práctico:
Ahora que hemos analizado estos conceptos, veamos un ejemplo práctico. Supongamos
que queremos registrar una lista de nombres en un archivo y luego leerlos para mostrarlos.

# Escribir nombres en un archivo

archivo = open("[Link]", "w")
[Link]("María\n")
[Link]("Carlos\n")
[Link]("Lucía\n")
[Link]()

# Leer y mostrar el contenido del archivo

archivo = open("[Link]", "r")
print("Contenido del archivo:")
for linea in archivo:
print([Link]())
[Link]()​
Este ejemplo comienza creando un archivo llamado [Link] en modo escritura
utilizando la función open(). El parámetro "w" indica que el archivo será abierto para
escribir, y si ya existe un archivo con el mismo nombre, su contenido será reemplazado.
Luego, se utiliza el método write() para escribir tres nombres, cada uno seguido de un salto
de línea (\n), lo que garantiza que cada nombre quede en una línea separada dentro del
archivo. Una vez que se han escrito los datos, el archivo se cierra con close(), liberando los
recursos asociados.

En la segunda parte, el mismo archivo se abre nuevamente, esta vez en modo lectura
utilizando el parámetro "r". Se imprime un encabezado para indicar que se mostrará el
contenido del archivo. A continuación, se recorre cada línea del archivo con un bucle for.
Para evitar mostrar los saltos de línea adicionales, se aplica el método .strip() a cada línea .
Finalmente, el archivo se cierra otra vez con close().

La apariencia de la terminal luego de ejecutar el programa es la siguiente:

Contenido del archivo:

María
Carlos
Lucía

Introducción al manejo de excepciones con

try-except.
En el desarrollo de software, es común encontrarse con situaciones en las que un programa
puede fallar debido a errores inesperados, como intentar leer un archivo que no existe,
dividir por cero o trabajar con datos mal formateados. Estos errores, conocidos como
excepciones, pueden interrumpir abruptamente la ejecución del programa si no se manejan
correctamente.
El manejo de excepciones es un mecanismo que permite anticiparse a estos errores y
reaccionar de manera controlada, asegurando que el programa no se detenga de forma
inesperada y proporcionando mensajes útiles al usuario o desarrollador. En Python, este
mecanismo se implementa con la estructura try-except.

El bloque try-except funciona como un sistema de seguridad: dentro del bloque try se
coloca el código que puede generar una excepción, y dentro del bloque except se define
cómo responder a esa excepción si ocurre. Esto permite que el programa continúe
ejecutándose o tome acciones específicas frente a un error, como registrar el problema,
pedir nuevamente una entrada válida o usar un valor por defecto.

try:
# Código que puede generar una excepción
# Por ejemplo: abrir un archivo, realizar
# una operación matemática, convertir un dato, etc.
operación_riesgosa()

except TipoDeExcepción:
# Cómo manejar la excepción si ocurre
# Mostrar un mensaje de error, registrar el problema,
# usar un valor predeterminado, etc.
manejar_error()

Por ejemplo, al trabajar con archivos, podríamos encontrarnos con situaciones como
intentar abrir un archivo que no existe o carecer de permisos para escribir en él. Usar
try-except en estos casos no solo hace que el código sea más robusto, sino que también
mejora la experiencia del usuario al manejar los errores de forma clara para construir
programas confiables, capaces de operar en entornos reales, donde los errores son
inevitables. Nos permite anticiparnos a las fallas, mantener el control y mejorar la calidad
general del software.
 Resumiendo:​
Bloque try: Aquí colocás el código que puede generar un error. Python
intentará ejecutarlo. Si no hay errores, el bloque except no se ejecutará.​
Bloque except: Si ocurre un error en el bloque try, Python "salta" al bloque
except correspondiente. Allí definís cómo manejar el error (por ejemplo,
mostrando un mensaje o tomando alguna acción correctiva).

Ejemplo práctico:
Acá tenés un ejemplo práctico que utiliza try-except para manejar posibles errores al
intentar abrir y leer un archivo en Python. Vamos a suponer que el archivo que queremos
abrir tal vez no exista.

try:
# Intentamos abrir un archivo para lectura
archivo = open("[Link]", "r")

# Leemos todo el contenido del archivo

contenido = [Link]()
print("Contenido del archivo:")

# Mostramos el contenido del archivo

print(contenido)

# Cerramos el archivo
[Link]()

except FileNotFoundError:
print("Error: El archivo '[Link]' no existe.")
print("Verificá el nombre o la ubicación del archivo.")
¿Cómo funciona esto? Bien, en Python, cuando intentás abrir un archivo que no existe con
el modo de lectura ("r"), se genera una excepción llamada FileNotFoundError. Este error
es una subclase de las excepciones integradas en Python, y su función principal es indicar
que el archivo solicitado no se pudo encontrar en la ubicación especificada. Si no
manejamos esta excepción, el programa se detendría abruptamente, mostrando un mensaje
de error.

El bloque except del ejemplonos permite "atrapar" este tipo específico de error y definir
cómo debe responder el programa cuando ocurre. Al especificar except
FileNotFoundError:, estamos indicando que queremos manejar exclusivamente este tipo
de error. Esto es útil cuando trabajamos con archivos, ya que el error puede ser común y
predecible, pero no queremos que detenga el funcionamiento del resto del programa.

En el ejemplo, al intentar abrir el archivo, si no existe en la carpeta donde se está

ejecutando el script, Python lanza un FileNotFoundError, y el bloque try-except captura ese
error y muestra un mensaje más claro al usuario.

Validar entrada de datos con try-except.

En muchos programas interactivos, como los que solicitan datos al usuario, es común
encontrarse con errores si el usuario ingresa información incorrecta o inesperada. Por
ejemplo, si un programa espera un número y el usuario escribe texto, esto puede generar
una excepción y hacer que el programa se detenga de manera abrupta. Este tipo de
situaciones no solo afectan la experiencia del usuario, sino que también hacen que el
software parezca menos profesional.

Para evitar estos problemas, podemos usar el bloque try-except de Python. En lugar de
detenerse, el programa puede mostrar un mensaje claro al usuario indicando el problema,
pedir nuevamente la entrada correcta o incluso tomar una acción predeterminada. Veamos
un ejemplo:
print("=== Calculadora de División ===")
try:
numerador = float(input("Ingresá el numerador: "))
denominador = float(input("Ingresá el denominador: "))

# Intentamos realizar la división

resultado = numerador / denominador

print(f"El resultado de la división es: {resultado:.2f}")

except ValueError:
# Manejo de error si el usuario ingresa algo que no es
# un número
print("[ERROR] Debés ingresar valores numéricos válidos.")

except ZeroDivisionError:
# Manejo de error si el usuario intenta dividir por cero
print("[ERROR] El denominador no puede ser cero.")
print(" Intentá nuevamente.")

print("Gracias por usar la calculadora.")

El programa del ejemplo es una calculadora sencilla que permite al usuario realizar
divisiones. Primero, se imprime un título para informar al usuario qué hace el programa.
Luego, se utiliza un bloque try para encapsular el código que podría generar errores.

En la primera parte, se solicita al usuario que ingrese el numerador y el denominador

utilizando input(). Como el valor ingresado debe ser un número, lo convertimos a tipo
float().
Dentro del bloque try, se intenta realizar la operación de división. Si todo va bien, el
programa muestra el resultado formateado a dos decimales. Sin embargo, si el usuario
comete algún error, como ingresar texto en lugar de números, el bloque except ValueError
captura la excepción y muestra un mensaje de error indicando que debe ingresar valores
numéricos válidos.
Además, el bloque except ZeroDivisionError se encarga de manejar el caso particular en
que el usuario intente dividir por cero, mostrando un mensaje que explica el problema.

Al finalizar, independientemente de si hubo errores o no, se imprime un mensaje de cierre

agradeciendo al usuario por usar la calculadora.

Errores comunes manejados con except en

Python.
Esta tabla incluye algunos de los errores más frecuentes que podemos manejar con
try-except:

Tipo de error Descripción

Ocurre cuando se pasa un valor inválido a una operación o

ValueError
función.

Surge cuando se usa un tipo de dato incorrecto en una

TypeError
operación o función.​

Se genera al intentar acceder a un índice fuera del rango

IndexError
válido en una lista o tupla.​

Aparece al intentar acceder a una clave que no existe en un

KeyError
diccionario.​

Se produce cuando se intenta abrir un archivo que no existe

FileNotFoundError
en el sistema.​

ZeroDivisionError Ocurre al intentar dividir un número por cero.​

Surge cuando se intenta acceder a un atributo que no existe

AttributeError
en un objeto.​

Aparece cuando no se puede importar un módulo o paquete,

ImportError
ya sea porque no existe o tiene errores.​
Bases de datos.
Las bases de datos son herramientas que nos permiten almacenar, organizar y acceder a
grandes cantidades de información de manera eficiente. Imaginá que estás gestionando una
lista de clientes, productos o transacciones. A medida que la información crece, las
soluciones como listas o archivos de texto se vuelven menos prácticas. Las bases de datos
resuelven este problema al proporcionar una estructura organizada y un sistema para
manejar estos datos.

Una base de datos no es más que un conjunto de datos estructurados, organizados en

tablas. Cada tabla es como una hoja de cálculo donde las filas representan registros
(datos específicos, como el nombre de un cliente) y las columnas representan atributos
(como el correo o el número de teléfono de ese cliente).

SQL, que significa Structured Query Language (Lenguaje de Consulta Estructurado), es el

lenguaje utilizado para interactuar con bases de datos. A través de SQL, es posible realizar
operaciones esenciales como agregar información nueva a una tabla, recuperar datos
almacenados aplicando filtros o condiciones específicas, modificar registros existentes y
eliminar información que ya no se necesita. Este lenguaje es una herramienta estándar
en el manejo de bases de datos y es ampliamente utilizado en proyectos de cualquier
escala, desde pequeños sistemas hasta grandes aplicaciones empresariales.

Las bases de datos y SQL son muy importantes en el desarrollo de software porque
permiten a los programas gestionar datos de manera eficiente. Estas herramientas ofrecen
varias ventajas importantes. Por un lado, los datos se almacenan de manera estructurada,
lo que facilita su acceso y manipulación. Además, la información persiste incluso después
de cerrar el programa, asegurando su disponibilidad a largo plazo. Tanto SQL como las
bases de datos son altamente escalables, lo que significa que siguen siendo prácticas
incluso cuando la cantidad de datos crece significativamente.

En Python, es posible trabajar con bases de datos utilizando módulos como sqlite3, que
permite conectar el lenguaje con una base de datos y ejecutar operaciones en ella. Aunque
abordaremos ese módulo en la clase siguiente, presentaremos una visión general para que
comprendas cómo SQL y Python se complementan y cómo esta integración es una base
importante para desarrollar tus aplicaciones.

Python ofrece una variedad de herramientas para interactuar con bases de datos, y una de
las más accesibles y versátiles es SQLite. SQLite es una biblioteca que implementa una
base de datos relacional de alto rendimiento, ligera y autónoma, ideal para aplicaciones
pequeñas y medianas. Una de sus principales ventajas es que no requiere configuración
previa ni un servidor externo, lo que la hace perfecta para aprender los fundamentos de
bases de datos y SQL.

El módulo sqlite3, incluido de forma predeterminada en Python, permite conectar el lenguaje

con una base de datos SQLite y ejecutar consultas SQL directamente desde el programa.
Esto abre la posibilidad de crear aplicaciones que puedan manejar, organizar y procesar
datos de manera eficiente. Por ejemplo, podés utilizar Python y SQLite para registrar datos
de clientes o productos, realizar consultas para buscar información específica o actualizar
registros existentes.

En la próxima clase, aprenderás a instalar y usar el módulo sqlite3, establecer conexiones

con bases de datos SQLite y definir tablas para estructurar la información. También
exploraremos las consultas SQL básicas, como SELECT, INSERT, UPDATE y DELETE, que
son las herramientas esenciales para interactuar con los datos almacenados en una base
de datos.

Ruta de avance.
Ahora que entendiste los conceptos básicos de persistencia de datos y comenzaste a
trabajar con archivos en Python, estás un paso más cerca de dominar una habilidad clave
para el desarrollo del Trabajo Final Integrador. Incorporar la posibilidad de guardar y
recuperar información entre sesiones hará que tu proyecto sea más funcional y relevante.

Pensá en cómo podés aplicar estas herramientas a tu proyecto actual. Por ejemplo, si tu TFI
incluye un sistema de gestión de clientes o productos, podrías usar archivos para almacenar
los datos que el usuario ingrese y recuperarlos al reiniciar la aplicación. Esto permitirá que
el sistema mantenga su utilidad en el tiempo y no pierda información al cerrarse.

Consejos para avanzar:

●​ Practicá leer y escribir archivos con distintos formatos de datos y estructuras. Por
ejemplo, probá registrar listas de productos o nombres de clientes en un archivo y
luego recuperarlos para mostrarlos en pantalla.
●​ Aplicá el manejo de excepciones que aprendiste con try-except para manejar
posibles errores en la interacción con archivos, como la falta de permisos o la
ausencia de un archivo.
●​ Reflexioná sobre cómo podés mejorar la experiencia del usuario en tu programa al
agregar mensajes claros cuando ocurran errores o confirmaciones al guardar datos
correctamente.
Esta práctica no sólo te ayudará a consolidar lo aprendido en esta clase, sino que también
te preparará para integrar bases de datos en tus proyectos, una habilidad que explorarás en
la próxima clase. ¡Seguí adelante, estás haciendo un gran trabajo!

Ejercicio Práctico:
Como parte del proyecto de TalentoLab, el cliente necesita un sistema que permita registrar
los datos de los usuarios en un archivo de texto, para que puedan ser recuperados y
utilizados en futuras sesiones. Diego te asignó la tarea de desarrollar este sistema básico
de persistencia de datos, aplicando todo lo que aprendiste. Tu tarea consiste en:

1) Creá un programa que permita ingresar los datos de un

cliente: nombre, apellido y correo electrónico. Usá try-except
para manejar posibles errores durante la entrada de datos. Por
ejemplo:

●​ Si el archivo no puede abrirse para escritura.

●​ Si los datos ingresados no son válidos (por ejemplo, si el
correo no contiene una "@" o el nombre está vacío).

2) Guardá los datos ingresados en un archivo de texto llamado [Link], de forma

que cada cliente quede registrado en una nueva línea.

3)Una vez guardados los datos, mostrá un mensaje de confirmación al usuario y

cerrá el archivo correctamente.

La salida por la terminal podría ser algo asi:

=== Registro de Clientes ===

Ingresá los datos del cliente:
Nombre: Ana
Apellido: López
Correo: [Link]@[Link]

Cliente registrado con éxito en [Link]

Si ocurre un error, como intentar guardar en un archivo protegido, el programa debería
mostrar un mensaje claro:

[ERROR] No se pudo guardar la información.

Materiales y Recursos Adicionales:

Artículos:
Alfredo Sanchez Alberca: Control de errores mediante excepciones
Datacamp: Lectura y escritura de archivos en Python
TutorialesYa: Archivos de texto: creación, escritura y lectura
Oracle: ¿Qué son las bases de datos?

Videos:
Codigofacilito: Excepciones
Dimas: Manejo de archivos en Python

Preguntas para Reflexionar:

1.​ ¿Por qué es importante la persistencia de datos en las aplicaciones que
desarrollamos? ¿Cómo creés que afecta esto a la experiencia del usuario final?
2.​ ¿Qué ventajas encontrás en el uso de archivos de texto para guardar información?
¿Cuáles serían las limitaciones de esta técnica frente a otras opciones como las
bases de datos?
3.​ ¿Cómo te sentiste utilizando try-except para manejar errores? ¿Podés identificar
situaciones reales en las que su uso sería esencial?
Próximos Pasos:
En la próxima clase, vamos a dar un salto hacia una forma más avanzada y poderosa de
manejar datos: las bases de datos. Aprenderás a utilizar SQLite, un sistema de gestión de
bases de datos liviano y eficiente, ideal para proyectos pequeños y medianos. Exploraremos
cómo integrar SQLite con Python a través del módulo sqlite3, lo que te permitirá crear,
gestionar y consultar bases de datos desde tus programas.

Además, vamos a trabajar con consultas SQL básicas como SELECT, INSERT, UPDATE y
DELETE, para que puedas manipular los datos de manera eficiente. Este conocimiento te
abrirá la puerta a desarrollar aplicaciones que requieran manejar grandes volúmenes de
información de forma estructurada y persistente.

Te recomiendo repasar lo aprendido sobre la persistencia de datos en archivos y reflexionar

sobre las diferencias con el uso de bases de datos. Así estarás mejor preparado para
comprender cómo SQL y Python se combinan para ofrecer una solución robusta a las
necesidades de almacenamiento y recuperación de información.¡Nos vemos en la próxima
clase!
Iniciación a la

Programación con
Python
Clase 13
Clase N° 13 | Módulo SQLite 3
Temario:
●​ Instalación y uso del módulo sqlite3.
●​ Conexión a una base de datos SQLite.
●​ Creación de tablas y definición de campos.
●​ Consultas SQL básicas desde Python: SELECT, INSERT, UPDATE, DELETE.

Objetivos de la Clase
En esta clase, aprenderás a trabajar con bases de datos SQLite directamente desde
Python, un paso esencial para desarrollar aplicaciones que manejen grandes volúmenes de
datos de manera organizada y eficiente. Descubrirás cómo instalar y utilizar el módulo
sqlite3 para conectar tus programas con una base de datos SQLite, lo que permitirá
almacenar y recuperar información de forma persistente.

Además, explorarás cómo crear bases de datos y definir tablas con campos específicos,
entendiendo la importancia de estructurar los datos de manera lógica para facilitar su
manipulación. También aprenderás a ejecutar consultas SQL básicas, como SELECT,
INSERT, UPDATE y DELETE, que te permitirán gestionar y modificar la información
almacenada según las necesidades de tu aplicación.

La integración de consultas SQL en tus programas será otro aspecto clave que abordarás,
lo que te preparará para diseñar aplicaciones más avanzadas y robustas. Con estas
herramientas, darás un gran paso hacia la creación de proyectos con una gestión
profesional de la información.
Bienvenido a tu jornada en TalentoLab 🎉

El día comienza con un correo de Mariana en tu bandeja de entrada. El asunto es claro y

directo: “Nueva etapa del proyecto: Bases de datos SQL”. Al abrirlo, descubrís que el cliente
ha planteado un nuevo desafío. Mariana te explica que, si bien el sistema actual cumple con
su función al almacenar los datos en archivos de texto, necesita algo más robusto y
profesional para manejar un volumen creciente de información.

"Queremos dar el próximo paso. El cliente necesita que el sistema utilice

una base de datos SQL para almacenar y gestionar la información. Esto
no solo hará que el sistema sea más eficiente, sino que permitirá realizar
consultas más rápidas y precisas sobre los datos. Además, podremos
manejar grandes volúmenes de información sin problemas.”

Más tarde, en una reunión con Diego, el desarrollador senior, te da más detalles. "Vamos a
trabajar con SQLite, que es ideal para este tipo de proyectos porque no requiere
configuración compleja. Es una base de datos ligera, pero poderosa, y Python tiene todo lo
necesario para conectarse y trabajar con ella. Hoy vas a aprender cómo instalarla, crear
tablas y ejecutar consultas básicas desde tu programa. Te va a sorprender lo que podés
lograr."

Con este nuevo desafío en puerta, te sentís motivado para aprender una de las
herramientas más importantes en el desarrollo de software profesional.
Estructura de la base de datos
En una base de datos, la información se organiza en tablas. Podemos imaginar una tabla
como una hoja de cálculo donde cada fila representa un registro (como un producto del
inventario) y cada columna representa un campo (por ejemplo, el nombre del producto, el
precio o la cantidad disponible). Esta estructura es muy práctica porque facilita la búsqueda,
el filtrado y la modificación de datos.

Ejemplo simple de una tabla

Campos y registros en las tablas

En una base de datos, un campo es una columna dentro de una tabla que almacena un tipo
específico de información sobre los registros que están en esa tabla. Por ejemplo, si
pensamos en una tabla de productos, cada producto sería un registro y cada campo
almacenaría una característica específica de ese producto, como su nombre, cantidad o
precio.

Los tipos de datos que podemos almacenar en los campos de una tabla son importantes
porque determinan qué clase de información puede guardarse en ese campo. Al definir una
tabla, tenemos que indicar qué tipo de dato se acepta en cada campo para asegurarnos de
que la información se almacene correctamente.

Estos son algunos de los tipos de datos más comunes y útiles para un proyecto de gestión
de inventario:
 ●​ Texto: Este tipo de dato se utiliza para almacenar cadenas de texto. Es útil cuando
queremos guardar nombres de productos, descripciones o categorías. Por ejemplo,
podríamos tener un campo llamado "nombre" para guardar el nombre del producto
("Manzana", "Leche", etc.) y otro llamado "descripción" para una breve descripción
del producto.

●​ Números enteros: Este tipo de dato se utiliza para almacenar números enteros. Es
ideal para cantidades de productos o para campos que necesiten valores numéricos
sin decimales, como el código de un producto (por ejemplo, un ID único que
identifique cada producto). Un campo de tipo entero sería perfecto para registrar
cuántas unidades de cada producto tenemos en el inventario.

●​ Números de punto flotante: Cuando necesitamos almacenar precios o valores que

incluyan decimales, usamos un tipo de dato que permita números con fracciones. En
un sistema de inventario, el precio de un producto es un ejemplo de un valor que
suele requerir decimales.

●​ Fechas y horas: A veces es necesario registrar cuándo ocurrió algo, como la fecha
en que un producto fue agregado al inventario o la última vez que se actualizó su
cantidad. Para esto, usamos un tipo de dato que pueda manejar fechas y horas.
Estos campos son útiles para llevar un control de las acciones que realizamos en la
base de datos.

Al crear una tabla, decidimos qué tipo de datos vamos a almacenar en cada campo según el
tipo de información que necesitamos guardar. De esta forma nos aseguramos de que la
base de datos esté organizada y opere con normalidad.

Campos clave.
Ahora vamos a hablar sobre un concepto clave en las bases de datos: el campo clave, o
también conocido como clave primaria. Este campo es uno de los elementos más
importantes cuando diseñamos una tabla en nuestra base de datos.

Un campo clave es un campo especial dentro de una tabla que se utiliza para identificar de
manera única cada registro. Imaginemos que tenemos una tabla donde guardamos todos
los productos del inventario. Cada producto tiene su propio nombre, precio, cantidad, etc.,
pero necesitamos un dato que permita diferenciar cada producto de manera única. Para
esto, usamos una clave primaria.
La clave primaria tiene dos características principales:

Unicidad: No puede haber dos registros en la tabla que tengan el mismo valor en el campo
clave. Esto es lo que permite identificar de manera única cada producto en el inventario. Por
ejemplo, en nuestra tabla de productos, podríamos usar un campo llamado "ID Producto",
que asigna un número único a cada producto. Así, aunque tengamos dos productos
llamados "Pan", cada uno tendría un número de ID diferente, lo que nos permite
diferenciarlos.

No puede ser nulo: El campo clave debe tener siempre un valor. No puede quedar vacío.
Si no existiera una clave para un registro, no tendríamos manera de identificarlo claramente
dentro de la tabla, lo que generaría problemas al momento de buscar o actualizar
información.

Por ejemplo, en nuestra tabla de productos, podemos tener un campo llamado "ID
Producto" que actúe como clave primaria. Supongamos que tenemos estos productos.

En este ejemplo, el campo ”ID Producto” es la clave primaria. Cada producto tiene un
número único que lo diferencia de los demás, incluso si otros datos, como el nombre,
llegaran a repetirse. El hecho de que sea único y obligatorio nos asegura que podemos
identificar cualquier producto en la tabla sin confusión.

Una de las mayores ventajas de utilizar una clave primaria es que nos permite realizar
búsquedas de manera rápida. Al tener un identificador único para cada registro, podemos
encontrar lo que buscamos sin tener que comparar otros campos. Además, nos brinda
seguridad al momento de actualizar datos. Si necesitamos cambiar la cantidad de un
producto o modificar su precio, podemos hacerlo con la tranquilidad de que estamos
editando el registro correcto, ya que está identificado de forma única. Por otro lado, la clave
primaria también garantiza la integridad de los datos. Al no permitir valores repetidos o
vacíos, ayuda a mantener la tabla organizada y libre de errores. Esto hace que sea una
herramienta casi indispensable para la correcta gestión de los datos, sobre todo cuando
trabajamos con grandes volúmenes de información, como en el caso de un sistema de
inventario.

Introducción al módulo SQLite3.

SQLite es un motor de base de datos ligero y autónomo que no requiere configuraciones
complejas ni servidores externos para funcionar. Esto lo convierte en una excelente opción
para proyectos pequeños y medianos, donde la simplicidad y la eficiencia son clave. En
Python, el módulo sqlite3 permite interactuar fácilmente con bases de datos SQLite,
integrando consultas y gestión de datos directamente en nuestros programas.

Una de las grandes ventajas de SQLite es que los datos se almacenan en un archivo único
que puede ser fácilmente transferido o respaldado. Además, al ser una base de datos
relacional, organiza la información en tablas, tal como explicamos antes. Esto facilita la
consulta y manipulación de datos.

Al trabajar con sqlite3, podés crear, leer, actualizar y eliminar datos en una base de datos
utilizando comandos SQL directamente desde Python. Este enfoque no solo mejora la
persistencia de los datos, sino que también permite gestionar grandes volúmenes de
información de manera más eficiente que utilizando archivos de texto.

Conexión a una base de datos SQLite

Para trabajar con bases de datos SQLite en Python, es necesario establecer una conexión.
Esta conexión actúa como un puente entre tu programa y la base de datos, permitiéndote
enviar y recibir información. Si la base de datos no existe, SQLite la creará automáticamente
en el lugar indicado, lo que simplifica enormemente el proceso de configuración.

La conexión se establece mediante la función [Link](). Este método requiere que

especifiques el nombre del archivo donde se almacenará la base de datos. Por ejemplo, si
querés crear una base de datos llamada [Link], simplemente indicás este nombre
al método. Una vez creada la conexión, también es necesario cerrarla al final del programa
para liberar recursos y asegurar que todos los cambios se guarden correctamente.
Veamos un ejemplo básico:

import sqlite3

# Establecer la conexión a la base de datos

conexion = [Link]("[Link]")

print("Conexión establecida exitosamente.")

# Cerrar la conexión
[Link]()
import sqlite3

# Establecer la conexión a la base de datos

conexion = [Link]("[Link]")

print("Conexión establecida exitosamente.")

# Cerrar la conexión
[Link]()

En este ejemplo, se establece una conexión con la base de datos llamada [Link]. Si
el archivo no existe, será creado en el mismo directorio donde se ejecuta el programa. El
mensaje en pantalla confirma que la conexión se realizó correctamente, y al final, se cierra
la conexión para evitar problemas futuros.

Cerrar la conexión no solo es una buena práctica, sino que también previene
errores relacionados con bloqueos de archivo o recursos no liberados.
Creación de tablas y definición de campos
Una vez establecida la conexión con una base de datos SQLite, el siguiente paso es definir
su estructura creando tablas. Una tabla es el componente principal de una base de datos,
donde los datos se organizan en filas y columnas. Cada columna representa un campo con
un tipo de dato específico, como texto, números o fechas, mientras que cada fila almacena
un registro individual.

Para crear una tabla en SQLite desde Python, utilizamos sentencias SQL con el método
execute() proporcionado por el objeto cursor. El cursor es una herramienta que nos permite
interactuar con la base de datos, ejecutar consultas y recuperar resultados.

A continuación, un ejemplo donde se crea una tabla llamada productos con tres campos: id
(clave primaria), nombre (nombre del producto) y precio (precio del producto):

import sqlite3

# Establecer la conexión a la base de datos

conexion = [Link]("[Link]")

# Crear un objeto cursor

cursor = [Link]()

# Crear una tabla

[Link]('''
CREATE TABLE IF NOT EXISTS productos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
precio REAL NOT NULL
)
''')

print("Tabla 'productos' creada exitosamente.")

# Confirmar los cambios y cerrar la conexión

[Link]()
[Link]()
En el ejemplo, la conexión a la base de datos se realiza con [Link](), creando o
abriendo el archivo [Link]. Luego, se utiliza el método cursor() para obtener un
objeto cursor, que es necesario para ejecutar comandos SQL.

La sentencia CREATE TABLE IF NOT EXISTS asegura que la tabla se cree solo si no
existe ya en la base de datos, evitando errores por duplicados. Dentro de los paréntesis se
define la estructura de la tabla:

●​ id INTEGER PRIMARY KEY AUTOINCREMENT: El campo id es un identificador

único que se incrementa automáticamente con cada nuevo registro.

●​ nombre TEXT NOT NULL: El campo nombre almacena texto y no puede quedar
vacío.

●​ precio REAL NOT NULL: El campo precio almacena números reales y tampoco
puede quedar vacío.

Finalmente, se utiliza commit() para guardar los cambios realizados en la base de datos y
close() para cerrar la conexión.

Inserción de datos en una tabla

Una vez creada la tabla, el siguiente paso es agregar datos a la misma. En SQLite, esto se
realiza mediante la sentencia SQL INSERT INTO, que permite especificar los valores para
cada columna. Este proceso se puede implementar desde Python usando el método
execute() del cursor, proporcionando los valores de manera directa o a través de
parámetros para mayor flexibilidad y seguridad.

El siguiente ejemplo muestra cómo insertar productos en la tabla productos creada

anteriormente:

import sqlite3

# Conexión a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

# Insertar datos en la tabla

[Link]('''
 INSERT INTO productos (nombre, precio)
VALUES (?, ?)
''', ("Lápiz", 25.50))

[Link]('''
INSERT INTO productos (nombre, precio)
VALUES (?, ?)
''', ("Cuaderno", 120.00))

[Link]('''
INSERT INTO productos (nombre, precio)
VALUES (?, ?)
''', ("Mochila", 890.99))

print("Productos agregados exitosamente.")

# Confirmar los cambios y cerrar la conexión

[Link]()
[Link]()

En el ejemplo, se comienza estableciendo la conexión con la base de datos y creando un

objeto cursor para interactuar con ella. La sentencia SQL INSERT INTO especifica la tabla
(productos) y las columnas (nombre y precio) en las que se van a insertar valores.

En lugar de escribir los valores directamente en la consulta, se utiliza el símbolo ? como

marcador de posición. Esto es una práctica recomendada porque evita vulnerabilidades
como las inyecciones SQL. Los valores reales se pasan como una tupla en el segundo
argumento del método execute().

●​ En el primer llamado a execute(), se inserta el producto "Lápiz" con un precio de

25.50.
●​ En el segundo y tercer llamados, se agregan otros dos productos: "Cuaderno" y
"Mochila", con sus respectivos precios.

Finalmente, usamos el método commit() para guardar los cambios en la base de datos,
asegurándose de que los datos se conserven. La conexión se cierra al final con close().
Consulta de datos con SELECT
La sentencia SELECT en SQL se utiliza para recuperar información almacenada en una
tabla. Es una de las operaciones más comunes en el manejo de bases de datos y permite
obtener datos específicos o todos los registros según los criterios definidos.

En Python, se puede implementar SELECT utilizando el método execute() del cursor, al

igual que otras sentencias SQL. Veamos cómo recuperar los datos insertados en la tabla
productos.

Ejemplo: Recuperar todos los registros

import sqlite3

# Conexión a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

# Recuperar todos los registros de la tabla productos

[Link]('SELECT * FROM productos')
productos = [Link]()

print("\n=== Lista de Productos ===")

for producto in productos:
print(f"ID: {producto[0]}, Nombre: {producto[1]}, Precio:
${producto[2]:.2f}")

# Cerrar la conexión
[Link]()

El comando SELECT * FROM productos indica que queremos obtener todos los registros de
la tabla productos. El asterisco (*) significa "todas las columnas". El método fetchall()
recupera todos los resultados de la consulta en forma de lista de tuplas, donde cada tupla
representa un registro de la tabla.

En el bucle for, se itera sobre los resultados para mostrar el ID, nombre y precio de cada
producto. Esto facilita una visualización clara de los datos.
Recuperar registros con filtros

Es posible añadir condiciones a la consulta para recuperar registros específicos usando

WHERE. Por ejemplo, supongamos que queremos obtener los productos cuyo precio sea
mayor a $100.

# Recuperar productos con precio mayor a $100

[Link]('SELECT * FROM productos WHERE precio > ?',
(100,))productos_filtrados = [Link]()

print("\n=== Productos con Precio Mayor a $100 ===")

for producto in productos_filtrados:

print(f"ID: {producto[0]}, Nombre: {producto[1]}, Precio:
${producto[2]:.2f}")

La cláusula WHERE permite definir condiciones para filtrar los resultados. En este caso,
precio > ? selecciona solo los productos cuyo precio sea mayor a 100. El marcador ? es
reemplazado por el valor proporcionado en la tupla (100,), asegurando que la consulta sea
segura.

Ordenar los resultados con ORDER BY

Se puede ordenar los resultados utilizando la cláusula ORDER BY. Por ejemplo, para
mostrar los productos en orden ascendente por precio:

# Ordenar los productos por precio (ascendente)

[Link]('SELECT * FROM productos ORDER BY precio ASC')
productos_ordenados = [Link]()

print("\n=== Productos Ordenados por Precio (Ascendente) ===")

for producto in productos_ordenados:
print(f"ID: {producto[0]}, Nombre: {producto[1]}, Precio:
${producto[2]:.2f}")
El uso de ASC indica que el orden es ascendente, mientras que DESC lo haría
descendente.

Seleccionar columnas específicas

Si solo queremos recuperar ciertos campos, podemos especificar los nombres de las
columnas en lugar de usar *. Por ejemplo, obtener solo los nombres de los productos:

# Obtener solo los nombres de los productos

[Link]('SELECT nombre FROM productos')
nombres = [Link]()

print("\n=== Nombres de Productos ===")

for nombre in nombres:
print(f"Producto: {nombre[0]}")

La sentencia SELECT es casi indispensable para trabajar con bases de datos, y como
hemos visto, su flexibilidad permite extraer la información de diferentes formas según las
necesidades de cada aplicación.

Actualización de datos con UPDATE.

La sentencia UPDATE en SQL se utiliza para modificar registros existentes en una tabla. Es
una herramienta esencial cuando necesitamos corregir o actualizar información sin
eliminarla ni insertar nuevos datos.

En Python, se puede usar el método execute() para implementar UPDATE. Veamos como
utilizarlo:

Ejemplo: Actualizar el precio de un producto

Supongamos que necesitamos modificar el precio de un producto específico en nuestra

tabla productos. Por ejemplo, queremos actualizar el precio del producto cuyo ID es 1.
import sqlite3

# Conexión a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

# Actualizar el precio de un producto específico

nuevo_precio = 250.0
id_producto = 1
[Link]('UPDATE productos SET precio = ? WHERE id = ?',
(nuevo_precio, id_producto))

# Confirmar cambios
[Link]()

print(f"Producto con ID {id_producto} actualizado correctamente.")

# Verificar los cambios

[Link]('SELECT * FROM productos WHERE id = ?', (id_producto,))
producto_actualizado = [Link]()

print("\n=== Producto Actualizado ===")

print(f"ID: {producto_actualizado[0]}, Nombre:
{producto_actualizado[1]}, Precio: ${producto_actualizado[2]:.2f}")

# Cerrar la conexión
[Link]()

La sentencia UPDATE se compone de tres partes clave:

●​ UPDATE productos especifica la tabla en la que queremos realizar la actualización.

●​ SET precio = ? define el campo que será modificado y el nuevo valor que tomará.
●​ WHERE id = ? agrega una condición para asegurar que solo se modifique el registro
correspondiente. En este caso, se usa el ID del producto como identificador único.
El uso de los marcadores ? permite realizar consultas parametrizadas, lo que evita
vulnerabilidades como las inyecciones SQL.

Tras ejecutar la actualización, es fundamental llamar a [Link]()

para guardar los cambios en la base de datos. Luego, se verifica el cambio
con una consulta SELECT que muestra el registro actualizado.

Actualizar varios registros simultáneamente

También es posible modificar varios registros en una sola operación. Por ejemplo,
supongamos que queremos aumentar un 10% al precio de todos los productos que cuestan
menos de $100:

# Incrementar en un 10% los precios de los productos con precio menor a

$100
[Link]('UPDATE productos SET precio = precio * 1.10 WHERE
precio < ?', (100,))

# Confirmar cambios
[Link]()

print("Precios actualizados para productos con precio menor a $100.")

Este código utiliza la sentencia UPDATE para modificar los precios de los productos en una
base de datos que cumplan con una condición específica. En este caso, se busca
incrementar un 10% el precio de todos los productos cuyo valor sea menor a $100. La
sentencia SQL define la tabla (productos), el campo a modificar (precio) y la operación que
debe realizarse (precio * 1.10), además de incluir la condición WHERE precio < ?, donde el
marcador ? se reemplaza por el valor 100.

Después de ejecutar la operación, el método [Link]() se utiliza para guardar los

cambios realizados en la base de datos. Finalmente, se imprime un mensaje en la consola
indicando que los precios de los productos han sido actualizados correctamente. Este
enfoque asegura que solo los registros que cumplan con la condición definida sean
afectados.
 El uso de la cláusula WHERE es esencial para evitar modificaciones
accidentales en todos los registros de la tabla. Si WHERE se omite, se
actualizarán todos los registros, lo que puede no ser deseado.

Además, siempre es buena práctica verificar el impacto de la operación con una consulta
previa o posterior que muestre los registros afectados, asegurando así la integridad de los
datos.

Eliminar registros con DELETE.

La sentencia DELETE en SQL se utiliza para eliminar registros específicos de una tabla. Es
una herramienta poderosa y debe usarse con cuidado, ya que una vez eliminados los
registros, no se pueden recuperar a menos que se haya realizado un respaldo previo. Es
fundamental siempre acompañar la instrucción con una condición clara usando WHERE,
para evitar eliminar toda la información de la tabla.

La estructura básica de DELETE es la siguiente:

DELETE FROM nombre_de_tabla WHERE condicion;

Aquí, nombre_de_tabla es la tabla en la que se van a eliminar los registros, y condicion

define qué registros serán eliminados.

Si no se especifica un WHERE, se eliminarán todos los registros de la

tabla, dejando la estructura intacta pero vacía.
Ejemplo 1: Eliminando un producto específico

Supongamos que tenemos una tabla llamada productos y queremos eliminar un producto
basándonos en su nombre.

# Conexión a la base de datos

import sqlite3
conexion = [Link]("[Link]")
cursor = [Link]()

# Eliminar un producto específico

nombre_producto = "Lápiz"
[Link]("DELETE FROM productos WHERE nombre = ?",
(nombre_producto,))

# Confirmar cambios
[Link]()

print(f"Producto '{nombre_producto}' eliminado de la base de datos.")

# Cerrar la conexión
[Link]()

En este ejemplo, comenzamos estableciendo la conexión a la base de datos y obteniendo

un cursor para ejecutar las consultas. Luego, usamos la sentencia DELETE con un WHERE
para especificar que queremos eliminar el registro donde el campo nombre coincide con el
valor de la variable nombre_producto. Para prevenir inyecciones SQL, utilizamos un
marcador ? y pasamos el valor como una tupla. Finalmente, confirmamos los cambios con
commit y cerramos la conexión.
Ejemplo 2 : Eliminando productos por precio

En algunos casos, podemos querer eliminar varios registros que cumplan con una
condición, como todos los productos con un precio inferior a cierto valor.

# Eliminar productos con precio menor a $50

precio_limite = 50
[Link]("DELETE FROM productos WHERE precio < ?",
(precio_limite,))

# Confirmar cambios
[Link]()

print(f"Productos con precio menor a ${precio_limite} eliminados.")

La sentencia DELETE es extremadamente útil para mantener la base de datos limpia y

actualizada. Sin embargo, siempre debe usarse con precaución, asegurándose de definir
condiciones específicas, para evitar la eliminación accidental de datos valiosos.

Ejercicio Práctico
Al finalizar el día, Diego se acerca con una solicitud concreta:

"Mariana ha hablado con el cliente, y tienen una tarea específica

que quieren resolver ya mismo. Nos pidieron que hagamos una
prueba con el sistema SQLite. Necesitamos algo básico pero
funcional: registrar productos con su nombre y precio, y luego
mostrarlos en pantalla para asegurarnos de que el registro funciona
correctamente. ¿Te animás a encargarte de esta parte? Es clave
para que avancemos hacia la solución más completa."
Necesitaras:

1.​ Crear una base de datos SQLite llamada [Link].

2.​ Definir una tabla llamada productos con los campos id (clave primaria
autoincremental), nombre (texto, no nulo) y precio (real, no nulo).
3.​ Diseñar un programa que permita:
○​ Registrar un producto ingresando su nombre y precio.
○​ Mostrar todos los productos almacenados en la base de datos.

El sistema debe incluir validaciones básicas:

●​ El nombre no puede estar vacío.

●​ El precio debe ser un número mayor que cero.

Materiales y Recursos Adicionales:

Artículos:
[Link]: Interfaz para bases de datos SQLite
Datacamp: Cómo trabajar con SQLite en Python

Videos:
Auribox Training: SQLite con Python
Dimas: ¿Cómo usar SQLite3 en PYTHON?

Preguntas para Reflexionar:

1.​ Aprendiste a crear tablas y realizar consultas básicas. ¿Qué beneficios encontrás en
estructurar los datos en tablas con campos definidos en lugar de usar listas o
diccionarios?
2.​ Pensando en las operaciones SQL que vimos (SELECT, INSERT, UPDATE,
DELETE), ¿cuál te pareció más intuitiva y por qué?
3.​ ¿Qué errores podrías prever al trabajar con bases de datos en programas reales y
cómo creés que podrías evitarlos usando lo aprendido?
4.​ ¿Cómo podrías aplicar el uso de bases de datos SQLite en un proyecto más
complejo, como el Trabajo Final Integrador?
Próximos Pasos:
La clase siguiente te llevará a profundizar aún más en el manejo de bases de datos,
ampliando tus habilidades para realizar operaciones CRUD (Crear, Leer, Actualizar y
Eliminar) de manera segura y eficiente. Además, aprenderás cómo manejar parámetros en
tus consultas para proteger tus programas contra posibles inyecciones SQL, una amenaza
común en aplicaciones que interactúan con bases de datos.

Exploraremos también el manejo de transacciones, un recurso esencial para garantizar la

integridad de los datos en operaciones más complejas. Estos conceptos te ayudarán a
escribir código más robusto y profesional, sentando las bases para desarrollar aplicaciones
que gestionen información de forma confiable y escalable.

Repasá los conceptos de esta clase y asegurate de comprender cómo estructurar y realizar
consultas en SQLite, ya que serán fundamentales para continuar avanzando en el curso.
Iniciación a la

Programación con
Python
Clase 14
Clase N° 14 | Operaciones CRUD
con Bases de Datos
Temario:
●​ Profundización en operaciones CRUD.
●​ Uso de parámetros en consultas para prevenir inyecciones SQL.
●​ Manejo de transacciones y control de errores.

Objetivos de la Clase
En esta clase, te adentrarás en la implementación completa de las operaciones CRUD en
bases de datos SQLite desde Python. Aprenderás a estructurar un sistema capaz de crear,
leer, actualizar y eliminar registros de manera eficiente, lo que te permitirá gestionar
información de forma organizada y persistente.

También conocerás las inyecciones SQL, un problema de seguridad común en

aplicaciones que manejan bases de datos. Entenderás cómo se originan estos ataques y, lo
más importante, cómo prevenirlos utilizando consultas parametrizadas en Python,
garantizando así la integridad y seguridad de los datos.

Por último, abordarás el manejo de transacciones y el control de errores al trabajar con

bases de datos. Descubrirás cómo asegurarte de que las operaciones realizadas en la base
sean consistentes y cómo responder ante posibles fallos mediante el uso de commit(),
rollback() y estructuras de manejo de excepciones. Todo esto sentará una base sólida para
que puedas integrar bases de datos de manera segura y confiable en tu Trabajo Final
Integrador.
Bienvenido a tu jornada en TalentoLab 🎉

El día comienza con un nuevo desafío en TalentoLab. Revisás tu correo y encontrás un

mensaje de Mariana con el asunto: "Fortaleciendo la gestión de datos".

"Hola!
El sistema ya almacena información en SQLite, pero necesitamos que
los usuarios puedan modificar y eliminar registros de manera segura. Tu
tarea es implementar correctamente el CRUD (Crear, Leer, Actualizar y
Eliminar), asegurando que las operaciones sean confiables y
protegiendo el sistema contra posibles errores o ataques de inyección
SQL.
Diego está listo para explicarte cómo manejar transacciones y controlar errores en consultas
SQL. Esto garantizará que los datos no se corrompan y que, en caso de fallos, podamos
revertir cambios sin afectar la integridad del sistema.

¡Confío en que vas a hacer un gran trabajo!"

Te dirigís a la oficina de Diego, quien te recibe con su mate en la mano.

"Bienvenido al siguiente nivel. Hoy vas a aprender cómo hacer que nuestro sistema sea
más robusto, ejecutando operaciones CRUD de manera segura. También te voy a mostrar
cómo las transacciones ayudan a mantener la integridad de los datos. Cuando terminemos,
vas a estar listo para poder aplicar todo esto en tu Trabajo Final Integrador."

Tomás asiento, listo para profundizar en la gestión avanzada de bases de datos en Python.
CRUD y su importancia en bases de datos
En cualquier aplicación que maneje información estructurada, es fundamental poder crear,
leer, actualizar y eliminar registros dentro de una base de datos. Estas cuatro operaciones
conforman lo que se conoce como CRUD (por sus siglas en inglés: Create, Read, Update,
Delete), y son la base de cualquier sistema de gestión de datos.

Cuando un usuario registra un producto o cliente en un sistema, en realidad está ejecutando

una operación Create (Crear) en la base de datos. Cuando consulta información, el sistema
está ejecutando una Read (Leer). Si necesita modificar algún dato, usa una operación
Update (Actualizar), y cuando borra un registro, se aplica Delete (Eliminar).

Implementar correctamente CRUD no solo permite manipular datos, sino que también
garantiza que la información esté organizada, accesible y actualizada. Sin un sistema
CRUD correcto, los datos serían estáticos o estarían desorganizados, dificultando su
administración.

SQLite facilita la implementación de estas operaciones mediante consultas SQL,

permitiendo modificar los registros de manera estructurada. Sin embargo, al trabajar con
datos en una base de datos, es fundamental proteger la integridad de la información y
prevenir errores o vulnerabilidades.

Vamos a aplicar lo que ya sabemos sobre consultas SQL y la interacción con bases de
datos, pero ahora estructurándolo en un sistema funcional que permita realizar las cuatro
operaciones de CRUD de manera segura y eficiente.

Implementación de CRUD en SQLite con Python

Hasta ahora, hemos aprendido cómo realizar consultas SELECT, INSERT, UPDATE y
DELETE en SQLite. Ahora vamos a integrar todas estas operaciones dentro de un único
programa en Python, de manera que podamos gestionar una base de datos de productos,
clientes o cualquier otra entidad de interés. La implementación de CRUD en Python sigue
una estructura clara:

1.​ Conexión a la base de datos: Se establece una conexión con un archivo SQLite
para almacenar los datos.
2.​ Creación de una tabla si no existe: Se define la estructura de los datos (nombre,
precio, stock, etc.).
 3.​ Funciones para cada operación: Se programan las funciones para agregar, leer,
actualizar y eliminar registros.
4.​ Menú interactivo: Se permite al usuario seleccionar qué acción desea realizar.

Veamos un ejemplo concreto, escribiendo el código básico de un CRUD para manejar datos
de alumnos.

import sqlite3

# Conexión a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

# Crear la tabla si no existe

[Link]('''
CREATE TABLE IF NOT EXISTS alumnos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
edad INTEGER NOT NULL,
curso TEXT NOT NULL
)
''')
[Link]()

def agregar_alumno(nombre, edad, curso):

"""Inserta un nuevo alumno en la base de datos"""
[Link]("INSERT INTO alumnos (nombre, edad, curso) VALUES (?,
?, ?)", (nombre, edad, curso))
[Link]()
print("Alumno agregado con éxito.")

def mostrar_alumnos():
"""Muestra todos los alumnos en la base de datos"""
[Link]("SELECT * FROM alumnos")
alumnos = [Link]()
print("\nLista de alumnos:")
 for alumno in alumnos:
print(f"ID: {alumno[0]}, Nombre: {alumno[1]}, Edad: {alumno[2]},
Curso: {alumno[3]}")

def actualizar_curso(id_alumno, nuevo_curso):

"""Modifica el curso de un alumno específico"""
[Link]("UPDATE alumnos SET curso = ? WHERE id = ?",
(nuevo_curso, id_alumno))
[Link]()
print("Curso actualizado correctamente.")

def eliminar_alumno(id_alumno):
"""Elimina un alumno de la base de datos"""
[Link]("DELETE FROM alumnos WHERE id = ?", (id_alumno,))
[Link]()
print("Alumno eliminado correctamente.")

# Menú interactivo
while True:
print("\nGestión de Alumnos")
print("1. Agregar alumno")
print("2. Mostrar alumnos")
print("3. Actualizar curso de un alumno")
print("4. Eliminar alumno")
print("5. Salir")

opcion = input("Seleccioná una opción: ")

if opcion == "1":
nombre = input("Ingresá el nombre del alumno: ").strip()
edad = input("Ingresá la edad del alumno: ").strip()
curso = input("Ingresá el curso del alumno: ").strip()

if [Link](): # Validar que la edad sea un número

agregar_alumno(nombre, int(edad), curso)
else:
 print("La edad debe ser un número válido.")

elif opcion == "2":

mostrar_alumnos()

elif opcion == "3":

id_alumno = input("Ingresá el ID del alumno a actualizar:
").strip()
nuevo_curso = input("Ingresá el nuevo curso: ").strip()

if id_alumno.isdigit():
actualizar_curso(int(id_alumno), nuevo_curso)
else:
print("El ID debe ser un número válido.")

elif opcion == "4":

id_alumno = input("Ingresá el ID del alumno a eliminar:
").strip()

if id_alumno.isdigit():
eliminar_alumno(int(id_alumno))
else:
print("El ID debe ser un número válido.")

elif opcion == "5":

print("Saliendo del sistema...")
break

else:
print("Opción inválida. Intentá nuevamente.")

# Cerrar la conexión al finalizar

[Link]()
El código propuesto implementa un sistema CRUD para la gestión de alumnos en una base
de datos SQLite. Al comenzar, establece una conexión con una base de datos llamada
"[Link]" y crea una tabla llamada "alumnos" (en caso de que aún no exista). Esta
tabla tiene cuatro columnas: ID, nombre, edad y curso. La columna ID es un número
entero que se incrementa automáticamente para identificar cada alumno de forma única,
mientras que las demás columnas almacenan los datos ingresados por el usuario.

Para realizar las operaciones de gestión, se han definido distintas funciones que encapsulan
las acciones necesarias para interactuar con la base de datos. La función
agregar_alumno() permite insertar un nuevo registro en la tabla, asegurándose de recibir el
nombre, la edad y el curso del estudiante. La función mostrar_alumnos() recupera todos
los registros de la base de datos y los muestra en pantalla. Cada fila obtenida a través de la
consulta SQL se presenta con el ID, el nombre, la edad y el curso de una persona.

Cuando se necesita modificar el curso de un alumno, la función actualizar_curso() permite

actualizar la información en la base de datos, solicitando el ID del alumno y el nuevo curso
que se asignará. Del mismo modo, la función eliminar_alumno() permite borrar un registro
de la base de datos de manera permanente, solicitando el ID del alumno que se desea
eliminar. Estas operaciones garantizan que los datos se mantengan actualizados y
organizados dentro del sistema.

El código principal ejecuta un menú interactivo que le permite al usuario seleccionar qué
acción desea realizar. Cada opción está asociada a una función específica que ejecuta la
operación correspondiente. Si el usuario elige agregar un nuevo alumno, se le solicitan los
datos y se verifica que la edad ingresada sea un número válido antes de insertarlo en la
base de datos. Si elige mostrar la lista de alumnos, se ejecuta la consulta para recuperar
todos los registros existentes y mostrarlos en la pantalla.

Para modificar el curso de un alumno, el sistema solicita el ID del alumno y el nuevo curso
a asignar. Antes de ejecutar la actualización, verifica que el ID ingresado sea numérico. Lo
mismo ocurre en la opción de eliminación: el sistema solicita el ID del alumno, lo valida y, si
es correcto, procede a eliminarlo de la base de datos.

Cuando el usuario decide salir del sistema, la conexión con la base de datos se cierra
correctamente. Esto es fundamental para garantizar que los cambios realizados se guarden
y evitar problemas de acceso a la base de datos en futuras ejecuciones del programa.

Este código permite gestionar alumnos en una base de datos de manera eficiente,
aplicando las operaciones CRUD de una forma estructurada y organizada. Más adelante
veremos cómo mejorar la seguridad de estas consultas para prevenir errores y
vulnerabilidades, asegurando que la base de datos sea robusta y segura.
¿Qué es una inyección SQL y por qué es un problema?
Cuando trabajamos con bases de datos en Python o en cualquier otro lenguaje, es
fundamental asegurarnos de que nuestras consultas sean seguras. Una de las principales
amenazas que enfrentamos al interactuar con bases de datos es la inyección SQL. Este
tipo de ataque ocurre cuando un usuario malintencionado introduce código SQL en los
campos de entrada de un formulario, manipulando la consulta para acceder, modificar o
incluso eliminar datos de la base de datos.

Por ejemplo, si en un sistema sin protección, un usuario ingresa el siguiente texto en un

campo de búsqueda:

' OR 1=1 --

Y el sistema ejecuta la consulta sin validar la entrada, se podría generar una instrucción
como esta:

SELECT * FROM alumnos WHERE nombre = '' OR 1=1 --'

La condición 1=1 siempre es verdadera, por lo que la consulta devolverá todos los registros
de la tabla. En algunos casos, una inyección SQL maliciosa podría incluso eliminar toda la
base de datos o exponer información sensible.

Para evitar este problema, nunca debemos construir las consultas SQL concatenando
variables directamente en la consulta. En su lugar, se deben utilizar parámetros en
consultas preparadas, lo que evita que el contenido ingresado por el usuario se interprete
como código SQL.

A continuación, presentamos una versión segura de una consulta de inserción de datos

utilizando parámetros con SQLite:

def agregar_alumno_seguro(nombre, edad, curso):

conexion = [Link]("[Link]")
cursor = [Link]()
 [Link]("INSERT INTO alumnos (nombre, edad, curso) VALUES (?,
?, ?)", (nombre, edad, curso))

[Link]()
[Link]()

En este caso, los signos de interrogación (?) actúan como marcadores de posición en la
consulta, y los valores que proporciona el usuario se pasan como una tupla aparte. De esta
manera, SQLite maneja los datos de manera segura y evita que sean interpretados
como código SQL malicioso.

Otro ejemplo, aplicando este principio en una consulta de selección:

def buscar_alumno(nombre):
conexion = [Link]("[Link]")
cursor = [Link]()

[Link]("SELECT * FROM alumnos WHERE nombre = ?", (nombre,))

resultados = [Link]()
[Link]()

return resultados

Aquí, en lugar de construir la consulta concatenando el valor de nombre, se utiliza un

parámetro de consulta, asegurando que el dato ingresado por el usuario no sea tratado
como código SQL.

Comparación entre consultas seguras y vulnerables

Para que quede claro cómo mejorar la seguridad de nuestras consultas, comparemos dos
versiones de una consulta de eliminación de alumnos:
❌ Consulta insegura (vulnerable a inyección SQL):
def eliminar_alumno_inseguro(nombre):
conexion = [Link]("[Link]")
cursor = [Link]()

# Construcción de la consulta con formato inseguro

consulta = f"DELETE FROM alumnos WHERE nombre = '{nombre}'"
[Link](consulta)

[Link]()
[Link]()

Este código es peligroso porque si alguien ingresa un nombre como: ' OR

1=1 -- se generaría una consulta que borraría todos los alumnos de la base
de datos.

✅ Consulta segura (protegida contra inyección SQL)

def eliminar_alumno_seguro(nombre):
conexion = [Link]("[Link]")
cursor = [Link]()

# Uso de parámetros para prevenir inyección SQL

[Link]("DELETE FROM alumnos WHERE nombre = ?", (nombre,))

[Link]()
[Link]()
Este código evita el problema porque el valor ingresado se trata como un dato, no como
parte de la consulta SQL. Este enfoque basado en parámetros de consulta no sólo
protege nuestras bases de datos de ataques, sino que también mejora la eficiencia y
seguridad del sistema. En la siguiente sección, veremos cómo el uso de transacciones y
manejo de errores nos ayuda a garantizar la integridad de la información en la base de
datos.

Uso de transacciones y manejo de errores en bases de datos

Hasta ahora, hemos aprendido a realizar operaciones sobre bases de datos utilizando
consultas SQL seguras con SQLite. Sin embargo, para garantizar la integridad de los
datos, es importante entender el concepto de transacciones y cómo manejar posibles
errores al interactuar con la base de datos.

Una transacción es un conjunto de operaciones SQL que deben ejecutarse de manera

completa o no ejecutarse en absoluto. En otras palabras, o se realizan todas las
operaciones correctamente o ninguna de ellas se lleva a cabo.

Por ejemplo, imaginemos un sistema de inscripción de alumnos en un curso. Si agregamos

un alumno en la base de datos, pero por un error no se registra correctamente su curso
asignado, la base de datos quedaría en un estado inconsistente. Para evitar este tipo de
problemas, las bases de datos utilizan transacciones que aseguran que todo el proceso se
realice de manera correcta o que, en caso de error, se deshaga automáticamente.

Las transacciones en SQLite se controlan con las siguientes instrucciones:

●​ BEGIN TRANSACTION: Esta instrucción indica el inicio de una transacción. A partir

de este punto, cualquier operación que se realice en la base de datos quedará en un
estado pendiente y no será aplicada de inmediato. Es una forma de decirle a la base
de datos que las siguientes operaciones forman parte de un mismo bloque y deben
tratarse como una unidad.
●​ COMMIT: Si todas las operaciones dentro de la transacción se ejecutan
correctamente, se usa esta instrucción para confirmar los cambios y hacerlos
permanentes en la base de datos. Hasta que no se ejecute COMMIT, los cambios no
son visibles para otros procesos ni quedan guardados de forma definitiva.
●​ ROLLBACK: Si en algún momento ocurre un error dentro de la transacción, esta
instrucción permite revertir todos los cambios realizados desde BEGIN
TRANSACTION, dejando la base de datos en el estado en que se encontraba antes
de iniciar la transacción. Esto es especialmente útil para evitar inconsistencias en los
datos y garantizar que no se almacene información incorrecta.
Ejemplo de transacción en SQLite

Supongamos que tenemos una base de datos con una tabla de alumnos y queremos
registrar a un estudiante asegurándonos de que se agregue correctamente a la base de
datos antes de confirmar los cambios.

import sqlite3

def registrar_alumno(nombre, edad, curso):

conexion = [Link]("[Link]")
cursor = [Link]()

try:
# Iniciar la transacción
[Link]("BEGIN TRANSACTION")

# Insertar el nuevo alumno en la base de datos

[Link]("INSERT INTO alumnos (nombre, edad, curso) VALUES
(?, ?, ?)", (nombre, edad, curso))

# Confirmar los cambios

[Link]()
print("Alumno registrado con éxito.")

except [Link] as e:
# Si ocurre un error, revertimos los cambios
[Link]()
print(f"Error al registrar al alumno: {e}")

finally:
[Link]()
Primero, se establece la conexión con la base de datos y se obtiene un cursor para ejecutar
consultas. Luego, se inicia una transacción con BEGIN TRANSACTION, lo que indica que
cualquier operación SQL posterior será parte de la transacción.

Dentro del bloque try, se ejecuta una consulta INSERT INTO para agregar el alumno a la
base de datos. Si la operación se realiza con éxito, el programa ejecuta commit(), lo que
confirma los cambios. Sin embargo, si ocurre un error en cualquier punto del proceso (por
ejemplo, si la tabla alumnos no existe o los datos ingresados son incorrectos), el programa
captura la excepción en el bloque except. En este caso, se ejecuta rollback(), lo que anula
cualquier modificación hecha durante la transacción y deja la base de datos en su estado
original.

El bloque finally es una parte opcional de la estructura try-except que se ejecuta siempre,
sin importar si ocurrió un error o no dentro del bloque try. Esto lo hace ideal para tareas que
deben realizarse sin excepción, como cerrar una conexión con la base de datos.

Cuando trabajamos con bases de datos, es muy importante cerrar la conexión después de
realizar una operación. Si no lo hacemos, podríamos dejar la base de datos en un estado
inconsistente o consumir recursos innecesariamente. El bloque finally garantiza que la
conexión se cierre incluso si ocurre un error en el proceso.

Por ejemplo, si intentamos insertar datos en la base y ocurre un problema con los valores
ingresados, el bloque except manejará el error, pero el finally se ejecutará de todas formas
para cerrar la conexión, asegurando que no queden conexiones abiertas.

Ejemplo de transacción con múltiples operaciones

Si queremos registrar a un alumno y asignarle un código de inscripción en una tabla aparte,

podemos realizar ambas operaciones dentro de una misma transacción para asegurarnos
de que se ejecuten en conjunto.

import sqlite3

def inscribir_alumno(nombre, edad, curso, codigo_inscripcion):

conexion = [Link]("[Link]")
cursor = [Link]()
 try:
# Iniciar transacción
[Link]("BEGIN TRANSACTION")

# Insertar al alumno en la tabla principal

[Link]("INSERT INTO alumnos (nombre, edad, curso) VALUES
(?, ?, ?)", (nombre, edad, curso))

# Insertar el código de inscripción en otra tabla relacionada

[Link]("INSERT INTO inscripciones (nombre, codigo)
VALUES (?, ?)", (nombre, codigo_inscripcion))

# Confirmar los cambios

[Link]()
print("Alumno inscripto con éxito.")

except [Link] as e:
# Si hay un error, revertimos ambas operaciones
[Link]()
print(f"Error al inscribir al alumno: {e}")

finally:
[Link]()

Este ejemplo introduce un concepto muy importante en la manipulación de bases de datos:

el uso de transacciones en múltiples tablas. A diferencia del código anterior, aquí no solo
insertamos datos en una tabla, sino que realizamos operaciones en dos tablas relacionadas
dentro de la misma transacción. Esto significa que ambas inserciones (en la tabla alumnos
y en la tabla inscripciones) se consideran parte de una única operación.

El bloque try comienza con BEGIN TRANSACTION, lo que indica que cualquier cambio
realizado en la base de datos después de esa línea quedará pendiente hasta que se
confirme con commit(). Si ambas inserciones (INSERT INTO alumnos y INSERT INTO
inscripciones) se ejecutan correctamente, la transacción se confirma y los datos quedan
almacenados en ambas tablas.
Sin embargo, si ocurre un error en cualquiera de las dos operaciones, el bloque except
entra en acción y ejecuta rollback(). Esto revierte todas las modificaciones realizadas
desde el inicio de la transacción, asegurando que la base de datos no quede en un estado
inconsistente.

El bloque finally se mantiene igual que en el ejemplo anterior, asegurando que la conexión
con la base de datos se cierre siempre, sin importar si la operación fue exitosa o no.

Este enfoque es casi indispensable cuando trabajamos con datos que dependen unos de
otros. Si solo se insertase al alumno pero fallara la inserción del código de inscripción,
tendríamos información incompleta en la base de datos. Gracias al uso de transacciones,
evitamos este problema garantizando que ambas inserciones ocurran juntas o ninguna de
ellas se registre.

Ejercicio Práctico
La jornada en TalentoLab transcurre con el habitual ritmo de trabajo cuando Mariana se
acerca a tu escritorio con su tablet en la mano.

"¡Felicitaciones! El cliente ha quedado muy conforme con la primera

versión del registro de productos. Pudieron cargar información y
recuperarla sin problemas. Pero ahora nos piden algunas mejoras
para garantizar que el sistema sea más seguro y fácil de
administrar."

Te muestra en pantalla un par de puntos que debemos agregar:

1.​ Validación de datos al registrar un producto: Actualmente, el sistema permite

agregar productos, pero no verifica si los datos ingresados son válidos. Es necesario
asegurarse de que el nombre del producto no esté vacío y que el precio sea un
número positivo antes de almacenarlo en la base de datos.
2.​ Eliminar un producto con confirmación: El cliente quiere evitar eliminaciones
accidentales. Por lo tanto, al eliminar un producto, el sistema debe solicitar una
confirmación antes de ejecutar la acción.

Desde su escritorio, Luis se suma a la conversación:

 Podrías aprovechar Colorama para mejorar la experiencia visual.
Por ejemplo, podrías resaltar los mensajes de advertencia en rojo,
las confirmaciones en verde, y la información general en azul.
Haría que la interfaz sea más clara y atractiva para el usuario.

Materiales y Recursos Adicionales:

Artículos:
Recursos Python: Inyección SQL en sqlite3
ITtrip: Uso y la importancia de las consultas parametrizadas en SQL

Videos:
DayiTecnologia: Creando un CRUD con SQLite3 y Python
LuisDev: Manejo de errores en Python

Preguntas para Reflexionar:

1.​ Cuando trabajamos con bases de datos en Python, ¿por qué es importante utilizar
parámetros en las consultas en lugar de concatenar directamente los valores
ingresados por el usuario?
2.​ En la implementación de transacciones con SQLite, ¿qué problema se podría
generar si olvidamos hacer un COMMIT después de una serie de modificaciones en
la base de datos?
3.​ El manejo de excepciones con try-except es clave para evitar errores inesperados.
¿Qué tipo de situaciones creés que podrían requerir un ROLLBACK dentro de un
bloque except?
4.​ Si tuvieras que optimizar un sistema CRUD para mejorar su seguridad y rendimiento,
¿qué técnicas o herramientas considerarías implementar más allá de lo aprendido
en esta clase?
Próximos Pasos:
A medida que avanzamos en nuestro camino en Python y bases de datos, es momento de
integrar todos los conocimientos adquiridos. En la próxima clase, vamos a llevar a cabo el
Proyecto Final, un desafío en el que pondrás en práctica cada uno de los conceptos
trabajados a lo largo del curso.

Será una oportunidad para desarrollar un sistema completo, aplicando desde estructuras
básicas hasta bases de datos y manejo de errores. También veremos buenas prácticas de
programación y cómo documentar tu código de manera profesional para que sea claro y
comprensible para cualquier persona que lo lea.

Durante este proceso, no solo consolidarás lo aprendido, sino que también te prepararás
para presentar tu trabajo de manera ordenada y efectiva, tal como lo harías en un entorno
profesional. ¡Este es el momento de demostrar todo lo que has aprendido!

Para aprovechar al máximo la próxima clase, repasá el código de tus proyectos anteriores,
asegurate de comprender cómo funcionan las operaciones CRUD con SQLite y pensá en
cómo podrías mejorar y optimizar tu código con lo que aprendiste hasta ahora.
Iniciación a la

Programación con
Python
Clase 15
Clase N° 15 | Trabajo Final
Integrador y repaso general
Temario:
●​ Integración de todos los conceptos aprendidos.
●​ Desarrollo de un proyecto completo.
●​ Mejores prácticas de programación.
●​ Documentación y presentación del proyecto.

Objetivos de la Clase
En esta última clase del curso, integrarás todo lo aprendido en un proyecto funcional que
servirá como modelo para tu Trabajo Final Integrador (TFI). Aplicarás los conocimientos
adquiridos sobre bases de datos SQLite3, funciones en Python, manejo de
excepciones, validaciones, seguridad, estructuras de datos y optimización del
código.

A través del desarrollo de un sistema CRUD completo para la gestión de alumnos,

consolidarás tus habilidades en la manipulación de datos, creando, consultando,
actualizando y eliminando información de una base de datos real. Además, reforzarás el uso
de buenas prácticas de programación, asegurando que el código sea modular, seguro y
eficiente.

También aprenderás a documentar correctamente tu código para facilitar su comprensión

y mantenimiento. Por último, te prepararemos para la presentación profesional de tu
proyecto, explorando estrategias para estructurar y explicar tu solución de manera clara y
efectiva.
El desafío final en TalentoLab 🧩

El ambiente en TechLab se siente distinto hoy. Después de semanas de aprendizaje y

práctica, Mariana reúne a todo el equipo para plantear el último desafío antes de la entrega
del proyecto final. Con una sonrisa, toma la palabra.

"—Llegó el momento de demostrar todo lo que aprendiste. Has trabajado

con bases de datos, manejo de errores, validaciones, funciones,
consultas SQL y muchas otras herramientas fundamentales. Ahora,
el cliente necesita una solución completa, bien estructurada y funcional.”

Diego, el desarrollador senior, interviene:

"— La mejor forma de prepararte para el Trabajo Final Integrador es

construir un sistema CRUD desde cero. Te propongo un desafío muy
parecido al proyecto real, pero con una temática distinta. Vamos a
desarrollar un sistema de gestión de alumnos que permita registrar,
consultar, actualizar y eliminar información en una base de datos.”

Mariana asiente y agrega:

"— Este ejercicio te ayudará a consolidar lo aprendido, te servirá como

base para organizar tu propio proyecto final. Quiero que prestes atención
a la estructura del código, las validaciones y la documentación. Todo lo
que hagamos hoy será clave para entregar un trabajo profesional.”
Diego finaliza la reunión con un consejo:

"— Te recomiendo que dividas el desarrollo en partes: primero, la

estructura de la base de datos, luego las funciones CRUD, y
finalmente la interfaz de interacción con el usuario. Aplica lo que
hemos visto sobre buenas prácticas, modularidad y seguridad.”

Creación de la base de datos y estructura de tablas

Antes de comenzar a programar, es fundamental definir cómo vamos a almacenar los datos
de los alumnos en nuestra base de datos. Usaremos SQLite3, que nos permitirá gestionar
la información de manera estructurada y eficiente dentro de nuestro programa.

Para esta aplicación, crearemos una base de datos llamada [Link], que almacenará
la información de los alumnos. La base de datos contará con una tabla principal llamada
alumnos, con los siguientes campos:

Campo Tipo de dato Descripción

INTEGER PRIMARY KEY

id Identificador único del alumno.
AUTOINCREMENT​

nombre TEXT NOT NULL​ Nombre del alumno. No puede estar vacío.

apellido TEXT NOT NULL​ Apellido del alumno. No puede estar vacío.

INTEGER CHECK Edad del alumno, con un rango de

edad
(edad >= 5 AND edad <= 120) validación.

curso TEXT NOT NULL Curso en el que está inscripto.

TEXT UNIQUE CHECK Dirección de correo electrónico válida y

email
(email LIKE '%@%') única.
Cada campo cumple un propósito específico. Usamos una clave primaria autoincremental
para el id, asegurándonos de que cada alumno tenga un identificador único. Aplicamos
restricciones como NOT NULL en campos que siempre deben tener un valor y validaciones
como CHECK en edad para asegurarnos de que sea un número válido. También nos
aseguramos de que el email tenga el formato correcto.

Ahora que definimos la estructura, vamos a crear la base de datos y la tabla utilizando
Python y SQLite3. Este código primero establece una conexión con [Link] y luego
crea la tabla alumnos con las restricciones que definimos previamente. La línea IF NOT
EXISTS en la sentencia CREATE TABLE evita errores si la tabla ya existe.

import sqlite3
from colorama import Fore, Style, init
# Inicializar colorama
init(autoreset=True)

# Conectar o crear la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

# Crear la tabla de alumnos

[Link]('''
CREATE TABLE IF NOT EXISTS alumnos (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
apellido TEXT NOT NULL,
edad INTEGER CHECK (edad >= 5 AND edad <= 120),
curso TEXT NOT NULL,
email TEXT UNIQUE CHECK (email LIKE '%@%')
)
''')

# Confirmar los cambios y cerrar la conexión

[Link]()
[Link]()

print("Base de datos y tabla de alumnos creadas con éxito.")

El código establece una conexión con SQLite3 y creando un objeto cursor, que nos permite
ejecutar comandos SQL dentro de la base de datos. Luego, con CREATE TABLE IF NOT
EXISTS alumnos, definimos nuestra tabla asegurándonos de que solo se cree si no existe
previamente.

Cada campo de la tabla tiene restricciones para garantizar la calidad de los

datos. Por ejemplo, NOT NULL evita que se inserten registros incompletos,
CHECK impide edades fuera del rango definido, y UNIQUE en email asegura
que no haya duplicados.

Finalmente, [Link]() guarda los cambios en la base de datos y

[Link]() cierra la conexión para liberar recursos.

Función para agregar alumnos a la base de datos

Ahora que tenemos nuestra base de datos y la tabla alumnos creada, el siguiente paso es
implementar la función que permitirá registrar nuevos alumnos. Esta función debe permitir la
entrada de datos del usuario, validarlos y almacenarlos en la base de datos de forma
segura.

Para ello, agregaremos validaciones en la entrada de datos y utilizaremos try-except para

manejar posibles errores, como intentos de insertar datos duplicados o en un formato
incorrecto.

def agregar_alumno():
"""
Solicita los datos del alumno y los guarda en la base de datos,
validando la entrada.
"""

# Conectar a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

try:
print([Link] + "\n=== Registrar Nuevo Alumno ===")
 # Solicitar datos con validaciones básicas
nombre = input("Ingresá el nombre del alumno:
").strip().capitalize()
apellido = input("Ingresá el apellido del alumno:
").strip().capitalize()
edad = input("Ingresá la edad del alumno: ").strip()
curso = input("Ingresá el curso del alumno: ").strip().upper()
email = input("Ingresá el email del alumno: ").strip().lower()

# Validaciones
if not nombre or not apellido or not curso:
print([Link] + "[ERROR] El nombre, apellido y curso no
pueden estar vacíos.")
return

if not [Link]() or not (5 <= int(edad) <= 120):

print([Link] + "[ERROR] La edad debe ser un número entre 5
y 120.")
return

if "@" not in email or " " in email:

print([Link] + "[ERROR] El email debe tener un formato
válido (ejemplo@[Link]).")
return

# Insertar en la base de datos

[Link]('''
INSERT INTO alumnos (nombre, apellido, edad, curso, email)
VALUES (?, ?, ?, ?, ?)
''', (nombre, apellido, int(edad), curso, email))

# Confirmar la transacción
[Link]()
print([Link] + f"[ÉXITO] Alumno {nombre} {apellido}
registrado correctamente.")
 except [Link]:
print([Link] + "[ERROR] El email ingresado ya está
registrado.")

except [Link] as e:
print([Link] + f"[ERROR] Error en la base de datos: {e}")

finally:
[Link]()

El código que acabás de ver permite registrar alumnos en la base de datos, asegurando que
los datos sean válidos y manejando posibles errores. Vamos a recorrerlo en detalle para
que puedas entender cada parte y cómo se conecta con lo que ya aprendiste.

El primer paso es la importación de los módulos necesarios. Se usa sqlite3 para interactuar
con la base de datos y Colorama para mejorar la visualización de mensajes en la terminal,
destacando los errores en rojo, mostrar información en cian y confirmar operaciones
exitosas en verde.

Luego, se define la función agregar_alumno(), que se encarga de solicitar los datos al

usuario, validarlos e insertarlos en la base de datos. Lo primero que hace esta función es
conectarse a la base de datos [Link] y obtener un cursor para ejecutar comandos
SQL.

Antes de realizar la inserción en la base de datos, el programa solicita al usuario cinco

datos: nombre, apellido, edad, curso y email. Se aplican transformaciones básicas en las
cadenas de texto, como convertir el nombre y el apellido a formato capitalizado,
asegurarse de que el curso se almacene en mayúsculas y que el email se almacene en
minúsculas. Esto ayuda a mantener los datos consistentes dentro de la base.

Una vez obtenidos los datos, el código realiza varias validaciones antes de insertarlos.
Primero, verifica que ni el nombre, ni el apellido, ni el curso estén vacíos, ya que son datos
obligatorios. Si alguno está vacío, se muestra un mensaje de error y se corta la ejecución
con un return. Luego, revisa que la edad sea un número entero entre 5 y 120 años, ya que
no tendría sentido registrar un alumno con una edad fuera de esos rangos. También valida
que el email contenga un @ y que no tenga espacios en blanco, asegurando que el formato
sea correcto. Si alguna de estas validaciones falla, el programa no intenta guardar los datos
y muestra un mensaje de error al usuario.
Cuando todos los datos son correctos, se ejecuta la consulta SQL INSERT INTO alumnos
para agregar el nuevo registro a la base de datos. Acá es importante notar que se usa una
consulta parametrizada, representando los valores con signos de interrogación (?). Esto es
clave porque previene ataques de inyección SQL y asegura que los datos sean insertados
de manera segura.

Después de ejecutar la consulta, se usa commit() para confirmar los cambios y guardar el
nuevo registro en la base de datos. Si todo sale bien, se muestra un mensaje en verde
confirmando que el alumno fue agregado con éxito.

En el bloque except, se manejan posibles errores que pueden surgir durante la ejecución.
Si se intenta registrar un email que ya está en uso, el programa detecta la violación de una
restricción de unicidad y muestra un mensaje de error específico. Si ocurre otro problema
con SQLite, el mensaje de error de la base de datos se captura y se muestra al usuario,
para que pueda entender qué sucedió.

Por último, en el bloque finally, el código se asegura de cerrar la conexión con la base
de datos, independientemente de si la operación fue exitosa o falló. Esto es importante
porque mantener conexiones abiertas innecesariamente puede generar problemas en el
sistema.

Consultar y modificar datos

Como ya sabemos, en cualquier sistema de gestión es tan importante registrar información
como poder acceder a ella y modificarla cuando sea necesario. Vamos a trabajar en dos
funciones clave: una para consultar alumnos y otra para eliminarlos de la base de datos.

Comenzaremos con la consulta. Esta funcionalidad permitirá ver los datos almacenados y
realizar búsquedas específicas. Implementaremos una opción que muestre todos los
alumnos y otra que permita filtrar por nombre. Además, aplicaremos formato con
Colorama para mejorar la experiencia visual.

Luego, pasaremos a la eliminación de alumnos. Antes de eliminar un registro, es

fundamental asegurarnos de que el usuario realmente desea hacerlo. Para eso, pediremos
una confirmación antes de ejecutar la acción. Además, como los alumnos pueden estar
relacionados con otras tablas en la base de datos, utilizaremos transacciones para
garantizar que cualquier error en la operación no deje la base en un estado inconsistente.
Vamos a implementar estas funciones asegurándonos de utilizar:

●​ Consultas parametrizadas para evitar inyecciones SQL.

●​ Manejo de errores con try-except para capturar problemas como intentos de
eliminar un alumno inexistente.
●​ Colorama para destacar la información y mejorar la legibilidad de la terminal.

Comencemos por la función consultar_alumno(), que nos permite listar todos los alumnos
o buscar por nombre.

def consultar_alumnos():
"""
Permite consultar la lista de alumnos registrados en la base de
datos.
Ofrece la opción de ver todos los alumnos o buscar por nombre.
"""

# Conectar a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

try:
print([Link] + "\n=== Consultar Alumnos ===")
print("1. Mostrar todos los alumnos")
print("2. Buscar alumno por nombre")
opcion = input("Seleccioná una opción: ").strip()

if opcion == "1":
# Mostrar todos los alumnos
[Link]("SELECT id, nombre, apellido, edad, curso,
email FROM alumnos")
alumnos = [Link]()

if not alumnos:
print([Link] + "[INFO] No hay alumnos registrados
en la base de datos.")
return
 print([Link] + "\n=== Lista de Alumnos ===")
for alumno in alumnos:
print([Link] + f"ID: {alumno[0]}, Nombre:
{alumno[1]} {alumno[2]}, Edad: {alumno[3]}, Curso: {alumno[4]}, Email:
{alumno[5]}")

elif opcion == "2":

# Buscar alumno por nombre
nombre_busqueda = input("Ingresá el nombre del alumno a
buscar: ").strip().capitalize()

if not nombre_busqueda:
print([Link] + "[ERROR] El nombre no puede estar
vacío.")
return

[Link]("SELECT id, nombre, apellido, edad, curso,

email FROM alumnos WHERE nombre = ?", (nombre_busqueda,))
alumnos = [Link]()

if not alumnos:
print([Link] + "[INFO] No se encontraron alumnos
con ese nombre.")
return

print([Link] + f"\n=== Alumnos con el nombre

'{nombre_busqueda}' ===")
for alumno in alumnos:
print([Link] + f"ID: {alumno[0]}, Nombre:
{alumno[1]} {alumno[2]}, Edad: {alumno[3]}, Curso: {alumno[4]}, Email:
{alumno[5]}")

else:
print([Link] + "[ERROR] Opción no válida.")
 except [Link] as e:
print([Link] + f"[ERROR] Ocurrió un problema al consultar la
base de datos: {e}")

finally:
[Link]()

Esta función permite consultar alumnos en la base de datos mediante dos opciones: listar
todos los alumnos registrados o buscar uno en particular por su nombre.

Al iniciar, se establece la conexión con la base de datos [Link] y se muestra un menú

con las dos opciones. Si el usuario elige la primera opción, se ejecuta una consulta SQL
SELECT * FROM alumnos, recuperando todos los registros de la tabla y mostrándolos en
la terminal con un formato claro.

Si se opta por la segunda opción, se solicita que se ingrese un nombre para buscar. Antes
de realizar la consulta, el programa verifica que el nombre no esté vacío. Luego, se ejecuta
una consulta parametrizada SELECT * FROM alumnos WHERE nombre = ? para
recuperar sólo aquellos registros que coincidan con el nombre ingresado.

En ambos casos, si la base de datos no contiene registros o la búsqueda no arroja

resultados, el programa muestra un mensaje informativo en color amarillo. Además, si
ocurre un error en la consulta, se captura la excepción y se muestra un mensaje de error en
color rojo. Para terminar, la conexión con la base de datos se cierra dentro del bloque
finally, asegurando que no quede abierta después de la ejecución.

La función eliminar_alumno() implementa una confirmación antes de proceder con la

eliminación. Se ha diseñado para que el usuario primero busque al alumno por su ID y luego
confirme la eliminación antes de ejecutarla. Recordá que esto es sólo un ejemplo, y que vos
podés, en tu TFI, implementar otras funcionalidades, o estas mismas pero de otra manera.

def eliminar_alumno():
"""
Permite eliminar un alumno de la base de datos, asegurando que el
usuario confirme la acción antes de proceder.
 """

# Conectar a la base de datos

conexion = [Link]("[Link]")
cursor = [Link]()

try:
print([Link] + "\n=== Eliminar Alumno ===")

# Mostrar todos los alumnos disponibles para que el usuario

pueda elegir
[Link]("SELECT id, nombre, apellido, curso FROM
alumnos")
alumnos = [Link]()

if not alumnos:
print([Link] + "[INFO] No hay alumnos registrados en la
base de datos.")
return

print([Link] + "\n=== Lista de Alumnos ===")

for alumno in alumnos:
print([Link] + f"ID: {alumno[0]}, Nombre: {alumno[1]}
{alumno[2]}, Curso: {alumno[3]}")

# Solicitar el ID del alumno a eliminar

id_alumno = input("\nIngresá el ID del alumno que querés
eliminar: ").strip()

if not id_alumno.isdigit():
print([Link] + "[ERROR] El ID ingresado no es válido.")
return

id_alumno = int(id_alumno)

# Verificar si el alumno existe en la base de datos

 [Link]("SELECT nombre, apellido FROM alumnos WHERE id =
?", (id_alumno,))
alumno = [Link]()

if not alumno:
print([Link] + "[INFO] No se encontró un alumno con ese
ID.")
return

# Confirmación antes de eliminar

confirmacion = input([Link] + f"¿Estás seguro de que querés
eliminar a {alumno[0]} {alumno[1]}? (S/N): ").strip().lower()

if confirmacion != "s":
print([Link] + "[CANCELADO] La eliminación ha sido
cancelada.")
return

# Eliminar al alumno
[Link]("DELETE FROM alumnos WHERE id = ?", (id_alumno,))
[Link]()
print([Link] + f"[ÉXITO] Alumno {alumno[0]} {alumno[1]}
eliminado correctamente.")

except [Link] as e:
print([Link] + f"[ERROR] Ocurrió un problema al eliminar el
alumno: {e}")

finally:
[Link]()

La función comienza estableciendo una conexión con la base de datos [Link]. Luego,
recupera y muestra todos los alumnos registrados para que el usuario pueda identificar cuál
desea eliminar. Se muestran los ID, nombres y cursos de los alumnos disponibles.
A continuación, el usuario debe ingresar el ID del alumno a eliminar. Se verifica que el ID
sea un número válido y que exista en la base de datos. Si el alumno no es encontrado, se
muestra un mensaje informativo.

Si el alumno existe, el sistema solicita una confirmación antes de proceder con la

eliminación. Se le pide al usuario que ingrese "S" para confirmar o cualquier otra tecla para
cancelar la operación. Si se confirma, se ejecuta la sentencia DELETE FROM alumnos
WHERE id = ?, eliminando el registro de la base de datos. Luego, el sistema confirma que
la operación fue exitosa.

Si ocurre un error durante el proceso, como un problema en la base de datos, se captura y

se muestra un mensaje de error en rojo. La conexión con la base de datos se cierra
correctamente al finalizar la función.

Menú principal
Ahora, vamos a escribir el código del menú principal. Este menú permite elegir entre
agregar, consultar y eliminar alumnos, asegurando una interacción intuitiva y clara con las
funciones que escribimos antes.

def menu():
"""
Muestra el menú principal y permite seleccionar las acciones a
realizar en la base de datos.
"""

while True:
print([Link] + "\n=== Menú de Gestión de Alumnos ===")
print([Link] + "1. Registrar nuevo alumno")
print([Link] + "2. Consultar alumnos")
print([Link] + "3. Eliminar un alumno")
print([Link] + "4. Salir")

opcion = input([Link] + "Seleccioná una opción: ").strip()

if opcion == "1":
 agregar_alumno()
elif opcion == "2":
consultar_alumnos()
elif opcion == "3":
eliminar_alumno()
elif opcion == "4":
print([Link] + "\nGracias por usar el sistema. ¡Hasta
luego!")
break
else:
print([Link] + "[ERROR] Opción no válida. Intentá
nuevamente.")

# Ejecutar el menú
menu()

Este es la última pieza de nuestro proyecto. El menú principal es el punto de entrada del
programa y permite al usuario navegar entre las diferentes opciones disponibles. Desde
esta interfaz, podés registrar nuevos alumnos, consultar la base de datos, eliminar registros
o salir del programa.

Podes probarlo poniendo en un mismo archivo .py todo el código que hemos
visto, cuidando que las funciones estén al principio, y que se importen los
módulos antes de usarlas. La última función a incluir es menu().

Este programa permite registrar, consultar y eliminar alumnos, asegurando que la

información ingresada sea válida y que las acciones realizadas sean claras para el usuario.

El uso de try-except garantiza que los errores en la base de datos sean manejados
adecuadamente, evitando fallos inesperados y proporcionando mensajes informativos en
caso de problemas. Colorama se emplea para mejorar la visualización de los mensajes en
la terminal, destacando errores en rojo, información en amarillo y confirmaciones en verde,
lo que facilita la comprensión de las operaciones realizadas.
Buenas prácticas y estructura del código
Cuando desarrollás un proyecto en Python, especialmente uno que involucra bases de
datos y múltiples funciones, es fundamental que estructures el código de manera clara y
ordenada. Un código bien organizado no sólo facilita su comprensión y mantenimiento, sino
que también te permite realizar mejoras y agregar nuevas funcionalidades sin dificultad.

Una de las mejores prácticas es dividir el código en archivos según su función. En lugar de
tener todo en un solo archivo, puedes separar la lógica del programa en módulos
específicos. Por ejemplo, un archivo puede contener las funciones relacionadas con la base
de datos, otro las funciones de interacción con el usuario y un tercero el menú principal.
Esto ayuda a mantener cada parte del sistema bien delimitada, facilitando la depuración y el
trabajo en equipo.
Otro aspecto clave es la legibilidad del código. Elegir nombres de variables y funciones
descriptivos permite que tu código sea comprensible incluso para los demás. Usar
convenciones como snake_case para los nombres de funciones y variables, así como
mantener una correcta indentación, hace que el código sea más intuitivo. También es
recomendable que evites redundancias y reutilices funciones en lugar de repetir líneas de
código similares en diferentes partes del programa.

El manejo adecuado de errores es otro punto importante. Utilizar try-except para gestionar
posibles fallos, como errores en la conexión a la base de datos o entradas incorrectas del
usuario, mejora la estabilidad del sistema. Incluir mensajes de error claros y útiles evita que
el usuario se frustre y proporciona información útil para corregir problemas.

Además, la implementación de comentarios en el código contribuye a su comprensión y

mantenimiento. Agregar notas breves explicando qué hace cada función o bloque de código
ayuda a quienes trabajan con el programa, incluyendo al propio desarrollador si necesita
modificarlo en el futuro. Escribir documentación clara y concisa garantiza que el proyecto
pueda ser utilizado y ampliado sin dificultades.

Si se siguen estas prácticas, el desarrollo de aplicaciones en Python será mucho más

eficiente, permitiendo que los programas sean fáciles de entender, mantener y mejorar a lo
largo del tiempo.
Presentación del proyecto
El Trabajo Final Integrador representa la culminación de todo lo aprendido en el curso.
Más allá de la implementación técnica, es fundamental que el proyecto esté bien
estructurado, correctamente documentado y presentado de una manera profesional. Esto no
sólo facilita su comprensión y evaluación, sino que también te prepara para el mundo
laboral, donde la claridad y la organización son tan importantes como el código mismo.

Organización del código:

Un código bien estructurado es fácil de leer, mantener y modificar. Para lograr esto, es
recomendable dividir el código en funciones que realicen tareas específicas, evitando
redundancias y asegurando una lógica clara. Además, la utilización de nombres descriptivos
en variables y funciones mejora la comprensión del programa.

En el caso del TFI, tu aplicación podría estar organizada en módulos que se encarguen de
la conexión con la base de datos, la manipulación de los datos y la interfaz con el usuario.
Esto facilitaría su mantenimiento y -eventualmente- permite reutilizar funciones en distintos
puntos del programa.

Uso de comentarios y documentación:

Un código sin comentarios es como un libro sin índice: difícil de entender y navegar. Es
importante incluir comentarios explicativos en las secciones importantes del código,
indicando la finalidad de cada función y los pasos más relevantes dentro de ellas. Sin
embargo, los comentarios deben ser concisos y aportar valor, evitando redundancias.

Además de los comentarios en el código, se debe incluir un archivo de documentación,

comúnmente llamado [Link], en el que se expliquen aspectos fundamentales del
proyecto. Este archivo debe incluir:

●​ Breve descripción del propósito de la aplicación.

●​ Instrucciones para la instalación y ejecución.
●​ Explicación de las funcionalidades implementadas.
●​ Cualquier requisito adicional para su correcto funcionamiento.

Para complementar la documentación, es recomendable incluir ejemplos de uso con

capturas de pantalla o fragmentos de salida en la terminal. Esto ayuda a quienes revisen el
código a entender rápidamente su funcionalidad sin necesidad de ejecutarlo. Por ejemplo,
se pueden mostrar ejemplos de cómo se registran nuevos productos, cómo se buscan
elementos en la base de datos y cómo se genera el reporte de bajo stock.
Uso de buenas prácticas

Además de modularizar el código, documentarlo correctamente y proporcionar ejemplos, es

importante seguir buenas prácticas generales, tales como:

●​ Manejo de excepciones con try-except para evitar fallos inesperados.

●​ Uso de Colorama para mejorar la experiencia del usuario en la terminal.
●​ Validaciones de datos antes de ingresarlos en la base de datos para evitar
inconsistencias.
●​ Implementación de un menú interactivo claro, con mensajes informativos y opciones
intuitivas.

Siguiendo estos principios, el proyecto no solo cumplirá con los requisitos técnicos, sino que
también será más robusto, fácil de entender y con un nivel de calidad que refleje el esfuerzo
y aprendizaje adquirido a lo largo del curso.

Ejercicio Práctico
El día en TalentoLab está lleno de actividad. Mariana te llama a su oficina para una reunión
breve.

"Ahora que ya dominás SQLite, quiero que hagas algo importante

antes de comenzar con tu TFI. ​
Tu misión es escribir el programa que cree el archivo de la base de
datos y la tabla que contendrá los datos. Esto te permitirá tener la
estructura lista para cuando empieces a desarrollar las
funcionalidades del TFI. Asegurate de que los campos sean los
adecuados y de establecer correctamente las claves y
restricciones."

Con el objetivo claro en mente, te dirigís a tu computadora, listo para escribir el primer
código que dará vida a tu TFI.

Materiales y Recursos Adicionales:

Artículos:
Digital Talent Agency: 10 buenas prácticas para programadores
PY4E: Bases de datos y SQL
Videos:
DayiTecnologia: Creando un CRUD con SQLite3 y Python
LuisDev: Manejo de errores en Python

Preguntas para Reflexionar:

1.​ ¿Por qué es importante validar los datos antes de insertarlos en la base de datos?
¿Qué consecuencias podría tener no hacerlo?
2.​ En un proyecto real, ¿qué ventajas te ofrece modularizar tu código con funciones en
lugar de escribir toda la lógica en un solo bloque de código?
3.​ Pensando en tu TFI, ¿qué funcionalidades planeás implementar primero y por qué?
¿Cómo podrías organizar tu trabajo para desarrollar el sistema de manera eficiente?
4.​ ¿Cómo podrías mejorar la experiencia del usuario en la interacción con tu sistema?
¿Qué elementos visuales o mensajes podrían hacer que la aplicación sea más clara
y fácil de usar?

Próximos Pasos:
Después de todo el camino recorrido, llegamos a la etapa final del curso. Ya tenés todas las
herramientas necesarias para desarrollar tu Trabajo Final Integrador, aplicando todo lo
aprendido sobre estructuras de datos, bases de datos, validaciones, manejo de errores y
buenas prácticas de programación.

En la próxima clase, vas a tener la oportunidad de presentar tu proyecto, compartir tu

experiencia de desarrollo y recibir retroalimentación sobre tu trabajo. Será un espacio para
reflexionar sobre los desafíos que enfrentaste, las decisiones que tomaste en tu código y
cómo podrías seguir mejorando tu sistema.

También haremos un repaso de los objetivos del curso, destacando los conceptos
fundamentales que adquiriste y su aplicación en proyectos reales. Además, te brindaremos
orientación sobre cómo seguir aprendiendo y qué recursos adicionales podés explorar para
profundizar tus conocimientos en Python y desarrollo de software.

Esta última clase no sólo marcará el cierre del curso, sino que será una instancia clave
para consolidar lo aprendido y proyectar tus próximos pasos como programador. ¡Nos

🚀
vemos en la próxima clase para celebrar tu progreso y compartir experiencias con el resto
del equipo!
Clase N° 16 | Presentación del TFI
y cierre del curso
Temario:
●​ Presentación de los proyectos realizados.
●​ Retroalimentación y discusión.
●​ Repaso de los objetivos del curso.
●​ Orientación sobre próximos pasos y recursos adicionales.

Objetivos de la Clase
Llegamos a la última clase del curso, un espacio dedicado a cerrar el ciclo de aprendizaje,
reflexionar sobre lo que hemos aprendido y compartir los proyectos que cada estudiante ha
desarrollado.

El objetivo principal de esta clase es que los participantes que lo deseen puedan presentar
su Trabajo Final Integrador, demostrando cómo aplicaron los conceptos y herramientas
vistas a lo largo del curso. A través de esta presentación, se fomentará la comunicación
técnica, el pensamiento crítico y la capacidad de explicar decisiones de diseño y desarrollo.
También se generará un espacio de retroalimentación constructiva, donde tanto los
docentes como los compañeros podrán aportar comentarios y sugerencias sobre los
proyectos. Esto permitirá identificar oportunidades de mejora y reconocer logros individuales
y grupales.

Además de la presentación de proyectos, se realizará un repaso general del curso,

destacando los conceptos fundamentales adquiridos y cómo estos se pueden seguir
utilizando y profundizando en futuros proyectos. Se brindarán recomendaciones y recursos
adicionales para seguir explorando el mundo de la programación con Python.

Finalmente, se abrirá un espacio de cierre y despedida, en el que se celebrarán los logros

alcanzados, se reconocerá el esfuerzo de cada estudiante y se alentará a continuar
aprendiendo y creciendo en el ámbito del desarrollo de software.
Fundamentos de la programación con Python.
El curso comenzó con la introducción a los conceptos esenciales de la programación en
Python, sentando las bases para comprender cómo funcionan los programas y cómo
estructurar el código de manera clara y eficiente. Se trabajó con variables y tipos de datos,
entendiendo la diferencia entre valores numéricos, cadenas de texto y estructuras más
complejas. También se exploraron los operadores matemáticos y lógicos, fundamentales
para la manipulación de datos y la toma de decisiones dentro de un programa.

Uno de los primeros desafíos fue aprender a interactuar con el usuario mediante la entrada
y salida de datos. Se trabajó con la función input() para recibir información y con print()
para mostrar resultados en pantalla, incorporando desde el inicio la importancia de escribir
código comprensible y funcional.

A medida que se avanzaba, se introdujeron las estructuras de control, que permitieron

tomar decisiones dentro del programa con if, elif y else, y ejecutar tareas repetitivas con
while y for. Estas herramientas resultaron clave para estructurar programas dinámicos,
capaces de responder a diferentes situaciones y automatizar procesos sin necesidad de
escribir instrucciones repetitivas.

La combinación de estos elementos fue el primer paso hacia la construcción de programas

más complejos. Al dominar estos fundamentos, cada estudiante adquirió la capacidad de
resolver problemas básicos utilizando Python, preparando el camino para abordar
estructuras de datos más avanzadas y la organización del código en proyectos reales.

Estructuras de datos y manipulación

A medida que se profundizó en la programación con Python, se introdujeron las estructuras
de datos, herramientas fundamentales para organizar y manipular la información de manera
eficiente. Se comenzó con las listas, que permiten almacenar múltiples valores en una sola
variable y acceder a ellos mediante índices. Se exploraron métodos como append(),
remove() y sort(), comprendiendo cómo modificar, ordenar y gestionar los elementos dentro
de una lista.

Luego se incorporaron las tuplas, similares a las listas pero con la diferencia clave de que
son inmutables. Este concepto ayudó a entender cuándo es conveniente utilizar estructuras
de datos que no se pueden modificar, asegurando la integridad de la información en ciertos
contextos.

Un paso fundamental fue la introducción de los diccionarios, estructuras que permiten

almacenar datos en pares clave-valor. Se comprendió cómo agregar, modificar y acceder a
los elementos de un diccionario, reconociendo su utilidad para organizar información de
manera más estructurada y facilitar su acceso sin necesidad de recorrer grandes volúmenes
de datos.
Finalmente, para reforzar estos conceptos, se trabajó en la iteración sobre estas estructuras
mediante los bucles for y while. Se experimentó con la manipulación de listas y diccionarios
dentro de ciclos, optimizando la manera en que se procesan grandes cantidades de datos
en un programa. Este aprendizaje resultó clave para desarrollar sistemas más complejos,
como los que se aplicarían más adelante en la gestión de bases de datos.

Modularización y funciones
A medida que los programas fueron creciendo en complejidad, se hizo evidente la
necesidad de organizar mejor el código para hacerlo más claro, reutilizable y fácil de
mantener. En este contexto, se introdujeron las funciones definidas por el usuario,
permitiendo encapsular bloques de código en unidades independientes que pueden ser
llamadas en distintos momentos sin necesidad de reescribirlas.

Se aprendió a definir funciones con y sin parámetros, comprendiendo cómo enviar

información a una función y recibir un resultado a partir de su ejecución. También se exploró
el uso de return, que permite que una función devuelva un valor específico para ser utilizado
en otras partes del programa. Se enfatizó la importancia de la modularización como una
estrategia clave para desarrollar software estructurado y eficiente.

Otro concepto fundamental fue el alcance de las variables dentro y fuera de las funciones.
Se explicó la diferencia entre variables locales y globales, destacando las mejores prácticas
para evitar conflictos y mejorar la legibilidad del código. Además, se trabajó en la
documentación de funciones mediante docstrings, asegurando que cada fragmento de
código estuviera correctamente explicado y pudiera ser comprendido tanto por su autor
como por otras personas que lo utilizaran en el futuro.

Finalmente, se vio la importancia de dividir un programa en módulos, permitiendo importar

funciones desde otros archivos y organizando el código en unidades más manejables. Esta
práctica no solo simplifica el desarrollo, sino que también es un estándar en la industria para
mantener proyectos escalables y bien estructurados.

Persistencia de datos y manejo de errores.

Guardar y recuperar información de manera permanente es una necesidad fundamental en
cualquier sistema informático. Para abordar este desafío, se introdujo el concepto de
persistencia de datos y se exploraron las distintas formas en que Python permite almacenar
información más allá de la ejecución del programa.

Primero, se trabajó con archivos de texto, aprendiendo a leer y escribir datos en archivos
mediante el uso de open(), read(), write() y close(). Se explicó cómo abrir archivos en
diferentes modos, como lectura ("r"), escritura ("w") y adición ("a"), permitiendo a los
programas conservar información entre distintas ejecuciones. Se enfatizó la importancia de
cerrar los archivos correctamente y se mostró el uso de with open(), una alternativa más
segura para gestionar archivos sin riesgo de errores por omisión de cierre.
El manejo de excepciones fue otro tema clave dentro de esta unidad. Se introdujo la
estructura try-except como una herramienta fundamental para prevenir fallos inesperados
en la ejecución de un programa. Se trabajó con distintos tipos de errores, como
FileNotFoundError, ValueError y ZeroDivisionError, comprendiendo cómo capturar y
manejar cada uno para mejorar la estabilidad del código. Además, se exploró el uso de
finally, que garantiza la ejecución de ciertos bloques de código, como el cierre de archivos
o la desconexión de bases de datos, independientemente de si ocurrió o no un error.

A medida que el curso avanzó, se presentaron bases de datos como una solución más
eficiente y estructurada para almacenar grandes volúmenes de información. Se realizó una
introducción a SQLite, un sistema de gestión de bases de datos ligero y de fácil integración
con Python. Se aprendió a crear bases de datos y tablas, definir estructuras de datos y
realizar operaciones básicas con SQL, como SELECT, INSERT, UPDATE y DELETE.

Para reforzar la seguridad y prevenir ataques, se abordaron las inyecciones SQL y se

explicó cómo usar parámetros en consultas para evitar vulnerabilidades. También se trabajó
con transacciones en bases de datos, asegurando que las operaciones se ejecuten de
forma segura mediante el uso de BEGIN TRANSACTION, COMMIT y ROLLBACK, lo que
garantiza la consistencia de los datos ante posibles errores o interrupciones inesperadas.

Desarrollo de aplicaciones con bases de datos

El uso de bases de datos permitió consolidar los conocimientos adquiridos previamente,
dando lugar a la construcción de aplicaciones más robustas y funcionales. Se trabajó con
SQLite, un sistema de bases de datos liviano que se integra directamente con Python sin
necesidad de configuraciones adicionales.

El primer paso fue aprender a establecer una conexión con la base de datos y definir una
estructura de almacenamiento mediante la creación de tablas. Se exploró el uso de la
sentencia CREATE TABLE, permitiendo definir los distintos tipos de datos y restricciones
para cada campo, como claves primarias (PRIMARY KEY), valores únicos (UNIQUE) y
restricciones de no nulo (NOT NULL).

Una vez establecida la estructura, se avanzó en la implementación de las operaciones

CRUD (Create, Read, Update y Delete), fundamentales para la manipulación de datos en
cualquier aplicación. Se desarrollaron funciones que permitieron insertar registros en la
base de datos (INSERT), consultar información almacenada (SELECT), actualizar registros
(UPDATE) y eliminarlos (DELETE). Se puso especial énfasis en el uso de parámetros en
consultas SQL, evitando la construcción manual de cadenas y minimizando riesgos de
inyección de código malicioso.
A medida que el curso avanzó, se integraron herramientas adicionales, como Colorama,
para mejorar la interfaz del usuario en la terminal y facilitar la visualización de mensajes de
error o confirmación en distintos colores. Esto contribuyó a una experiencia más intuitiva y
organizada dentro del sistema.

Con estos conocimientos, los alumnos pudieron aplicar bases de datos en sus proyectos,
estructurando la información de manera eficiente y asegurando la integridad de los datos
almacenados. Este aprendizaje resultó fundamental para la preparación del Trabajo Final
Integrador, en el que cada estudiante desarrolló su propia aplicación completa.

Trabajo Final Integrador: Aplicación de los

conocimientos
El cierre del curso estuvo marcado por el desarrollo del Trabajo Final Integrador (TFI), un
proyecto diseñado para aplicar de manera práctica todos los conceptos adquiridos a lo largo
de las clases. Este desafío permitió consolidar conocimientos sobre estructuras de datos,
control de flujo, manipulación de archivos y bases de datos, asegurando que cada
estudiante pudiera desarrollar una aplicación funcional basada en Python.

El proyecto consistió en la creación de un sistema de gestión que permitiera a los usuarios

registrar, consultar, modificar y eliminar datos de manera eficiente. Para ello, se
estructuró un CRUD completo utilizando bases de datos SQLite, con validaciones estrictas
y un flujo de trabajo optimizado para asegurar la integridad de los datos almacenados. Se
puso especial énfasis en el uso de transacciones, previniendo inconsistencias en la base
de datos y asegurando que cada operación se ejecutara de manera correcta o fuera
revertida en caso de error.

Uno de los aspectos fundamentales del TFI fue la implementación de validaciones en la

entrada de datos, asegurando que los valores ingresados fueran correctos y consistentes.
Se utilizó try-except para manejar excepciones y se integró Colorama para proporcionar
una interfaz clara e intuitiva en la terminal, diferenciando mensajes de error, advertencia y
confirmación con colores específicos.

A lo largo del desarrollo del proyecto, se incentivó la aplicación de buenas prácticas de

programación, promoviendo la modularización del código mediante funciones reutilizables.
Además, se destacó la importancia de mantener una estructura clara y bien documentada,
asegurando que el código fuera fácil de leer y mantener.

La última etapa del TFI consistió en la presentación del proyecto, brindando a cada
estudiante la oportunidad de evaluar su trabajo y compartir su experiencia de desarrollo. Se
ofreció una instancia de retroalimentación, permitiendo recibir sugerencias y comentarios
que pudieran contribuir a mejorar futuras implementaciones. Esta instancia también sirvió
para reforzar la confianza en las habilidades adquiridas, demostrando la capacidad de cada
alumno para abordar proyectos de programación completos.

El Trabajo Final Integrador no solo fue un ejercicio de evaluación, sino también un primer
paso hacia la aplicación real de Python en la resolución de problemas cotidianos. Con este
proyecto, los alumnos adquirieron una base sólida para seguir explorando el desarrollo de
software y continuar su aprendizaje en áreas más avanzadas.

Conclusión y cierre del curso

A lo largo de este curso, los estudiantes han recorrido un camino progresivo en el
aprendizaje de Python, comenzando con los fundamentos de la programación hasta llegar a
la integración de bases de datos y el desarrollo de aplicaciones completas. Cada clase fue
diseñada para introducir nuevos conceptos de manera gradual, asegurando que cada tema
fuera comprendido y aplicado en ejercicios prácticos, consolidando así un aprendizaje
significativo.

El curso no solo se enfocó en el lenguaje Python como herramienta de desarrollo, sino

también en la lógica de programación, el diseño estructurado y las buenas prácticas que
garantizan la escritura de código claro, eficiente y mantenible. Desde el uso de estructuras
condicionales y bucles hasta la implementación de funciones y módulos, cada elemento
aprendido se convirtió en una pieza clave para el desarrollo de programas más robustos y
organizados.

La incorporación de bases de datos y la persistencia de datos permitió a los estudiantes dar

un salto en la funcionalidad de sus aplicaciones, pasando de programas efímeros que
operan solo en memoria a sistemas capaces de almacenar información de manera
permanente. El uso de SQLite como base de datos integrada en Python representó una
solución accesible y poderosa para gestionar información de forma estructurada, y su
combinación con el control de errores y el manejo de excepciones brindó a los estudiantes
herramientas para escribir código más seguro y confiable.

El Trabajo Final Integrador marcó el punto culminante del curso, permitiendo a cada
estudiante demostrar su capacidad para aplicar lo aprendido en un proyecto real. Más allá
de la implementación técnica, el proceso de desarrollo les permitió enfrentar desafíos, tomar
decisiones de diseño y experimentar el ciclo completo de construcción de una aplicación. La
presentación del proyecto y la retroalimentación recibida fueron parte fundamental de la
experiencia, reforzando la importancia de la documentación, la organización del código y la
comunicación efectiva de los resultados.

Este curso no solo ha sido una introducción a Python, sino también una invitación a
continuar explorando el mundo de la programación. Cada herramienta aprendida puede ser
la base para seguir avanzando en áreas como el desarrollo web, la automatización, la
inteligencia artificial o la ciencia de datos. El aprendizaje no se detiene aquí, y con una base
sólida, cada estudiante tiene la posibilidad de seguir perfeccionando sus habilidades y
aplicarlas en nuevos desafíos.

Con esta última clase, cerramos una etapa, pero dejamos abierta la puerta a nuevas
oportunidades de aprendizaje y crecimiento en la programación. ¡Felicitaciones a cada
estudiante por haber llegado hasta aquí y por todo el esfuerzo invertido en su desarrollo
como programadores y programadoras!

Materiales y Recursos Adicionales:

Enlace:
TalentoTech: Construí tu futuro en tecnología y potenciá tu carrera con nuestros cursos

Preguntas para Reflexionar:

1.​ ¿Cómo ha cambiado tu comprensión de la programación desde el inicio del

curso hasta ahora?​
Pensá en lo que sabías al comenzar y en las habilidades que desarrollaste durante
cada clase.
2.​ Si tuvieras que explicarle a alguien que no conoce Python, ¿cómo describirías
su estructura y principales características?​
Reflexioná sobre qué hace a Python un lenguaje accesible y poderoso para
desarrollar software.
3.​ ¿Cuál de los temas aprendidos te resultó más desafiante y cómo lograste
superarlo?​
Recordá algún concepto o práctica que al principio te pareció difícil, pero que luego
comprendiste con la práctica.
4.​ ¿Cómo creés que el uso de funciones y módulos mejoró la calidad de tu
código?​
Evaluá el impacto de dividir tu código en partes reutilizables y organizadas.
5.​ ¿Por qué la persistencia de datos es una característica clave en el desarrollo
de aplicaciones?​
Pensá en la importancia de guardar información más allá de la ejecución del
programa y cómo lo implementaste con archivos y bases de datos.
6.​ ¿Qué aprendiste sobre la seguridad en la programación, especialmente con
bases de datos y consultas SQL?​
Reflexioná sobre los riesgos que enfrentan las bases de datos y cómo prevenir
inyecciones SQL en tus aplicaciones.
7.​ Si tuvieras que mejorar o ampliar el Trabajo Final Integrador, ¿qué
funcionalidades agregarías?​
Imaginá qué cambios o mejoras podrías hacer para optimizar tu proyecto.
 8.​ ¿Cómo podrías aplicar los conocimientos adquiridos en este curso en un
proyecto o problema del mundo real?​
Relacioná lo aprendido con situaciones concretas que podrías enfrentar en un
entorno profesional o académico.
9.​ ¿Qué concepto o herramienta del curso te gustaría seguir profundizando?​
Identificá qué área te resultó más interesante y cómo podrías seguir aprendiendo
sobre ella.
10.​¿Qué consejo le darías a alguien que está por empezar este curso?​
Pensá en los desafíos y aprendizajes que tuviste y qué recomendación podría
ayudar a futuros estudiantes.

Próximos Pasos:
El curso ha llegado a su fin, pero el camino en la programación y el desarrollo de software
apenas comienza. A lo largo de estas clases, aprendiste los fundamentos de Python, bases
de datos, manipulación de archivos, estructuras de datos y muchos otros conceptos que te
permitirán abordar proyectos cada vez más desafiantes. Sin embargo, la programación es
un campo en constante evolución, y seguir capacitándote es fundamental para consolidar lo
aprendido y expandir tus habilidades.

Si querés continuar tu formación en el ámbito de la tecnología, existen múltiples rutas de

especialización disponibles que te permitirán profundizar en distintas áreas según tus
intereses y objetivos profesionales.

Si te interesa el desarrollo web, podés convertirte en Desarrollador Full Stack Node o

Java, completando un programa de cuatro módulos que comienza con la Programación
Inicial con Python que acabas de finalizar, y termina con el desarrollo en React y
Back-End con [Link] o Java. Esta formación te permitirá crear aplicaciones completas,
tanto en la parte visual como en la lógica del servidor, preparándote para trabajar en
proyectos integrales de software.

Para quienes prefieran el mundo de los videojuegos, existe un trayecto de especialización

en Unity 2D y 3D, que comienza con una sólida base en Programación Inicial con Python
que ya tenes, y luego se adentra en el desarrollo de videojuegos utilizando el motor Unity.
Esta capacitación te brindará las herramientas necesarias para diseñar y programar
experiencias interactivas.

Si tu interés está en el análisis y procesamiento de datos, hay opciones como Analista de

Datos o Data Scientist. Ambas especializaciones parten tambien de Programación Inicial
con Python, y luego avanzan en el uso de herramientas de Business Intelligence, Data
Analytics y Machine Learning. Estas formaciones son ideales para quienes buscan aplicar
la programación en la toma de decisiones basadas en datos, un campo con creciente
demanda en múltiples industrias.

Por otro lado, si tu objetivo es mejorar la calidad del software, el área de Testing QA y
Tester Engineer ofrece la posibilidad de especializarte en la detección y automatización de
pruebas para garantizar el funcionamiento óptimo de las aplicaciones. Este camino incluye
formación en Testing QA manual y automatizado, complementado con conocimientos en
Python para desarrollar herramientas que faciliten la validación de software.

Finalmente, si querés enfocarte en el diseño y construcción de interfaces web, la

especialización en Desarrollo Front-End te permitirá dominar JavaScript, React y otras
tecnologías del lado del cliente para crear sitios web dinámicos y atractivos.

Cada uno de estos caminos representa una oportunidad para seguir creciendo y
consolidando tus habilidades en programación. Independientemente de la especialización
que elijas, lo más importante es seguir practicando, construyendo proyectos propios y
aplicando lo aprendido en situaciones reales. La tecnología avanza rápidamente, y quienes
se capacitan y se mantienen actualizados tienen la posibilidad de acceder a nuevas
oportunidades y desafíos profesionales.

🚀
Este curso fue solo el primer paso en tu recorrido. Ahora, la decisión está en tus manos:
¿qué camino vas a seguir?