Platzi
Platzi

¡Invierte en ti y celebremos! Adquiere un plan Expert o Expert+ a precio especial.

Antes: $349
$259
Currency
Antes: $349
Ahorras: $90
COMIENZA AHORA
Termina en: 8D : 10H : 35M : 21S

Programación Orientada a Objetos

2/25

Lectura

Programación orientada a objetos en Python

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

Me costo mucho entender la lectura, esta imagen me ayudo mucho, aunque la verdad aun no tengo claro para que sirve el ‘self’
Capture.PNG

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

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 😃

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 😄

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)

Mi resumen.

Curso de POO y Algoritmos con Python-1.png

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 “Persona”, 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 “Persona 1”,

Esta instancia “Persona 1” tiene las mismas características (variables) y acciones (funciones) que la clase “Persona”, sólo que ahora ya tiene valores: Ejemplo:

Instancia “Persona 1”:
CARACTERÍSTICAS (Variables)
nombre = "Pedro"
apellido = "Martín"
edad = 30
género = “Masculino”

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

Y así como hemos creado la Instancia “Persona 1”, podemos crear otras instancias como “Persona 2”, “Persona 3”, etc… y cada una puede tener diferentes Características o valores.

Espero les sirva de ayuda

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

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```
script_python_hotel.png
primera clase.JPG

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/

¿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 ‘alias’ y en función de ese ‘alias’ 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 “comprender” 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

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

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)


¿Instancia es lo mismo que Objeto?

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 “argumentos (valores)” para determinados “pará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 (“Guau; 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).

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

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 cumpleaños(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.

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(“el coche ha arrancado”)

mi_coche=Coche()
coche_de_mi_gfa=Coche()

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:

clase_cohete.png

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: ‘insumo’, ‘analisis_unitario’ y ‘presupuesto’.
  2. Asignar a cada clase sus atributos y métodos, por ejemplo: ‘insumo’ tiene como atributos: ‘id_insumo’, ‘nombre’, ‘unidad’, ‘valor_unitario’. ‘analisis_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 ‘presupuesto’, ya que tienen un alcance específico. En cada presupuesto se llaman los ‘analisis_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()

Esta imagen me aclaró la estructura de una clase:
clase_enpython_partes.png

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 ‘Error’.

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 “set_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 “self” como primer argumento.

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')

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 “despué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 👍
.
poo.PNG

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

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 añadir_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:

Screen Shot 2021-02-14 at 3.28.14 PM.png

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(“sqrt(xx+yy)+3cos(sqrt(xx+y*y))+5”,“XY”)
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 ‘persona’

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 “Notas 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).

La población de un REBAÑO, (edad, vacunas,…)

hotel_de_angel = Hotel(50,20) #instancia del objeto
hotel_de_angel.anadir_huespedes(800000000)
hotel_de_angel.checkout(1)
print(hotel_de_angel.ocupacion_total())
799999999

No hay nada aún aquí!

class vehiculo():
    def __init__(self, puertas, ruedas, largo, ancho, motor, cylindraje, aireacondicinado,tipocombustible, color):
        self.puertas = puertas
        self.ruedas = ruedas
        self.largo = largo
        self.ancho = ancho
        self.motor = motor
        self.cylindraje = cylindraje
        self.aireacondicionado = aireacondicinado
        self.tipocombustible = tipocombustible
        self.color = color

    def caracteristicas(self):
        for attr, value in self.items():
            print(attr, ":", value)


MiCarro = vehiculo(4, 4, 3, 1.5, 'combustion interna', 2000, 'gasolina', "negro")
MiCarro.caracteristicas()

todos comentando su conocimiento y yo: Kha?

Para mi sería útil crear la clase paciente, y cada paciente tiene sus instancias, como por ejemplo, peso, talla, frecuencia cardiaca, frecuencia respiratoria, circunferencia de cintura y circunferencia de cadera; finalmente podría definir los métodos de instancia: Índice de masa corporal y Índice cintura-cadera.

Cuando se refieren a instancia se trata del espacio definido cuando se crea una clase con el keyword class, correcto?

Clases: Es el diseño de un objeto a fabricar
Los objetos es la materializacion de la clase
todos los metodos en las clases usan la palabra self como parametro
en C se usan contructores para iniciar una clase, en python usan ini

Una no tengo clara la utilidad de Self. Agradezco cualquier aporte!

La programación orientada a objetos o POO para algunas personas les parece algo compleja y no la entienden del todo al principio pero en realidad es fácil solo debes abstraer las cosas un poco y entender que todo se puede representar mediante objetos

Clase: Agrupacion de objetos.
Atributos: Caracteristicas de la clase (del objeto)
Metodos: Acciones que el objeto puede realizar o acciones que podemos realizar con los atributos.