Contenido del curso
Playground - Implementa un sistema de pagos
Edgar Alarcón
Estudiante
Julio Cardenas
Estudiante
José Miguel Reyes
Estudiante
Nicolas Alpargatero
Estudiante
Jhon Freddy Tavera Blandon
EstudianteJulio Cardenas
Estudiante
Gonzalo Gutiérrez Castillo
Estudiante
Harold Zurita Simon
Estudiante
Diego Cruz
Estudiante
Waldir Zapata Garcia
Estudiante
Alejandro Anaya
Estudiante
Luis Kennedy Saavedra Fuentes
EstudianteLuis Kennedy Saavedra Fuentes
EstudianteJosé Miguel Reyes
Estudiante
iecgerman .
EstudianteLinda Atenea Mejía Usme
Estudiante
Diego Gilabert
Estudiante
Brayan Estiben Rodallega Saavedra
Estudiante
David Hereira
EstudianteOscar Dario Florez Diaz
EstudianteLa verdad le intente por muchos medios, termine confundiéndome mas. Creo que estas test tan exhaustivos alejan y desmotivan. Deberían de haber como dos niveles: 1) con la lógica del funcionamiento y los test básicos y 2) Con la lógica del funcionamiento y los test extremos.
De corazón, creo que los test exhaustivos son anti-didácticos , realmente desmotivan.
A mi me pasa exactamente igual.
Lo que no entiendo es porque pasa el test_paypal_inherits_from_pay si esta escrito con la misma logica que card o cash
A mí me pasa lo mismo!! :-(
Aunque haya error por el momento en el testing se practicó que es lo importante.
Para ser un curo enfocado a principiantes más que todo a principiantes, hay conceptos muy avanzados y complejos. Entiendo que al avanzar las clases del reto se va volviendo más complejo los Playground, pero deberían de pensar en todos y dar opciones de código e implementación más menos complejos
paypal_result = process_pay(paypal_payment, 100) card_result = process_pay(card_payment, 50) cash_result = process_pay(cash_payment, 30) print(paypal_result) print(card_result) print(cash_result)
o o o o o o
class Pay: def make_pay(self, quantity): salida = dict() salida['realized'] = True salida['quantity'] = quantity return salida
class PayPal(Pay): def __init__(self, email): self.email = email def make_pay(self, quantity): salida = dict() salida['realized'] = True salida['quantity'] = quantity salida['platform'] = "PayPal" salida['email'] = self.email return salida
class Card(Pay): def __init__(self, card_number): self.card_number = card_number def make_pay(self, quantity): if len(self.card_number) == 16: salida = dict() salida['realized'] = True salida['quantity'] = quantity salida['last_card_numbers'] = self.card_number[-4:] return salida else: raise Exception
class Cash(Pay): pass
from pay import Pay from paypal import PayPal from cash import Cash from card import Card def process_pay(payment_method, amount): return payment_method.make_pay(amount) pay = Pay() print(process_pay(pay, 400)) paypal = PayPal("test@mail.com") print(process_pay(paypal, 240)) cash = Cash() print(process_pay(cash, 400)) card = Card("4913478952471122") print(process_pay(card, 100)) card1 = Card("913478952471122") print(process_pay(card1, 100))
class Pay: def make_pay(self, quantity): return { "realized": True, "quantity": quantity } class PayPal(Pay): def __init__(self,email): self.email=email def make_pay(self,quantity): pay_info = super().make_pay(quantity) pay_info.update({ "platform":"PayPal", "email":self.email }) return pay_info class Card(Pay): def __init__(self,card_number): self.card_number=card_number def make_pay(self, quantity): if len(self.card_number)==16: pay_info=super().make_pay(quantity) pay_info.update({ 'last_card_numbers':self.card_number[-4:] }) return pay_info else: raise Exception("El número de la tarjeta no tiene 16 digitos") class Cash(Pay): def make_pay(self, quantity): return super().make_pay(quantity) def process_pay(payment_method, amount): return payment_method.make_pay(amount) card = Card("4913478952471122") print(process_pay(card, 100)) paypal = PayPal("test@mail.com") print(process_pay(paypal, 240)) cash = Cash() print(process_pay(cash, 400))
Solución …
Hay bugs en los tests test_card_inherits_from_pay y test_cash_inherits_from_pay. Sería genial si pudieran revisarlo, saludos 👋.
.
from pay import Pay class Card(Pay): def __init__(self, card_number): self.card_number = card_number def make_pay(self, quantity): if len(self.card_number) != 16: raise Exception("invalid card number length") info = super().make_pay(quantity) info["last_card_numbers"] = self.card_number[-4:] return info
Cash:
from pay import Pay class Cash(Pay): def make_pay(self, quantity): return super().make_pay(quantity)
Main:
def process_pay(payment_method, amount): return payment_method.make_pay(amount)
Pay:
class Pay: def make_pay(self, quantity): return { "realized": True, "quantity": quantity }
Paypal:
from pay import Pay class PayPal(Pay): def __init__(self, email): self.email = email def make_pay(self, quantity): info = super().make_pay(quantity) info.update({ "platform": "PayPal", "email": self.email }) return info
hola este es mi aporte, solo paso un test pero la logica funciona tal cual pide el ejecrcicio.
class Pay: def make_pay(self, amount): return { "realized": True, "quantity": amount } class PayPal(Pay): def __init__(self, email=None): self.email = email def make_pay(self, amount): result = super().make_pay(amount) result["platform"] = "PayPal" result["email"] = self.email return result class Card(Pay): def __init__(self, card_number=None): self.card_number = card_number def make_pay(self, amount): if self.card_number is None or len(self.card_number) != 16: raise Exception("Invalid card number") result = super().make_pay(amount) result["last_card_numbers"] = self.card_number[-4:] return result class Cash(Pay): def __init__(self): pass def process_pay(payment_method, amount): return payment_method.make_pay(amount) ```class Pay: def make\_pay(self, amount): return { "realized": True, "quantity": amount } class PayPal(Pay): def \_\_init\_\_(self, email=None): self.email = email def make\_pay(self, amount): result = super().make\_pay(amount) result\["platform"] = "PayPal" result\["email"] = self.email return result class Card(Pay): def \_\_init\_\_(self, card\_number=None): self.card\_number = card\_number def make\_pay(self, amount): if self.card\_number is None or len(self.card\_number) != 16: raise Exception("Invalid card number") result = super().make\_pay(amount) result\["last\_card\_numbers"] = self.card\_number\[-4:] return result class Cash(Pay): def \_\_init\_\_(self): pass def process\_pay(payment\_method, amount): return payment\_method.make\_pay(amount)
it's ok
Al igual que la clase playground 37, los test tienen errores
Creo que estos últimos ejercicios no tienen un planteamiento completo sobre lo que trata el mismo ejercicio. Cosas que ya había visto con otros ejercicios y cursos. No terminas de entender o aprender completamente si está bien hecho el código, la lógica, los procesos, obteniendo un verdadero resultado final de acuerdo a todo lo que pide el ejercicio. Quedo a las derivas con los ejercicios de entre parentesis "casos reales". Toca buscar aprender y complementar por otros medios. Que no es malo, sino que se paga por estos cursos y en parte ayuda, pero creo que es para dar más sobre todo en los proyectos, ejercicios y prácticas que plantean en los cursos. . . Ojalá si plantean un caso real, de principio a fin sean buenas prácticas, nada quede al aire, cada variable, funcion y clase al final del ejercicio se vea que todo está hecho, todo tiene fluidez y no quedar el ejericio estancado sin saber si está bien o que no está bien cuando muchas veces no resuelven los ejercicios como es. Hablo de mi expericiencia sobre todo aprendiendo python.
No quedo claro si mi linea de aprendizaje está creciendo, estancada o bajando a no quedar claro en los ultimos ejercicios si está bien hecho o no a pesar de que no hay una sola forma de resolver. . . Frustra pasar un buen rato cuando el test no pasa, pero cuando ves la solución, el código de la solución hace la misma funcionalidad pero igual no pasa el test. No quedo claro del todo.
Mi código, fallando los test de herencia para Card y Cash como a mis otros compañeros, aunque se resuelve correctamente la lógica de los ejemplos.
# pay.py class Pay: def make_pay(self, quantity): return { "realized": True, "quantity": quantity }
# card.py from pay import Pay class Card(Pay): def __init__(self, card_number): self.card_number = card_number def make_pay(self, quantity): if len(self.card_number) != 16: raise Exception("Invalid card number") last_digits = self.card_number[-4:] payment_info = super().make_pay(quantity) payment_info["last_card_numbers"] = last_digits return payment_info
# cash.py from pay import Pay class Cash(Pay): def make_pay(self, quantity): return super().make_pay(quantity)
# paypal.py from pay import Pay class PayPal(Pay): def __init__(self, email): self.email = email def make_pay(self, quantity): payment_info = super().make_pay(quantity) payment_info["platform"] = "PayPal" payment_info["email"] = self.email return payment_info
# main.py from card import Card from cash import Cash from pay import Pay from paypal import PayPal def process_pay(payment_method, amount): return payment_method.make_pay(amount)
PPFF CADA VEZ ESTA MAS FACIL ESTO
# PASO 1 # Bueno primero que nada te piden que crees una clase base (padre) que se llame Pagar class Pagar: def __init__(self): # agregamos su método constructor pass def hacer_pago(self, total_a_pagar): return { "realizado": True, "cantidad": total_a_pagar } # seguido de eso debe de contener un único método llamado hacer_pago (make_pay) """Este método recibirá el total_a_pagar y devolverá un objeto con dos propiedades realized: true quantity: $cantidadAPagar""" """Además, deberás crear también las clases PayPal, Tarjeta (Card) y Efectivo (Cash), donde cada una debe heredar de la clase Pay. Tenemos que crear paypal.py, efectivo.py y tarjeta.py"""
# PASO 2 """La clase PayPal debe recibir un correo (email) en el constructor y el método make_pay debe agregar las propiedades: plataforma: "PayPal" correo: $EmailRecibido.""" from pagar import Pagar class PayPal(Pagar): # creamos la la clase hija que hereda la clase padre Pagar, recordemos que si queremos que esto funcione hay que importar Pagar def __init__(self, correo): #creamos su método constructor simepre usando self seguido del parámetro que utilizaremos en este caso correo self.xyz = correo # como dato si ponemos self.correo = correo no significan lo mismo, self.correo esta haciendo referencia a si mismo y despues del = correo es el parametro que recibiremos por ejemplo test@mail.com def hacer_pago(self, total_a_pagar): informacion_de_pago = super().hacer_pago(total_a_pagar) informacion_de_pago['plataforma'] = 'PayPal' informacion_de_pago['correo'] = self.xyz return informacion_de_pago
# PASO 3 """La clase Card recibirá un número de tarjeta de 16 dígitos. Al momento de acceder al método hacer_pago, se validará si la tarjeta en cuestión tiene esa longitud. En caso de no tener los 16 dígitos, se debe lanzar una Exception. En caso contrario, al método que proviene de la clase padre Pagar, se le agregará la propiedad de ultimos_4_digitos: donde se devolverán los últimos 4 dígitos de la tarjeta.""" # improtamos la clase padre Pagar from pagar import Pagar class Tarjeta(Pagar): # la clase Tarjeta hereda la superclase Pagar def __init__(self, numero_de_tarjeta): # creamos método constructor self.numero_de_tarjeta = numero_de_tarjeta # hacemos referencia al parámetro def hacer_pago(self, total_a_pagar): if len(self.numero_de_tarjeta) != 16: # raise Exception("La tarjeta debe contener 16 dígitos") informacion_de_pago = super().hacer_pago(total_a_pagar) # aqui con super()estamos heredando de la superclase Pagar donde ahi se encuentra el método def hacer_pago() informacion_de_pago["ultimos_4_digitos"] = self.numero_de_tarjeta[-4:] # return informacion_de_pago
# PASO 4 """La clase Efectivo simplemente nos devolverá lo mismo que la clase base Pagar.""" # importamos la clase Pagar from pagar import Pagar class Efectivo(Pagar): pass
# PASO 5 # OJO AQUI ME DIO EL SIGUIETE ERROR PORQUE NO ESTOY IMPORTANDO LOS MODULOS, EN ESTE CASO OCUPO EL MODULO pagar.py """ line 11, in <module> pagar = Pagar() NameError: name 'Pagar' is not defined""" from pagar import Pagar from efectivo import Efectivo from paypal import PayPal from tarjeta import Tarjeta """Por último se debe implementar la lógica de la función procesar_pago la cual recibirá un metodo_de_pago y la cantidad total_a_pagar, para poder devolver el objeto llamando al método hacer_pago de cada entidad recibida.""" # esto es super fácil debemos crear una funcion que retorne otra función con el objeto que ocupamos como el correo, la tarjeta, etc. def procesar_pago(metodo_de_pago, total_a_pagar): return metodo_de_pago.hacer_pago(total_a_pagar) print('**********Ejemplo 1:********** ') tarjeta = Tarjeta("4913478952471122") print(procesar_pago(tarjeta, 100)) # {'realizado': True, 'cantidad': 100, 'ultimos_4_digitos': '1122'} print('\n**********Ejemplo 2:**********') paypal = PayPal("test@mail.com") print(procesar_pago(paypal, 240)) # {'realizado': True, 'cantidad': 240, 'plataforma': 'PayPal', 'correo': 'test@mail.com'} print('\n**********Ejemplo 3:**********') efectivo = Efectivo() print(procesar_pago(efectivo, 400)) # {'realizado': True, 'cantidad': 400} pagar = Pagar() print(procesar_pago(pagar, 400)) # {'realizado': True, 'cantidad': 400} print('\n********** Ejemplo con Error de tarjeta: **********') tarjeta1 = Tarjeta("91347895247113453645634563453634221") print(procesar_pago(tarjeta1, 100)) """File "/home/runner/python-reto21dias/sistemaPagos/tarjeta.py", line 15, in hacer_pago raise Exception("La tarjeta debe contener 16 dígitos") Exception: La tarjeta debe contener 16 dígitos"""
#card.py from pay import Pay class Card(Pay): def __init__(self, card_number): self.card_number = card_number def make_pay(self, quantity): if len(self.card_number) != 16: raise Exception("El número de tarjeta no es correcto") make_pay = super().make_pay(quantity) make_pay["last_card_numbers"] = self.card_number[-4:] return make_pay
#cash.py from pay import Pay class Cash(Pay): def make_pay(self, quantity): return super().make_pay(quantity)
#main.py from cash import Cash from paypal import PayPal from card import Card def process_pay(payment_method, amount): return payment_method.make_pay(amount)
#pay.py class Pay: def make_pay(self, quantity): return { "realized": True, "quantity": quantity }
#paypal.py from pay import Pay class PayPal(Pay): def __init__(self, email): self.email = email def make_pay(self, quantity): make_pay = super().make_pay(quantity) make_pay["platform"] = "PayPal" make_pay["email"] = self.email return make_pay
. . . . . . . . . . . . No pues igual hubieron dos test que no me pasaron y no entendi porque
. Main
from paypal import PayPal from cash import Cash from card import Card def process_pay(payment_method, amount): return payment_method.make_pay(amount)
Pay
class Pay: def make_pay(self, cash): return {"realized": True, "quantity": cash}
Paypal
from pay import Pay class PayPal(Pay): def __init__(self, email): self.email = email def make_pay(self, cash): return super().make_pay(cash) | {"platform": "PayPal", "email": self.email}
Card
from pay import Pay class Card(Pay): def __init__(self, n_card): self.n_card = n_card def make_pay(self, cash): if len(self.n_card) != 16: raise Exception( "El numero que proporciono no cuenta con los 16 digitos requeridos") return super().make_pay(cash) | {"last_card_numbers": self.n_card[-4:]}
Cash
from pay import Pay class Cash(Pay): pass
# main.py: from paypal import PayPal from cash import Cash from card import Card def process_pay(payment_method, amount): return payment_method.make_pay(amount) # pay.py: class Pay: def make_pay(self, quantity): return { "realized": True, "quantity": quantity } # paypal.py: from pay import Pay class PayPal(Pay): def __init__(self, email) -> None: super().__init__() self._email = email def make_pay(self, quantity): info = super().make_pay(quantity) info["platform"] = "PayPal" info["email"] = self._email return info @property def email(self): return self._email @email.setter def email(self, email): self._email = email # cash.py: from pay import Pay class Cash(Pay): pass # card.py: from pay import Pay class Card(Pay): def __init__(self, card_number) -> None: super().__init__() self._card_number = card_number def make_pay(self, quantity): if len(self._card_number) == 16: info = super().make_pay(quantity) info["last_card_numbers"] = self._card_number[12:] return info else: raise Exception("La longitud de la tarjeta debe ser de 16 digitos") @property def card_number(self): return self._card_number @card_number.setter def card_number(self, card_number): self._card_number = card_number
mi aporte aunque no psó del todo, me da un error de assert False is True para los inherits de cash y card aunque comparé con la solución de platzi y no veo diferencia * * * * * *
pay
class Pay: #Tu código aquí 👇 def make_pay(self, cantidadAPagar): return {'realized': True, 'quantity': cantidadAPagar}
cash
from pay import Pay class Cash(Pay): def make_pay(self, cantidadApagar): return super().make_pay(cantidadApagar)
card.
from pay import Pay class Card(Pay): # Tu código aquí 👇 def __init__(self, card_numbers): self.card_numbers = card_numbers def make_pay(self, cantidadAPagar): if len(self.card_numbers) != 16: raise Exception("el numero de tarjeta debe tener 16 digitos") respuesta = super().make_pay(cantidadAPagar) respuesta['last_card_numbers'] = self.card_numbers[-4:] return respuesta
paypal
from pay import Pay class PayPal(Pay): # Tu código aquí 👇 def __init__(self, email): self.email = email def make_pay(self, cantidadAPagar): respuesta = super().make_pay(cantidadAPagar) respuesta['platform']= 'PayPal' respuesta['email']= self.email return respuesta
main
from card import Card from cash import Cash from paypal import PayPal def process_pay(payment_method, amount): # Tu código aquí 👇 return payment_method.make_pay(amount)
class Pay: def make_pay(self, quantity_to_pay): return { "realized" : True, "quantity" : quantity_to_pay } from pay import Pay class PayPal(Pay): def __init__(self, email): self._email = email def make_pay(self, quantity_to_pay): response = super().make_pay(quantity_to_pay) response['platform'] = 'PayPal' response['email'] = self._email return response from pay import Pay class Card(Pay): def __init__(self,number_card): self._number_card = number_card def make_pay(self, quantity_to_pay): if len(self._number_card) != 16: raise Exception("El numero de tarjeta no es valido") response = super().make_pay(quantity_to_pay) response['last_card_numbers'] = self._number_card[-4:] return response from pay import Pay class Cash(Pay): def make_pay(self, quantity_to_pay): return super().make_pay(quantity_to_pay) def process_pay(payment_method, amount): return payment_method.make_pay(amount)
