Fundamentos de Programación Orientada a Objetos en Python

# Fundamentos de la Programación Orientada a Objetos (POO) La Programación Orientada a Objetos es un paradigma de programación que organiza el diseño del software en torno a objetos. Los objetos son instancias de clases, que pueden tener atributos (datos) y métodos (funciones). #### Conceptos Clave 1. **Clase**: Es un molde o plantilla que define los atributos y métodos que tendrán los objetos. 2. **Objeto**: Es una instancia de una clase. 3. **Atributo**: Es una variable que pertenece a una clase o a un objeto. 4. **Método**: Es una función que pertenece a una clase o a un objeto. 5. **Herencia**: Es un mecanismo por el cual una clase puede heredar atributos y métodos de otra clase. 6. **Encapsulamiento**: Es el concepto de ocultar los detalles internos de un objeto y exponer sólo lo necesario. 7. **Polimorfismo**: Es la capacidad de diferentes clases de ser tratadas como instancias de la misma clase a través de una interfaz común.

**Self - Analogía con un espejo:** Imagina que cada objeto tiene un espejo. Cuando un objeto se mira en el espejo (`self`), ve sus propios atributos (nombre, color, nivel de batería) y puede actuar sobre ellos (caminar, hablar, cargar batería). Ejemplo con robot's: ```python class Robot: def __init__(self, nombre, color, nivel_bateria): self.nombre = nombre self.color = color self.nivel_bateria = nivel_bateria def caminar(self): if self.nivel_bateria > 10: print(f"{self.nombre} está caminando.") self.nivel_bateria -= 10 # Reduce la batería al caminar else: print(f"{self.nombre} necesita recargar batería.") def hablar(self, mensaje): print(f"{self.nombre} dice: {mensaje}") def cargar_bateria(self): self.nivel_bateria = 100 print(f"{self.nombre} ha recargado su batería al 100%.") # Creamos dos robots mi_robot = Robot("R2-D2", "blanco", 100) otro_robot = Robot("C-3PO", "dorado", 80) # Hacemos que los robots realicen acciones mi_robot.caminar() # Output: R2-D2 está caminando. mi_robot.hablar("¡Hola!") # Output: R2-D2 dice: ¡Hola! otro_robot.hablar("¡Saludos!") # Output: C-3PO dice: ¡Saludos! otro_robot.caminar() # Output: C-3PO está caminando. # Simulamos que los robots caminan varias veces for _ in range(10): mi_robot.caminar() mi_robot.caminar() # Output: R2-D2 necesita recargar batería. mi_robot.cargar_bateria() # Output: R2-D2 ha recargado su batería al 100%. mi_robot.caminar() # Output: R2-D2 está caminando. ```

La Programación Orientada a Objetos (POO) es un paradigma de programación que se basa en el uso de \*\*objetos\*\* para diseñar y desarrollar aplicaciones. Este enfoque se centra en crear software que sea modular, reutilizable y más fácil de mantener. Aquí están los fundamentos clave de la POO: \### 1. \*\*Clases y Objetos\*\* \- \*\*Clase:\*\* Una clase es un molde o plantilla que define las propiedades (atributos) y comportamientos (métodos) que tendrán los objetos creados a partir de ella. Por ejemplo, una clase `Coche` podría tener atributos como `color`, `marca`, y `modelo`, y métodos como `arrancar()` o `frenar()`. \- \*\*Objeto:\*\* Un objeto es una instancia de una clase. Es un elemento concreto que se crea a partir de una clase, con valores específicos para sus atributos. Por ejemplo, un objeto de la clase `Coche` podría ser un coche rojo de la marca `Toyota` y modelo `Corolla`. \### 2. \*\*Encapsulamiento\*\* \- El encapsulamiento consiste en ocultar los detalles internos de un objeto y exponer sólo lo necesario. Esto se logra mediante el uso de \*\*modificadores de acceso\*\* como `private`, `protected`, y `public`, que controlan qué partes de un objeto pueden ser accedidas o modificadas desde fuera de su clase. Esto protege los datos y asegura que solo se modifiquen de manera controlada. \### 3. \*\*Herencia\*\* \- La herencia permite crear nuevas clases basadas en clases existentes. Una clase que hereda de otra (llamada \*\*subclase\*\* o \*\*clase derivada\*\*) toma los atributos y métodos de la clase base (llamada \*\*superclase\*\* o \*\*clase padre\*\*), y puede añadir o modificar funcionalidades. Esto fomenta la reutilización del código y la creación de jerarquías de clases. Por ejemplo, si tenemos una clase `Vehículo`, podemos crear una subclase `Coche` que herede de `Vehículo`. \### 4. \*\*Polimorfismo\*\* \- El polimorfismo permite que un mismo método o función pueda tener diferentes comportamientos según el objeto que lo invoque. Existen dos tipos principales de polimorfismo: \- \*\*Polimorfismo en tiempo de compilación (sobrecarga):\*\* Permite definir varios métodos con el mismo nombre pero diferentes parámetros. \- \*\*Polimorfismo en tiempo de ejecución (sobreescritura):\*\* Permite que una subclase redefina un método de su superclase para modificar su comportamiento. \### 5. \*\*Abstracción\*\* \- La abstracción consiste en representar conceptos esenciales sin incluir detalles de implementación específicos. Las clases abstractas y las interfaces son herramientas que permiten definir métodos sin implementarlos, dejando que las clases derivadas proporcionen la implementación. Esto facilita la creación de sistemas flexibles y extensibles. \### 6. \*\*Modularidad\*\* \- La POO promueve la división del software en módulos o componentes independientes (objetos), que pueden ser desarrollados, testeados y mantenidos por separado, pero que funcionan juntos como un todo coherente. \### 7. \*\*Relaciones entre Objetos\*\* \- Las clases y objetos pueden relacionarse de varias maneras, como: \- \*\*Asociación:\*\* Una relación donde un objeto utiliza a otro. \- \*\*Agregación:\*\* Una forma más débil de asociación, donde un objeto contiene referencias a otros objetos. \- \*\*Composición:\*\* Una forma más fuerte de agregación, donde un objeto contiene y controla completamente a otros objetos. \### Ventajas de la POO: \- \*\*Reutilización de código:\*\* Las clases pueden reutilizarse en diferentes partes de un programa o en diferentes proyectos. \- \*\*Facilidad de mantenimiento:\*\* El encapsulamiento y la modularidad facilitan la localización y corrección de errores. \- \*\*Facilidad de expansión:\*\* La herencia y la abstracción permiten agregar nuevas funcionalidades sin alterar el código existente. \- \*\*Flexibilidad:\*\* El polimorfismo permite que el código sea más flexible y fácil de extender. Estos fundamentos hacen de la POO un enfoque poderoso y ampliamente utilizado en el desarrollo de software moderno.

`__init__` es el nombre del método. Este nombre es especial y está reservado para los constructores en Python

\#nombre de la Clase class <u>Person</u>: ( siempre en mayúscula ) \#constructor ( debe ser un función def \_\_init\_\_(self,name,age): self.name = name self.age = age Tremenda "Clase" <<<<<<

## **Fundamentos de Programación Orientada a Objetos en Python** El objetivo de este código es simular una cuenta bancaria con algunas operaciones básicas, como depositar, retirar dinero y activar o desactivar la cuenta. ### 1. **Clase** `BankAccount`**:** Una **clase** es como un plano o plantilla que define cómo serán los objetos que crees a partir de ella. En este caso, la clase `BankAccount` es el plano para crear cuentas bancarias. ### 2. **Método** `__init__`**:** Este método es el **constructor**, es decir, se ejecuta automáticamente cuando creas una nueva cuenta bancaria. Aquí defines los **atributos** de la cuenta, que son: * `account_holder`: El nombre del dueño de la cuenta. * `balance`: El saldo de la cuenta. * `is_active`: Un indicador de si la cuenta está activa o no (por defecto es `True`). Es como llenar un formulario cuando abres una cuenta nueva. def \_\_init\_\_(self, account\_holder, balance): self.account\_holder = account\_holder self.balance = balance self.is\_active = True`self` se refiere a la cuenta que estás creando. Todo lo que pongas como `self.algo` pertenece a esa cuenta en particular. ### 3. **Método** `deposit`**:** Este método permite **depositar** dinero en la cuenta. Primero verifica si la cuenta está activa. Si lo está, suma el monto al saldo actual y te muestra un mensaje con el nuevo saldo. def deposit(self, amount): if self.is\_active: self.balance += amount print(f"Se ha depositado {amount}. Saldo actual {self.balance}") else: print("No se puede depositar, cuenta inactiva") ### 4. **Método** `withdraw`**:** Este método permite **retirar** dinero. Primero verifica si la cuenta está activa. Si lo está, comprueba si tienes suficiente dinero para retirar. Si es así, reduce el saldo; si no, te avisa que no tienes fondos suficientes. def withdraw(self, amount): if self.is\_active: if amount <= self.balance: self.balance -= amount print(f"Se ha retirado {amount}. Saldo actual {self.balance}") else: print("Fondos insuficientes") else: print("No se puede retirar, cuenta inactiva") ### 5. **Métodos** `deactivate_account` **y** `activate_account`**:** Estos métodos permiten **desactivar** o **activar** la cuenta. Cuando una cuenta está desactivada, no se pueden hacer depósitos ni retiros. def deactivate\_account(self): self.is\_active = False print("La cuenta ha sido desactivada") def activate\_account(self): self.is\_active = True print("La cuenta ha sido activada") ### 6. **Crear objetos (cuentas bancarias):** Aquí estás creando dos cuentas bancarias: una para Ana y otra para Luis, con saldos iniciales de 500 y 1000, respectivamente. account1 = BankAccount("Ana", 500) account2 = BankAccount("Luis", 1000) ### 7. **Llamar a los métodos:** Por último, se hacen operaciones con las cuentas: * **Depositar** dinero en las cuentas de Ana y Luis. * **Desactivar** la cuenta de Ana y luego intentar depositar, lo cual no se permite porque la cuenta está desactivada. account1.deposit(200) account2.deposit(100) account1.deactivate\_account() account1.deposit(50) # Esto no funcionará porque la cuenta está desactivada ### Resumen: 1. **Clase** `BankAccount`: Es el plano para crear cuentas bancarias. 2. **Métodos**: Son acciones que puedes hacer con una cuenta (depositar, retirar, activar/desactivar). 3. **Objetos**: `account1` y `account2` son ejemplos de cuentas bancarias que creaste usando la clase. Con esto, puedes manejar varias cuentas de banco en el programa, y hacer operaciones básicas como depósitos y retiros. ¡Así es cómo funciona la POO!

Quisiera compartir un ejercicio que aplica la programación orientada a objetos. ```js # Enter your date automatic class Enter_Date: def __init__(self, name, years): self.DateN = [] self.name = name self.years = years self.available = True def list_date(self): if self.available: self.DateN.append(self.name) self.DateN.append(self.years) return self.DateN class start: def __init__(self): self.var1 = "" self.var2 = "" def conversation(self): print("Hello today we are going to store data ") print("1.Enter date ") print("2.End ") Enter1 = int(input()) if Enter1 == 1: self.var1 = input("Enter your name: ") self.var2 = input("Enter your age: ") return self.var1, self.var2 else: print("Coming out") income = int(input("Please income how much data going to Enter ")) all_data = [] user1 = None for i in range(income): person1 = start() person1.conversation() user1 = Enter_Date(person1.var1, person1.var2) all_data.append(user1.list_date()) print(all_data) class Rol_family: def __init__(self, data): self.data = data self.occupation = [] def enter_date(self, index): adjusted_index = index - 1 if adjusted_index < len(self.data): name, age = self.data[adjusted_index] print(f"Hola {name} a question") occupation_data = input("What is your occupation in the family? ") self.occupation.append(occupation_data) return occupation_data else: return "Index out of range" def result_date(self, index): if index < len(self.occupation): name, age = self.data[index] print(f"{name} of {age} ages your occupation in family is {self.occupation[index]}") else: print("Index out of range") start_family = Rol_family(all_data) for i in range(len(all_data)): index_to_retrieve = int(input("Enter the index of the data you want to retrieve: ")) print(start_family.enter_date(index_to_retrieve)) print(start_family.occupation) one = 0 while one < len(all_data): start_family.result_date(one) one += 1 ```

El constructor es una funcion propia y especial de las clases

por qué me sale este error ? account1 = Bankaccount("Ana", 300) TypeError: Bankaccount() takes no arguments

```js class Bank_Account: def __init__(self, balance, account_holder): self.balance = balance self.account_holder = account_holder self.is_active = True def deposit(self, ammount): if self.is_active: self.balance += ammount print(f'Depositaste ${ammount}. Total: {self.balance}') else: print('Operación no realizada. La cuenta no se encuentra activa') def print_balance(self): print(f'Hola, {self.account_holder}, tu balance actual es: ${self.balance}') def withdraw(self, ammount): if self.is_active: if self.balance < ammount: print(f'No puedes retirar una cantida mayor al monto disponible: {self.balance}') else: self.balance -= ammount print(f'Retiraste ${ammount}. Total: ${self.balance}') else: print('Operación no realizada. La cuenta no se encuentra activa') def activate(self): if self.is_active: print('La cuenta está activa actualmente') else: self.is_active = True print('La cuenta se activó correctamente') def deactivate(self): if not self.is_active: print('La cuenta está inactiva actualmente') else: self.is_active = True print('La cuenta se desactivó correctamente') bank_account1 = Bank_Account(100, 'Edwin') bank_account1.deposit(35) bank_account1.print_balance() bank_account1.withdraw(83) bank_account1.print_balance() bank_account1.activate() bank_account1.deactivate() ```

En Python, `self` se utiliza para referirse a la instancia actual de la clase. Cuando se define un atributo dentro de un método, como el constructor `__init__`, se precede con `self` para que se asocie específicamente con el objeto que se está creando. Esto permite acceder y modificar los atributos del objeto en otros métodos de la clase. Por ejemplo, `self.nombre` guarda el nombre del objeto y se puede utilizar en cualquier método de la clase para referirse a ese atributo.

````python class BankAccount: def __init__(self, account_holder, balance): self.account_holder = account_holder self.balance = balance self.is_active = True def deposit(self, amount): if self.is_active: self.balance += amount print(f"Se ha depositado ${amount}. Su saldo actual es de ${self.balance}") else: print("No se puede depositar, cuenta inicativa") def withdraw(self, amount): if self.is_active: if amount <= self.balance: self.balance -= amount print(f"Se ha retirado ${amount}. Su saldo actual es de ${self.balance}") else: print(F"Saldo insuficiente, quieres retirar ${amount} y solo tienes ${self.balance}") else: print("No se puede retirar, cuenta inicativa") def active_account(self): self.is_active = True print("Su cuenta ha sido activada") def deactive_account(self): self.is_active = False print("Su cuenta ha sido desactivada") account1 = BankAccount("Marta", 500) account2 = BankAccount("José", 740) account1.deposit(200) account2.deposit(100) account1.withdraw(50) account2.withdraw(5000) account1.deactive_account() account1.deposit(100) account1.active_account() account1.deposit(100) ```class BankAccount:    def \_\_init\_\_(self, account\_holder, balance):        self.account\_holder = account\_holder        self.balance = balance        self.is\_active = True     def deposit(self, amount):        if self.is\_active:            self.balance += amount            print(f"Se ha depositado ${amount}. Su saldo actual es de ${self.balance}")        else:            print("No se puede depositar, cuenta inicativa")     def withdraw(self, amount):        if self.is\_active:            if amount <= self.balance:                self.balance -= amount                print(f"Se ha retirado ${amount}. Su saldo actual es de ${self.balance}")            else:                print(F"Saldo insuficiente, quieres retirar ${amount} y solo tienes ${self.balance}")            else:            print("No se puede retirar, cuenta inicativa")     def active\_account(self):        self.is\_active = True        print("Su cuenta ha sido activada")        def deactive\_account(self):        self.is\_active = False        print("Su cuenta ha sido desactivada") account1 = BankAccount("Marta", 500)account2 = BankAccount("José", 740) account1.deposit(200)account2.deposit(100)account1.withdraw(50)account2.withdraw(5000)account1.deactive\_account()account1.deposit(100)account1.active\_account()account1.deposit(100) ````

Muy buena clase. Analogia con Planos(Clases) y Objetos(Casa Construidas) Clases: Son moldes, especificaciones o planos que describen el numero de habitaciones(Atributos) su espacio(Tipo de dato) donde algo se va a guardar muebles(Datos) para hacer cosas con esos muebles en el futuro como pintar muebles vaciasr = (Metodos)  Objeto: Son las casas Construidas por una constructora(Sistema operativo/Win/Mac/Linux) y ya disponibles para meter tus muebles con el numero de habitaciones(Atributos) especificados en el plano(Clase) y las acciones(Metodos) que puedes hacer con tus muebles asi que ya puedes meter un mueble negro a una habitacion pintarlo y destruirlo 

No me queda claro aun ¿cuándo escribir self y cuándo no? es un poco confuso. Gracias.

No hay control de calidad en estos videos 😕 revisen porfavor las clases, tienen muchos errores y no se corrigen. (Me dirijo a los editores o encargados etc)

La propiedad `is_active` en el contexto de programación orientada a objetos en Python es un atributo de tipo booleano. Este tipo de entrada se utiliza para representar el estado de una cuenta (o cualquier entidad) que puede estar activa (True) o inactiva (False). En el ejemplo del curso, `is_active` se utiliza para controlar si se pueden realizar operaciones como depósitos o retiros en una cuenta bancaria.

Un paradigma es un modelo o un conjunto de conceptos y prácticas que definen una forma de entender y abordar un determinado campo de estudio o actividad. En programación, por ejemplo, un paradigma determina cómo se organizan y estructuran los programas. La programación orientada a objetos, que se mencionó en la clase, es un paradigma que organiza el software en "objetos" que representan entidades del mundo real, facilitando la reutilización del código y la modularidad.

\# Atributos: Propiedades que definen al objeto# Métodos: Acciones que puede realizar el objeto# Clase: Plantilla que contiene los atributos y métodos del objeto, con esta plantilla se pueden crear objetos de ese tipo (instanciar) class Persona:    def \_\_init\_\_(self, nombre, edad): # \_\_init\_\_ Método que permite instanciar y darle los valores necesarios para inicializarlo        self.nombre = nombre # Atributo 1        self.edad = edad # Atributo 2        def saludar(self): # Método 1        print(f'Hola mundo soy {self.nombre}') \# Instanciar (Crear un objeto)persona1 = Persona('Cesar', 21)# Una vez creado un objeto se accede con ' . ' a sus atributos ya sea para consultarlos o modificarlosprint(persona1.nombre)persona1.nombre = 'David'# con ' .() ' se ejecutan los metodos del objetopersona1.saludar()

El error `TypeError: BankAccount() takes no arguments` indica que tu clase `BankAccount` no está configurada para recibir parámetros en su constructor. Asegúrate de que tu constructor en la clase `BankAccount` esté definido correctamente para aceptar los argumentos que mencionaste, como `account_holder` y `balance`. Tu constructor debería verse así: ```python class BankAccount: def __init__(self, account_holder, balance): self.account_holder = account_holder self.balance = balance self.is_active = True ``` Verifica que la definición de tu clase incluya estos parámetros.

Uyyy este si está desefiante!! Me gusta! Ya empieza lo chido!!

''' `Hola amig@s, hice un código para prácticar. Espero que les guste, igual si tienen alguna observación se los agradecería.` `'''` *class* BankAcountPlant:    *def* \_\_init\_\_(self, account\_holder, amount\_btc, amount\_plt):        *self*.account\_holder *=* account\_holder        *self*.amount\_btc *=* amount\_btc        *self*.amount\_plt *=* amount\_plt        *self*.is\_active *=* True        *def* *GetBalance*(self, coin):        *try*:             *if* coin.lower() *==* "bitcoin" *or* coin.lower() *==* "btc" *and* *self*.is\_active:                print(*f*"Hola {*self*.account\_holder}, el balance de tu cuenta en bitcoin es: {*self*.amount\_btc} BTC")            *elif* coin.lower() *==* "plants coin" *or*  coin.lower() *==* "plt" *and* *self*.is\_active:                print(*f*"Hola {*self*.account\_holder}, el balance de tu cuenta en plants coin es: {*self*.amount\_plt} PLT")            *else*:                 print(*f*"Cuenta no activa")        *except*:            print("Opcion no valida!")     *def* *Deposit*(self, coin, income):        *try*:             *if* *self*.is\_active:                *if* coin.lower() *==* "bitcoin" *or* coin.lower() *==* "btc":                    *try*:                        *self*.amount\_btc *+=* income                        print(*f*"{*self*.account\_holder}, has depositado {income} BTC. Tu balance en bitcoin es: {*self*.amount\_btc}")                    *except*:                        print("Deposito invalido")                *elif* coin.lower() *==* "plantscoin" *or* coin.lower() *==* "plt":                    *try*:                        *self*.amount\_plt *+=* income                        print(*f*"{*self*.account\_holder}, has depositado {income} PLT. Tu balance en plants coin es: {*self*.amount\_plt}")                    *except*:                        print("Deposito invalido")            *else*:                print("Cuenta inactiva")        *except*:            print("Opcion no valida!")        *def* *Withdraw*(self, coin, outcome):        *try*:             *if* *self*.is\_active:                *if* coin.lower() *==* "bitcoin" *or* coin.lower() *==* "btc":                    *try*:                        *if* *self*.amount\_btc *<* outcome:                            print(*f*"{*self*.account\_holder}, no puedes retirar {outcome} BTC. El balance de tu cuenta es: {*self*.amount\_btc}")                        *else*:                            *self*.amount\_btc *-=* outcome                            print(*f*"{*self*.account\_holder}, has retirado {outcome} BTC. Tu balance en bitcoin es: {*self*.amount\_btc}")                    *except*:                        print("Deposito invalido")                *elif* coin.lower() *==* "plants coin" *or* coin.lower() *==* "plt":                    *try*:                        *if* *self*.amount\_plt *<* outcome:                            print(*f*"{*self*.account\_holder}, no puedes retirar {outcome} PLT. El balance de tu cuenta es: {*self*.amount\_plt} PLT")                        *else*:                            *self*.amount\_plt *-=* outcome                            print(*f*"{*self*.account\_holder}, has retirado {outcome} PLT. Tu balance en plants coin es: {*self*.amount\_plt}")                    *except*:                        print("Deposito invalido")            *else*:                print("Cuenta inactiva")        *except*:            print("Opcion no valida!")     *def* *DeactivateAcount*(self):        *self*.is\_active *=* False        *def* *ActivateAcount*(self):        *self*.is\_active *=* True Account\_1 *=* BankAcountPlant("James Rodriguez", 5.4, 10000) Account\_2 *=* BankAcountPlant("Silvia Rodriguez", 8, 122.89) Account\_1.GetBalance("Bitcoin")Account\_1.GetBalance("Plt") Account\_2.GetBalance("btc")Account\_2.GetBalance("Plants coin") Account\_1.DeactivateAcount()Account\_1.ActivateAcount()Account\_1.Deposit("btc", 0.5)Account\_1.Withdraw("plt", 100) Account\_2.Deposit("plt", 500)Account\_2.Withdraw("PLANTS COIN", 22)

````python class BankAcountPlant: def __init__(self, account_holder, amount_btc, amount_plt): self.account_holder = account_holder self.amount_btc = amount_btc self.amount_plt = amount_plt self.is_active = True def GetBalance(self, coin): try: if coin.lower() == "bitcoin" or coin.lower() == "btc" and self.is_active: print(f"Hola {self.account_holder}, el balance de tu cuenta en bitcoin es: {self.amount_btc} BTC") elif coin.lower() == "plants coin" or coin.lower() == "plt" and self.is_active: print(f"Hola {self.account_holder}, el balance de tu cuenta en plants coin es: {self.amount_plt} PLT") else: print(f"Cuenta no activa") except: print("Opcion no valida!") def Deposit(self, coin, income): try: if self.is_active: if coin.lower() == "bitcoin" or coin.lower() == "btc": try: self.amount_btc += income print(f"{self.account_holder}, has depositado {income} BTC. Tu balance en bitcoin es: {self.amount_btc}") except: print("Deposito invalido") elif coin.lower() == "plantscoin" or coin.lower() == "plt": try: self.amount_plt += income print(f"{self.account_holder}, has depositado {income} PLT. Tu balance en plants coin es: {self.amount_plt}") except: print("Deposito invalido") else: print("Cuenta inactiva") except: print("Opcion no valida!") def Withdraw(self, coin, outcome): try: if self.is_active: if coin.lower() == "bitcoin" or coin.lower() == "btc": try: if self.amount_btc < outcome: print(f"{self.account_holder}, no puedes retirar {outcome} BTC. El balance de tu cuenta es: {self.amount_btc}") else: self.amount_btc -= outcome print(f"{self.account_holder}, has retirado {outcome} BTC. Tu balance en bitcoin es: {self.amount_btc}") except: print("Deposito invalido") elif coin.lower() == "plants coin" or coin.lower() == "plt": try: if self.amount_plt < outcome: print(f"{self.account_holder}, no puedes retirar {outcome} PLT. El balance de tu cuenta es: {self.amount_plt} PLT") else: self.amount_plt -= outcome print(f"{self.account_holder}, has retirado {outcome} PLT. Tu balance en plants coin es: {self.amount_plt}") except: print("Deposito invalido") else: print("Cuenta inactiva") except: print("Opcion no valida!") def DeactivateAcount(self): self.is_active = False def ActivateAcount(self): self.is_active = True Account_1 = BankAcountPlant("James Rodriguez", 5.4, 10000) Account_2 = BankAcountPlant("Silvia Rodriguez", 8, 122.89) Account_1.GetBalance("Bitcoin") Account_1.GetBalance("Plt") Account_2.GetBalance("btc") Account_2.GetBalance("Plants coin") Account_1.DeactivateAcount() Account_1.ActivateAcount() Account_1.Deposit("btc", 0.5) Account_1.Withdraw("plt", 100) Account_2.Deposit("plt", 500) Account_2.Withdraw("PLANTS COIN", 22) ```*class* BankAcountPlant:    *def* \_\_init\_\_(self, account\_holder, amount\_btc, amount\_plt):        *self*.account\_holder *=* account\_holder        *self*.amount\_btc *=* amount\_btc        *self*.amount\_plt *=* amount\_plt        *self*.is\_active *=* True        *def* *GetBalance*(self, coin):        *try*:             *if* coin.lower() *==* "bitcoin" *or* coin.lower() *==* "btc" *and* *self*.is\_active:                print(*f*"Hola {*self*.account\_holder}, el balance de tu cuenta en bitcoin es: {*self*.amount\_btc} BTC")            *elif* coin.lower() *==* "plants coin" *or*  coin.lower() *==* "plt" *and* *self*.is\_active:                print(*f*"Hola {*self*.account\_holder}, el balance de tu cuenta en plants coin es: {*self*.amount\_plt} PLT")            *else*:                 print(*f*"Cuenta no activa")        *except*:            print("Opcion no valida!")     *def* *Deposit*(self, coin, income):        *try*:             *if* *self*.is\_active:                *if* coin.lower() *==* "bitcoin" *or* coin.lower() *==* "btc":                    *try*:                        *self*.amount\_btc *+=* income                        print(*f*"{*self*.account\_holder}, has depositado {income} BTC. Tu balance en bitcoin es: {*self*.amount\_btc}")                    *except*:                        print("Deposito invalido")                *elif* coin.lower() *==* "plantscoin" *or* coin.lower() *==* "plt":                    *try*:                        *self*.amount\_plt *+=* income                        print(*f*"{*self*.account\_holder}, has depositado {income} PLT. Tu balance en plants coin es: {*self*.amount\_plt}")                    *except*:                        print("Deposito invalido")            *else*:                print("Cuenta inactiva")        *except*:            print("Opcion no valida!")        *def* *Withdraw*(self, coin, outcome):        *try*:             *if* *self*.is\_active:                *if* coin.lower() *==* "bitcoin" *or* coin.lower() *==* "btc":                    *try*:                        *if* *self*.amount\_btc *<* outcome:                            print(*f*"{*self*.account\_holder}, no puedes retirar {outcome} BTC. El balance de tu cuenta es: {*self*.amount\_btc}")                        *else*:                            *self*.amount\_btc *-=* outcome                            print(*f*"{*self*.account\_holder}, has retirado {outcome} BTC. Tu balance en bitcoin es: {*self*.amount\_btc}")                    *except*:                        print("Deposito invalido")                *elif* coin.lower() *==* "plants coin" *or* coin.lower() *==* "plt":                    *try*:                        *if* *self*.amount\_plt *<* outcome:                            print(*f*"{*self*.account\_holder}, no puedes retirar {outcome} PLT. El balance de tu cuenta es: {*self*.amount\_plt} PLT")                        *else*:                            *self*.amount\_plt *-=* outcome                            print(*f*"{*self*.account\_holder}, has retirado {outcome} PLT. Tu balance en plants coin es: {*self*.amount\_plt}")                    *except*:                        print("Deposito invalido")            *else*:                print("Cuenta inactiva")        *except*:            print("Opcion no valida!")     *def* *DeactivateAcount*(self):        *self*.is\_active *=* False        *def* *ActivateAcount*(self):        *self*.is\_active *=* True Account\_1 *=* BankAcountPlant("James Rodriguez", 5.4, 10000) Account\_2 *=* BankAcountPlant("Silvia Rodriguez", 8, 122.89) Account\_1.GetBalance("Bitcoin")Account\_1.GetBalance("Plt") Account\_2.GetBalance("btc")Account\_2.GetBalance("Plants coin") Account\_1.DeactivateAcount()Account\_1.ActivateAcount()Account\_1.Deposit("btc", 0.5)Account\_1.Withdraw("plt", 100) Account\_2.Deposit("plt", 500)Account\_2.Withdraw("PLANTS COIN", 22)```js ````

gracias, muy buena y clara clase

class Bankaccount:    def \_\_init\_\_(self, client, balance):        *self*.client = client        *self*.balance = balance        *self*.active\_account = True     def deposit(self, amount):        if *self*.active\_account:            *self*.balance += amount            print(f"""You have deposited an amount of ${amount}, to a balance of ${*self*.balance - amount}. Your current balance is ${*self*.balance}.""")        else:            print("This account is not active so you cannot perform any transactions here.")     def withdraw(self, amount):        if *self*.active\_account:            if *self*.balance >= amount:                *self*.balance -= amount                print(f"You have withdrawn an amount of ${amount}. Your current balance is ${*self*.balance}")            else:                print(f"Insufficient funds. The maximum amount you can withdraw is: ${*self*.balance}.")         else:            print("This account is not active.")     def deactivate\_account(self):        if *self*.active\_account == True:            *self*.active\_account = False            print(f"The account of {*self*.client}, has been deactivated successfully")     def reactivate\_account(self):        if *self*.active\_account == False:            *self*.active\_account = True            print(f"The account of {*self*.client} has been activated.") account1 = Bankaccount("Clint", 700)account2 = Bankaccount("Fred", 1100) ```js ``` ```python class Bankaccount: def __init__(self, client, balance): self.client = client self.balance = balance self.active_account = True def deposit(self, amount): if self.active_account: self.balance += amount print(f"""You have deposited an amount of ${amount}, to a balance of ${self.balance - amount}. Your current balance is ${self.balance}.""") else: print("This account is not active so you cannot perform any transactions here.") def withdraw(self, amount): if self.active_account: if self.balance >= amount: self.balance -= amount print(f"You have withdrawn an amount of ${amount}. Your current balance is ${self.balance}") else: print(f"Insufficient funds. The maximum amount you can withdraw is: ${self.balance}.") else: print("This account is not active.") def deactivate_account(self): if self.active_account == True: self.active_account = False print(f"The account of {self.client}, has been deactivated successfully") def reactivate_account(self): if self.active_account == False: self.active_account = True print(f"The account of {self.client} has been activated.") account1 = Bankaccount("Clint", 700) account2 = Bankaccount("Fred", 1100) ```

La sentencia `with` en Python se utiliza para simplificar el manejo de recursos, como archivos. Su principal ventaja es que garantiza que los recursos se liberen automáticamente después de su uso, incluso si ocurre un error. Por ejemplo, al abrir un archivo: ```python with open('archivo.txt', 'r') as file: contenido = file.read() ``` Aquí, el archivo se cierra automáticamente al finalizar el bloque, evitando fugas de recursos. Esta práctica mejora la legibilidad y la eficiencia del código.

```js #Fundamentos de Programación Orientada a Objetos en Python class person: def __init__(self,name, age): self.name = name self.age = age def greet(self): print(f"Hola , mi nombre es {self.name} y tengo,{self.age},") person1 = person('Alexis', 37) person2 = person('Luis', 23) person1.greet() person2.greet() ```#Fundamentos de Programación Orientada a Objetos en Pythonclass person:    def \_\_init\_\_(self,name, age):        self.name = name        self.age = age            def greet(self):        print(f"Hola , mi nombre es {self.name} y tengo,{self.age},")                person1 = person('Alexis', 37)person2 = person('Luis', 23) person1.greet()person2.greet()

Una clase en Python es como un molde o plantilla y ese molden tiene , digamos que ese molde es una figura humana,tine brazo tiene pierna, tieno ojo , tiene color

Fundamentos de Programación Orientada a Objetos en Python: Para crear una clase de objeto se usa class \_\_init\_\_ : \_\_init\_\_ se usa para inicializar atributos de un objeto. Se ejecuta automáticamente al crear una instancia. Es una parte clave de la programación orientada a objetos en Python. Hace que el código sea más limpio, organizado y fácil de entender. Crear objetos para la clase Person: class Person: def \_\_init\_\_(self, name, age): self.name = name self.age = age person1 = Person("Ana", 30) person2 = Person("Luis", 25) withdraw = retirar

Hola! Soy Sasha del futuro (Que ya terminó el modulo de POO) Les quiero dejar mis notas sobre POO en Python, (con cosas extras que no explican acá) Espero les sirva para entender mejor POO porque si es bastante enredado, pero creo que ya lo entendí y ese entendimiento lo plasme en mis notas! <https://sashanclrp.notion.site/Curso-Profesional-de-Python-148f47adcb91809c8d82cfc8af1b6edb?pvs=4>

`# Define the Car class` `class Car:` ` def __init__(self, make, model, year):` ` # Attributes` ` self.make = make` ` self.model = model` ` self.year = year` ` self.is_running = False` ` # Method to start the car` ` def start(self):` ` if not self.is_running:` ` self.is_running = True` ` print(f"The {self.make} {self.model} is now running.")` ` else:` ` print(f"The {self.make} {self.model} is already running!")` ` # Method to stop the car` ` def stop(self):` ` if self.is_running:` ` self.is_running = False` ` print(f"The {self.make} {self.model} has stopped.")` ` else:` ` print(f"The {self.make} {self.model} is already off.")` ` # Method to display car details` ` def display_info(self):` ` print(f"{self.year} {self.make} {self.model}")` `# Create an instance of the Car class` `my_car = Car("Toyota", "Corolla", 2022)` `# Use the class methods` `my_car.display_info() # Output: 2022 Toyota Corolla` `my_car.start() # Output: The Toyota Corolla is now running.` `my_car.stop() # Output: The Toyota Corolla has stopped.`

\# Define the Car class class Car: def \_\_init\_\_(self, make, model, year): \# Attributes self.make = make self.model = model self.year = year self.is\_running = False \# Method to start the car def start(self): if not self.is\_running: self.is\_running = True print(f"The {self.make} {self.model} is now running.") else: print(f"The {self.make} {self.model} is already running!") \# Method to stop the car def stop(self): if self.is\_running: self.is\_running = False print(f"The {self.make} {self.model} has stopped.") else: print(f"The {self.make} {self.model} is already off.") \# Method to display car details def display\_info(self): print(f"{self.year} {self.make} {self.model}") \# Create an instance of the Car class my\_car = Car("Toyota", "Corolla", 2022) \# Use the class methods my\_car.display\_info() # Output: 2022 Toyota Corolla my\_car.start() # Output: The Toyota Corolla is now running. my\_car.stop() # Output: The Toyota Corolla has stopped.

Decidí cambiar un poco el ejercicio, ahora es una cuenta de ahorros. ```python class Ahorro: def __init__(self, nombre, cuenta, saldo_inicial): self.nombre = nombre self.cuenta = cuenta self.saldo_inicial = saldo_inicial self.estado = True def depositar(self, cuenta, monto): if self.estado == True: if self.cuenta == cuenta: self.saldo_inicial += monto print(f"El monto ingresado es $ {monto} y su saldo total es $ {self.saldo_inicial}") else: print("Error: La cuenta ingresada no existe") else: print("Error: Su cuenta esta inactiva") def retirar(self, cuenta, monto): if self.estado == True: if self.cuenta == cuenta: if self.saldo_inicial >= monto: self.saldo_inicial -= monto print(f"Tu saldo final es $ {self.saldo_inicial} haz retirado $ {monto}") else: print("Error: El saldo de tu cuenta es menor al monto que intentas retirar") else: print("Error: Esta cuenta no es correcta") else: print("Error: Tu cuenta esta desactivada") def congelarCuenta(self, cuenta): if self.cuenta == cuenta: self.estado = False print("Estado: Cuenta desactivada exitosamente") else: print("Error: Esta cuenta no existe") def descongelarCuenta(self, cuenta): if self.cuenta == cuenta: self.estado = True print("Estado: Cuenta activada exitosamente") else: print("Error: Esta cuenta no existe") cuenta1 = Ahorro("Cristian Mora", 12345, 500) cuenta1.depositar(12345, 100) cuenta1.retirar(12345, 50) cuenta1.congelarCuenta(12345) cuenta1.depositar(12345, 500) cuenta1.descongelarCuenta(12345) cuenta1.depositar(12345, 400) ```

Para El caso practico de la clase; En cuanto a las funciones de desactivar y activar la cuenta. Yo preferiría crear una sola función llamada change_state(self) y preguntar dentro de la función si es true la convierta en false y si es false la convierta en true. De tal manera se llama una sola y no se requiere la validación de si esta o no desactivada para desactivar mismo.

Que tal chicos! Me dejo intrigado el porque creamos un metodo llamado **\_\_init\_\_** y nunca lo llamamos, estuve investigando y (espero explicarme bien) resulta que este metodo es importantisimo para que todos los atributos de la clase (name y age o account\_holder y balance), se definan desde la creacion de los objetos (person1 = Person('Carlitos',20)) y posteriormente se puedan utilizar estos atributos mas adelante dentro de los metodos (person1.greet()) Asi que, si por alguna razon nos saltamos la creacion del metodo \_\_**init**\_\_ no estaremos asignandole atributos a la clase, seria como crear un ser humano y no asignarle atributos como su nombre o su edad o su estatura y mas adelante no podriamos ni asignar ni llamar estos datos. Un punto extra es que este metodo init, en ejecucion de codigo, se llama cuando estamos creando los objetos de la clase.

No es obligatorio usar `def __init__` al construir una clase, pero es una buena práctica para inicializar atributos. El `self` se refiere a la instancia de la clase y es necesario para acceder a sus atributos y métodos. Sin `self`, no podrías referenciar los datos de la instancia.

Me sale este error: account1 = Bankaccount("Ana", 300) TypeError: Bankaccount() takes no arguments

Les comparto mi aporte con el ejercicio de la cuenta bancaria: ```python class BankAccount: def __init__(self, holder_name:str, balance:int): self.holder_name = holder_name self.balance = balance self.status = True print(f"Se ha creado la cuenta de: {self.holder_name}, con un saldo inicial de: {self.balance}") def deactivate(self): self.status = False print(f"Se ha desactivado la cuenta bancaria") def activate(self): self.status = True print(f"Se ha activado la cuenta bancaria") def deposit(self,amount:int): if amount > 0: self.balance += amount print(f"Se ha depositado un total de {amount}, el nuevo saldo es: {self.balance}") else: print(f"Error en el deposito!, El monto debe ser mayor a $0, el saldo actual es {self.balance}") def withdraw(self,amount:int): if self.balance <= 0: print(f"Se dispone de un saldo no apto para generar retiros, el saldo actual de la cuenta es {self.balance}") elif amount <= 0: print(f"Error en el retiro!, El monto a retirar debe ser mayor a $0, el saldo actual de la cuenta es {self.balance}") elif amount <= self.balance: self.balance -= amount print(f"Se ha retirado un total de {amount}, el nuevo saldo es: {self.balance}") else: print(f"Error en el retiro!, El monto a retirar debe ser a lo sumo igual que el saldo disponible, el saldo actual de la cuenta es {self.balance}") ```Espero les sea de utilidad!

Hola! Les comparto el código de la clase con algunas mejors en detalles y comentarios. ```python class Person: # Constructor, es una funcion propia y especial de las clases # En esta definimos los atributos principales def __init__(self, name, age): self.name = name self.age = age def greet(self): print(f"Hola, mi nombre es {self.name} y tengo {self.age} años") person1 = Person("Sara", 31) person2 = Person("Juan", 25) person1.greet() person2.greet() ``````python class BankAccount(): def __init__(self, account_number, balance): self.account_number = account_number self.balance = balance self.is_active = True def deposit(self, amount): if self.is_active: self.balance += amount print(f"Depósito de ${amount} realizado. Nuevo saldo: ${self.balance}") else: print("La cuenta está inactiva. No se puede realizar el depósito.") def withdraw(self, amount): if self.is_active: if self.balance >= amount: self.balance -= amount print(f"Retiro de ${amount} realizado. Nuevo saldo: ${self.balance}") else: print("Saldo insuficiente para realizar el retiro.") else: print("La cuenta está inactiva. No se puede realizar el retiro.") def deactivate_account(self): if self.is_active: self.is_active = False print("La cuenta ha sido desactivada.") else: print("La cuenta ya está inactiva.") def activate_account(self): if not self.is_active: self.is_active = True print("La cuenta ha sido activada.") else: print("La cuenta ya está activa.") # Creacion de Objetos account1 = BankAccount("123456789", 1000) account2 = BankAccount("987654321", 500) # Llamado a Métodos account1.deposit(500) account2.deposit(300) account1.withdraw(200) account2.withdraw(1600) account1.deactivate_account() account1.deposit(1000) account2.activate_account() ```

Faltó este pedacito de códiggo XD else:  print("Fondo insuficiente")

Consulta chicos: Para lograr convertirse en un Backend Developer esta bien emepezar por python ? y luego con que deberia seguir ? muchas gracias!!!

La programación orientada a objetos (POO) modela soluciones en términos de "objetos", los cuales representan tanto cosas físicas del mundo real como conceptos abstractos. Este enfoque se basa en la idea de que los objetos interactúan entre sí a través de sus propiedades (datos) y comportamientos (funciones) , El objetivo principal es organizar el código de manera modular, reutilizable y mantenible, facilitando la construcción de sistemas complejos.

`self.is_active = True` Esto es una variable de instancia, como bien dijo la profesora esta no se recibe como parametro pero si genera una copia en cada instancia, permitiendo que se pueda modificar, en este caso de True a False en cualquier momento, diferente a las variables de clase que son las que se crean fuera de las instancias y fuera del constructor,tambien se genera una copia en cada instancia pero a diferencia si se cambia el valor de esta se cambia el valor en todas las instancias.

Muy buena explicacion profe

Hize una pequeña mejora al ejercicio de la clase, para que se puedan hacer transferencias. class BankAccount:    def \_\_init\_\_(self, name, balance):        self.name = name        self.balance = balance        self.is\_activa = True            def deposit(self, amount):        if self.is\_activa:            self.balance += amount # Con esto se suma el monto al balance            print(f'Se ha hecho un deposito de {amount} a tu cuenta {self.name}, quedando un saldo de {self.balance} ')                    else:            print('La cuenta no está activa, o no existe')                def withdraw(self, amount):        if self.is\_activa:            if self.balance >= amount:                self.balance -= amount                print(f"Se ha hecho un retiro de tu cuenta {self.name} por un valor de {amount}, quedando un saldo de {self.balance}")            else:                print('Error interno, ---> No tienes suficiente saldo <---')                    def deactivate(self):        self.is\_activa = False        print(f'{self.name}, tu cuenta ha sido desactivada')            def activate(self):        self.is\_activa = True        print(f'{self.name}, tu cuenta ha sido activada')        # Crear transferencias entre cuentaas    def transfer(self, amount, account):        if self.is\_activa: #Si la cuenta está activa            if self.balance >= amount:                self.balance -= amount                account.balance += amount                print(f'Que Nota, {self.name} te ha transferido ${amount} {account.name}, quedaste con {account.balance}!!')            cuenta1 = BankAccount ('David', 10000)cuenta2 = BankAccount ('Paula', 200)cuenta3 = BankAccount ('Luisa', 50000) \# Llamar a los métodos de la clase BankAccountcuenta1.deposit(5000)cuenta2.withdraw(10000)cuenta3.deactivate()cuenta3.deposit(10000)cuenta2.withdraw(20)cuenta1.deposit(1000)cuenta3.activate()cuenta3.deposit(10000) cuenta3.transfer(30000, cuenta1) ```js class BankAccount: def __init__(self, name, balance): self.name = name self.balance = balance self.is_activa = True def deposit(self, amount): if self.is_activa: self.balance += amount # Con esto se suma el monto al balance print(f'Se ha hecho un deposito de {amount} a tu cuenta {self.name}, quedando un saldo de {self.balance} ') else: print('La cuenta no está activa, o no existe') def withdraw(self, amount): if self.is_activa: if self.balance >= amount: self.balance -= amount print(f"Se ha hecho un retiro de tu cuenta {self.name} por un valor de {amount}, quedando un saldo de {self.balance}") else: print('Error interno, ---> No tienes suficiente saldo <---') def deactivate(self): self.is_activa = False print(f'{self.name}, tu cuenta ha sido desactivada') def activate(self): self.is_activa = True print(f'{self.name}, tu cuenta ha sido activada') # Crear transferencias entre cuentaas def transfer(self, amount, account): if self.is_activa: #Si la cuenta está activa if self.balance >= amount: self.balance -= amount account.balance += amount print(f'Que Nota, {self.name} te ha transferido ${amount} {account.name}, quedaste con {account.balance}!!') cuenta1 = BankAccount ('David', 10000) cuenta2 = BankAccount ('Paula', 200) cuenta3 = BankAccount ('Luisa', 50000) # Llamar a los métodos de la clase BankAccount cuenta1.deposit(5000) cuenta2.withdraw(10000) cuenta3.deactivate() cuenta3.deposit(10000) cuenta2.withdraw(20) cuenta1.deposit(1000) cuenta3.activate() cuenta3.deposit(10000) cuenta3.transfer(30000, cuenta1) ```

Las **funciones** que están dentro de una clase en Python, se les llama **métodos**. Un método es una función que está asociada a un objeto o instancia de una clase. Los métodos permiten que los objetos interactúen con sus propios atributos y con otros objetos. Existen tipos de métodos como: **Métodos de instancia**: Estos son los métodos más comunes. Se definen con la palabra clave `self` como su primer parámetro, que hace referencia a la instancia actual de la clase. **Métodos de clase (**`@classmethod`**)**: Estos métodos no están asociados a una instancia específica, sino a la clase en sí. El primer parámetro es `cls`, que representa la clase. **Métodos estáticos (**`@staticmethod`**)**: Son funciones que pertenecen a una clase, pero no interactúan con la clase ni con las instancias. No requieren el parámetro `self` ni `cls`.

Seria prudente tambien indicar que mensaje mostrar cuando tiene fondos insuficientes: `def withdrawl(self, amount):        if self.is_active:            if amount <= self.balance:                self.balance -= amount                print(f"Se ha retirado {amount} y el saldo actual es {self.balance}")            else:                print(f"No se pudo retirar los {amount}, tu saldo es insuficiente, tu saldo actual es de {self.balance}")`


Me gustó el ejercicio que hice, lo dejo por acá: ```python class BankAccount: def __init__(self, account_holder, balance): self.account_holder = account_holder self.balance = balance self.is_active = True def deposit(self, amount): if self.is_active: self.balance += amount print(f'Se ha depositado {amount}. El saldo actual es: {self.balance}') else: print('La cuenta no esta activia, no se puede depositar.') def withdraw(self, amount): if self.is_active: if amount <= self.balance: self.balance -= amount print(f'Se ha retirado {amount}. El saldo actual es: {self.balance}') else: print('Saldo insuficiente, no se puede retirar esa cantidad.') else: print('La cuenta no esta activa, no se puede retirar.') def deactivate(self): self.is_active = False print(f'La cuenta de {self.account_holder} ha sido desactivada') def activate(self): self.is_active = True print(f'La cuenta de {self.account_holder} ha sido activada') account1 = BankAccount('Ana', 500) account2 = BankAccount('Luis', 1200) # Llamando a los metodos account1.deposit(2000) account2.deposit(500) account1.deactivate() account1.withdraw(300) account1.activate() account1.withdraw(30000) #en python todo es una clase ```

Muchas gracias, qué clase tan clara. Luego de meses siento que di un gran salto en cuanto a entender POO

<https://github.com/JimcostDev/python_programming_fundamentals/tree/master/05_poo> ## Pilares de la Programación Orientada a Objetos La **POO** se basa en cuatro pilares fundamentales. Estos conceptos han evolucionado con el tiempo y se han adaptado a diferentes lenguajes de programación, pero las bases siguen siendo las mismas: * **Abstracción** * **Encapsulamiento** * **Herencia** * **Polimorfismo**

Apuntes y codigo. El ejercicio de la cuenta de banco viene en comentarios. ```python # POO - Programación Orientada a Objetos # Objeto: Instancia de una clase que contiene datos y comportamientos específicos. # Clase: Plantilla que define las propiedades (atributos) y comportamientos (métodos) de los objetos. # Atributo: Variable dentro de una clase que almacena información sobre el objeto. # Método: Función definida dentro de una clase que describe las acciones que un objeto puede realizar. # Constructor: Método especial en una clase (__init__) que se llama automáticamente al crear un nuevo objeto para inicializar sus atributos. # Parámetro: Variable en una función o método que recibe un valor al ser llamada para usar dentro de esa función o método. #Ejercicios POO class Person: # Definimos una nueva clase, una buena practica es utilizar mayuscalas al principio aqui def __init__(self,name,age): # Es una funcion particular que define el costructor, Self es para que se llame a el mismo self.name = name # Al nuevo objeto "Person" , le da el atributo de que tiene "name"(nombre) y aqui se lo asigna self.age = age # Lo mismo pero con "age" (edad) # El constructor ya asigno nuevos atributos al objeto o clase de los parametros "name" y "age" def greet(self): # Creamos / definimso una funcion para saludar #print(f"Hola,mi nombre es {self.name} y tengo {self.age}") print("Hola, mi nombre es", self.name, "y tengo", self.age) person1 = Person("Ana",33) person2 = Person("Luis",25) person1.greet() person2.greet() ```

```python class BankAccount: def __init__(self, account_holder, balance): self.account_holder = account_holder self.balance = balance self.is_active = True def deposit(self, amount): #Depositar if self.is_active: self.balance += amount print(f"Se a depositado {amount} en la cuenta de {self.account_holder}. \nSaldo actual es: {self.balance}") else: print(f"No se puede depositar, cuenta de {self.account_holder} está inactiva") def withdraw(self, amount): #Retirar if self.is_active: if amount <= self.balance: self.balance -= amount print (f"Se ha retirado {amount} de la cuenta de {self.account_holder}. \n Saldo actual es: {self.balance}") else: print(f"Saldo insuficiente para retirar, su saldo actual es {self.balance} bs.") else: print(f"La cuenta de {self.account_holder} esta desactivada \nNo se puede retirar") def desactive_account(self): self.is_active = False print("Cuenta desactivada") def active_account(self): self.is_active = True print("Cuenta Activada Correctamente") account1 = BankAccount("Ana", 500) account2 = BankAccount("Luis", 1000) #Llamada a los métodos account1.deposit(200) account2.deposit(100) account1.desactive_account() account1.deposit(50) account1.active_account() account1.deposit(50) account2.desactive_account() account2.withdraw(1800) ```class BankAccount:    def \_\_init\_\_(self, account\_holder, balance):        self.account\_holder = account\_holder        self.balance = balance        self.is\_active = True    def deposit(self, amount): #Depositar        if self.is\_active:            self.balance += amount            print(f"Se a depositado {amount} en la cuenta de {self.account\_holder}. \nSaldo actual es: {self.balance}")        else:            print(f"No se puede depositar, cuenta de {self.account\_holder} está inactiva")    def withdraw(self, amount): #Retirar        if self.is\_active:            if amount <= self.balance:                self.balance -= amount                print (f"Se ha retirado {amount} de la cuenta de {self.account\_holder}. \n Saldo actual es: {self.balance}")            else:                print(f"Saldo insuficiente para retirar, su saldo actual es {self.balance} bs.")        else:            print(f"La cuenta de {self.account\_holder} esta desactivada \nNo se puede retirar")            def desactive\_account(self):         self.is\_active = False        print("Cuenta desactivada")     def active\_account(self):        self.is\_active = True        print("Cuenta Activada Correctamente")account1 = BankAccount("Ana", 500)account2 = BankAccount("Luis", 1000) \#Llamada a los métodos account1.deposit(200)account2.deposit(100) account1.desactive\_account()account1.deposit(50) account1.active\_account()account1.deposit(50) account2.desactive\_account()account2.withdraw(1800)

Les presento mi ejemplo practico: ![]()

**Resumen:** **Programación Orientada a Objetos** Es un paradigma de la programación que nos dice que el software se debe organizar en objetos que son instancias de clases. Las clases son una plantilla genérica, como la clase Persona, esta clase aplicaría a cualquier ser humano ya que contendría, nombre, apellido, edad, estatura como atributos por ejemplo y métodos como caminar, sentarse, reír etc. Por otro lado los objetos son muestras particulares de la clase, es decir, una clase instanciada, esta puede contener adicional a los atributos y métodos de la clase, nuevos atributos y métodos propios. Los <u>métodos </u>son funciones propias de las clases y los <u>atributos</u>, de igual forma son variables propias de la clase La clase requiere de un concepto llamado <u>constructor</u> que sirve para inicializar el objeto, a este constructor se le pueden añadir parametros, se define como una función con la palabra reservada \_\_init\_\_ y como parametro principal debe incluirse la palabra reservada self que indica que esa función solo afectara al objeto que creamos lo que genera que sean independiente entre ellos. ```python #Sin parametros class Coche: def __init__(self): pass #Con parametros class Coche: def __init__(self, matricula, marca, velocidad_max, automatico): self.matricula = matricula self.marca = marca self.velocidad_max = velocidad_max self.automatico = automatico ```

```python #Ejercicios de Clase POO class Person: def __init__(self,name,age): self.name = name self.age = age def greet(self): print(f"Hola,mi nombre es {self.name} y tengo {self.age}") person1 = Person("Ana",33) person2 = Person("Luis",25) person1.greet() person2.greet() class BankAccount: def __init__(self,account_holder, balance): self.account_holder = account_holder self.balance = balance self.is_active = True def deposit(self,amount): if self.is_active: self.balance += amount print(f"Se ha depositado {amount}. Saldo actual: {self.balance}") else: print("No se puede depositar, Cuenta inactiva") def withdraw(self,amount): if self.is_active: if amount <= self.balance: self.balance -= amount print(f"Se ha retirado {amount}. Saldo actual: {self.balance}") else: print("No se puede depositar, Cuenta inactiva") def deactivate_account(self): self.is_active = False print(f"La cuenta ha sido desactivada.") def activate_account(self): self.is_active = True print(f"La cuenta ha sido activada.") account1 = BankAccount("Ana",500) account2 = BankAccount("Luis",1000) #Llamada a los métodos. account1.deposit(200) account2.deposit(100) account1.deactivate_account() account1.deposit(50) account1.activate_account() account1.deposit(50) ```class Person:    def \_\_init\_\_(self,name,age):        self.name = name        self.age = age     def greet(self):        print(f"Hola,mi nombre es {self.name} y tengo {self.age}") person1 = Person("Ana",33)person2 = Person("Luis",25) person1.greet()person2.greet() class BankAccount:    def \_\_init\_\_(self,account\_holder, balance):        self.account\_holder = account\_holder        self.balance = balance        self.is\_active = True     def deposit(self,amount):        if self.is\_active:            self.balance += amount            print(f"Se ha depositado {amount}. Saldo actual: {self.balance}")        else:            print("No se puede depositar, Cuenta inactiva")     def withdraw(self,amount):            if self.is\_active:                if amount <= self.balance:                    self.balance -= amount                    print(f"Se ha retirado {amount}. Saldo actual: {self.balance}")            else:                print("No se puede depositar, Cuenta inactiva")     def deactivate\_account(self):            self.is\_active = False            print(f"La cuenta ha sido desactivada.")     def activate\_account(self):            self.is\_active = True            print(f"La cuenta ha sido activada.") account1 = BankAccount("Ana",500)account2 = BankAccount("Luis",1000) \#Llamada a los métodos.account1.deposit(200)account2.deposit(100)account1.deactivate\_account()account1.deposit(50)account1.activate\_account()account1.deposit(50)


```python class BankAccount: def __init__(self,acount_holder, balance): self.account_holder=acount_holder self.balance=balance self.is_active=True def activate_account(self): if self.is_active: print(f"la cuenta a nombre de {self.account_holder} ya se encuentra activa") else: self.is_active=True def deactivate_account(self): if self.is_active!=True: print(f"la cuenta a nombre de {self.account_holder} se encuentra actualemte inactiva") else: self.is_active=False print("Cuenta inactiva, no podras realizar retiros ni depósitos") def deposit(self,amount): if self.is_active: self.balance+=amount print(f"Has agregado $ {amount} a tu cuenta, tu saldo actual es de $ {self.balance}") else: print("cuenta inactiva, no es posible depositar") def withdraw(self,amount): if amount>self.balance and self.is_active: print("La cantidad a retirar es mayor a tu saldo") if amount<self.balance and self.is_active: self.balance-=amount print(f"Retiraste $ {amount} de tu cuenta, tu saldo actual es de ${self.balance}") else: print("cuenta inactiva, no es posible depositar") def current_balance(self): if self.is_active: print(f"Hola {self.account_holder} tu saldo actual es de ${self.balance}") else: print("Lo sentimos, la cuenta está inactiva") Account_a=BankAccount("Pedro",500) Account_a.activate_account() Account_a.deposit(200) Account_a.withdraw(300) Account_a.deposit(200) Account_a.current_balance() Account_a.deactivate_account() Account_a.withdraw(300) Account_a.deposit(200) Account_a.current_balance() la cuenta a nombre de Pedro ya se encuentra activa Has agregado $ 200 a tu cuenta, tu saldo actual es de $ 700 Retiraste $ 300 de tu cuenta, tu saldo actual es de $400 Has agregado $ 200 a tu cuenta, tu saldo actual es de $ 600 Hola Pedro tu saldo actual es de $600 Cuenta inactiva, no podras realizar retiros ni depósitos cuenta inactiva, no es posible depositar cuenta inactiva, no es posible depositar Lo sentimos, la cuenta está inactiva ```