Disfruta de nuestro contenido y eventos por un a帽o a un precio especial

Antes: $179

Currency
$149/a帽o
隆Suscr铆bete!

馃敟 Te quedan 馃敟

1D
6H
58M
9S

Programaci贸n Orientada a Objetos

2/25

Lectura

Uno de los elementos m谩s importantes de los lenguajes de programaci贸n es la utilizaci贸n de clases para organizar programas en m贸dulos y abstracciones de datos.

Las clases se pueden utilizar de diversas maneras. Pero en este art铆culo hablaremos de c贸mo utilizarlas en el contexto de la programaci贸n orientada a objetos. La clave para entender la programaci贸n orientada a objetos es pensar en objetos como agrupaciones de datos y los m茅todos que operan en dichos datos.

Por ejemplo, podemos representar a una persona con propiedades como nombre, edad, g茅nero, etc. y los comportamientos de dicha persona como caminar, cantar, comer, etc. De la misma manera podemos representar unos aud铆fonos con propiedades como su marca, tama帽o, color, etc. y sus comportamientos como reproducir m煤sica, pausar y avanzar a la siguiente canci贸n.

Puesto de otra manera, la programaci贸n orientada a objetos nos permite modelar cosas reales y concretas del mundo y sus relaciones con otros objetos.

Las ideas detr谩s de la programaci贸n orientada a objetos tienen m谩s de 50 a帽os y han sido ampliamente aceptadas y practicadas en los 煤ltimos treinta. A mediados de la d茅cada de los setenta se comenzaron a escribir art铆culos acad茅micos explicando los beneficios de esta aproximaci贸n a la programaci贸n. Tambi茅n durante esos a帽os se comenzaron a escribir los primeros lenguajes de programaci贸n que incorporaban estas ideas (como Smalltalk y CLU). Pero no fue hasta la llegada de Java y C++ que la idea consigui贸 un n煤mero importante de seguidores.

Hasta ahora, en el curso previo de esta serie hemos utilizado programaci贸n orientada a objetos de manera impl铆cita. Cuando decimos 鈥淟os objetos son las principales cosas que un programa de Python manipula. Cada objeto tiene un tipo que define qu茅 cosas puede realizar un programa con dicho objeto,鈥 nos estamos refiriendo a las ideas principales de la programaci贸n orientada a objetos. Hemos utilizado los tipos lista y
diccionario, entre muchos otros, as铆 como los m茅todos asociados a dichos tipos.

As铆 como los creadores de un lenguaje de programaci贸n solo pueden dise帽ar una fracci贸n muy peque帽a de todas las funciones 煤tiles (como abs, float, type, etc.), tambi茅n pueden escribir una fracci贸n muy peque帽a de los tipos 煤tiles (int, str, dict, list, etc.). Ya sabemos los mecanismos que nos permiten crear funciones, ahora veremos los mecanismos que nos permiten crear nuevos tipos (o clases).

Clases en Python

Las estructuras primitivas con las que hemos trabajado hasta ahora nos permiten definir cosas sencillas, como el costo de algo, el nombre de un usuario, las veces que debe correr un bucle, etc. Sin embargo, existen ocasiones cuando necesitamos definir estructuras m谩s complejas, por ejemplo un hotel. Podr铆amos utilizar dos listas: una para definir los cuartos y una segunda para definir si el cuarto se encuentra ocupado o no.

cuartos_de_hotel = [101, 102, 103, 201, 202, 203]
cuarto_ocupado = [True, False, False, True, True, False]

Sin embargo, este tipo de organizaci贸n r谩pidamente se sale de control. 驴Qu茅 tal que quisi茅ramos a帽adir m谩s propiedades, c贸mo si el cuarto ya fue aseado o no? 驴Si el cuarto tiene cama doble o sencilla? Esto nos lleva a una falta fuerte de organizaci贸n y es justamente el punto que justifica la existencia de clases.

Las clases nos permiten crear nuevos tipos que contiene informaci贸n arbitraria sobre un objeto. En el caso del hotel, podr铆amos crear dos clases Hotel() y Cuarto() que nos permitiera dar seguimiento a las propiedades como n煤mero de cuartos, ocupaci贸n, aseo, tipo de habitaci贸n, etc.

Es importante resaltar que las clases solo proveen estructura. Son un molde con el cual podemos construir objetos espec铆ficos. La clase se帽ala las propiedades que los hoteles que modelemos tendr谩n, pero no es ning煤n hotel espec铆fico. Para eso necesitamos las instancias.

Instancias

Mientras que las clases proveen la estructura, las instancias son los objetos reales que creamos en nuestro programa: un hotel llamado PlatziHotel o Hilton. Otra forma de pensarlo es que las clases son como un formulario y una vez que se llena cada copia del formulario tenemos las instancias que pertenecen a dicha clase. Cada copia puede tener datos distintos, al igual que cada instancia es distinta de las dem谩s (aunque todas pertenecen a una misma clase).

Para definir una clase, simplemente utilizamos el keyword class. Por ejemplo:

class Hotel:
    pass

Una vez que tenemos una clase llamada Hotel podemos generar una instancia llamando al constructor de la clase.

hotel = Hotel()

Atributos de la instancia

Todas las clases crean objetos y todos los objetos tienen atributos. Utilizamos el m茅todo especial __init__ para definir el estado inicial de nuestra instancia. Recibe como primer par谩metro obligatorio self (que es simplemente una referencia a la instancia).

class Hotel:
    
    def __init__(self, numero_maximo_de_huespedes, lugares_de_estacionamiento):
        self.numero_maximo_de_huespedes = numero_maximo_de_huespedes
        self.lugares_de_estacionamiento = lugares_de_estacionamiento
        self.huespedes = 0


hotel = Hotel(numero_maximo_de_huespedes=50, lugares_de_estacionamiento=20)
print(hotel.lugares_de_estacionamiento) # 20

M茅todos de instancia

Mientras que los atributos de la instancia describen lo que representa el objeto, los m茅todos de instancia nos indican qu茅 podemos hacer con las instancias de dicha clase y normalmente operan en los mencionados atributos. Los m茅todos son equivalentes a funciones dentro de la definici贸n de la clase, pero todos reciben self como primer argumento.

class Hotel:

    ...

    def anadir_huespedes(self, cantidad_de_huespedes):
        self.huespedes += cantidad_de_huespedes

    def checkout(self, cantidad_de_huespedes):
        self.huespedes -= cantidad_de_huespedes

    def ocupacion_total(self):
        return self.huespedes


hotel = Hotel(50, 20)
hotel.anadir_huespedes(3)
hotel.checkout(1)
hotel.ocupacion_total() # 2

Ahora que ya sabemos qu茅 son las clases y c贸mo las podemos utilizar en nuestros programas, plat铆canos qu茅 clases te ser铆an 煤tiles para modelar en uno de tus programas.

Aportes 267

Preguntas 7

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

Me costo mucho entender la lectura, esta imagen me ayudo mucho, aunque la verdad aun no tengo claro para que sirve el 鈥榮elf鈥

Como dato curioso Smalltalk y CLU fueron creados principalmente por mujeres, Smalltalk, fue creado entre otros por Adele Goldberg en 1980, y CLU por Barbara Liskov en 1974. Tambien otros como COBOL y FORMAC fueron desarrollados en mayor parte por otras talentosas e inteligentes mujeres que contribuyeron a reducir la brecha de genero en la industria de la tecnolog铆a. Inspiraciones!!!

https://pythones.net/clases-y-metodos-python-oop/

Recomiendo mucho este blog, en el podremos aclarar muchos conceptos de POO en Python.

Ya qued贸 publicado este material 馃槃

Algo muy muy interesante y que estoy seguro veremos mas adelante, es como la POO se complementa con los diagramas Entidad - Relaci贸n propios de una base de datos.

Simplemente es algo que te vuela la cabeza. Adem谩s, entender ambas partes a la perfecci贸n (tanto POO como el modelado de BD) es fundamental para cualquier desarrollador. 脕nimo compa帽eros, juntos llegaremos hasta el final de este interesante camino 馃槂

Mi resumen.

Me quedo mucho mas claro con este video que encontr茅.

https://www.youtube.com/watch?v=VYXdpjCZojA

class Humano:
    def __init__(self, edad, sexo):
        self.edad = edad
        self.sexo = sexo
        
pedro = Humano(23, 'Masculino')
susana = Humano(22, 'Femenino')
       
print('Soy Susana y tengo ' + str(susana.edad) + ' y soy ' + susana.sexo)
print('Soy Pedro y tengo ' + str(pedro.edad) + ' y soy ' + pedro.sexo)

Sintaxis de una clase

class <Nombre_clase>
	__init__(self, <argumentos>)
		self.<atributo> = <argumento>
	<metodo>()
		<codigo>

Inicializaci贸n de una Instancia

nombre_instancia = Nombre_clase(<argumentos>)
#Los argumentos que colocamos ser谩n los atributos de la instancia

Nota:
Por buenas practicas los nombres de las clases se escriben con May煤sculas y las instancias con min煤sculas

Literal, me he demorado 1 hora en realizar este c贸digo, pero aprend铆 mucho. Les comparto para que lo revisen. Es un programa para administrar hoteles. 馃槃

class Hotel:
    
    def __init__ (self, stars, rooms, room_bats):
        self._estrellas = stars                     #atributo privado 
        self._cuartos = rooms                        #atributo privado este dato lo estar茅 variando
        self._cuartos_bano = room_bats               #atributo privado este dato lo estar茅 variando

        self._cuartos_max = rooms                   #este dato es fijo, representa los cuartos m谩ximo que introduce el usuario
        self._cuartos_bano_max = room_bats          #este dato es fijo, representa los cuartos ba帽o m谩ximo que introduce el usuario
    
    def _actualizar_datos(self, accion, cuartos, cuartos_bano):     #metodo privado

        if accion == 'alquilar' or accion == 'reservar':        # al alquilar y reservar, restamos y calculamos los cuartos disponibles
            if self._cuartos - cuartos < 0:                     # verificamos que el usuario no reserve cuartos que no se dispone
                print(f'*** NO SE DISPONE DE {cuartos} CUARTOS, SOLO QUEDAN {self._cuartos} CUARTOS ***')
            else:                                               # si todo es conforme, actualizamos la data
                self._cuartos -= cuartos        
            if self._cuartos_bano - cuartos_bano < 0:           # verificamos que el usuario no reserve cuartos ba帽o que no se dispone
                print(f'*** NO SE DISPONE DE {cuartos_bano} CUARTOS BA脩O, SOLO QUEDAN {self._cuartos_bano} CUARTOS ***')
            else:                                                # si todo es conforme, actualizamos la data
                self._cuartos_bano -= cuartos_bano              #actualizamos los atributos

        elif accion == 'cancelar_reserva':                      #al cancelar reserva, sumamos y calculamos los cuartos disponibles
            if self._cuartos + cuartos > self._cuartos_max:
                print(f'*** NO SE PUEDE EJECUTAR LA ACCI脫N, SE DISPONE DE {self._cuartos} CUARTOS ***')
            else:
                self._cuartos += cuartos
            if self._cuartos_bano + cuartos_bano > self._cuartos_bano_max:
                print(f'*** NO SE PUEDE EJECUTAR LA ACCI脫N, SE DISPONE DE {self._cuartos_bano} CUARTOS BA脩O ***')
            else:
                self._cuartos_bano += cuartos_bano              #actualizamos los atributos
    
    def alquilar(self, cuartos, cuartos_bano):          #m茅todo p煤blico
        self._actualizar_datos('alquilar', cuartos, cuartos_bano)
        print(f'Quedan {self._cuartos} cuartos y {self._cuartos_bano} cuartos ba帽o disponibles')
    
    def reservar(self, cuartos, cuartos_bano):          #m茅todo p煤blico
        self._actualizar_datos('reservar', cuartos, cuartos_bano)
        print(f'Quedan {self._cuartos} cuartos y {self._cuartos_bano} cuartos ba帽o disponibles')
    
    def cancelar_reserva(self,cuartos, cuartos_bano):   #metodo p煤blico
        self._actualizar_datos('cancelar_reserva', cuartos, cuartos_bano)
        print(f'Quedan {self._cuartos} cuartos y {self._cuartos_bano} cuartos ba帽o disponibles')
    
    def llamar_asistente(self):                         #metodo_p煤blico
        print(""" 
        
        --- EL ASISTENTE EST脕 EN CAMINO  --- """)
    
    def menu(self):
        
        opcion = int(input(f"""
        ----------------- WELCOME TO HOTEL ASSISTENT ----------------- 
            Este es el asistente para trabajar con los hoteles
            
            DISPONES DE:
            - {self._cuartos} CUARTOS
            - {self._cuartos_bano} CUARTOS BA脩O
            -----------------------------
                驴Qu茅 es lo que deseas hacer?  
                    1.- Alquilar
                    2.- Reservar
                    3.- Cancelar reserva
                    4.- Llamar sistente
                    5.- Salir del programa

            Eliga una opci贸n ---> """))
        return opcion

        

def preguntar():                    #funci贸n para preguntarle al usuario cuantos cuartos y cuartos va alquilar, reservar o cancelar la reserva
    cuartos = int(input('Cuantos cuartos: '))          
    cuantos_bano = int(input('Cuantos cuartos ba帽o: '))

    return cuartos, cuantos_bano        #retorno 2 valores

def run():

    hotel_cielo = Hotel(3,20,15)        #creo un objeto de la clase Hotel. Parametros 3 estrellas x'dd , 20 cuartos y 15 cuartos ba帽o

    while True:
        opcion = hotel_cielo.menu()
        if opcion == 1:
            print(" ----------------- ALQUILAR ----------------------")
            cuartos, cuartos_bano = preguntar()
            hotel_cielo.alquilar(cuartos, cuartos_bano)
        elif opcion == 2:
            print(" ----------------- RESERVAR ----------------------")
            cuartos, cuartos_bano = preguntar()
            hotel_cielo.reservar(cuartos, cuartos_bano)
        elif opcion == 3:
            print(" ----------------- CANCELAR RESERVA ----------------------")
            cuartos, cuartos_bano = preguntar()
            hotel_cielo.cancelar_reserva(cuartos, cuartos_bano)
        elif opcion == 4:
            hotel_cielo.llamar_asistente()
        else:
            break


if __name__ == '__main__':		#entry point
    run()

Para aquellos que de pronto no entendieron que es una clase, quisiera compartirles de qu茅 manera pude entenderlo.

Las clases son como un molde a seguir de las cuales se crean cosas a partir de aquello, imaginemos la clase 鈥淧ersona鈥, la cual cuenta con caracter铆sticas (variables) y acciones (funciones).

Una clase persona puede tener:

  1. Caracter铆sticas (variables) como nombre, apellido, edad, genero, etc鈥
  2. Acciones (funciones) como caminar, correr, saltar, ver, etc鈥

Ahora, una Instancia ya es algo real (no abstracto como la clase), una instancia ya cuenta con valores en sus caracter铆sticas (variables) y ciertas acciones (funciones) pueden ser iguales a las de la clase o pueden sobreescribirse.

Entonces, tenemos una clase Persona con caracter铆sticas (variables) y acciones (funciones). Teniendo esto en cuenta, podemos crear una instancia que llamamos 鈥淧ersona 1鈥,

Esta instancia 鈥淧ersona 1鈥 tiene las mismas caracter铆sticas (variables) y acciones (funciones) que la clase 鈥淧ersona鈥, s贸lo que ahora ya tiene valores: Ejemplo:

Instancia 鈥淧ersona 1鈥:
CARACTER脥STICAS (Variables)
nombre = "Pedro"
apellido = "Mart铆n"
edad = 30
g茅nero = 鈥淢asculino鈥

ACCIONES (Funciones) (Heredadas de la clase Persona)
Caminar()
Correr()
Saltar()
Ver()

Y as铆 como hemos creado la Instancia 鈥淧ersona 1鈥, podemos crear otras instancias como 鈥淧ersona 2鈥, 鈥淧ersona 3鈥, etc鈥 y cada una puede tener diferentes Caracter铆sticas o valores.

Espero les sirva de ayuda

Porque es necesario colocar la palabra self en el inicio de un m茅todo?

Pythontutor es una excelente herramienta para observar la ejecuci贸n de un script, puedes reproducir observar lo que sucede paso a paso.

class Hotel:
    
    def __init__(self, numero_maximo_de_huespedes, lugares_de_estacionamiento):
        self.numero_maximo_de_huespedes = numero_maximo_de_huespedes
        self.lugares_de_estacionamiento = lugares_de_estacionamiento
        self.huespedes = 0
    
    def anadir_huespedes(self, cantidad_de_huespedes):
        self.huespedes += cantidad_de_huespedes

    def checkout(self, cantidad_de_huespedes):
        self.huespedes -= cantidad_de_huespedes

    def ocupacion_total(self):
        return self.huespedes

hotel = Hotel(50, 20)
hotel.anadir_huespedes(3)
hotel.checkout(1)
hotel.ocupacion_total() # 2```

Lo hice tomando como ejemplo la construcci贸n. Les comparto el c贸digo y las explicaciones.

#Primero crear茅 la clase construcci贸n para cualquier tipo
#sea infraestructura, habitacional, o insdustrial.

class Construccion:
    #Ahora especifico los atributos, es decir, sus caracter铆sticas.
    def __init__(self, tipo, material, costo):
        self.tipo = tipo
        self.material = material
        self.costo = costo
    
    #Ahora sus m茅todos, es decir qu茅 se puede hacer con esta.

    def escoger_tipo(self, el_tipo):
        self.que_tipo = el_tipo
    
    def escoger_material(self, el_material):
        self.que_material = el_material

    def escoger_costo(self, el_costo):
        self.que_costo = el_costo


#Creamos la instancia (objeto) edificio, que es una edificaci贸n
#tipo habitacional, se us贸 hormig贸n para construirlo y cost贸 1000000.

edificio = Construccion('habitacional', 'hormigon', 1000000)

#Oops, los due帽os decidieron construir el edificio con acer, lo que
#elevar铆a el costo a 1250000. Entonces tenemos que modificar el objeto

edificio.escoger_material('acero')
edificio.escoger_costo(1250000)


Iba un par de clases adelante y pensaba que habia entendido, pero creo que no.
Me ayud贸 mucho ver este video y despues volver a leer esta clasa con MUCHA atencion.
Espero les ayude.

https://www.youtube.com/watch?v=ykpT5P7171M&ab_channel=EscueladeInform谩ticos

Para los que no les ha quedado muy claro lo que es el m茅todo init lean este articulo: https://www.edureka.co/blog/init-in-python/

Clase: Plantilla o modelo a partir de la cual podemos crear objetos y donde se determinan los atributos (caracter铆sticas) y m茅todos (acciones realizables) que tendr谩n.

鈥 Objeto: Normalmente creado a partir de una clase son entidades que almacenan informaci贸n en forma de argumento para atributos y realizan acciones organizadas a trav茅s de m茅todos que permiten cambiar atributos o estados del objeto o de otros objetos de la clase.
鈥 Los atributos: Son variables de diferentes tipos (Entero; Texto; Booleanos) que pueden tener valores por defecto o le podr谩n ser asignadas al momento de la Instancia de un objeto determinando sus caracter铆sticas y estado.
鈥 Los m茅todos: Son funciones; acciones realizables por el objeto que permiten cambiar sus atributos o el de otros objetos de la clase permitiendo un cambio de estado del objeto; a menudo requiriendo 鈥渁rgumentos (valores)鈥 para determinados 鈥減ar谩metros (nombres de variables establecidas en funciones o rutinas).
鈥 Instancia: Palabra que refiere a la creaci贸n de un objeto partiendo de una clase. Durante la instancia son asignados los valores iniciales para los atributos.

Ejemplos:
1.
鈥 Tenemos la Clase: Animal
鈥 El objeto instanciado (creado a partir de esa clase): Perro
鈥 Que tiene sus atributos:

鈥 Color: negro;
鈥 Raza: Coquer;
鈥 Tiene collar: True (si))
鈥 Y tiene sus m茅todos:

鈥 Ladra (鈥淕uau; guau鈥)
鈥 Corre (Run)
鈥 Camina()
鈥 Olfatea()

Ejemplo gr谩fico de Clases; objeto e instancia

F铆jate en este ejemplo vamos a jugar a ser Dioses: Vamos a crear la clase Humano que tendr谩 ciertos atributos propios de cualquier ser Humano y algunos m茅todos tambi茅n que pueden realizar los seres humanos. A partir de esta clase vamos a crear dos objetos: Marcos y Elisa. Que ser谩n nuestros seres y al momento de la instancia les vamos a dar los valores para cada uno de sus atributos y m茅todos.

鈥 La clase Humano posee Atributos (Fecha de nacimiento; edad; Padres; Genero鈥)
鈥 La clase Humano posee M茅todos (Correr; Caminar y Hablar)
鈥 Los objetos Marcos y Elisa pertenecen a la misma Clase; pero tienen Diferentes valores para los atributos y sus m茅todos quiz谩s obtengan diferentes argumentos (valores para sus par谩metros).

驴Qu茅 resuelve la Programaci贸n Orientada a Objetos?
La programaci贸n Orientada a Objetos nace de los problemas creados por la programaci贸n estructurada y nos ayuda a resolver ciertos problemas como:
鈥 C贸digo muy largo: A medida que un sistema va creciendo y se hace m谩s robusta el c贸digo generado se vuelve muy extenso haci茅ndose dif铆cil de leer, depurar, mantener.
鈥 Si algo falla, todo se rompe: Ya que con la programaci贸n estructurada el c贸digo se ejecuta secuencialmente al momento de que una de esas l铆neas fallara todo lo dem谩s deja de funcionar.
鈥 Dif铆cil de mantener.

Supongamos que conoces a una persona nueva, lo primero que vez pues son sus caracter铆sticas f铆sicas. A medida que hablan te dice sus habilidades (habilidades en este caso ser铆an las cosas que la persona puedes hacer usando sus caracter铆sticas ) y lo que puede obtener con ellas. (supongamos la persona nunca te dijo su nombre)
Ahora, supongamos que le quieres contar a alguien m谩s sobre esa persona nueva pero recuerdas que no sabes su nombre, entonces inventas un 鈥榓lias鈥 y en funci贸n de ese 鈥榓lias鈥 pues comienzas a describir a la persona, a decir cuales son sus caracter铆sticas y a decir lo que esa persona puede hacer (habilidades) y lograr.
Bueno, digamos que ese alias hace que cobre sentido todo lo relacionado con esa persona. (*el acto de ponerle un alias a la persona ser铆a lo equivalente a hacer una instancia, que es lo equivalente a usar la clase por primera vez llen谩ndolo con sus caracter铆sticas o atributos. los atributos de la clase son los que se ponen despues de self en la funcion que inicia con init)
Despu茅s de 鈥渃omprender鈥 lo que son los objetos y despu茅s de pensar en c贸mo podr铆a explicarlo, fue como llegue a la idea anterior.
Digamos que las caracter铆sticas f铆sicas de la persona serian los atributos de las clases en python y que las habilidades de la persona ser铆an los m茅todos (ya que ambos usan sus caracter铆sticas o atributos para lograr u obtener cosas).
pd1: con dos le铆as creo que si queda mas claro
pd2: si en algo estoy mal, acepto sugerencias

Una clase es un conjunto que contiene:
Atributos: las caracteristicas del objeto que estoy representando
Metodos: Acciones que el objeto puede realizar
Constructor: Este es muy pero que muy importante puesto que con 茅l CREAMOS el objeto. Y dependiendo de este constructor es como vamos a definir inicializar el OBJETO.
Relaciones: Los objetos se pueden relacionar unos con otros.

import os
os.system('cls')

class Hotel:
    
    def __init__(self, numero_maximo_de_huespedes, lugares_de_estacionamiento):
        self.numero_maximo_de_huespedes = numero_maximo_de_huespedes
        self.lugares_de_estacionamiento = lugares_de_estacionamiento
        self.huespedes = 0
        
    def anadir_huespedes(self, cantidad_de_huespedes):  # --> Operaciones entro de clase Hotel
        self.huespedes += cantidad_de_huespedes         # Aumentar huespedes

    def checkout(self, cantidad_de_huespedes):          # --> Operaciones entro de clase Hotel
        self.huespedes -= cantidad_de_huespedes         # Disminuir huespeder

    def ocupacion_total(self):                          # --> Operaciones entro de clase Hotel
        return self.huespedes                           # Calcula huespedes actuales

hotel = Hotel(numero_maximo_de_huespedes=50, lugares_de_estacionamiento=20)

print(f'Numero de huespedes maximo')
print(hotel.numero_maximo_de_huespedes)
print(f'Numero de estacionamiento maximo')
print(hotel.lugares_de_estacionamiento) 

# hotel = Hotel(50, 20) Se puede modificar la cantidad maxima de huespedes dado el caso.

##  --- Flujo de informacion  ---  ##


print('Ingresan 7 huespedes, Marzo 24')
print(f'Huespedes checkin: 7')
hotel.anadir_huespedes(7)   # --> Operaciones dentro de class Hotel, hacer llamado con hotel. IMPORTANTE
                            # verificar y entender cuales son las funciones existentes dentro de class Hotel
                            # para saber que operaciones pueden hacer en esta.

print('Salen 3 huespedes, Abril 2')
print(f'Huespedes checkout:', 3 )
hotel.checkout(3)

print(f'Huespedes actuales:', hotel.huespedes)


De la forma en que lo entiendo es que un objeto tiene 2 caracter铆sticas que son: atributos y m茅todos.
Un atributo es una variable como las de toda la vida pero que es una variable propia de ese objeto y es una variable que no va a compartir con otro objeto aunque sean del mismo tipo. por ejemplo, en un coche, a pesar de que 2 coches pueden ser del mismo fabricante, uno puede tener el atributo color = rojo mientras que el otro lo tenga azul.
Un m茅todo es una funcionalidad de ese objeto (una acci贸n que hace el objeto). Los m茅todos pueden interactuar con las variables del programa (incluidas las variables del propio objeto) y es justo por eso que se utiliza el par谩metro SELF porque cuando un objeto utiliza un atributo o un m茅todo necesita saber a quien pertenece y la palabra self es para indicar que esta usando los atributos y m茅todos de 脡L MISMO (self).
El m茅todo init es para indicar que las variables o atributos van a arrancar en el estado que se d茅 por defecto, por ejemplo:
def init(self):
self.variable1=10
self.variable2=0

Entonces, cualquier objeto que decida crear a partir de esa clase, iniciar谩 con variable1=10 y variable2=0

Una clase no es un objeto sino un molde con el que ser谩n fabricados los objetos y para crear un objeto a partir de un molde se crea una variable y se le asigna la clase del objeto que se quiere crear, por ejemplo si quisiera crear 2 objetos coche ser铆a:
class Coche:
def init(self):
self.marca="marca gen茅rica"
self.color="color gen茅rico"
def arrancar(slef):
print(鈥渆l coche ha arrancado鈥)

mi_coche=Coche()
coche_de_mi_gfa=Coche()

驴Instancia es lo mismo que Objeto?

La programaci贸n orientada a objetos implica un pensamiento orientado a objetos, que ya de todas maneras es natural en el ser humano. Preguntate que es lo que quieres describir, esto te llevar谩 a encontrar la entidad que deseas abstraer como una clase, una vez que tengas esto claro es importante describir esta en funci贸n de sus caracter铆sticas y comportamientos, esto te llevar谩 a poder abstraerla a nivel de atributos y m茅todos. B谩sicamente pensar en objetos es la capacidad que todos tenemos de describir las generalidades de algo, por ejemplo, si dubujase un arbol gen茅rico en una pizarra, no necesitar铆as saber que tipo espec铆fico de 谩rbol es, solo debes saber que tiene un tronco, un follaje y unas ramas, y con eso puedes identificar en general un 谩rbol, es lo mismo con el paradigma de pensamiento orientado a objetos.

https://docs.python.org/es/3/tutorial/classes.html?highlight=clases
Buenas compa帽eros les dejo es te link para que ahonden m谩s en el tema de las Clases.

Comparto mi c贸digo para que me den un feedback para mejorarlo, gracias

#defino mi lista
alumnado = []

#defino una clase Alumno
class Alumno: 
# se inicia el constructor de instancias y propiedades de instancia
    
    def __init__(self, id_alumno, nombre, grado, alumnos):
        self.id_alumno = id_alumno      #incializo variables de instancia
        self.nombre = nombre            
        self.grado = grado            
        self.alumnos = alumnos
    
    def agregar(self, id_alumno, nombre, grado, alumnos):

        new_item = {
		    "id_alumno": id_alumno, 
		    "nombre": nombre,
		    "grado": grado
		    }

        self.alumnos.append(new_item)
        print('El Alumno ingresado es: ')
        print(
		    "\tid_alumno: ", id_alumno, "\n",
		    "\tnombre: ", nombre, "\n",
            "\tgrado: ", grado, "\n",
		    		)


    def mostrar(self, alumnos):    

        if len(alumnos) == 0:
            print('No existen alumnos en la lista')
        else:
            i = 0
            for dictionary in alumnos:
                i += 1
                print(f"Alumno #{i} :")
                print(
		    		"\tid_alumno: ", dictionary["id_alumno"], "\n",
		    		"\tnombre: ", dictionary["nombre"], "\n",
                    "\tgrado: ", dictionary["grado"], "\n",
		    		)
    
    def borrar(self, alumnos):
        OpcionBorrar = int(input('Ingrese el alumno a borrar: '))-1
        del alumnos[OpcionBorrar]

         
def Menu():

    while True:

        command = str(input('''
            驴Que deseas hacer?

            [a]A帽adir Alumno
            [b]Mostrar Alumnos
            [c]Eliminar Alumnos
            [s]Salir
        '''))

        alumnos = alumnado
        id_alumno = ''
        nombre = ''
        grado = ''
        matricular = Alumno(id_alumno,nombre,grado,alumnos)

        if  command.lower() == 'a':
            id_alumno = str(input('Escribe la identificacion del Alumno : '))
            nombre = str(input('Escribe el nombre del Alumno : '))
            grado = str(input('Escribe el grado academico: '))
            print('')
            matricular.agregar(id_alumno,nombre,grado,alumnos)

        elif command.lower() == 'b':
            matricular.mostrar(alumnos)

        elif command.lower() == 'c':
            matricular.borrar(alumnos)

        elif command.lower() == 's':
            break
        else:
            print('Comando no encontrado.')

if __name__ == '__main__':
    print()
    print('B I E N V E N I D O  A L  S I S T E M A  D E   M A T R I C U L A S')
    Menu()

Trate de inventar algo similar para comprender el concepto y se los comparto:

class Libro:
    
    def __init__(self, genero, autor, fecha_publicacion):
        self.genero = genero
        self.autor = autor
        self.fecha_publicacion = fecha_publicacion
        self.libros=0
    
    def agregar_ejemplar(self, numero_de_libros):
        self.libros += numero_de_libros
    
    def eliminar_ejemplar(self,numero_de_libros):
        self.libros -= numero_de_libros
        
    def contar_ejemplares(self):
        return self.libros

pandereta = Libro('novela','Gabriel','20-02-2000')
aventuraenelcielo = Libro('poesia','pombo','20-01-1999')
pandereta.agregar_ejemplar(2)
aventuraenelcielo.agregar_ejemplar(5)

print(f'Del libro pandereta hay {pandereta.contar_ejemplares()} ejemplares disponibles')
print(f'Del libro aventura en el cielo hay {aventuraenelcielo.contar_ejemplares()} ejemplares disponibles')

MI C脫DIGO, ESPERO LES SIRVA, SI TIENEN ALGUNA DUDA AVISEN

class Hotel:
    def __init__(self, max_number_guests, free_parking_spaces):
        self.max_number_guests = max_number_guests
        self.free_parking_spaces = free_parking_spaces
        self.guests = 0

    def add_guests(self, guests):
        self.guests += guests
    def checkout(self, guests):
        self.guests -= guests
    def total_ocupation(self):
        return self.guests

def run():

    my_hotel = Hotel(80, 20)

    print('''
    * * * * * * * * * * * * *
           HOTEL MATUS
    * * * * * * * * * * * * *
    ''')

    print(f'Maximum number of guests: {my_hotel.max_number_guests}')
    print(f'Number of free parking spaces: {my_hotel.free_parking_spaces}')

    guests_number = int(input('\nAdd the number of guests: '))
    my_hotel.add_guests(guests_number)

    people_exits = int(input('Number of people exits: '))
    my_hotel.checkout(people_exits)

    print(f'Total occupancy: {my_hotel.total_ocupation()}')



if __name__ == '__main__':
    run()

La Programaci贸n Orientada a Objetos es una de las cosas m谩s importantes de muchos lenguajes, de verdad facilita mucho la vida y la lectura y reutilizaci贸n de c贸digo, lo m谩s importante aqu铆 es pensar en todo esto como un simple objeto de la vida real, ese objeto tiene cosas que los describe (color, tama帽o, peso, etc.), pero tambi茅n tiene acciones, cosas que puede realizar (rodar, caminar, correr, etc.) y b谩sicamente eso es una clase, el molde que describe qu茅 atributos tiene y qu茅 m茅todos puede ejecutar.
.
Ahora, tambi茅n existen muchas otras herramientas que nos ayudan a mejorar la escritura del c贸digo de nuestras clases, un ejemplo de ellas es SOLID, pero eso lo veremos en un pr贸ximo video鈥 馃槃

CLASE 2: PROGRAMACI脫N ORIENTADA A OBJETOS EN PYTHON

La programaci贸n orientada a objetos es pensar en objetos como agrupaciones de datos y los m茅todos que operan dichos datos. Los objetos son las instancias de una clase y la clase a su vez, son la representaci贸n de las propiedades del objeto.

- Clases en Python

Las clases nos permiten crear nuevos tipos que contienen la informaci贸n de un objeto. Estas solo proveen estructura pero no definen un objeto en espec铆fico.

En Python una clase se define con el Keyword class

- Instancias en Python

Las instancias son los objetos reales que creamos en nuestro programa. Es decir, contendr谩 la informaci贸n particular de un objeto que pertenezca a la clase que definimos.

Una vez creada la clase podemos crear instancias de la clase llamando al constructor:

Objeto_1 = clase1()

- Atributos de la instancia

Todos los objetos (o instancias de una clase) tienen atributos que caracterizan el objeto en particular.

En Python se usa el m茅todo especial init para definir el estado inicial de nuestra instancia. Adem谩s recibe como par谩metro obligatorio self

- M茅todos de instancia

Los m茅todos nos indican qu茅 podemos hacer con las instancias (objetos) de la clase y por lo general se operan en los atributos y todos reciben como primer argumento self.

Hola, les comparto una clase de Persona

class Persona():
    def __init__(self, nombre, edad, profesion):
        self.nombre = nombre
        self.edad = edad
        self.profesion = profesion
    
    def datos_basicos(self):
        print(f'Este es {self.nombre}. Tiene {self.edad} a帽os y su profesi贸n es {self.profesion}')

    def cumpleaos(self):
        self.edad += 1
    
    def nueva_profesion(self,prof):
        self.profesion = prof

def run():
    carlos = Persona('Carlos', 29, 'Estudiante')
    carlos.datos_basicos()
    carlos.cumplea帽os()
    carlos.nueva_profesion('Ingeniero')
    carlos.datos_basicos()

if __name__ == "__main__":
    run()

la referencias self es como usar un this en js ?

En un videojuego podr铆a existir la clase Player. Esta tendr铆a atributos como: vida, da帽o, velocidad, altura de salto, y estamina. Y m茅todos o comportamientos como: saltar, moverse, atacar, interactuar con item y recargar estamina.

La palabra self es una convenci贸n o es una de las palabras clave de python?

Yo tengo un c贸digo que program茅 para mi tesis. Lo escrib铆 para hacer simulaci贸n estoc谩stica, pero en ese entonces no conoc铆a la POO y lo escrib铆 todo de forma secuencial. As铆 que quiero reescribir mi c贸digo utilizando este paradigma para tenerlo mejor ordenado, y poder compartirlo.

A mi me costaba, entender las instancias hasta que te das cuenta que cuando haces POO lo que generas es una base de la cual puedes sacar la cantidad de ejemplares que necesitas es como en una fabrica de autos, vos tenes el molde y dependiendo de las cosas que le agregues al class ChasisBase() es el auto que vas a tener, es decir tenes, def material_Chasis(), def dureza_Chasis(), def motor(), etc鈥 una vez que terminaste de crear la base creas tu propio ejemplar es decir que le das uso a la POO de la siguiente manera autoToyota = ChasisBase(hierro, 80/100, 2.0TD) y despues imprimis print(autoToyota). Espero que le sirva es como yo logro entenderlo

es una gran herramienta para la gesti贸n del stock de un almacen.
Mi clase Almacen tiene atributos como cant_de_manzanas, cant_de_naranjas, cant_de_duraznos.
Dentro de mi Almacen (clase) puedo restar las manzanas que se venden, puedo sumar la cantidad de naranjas que ingresaron, etc.

Se me ocurre modelar un cohete de SPACE X:

bueno llego a hora de romperme la cabeza

Estoy trabajando en un programa que ayude a hacer presupuestos de instalaciones electricas, entonces el enfoque de POO que se puede utilizar ser铆a:

  1. Definir 3 clases principales: 鈥榠nsumo鈥, 鈥榓nalisis_unitario鈥 y 鈥榩resupuesto鈥.
  2. Asignar a cada clase sus atributos y m茅todos, por ejemplo: 鈥榠nsumo鈥 tiene como atributos: 鈥榠d_insumo鈥, 鈥榥ombre鈥, 鈥榰nidad鈥, 鈥榲alor_unitario鈥. 鈥榓nalisis_unitario鈥 tiene el metodo calcular_valor_unitario(), el cual multiplica el valor del insumo por la cantidad y luego suma para dar el valor total de la actividad.
  3. Cada proyecto es una instancia de la clase 鈥榩resupuesto鈥, ya que tienen un alcance espec铆fico. En cada presupuesto se llaman los 鈥榓nalisis_unitarios鈥, se insertan las cantidades y se calcula el valor total del presupuesto.

Esta es la idea inicial del programa de presupuestos y espero seguir d谩ndole forma a medida que avance el curso, a ver si al final tengo un programa funcional.

Clases e Instancias en Python
Clases
Las clases proveen la estructura de nuestros objetos, podemos hace la analogia con un molde que se帽alas las propiedades que tendr谩 nuestro objeto.

Instancias
Son los objetos en s铆 mismos, el producto que obtenemos del molde.

Atributos
Son las propiedades que daremos a nuestro objeto (valores que asignamos al objeto). Los definimos en el m茅todo especial init()

M茅todos
Indican lo que el objeto puede hacer (sus comportamientos), generalmente operan con los atributos. Son un equivalente a las funciones, pero solo operan dentro de la clase y su primer argumento siempre sera self

Nota
self 鈫 referencia a la propia instancia

Les comparto el codigo que hice resumiendo esta clase, por fin estoy entendiendo como funcionan las clases en python 馃槃

class Hotel:
    def __init__(self, numero_maximo_de_huespedes, lugares_de_estacionamiento):
        self.numero_maximo_de_huespedes = numero_maximo_de_huespedes
        self.lugares_de_estacionamiento = lugares_de_estacionamiento
        self.huespedes = 0
        self.estacionamientos = 0
    #Hasta aqui es como se crea una clase
    #Instancias
    def anadir_huespedes(self, cantidad_de_huespedes):
        self.huespedes += cantidad_de_huespedes
    def checkout(self, cantidad_de_huespedes):
        self.huespedes -= cantidad_de_huespedes

    def parking_spaces_add(self, cantidad_de_estacionamientos):
        self.estacionamientos += cantidad_de_estacionamientos
    def parking_spaces_remove(self, cantidad_de_estacionamientos):
        self.estacionamientos -= cantidad_de_estacionamientos


    def ocupacion_total(self):
        return [['Huespedes', 'Estacionamientos'],
                [self.huespedes, self.estacionamientos]]

def main():
    hotel_hilton = Hotel(numero_maximo_de_huespedes=100, lugares_de_estacionamiento=50) #Este es el def __init__
    hotel_hilton.anadir_huespedes(10)
    hotel_hilton.parking_spaces_add(3)
    hotel_hilton.anadir_huespedes(30)
    hotel_hilton.parking_spaces_add(9)
    hotel_hilton.checkout(5)
    hotel_hilton.parking_spaces_remove(2)
    print(hotel_hilton.ocupacion_total())


if __name__ == "__main__":
    main()

Hola, creo que tengo un error en las asignaciones. Me ayudan?

class Estudiante:
    
    def __init__(self, nombre, apellido, nivel_de_logro):
        self.nombre = nombre
        self.apellido = apellido
        self.nivel_de_logro = nivel_de_logro

    def aprueba (self):
        if self.nivel_de_logro > 80 :
            return "aprobado"

        else:
            return "reprobado"
    
est1 = Estudiante("alejandro", "barr铆a", 90)
est2 = Estudiante("pedro", "paramo", 30)

result=est1.aprueba
print(result)```

Esta imagen me aclar贸 la estructura de una clase:

Tomada de : https://j2logo.com/python/tutorial/programacion-orientada-a-objetos/

Un resumen de esto 馃槂

  • Uno de los elementos m谩s importantes de los lenguajes de programaci贸n es la utilizaci贸n de clases para organizar programas en m贸dulos y abstracciones de datos.
  • En POO las clases (u objetos) son agrupaciones de datos y los m茅todos que operan a dichos datos.
  • Nos permite modelar cosas reales y concretas del mundo y sus relaciones con otros objetos.
  • Estas ideas tienen mas de 50 a帽os (aplicadas mucho desde hace 30, con Java y C++).
  • En cualquier lenguaje de programaci贸n, solo estar谩n algunos tipos de objetos y unas pocas funciones, pero nosotros podemos crear nuevas.
  • Clases en Python:
    • Las que vienen por defecto son las estructuras primitivas. Muchas veces usar solo estas clases nos lleva a una falta fuerte de organizaci贸n.
    • Las clases nos permiten crear nuevos tipos que contiene informaci贸n arbitraria sobre un objeto.
    • Las clases solo proveen estructura, ya que son un molde con el cual podemos construir un objeto espec铆fico. Es como un formulario.
    • Para crear una clase usamos el keyword class <nombre>:.
  • Instancias:
    • Las instancias son los objetos reales que creamos en nuestro programa. Es la respuesta al formulario.
    • Para crear una instancia de una clase: instancia = clase().
    • Todas las clases crean objetos, y estos tienen atributos. Con el m茅todo __init__definimos el estado inicial de nuestra instancia, y recibe como primer par谩metro obligatorio self.
  • M茅todos de instancia:
    • Los m茅todos nos indican qu茅 podemos hacer con las instancias de dicha clase y normalmente operan en los atributos mencionados. Son equivalentes a funciones dentro de la clase, pero todos reciben self como primer argumento.
class Hotel:
    def __init__(self, numero_maximo_de_huespedes, lugares_de_estacionamiento):
        self.numero_maximo_de_huespedes = numero_maximo_de_huespedes
        self.lugares_de_estacionamiento = lugares_de_estacionamiento
        self.huespedes = 0

		def anadir_huespedes(self, cantidad_de_huespedes):
        self.huespedes += cantidad_de_huespedes

    def checkout(self, cantidad_de_huespedes):
        self.huespedes -= cantidad_de_huespedes

    def ocupacion_total(self):
        return self.huespedes

hotel = Hotel(50, 20)
print(hotel.lugares_de_estacionamiento) # 20

hotel.anadir_huespedes(3)
hotel.checkout(1)
hotel.ocupacion_total() # 2

Ejemplo de objetos para gamers:

class Warrior:
    def __init__(self, faction, race, rol, genere, name, live):
        self.faction = faction
        self.race = race
        self.rol = rol
        self.genere = genere
        self.name = name
        self.live = live
    def __str__(self):
        return "Su faccion es: {}\nSu raza es: {}\nSu rol es:{}\nSu genero es: {}\nSu nombre es:{}"\
            .format(self.faction, self.race, self.rol, self.genere, self.name)
    def accion(self):
        if self.rol == "DPS":
            return "Te ataco con mi AXE"
        elif self.rol == "TANK":
            return "Yo soy el tanque del equipo"
        elif self.rol == "HEALER":
            return "Yo curare al equipo"
        else:
            return "No tengo ningun rol asignado"

personaje = Warrior("Horda", "Orco", "HEALER1", "Hombre", "Thrall", 10)
print(str(personaje))
print(personaje.accion())```

Estoy trabajando en un proyecto para un sistema de inventario de instrumentos musicales (en almac茅n y circulantes) y contratos de comodatos sobre dichos instrumentos, es obligatorio definir clases para el usuario/comodatario, el comodato en si y obviamente el instrumento.

las Clases son como un molde, las instancias son como que caracter铆sticas tiene, y los m茅todos son que hace esas caracter铆sticas

Qu茅 tal, un ejemplo super sencillo:

class Alumno:
  def __init__(self, nombre, edad):
    self.nombre = nombre
    self.edad = edad
  
  def datos_alumno(self):
    print('Mi nombre es {} y tengo {} a帽os.'.format(self.nombre, self.edad))
    

george = Alumno('George', 12)
george.datos_alumno()


nidia = Alumno('Nidia', 15)
nidia.datos_alumno()
class cuadrado:

    def __init__(self, base, altura):
        self.base = base
        self.altura = altura
    
    def getBase(self):
        return self.base
    
    def getAltura(self):
        return self.altura
    
    def area(self):
        return self.base * self.altura

cuadrado = cuadrado(30, 40)
cuadrado.area()

M茅todos de instancia:
Nos indican que podemos hacer con las instancias, normalmente operan con los atributos. Son equivalentes a funciones dentro de la clase.

Les comparto una practica que hice, espero les agrade. Saludos!

# 1. create the class Desktop, this contain specific attributes.
class Desktop():
    #2. attributes
    def __init__(self, pencilOnDesk, paperBookOnDesk, lampOnDesk, laptopsOnDesk):
        self.pencilOnDesk = pencilOnDesk
        self.paperBookOnDesk = paperBookOnDesk
        self.lampOnDesk = lampOnDesk
        self.laptopsOnDesk = laptopsOnDesk

    #3. define functions I'll we use with my instance 麓myDesktop麓
    #be carefoul with the 4 tab space.
    # This function is inside the class
    def addLaptop(self, valueLaptop):
        self.laptopsOnDesk += valueLaptop

    def printData(self):
        print(f'Lapiceros en el escritorio: {self.pencilOnDesk}')
        print(f'Cuadernos en el escritorio: {self.paperBookOnDesk}')
        print(f'Lamparas en el escritorio: {self.lampOnDesk}')
        print(f'Laptops en el escritorio: {self.laptopsOnDesk}')

def run():
    #4. create a instance myDesktop with some attributes from Desktop
    myDesktop = Desktop(10,2,1,0)
    otherDesktop = Desktop(5,['Tom Sawyer','Moby-Dick','PHP 5'],'lampara articulada amarilla','MacBook Pro')
    print('primer instancia MyDesktop')
    print(myDesktop.printData())
    print('Segunda instancia otherDesktop')
    print(otherDesktop.printData())

    #5. call some functions to change data on my instance myDesktop
    myDesktop.addLaptop(2)
    print('segunda instancia MyDesktop')
    print(myDesktop.printData())

    otherDesktop.addLaptop(', Dell')
    print(otherDesktop.printData())

if __name__ == "__main__":
    run()```

Clase 鈥楨rror鈥.

Muy interesante esta clase, la verdad. Hasta hace poco no comprend铆a muy bien para qu茅 era la palabra self, sin embargo, ahora ya tengo m谩s conceptos m谩s claros. La ventaja de nunca parar de aprender.

Si alguien no ha entendido que son las Clases, pueden entenderlo como una idea abstracta de algo, es decir, es la definici贸n de algo. Ahora, que se puede hacer con una idea? Crear cosas, a esas cosas se les llaman instancias que son los mismos objetos. por ejemplo: Crear el concepto de una silla, ser铆a el equivalente a la clase. ahora, hay muchos tipos de sillas, pues bien, soda silla que sea creada con el concepto es un objeto que en nuestro caso llamaremos instancia. Si bien como todas las sillas comparten caracter铆sticas, en nuestro caso las llamaremos atributos, pero ojo, recuerden que esto puede variar porque se pueden crear sillas para diferentes contextos, pero no por eso tienen un concepto (clase) diferente.

Una explicaci贸n m谩s completa la pueden encontrar en el siguiente link: https://thefricky.wordpress.com/2008/01/15/programacion-orientada-a-objetos-clase-e-instancia/

producto, cliente, vendedor, tienda, proveedor

Por si el concepto de self no qued贸 claro, espero mi ejemplo les sirva.

class x():
    def __init__ (self, nombre):
        self.nombre = nombre

z = x('Juan')
print(z.nombre) #Juan

Programaci贸n Orientada a Objetos

Esto es un reto muy interesante ya que en realidad vengo desde 0 pero este profe es buen铆simo

De las mejores explicaciones 馃憦

self se que parece ser uno de los conceptos m谩s dif铆ciles de entender, pero lo que hace es que se utiliza para que un objeto haga referencia a s铆 mismo dentro de una funci贸n por ejemplo si tenemos una clase que guarda un valor para que voy a tener hoy de almuerzo y que puedo modificar el valor de lo que voy a tener para el almuerzo utilizando un metodo de la clase se usa self para que pueda reasignar un nuevo valor para esta llave dentro de mi objeto

class Food:
    def __init__(self, my_lunch):
        self.my_lunch = my_lunch

    def set_new_lunch(self, my_new_lunch):
        self.my_lunch = my_new_lunch

dish_1 = Food(my_lunch='pasta')
print(dish_1.my_lunch) #pasta

dish_1.set_new_lunch('pizza')
print(dish_1.my_lunch) #pizza

como ven en la funci贸n 鈥渟et_new_lunch鈥 se referencia a self para apuntar hacia la propiedad de esa instancia con eso si inicializo varias instancias de la misma clase cada vez que utilice un metodo de la instancia que necesite operar propiedades lo hara sobre los valores de cada instancia

Excelente explicaci贸n, a veces se extra帽an en v铆deos, pero este texto es tremendamente claro

Interesante como Python requiere sea utilizado la palabra 鈥渟elf鈥 como primer argumento.

Despues de pensar y revisar documentaci贸n este es mi codigo para matriculas de alumnos

# -*- coding: utf-8 -*-

#defino una clase Alumno
class Alumno:
    
# se inicia el constructor de instancias y propiedades de instancia
    
    def __init__(self, id_alumno,nombre, grado):
        self.id_alumno=id_alumno #incializo variable de instancia
        self.nombre = nombre  #inicializamos variable de instancia
        self.grado = grado      #inicializamos variable de instancia 
        
#defino luna clase para adicionar alumnos
   
class Agregar_alumno:

    def __init__(self):
            self._alumnos = []  #definimos un vector donde ingresaremos los alumnos

    def add(self, id_alumno,nombre,grado):
        print()
        print('los datos ingresados son: ')
        print('id_alumno: {}, nombre: {}, grado: {}'.format(id_alumno, nombre, grado))
        

def procesar():
    
   matricular=Agregar_alumno()

   while True:
        command = str(input('''
            驴Que deseas hacer?

            [a]A帽adir Alumno
            [s]Salir
        '''))

        if command == 'a':
            id_alumno = str(input('Escribe la identificacion del Alumno : '))
            nombre = str(input('Escribe el nombre del Alumno : '))
            grado = str(input('Escribe el grado academico: '))

            matricular.add(id_alumno,nombre,grado)

        elif command == 's':
            break
        else:
            print('Comando no encontrado.')
            
print('los datos ingresados son: ')

if __name__ == '__main__':
    print()
    print('B I E N V E N I D O  A L  S I S T E M A  D E   M A T R I C U L A S')
    procesar()```

Excelente, gracias! Desde que veo las clases como un molde y los objetos como el resultado 鈥渄espu茅s de inyectar pl谩stico en el molde鈥. Se me ha hecho m谩s f谩cil distinguirlos.

Hay muchas cosas sobre la programci贸n orientada a objetos que a煤n no me quedan claro, espero poder entenderlas a lo largo de este curso.

Me gustar铆a implementar m茅todos num茅ricos y algoritmos de optimizaci贸n y utilizar objetos para su funcionamientos.

Comparto mis apuntes de la clase 馃憤
.

Programaci贸n Orientada a Objetos
Objetos Podemos definir a los objetos como una agrupaci贸n de datos (atributos) y m茅todos que operan con dichos datos.
Con los objetos podemos modelar las cosas reales y concretas del mundo y sus relaciones con otros objetos

Nota
En la d茅cada de los 70 aparecieron los lenguajes orientados a objetos como Smalltall y CLU pero no fue hasta la llegada de Java y C++ cuando se popularizo este tipo de programacion

La programaci贸n orientada a objetos (POO), es uno de los enfoques m谩s importantes en el desarrollo de software. Este favorece la modularidad, el encapsulamiento y la escalabilidad de cualquier programa. En terminos sencillos la POO se basa en agrupar entidades en objetos con sus datos, caracteristicas y comportamientos.
En Python, todos los datos son objetos, desde las funciones hasta las estructuras de datos. Los objetos son creaciones basadas en las clases definidas en el programa.
Las clases son la representaci贸n o abstracci贸n de cosas o situaciones del mundo real. Una clase provee la estructura o el molde con el cual podemos contruir un objeto con las propiedades de su abstracci贸n. Se podria ver la clase como un formulario vac铆o y cada copia diligenciada de ese formulario ser铆a un objeto especifico.
Cuando se crea el objeto especifico basado en una clase pasa a ser considerado como una instancia de la clase.
Todas las clases crean objetos y tanto las clases como las instancias pueden guardar informaci贸n que describen lo que representan. Esta informaci贸n se denomina atributo.
Otra parte fundamental son los denominados m茅todos que son herramientas definidas para operar tanto con su propios atributos como con otros objetos.

Para dar mayor claridad al tema se define la clase libro con sus atributos y m茅todos. De esta clase se crea la instancia Homo Deus con sus caracteristicas especificas. Vemos que la clase no es un libro en particular representa cualquier objeto del universo de libros.

Para definir una clase se utiliza la palabra reservada class seguida de un identificador v谩lido.
Ahora se deben agregar los parametros para poder inicilizar la instancia con la funci贸n init, que recibe los par谩metros neccesarios y su primer par谩metro siempre ser谩 self, que es una referencia a la instancia.
Y por 煤ltimo definimos los m茅todos que se crean como cualquier funci贸n con la palabra reservada def:

Actualmente estoy trabajando en la extracci贸n de unos datos de ventas dentro de un ecommerce con python. La primer versi贸n que realic茅 la hice sin utilizar ning煤n concepto ligado a POO (muchas l铆neas y c贸digo spaguetti), para la segunda versi贸n ahora si estoy utilizando POO y definitivamente no solo se reducen las l铆neas, tambi茅n es muy sencillo leer y entender todos tus scripts. Es una maravilla!

Estas lecturas deber铆an ser contenido adicional. Todo deber铆a estar explicado en video.

estoy creando el juego del ahorcado, y me serviria mucho una clase la cual compare la letra que ingrese con los caracteres que conforman la palabra, si la palabra que ingrese esta en la cadena de caracteres, me indique la poscicion de la coincidencia para posteriormente remplazar esta letra en una cadena de caracteres con espacios vacios 鈥淿_鈥 que tiene la misma cantidad de espacios que la palabra a adiviniat

El conocimiento es poder!

El c贸digo:

class Hotel:
    
    def __init__ (self, stars, rooms, room_bats):
        self._estrellas = stars                     #atributo privado 
        self._cuartos = rooms                        #atributo privado este dato lo estar茅 variando
        self._cuartos_bano = room_bats               #atributo privado este dato lo estar茅 variando

        self._cuartos_max = rooms                   #este dato es fijo, representa los cuartos m谩ximo que introduce el usuario
        self._cuartos_bano_max = room_bats          #este dato es fijo, representa los cuartos ba帽o m谩ximo que introduce el usuario
    
    def _actualizar_datos(self, accion, cuartos, cuartos_bano):     #metodo privado

        if accion == 'alquilar' or accion == 'reservar':        # al alquilar y reservar, restamos y calculamos los cuartos disponibles
            if self._cuartos - cuartos < 0:                     # verificamos que el usuario no reserve cuartos que no se dispone
                print(f'*** NO SE DISPONE DE {cuartos} CUARTOS, SOLO QUEDAN {self._cuartos} CUARTOS ***')
            else:                                               # si todo es conforme, actualizamos la data
                self._cuartos -= cuartos        
            if self._cuartos_bano - cuartos_bano < 0:           # verificamos que el usuario no reserve cuartos ba帽o que no se dispone
                print(f'*** NO SE DISPONE DE {cuartos_bano} CUARTOS BA脩O, SOLO QUEDAN {self._cuartos_bano} CUARTOS ***')
            else:                                                # si todo es conforme, actualizamos la data
                self._cuartos_bano -= cuartos_bano              #actualizamos los atributos

        elif accion == 'cancelar_reserva':                      #al cancelar reserva, sumamos y calculamos los cuartos disponibles
            if self._cuartos + cuartos > self._cuartos_max:
                print(f'*** NO SE PUEDE EJECUTAR LA ACCI脫N, SE DISPONE DE {self._cuartos} CUARTOS ***')
            else:
                self._cuartos += cuartos
            if self._cuartos_bano + cuartos_bano > self._cuartos_bano_max:
                print(f'*** NO SE PUEDE EJECUTAR LA ACCI脫N, SE DISPONE DE {self._cuartos_bano} CUARTOS BA脩O ***')
            else:
                self._cuartos_bano += cuartos_bano              #actualizamos los atributos
    
    def alquilar(self, cuartos, cuartos_bano):          #m茅todo p煤blico
        self._actualizar_datos('alquilar', cuartos, cuartos_bano)
        print(f'Quedan {self._cuartos} cuartos y {self._cuartos_bano} cuartos ba帽o disponibles')
    
    def reservar(self, cuartos, cuartos_bano):          #m茅todo p煤blico
        self._actualizar_datos('reservar', cuartos, cuartos_bano)
        print(f'Quedan {self._cuartos} cuartos y {self._cuartos_bano} cuartos ba帽o disponibles')
    
    def cancelar_reserva(self,cuartos, cuartos_bano):   #metodo p煤blico
        self._actualizar_datos('cancelar_reserva', cuartos, cuartos_bano)
        print(f'Quedan {self._cuartos} cuartos y {self._cuartos_bano} cuartos ba帽o disponibles')
    
    def llamar_asistente(self):                         #metodo_p煤blico
        print(""" 
        
        --- EL ASISTENTE EST脕 EN CAMINO  --- """)
    
    def menu(self):
        
        opcion = int(input(f"""
        ----------------- BIENVENIDO AL ASISTENTE DE HOTEL ----------------- 
                                                by Juan Carlos Ortiz Romero.
            Este es el asistente para trabajar con los hoteles
            
            DISPONES DE:
            - {self._cuartos} HABITACIONES
            - {self._cuartos_bano} HABITACIONES CON JACUZZI
            -----------------------------
                驴Qu茅 es lo que deseas hacer?  
                    1.- Alquilar
                    2.- Reservar
                    3.- Cancelar reserva
                    4.- Llamar asistente
                    5.- Salir del programa

            Eliga una opci贸n ---> """))
        return opcion

        

def preguntar():                    #funci贸n para preguntarle al usuario cuantos cuartos y cuartos va alquilar, reservar o cancelar la reserva
    cuartos = int(input('Cuantas habitaciones: '))          
    cuantos_bano = int(input('Cuantas habitaciones con Jacuzzi: '))

    return cuartos, cuantos_bano        #retorno 2 valores

def run():

    hotel_cielo = Hotel(3,20,15)        #creo un objeto de la clase Hotel. Parametros 3 estrellas x'dd , 20 cuartos y 15 cuartos ba帽o

    while True:
        opcion = hotel_cielo.menu()
        if opcion == 1:
            print(" ----------------- ALQUILAR ----------------------")
            cuartos, cuartos_bano = preguntar()
            hotel_cielo.alquilar(cuartos, cuartos_bano)
        elif opcion == 2:
            print(" ----------------- RESERVAR ----------------------")
            cuartos, cuartos_bano = preguntar()
            hotel_cielo.reservar(cuartos, cuartos_bano)
        elif opcion == 3:
            print(" ----------------- CANCELAR RESERVA ----------------------")
            cuartos, cuartos_bano = preguntar()
            hotel_cielo.cancelar_reserva(cuartos, cuartos_bano)
        elif opcion == 4:
            hotel_cielo.llamar_asistente()
        else:
            break


if __name__ == '__main__':		#entry point
    run()

Acount,
Persona

Ser铆an tan s贸lo algunas de las clases que podr铆a modelar en alguno de mis programas.

No me agrada que de un tema as铆 haya tanta lectura

Una clase en la que las instancias ser谩n cuentas bancarias.
Los atributos ser谩n: el saldo de la cuenta, cobro de cuota de manejo. Los m茅todos son: consignaciones y transferencias.

Comparto mi c贸digo. C贸mo hab铆a contado en el curso pasado, en uno de mis proyectos de programaci贸n de mi Universidad realic茅 un programa para reservar y mostrar asientos en un avi贸n y realizar este proyecto del hotel me record贸 a ello. Creo que tratar茅 de buscarlo e implementarlo en Python ya que en ese entonces lo hice en C++, se que ser谩 mucho m谩s sencillo implementarlo en Python.
Algunas de las mejoras realizadas ac谩 son ideas de compa帽eros que tambi茅n pusieron su c贸digo en los comentarios.

class Hotel:
    
    def __init__(self, nombre_hotel, numero_de_habitaciones, numero_maximo_de_huespedes, lugares_de_estacionamiento): #
        self.nombre_hotel = nombre_hotel
        self.numero_de_habitaciones = numero_de_habitaciones
        self.numero_maximo_de_huespedes = numero_maximo_de_huespedes
        self.lugares_de_estacionamiento = lugares_de_estacionamiento
        self.huespedes = 0

    def __str__(self):
        return self.nombre_hotel

    def anadir_habitacicones(self, numero_de_habitaciones):
        self.numero_de_habitaciones += numero_de_habitaciones

    def eliminar_habitaciones(self, numero_de_habitaciones):
        self.numero_de_habitaciones -= numero_de_habitaciones       

    def anadir_huespedes(self, cantidad_de_huespedes): #A帽ade huespedes al hotel
        self.huespedes += cantidad_de_huespedes

    def checkout(self, cantidad_de_huespedes): #Resta la cantidad 
        self.huespedes -= cantidad_de_huespedes

    def ocupacion_total(self): #Indica la ocupaci贸n total del hotel
        return self.huespedes            

hotel = Hotel("Greek Pantheon", 40, 80, 20)



if __name__ == '__main__':
    
       
        print(f'Bienvenido a el Hotel {hotel.nombre_hotel}')
        print(f'El n煤mero m谩ximo de hu茅spedes que pueden hospedarse son: {hotel.numero_maximo_de_huespedes}')
        print(f'Lugares de estacionemiento: {hotel.lugares_de_estacionamiento}')

        anadir = int(input("驴Cu谩ntos hu茅spedes nuevos han entrado?: "))
        salida = int(input("驴Cu谩ntos hu茅spedes se han ido?: "))

        hotel.anadir_huespedes(anadir)
        hotel.checkout(salida)
        hotel.ocupacion_total()

        print(f'Han entrado {anadir} hu茅sped(es) y han salido {salida} hu茅sped(es). Actualmente en el hotel se encuentran {hotel.ocupacion_total()} hu茅spedes.')

este es mi objeto:

<class persona:

    def __init__(self, name, surname, weigth):
        self.nombre = name
        self.apellido = surname
       self.peso = weigth


    def introduction(self, name, weigth):
        print(f'hola, encantado de conocerte, mi nombre es {name} y peso {weigth}'

persona_1 = persona("antonio", "machado", "80")
persona_1.introduction("antonio", 80)>

Es un Platzi Hotel

class Hotel:

    def __init__(self, maximos_huespedes, lugares_estacionamiento):
        self.maximos_huespedes = maximos_huespedes
        self.lugares_estacionamiento = lugares_estacionamiento
        self.huespedes = 0
    
    def aadir_huespedes(self, cantidad_ingresados):
        self.huespedes += cantidad_ingresados

    def check_out(self, cantidad_huespedes):
        self.huespedes -= cantidad_huespedes

    def ocupacion(self):
        return self.huespedes


platzi_hotel = Hotel(100, 150)

print(platzi_hotel.maximos_huespedes)
print(platzi_hotel.huespedes)
platzi_hotel.a帽adir_huespedes(20)
print(platzi_hotel.ocupacion())

Necesito hacer clases para conjuntos de datos meteorologicos, para modelos de machine learning y otra para resultados de los pronosticos.

import pandas as pd
import pvlib as pv

filtered_rad=[]

class pvlibmodule:
    
    def __init__(self,settings):
      
        self.configuration = settings
        self.system = pv.pvsystem.PVSystem()
        self.location = pv.location.Location(latitude= settings["latitude"], 
                                        longitude= settings["longitude"], 
                                        altitude= settings["altitude"],
                                        tz= settings["tz"])
        
        cec_inverters = pv.pvsystem.retrieve_sam('cecinverter')
        sandia_modules = pv.pvsystem.retrieve_sam('SandiaMod')
        cec_modules = pv.pvsystem.retrieve_sam('CECMod')
    
    def weather_df_process(self,df,column_name= "Value"):
       pass

        
    def execute_pvlib_modelchain(self,df,config):
       pass

Les paso un tip si leyeron sobre las clases en ingl茅s: las instancias son los objetos, para que no se confundan.

Aqu铆 mi peque帽o ejemplo de un estado de resultados:

Una pregunta, las instancias son lo mismo que los objetos??

Ejemplo para Graficar Funciones Matem谩ticas en 3d
class Funcion3D:
def init(self, cadena_fun, vari):
cadena_funcion_matematica = cadena_fun
variables = vari

def graficar_funcion(self):
    
def definir_rango_eje_x(self, x_ini, x_fin):
    
def definir_rango_eje_y(self, y_ini, y_fin):
    
def rotar_funcion(self, angulo_radianes):

funcion = Funcion3D(鈥渟qrt(xx+yy)+3cos(sqrt(xx+y*y))+5鈥,鈥淴Y鈥)
funcion.definir_rango_eje_x(-45,45)
funcion.definir_rango_eje_y(-100,100)
funcion.rotar_funcion(30)
funcion.graficar_funcion()

Pienso que la primordial es la clase 鈥榩ersona鈥

class persona:


	def__init__(self, nombres, apellidos, identificacion, sexo):
		self.nombres = nombres
		self.apellidos = apellidos
		self.identificacion = identificacion
		self.sexo = sexo

	def saludo(self):
		return print(f'Hola mi nombre es {self.nombres} {self.apellidos}. Gusto en conocerte!')

En este apartado tenemos la explicaci贸n sobre conceptos como clases, instancias, Atributos de una instancia y m茅todos de una instancia.

La clase se entiende como una estructura un molde que te permite almacenar temporalmente atributos. Estos atributos son caracter铆sticas de la clase.

Las instancias son los objetos. Vendr铆an a ser los datos que ocupar谩n la estructura (clase)

Atributos de la instancia: Los atributos vendr铆an a ser las caracter铆sticas de la clase

M茅todos de la instancia: Son las acciones que se pueden realizar con dicha clase

class Invernadero:
	def	_init_(self, numero_maximo_de_hortalizas):
		self.numero_maximo_de_hortalizas = numero_maximo_de_hortalizas
		self.hortalizas = 0

	def	anadir_hortalizas(self, cantidad_de_hortalizas):
		self.hortalizas += cantidad_de_hortalizas
	def	quitar_hortalizas(self, cantidad_de_hortalizas):#Por cosecha o desecho
		self.hortalizas -= cantidad_de_hortalizas
	def	hortalizas_totales(self):
		return self.hortalizas

class Moto_Taller():

    def __init__(self, numero_de_motos, camellones_disponibles):
        self.numero_de_motos = numero_de_motos
        self.camellones_disponibles = camellones_disponibles
        self.clientes = 0

    def add_cliente(self, cantidad_de_clientes):
        self.clientes += cantidad_de_clientes

    def moto_reparada(self, cantidad_de_clientes):
        self.clientes -= cantidad_de_clientes

    def por_reparar(self):
        return self.clientes



taller1 = Moto_Taller(numero_de_motos=5, camellones_disponibles= 7)
print("Camellones disponibles: " + str(taller1.camellones_disponibles))

taller1.add_cliente(6)
taller1.moto_reparada(4)
print("las motos que faltan por reparar son: " + str(taller1.por_reparar()))

Agradezco sus comentarios o mejoras!!

馃憱馃憱馃憱 Vamos a representar la una marca de pantalones馃憱馃憱馃憱

#鈶燵CLASE] Primero creo la clase que contenga el objeto (Osea la categoria pantalones)
class pants_brand:
    #鈶ATRIBUTOS] especifico los atributos que tiene mi objeto (Mi pantalon)
    def __init__(self, material, price, brand, discount, total_stock):
        self.material = material
        self.price = price
        self.brand = brand
        self.discount = discount
        self.total_stock = total_stock

    #鈶METODO] Defino las funciones para las acciones que voy a querer con mis futuras [鈶 Instancias]
    # 鈫 Nota: Tener presente la correcta identacion. 
    def total_sales(self, sales_units):
        self.total_stock -= sales_units
    
    def offer(self, value):
        self.discount += value


    def total_data(self):
        print(f'Material: {self.material}')
        print(f'Brand: {self.brand}')
        print(f'Price: {self.price}')
        print(f'Possible discount: {self.discount}')
        return [f'Availability: {self.total_stock} pants']


#鈶INSTANCIAS] Hay muchos pantalones en el mundo
# nosotros creamos el objeto unico que queremos para nuestro programa.
# Este es un tipo de pantalon que tiene unas caracteristicas unicas
def run():
    pants = pants_brand('Cotton', 1000, 'Tom Ford', 0, 100) 
    pants.total_sales(5)
    pants.offer(20)
    print(pants.total_data())
 

if __name__ == '__main__':
    run()

Hola, este es mi c贸digo por si alguien tiene alguna sugerencia, a煤n estoy medio perdido en todo esto. Muchas gracias!
Lo ten铆a m谩s largo pero prefer铆 minimizarlo para poder entenderlo mejor

class Travel:
    def __init__(self, hotel_price, tour_price):
        self.hotel_price = hotel_price
        self.tour_price = tour_price
    
    def add_hotel_price(self, add_hotel_price):
        self.price += add_hotel_price
    def add_tour_price(self, add_tour_price):
        self.price += add_tour_price
    def full_price(self):
        return self.price


travel = Travel(100, 40)
travel.add_hotel_price(100)
travel.add_tour_price(40)
travel.full_price() #140


Me encant贸 sacar apuntes de este art铆culo. Super claro y gran herramienta para recordar las 鈥淣otas de Conell鈥.

Al ponerlo en visual studio code, me sale un TypeError en " hotel = Hotel (50, 20) " y no entiendo, al poner
" hotel.anadir_huespedes(3) " los valores se hotel se unen con anadir_huespedes? o que funci贸n cumple esto?

Es decir, entiendo el contexto, pero no logro interiorizar la sintaxis, no la asimilo muy bien.

podr铆a ser las sgtes clases: PROVEEDORES - TIENDAS - CLIENTES - VENTAS -

self (que es simplemente una
referencia a la instancia).