Programación Orientada a Objetos en Python: Clases y Métodos Básicos
Resumen
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
classPersona:def__init__(self, nombre, edad): self.nombre = nombre
self.edad = edad
defsaludar(self):print(f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años")# Crear objetos de la clase Personapersona1 = 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
classBankAccount:def__init__(self, account_holder, balance): self.account_holder = account_holder
self.balance = balance
self.is_active =Truedefdeposit(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")defwithdraw(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")defdeactivate(self): self.is_active =Falseprint("La cuenta ha sido desactivada")defactivate(self): self.is_active =Trueprint("La cuenta ha sido activada")# Crear objetos de la clase BankAccountcuenta1 = 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 cuentascuenta1 = BankAccount("Ana",500)cuenta2 = BankAccount("Luis",1000)# Realización de operacionescuenta1.deposit(500)cuenta2.withdraw(100)cuenta1.deactivate()cuenta1.deposit(200)# No se puede depositar, cuenta inactivacuenta1.activate()cuenta1.deposit(200)# Depósito exitoso
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
Clase: Es un molde o plantilla que define los atributos y métodos que tendrán los objetos.
Objeto: Es una instancia de una clase.
Atributo: Es una variable que pertenece a una clase o a un objeto.
Método: Es una función que pertenece a una clase o a un objeto.
Herencia: Es un mecanismo por el cual una clase puede heredar atributos y métodos de otra clase.
Encapsulamiento: Es el concepto de ocultar los detalles internos de un objeto y exponer sólo lo necesario.
Polimorfismo: Es la capacidad de diferentes clases de ser tratadas como instancias de la misma clase a través de una interfaz común.
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:
classRobot:def__init__(self, nombre, color, nivel_bateria): self.nombre = nombre
self.color = color
self.nivel_bateria = nivel_bateria
defcaminar(self):if self.nivel_bateria >10:print(f"{self.nombre} está caminando.") self.nivel_bateria -=10# Reduce la batería al caminarelse:print(f"{self.nombre} necesita recargar batería.")defhablar(self, mensaje):print(f"{self.nombre} dice: {mensaje}")defcargar_bateria(self): self.nivel_bateria =100print(f"{self.nombre} ha recargado su batería al 100%.")# Creamos dos robotsmi_robot = Robot("R2-D2","blanco",100)otro_robot = Robot("C-3PO","dorado",80)# Hacemos que los robots realicen accionesmi_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 vecesfor _ inrange(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.
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. ClaseBankAccount:
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 = Trueself se refiere a la cuenta que estás creando. Todo lo que pongas como self.algo pertenece a esa cuenta en particular.
3. Métododeposit:
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étodowithdraw:
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étodosdeactivate_accountyactivate_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.
Quisiera compartir un ejercicio que aplica la programación orientada a objetos.
# Enter your date automatic
classEnter_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.DateNclassstart: 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())ifEnter1==1: self.var1=input("Enter your name: ") self.var2=input("Enter your age: ")return self.var1, self.var2else:print("Coming out")income =int(input("Please income how much data going to Enter "))all_data =[]user1 =Nonefor i inrange(income): person1 =start() person1.conversation() user1 =Enter_Date(person1.var1, person1.var2) all_data.append(user1.list_date())print(all_data)classRol_family: def __init__(self, data): self.data= data
self.occupation=[] def enter_date(self, index): adjusted_index = index -1if 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 inrange(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 =0while one <len(all_data): start_family.result_date(one) one +=1
Comparto un ejemplo basico de como crear sus excepciones a nivel de clase, espero le sea de utilidad
classErrors(Exception): def __init__(self,code,message): self.code=code
self.message=message
nombre=input("Ingrese su nombre: ")edad=int(input("ingrese su edad: "))try:if edad<18: raise Errors(9000,"La edad permitida tiene que se mayor a 18")except Errorsase:print(e)
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.
Hola! te recomiendo seguir los ejercicios para entender la diferencia entre clase y objeto, traté de explicar de manera conceptual lo mejor posible, pero siento que en tu caso será mejor que sigas el paso a paso, en todo caso si necesitas mas ayuda, podemos agendar una llamada :)
Una clase es como la especificación o el plano de una casa, indicando cuánto espacio va a ocupar (Codigo).
Un objeto es la casa construida por una Constructora(Sistema Operativo) y ubicada en un sitio específico(Memoria RAM) una calle, ya con dirección(Puntero) donde puedes ir, usar y vivir en ella meter tus cosas(Datos) en cada una de sus habitaciones(Variables).
De un plano de apartamento(Clase) puedes tener un conjunto 200 apartamentos construidos(Objetos) por ende es decir 200 objetos basados en 1 sola clase.
He estado en esa misma situación de Python y C y con gusto te ayudo yo aprendi C y te cuento.
Python es un lenguaje de alto nivel; en otras palabras, es un frontend más amigable y atractivo que te oculta su backend que es C/C++.
Su objetivo y ventaja principal es que no tengas que aprender ni interactuar con código en C para usar programas escritos en C a cambio de perdida de un poco de rendimiento.
En mi opinión personal, no necesitas aprender C para entender Python a fondo.
C deja ver en crudo conceptos de Ciencias de la Computación pero esos mismos los puedes aprender sin C como el como funciona la memoria RAM, Stack, Heap, Paginacion el Kernel etc etc..
Paciencia, mi querido. Primero caminas = alto nivel (Python, JavaScript) y van a quedar cosas que aun no casan del todo y esta ok.
Segundo Ciencias de computacion.
Y Tercero ya corres = Nivel sistema (Rust, C, C++, Java) aplicando Ciencias de la Computación, Software Engineering, Data Egineering etc etc soy hasta ese punto recomiendo C o similares.
Tratare de ayudarte espero me explique.
La Programación Orientada a Objetos (POO) organiza el código en objetos y clases. Los objetos representan cosas del mundo real con atributos (características) y métodos (acciones). Las clases son plantillas que definen los atributos y métodos que tendrán los objetos.
Ejemplo con una Silla
En el Mundo Real:
Silla: Un objeto real tiene características como color, material, y altura, y puede realizar acciones como moverse o ajustarse.
En Programación:
Clase (Silla): Es la plantilla que define qué atributos y métodos tendrán las sillas.
Atributos (color,material,altura): Características de cada silla.
Métodos (mover(),ajustar()): Acciones que cada silla puede realizar.
Objeto (mi_silla): Una instancia específica de la clase Silla con valores concretos para los atributos(color,material,altura) y la capacidad de realizar los métodos definidos (mover(),ajustar().
Hola Adriana, haciendo unas pruebas, puedo concluir que self es una palabra reservada OBLIGATORIA tanto en el caso que declares el constructor como en el caso que declares un método / función.
En el ejemplo siguiente, puedes ver que declaré el constructor adecuadamente, pero en el caso del método no puse "self" y me lanzó error.
No he investigado mucho la POO en Python, pero sí lo sé en JAVA y C#.
Creo que el "self" actúa como una suerte de this en C#.
No es obligatorio declarar el constructor, pero si lo declaras, te obliga a incluir el self y sus parámetros para luego inicializar.
classBank_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=Trueprint('La cuenta se activó correctamente') def deactivate(self):if not self.is_active:print('La cuenta está inactiva actualmente')else: self.is_active=Trueprint('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()
classBankAccount:def__init__(self, account_holder, balance): self.account_holder = account_holder
self.balance = balance
self.is_active =Truedefdeposit(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")defwithdraw(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")defactive_account(self): self.is_active =Trueprint("Su cuenta ha sido activada")defdeactive_account(self): self.is_active =Falseprint("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)```classBankAccount:def \_\_init\_\_(self, account\_holder, balance): self.account\_holder = account\_holder self.balance = balance self.is\_active =Truedefdeposit(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")defwithdraw(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 =Trueprint("Su cuenta ha sido activada")def deactive\_account(self): self.is\_active =Falseprint("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)
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
Implementé un método para transferir dinero de una cuenta a otra. este método recibe como uno de los parámetros parámetro la cuenta destino, que justamente en el objeto account2. Estro permite transferir reutilizando los métodos anteriormente creados .retirar() y .depositar():
classBankAccount:def__init__(self, account_holder, balance,id): self.account_holder = account_holder
self.balance = balance
self.is_active =True self.id=iddefdeposito(self, amount):if self.is_active: self.balance += amount
print(f"Se ha realizado un deposito de ${amount}. Su nuevo saldo es ${self.balance}.")else:print("No fue posible realizar un deposito debido a que su cuenta esta INACTIVA")defretirar(self, amount):if self.is_active:if amount <= self.balance: self.balance -= amount
print(f"Se ha retirado ${amount} de su cuenta. Su saldo actual es ${self.balance}.")else:print("No es posible retirar esa cantidad, ya que supera sus fondos actuales")else:print("No es posible retirar de su cuenta debido a que se encuentra INACTIVA")defdesactivar(self): self.is_active =Falseprint("Su cuenta fue desactivada!")defactivar(self): self.is_active =Trueprint("Su cuenta fue activa activada")defbalance_actual(self):print(f"Hola, {self.account_holder}, Su saldo actual es de ${self.balance}.")deftransferir(self, amount, cuenta_destino):if self.is_active and cuenta_destino.is_active:if amount <= self.balance: self.retirar(amount) cuenta_destino.deposito(amount)print(f"Se ha transferido ${amount} desde la cuenta de {self.account_holder} a la cuenta de {cuenta_destino.account_holder}!")else:print("Alguna de las cuenta se encuentra Inactiva")