República Bolivariana de Venezuela

Ministerio Para el Poder Popular de la Educación Universitaria

Universidad Nacional Experimental de los Llanos Occidentales
“Ezequiel Zamora” Barinas - estado Barinas

Profesor Marcos Jerez

Saludos, a continuación les envío un documento donde explica cómo
cree los ejemplos de las cuatro fases de entrega del proyecto de
Algoritmo y Programación 1, no tiene la estructura exacta del
proyecto, teniendo en cuenta que si así lo hiciera, ustedes solo
copiarían y pegarían, haciendo algunos cambios mínimos y lo que se
quiere es que ustedes en el proceso de creación de sus proyectos
aprendan.

Este es el diario del programador, donde se explica desde la visión del

profesor, ¿Por qué? Y ¿Para qué? Se crearon cada uno de los ejemplos
de las 4 fases del proyecto, estas fases no tienen nombres de fases,
sino el contenido en el que se basan.

Ejemplo 1 (El inicio del proyecto):

Para la primera fase, es decir, para el módulo 1, donde vamos a

necesitar solo lo aprendido en Introducción a la Informática y
lo aprendido en el módulo (Fundamentos Básicos de la
Programación) necesito un ejemplo que utilizando solo estructuras
de control básicas, me permita desarrollar el
código de un programa sencillo para llevar el registro de las ventas
diarias en una pequeña tienda de víveres. Por cierto el nombre de mi
proyecto es genérico para no dar más pistas de las necesarias, las
cuales ustedes si deberían desarrollar en sus informes.

El Código:

# Se inicializan las variables necesarias

total_venta = 0
iva = 0.16

# Bucle para registrar los

productos for i in range(1, 5):
# Se registra el valor del producto
valor_producto = float(input(f"Ingrese el valor del producto {i}:
"))

# Se valida que la entrada sea un número

positivo if valor_producto <= 0:
 print("Error: El valor del producto debe ser un número
positivo.") continue

# Se actualiza el total de la
venta total_venta +=
valor_producto

# Se calcula el IVA
iva_total = total_venta * iva

# Se calcula el total final (venta + IVA)

total_final = total_venta + iva_total

# Se muestran los resultados

print("Total venta:", total_venta)
print("IVA (16%):", iva_total)
print("Total final:", total_final)

El Código ejecutado:

Este programa permite ingresar el valor de 4 productos, muestra el

valor acumulado de la venta, agrega el IVA (16%) y muestra el total
de la venta.

Explicación del código:

1. Se inicializan las variables:

o total_venta: Almacena el total de la venta

acumulado.

o iva: Almacena el valor del IVA (16%).

2. Bucle for:
 o Este bucle se repite 4 veces, permitiendo ingresar el valor
de 4 productos.

o Dentro del bucle, se realizan las siguientes acciones:

 Registro del valor del producto:

 Se utiliza la función input() para obtener el

valor del producto actual del usuario.

 Se convierte la entrada a un número flotante

utilizando la función float().

 Validación de la entrada:

 Se verifica que el valor del producto sea un

número positivo. Si no lo es, se muestra un
mensaje de error y se continúa con la
siguiente iteración del bucle.

 Actualización del total de la venta:

 Se suma el valor del producto actual al total

de la venta acumulado.

3. Cálculo del IVA:

o Se calcula el IVA total multiplicando el total de la venta

por el valor del IVA.

4. Cálculo del total final:

o Se suma el IVA total al total de la venta para obtener el

total final.

5. Mostrar resultados:

o Se muestran el total de la venta, el IVA y el total final

utilizando la función print().

En este ejemplo, se han utilizado estructuras de control

secuenciales para:

 Registrar los productos uno a uno.

  Calcular el total de la venta acumulado.

 Calcular el IVA.

 Calcular el total final.

 Se ha utilizado un bucle for para iterar sobre los productos y

registrar sus valores.

Ejemplo 2 (Funciones y Estructuras de Datos

Básicas):

Para este ejemplo permítanme dividirlo en dos para que entiendan las
diferencias, ustedes no necesitan hacerlo así, es solo para que lo
entiendan mejor. En el último ejemplo vendría a ser el definitivo,
como el que ustedes entregarían en el módulo 2.

El Código (Estructuras de Datos):

# Se define el IVA
iva = 0.16

# Se crea un diccionario para almacenar los productos

productos = {}

# Bucle para registrar los

productos for i in range(1, 5):
# Se solicita el valor del producto
valor_producto = float(input(f"Ingrese el valor del producto {i}:
"))

# Se valida la
entrada if
valor_producto <= 0:
print("Error: El valor del producto debe ser un número
positivo.") continue

# Se agrega el producto al diccionario con su valor

productos[f"Producto {i}"] = valor_producto

# Se inicializa el total de la venta en 0

total_venta = 0

# Se calcula el total de la venta iterando sobre el

diccionario for valor in productos.values():
# Se calcula el IVA total
iva_total = total_venta *
iva

# Se calcula el total final (venta + IVA)

total_final = total_venta + iva_total

# Se muestran los resultados

print("Detalle de productos:")
for producto, valor in
productos.items(): print(f"{producto}:
{valor}")
print("Total venta:", total_venta)
print("IVA (16%):", iva_total)

El código ejecutado:

Explicación de las mejoras:

1. Diccionario productos:

o Se crea un diccionario vacío llamado productos para

almacenar los nombres y valores de los productos.

o Al registrar un producto, se utiliza su nombre como clave

y su valor como dato dentro del diccionario.

2. Cálculo del total de la venta:

o Se inicializa la variable total_venta en 0.

 o Se itera sobre los valores del diccionario productos
utilizando un bucle for.

o Dentro del bucle, se suma el valor de cada producto al

total_venta.

3. Detalle de productos:

o Antes de mostrar los resultados finales, se imprime

un encabezado "Detalle de productos".

o Se itera sobre el diccionario productos utilizando un bucle

for con items().

o Dentro del bucle, se imprime el nombre del

producto (clave) y su valor asociado (dato).

En este ejemplo, se ha utilizado un diccionario para:

 Almacenar los productos de forma organizada,

permitiendo acceder a ellos por su nombre.

 Facilitar el cálculo del total de la venta iterando sobre los

valores del diccionario.

 Ofrecer un detalle más completo al mostrar el nombre de cada

producto y su valor.

Este es un ejemplo más avanzado que utiliza una estructura

de datos (diccionario) para mejorar la organización y
manejo de la información.

Ten en cuenta que también se podrían utilizar listas o

tuplas para almacenar los productos, pero un diccionario
ofrece mayor flexibilidad para acceder a la información por
nombre.

El Código (Estructuras de Datos y Funciones):

# Se define el IVA
iva = 0.16

def registrar_producto():
"""Solicita al usuario el valor de un producto y lo valida."""
valor_producto = float(input("Ingrese el valor del producto: "))
 if valor_producto <= 0:
print("Error: El valor del producto debe ser un número
positivo.") return None

return valor_producto

def calcular_total_venta(productos):
"""Calcula el total de la venta a partir de un diccionario de
productos."""
total_venta = 0
for valor in productos.values():
total_venta += valor
return total_venta

def calcular_iva(total_venta):
"""Calcula el IVA a partir del total de la venta."""
iva_total = total_venta * iva
return iva_total

def calcular_total_final(total_venta, iva_total):

"""Calcula el total final (venta + IVA)."""
total_final = total_venta + iva_total
return total_final

def mostrar_detalle_productos(productos):
"""Muestra un detalle de los productos y sus valores."""
print("Detalle de productos:")
for producto, valor in
productos.items():
print(f"{producto}: {valor}")

def mostrar_resultados(total_venta, iva_total, total_final):

"""Muestra los resultados finales (total venta, IVA y total
final).""" print("Total venta:", total_venta)
print("IVA (16%):", iva_total)
print("Total final:", total_final)

# Programa principal
productos = {}

for i in range(1, 5):

valor_producto =
registrar_producto() if
valor_producto is not None:
productos[f"Producto {i}"] = valor_producto

total_venta =
calcular_total_venta(productos) iva_total
= calcular_iva(total_venta)
total_final = calcular_total_final(total_venta, iva_total)

mostrar_detalle_productos(productos)
mostrar_resultados(total_venta, iva_total, total_final)

El código ejecutado:

Explicación de las mejoras:

1. Funciones:

o Se han definido 5 funciones:

 registrar_producto(): Solicita y valida el valor de un

producto.

 calcular_total_venta(productos): Calcula el total de

la venta a partir de un diccionario de productos.

 calcular_iva(total_venta): Calcula el IVA a partir del

total de la venta.

 calcular_total_final(total_venta, iva_total): Calcula el

total final (venta + IVA).

 mostrar_detalle_productos(productos): Muestra un
detalle de los productos y sus valores.
  mostrar_resultados(total_venta, iva_total,
total_final): Muestra los resultados finales (total
venta, IVA y total final).

2. Modularización:

o El código se ha dividido en funciones más pequeñas y

específicas, lo que facilita su comprensión y
mantenimiento.

o Cada función se encarga de una tarea específica,

evitando la repetición de código.

3. Reutilización:

o Las funciones pueden ser reutilizadas en otros programas

o proyectos.

o Por ejemplo, la función registrar_producto() podría usarse

para registrar datos en otros contextos.

En este ejemplo, se ha utilizado la programación funcional

para:

 Modularizar el código en funciones más pequeñas y

reutilizables.

 Mejorar la legibilidad y mantenibilidad del código.

 Facilitar la reutilización de código en otros programas o

proyectos.

Recuerda que las funciones son una herramienta poderosa

para organizar y estructurar tu código de manera eficiente.

Ejemplo 3 (Estructuras de Control):

Aunque ya conocemos las estructuras de control en esta fase del

módulo 3 se desarrolla con mayor complejidad que lo que se pudo ver
en introducción a la informática. Ahora este programa mejora
el ejemplo anterior con estructuras de control más elaboradas y
nuevas funcionalidades:
El Código:

# Se define el IVA
iva = 0.16

def registrar_producto():
"""Solicita al usuario el valor de un producto y lo valida."""
valor_producto = float(input("Ingrese el valor del producto: "))

if valor_producto <= 0:
print("Error: El valor del producto debe ser un número
positivo.") return None

return valor_producto

def calcular_total_venta(productos):
"""Calcula el total de la venta a partir de un diccionario de
productos."""
total_venta = 0
for valor in productos.values():
total_venta += valor
return total_venta

def calcular_iva(total_venta):
"""Calcula el IVA a partir del total de la venta."""
iva_total = total_venta * iva
return iva_total

def calcular_total_final(total_venta, iva_total,

descuento): """Calcula el total final (venta + IVA -
descuento).""" total_final = total_venta + iva_total -
descuento
return total_final

def aplicar_descuento(total_venta):
"""Solicita al usuario el porcentaje de descuento y lo aplica al
total de la venta."""
while True:
try:
porcentaje_descuento = float(input("Ingrese el porcentaje de
descuento (0-100%): "))
if 0 <= porcentaje_descuento <=
100: break
else:
print("Error: El porcentaje de descuento debe estar entre 0
y
100%.")
except ValueError:
 descuento = total_venta * (porcentaje_descuento / 100)
return descuento

def mostrar_detalle_productos(productos):
"""Muestra un detalle de los productos y sus
valores.""" print("Detalle de productos:")
for producto, valor in
productos.items():
print(f"{producto}: {valor}")

def mostrar_resultados(total_venta, iva_total, descuento,

total_final): """Muestra los resultados finales (total venta,
IVA, descuento y total
final)."""
print("Total venta:",
total_venta) print("IVA (16%):",
iva_total) print("Descuento:",
descuento) print("Total final:",
total_final)

# Programa
principal
productos = {}

for i in range(1, 5):

valor_producto =
registrar_producto() if
valor_producto is not None:
productos[f"Producto {i}"] = valor_producto

total_venta = calcular_total_venta(productos)
iva_total = calcular_iva(total_venta)

descuento = aplicar_descuento(total_venta)

El código ejecutado:
Nuevas funcionalidades:

 Descuento:

o Se ha agregado la funcionalidad para aplicar un

descuento sobre la venta total.

o Se utiliza la función aplicar_descuento() para solicitar al

usuario el porcentaje de descuento y calcular el monto del
descuento.

o El descuento se aplica al total de la venta antes de

calcular el total final.

 Estructuras de control:

o Se han utilizado estructuras de control while True y try-

except para:

 Validar la entrada del usuario para el

porcentaje de descuento.

 Manejar errores de entrada de datos.

 Mensajes de error más descriptivos:

o Se han mejorado los mensajes de error para proporcionar

información más clara al usuario.

Este ejemplo es más completo y versátil, ya que permite:

 Registrar ventas de productos.

 Calcular el total de la venta.

  Aplicar un descuento sobre la venta.

 Calcular el IVA.

 Calcular el total final (venta + IVA - descuento).

 Mostrar un detalle de los productos y sus valores.

 Mostrar los resultados finales de la venta.

Recuerda que las estructuras de control y las funciones son

herramientas fundamentales para crear programas robustos y
flexibles.

Ejemplo 4 (Generadores y Excepciones):

Este programa es una versión final del ejemplo de registro de ventas,

utilizando generadores y excepciones para mejorar la eficiencia y el
manejo de errores. Es decir, aquí vamos a encontrar un poco de cada
uno de los microproyectos presentados hasta el momento:

El Código:

import random

# Se define el IVA
iva = 0.16

def registrar_producto():
"""Solicita al usuario el valor de un producto y lo
valida.""" try:
valor_producto = float(input("Ingrese el valor del
producto: ")) if valor_producto <= 0:
raise ValueError("El valor del producto debe ser un número
positivo.")
return valor_producto
except ValueError as
error:
print(f"Error: {error}")
return None

def calcular_total_venta(productos):
 """Calcula el total de la venta a partir de un generador de
productos."""
total_venta = 0
for valor in productos:
total_venta += valor
return total_venta

def calcular_iva(total_venta):
"""Calcula el IVA a partir del total de la venta."""
iva_total = total_venta * iva
return iva_total

def calcular_total_final(total_venta, iva_total, descuento):

"""Calcula el total final (venta + IVA - descuento)."""
total_final = total_venta + iva_total - descuento
return total_final

def aplicar_descuento(total_venta):
"""Solicita al usuario el porcentaje de descuento y lo
valida.""" while True:
try:
porcentaje_descuento = float(input("Ingrese el porcentaje
de descuento (0-100%): "))
if 0 <= porcentaje_descuento <= 100:
break
else:
print("Error: El porcentaje de descuento debe estar entre 0 y
100%.")
except ValueError:
print("Error: Debe ingresar un número válido.")

descuento = total_venta * (porcentaje_descuento / 100)

return descuento

def mostrar_detalle_productos(productos):
"""Muestra un detalle de los productos y sus valores."""
print("Detalle de productos:")
for producto, valor in
productos.items():
print(f"{producto}: {valor}")

def mostrar_resultados(total_venta, iva_total, descuento,

total_final): """Muestra los resultados finales (total venta, IVA,
descuento y total
final)."""
print("Total venta:", total_venta)
print("IVA (16%):", iva_total)
print("Descuento:", descuento)
print("Total final:", total_final)

# Programa principal
productos = {}

# Generador de productos
aleatorios def
generar_productos():
for _ in range(random.randint(3,
5)): valor_producto =
registrar_producto() if
valor_producto is not None:
yield valor_producto

productos_generador =

generar_productos()

total_venta = calcular_total_venta(productos_generador)
iva_total = calcular_iva(total_venta)

descuento = aplicar_descuento(total_venta)
total_final = calcular_total_final(total_venta, iva_total,

El Código ejecutado:

Mejoras con generadores y excepciones:

 Generador de productos:

o Se utiliza un generador para registrar los productos, lo

que permite iterar sobre ellos de manera eficiente sin
necesidad de almacenar todos los valores en una lista.
 o El generador utiliza random.randint() para crear un
número aleatorio de productos entre 3 y 5.

 Manejo de excepciones:

o Se utiliza la excepción ValueError para manejar la entrada

incorrecta del usuario al registrar el valor del producto.

o Se utiliza un bloque try-except para capturar la excepción

y mostrar un mensaje de error más descriptivo.

 Código más limpio y organizado:

o Se ha mejorado la estructura del código para hacerlo más

legible y fácil de entender.

o Se han utilizado comentarios para explicar las diferentes

partes del código.

Este ejemplo final es el más completo y eficiente de los

presentados, ya que:

 Utiliza un generador para registrar los productos de manera

eficiente.

 Maneja errores de entrada de datos utilizando

excepciones.

 Presenta un código más limpio y organizado con

comentarios explicativos.

Fíjense que los cuatro programas, no es sino uno mismo, que

se va mejorando en el tiempo según las nuevas técnicas,
estructuras y métodos que se van agregando, entregados en 4
tiempos distintos pero el proyecto es el mismo siempre.