Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
14 Días
13 Hrs
31 Min
51 Seg
Fundamentos de Programación Orientada a Objetos en Python
23/63Recursos
La programación orientada a objetos (POO) es un paradigma de la programación que se basa en organizar el software en objetos, los cuales son instancias de clases. Las clases actúan como plantillas genéricas que definen atributos y comportamientos. Por ejemplo, una clase “Persona” puede tener atributos como nombre, apellido y fecha de nacimiento.
¿Cómo se crean clases y objetos en Python?
Para crear una clase en Python, se utiliza la palabra reservada class seguida del nombre de la clase con la primera letra en mayúscula. Dentro de la clase, se define un constructor con la función __init__. Esta función inicializa los atributos del objeto.
Ejemplo de creación de una clase y objeto
class Persona:
def __init__(self, nombre, edad):
self.nombre = nombre
self.edad = edad
def saludar(self):
print(f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años")
# Crear objetos de la clase Persona
persona1 = Persona("Ana", 30)
persona2 = Persona("Luis", 25)
persona1.saludar()
persona2.saludar()
¿Qué son los métodos en una clase?
Los métodos son funciones definidas dentro de una clase que operan sobre los objetos de la misma. En el ejemplo anterior, saludar es un método de la clase Persona.
¿Cómo manejar una cuenta bancaria con POO?
Un ejemplo práctico de POO es la gestión de una cuenta bancaria. Creamos una clase BankAccount con métodos para depositar y retirar dinero, así como para activar y desactivar la cuenta.
Ejemplo de clase BankAccount
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("Fondos insuficientes")
else:
print("No se puede retirar, cuenta inactiva")
def deactivate(self):
self.is_active = False
print("La cuenta ha sido desactivada")
def activate(self):
self.is_active = True
print("La cuenta ha sido activada")
# Crear objetos de la clase BankAccount
cuenta1 = BankAccount("Ana", 500)
cuenta2 = BankAccount("Luis", 1000)
cuenta1.deposit(500)
cuenta2.withdraw(100)
cuenta1.deactivate()
cuenta1.deposit(200)
cuenta1.activate()
cuenta1.deposit(200)
¿Cómo se crean y manejan objetos en Python?
La creación de objetos sigue una sintaxis similar a la de la creación de variables, pero usando el nombre de la clase seguido de los parámetros necesarios para el constructor.
Ejemplo de uso de la clase BankAccount
# Creación de cuentas
cuenta1 = BankAccount("Ana", 500)
cuenta2 = BankAccount("Luis", 1000)
# Realización de operaciones
cuenta1.deposit(500)
cuenta2.withdraw(100)
cuenta1.deactivate()
cuenta1.deposit(200) # No se puede depositar, cuenta inactiva
cuenta1.activate()
cuenta1.deposit(200) # Depósito exitoso
Aportes 39
Preguntas 3
Ordenar por:
# 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.
```
\#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" <<<<<<
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
```
`__init__` es el nombre del método. Este nombre es especial y está reservado para los constructores en Python
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.
El constructor es una funcion propia y especial de las clases
## **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!
por qué me sale este error ?
account1 = Bankaccount("Ana", 300)
TypeError: Bankaccount() takes no arguments
````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
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
```
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?