PROGRAMACION AVANZADA.
EVIDENCIA 2.
DOCENTE: RODRIGUEZ RAMIREZ IMELDA LIZETTE.
EQUIPO #3.
NOMBRE. MATRICULA.
JOSE JULIAN DE LA ROSA ROJAS. 2044933.
MAURICIO GABRIEL ÁLVAREZ GONZALEZ 2007135.
JESUS EDUARDO GONZALEZ CASTILLO 1976292.
INDICE.
INDICE. .......................................................................................................................................... 2
INTRODUCCION A (POO). ............................................................................................................. 3
LOS CONCEPTOS CLAVE DE LA (POO):.......................................................................................... 4
INTRODUCCIÓN. ........................................................................................................................... 5
Programa 1................................................................................................................................ 5
CODIGO DEL PROGRAMA 1. ......................................................................................................... 6
PROGRAMA 1 EN FUNCIONAMIENTO. ........................................................................................ 8
PRUEBA 1................................................................................................................................... 8
PRUEBA 2................................................................................................................................... 8
Conclusión..................................................................................................................................... 9
Programa 1................................................................................................................................ 9
INTRODUCCIÓN. ......................................................................................................................... 10
Programa 2.............................................................................................................................. 10
CODIGO PROGRAMA 2. .............................................................................................................. 11
PROGRAMA 2 EN FUNCIONAMIENTO. ...................................................................................... 12
PRUEBA. .................................................................................................................................. 12
CONCLUSIÓN............................................................................................................................... 13
Programa 2.............................................................................................................................. 13
CONCLUSIONES PERSONALES. ................................................................................................... 14
LINKS REPOSITORIOS DE GITHUB............................................................................................... 15
INTRODUCCION A (POO).
¿Que es la programación orientada a objetos (POO)?.
La Programación Orientada a Objetos (POO) es uno de los paradigmas fundamentales
en la ciencia de la computación y el desarrollo de software. Representa una forma
poderosa de abordar la resolución de problemas complejos al modelar el mundo real
como una colección de objetos interconectados. A diferencia de otros paradigmas de
programación que se centran en funciones o procedimientos, la programación
orientada a objetos (POO) organiza el código en torno a "objetos", que son instancias
de clases que encapsulan datos (atributos) y comportamiento (métodos).
En la POO, los objetos son las unidades fundamentales de abstracción y representan
entidades reales o conceptuales. Cada objeto tiene su propio estado interno (atributos)
y puede realizar acciones específicas (métodos) que pueden interactuar con otros
objetos. Esto fomenta la modularidad, la reutilización de código y la capacidad de
comprensión del software, ya que permite dividir problemas complejos en
componentes más pequeños y manejables.
LOS CONCEPTOS CLAVE DE LA (POO):
1.Clases: Son plantillas o moldes que definen la estructura y el comportamiento
de los objetos. Las clases especifican qué atributos (propiedades) y métodos
(comportamiento) tendrán los objetos creados a partir de ellas.
2.Objetos: Son instancias concretas de una clase. Cada objeto tiene su propio
estado, pero comparte la estructura y el comportamiento definidos en su clase.
3.Encapsulación: Es el principio de ocultar los detalles internos de un objeto y
exponer solo una interfaz pública. Esto permite controlar el acceso a los datos y
garantizar la coherencia de la información.
4. Herencia: Permite crear nuevas clases basadas en clases existentes,
heredando sus atributos y métodos. Esto fomenta la reutilización de código y la
creación de jerarquías de clases.
La Programación Orientada a Objetos es ampliamente utilizada en el desarrollo
de software debido a su capacidad para abordar problemas complejos de
manera estructurada y modular. Permite el desarrollo de sistemas más
mantenibles, escalables y comprensibles, lo que la convierte en un enfoque
esencial en el mundo de la programación.
INTRODUCCIÓN.
Programa 1.
El código proporcionado es una implementación sencilla de un programa
para una pastelería llamada, en este caso, "Pastelería El Mencho". Este
programa se utiliza para mostrar un menú de pasteles disponibles,
permitir al usuario seleccionar el sabor y el tamaño del pastel que desea
comprar, y finalmente, imprimir un ticket con el detalle de la compra.
La clase pasteles se utiliza para crear objetos de pasteles con atributos
como sabor, precio y tamaño. El menú incluye pasteles de vainilla,
chocolate y fresa, tanto en tamaño grande como mediano, cada uno con
su precio correspondiente. El usuario puede seleccionar un sabor de pastel
y especificar el tamaño deseado.
Luego de hacer la selección, el programa calcula el costo total y ofrece al
usuario la opción de imprimir un ticket con los detalles de la compra. Si el
usuario elige imprimir el ticket, se muestra un resumen de la compra,
incluyendo el sabor del pastel, el tamaño y el precio total. En caso de que
el usuario no desee imprimir el ticket, se le agradece por su preferencia.
CODIGO DEL PROGRAMA 1.
class pasteles:
def __init__(self,sabor,precio,tamaño):
self.sabor= sabor
self.precio= precio
self.tamaño= tamaño
print(f"El pastel de {self.sabor} tiene un costo de ${self.precio} el de tamaño {
self.tamaño}")
print("----------PASTELERIA EL MENCHO----------")
print("------------------MENU------------------")
vainilla = pasteles("vainilla","350", "grande")
vainilla2= pasteles("vainilla","250", "mediano")
chocolate = pasteles("chocolate","350","grande")
chocolate2= pasteles("chocolate","250", "mediano")
fresa = pasteles("fresa","350", "grande")
fresa2= pasteles("fresa","250", "mediano")
cake=input("escriba el sabor de pastel de tu preferencia ")
size=input("escriba el tamaño del pastel ")
if cake== "vainilla":
print("pastel de vainilla de tamaño ",size)
if size==("grande"):
print("costo de $350")
if size==("mediano"):
print("costo de $250")
if cake== "chocolate":
print("pastel de chocolate de tamaño ",size)
if size==("grande"):
print("costo de $350")
if size==("mediano"):
print("costo de $250")
if cake== "fresa":
print("pastel de fresa de tamaño ",size, )
if size==("grande"):
print("costo de $350")
if size==("mediano"):
print("costo de $250")
opcion=input("desea imprimir su ticket?")
if opcion== "si":
print("----------PASTELERIA EL MENCHO----------")
print("PASTEL SABOR", cake,"DE TAMAÑO",size)
if size=="grande":
print("TOTAL: $350")
if size=="mediano":
print("TOTAL: $250")
print("----MUCHAS GRACIAS POR SU PREFERENCIA---")
if opcion=="no":
print("muchas gracias, vuelva pronto!")
PROGRAMA 1 EN FUNCIONAMIENTO.
PRUEBA 1.
PRUEBA 2.
Conclusión.
Programa 1.
En conclusión, este código proporciona una interfaz
básica para que los clientes de "Pastelería El Mencho"
elijan y compren pasteles de diferentes sabores y
tamaños. Es un ejemplo simple de cómo se puede
implementar un sistema de selección y compra de
productos en una pastelería. Sin embargo, es importante
mencionar que este código tiene un enfoque didáctico y
podría mejorarse en varios aspectos, como la validación
de la entrada del usuario y la organización del código. En
un contexto más realista, también podría incluirse una
base de datos de productos y un sistema de pago más
completo.
INTRODUCCIÓN.
Programa 2.
El siguiente código es una implementación en Python de
una clase llamada saludo. Esta clase se utiliza para crear
objetos que representan un mensaje de saludo
personalizado. En el constructor de la clase __init__, se
pasan dos parámetros: mensaje y nombre, que se utilizan
para personalizar el saludo. Luego, el saludo
personalizado se imprime en la consola
En este caso particular, se crea un objeto usuario de la
clase saludo con el mensaje "Bienvenido" y el nombre
"Fernando". Esto dará como resultado que se imprima en
la consola un mensaje de saludo personalizado que dice
"Bienvenido seas Fernando".
CODIGO PROGRAMA 2.
class saludo:
def __init__(self,mensaje,nombre):
self.mensaje=mensaje
self.nombre=nombre
print(f"{self.mensaje} seas {self.nombre}")
usuario = saludo("Bienvenido","fernando")
PROGRAMA 2 EN FUNCIONAMIENTO.
PRUEBA.
CONCLUSIÓN.
Programa 2.
Para concluir, este código demuestra cómo se puede
utilizar una clase simple en Python para crear objetos que
representen saludos personalizados. Es una
implementación básica pero efectiva de la programación
orientada a objetos en Python, y puede servir como punto
de partida para proyectos más complejos que requieran la
personalización de mensajes de saludo u otras
interacciones similares.
CONCLUSIONES PERSONALES.
2044933 JOSÉ JULIÁN DE LA ROSA ROJAS.
Los códigos que hemos explorado demuestran de la simplicidad en la
programación. La primera muestra cómo una clase puede encapsular
datos y comportamientos para representar objetos del mundo real de
manera clara y efectiva. La segunda, aunque básica, demuestra cómo la
POO permite crear una interacción personalizada con el usuario. En
conjunto, estos ejemplos resaltan cómo la programación puede utilizarse
para simplificar tareas complejas mediante la creación de abstracciones y
objetos bien definidos.
2007135 MAURICIO GABRIEL ÁLVAREZ GONZALEZ.
Concluimos que ambos códigos, de alguna manera, involucran la
interacción con el usuario. La segunda muestra cómo se recopila la
preferencia del usuario y se ofrece una respuesta personalizada. Esto
subraya la importancia de diseñar interfaces de usuario intuitivas y
amigables. En la programación, no solo se trata de resolver problemas
técnicos, sino también de crear experiencias significativas para los
usuarios.
1976292 JESUS EDUARDO GONZALEZ CASTILLO.
Aunque los códigos son simples, ilustran la versatilidad de la
programación. Desde un programa de saludo personalizado hasta un
sistema básico de pedidos de pasteles, la programación puede adaptarse a
una amplia gama de aplicaciones. Esto refleja cómo la programación es
una herramienta poderosa que puede utilizarse para automatizar tareas
mundanas, mejorar la eficiencia en los negocios o crear soluciones únicas
y creativas.
LINKS REPOSITORIOS DE GITHUB.
JOSÉ JULIÁN DE LA ROSA ROJAS.
https://github.com/juliandelarosax/pyhtonprograms
MAURICIO GABRIEL ÁLVAREZ GONZALEZ.
https://github.com/maury2024/repository
JESUS EDUARDO GONZALEZ CASTILLO.
https://github.com/JesusEduGzz/evidencias
