Playground - Encapsula datos de los usuarios
Contenido del curso
Día 1
Día 2
Día 3
Día 4
Día 5
Día 6
Día 7
Día 8
Día 9
Día 10
Día 11
Día 12
Día 13
Día 14
Día 15
Día 16
Día 17
Día 18
Día 19
Día 20
Día 21
Playground - Encapsula datos de los usuarios
Contenido del curso
Playground - Encapsula datos de los usuarios
Nicolas Alpargatero
Estudiante
Luis Kennedy Saavedra Fuentes
Estudiante
Ángel Sabillón
Estudiante
Platzi Team
EstudiantePlatzi Team
Estudiante
Salomon Chambi
Estudiante
Victor Ortiz
EstudianteWaldir Zapata Garcia
EstudianteWaldir Zapata Garcia
Estudiante
Alejandro Anaya
Estudiante
José Miguel Reyes
Estudiante
Daniel Salazar Munoz
Estudiante
iecgerman .
Estudiante
Diego Gilabert
Estudiante
Cristofer Lux
EstudianteDiego Gilabert
Estudiante
Orlando Sánchez
EstudianteCristofer Lux
EstudianteLinda Atenea Mejía Usme
Estudiante
Harold Zurita Simon
Estudiante
andres barrera
Estudiante
Luis Gutiérrez Aguirre
Estudiante
Paola Alapizco
Estudiante
Gonzalo Gutiérrez Castillo
Estudiante
Gabriel Andrés Montiel Hermosa
EstudianteTesting el código para entenderlo mejor:
usuario1 = User("Juan", 20) usuario1.name = "Pepito" print(usuario1.name) `AttributeError: property 'name' of 'User' object has no setter`
Declare mis variables privadas con doble guion bajo (__), por lo mismo que leí en la clase que 1 solo guin bajo es no es buena practica (_) . Lo leí en el conceptop de convenciones y nomeclatura: .
Convenciones de Nomenclatura: En Python, se utilizan convenciones de nomenclatura para indicar el nivel de accesibilidad de los atributos y métodos de una clase. La convención más común es utilizar un guion bajo () al comienzo de un nombre de atributo o método para indicar que es un atributo o método privado, es decir, que no debería ser accedido directamente desde fuera de la clase.++ Aunque no hay restricciones técnicas para acceder a estos atributos o métodos, se considera una buena práctica no hacerlo Por ejemplo:++. . . Entonces en el test solamente aprobó 2 de los 6 test, y cuando veo la solucion, lo unico que varia es la conveción que utilizamos que fue en mi caso 2 guiones bajos (__) y el de la solución 1 guin bajo() . Entonces me confunde un poco que en la clase nos enseñen ambos y que 1 solo guion bajo (_) es mala práctica. . Este fue mi ejercicio con doble guion bajo (__)
class User: """Class user.""" def __init__(self, name, age): self.__name = name self.__age = age self.__friends = [] self.__messages = [] @property def name(self): """@Property decorator to method name""" return self.__name @name.setter def name(self, name): """@name.setter decorator to modify method name""" self.__name = name @property def age(self): """@Property decorator to method age""" return self.__age @age.setter def age(self, age): """@name.setter decorator to modify method name""" self.__age = age def addFriend(self, friend): """Add friend method""" self.__friends.append(friend) def sendMessage(self, message, friend): """Send message method""" self.__messages.append(message) friend.__messages.append(message) def showMessages(self): """Show Messages method""" return self.__messages # Example 1 # usuario1 = User("Juan", 20) # usuario2 = User("Maria", 25) # usuario1.addFriend(usuario2) # usuario1.sendMessage("Hola Maria!", usuario2) # r = usuario1.showMessages() # print(r) # Example 2 usuario1 = User("Juan", 20) usuario1.name = "Pepito" print(usuario1.name)
Este es el resultado del test con doble guion hajo (__)
Alguien me puede explicar por qué en este método, agregamos mensaje a friend? No debería bastar solamente con la línea de self...?
def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message)
A ti te estan pasando otro objeto de la clase User, por lo que para acceder a los atributos del objeto usas su instancia, en este caso el "friend". Si por ejemplo te pasaran una instancia diferente que no tuviese ese atributo el programa fallaria
Usando su instancia*
Mi solucion:
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] @property def name(self): return self._name @name.setter def name(self, new_name): self._name = new_name @property def age(self): return self._age @age.setter def age(self, new_age): self._age = new_age def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages
Mi ejercicio: . . . . . . . . . . . . . . . . . .
class User: def __init__(self, name, age): #Tu código aquí 👇 self._name = name self._age = age self._friends = [] self._messages = [] @property def name(self): return self._name @name.setter def name(self, newName): self._name = newName @property def age(self): return self._age @age.setter def age(self, newAge): self._age = newAge def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages
class User: #variables privadas name, age, friends, message def __init__(self, name, age): self.__name = name self.__age = age self._friends=[] self.__lstmessages=[] @property def age(self): return self.__age @age.setter def age(self, valor): self.__age = valor @property def name(self): return self.__name @name.setter def name(self, valor): self.__name = valor @property def friends(self): return self._friends @friends.setter def friends(self, valor): #print("en dict") self._friends.append(valor) @property def lstmessages(self): return self.__lstmessages @lstmessages.setter def lstmessages(self, valor): #print("en mensaje") self.__lstmessages.append(valor) #agrega un usuario a la lista de amigos del usuario actual. def addFriend(self, friend): self._friends.append(friend) #agrega un mensaje a la lista de mensajes del usuario actual y al amigo especificado. def sendMessage(self, message, friend): self.__lstmessages.append(message) friend.__lstmessages.append(message) #devuelve la lista de mensajes del usuario actual. def showMessages(self): return self.__lstmessages if __name__ == '__main__': usuario1 = User("Juan", 20) usuario2 = User("Maria", 25) usuario1.addFriend(usuario2) usuario1.sendMessage("Hola Maria!", usuario2) print(usuario1.showMessages()) #output: ['Hola Maria!'] usuario1 = User("Juan", 20) usuario1.name = "Pepito" print(usuario1.name) #Output: "Pepito"
🛡️🛡️Escudo anti-spoilers🛡️🛡️
Mi solución al reto:
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] @property def name(self): return self._name @name.setter def name(self, v): self._name = v @property def age(self): return self._age @age.setter def age(self, v): self._age = v def addFriend(self, friend): self._friends.append(friend) pass def sendMessage(self, msg, toFriend): self._messages.append(msg) toFriend._messages.append(msg) def showMessages(self): return self._messages
Mi código:
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] def addFriend(self, friend): self._friends.append(friend) friend._friends.append(self) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages @property def name(self): return self._name @name.setter def name(self, new_name): self._name = new_name @property def age(self): return self._age @age.setter def age(self, new_age): self._age = new_age
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] @property def name(self): return self._name @name.setter def name(self, Name): self._name = Name @property def age(self): return self._age @age.setter def age(self, Age): self._age = Age def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages
class Usuario: def __init__(self, nombre, edad): self._nombre = nombre # ojo hay que poner guión bajo, para tener buenas practicas y saber que son datos privados self._edad = edad self._amigos = [] # lista de diccionarios Usuario self._mensajes = [] # lista de strings # creamos los métodos públicos def agregarAmigo(self, amigo): self._amigos.append(amigo) def enviarMensajes(self, mensaje, amigo): self._mensajes.append(mensaje) self._mensajes.append(mensaje) def mostrarMensajes(self): return self._mensajes @property #esto es como usar get_nombre def nombre(self): return self._nombre # @nombre.setter # esto equivale a usar set_nombre def nombre(self, valor): self._nombre = valor @property def edad(self): return self._edad @edad.setter def edad(self, valor): self.edad = valor usuario1 = Usuario("Juan", 20) usuario2 = Usuario("Maria", 25) usuario1.agregarAmigo(usuario2) usuario1.enviarMensajes("Hola Maria!", usuario2) usuario1.mostrarMensajes() usuario1 = Usuario("Juan", 20) usuario2 = Usuario("Maria", 25) usuario1.agregarAmigo(usuario2) usuario1.enviarMensajes("Hola Maria!", usuario2) print(usuario1.mostrarMensajes()) # ['Hola Maria!', 'Hola Maria!'] usuario1 = Usuario("Juan", 20) usuario1.nombre = "Pepito" print(usuario1.nombre)
. . . . . . . . . . . . . Mi codigo
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] @property def name(self): return self._name @property def age(self): return self._age @property def friends(self): return self._friends @property def messages(self): return self._messages @name.setter def name(self, new_name): self._name = new_name @age.setter def age(self, new_age): self._age = new_age @friends.setter def friends(self, new_friend): self._friends = new_friend @messages.setter def messages(self, new_message): self._messages = new_message def addFriend(self, friend): self.friends.append(friend) def sendMessage(self, message, friend): self.messages.append(message) friend.messages.append(message) def showMessages(self): return self._messages
Hola Me podrias explicar el metodo
def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message)
si entiendo que con el self.messages.append(message) se agrega el mensaje, pero para que es o como funciona el friend.messages.append(messages)
friend es de la clase User, entonces para que tenga coherencia la conversacion, message debe estar almacenado tanto en los mensajes de del usuario1 como del usuario2
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] @property def name(self): return self._name @name.setter def name(self, new_name): self._name = new_name @property def age(self): return self._age @age.setter def age(self, new_age): self._age = new_age def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages
hola me puedes explicar el metodo
def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message)
si entiendo que con el self.messages.append(message) se agrega el mensaje, pero para que es o como funciona el friend.messages.append(messages)
Envío mi solución, sin embargo, aunque pasó las pruebas, después supe que esta necesita una corrección en cuanto a como se modifican los mesajes de friend en el método sendMessage(message, friend) ya que al tratarse de una atributo privado no se debe acceder como estoy accediendo en mi código, sinó que, _messages debe tener un setter para poder realizar modificaciones sobre friend desde ese método.
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages @property def name(self): return self._name @name.setter def name(self, new_name): self._name = new_name @property def age(self): return self._age @age.setter def age(self, new_age): self._age = new_age
Solución 😄… .
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) def showMessages(self): return self._messages @property def name(self): return self._name @property def age(self): return self._age @property def friends(self): return self._friends @property def messages(self): return self._messages @name.setter def name(self, name): self._name = name @age.setter def age(self, age): self._age = age @friends.setter def friends(self, friends): self._friends = friends @messages.setter def messages(self, messages): self._messages = messages
class Usuario: def init(self, Nombre, Edad): self._Nombre = Nombre self._Edad = Edad self._Amigos = [] self._Mensajes = []
def addFriend(self, Amigo): self._Amigos.append(Amigo) def sendMessage(self, Mensaje, Amigo): self._Mensajes.append({"Mensaje": Mensaje, "Amigo": Amigo}) def showMessages(self): Mensajes = [msg["Mensaje"] for msg in self._Mensajes] return Mensajes @property def Nombre(self): return self._Nombre @Nombre.setter def Nombre(self, Nuevo_Nombre): self._Nombre = Nuevo_Nombre @property def Edad(self): return self._Edad @age.setter def Edad(self, Nueva_Edad): self._Edad = Nueva_Edad
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append({"message": message, "friend": friend}) def showMessages(self): messages = [msg["message"] for msg in self._messages] return messages @property def name(self): return self._name @name.setter def name(self, new_name): self._name = new_name @property def age(self): return self._age @age.setter def age(self, new_age): self._age = new_age
Aquí mi solución, me está costando trabajo pero debo practicar más
Aquí mi solución :computer: :snake:
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._messages = [] # getters @property def name(self): return self._name @property def age(self): return self._age @property def friends(self): return self._friends @property def messages(self): return self._messages # setters @name.setter def name(self, value): self._name = value @age.setter def age(self, value): self._age = value @messages.setter def messages(self, message): self._messages.append(message) # Metodos def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend.messages = message def showMessages(self): return self.messages
class User: def __init__(self, name, age): self._name = name self._age = age self._friends:User = [] self._messages=[] @property def name(self): return self._name @name.setter def name(self, new_name): self._name=new_name @property def age(self): return self._age @age.setter def age(self, new_age): self._age=new_age def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._messages.append(message) friend._messages.append(message) @property def messages(self): return self._messages def showMessages(self): return self.messages
class User: def __init__(self, name, age): self._name = name self._age = age self._friends = [] self._mesasages = [] @property def name(self): return self._name @name.setter def name(self, name): self._name = name @property def age(self): return self._age @age.setter def age(self, age): self._age = age def addFriend(self, friend): self._friends.append(friend) def sendMessage(self, message, friend): self._mesasages.append(message) friend._mesasages.append(message) def showMessages(self): return self._mesasages