PROGRAMACIÓN EN PYTHON – CLASE 07

(Creado por el analista de sistemas y docente Leonel Iván Saafigueroa)


LISTAS Y TUPLAS

Organizando datos en Python.


Hacer las compras del mes puede ser complicado. ¡Imaginate intentar recordar todo sin una lista! Probablemente olvides algo importante. Para organizar tus compras, creas una lista. Python te ofrece una herramienta similar llamada “listas“, que te permite almacenar información en un solo lugar de forma organizada.

En vez de tratar de recordar cada dato por separado, las listas te permiten guardarlos juntos y acceder a ellos fácilmente.



En Python, las “listas” son estructuras especiales que te permiten guardar múltiples valores dentro de una sola variable. A diferencia de una variable simple que solo almacena un valor, una lista puede contener varios elementos, como si fuera una caja donde guardas diferentes objetos juntos. Para crear una lista, simplemente encerrás los elementos entre corchetes [] y separa cada uno con una coma.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
compras = ["manzanas", "pan", "leche", "queso"]
compras = ["manzanas", "pan", "leche", "queso"]

La lista “compras” guarda información sobre cuatro productos distintos. Cada producto ocupa una posición específica dentro de la lista, como si fueran lugares en una fila. Esta organización nos permite encontrar y utilizar cada producto individualmente según su posición.



Crear una lista en Python es fácil: solo necesitás usar corchetes [] y separar los elementos con comas. Pero, ¿qué pasa si querés obtener uno de esos elementos específicos? Ahí es donde entran los “índices“, que nos permiten localizar cada elemento dentro de la lista como si fueran lugares en una fila.

Dentro de una lista, cada elemento tiene su propia ubicación llamada “índice“. Pensá en ellos como números que señalan el lugar de cada artículo en una fila. El primer elemento está en el índice 0, el segundo en el índice 1, y así sucesivamente.

Podés acceder a un elemento de la lista simplemente usando su índice.

Si usamos el índice 0, obtenemos “manzanas“, que es el primer producto de nuestra lista. El índice 2 nos lleva a “leche“, el tercer producto.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
print(compras[0])
print(compras[2])
compras = ["manzanas", "pan", "leche", "queso"] print(compras[0]) print(compras[2])
compras = ["manzanas", "pan", "leche", "queso"]
print(compras[0])
print(compras[2])
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
manzanas
leche
manzanas leche
manzanas
leche

Y la mejor parte: si quieres modificar un elemento, solo necesitas reasignarle un nuevo valor.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
compras[1] = "yogur"
print(compras)
compras = ["manzanas", "pan", "leche", "queso"] compras[1] = "yogur" print(compras)
compras = ["manzanas", "pan", "leche", "queso"]
compras[1] = "yogur"
print(compras)
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
['manzanas', 'yogur', 'leche', 'queso']
['manzanas', 'yogur', 'leche', 'queso']
['manzanas', 'yogur', 'leche', 'queso']

index(x): Devuelve el índice donde se
encuentra el elemento x. Si hay mas de un elementos, solo devolverá el indice de la primer ocurrencia.
Si el elemento x no se encuentra en la lista, obtendremos un error y se detendrá la ejecución del programa.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
print(compras.index("pan"))
compras = ["manzanas", "pan", "leche", "queso"] print(compras.index("pan"))
compras = ["manzanas", "pan", "leche", "queso"]
print(compras.index("pan"))
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
1
1
1


Ya sabemos que las listas son flexibles: podemos cambiar elementos existentes. Además, Python nos permite agregar nuevos elementos con un método llamado append().

Imaginá trabajar en un proyecto donde el inventario cambia constantemente. Con append(), podés añadir productos a tu lista sin complicaciones, manteniendo tu información actualizada.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
compras[1] = "yogur"
compras.append("cereales")
print(compras)
compras = ["manzanas", "pan", "leche", "queso"] compras[1] = "yogur" compras.append("cereales") print(compras)
compras = ["manzanas", "pan", "leche", "queso"]
compras[1] = "yogur"
compras.append("cereales")
print(compras)  
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
['manzanas', 'yogur', 'leche', 'queso', 'cereales']
['manzanas', 'yogur', 'leche', 'queso', 'cereales']
['manzanas', 'yogur', 'leche', 'queso', 'cereales']

insert(pos, x): Inserta un elemento x en una posición específica.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
compras.insert(3,"yogur")
print(compras)
compras = ["manzanas", "pan", "leche", "queso"] compras.insert(3,"yogur") print(compras)
compras = ["manzanas", "pan", "leche", "queso"]
compras.insert(3,"yogur")
print(compras)  
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
['manzanas', 'pan', 'leche', 'yogur', 'queso']
['manzanas', 'pan', 'leche', 'yogur', 'queso']
['manzanas', 'pan', 'leche', 'yogur', 'queso']

extend(iterable): Agrega varios elementos de otra
lista o iterable al final.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
compras = ["manzanas", "pan", "leche", "queso"]
compras.extend(["papa","cebolla","bananas"])
print(compras)
compras = ["manzanas", "pan", "leche", "queso"] compras.extend(["papa","cebolla","bananas"]) print(compras)
compras = ["manzanas", "pan", "leche", "queso"]
compras.extend(["papa","cebolla","bananas"])
print(compras)  
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
['manzanas', 'pan', 'leche', 'queso', 'papa', 'cebolla', 'bananas']
['manzanas', 'pan', 'leche', 'queso', 'papa', 'cebolla', 'bananas']
['manzanas', 'pan', 'leche', 'queso', 'papa', 'cebolla', 'bananas']


En un programa de stock, a veces un producto se vende o se retira del inventario. ¿Cómo eliminamos ese producto de nuestra lista? Para eso usamos el método remove(). Simplemente indicas el valor a eliminar, y Python busca el primer valor coincidente dentro de la lista y lo elimina por completo.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
productos = ["manzanas", "pan", "leche"]
productos.remove("pan")
print(productos)
productos = ["manzanas", "pan", "leche"] productos.remove("pan") print(productos)
productos = ["manzanas", "pan", "leche"]
productos.remove("pan")
print(productos) 
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
['manzanas', 'leche']
['manzanas', 'leche']
['manzanas', 'leche']

pop(pos): Elimina el elemento en una posición específica y lo devuelve. Si no se indica posición, elimina el último. Si la posición está fuera de rango, obtendremos un error y se detendrá la ejecución del programa.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
productos = ["manzanas", "pan", "leche"]
productos.pop(2)
print(productos)
productos = ["manzanas", "pan", "leche"] productos.pop(2) print(productos)
productos = ["manzanas", "pan", "leche"]
productos.pop(2)
print(productos)
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
['manzanas', 'pan']
['manzanas', 'pan']
['manzanas', 'pan']

clear(): Elimina todos los elementos de la lista,
dejándola vacía.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
productos = ["manzanas", "pan", "leche"]
productos.clear()
print(productos)
productos = ["manzanas", "pan", "leche"] productos.clear() print(productos)
productos = ["manzanas", "pan", "leche"]
productos.clear()
print(productos)
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
[]
[]
[]

Finalmente, tenemos el método len() que nos dice cuántos elementos tiene una lista.

¿Para qué sirve? Imaginá un bucle en tu programa que necesita recorrer cada elemento de la lista. Con len(), podés saber cuántos elementos hay y asegurarte de no sobrepasarlos, evitando errores.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
productos = ["manzanas", "pan", "leche"]
cantidad_productos = len(productos)
print("Cantidad de productos:", cantidad_productos)
productos = ["manzanas", "pan", "leche"] cantidad_productos = len(productos) print("Cantidad de productos:", cantidad_productos)
productos = ["manzanas", "pan", "leche"]
cantidad_productos = len(productos)
print("Cantidad de productos:", cantidad_productos) 
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
Cantidad de productos: 3
Cantidad de productos: 3
Cantidad de productos: 3


Además de las listas, Python nos ofrece otro tipo de contenedor: la tupla. Imaginá una lista, pero con una característica especial: es inmutable. Una vez que creas una tupla, sus elementos permanecen fijos y no se pueden modificar. Son perfectas cuando necesitas garantizar que ciertos valores sean constantes e inalterables.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
mi_tupla = ("manzanas", "pan", "leche")
mi_tupla = ("manzanas", "pan", "leche")
mi_tupla = ("manzanas", "pan", "leche")

Una peculiaridad de las tuplas es que, a diferencia de las listas, se definen entre paréntesis (). Python reconoce automáticamente que estamos creando una tupla al usar esta sintaxis en vez de los corchetes [] utilizados para las listas.

La inmutabilidad de las tuplas significa que sus elementos permanecen fijos una vez creados.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
# Esto va a dar un error porque las tuplas
# no se pueden modificar
mi_tupla[1] = "yogur"
# Esto va a dar un error porque las tuplas # no se pueden modificar mi_tupla[1] = "yogur"
# Esto va a dar un error porque las tuplas
# no se pueden modificar
mi_tupla[1] = "yogur"

¿Dónde podemos usar tuplas? Son ideales para proteger datos que no deben modificarse, como precios fijos o configuraciones del sistema. Recordá esto a la hora de diseñar tu código: las tuplas te ayudan a mantener la integridad de la información crucial.

Imaginá una lista, pero con un detalle clave: la inmutabilidad.

Una vez creada, su contenido permanece fijo e inalterable. Esto es lo que define a una tupla.

Son perfectas cuando necesitas garantizar que ciertos valores permanezcan constantes durante la ejecución de tu programa, evitando cambios inesperados.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
# Inicializamos la variable
numero = 1
while numero <= 10:
print(numero)
# Incrementamos el valor de numero
# en 1 en cada iteración
numero = numero + 1
# Inicializamos la variable numero = 1 while numero <= 10: print(numero) # Incrementamos el valor de numero # en 1 en cada iteración numero = numero + 1
# Inicializamos la variable
numero = 1 

while numero <= 10: 
   print(numero)
   # Incrementamos el valor de numero 
   # en 1 en cada iteración
   numero = numero + 1
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
1
2
3
4
5
6
7
8
9
10
1 2 3 4 5 6 7 8 9 10
1
2
3
4
5
6
7
8
9
10


¿Necesitas mostrar los productos disponibles en tu inventario?

Imagina un bucle while que recorre tu lista de productos paso a paso.

Usarás un contador como índice, comenzando en 0 y aumentando con cada vuelta del bucle.

De esta forma, te asegurás de visitar cada producto de principio a fin.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
productos = ["manzanas", "pan", "leche"]
indice = 0
while indice < len(productos):
print("Producto", indice + 1, ":", productos[indice])
indice = indice + 1
productos = ["manzanas", "pan", "leche"] indice = 0 while indice < len(productos): print("Producto", indice + 1, ":", productos[indice]) indice = indice + 1
productos = ["manzanas", "pan", "leche"]
indice = 0

while indice < len(productos):
   print("Producto", indice + 1, ":", productos[indice])
   indice = indice + 1
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
Producto 1 : manzanas
Producto 2 : pan
Producto 3 : leche
Producto 1 : manzanas Producto 2 : pan Producto 3 : leche
Producto 1 : manzanas
Producto 2 : pan
Producto 3 : leche

¿Querés explorar los elementos de una tupla?

Al igual que con una lista, podés usar un bucle while para recorrer cada uno de sus valores.

Aunque no podés modificar los elementos dentro de una tupla, sí podés acceder a ellos sin problema, tal como lo harías con una lista.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
configuracion_tienda = ("nombre_tienda", "calle falsa 123", "Buenos Aires")
indice = 0
while indice < len(configuracion_tienda):
print("Dato", indice + 1, ":", configuracion_tienda[indice])
indice = indice + 1
configuracion_tienda = ("nombre_tienda", "calle falsa 123", "Buenos Aires") indice = 0 while indice < len(configuracion_tienda): print("Dato", indice + 1, ":", configuracion_tienda[indice]) indice = indice + 1
configuracion_tienda = ("nombre_tienda", "calle falsa 123", "Buenos Aires")
indice = 0

while indice < len(configuracion_tienda):
   print("Dato", indice + 1, ":", configuracion_tienda[indice])
   indice = indice + 1
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
Dato 1 : nombre_tienda
Dato 2 : calle falsa 123
Dato 3 : Buenos Aires
Dato 1 : nombre_tienda Dato 2 : calle falsa 123 Dato 3 : Buenos Aires
Dato 1 : nombre_tienda
Dato 2 : calle falsa 123
Dato 3 : Buenos Aires

¿Sabías que las listas pueden contener no solo números y cadenas de texto, sino también datos booleanos e incluso otras listas? ¡Es cierto! Cuando esto sucede, nos encontramos con lo que llamamos “listas de listas“.

Imaginá una tabla donde cada fila representa una lista con múltiples datos relacionados. Eso es precisamente una lista de listas: cada elemento de la lista principal es una lista en sí misma.

Podríamos tener una lista que almacene información sobre productos, con cada “producto” representado por una lista que incluye su nombre, precio y cantidad disponible en el inventario.


Inventario de productos


En este ejemplo, cada producto es una lista que guarda estos tres detalles. La lista principal “inventario” agrupa todas estas listas de productos. Para obtener la información específica de un producto, necesitamos usar dos niveles de índices: el primero nos lleva a la lista del producto deseado (por ejemplo, “inventario[0][0]” para las manzanas), y el segundo nos indica qué dato dentro de esa lista queremos acceder (por ejemplo, “inventario[0][1]” para obtener el precio de las manzanas).

Para recorrer cada producto en el inventario, podemos utilizar un bucle while. Dentro del bucle, usamos los índices de dos niveles para acceder a los datos individuales de cada producto.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
# Lista de productos: cada producto tiene nombre, precio y cantidad
inventario = [ ["manzanas", 100, 50],
["pan", 50, 20],
["leche", 60, 30] ]
# Recorrer el inventario y mostrar los datos de cada producto
indice = 0
while indice < len(inventario):
producto = inventario[indice]
print("Producto:", producto[0])
print("Precio: $", producto[1])
print("Cantidad disponible:", producto[2])
print("-------------------------")
indice = indice + 1
# Lista de productos: cada producto tiene nombre, precio y cantidad inventario = [ ["manzanas", 100, 50], ["pan", 50, 20], ["leche", 60, 30] ] # Recorrer el inventario y mostrar los datos de cada producto indice = 0 while indice < len(inventario): producto = inventario[indice] print("Producto:", producto[0]) print("Precio: $", producto[1]) print("Cantidad disponible:", producto[2]) print("-------------------------") indice = indice + 1
# Lista de productos: cada producto tiene nombre, precio y cantidad
inventario = [ ["manzanas", 100, 50],
               ["pan", 50, 20],
               ["leche", 60, 30]  ]
# Recorrer el inventario y mostrar los datos de cada producto
indice = 0
while indice < len(inventario):
   producto = inventario[indice]
   print("Producto:", producto[0])
   print("Precio: $", producto[1])
   print("Cantidad disponible:", producto[2])
   print("-------------------------")
   indice = indice + 1
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
Producto: manzanas
Precio: $ 100
Cantidad disponible: 50
-------------------------
Producto: pan
Precio: $ 50
Cantidad disponible: 20
-------------------------
Producto: leche
Precio: $ 60
Cantidad disponible: 30
-------------------------
Producto: manzanas Precio: $ 100 Cantidad disponible: 50 ------------------------- Producto: pan Precio: $ 50 Cantidad disponible: 20 ------------------------- Producto: leche Precio: $ 60 Cantidad disponible: 30 -------------------------
Producto: manzanas
Precio: $ 100
Cantidad disponible: 50
-------------------------
Producto: pan
Precio: $ 50
Cantidad disponible: 20
-------------------------
Producto: leche
Precio: $ 60
Cantidad disponible: 30
-------------------------


Imaginá un sistema para registrar los productos de una tienda.

Este script te permite crear un inventario utilizando listas de listas.

Empieza creando una lista vacía llamada “productos“, que se convertirá en el hogar de toda la información del inventario. Luego, le pide al usuario que ingrese códigos de producto (números enteros) para añadir cada nuevo artículo. Un bucle while se encarga de controlar este proceso: mientras no se ingrese el código “0” (indicando el fin de la entrada), el ciclo continúa pidiendo información.

Cada vez que un código válido es ingresado, el script solicita la descripción del producto, su precio y la cantidad disponible. Estos cuatro datos se convierten en una nueva lista dentro de la lista principal “productos“, agrupando así toda la información del mismo producto.

Finalmente, el programa muestra todos los productos almacenados en la lista “productos“, accediendo a cada dato individual utilizando sus índices correspondientes (como un código en la posición 0, la descripción en la posición 1, y así sucesivamente).

De esta manera, la persona que usa el programa puede ingresar varios productos, cada uno con sus datos asociados, y almacenarlos en una estructura clara y organizada.

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
productos = [] # Lista que almacenará los productos
# Solicitamos el primer código de producto
codigo = int(input("Ingresá el código del producto (0 para finalizar): "))
# Usamos el bucle while para ingresar los datos mientras el código no sea 0
while codigo != 0:
descripcion = input("Ingresá la descripción del producto: ")
precio = float(input("Ingresá el precio del producto: "))
cantidad = int(input("Ingresá la cantidad del producto: "))
# Agregamos los datos del producto como una lista dentro de la lista de productos
productos.append([codigo, descripcion, precio, cantidad])
# Solicitamos nuevamente el código del siguiente producto
codigo = int(input("Ingresá el código del siguiente producto (0 para finalizar): "))
# Mostramos la lista final de productos
print("Productos ingresados:")
for producto in productos:
print("Código:", producto[0], "Descripción:", producto[1], "Precio:", producto[2], "Cantidad:", producto[3])
productos = [] # Lista que almacenará los productos # Solicitamos el primer código de producto codigo = int(input("Ingresá el código del producto (0 para finalizar): ")) # Usamos el bucle while para ingresar los datos mientras el código no sea 0 while codigo != 0: descripcion = input("Ingresá la descripción del producto: ") precio = float(input("Ingresá el precio del producto: ")) cantidad = int(input("Ingresá la cantidad del producto: ")) # Agregamos los datos del producto como una lista dentro de la lista de productos productos.append([codigo, descripcion, precio, cantidad]) # Solicitamos nuevamente el código del siguiente producto codigo = int(input("Ingresá el código del siguiente producto (0 para finalizar): ")) # Mostramos la lista final de productos print("Productos ingresados:") for producto in productos: print("Código:", producto[0], "Descripción:", producto[1], "Precio:", producto[2], "Cantidad:", producto[3])
productos = [] # Lista que almacenará los productos

# Solicitamos el primer código de producto
codigo = int(input("Ingresá el código del producto (0 para finalizar): "))

# Usamos el bucle while para ingresar los datos mientras el código no sea 0
while codigo != 0:
   descripcion = input("Ingresá la descripción del producto: ")
   precio = float(input("Ingresá el precio del producto: "))
   cantidad = int(input("Ingresá la cantidad del producto: "))

   # Agregamos los datos del producto como una lista dentro de la lista de productos
   productos.append([codigo, descripcion, precio, cantidad])

   # Solicitamos nuevamente el código del siguiente producto
   codigo = int(input("Ingresá el código del siguiente producto (0 para finalizar): "))
# Mostramos la lista final de productos
print("Productos ingresados:")
for producto in productos:
   print("Código:", producto[0], "Descripción:", producto[1], "Precio:", producto[2], "Cantidad:", producto[3])
Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
Ingresá el código del producto (0 para finalizar): 1232
Ingresá la descripción del producto: Cajas
Ingresá el precio del producto: 1231
Ingresá la cantidad del producto: 23
Ingresá el código del siguiente producto (0 para finalizar): 2343
Ingresá la descripción del producto: Carpetas
Ingresá el precio del producto: 122
Ingresá la cantidad del producto: 45
Ingresá el código del siguiente producto (0 para finalizar): 0
Productos ingresados:
Código: 1232 Descripción: Cajas Precio: 1231.0 Cantidad: 23
Código: 2343 Descripción: Carpetas Precio: 122.0 Cantidad: 45
Ingresá el código del producto (0 para finalizar): 1232 Ingresá la descripción del producto: Cajas Ingresá el precio del producto: 1231 Ingresá la cantidad del producto: 23 Ingresá el código del siguiente producto (0 para finalizar): 2343 Ingresá la descripción del producto: Carpetas Ingresá el precio del producto: 122 Ingresá la cantidad del producto: 45 Ingresá el código del siguiente producto (0 para finalizar): 0 Productos ingresados: Código: 1232 Descripción: Cajas Precio: 1231.0 Cantidad: 23 Código: 2343 Descripción: Carpetas Precio: 122.0 Cantidad: 45
Ingresá el código del producto (0 para finalizar): 1232
Ingresá la descripción del producto: Cajas
Ingresá el precio del producto: 1231
Ingresá la cantidad del producto: 23
Ingresá el código del siguiente producto (0 para finalizar): 2343
Ingresá la descripción del producto: Carpetas
Ingresá el precio del producto: 122
Ingresá la cantidad del producto: 45
Ingresá el código del siguiente producto (0 para finalizar): 0
Productos ingresados:
Código: 1232 Descripción: Cajas Precio: 1231.0 Cantidad: 23
Código: 2343 Descripción: Carpetas Precio: 122.0 Cantidad: 45

TAREA PARA EL HOGAR

Sistema de Inventario Básico

Objetivo: Implementar un sistema básico para registrar y consultar productos en una tienda virtual.

Descripción:

El objetivo es crear un programa que permita a los usuarios agregar productos a un inventario virtual hasta que decidan no agregar más. Luego, el programa deberá mostrar todos los productos almacenados en el inventario.
Además, se debe implementar la funcionalidad de consulta para verificar si un producto específico está disponible en stock.

Requisitos:

Si no se encuentra el producto, informar al usuario que no está disponible en el inventario.

Almacenamiento: Utilizar una lista para almacenar información sobre los productos.

Cada elemento de la lista debe ser una sublista que contenga al menos las siguientes características: nombre del producto, cantidad disponible y precio (opcional).

Registro de Productos:

Permitir al usuario ingresar el nombre del producto, la cantidad disponible y el precio (opcional) para cada nuevo producto.

Utilizar un bucle while para solicitar información del producto hasta que el usuario indique que no desea agregar más productos.

Consulta de Productos:

Solicitar al usuario que ingrese el nombre de un producto a consultar.

Recorrer la lista de productos utilizando un bucle while para buscar el producto ingresado por el usuario.

Si se encuentra el producto, informar al usuario sobre su disponibilidad (cantidad en stock).