Les dejo un buen ejemplo/definicion de la diferencia entre metodos publicos y privados:
Un método público es aquel que permite a otras clases externas acceder a sus datos.
El computador con una persona (son dos clases) persona prende el computador, el prender es un método público.
Un método privado es aquel que permite el acceso a sus métodos, a través de datos internos de la misma clase y no a través de clases externas.
Ejemplo: En el mismo ejemplo anterior del computador: el cargar Windows es un método privado.
Ej. Público hablar frente en un auditorio y privado lo que esta pensando la persona.
Solo recuerda que en python no existen como tal los métodos públicos y privados, por convención se usa el doble guion bajo __ al principio y final, pero esto no quiere decir que el método no sea accesible desde afuera. Solo por aclarar
como es eso? del doble _ ? Pense que era uno solo y alpricipio de del metodo
Por si les interesa, hice LO MISMO del ejemplo pero utilizando un auto.
Tiene funciones como: “Cargar nafta”, “Subir personas”, “Acelerar” y “Moverse”.
No sigue a la perfección el patrón de orientado a objetos, pero me gusto como quedó.
Algunas funciones:
No nos deja “Moverse” si previamente no habian “Acelerado” (Medio raro eso debería acelerar a medida que te moves, pero aca estableces la velocidad de movimiento al acelerar).
Al “Moverse” el auto va consumiendo una variable propia llamada “Nafta” que es un calculo entre el consumo base por metro, la cantidad de personas y la distancia a recorrer.
Les dejo el código mas abajo.
# Clases y Objetos# Modelado de un auto
# TODO:Se le podria agregar que al retornar el tiempo, lo divida en "HH:MM:SS".# TODO:Se podria agregar que vaya acelerando a medida que se va moviendo.classAuto: _Autos =['''
_______
_/\______\\__
/,-.-|-,-.`-.
`( o )----( o )-'
`-' `-''','''
_______
_-_- _/\______\\__
_-_-__ /,-.-|-,-.`-.
_-_- `( o )----( o )-'
`-' `-'''
] def __init__(self): self._is_turned_on=False self.set_deffaul_values() def __init__(self, _is_turned_on): self._is_turned_on= _is_turned_on
self.set_deffaul_values() def set_deffaul_values(self): self._current_speed=0 self._capacidad_maxima_nafta=20000 self._nafta_level= self._capacidad_maxima_nafta self._velocidad_maxima=200 self._consumo_nafta_por_metro=2 self._capacidad_maxima_personas=5 self._personas_a_bordo=1 self._metros_recorridos=0 self._tiempo_en_viaje=0 def encender(self): self._is_turned_on=True self.mostrar_estado() def apagar(self):if(self._is_turned_on and self._current_speed==0): self._is_turned_on=False self.mostrar_estado()else:print("\t ERROR - El auto debe estar quieto.") # Se utiliza para definir la velocidad del auto al moverse(debería ir acelerando a medida que se mueve, pero bueno Já) def acelerar(self, velocidad_a_incrementar):if(self._is_turned_on):if(velocidad_a_incrementar >0):if((self._velocidad_maxima- self._current_speed)- velocidad_a_incrementar >=0): self._current_speed+= velocidad_a_incrementar
else: self._current_speed= self._velocidad_maximaelse:print("\t ERROR - Debe encender el auto primero.") def frenar(self, velocidad_a_reducir):if(self._is_turned_on):if(velocidad_a_reducir >0):if(self._current_speed- velocidad_a_reducir >=0): self._current_speed-= velocidad_a_reducir
else:print("\t ERROR - Debe encender el auto primero.") def cargar_nafta(self, _cantidad_litros):if(_cantidad_litros >0):if(self._nafta_level+ _cantidad_litros <= self._capacidad_maxima_nafta): self._nafta_level+= _cantidad_litros
else: self._nafta_level= self._capacidad_maxima_naftaelse:print("\t ERROR - No se puede cargar esa cantidad.") # Recibe los metros que se quiere mover el auto, y calcula cuanta nafata consume.Retorna los metros que logra recorrer.defmetros_posibles_restar_nafta(self, _metros_recorrer):if(self._is_turned_on and self._current_speed>0): consumo_personas =(1+float(self._personas_a_bordo/10)) costo_por_metro = self._consumo_nafta_por_metro* consumo_personas
nafta_por_consumir =(costo_por_metro * _metros_recorrer)if self._nafta_level- nafta_por_consumir >0: self._nafta_level-= nafta_por_consumir
return _metros_recorrer # Recorrio todo esto
else: metros_recorridos =int(self._nafta_level/(consumo_personas * self._consumo_nafta_por_metro)) self._nafta_level=0return metros_recorridos
else:print("\t ERROR - El auto debe estar en movimiento.")return0 # Para moverse, utiliza la velocidad que fue puesta al "acelerar()" def moverse(self, _cantidad_metros_recorrer):if(self._is_turned_on): metrosRecorridos = self.metros_posibles_restar_nafta(_cantidad_metros_recorrer) self._metros_recorridos+= metrosRecorridos
self._tiempo_en_viaje+=int(metrosRecorridos / self._current_speed*1000)if(self._nafta_level==0): self._is_turned_on=False self._current_speed=0else:print("\t ERROR - Debe encender el auto primero.") def subir_personas(self, _cantidad_personas):if(_cantidad_personas >0):if(self._personas_a_bordo+ _cantidad_personas < self._capacidad_maxima_personas): self._personas_a_bordo+= _cantidad_personas
else: self._personas_a_bordo= self._capacidad_maxima_personas def bajar_personas(self, _cantidad_personas):if(_cantidad_personas >0):if(self._personas_a_bordo- _cantidad_personas >=0): self._personas_a_bordo-= _cantidad_personas
else:print("\t ERROR - No puede haber una cantidad negativa de personas") def mostrar_estado(self):if self._is_turned_on:print(self._Autos[1])else:print(self._Autos[0]) # Muestra todas las variables y constantes del Auto def mostrar_valores(self):print('''
Estado:{0},Velocidad:{1}Km/h,CapacidadMáxima Nafta:{2},Nivel de Nafta:{3},VelocidadMáxima Posible:{4}Km/h,ConsumoPorMetro:{5},CapacidadMáxima Personas:{6},Personas a Bordo:{7},MetrosRecorridos:{8},Tiempo en viaje:{9}Hs'''.format( self._is_turned_on, self._current_speed, self._capacidad_maxima_nafta, self._nafta_level, self._velocidad_maxima, self._consumo_nafta_por_metro, self._capacidad_maxima_personas, self._personas_a_bordo, self._metros_recorridos, self._tiempo_en_viaje/1000))def run(): auto1 =Auto(_is_turned_on=True)whileTrue: commando =str(input('''
¿Qué desea hacer?[E]ncender.[A]pagar.[Ac]elerar.[F]renar.[M]over.[Su]bir personas.[B]ajar personas.[C]argar nafta.[Mo]strar TODO.[S]alir. \n\t Eleccion:''')).lower()if commando =="e": auto1.encender() elif commando =="a": auto1.apagar() elif commando =="ac": auto1.acelerar(int(input("Velocidad incrementar: "))) elif commando =="f": auto1.frenar(int(input("Velocidad reducir: "))) elif commando =="m": auto1.moverse(int(input("Cantidad kilometros a recorrer: "))) elif commando =="su": auto1.subir_personas(int(input("Cantidad personas suben: "))) elif commando =="b": auto1.bajar_personas(int(input("Cantidad personas bajan: "))) elif commando =="c": auto1.cargar_nafta(int(input("Cantidad litros cargar: "))) elif commando =="mo": auto1.mostrar_estado() auto1.mostrar_valores() elif commando =="s":breakelse:breaktry:run()except KeyboardInterrupt:print("\n\n\t Adios!!!")
Por que tiene 2 init ? no genera un problema definir dos funciones o métodos iguales?
Eso se llama “sobrecarga”.
Lo que hace es que si yo llamo al constructor sin pasarle parámetro, ejecuta uno y si le paso un parámetro ejecuta el otro.
Por ejemplo:
Honestamente me ha tocado ir a otros sitios (Udemy), para aclarar muchos conceptos que aqui del todo ni se nombran. No me gusta para nada explicaciones tan superficiales de un tema que deberia ser el core del curso.
Hay dos cursos de POO con Python en Platzi
Hola Xavier me podrias indicar los nombres o en que carrera se encuentran.
Gracias
Para repasar:
clases: la lampara
objetos (atributos): prendido, apagado
metodos: init,
turn_on
turn_off,
_display_image
para declarar variables en el objeto todas deben empezar con self.variable
muy buen resumen Ibu
Modelando una televisión con los controles de prendido, apagado, y cambio de canales arriba y abajo. Saludos
classCat: _CATS =['''
_..---...,""-._,/}/).'',``..'(/-</ _ {) \
; _ `. `.<a(,' ( \ )`. \ __.._ .: y
( <\_-) )'-.____...\ `._//-'`. `-' /-._)))`-._)))
`...' ''','''
, _..---...,""-._,/}/).'',``..'(/-</ _ {) \ MMIIAUU; _ `. `.<a(MMMIIA===AUU,' ( \ )`. \ __.._ ./0 M M M II A A UUUUU
( <\_-) )'-.____...\ `._ __\_\,`. `-' /-._)))`-._)))
`...'
'''] def __init__(self, says_meaow): self._meaows=False def meaows(self): self.says_meaow=True self._display_cat() def not_meaows(self): self.says_meaow=False self._display_cat() def _display_cat(self):if self.says_meaow:print(self._CATS[1])else:print(self._CATS[0])def run(): cat =Cat(says_meaow=False)whileTrue: command =input('''
¿Desas que el gatico diga Miau?Si: oprime s
No: oprime n
Salir: oprime e
''')if command =='s': cat.meaows() elif command =='n': cat.not_meaows() elif command =='e':breakelse:print('--*--*--*-- Comando inválido --*--*--*--')if __name__ =="__main__":run()
Jaja, práctico.
Me encantó
Buenas estaba revisando si encontraba el pdf de poo que dice en el vídeo pero por ningún lado sale, gracias
Algunas convenciones:
-Clases se comienzan con letras mayúsculas (Lamp y no lamp)
-Métodos "privados" empiezan con un guión bajo (_display_image)
-Constantes todo en mayúsculas y si es una variable de clase, con un guión bajo delante (_LAMPS)
-Funciones, Métodos, Variables, etc, en minúsculas
gracias!
Hola aquí dejo otras notas interesantes. Si un atributo es declarado con 2 (__) delante es un atributo privado que solo puede ser usado
dentro de la clase, esto es el encapsulamiento. Aquí les dejo un código donde creamos un dado y lo lanzamos mientras el valor no sea ni 1 ni 6 se pierde el juego.
""" Este programa es un juego de azar en el que se lanza un dado y si el valor no es ni 1 ni 6 se pierde.Para esto creamos la clase Dice con los atributos de un dado su valor y su cantidad de lados así como su comportamiento
como lo es el lanzarlo o girarlo para que obtengamos un valor al azar"""
#Importo libreria Randomimport random
classDice:"""Clase que crea un dado.Se puede lanzar el dado y obtener su valor.Darse cuenta que el array está declarado como contante
y además como privado ya que tiene dos(_) antes de dato.Que quiere decir esto?Ques una constante privada la cual solo puede ser
accedida dentro de su propia clase.Si tuviese un solo(_) sería una constante publica de la clase,así que cualquier pudiese
acceder a ella en el main por ejemplo"""
__DADO=["""
-----||| o |||-----""", """-----|o |||| o|-----""","""-----|o || o || o|-----""","""-----|o o||||o o|-----""", """-----|o o|| o ||o o|-----""", """-----|o o||o o||o o|-----"""] #Constante que define que el dado tiene 6 lados
__SIDES =6 #en el constructor de la clase no es necesario pasarle nada ya que se creará el dado con valor 1 def __init__(self): self.__value=1 #Con el metodo roll le damos un valor random de 1 a 6 a la instancia.Lo que es lo mismo que lanzar el dado
def roll(self): self.__value= random.randint(0,6) #Aquí mostramos el dibujo que corresponde al valor de dado obtenido
self.__display_dice() #este metodo es para obtener el valor del dado en el programa proncipal.De esa manera no es necesario accesar a la propia variable
#__value ya que es una variable privada que no queremos que sea modificada por el usuario a menos que use el metodo roll() def get_value(self):return self.__value #En este metodo mostramos la figura del dado que corresponda al valor generado cuando lanzamos el dado.Dense cuenta que en
# en este metodo tambien lo declaramos como un metodo privado que solo puede ser accedido dentro de la clase
def __display_dice(self):if self.__value is 1:print(self.__DADO[0]) elif self.__value is 2:print(self.__DADO[1]) elif self.__value is 3:print(self.__DADO[2]) elif self.__value is 4:print(self.__DADO[3]) elif self.__value is 5:print(self.__DADO[4])else:print(self.__DADO[5])def main(): dado =Dice() dado.roll()if1<dado.get_value() and dado.get_value()<6:print("perdiste, sacaste", dado.get_value())else:print("ganaste, sacaste", dado.get_value())
#intenten usar esta linea de codigo y verán que les arrojará error ya que es una variable privada
#print(dado.__SIDES)if __name__ =='__main__':main()```
gracias, justo algo que habia faltado en el video era explicar como se daclaraba una clase privada, esa pregunta la iba hacer
HERENCIA: capacidad de crear subclases a partir de una superclase o clase madre, la cuál le hereda atributos y métodos a la subclase, pero la subclase puede tener sus propios atributos y métodos.
POLIMORFISMO: Tolerancia al uso de diferentes tipos de datos por parte del lenguaje de programación, permitiendo, por ejemplo, la utilización de instancias de una superclase y sus subclases por parte de una función, o arreglo, etc.
COMPOSICIÓN: Forma en que una instancia A está compuesta por otra instancia B y al suceder cambios en el estado de la instancia B influyen en la instancia A.
Importante: La Herencia es entre clases/módulos, La Composición es entre objetos/instancias.
Hola, no hay documento de PDF
Hola, por favor me indican donde se encuentra el documento PDF relacionado con la modelación de objetos.
Gracias
Les dejo este código de la clase Doggy, donde creo una instancia dog en la que el usuario escoge el nombre de la mascota y le puse varios métodos:
En lo personal creo que es mejor tener la impresion del estado de la lampara en un metodo aparte y llamarlo cada vez que sea necesario, porque si necesitas o quieres hacer alguna modificacion a lo que quieres imprimir tendrias que hacerlo de uno por uno existiendo la posibilidad de que se te pase alguno. yo lo que hice fue modificar el metodo de _display_imagge() para que limpie la pantalla antes de mostrar la lampra
import os#modulo para limpiar pantalla
os.system("cls")#Windouws # os.system("clear")#Mac y Linux
jaja yo hice lo mismo por que me salia un error en display
Buenas tardes, llevo ya unas horas de estar intentando con el ejemplo y no entiendo porque me da el error y no funciona? que esta mal?
Error:
MacBook-Air-de-Carlos:Ejercicios carlos$ python lampmio.py
Traceback (most recent call last):
File "lampmio.py", line 60, in <module>
run()
File "lampmio.py", line 40, in run
lamp = Lamp(is_turned_on=False)
TypeError: this constructor takes no arguments
Hola Carlos! he repasado tu código una y otra vez y no veo el error, seguramente debe ser un bug, prueba borrando ese archivo y reescribe el código(no copies y pegues) y me cuentas. quedo atento
Me pasaba lo mismo, luego le quiete los argumentos a Lamp() y funcionó.
def run(): lamp =Lamp()
¿como se que un método es publico o privado? ¿por el "_" al inicio de la declaración?
En Python creo no hay ese tipo de encapsulación, pero por convención se usa el _ al inicio para indicar que no se puede usar por fuera de la clase o que es privado.
#Programa tomado del curso de Python# video 54,Desafio3.classLamp: #las clases siempre empiezan con minúsculas._LAMPS=['''
(\☻/)../█\
.../\...ΣշΣs ሀռ ለռցΣረ
''','''
{o,o}|)__)-"-"-'''
] #Variable clase, y tiene ascci art
#init es el constructor de la clase.def__init__(self, _is_turned_on): #método de instancia.self._is_turned_on=False #variable privada.#declaramos dos métodos públicos.defturn_on(self): self._is_turned_on=True self._display_image() def turn_off(self): self._is_turned_on=False self._display_image() #Ahora un método privado para mostrar en consola.def_display_image(self):if self._is_turned_on:print(self._LAMPS[0])else:print(self._LAMPS[1])def run(): lamp =Lamp(_is_turned_on=False)whileTrue: command =str(input('''
¿Qué deseas hacer?[p]render
[a]pagar
[s]alir
'''))if command =='p': lamp.turn_on() elif command =='a': lamp.turn_off()else:breakif __name__ =='__main__': #pnto de acceso al programa.run()
