Playground - Encapsula datos de los usuarios

21 Días de Python

Contenido del curso

¡Te damos la bienvenida a este reto!

1
Empezando con Python desde 0
01:08 min

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

32
Playground - Crea un task manager usando closures

Día 11

33
Lectura de archivos de texto y CSV
03:32 min

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

56
¡Lo lograste!
01:24 min

Playground - Encapsula datos de los usuarios

Luis Kennedy Saavedra Fuentes

Estudiante

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 (__)

. . Este es el resultado del test con un solo guion bajo (_)

. . La misma soulción solo cambia la convencion para los atributos ptivados. Con un solo guion bajo y con 2 guion bajo el que falla los tests.

Nicolas Alpargatero

Testing 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`

Ángel Sabillón

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)

Platzi Team

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*

Salomon Chambi

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

Victor Ortiz

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

Waldir Zapata Garcia

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"

Alejandro Anaya

🛡️🛡️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

José Miguel Reyes

. . . . . . . . . .

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

Daniel Salazar Munoz

. .

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

iecgerman .

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)

Diego Gilabert

. . . . . . . . . . . . . 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

Cristofer Lux

Hola Me podrias explicar el metodo

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

Orlando Sánchez

* * * * *

hola me puedes explicar el metodo

Linda Atenea Mejía Usme

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

Harold Zurita Simon

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

andres barrera

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

Luis Gutiérrez Aguirre

. . . . . . . . .

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

Paola Alapizco

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

Gonzalo Gutiérrez Castillo

Aquí mi aporte, espero les sirva:

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

Gabriel Andrés Montiel Hermosa

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

Playground - Encapsula datos de los usuarios

¡Te damos la bienvenida a este reto!

Empezando con Python desde 0

Día 1

Variables, funciones y sintaxis básica

Tipos de datos: Numbers, Strings y Diccionarios

Playground - Retorna el tipo

Día 2

Operadores

Playground - Calcula la propina

Día 3

Condicionales

Playground - Averigua si un año es bisiesto

Ciclos

Playground - Dibuja un triangulo usando bucles

Día 4

Listas

Encuentra a los gatitos más famosos

Diccionarios

Obtén el promedio de los estudiantes

Tuplas

Obten la información de los paquetes

Día 5

Calcula la cantidad de letras en una oración

Encuentra el mayor palíndromo

Día 6

Sets

Encuentre la intersección de conjuntos

Día 7

List comprehension

Encuentra palabras con dos vocales

Dictionary Comprehension

Calcula la longitud de las palabras

Día 8

Funciones Lambda

Filtra mensajes de un user específico

Higher order functions

Crea tu propio método map

Día 9

Manejo de Errores y excepciones

Maneja correctamente los errores

Maneja las excepciones

Día 10

Playground - Crea un task manager usando closures

Día 11

Lectura de archivos de texto y CSV

Día 12

Programación orientada a objetos

Crea un auto usando clases

Día 13

Abstracción en Python

Playground - Crea un sistema de carrito de compras

Encapsulamiento en Python