Fundamentos de Programación y Python

1

¿Por qué aprender Python?

2

Introducción a Python

3

Conceptos Básicos de Programación

4

Práctica: Te doy la bienvenida a los ejercicios interactivos

5

Manipulación de Cadenas de Texto en Python

6

Enteros, Flotantes y Booleanos

7

Todo lo que Debes Saber sobre print en Python

8

Operaciones Matemáticas en Python

9

Operaciones de Entrada/Salida en Consola

Colección y Procesamiento de Datos en Python

10

Listas

11

Método slice

12

Listas de más dimensiones y Tuplas

13

Aplicación de Matrices

14

Diccionarios

15

Comprehension Lists en Python (CLASE NUEVA)

Control de Flujo en Python

16

Estructuras condicionales

17

Bucles y Control de Iteraciones

18

Generadores e Iteradores

Funciones y Manejo de Excepciones en Python

19

Uso de Funciones en Python

20

Funciones Lambda y Programación Funcional en Python

21

¿Cómo realizar una función recursiva en Python?

22

Manejo de Excepciones y Uso de Pass (CLASE NUEVA)

Programación Orientada a Objetos en Python

23

Fundamentos de Programación Orientada a Objetos en Python

24

Ejercicio Biblioteca con POO

25

Herencia en POO con Python

26

Objetos heredados

27

Los 4 pilares de la programacion orientada a objetos

28

Uso de super() en Python (CLASE NUEVA)

29

Superando los Fundamentos de Programación Orientada a Objetos en Python

Lectura y escritura de archivos

30

Manejo de Archivos .TXT (CLASE NUEVA)

31

Manejo de Archivos CSV (CLASE NUEVA)

32

Manejo de Archivos JSON (CLASE NUEVA)

Biblioteca estándar de Python

33

Biblioteca estándar en Python (CLASE NUEVA)

34

Librería Os, Math y Random (CLASE NUEVA)

35

Librería Statistics y Análisis Estadístico (CLASE NUEVA)

36

Proyecto final: Guerra naval

Conceptos avanzados de Python

37

Recapitulación de lo aprendido hasta ahora

38

Escribir código Pythonico y profesional

39

Comentarios y Docstrings en Python

40

Scope y closures: variables locales y globales

41

Anotaciones de tipo

42

Validación de tipos en métodos

43

Librería Collections y Enumeraciones

Decoradores

44

Decoradores en Python

45

Decoradores anidados y con parámetros

46

Uso de Decoradores en clases y métodos

Métodos y estructura de clases en Python

47

Métodos mágicos

48

Sobrecarga de operadores

49

Implementación de `if __name__ == "__main__":`

50

Metaprogramación en Python

51

Uso de *args y **kwargs

52

Métodos privados y protegidos

53

Gestión avanzada de propiedades

54

Métodos estáticos y de clase avanzados

Programación concurrente y asíncrona

55

Introducción a la concurrencia y paralelismo

56

Threading y multiprocessing en Python

57

Asincronismo con asyncio

58

Asincronismo y concurrencia

Creación de módulos y paquetes

59

Creación de módulos en Python

60

Gestión de paquetes

61

Publicación de paquetes en PyPI

Proyecto final

62

Implementación de un sistema completo

63

Implementación de un Sistema Completo

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Python

Curso de Python

Carli Code

Carli Code

Métodos privados y protegidos

52/63
Recursos

Aportes 24

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

```js class BankAccount(): def __init__(self, name, balance, account): self.name = name self.balance = balance self.__account = account self.__transactions = [] def __update_balance(self, amount, operation): if operation == 'increment': self.balance += amount elif operation == 'decrement': self.balance -= amount print(f'The actual balance is: {self.balance}') def _register_transaction(self, amount, account, type_transfer): if type_transfer == 'in': self.__update_balance(amount, operation="increment") self.__transactions.append({ "amount": amount, "account": account, "type_transfer": type_transfer }) elif type_transfer == 'out': self.__update_balance(amount, operation="decrement") self.__transactions.append({ "amount": amount, "account": account, "type_transfer": type_transfer }) def _get_account_number(self): print(f'Your number account is: {self.__account}') def _show_transactions(self): for transaction in self.__transactions: print(f'{transaction}\n') thomas_account = BankAccount("Thomas", 1500000000, 4333567867564) david_account = BankAccount("David", 500000000, 4324567564) thomas_account._get_account_number() thomas_account._register_transaction(1500000, 243546573454, 'out') thomas_account._register_transaction(23000000, 243546573454, 'in') thomas_account._register_transaction(1500000, 243546573454, 'out') thomas_account._show_transactions() ```class BankAccount():     def \_\_init\_\_(self, name, balance, account):         self.name = name        self.balance = balance        self.\_\_account = account        self.\_\_transactions = \[]     def \_\_update\_balance(self, amount, operation):         if operation == 'increment':             self.balance += amount                elif operation == 'decrement':             self.balance -= amount         print(f'The actual balance is: {self.balance}')     def \_register\_transaction(self, amount, account, type\_transfer):         if type\_transfer == 'in':             self.\_\_update\_balance(amount, operation="increment")            self.\_\_transactions.append({                "amount": amount,                "account": account,                "type\_transfer": type\_transfer            })                elif type\_transfer == 'out':             self.\_\_update\_balance(amount, operation="decrement")            self.\_\_transactions.append({                "amount": amount,                "account": account,                "type\_transfer": type\_transfer            })     def \_get\_account\_number(self):         print(f'Your number account is: {self.\_\_account}')     def \_show\_transactions(self):         for transaction in self.\_\_transactions:             print(f'{transaction}\n') thomas\_account = BankAccount("Thomas", 1500000000, 4333567867564)david\_account = BankAccount("David", 500000000, 4324567564) thomas\_account.\_get\_account\_number()thomas\_account.\_register\_transaction(1500000, 243546573454, 'out')thomas\_account.\_register\_transaction(23000000, 243546573454, 'in')thomas\_account.\_register\_transaction(1500000, 243546573454, 'out')thomas\_account.\_show\_transactions()
```js print("") print("* Ejercicio 1:") print("- Métodos y variables privadas y protegidas.") print("") class BaseClass: """ Clase base para demostrar el encapsulamiento con métodos y variables privadas y protegidas. En Python, el encapsulamiento se implementa mediante convenciones de nomenclatura: - Los miembros protegidos comienzan con un guion bajo (_). - Los miembros privados comienzan con dos guiones bajos (__). """ def __init__(self): """ Constructor de la clase BaseClass. Inicializa una variable protegida y una variable privada. """ self._protected_variable = 'Esta es una variable protegida' self.__private_variable = 'Esta es una variable privada' def _protected_method(self): """ Método protegido. Los métodos protegidos están destinados a ser accedidos por la clase misma y sus subclases, pero no desde fuera de la clase. """ print("Este es un método protegido") def __private_method(self): """ Método privado. Los métodos privados solo deben ser accedidos desde dentro de la clase. """ print("Esto es un método privado") def show_variable_private(self): """ Método para acceder a la variable privada. Aunque no se recomienda acceder a miembros privados directamente, este método muestra cómo se puede hacer en caso de necesidad. """ return self.__private_variable def show_method_private(self): """ Método para llamar al método privado. Similar al método anterior, este método muestra cómo se puede llamar a un método privado desde dentro de la clase. """ return self.__private_method() base = BaseClass() # Acceder a la variable protegida (se puede hacer desde fuera de la clase, pero no se recomienda) print(f"Imprimiendo variable protegida: {base._protected_variable}") # Llamar al método protegido (se puede hacer desde fuera de la clase, pero no se recomienda) base._protected_method() # Intentar acceder al método privado directamente (causará un AttributeError) # base.__private_method() # Acceder a la variable privada a través de un método público print(base.show_variable_private()) # Salida: Esta es una variable privada # Llamar al método privado a través de un método público base.show_method_private() # Salida: Esto es un método privado print("") print("* Ejercicio 2:") print("- Ejemplo de clase CuentaBanco con encapsulamiento.") print("") class CuentaBanco: """ Clase CuentaBanco con encapsulamiento para proteger el saldo de la cuenta. Utiliza un atributo privado para el saldo y métodos protegidos para modificar y registrar las transacciones. """ def __init__(self): """ Constructor de la clase CuentaBanco. Inicializa el saldo de la cuenta a 0. """ self.__saldo_cuenta = 0 def _agregar_saldo(self, saldo): """ Método protegido para agregar saldo a la cuenta. Args: saldo: La cantidad de saldo a agregar. """ self.__saldo_cuenta += saldo self.__registrar_transaccion("Agregar saldo") print(f"El nuevo saldo de la cuenta es: {self.__saldo_cuenta}") def __registrar_transaccion(self, tipo_transaccion): """ Método privado para registrar una transacción. Args: tipo_transaccion: El tipo de transacción que se va a registrar. """ print(f"Registrando transacción de tipo: {tipo_transaccion}") # Crear dos instancias de CuentaBanco cuenta_uno = CuentaBanco() cuenta_dos = CuentaBanco() # Agregar saldo a las cuentas cuenta_uno._agregar_saldo(10) # Salida: # Registrando transacción de tipo: Agregar saldo # El nuevo saldo de la cuenta es: 10 cuenta_dos._agregar_saldo(100) # Salida: # Registrando transacción de tipo: Agregar saldo # El nuevo saldo de la cuenta es: 100 cuenta_uno._agregar_saldo(10) # Salida: # Registrando transacción de tipo: Agregar saldo # El nuevo saldo de la cuenta es: 20 cuenta_dos._agregar_saldo(100) # Salida: # Registrando transacción de tipo: Agregar saldo # El nuevo saldo de la cuenta es: 200 ```print("")print("\* Ejercicio 1:")print("- Métodos y variables privadas y protegidas.")print("") class BaseClass:    """    Clase base para demostrar el encapsulamiento con métodos y variables privadas y protegidas.     En Python, el encapsulamiento se implementa mediante convenciones de nomenclatura:    - Los miembros protegidos comienzan con un guion bajo (\_).    - Los miembros privados comienzan con dos guiones bajos (\_\_).    """    def \_\_init\_\_(self):        """        Constructor de la clase BaseClass.         Inicializa una variable protegida y una variable privada.        """        self.\_protected\_variable = 'Esta es una variable protegida'        self.\_\_private\_variable = 'Esta es una variable privada'     def \_protected\_method(self):        """        Método protegido.         Los métodos protegidos están destinados a ser accedidos por la clase misma y sus subclases,        pero no desde fuera de la clase.        """        print("Este es un método protegido")     def \_\_private\_method(self):        """        Método privado.         Los métodos privados solo deben ser accedidos desde dentro de la clase.        """        print("Esto es un método privado")     def show\_variable\_private(self):        """        Método para acceder a la variable privada.         Aunque no se recomienda acceder a miembros privados directamente, este método muestra        cómo se puede hacer en caso de necesidad.        """        return self.\_\_private\_variable     def show\_method\_private(self):        """        Método para llamar al método privado.         Similar al método anterior, este método muestra cómo se puede llamar a un método privado        desde dentro de la clase.        """        return self.\_\_private\_method() base = BaseClass() *# Acceder a la variable protegida (se puede hacer desde fuera de la clase, pero no se recomienda)*print(f"Imprimiendo variable protegida: {base.\_protected\_variable}") *# Llamar al método protegido (se puede hacer desde fuera de la clase, pero no se recomienda)*base.\_protected\_method() *# Intentar acceder al método privado directamente (causará un AttributeError)# base.\_\_private\_method()* *# Acceder a la variable privada a través de un método público*print(base.show\_variable\_private())  *# Salida: Esta es una variable privada* *# Llamar al método privado a través de un método público*base.show\_method\_private()  *# Salida: Esto es un método privado* print("")print("\* Ejercicio 2:")print("- Ejemplo de clase CuentaBanco con encapsulamiento.")print("") class CuentaBanco:    """    Clase CuentaBanco con encapsulamiento para proteger el saldo de la cuenta.     Utiliza un atributo privado para el saldo y métodos protegidos para modificar    y registrar las transacciones.    """    def \_\_init\_\_(self):        """        Constructor de la clase CuentaBanco.         Inicializa el saldo de la cuenta a 0.        """        self.\_\_saldo\_cuenta = 0     def \_agregar\_saldo(self, saldo):        """        Método protegido para agregar saldo a la cuenta.         Args:            saldo: La cantidad de saldo a agregar.        """        self.\_\_saldo\_cuenta += saldo        self.\_\_registrar\_transaccion("Agregar saldo")        print(f"El nuevo saldo de la cuenta es: {self.\_\_saldo\_cuenta}")     def \_\_registrar\_transaccion(self, tipo\_transaccion):        """        Método privado para registrar una transacción.         Args:            tipo\_transaccion: El tipo de transacción que se va a registrar.        """        print(f"Registrando transacción de tipo: {tipo\_transaccion}") *# Crear dos instancias de CuentaBanco*cuenta\_uno = CuentaBanco()cuenta\_dos = CuentaBanco() *# Agregar saldo a las cuentas*cuenta\_uno.\_agregar\_saldo(10)*# Salida:# Registrando transacción de tipo: Agregar saldo# El nuevo saldo de la cuenta es: 10* cuenta\_dos.\_agregar\_saldo(100)*# Salida:# Registrando transacción de tipo: Agregar saldo# El nuevo saldo de la cuenta es: 100* cuenta\_uno.\_agregar\_saldo(10)*# Salida:# Registrando transacción de tipo: Agregar saldo# El nuevo saldo de la cuenta es: 20* cuenta\_dos.\_agregar\_saldo(100)*# Salida:# Registrando transacción de tipo: Agregar saldo# El nuevo saldo de la cuenta es: 200*
```js class CuentaBancaria: def __init__(self, id, contraseña): self.id = id self.contraseña = contraseña self.saldo = 0 #Verificamos que el usuarioId y contraseña existan def verificar_usuario(self): for us in users: if self.id == us.get('id'): if self.contraseña == us.get('contraseña'): return True return False def verificar_saldo(self): for us in users: if self.id == us.get('id'): return print(f"Saldo disponible: {us.get('saldo')}") def _actualizar_saldo(self, sld): for us in users: if self.id == us.get('id'): old = us.get('saldo') #Actualizamos el valor de saldo en el diccionario us.update({'saldo' : sld}) #Agregamos la información de la transacción a una lista movements.append({'transaccion client id' : self.id, 'saldo' : f'from {old} to {sld}'}) return print(f"El nuevo saldo es {sld}") def __registrar_transaccion(): print(movements) def public_transaction(self): self.__registrar_transaccion() users = [ {'id' : 1, 'contraseña' : '12345', 'saldo' : 500}, {'id' : 2, 'contraseña' : '34567', 'saldo' : 600} ] movements = [] u1 = CuentaBancaria(1, '12345') if __name__ == '__main__': while True: print("Bienvenido a banco platzi") print("Escoga la acción que desea realizar") print("1. Verificar saldo") print("2. Actualizar saldo") print("3. Consultar actualizaciones de saldos") print("4. Salir") userInput = input("Ingrese su opción: ") match userInput: case "1": u1.verificar_usuario() if u1.verificar_usuario(): print("Acceso autorizado") print("Verificando saldo...") u1.verificar_saldo() input() else: print("Usuario y/o contraseña incorrectos") input() case "2": sld = int(input("Ingrese el saldo nuevo: ")) u1._actualizar_saldo(sld) #print(u1._actualizar_saldo(sld)) print(users) input() case "3": print(movements) input() case "4": print("Saliendo") break case _: print("Opçion invalida") ```
La respuesta al reto: """Crea una clase llamada "CuentaBancaria con un método protegidopara actualizar el saldo y un método privado para registrar las transacciones internamente.El método protegido (\_actualizar\_saldo) solo debe ser utilizado dentrode la clase y subclases.El método privado (\_\_registrar\_transaccion) debe ser completamente interno y no accesible fuera de la clase""" class CuentaBancaria: def \_\_init\_\_(self, titular: str, saldo: float =0.0): #Inicializa la cuenta bancaria con un titular y un saldo inicial. self.titular = titular self.\_saldo = saldo # El guion bajo (\_) indica que es un atributo protegido def \_actualizar\_saldo (self, cantidad: float): #Método protegido que actualiza el sueldo self.\_saldo += cantidad self.\_\_registrar\_transaccion(cantidad) #Llamamos al método privado def \_\_registrar\_transaccion (self, cantidad: float): #Método privado que registra las transacciones (simulado con un print). print(f"Transacción registrada: {cantidad}€. Nuevo saldo {self.\_saldo}€") def depositar (self, cantidad: float): #Método público para depositar dinero en la cuenta if cantidad >0: self.\_actualizar\_saldo(cantidad) else: print("No de puede depositar una cantidad negativa o 0") def retirar(self, cantidad: float): #Método público para retirar dinero de la cuenta if 0 < cantidad <= self.\_saldo: self.\_actualizar\_saldo(-cantidad) else: print("Fondos insuficientes o cantidad inválida") def mostrar\_saldo(self): #Método público que muestra el saldo actual de la cuenta print(f"El saldo actual de la cuenta de {self.titular} es: {self.\_saldo}€") cuenta = CuentaBancaria ("Marta", 10000)cuenta.mostrar\_saldo()cuenta.depositar(500)cuenta.retirar(300)cuenta.mostrar\_saldo() ```python """Crea una clase llamada "CuentaBancaria con un método protegido para actualizar el saldo y un método privado para registrar las transacciones internamente. El método protegido (_actualizar_saldo) solo debe ser utilizado dentro de la clase y subclases. El método privado (__registrar_transaccion) debe ser completamente interno y no accesible fuera de la clase""" class CuentaBancaria: def __init__(self, titular: str, saldo: float =0.0): #Inicializa la cuenta bancaria con un titular y un saldo inicial. self.titular = titular self._saldo = saldo # El guion bajo (_) indica que es un atributo protegido def _actualizar_saldo (self, cantidad: float): #Método protegido que actualiza el sueldo self._saldo += cantidad self.__registrar_transaccion(cantidad) #Llamamos al método privado def __registrar_transaccion (self, cantidad: float): #Método privado que registra las transacciones (simulado con un print). print(f"Transacción registrada: {cantidad}€. Nuevo saldo {self._saldo}€") def depositar (self, cantidad: float): #Método público para depositar dinero en la cuenta if cantidad >0: self._actualizar_saldo(cantidad) else: print("No de puede depositar una cantidad negativa o 0") def retirar(self, cantidad: float): #Método público para retirar dinero de la cuenta if 0 < cantidad <= self._saldo: self._actualizar_saldo(-cantidad) else: print("Fondos insuficientes o cantidad inválida") def mostrar_saldo(self): #Método público que muestra el saldo actual de la cuenta print(f"El saldo actual de la cuenta de {self.titular} es: {self._saldo}€") cuenta = CuentaBancaria ("Marta", 10000) cuenta.mostrar_saldo() cuenta.depositar(500) cuenta.retirar(300) cuenta.mostrar_saldo() ```
En Python, los métodos privados y protegidos son convenciones utilizadas para controlar el acceso a los atributos y métodos de una clase. Aunque Python no implementa un verdadero encapsulamiento como otros lenguajes (por ejemplo, Java o C++), proporciona ciertas convenciones que ayudan a gestionar la accesibilidad. Aquí tienes un desglose de ambos conceptos: \### Métodos Privados \- \*\*Definición\*\*: Los métodos privados son aquellos que no deben ser accesibles desde fuera de la clase. Se utilizan para encapsular la lógica que no debería ser expuesta. \- \*\*Convención\*\*: Se definen precediendo el nombre del método con dos guiones bajos (`\_\_`). Esto provoca que el método sea "name-mangled", es decir, el nombre del método se transforma internamente para incluir el nombre de la clase. \#### Ejemplo de Métodos Privados ```python class MiClase: def \_\_init\_\_(self): self.\_\_atributo\_privado = "Soy privado" def \_\_metodo\_privado(self): return "Este es un método privado" def metodo\_publico(self): return self.\_\_metodo\_privado() objeto = MiClase() print(objeto.metodo\_publico()) # Salida: Este es un método privado \# Intentar acceder al método privado directamente resultará en un error \# print(objeto.\_\_metodo\_privado()) # Esto generará un AttributeError ``` \### Métodos Protegidos \- \*\*Definición\*\*: Los métodos protegidos son aquellos que están destinados a ser utilizados solo dentro de la clase y sus subclases. Se pueden acceder desde fuera de la clase, pero se considera una mala práctica hacerlo. \- \*\*Convención\*\*: Se definen precediendo el nombre del método con un solo guion bajo (`\_`). \#### Ejemplo de Métodos Protegidos ```python class MiClase: def \_\_init\_\_(self): self.\_atributo\_protegido = "Soy protegido" def \_metodo\_protegido(self): return "Este es un método protegido" class SubClase(MiClase): def mostrar(self): return self.\_metodo\_protegido() objeto = SubClase() print(objeto.mostrar()) # Salida: Este es un método protegido \# Acceder directamente al método protegido es posible, pero no recomendado print(objeto.\_metodo\_protegido()) # Salida: Este es un método protegido ``` \### Resumen \- \*\*Métodos Privados\*\*: \- Se definen con `\_\_` (doble guion bajo). \- No son accesibles desde fuera de la clase. \- Se utilizan para ocultar la implementación. \- \*\*Métodos Protegidos\*\*: \- Se definen con `\_` (un solo guion bajo). \- Se pueden acceder desde fuera de la clase, pero se desaconseja. \- Se utilizan para indicar que un método no está destinado a ser usado públicamente. Estas convenciones son importantes para mantener un diseño claro y seguro en tus clases, permitiendo que los desarrolladores comprendan mejor las intenciones detrás del acceso a ciertos métodos y atributos.
**Método Público:** Se pueden acceder dentro y fuera de las clases **Método Protegido:** Es una convención para programadores. Indica que el método solo debería usarse dentro y fuera de la clase. (Aunque se puede acceder al método desde fuera de la clase. Esto no se recomienda) - Realmente no está protegido, solo es una nomenclatura. **Método Privado:** Este solo deja acceder dentro de las clases y subclases. (Es inaccesible por fuera de la clase)
Lo hice de este modo: ```python class CuentaBancaria: def __init__(self,nombre_titular): self.nombre_titular = nombre_titular self._saldo = 0 def _actualizar_saldo(self, cambio_saldo: float) -> float: self._saldo += cambio_saldo print(f'El saldo atual de {self.nombre_titular} es {self._saldo}') def __registro_transacciones(self, destino, monto: float): with open(f'transacciones_{self.nombre_titular}.txt','a+') as file: mensaje = (f'El usuario {self.nombre_titular} ha consigado ${monto}, a la cuenta de {destino.nombre_titular}') print(mensaje) file.write(mensaje) with open(f'transacciones_{destino.nombre_titular}.txt','a+') as file2: file2.write(mensaje) def transaccion(self,destino, monto:float): self._saldo -= monto destino._saldo += monto self.__registro_transacciones(destino, monto) cuenta_manuel = CuentaBancaria('Manuel') cuenta_manuel._actualizar_saldo(100) print(f'El saldo en {cuenta_manuel.nombre_titular} es de ${cuenta_manuel._saldo})') cuenta_jorge = CuentaBancaria('Jorge') cuenta_jorge._actualizar_saldo(200) print(f'El saldo en {cuenta_jorge.nombre_titular} es de ${cuenta_jorge._saldo})') #usando el método transacción para acceder al método privado: cuenta_manuel.transaccion(cuenta_jorge, 50) print("*******") print(f'El saldo en {cuenta_manuel.nombre_titular} es de ${cuenta_manuel._saldo})') print(f'El saldo en {cuenta_jorge.nombre_titular} es de ${cuenta_jorge._saldo})') ```class CuentaBancaria:    def \_\_init\_\_(self,nombre\_titular):        self.nombre\_titular = nombre\_titular        self.\_saldo = 0            def \_actualizar\_saldo(self, cambio\_saldo: float) -> float:        self.\_saldo += cambio\_saldo        print(f'El saldo atual de {self.nombre\_titular} es {self.\_saldo}')            def \_\_registro\_transacciones(self, destino, monto: float):        with open(f'transacciones\_{self.nombre\_titular}.txt','a+') as file:            mensaje = (f'El usuario {self.nombre\_titular} ha consigado ${monto}, a la cuenta de {destino.nombre\_titular}')            print(mensaje)            file.write(mensaje)        with open(f'transacciones\_{destino.nombre\_titular}.txt','a+') as file2:            file2.write(mensaje)        def transaccion(self,destino, monto:float):        self.\_saldo -= monto        destino.\_saldo += monto        self.\_\_registro\_transacciones(destino, monto)        cuenta\_manuel = CuentaBancaria('Manuel')cuenta\_manuel.\_actualizar\_saldo(100)print(f'El saldo en {cuenta\_manuel.nombre\_titular} es de ${cuenta\_manuel.\_saldo})')cuenta\_jorge = CuentaBancaria('Jorge')cuenta\_jorge.\_actualizar\_saldo(200)print(f'El saldo en {cuenta\_jorge.nombre\_titular} es de ${cuenta\_jorge.\_saldo})')#usando el método transacción para acceder al método privado:cuenta\_manuel.transaccion(cuenta\_jorge, 50)print("\*\*\*\*\*\*\*")print(f'El saldo en {cuenta\_manuel.nombre\_titular} es de ${cuenta\_manuel.\_saldo})')print(f'El saldo en {cuenta\_jorge.nombre\_titular} es de ${cuenta\_jorge.\_saldo})')
les comparto mi código:```python from datetime import datetime class BankAccount: def __init__(self, name: str,balance:float): self.name = name self.balance = balance self.is_active=True self.history = [] def _actualizar_saldo_(self,amount : float): if self.is_active: self.balance += amount self.__registrar_transaction(amount) print (f"se ha demositado {amount}. Saldo actual {self.balance}") else: print(f"No se puede depostar, Cuenta inactiva") def __registrar_transaction(self,amount: float): current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") self.history.append (f"Time: {current_time}, Name: {self.name}, Transaction: +{amount}, Balance: {self.balance}") def show_history(self): print("Historial de transacciones:") for event in self.history: print(event) account_1 = BankAccount("Fer",500) account_1._actualizar_saldo_(500) account_1.show_history() account_1._actualizar_saldo_(100) account_1.show_history() ```
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202025-01-04%20005612-2a2b294e-a1fc-46c7-a9a8-e07efe20c568.jpg)
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202025-01-04%20005559-f71f436b-abeb-4a4d-9db7-4678694a58e1.jpg)
Queda clara la diferencia.
```js class Cuentabancaria: def __init__(self,saldo): self._saldo=saldo def _ver_saldo(self): print(f'El saldo es {self._saldo}') def __transaccion(self,monto): self._saldo+=monto print(f'saldo actual {self._saldo}') persona1=Cuentabancaria(1000) persona1._ver_saldo() ```
```js class CuentaBancaria: def __init__(self, saldo_inicial): self.saldo_actual = saldo_inicial self.__registro_saldos = [saldo_inicial] def _actualizar_saldo(self, nuevo_saldo): self.saldo_actual = nuevo_saldo self.__registar_transacción(self.saldo_actual) def __registar_transacción(self, saldo_registrado): self.__registro_saldos.append(saldo_registrado) def deposit(self, quantity): self._actualizar_saldo(self.saldo_actual + quantity) def withdraw(self, quantity): if( quantity < self.saldo_actual): self._actualizar_saldo(self.saldo_actual - quantity) else: print("No se puede realizar operción.") def show_info(self): for registro in self.__registro_saldos: print(registro) cuentaPersonal = CuentaBancaria(1000) cuentaPersonal.deposit(5000) cuentaPersonal.withdraw(3000) cuentaPersonal.withdraw(1000) cuentaPersonal.withdraw(3000) cuentaPersonal.deposit(1000) cuentaPersonal.show_info() ```
```python import datetime class Bank_Account: def __init__(self, account_number, balance): self.account_number = account_number self.__balance = balance self.__transactions = [] #antes de crear el metodo de reiro o deposito hay que crear un metodo #para tener un seguimiento de los movimientos (PRIVADO) def __register_transactions(self, action, amount): transaction = { "action": action, "amount": amount, "date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") } self.__transactions.append(transaction) #Metodo para actualizar balance (PROTEGIDO) def _update_balance(self, amount): self.__balance += amount #metodos PUBLICOs def deposit(self, amount): if amount <= 0: raise ValueError("La cantidad tiene que ser mayor a 0") self._update_balance(amount) self.__register_transactions("Deposito", amount) print(f'Deposito exitoso de: ${amount} Balance actual: ${self.__balance}') def withdrawal(self, amount): if amount > self.__balance: raise ValueError("La cantidad tiene que ser menor a tu balance") self._update_balance(-amount) self.__register_transactions("Retiro", amount) print(f'Retiro exitoso de: ${amount} Balance actual: ${self.__balance}') #Metodos para consultar saldo y transacciones def get_balance(self): print(f"Balance actual: ${self.__balance}") return self.__balance def get_transactions(self): print(self.__transactions) return self.__transactions #upgrade_transaction_visibility def display_transactions(self): print(f"Historial de transacciones") for i, transaction in enumerate(self.__transactions, start=1): print(f"{i}. {transaction['action']}: ${transaction['amount']} - {transaction['date']}") #Crear instancias del objeto Bank Account miCuenta = Bank_Account(123456789, 2000) miCuenta.deposit(200) miCuenta.withdrawal(1000) miCuenta.get_balance() miCuenta.display_transactions() ```import datetime class Bank\_Account: def \_\_init\_\_(self, account\_number, balance): self.account\_number = account\_number self.\_\_balance = balance self.\_\_transactions = \[] #antes de crear el metodo de reiro o deposito hay que crear un metodo #para tener un seguimiento de los movimientos (PRIVADO) def \_\_register\_transactions(self, action, amount): transaction = { "action": action, "amount": amount, "date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") } self.\_\_transactions.append(transaction) #Metodo para actualizar balance (PROTEGIDO) def \_update\_balance(self, amount): self.\_\_balance += amount #metodos PUBLICOs def deposit(self, amount): if amount <= 0: raise ValueError("La cantidad tiene que ser mayor a 0") self.\_update\_balance(amount) self.\_\_register\_transactions("Deposito", amount) print(f'Deposito exitoso de: ${amount} Balance actual: ${self.\_\_balance}') def withdrawal(self, amount): if amount > self.\_\_balance: raise ValueError("La cantidad tiene que ser menor a tu balance") self.\_update\_balance(-amount) self.\_\_register\_transactions("Retiro", amount) print(f'Retiro exitoso de: ${amount} Balance actual: ${self.\_\_balance}') \#Metodos para consultar saldo y transacciones def get\_balance(self): print(f"Balance actual: ${self.\_\_balance}") return self.\_\_balance def get\_transactions(self): print(self.\_\_transactions) return self.\_\_transactions #upgrade\_transaction\_visibility def display\_transactions(self): print(f"Historial de transacciones") for i, transaction in enumerate(self.\_\_transactions, start=1): print(f"{i}. {transaction\['action']}: ${transaction\['amount']} - {transaction\['date']}") \#Crear instancias del objeto Bank AccountmiCuenta = Bank\_Account(123456789, 2000)miCuenta.deposit(200)miCuenta.withdrawal(1000)miCuenta.get\_balance()miCuenta.display\_transactions()
```python class Bank_Account: def __init__(self, name, balance): self.name = name self.__balance = balance self.__record = [] def _deposit(self, amount): if amount > 0: self.__balance += amount print(f"Se ha depositado la cantidad de ${amount} a su cuenta") self.__record_transaction("Depósito", amount) else: print("Monto inválido") def _withdraw(self, amount): if amount > self.__balance: print("Saldo insuficiente") else: self.__balance -= amount print(f"Se ha retirado la cantidad de ${amount} de su cuenta") self.__record_transaction("Retiro", amount) def __record_transaction(self, action, amount): self.__record.append((action, amount)) def get_record(self): return self.__record def get_balance(self): return self.__balance cuenta1 = Bank_Account("Juan", 1000) cuenta1._deposit(1000) cuenta1._withdraw(500) print("Saldo actual:", cuenta1.get_balance()) print("Historial: ", cuenta1.get_record()) ```
```python class CuentaBancaria: def __init__(self, nombre, numero_cuenta, _saldo): self.nombre = nombre self.numero_cuenta = numero_cuenta self._saldo = _saldo self.__historico_transacciones = [] def _actualizar_saldo(self, accion, monto): if accion == 'depositar': self._saldo += monto print(f'Ha recibido un deposito por: ${monto}. Su saldo actual es de: ${self._saldo}') self.__registrar_transaccion(accion, monto) elif accion == 'retirar': if self._saldo < monto: print("Fondos insuficientes para retirar $", monto) else: self._saldo -= monto print(f"Ha realizado un retiro por: ${monto}. Su saldo actual es de: ${self._saldo}") self.__registrar_transaccion(accion, monto) def __registrar_transaccion(self, accion, quantity): self.__historico_transacciones.append((accion, quantity)) def consultar_record(self): return self.__historico_transacciones cuenta = CuentaBancaria('Iris', '01342348632138821', 1000) cuenta._actualizar_saldo('depositar', 30000) print(cuenta.consultar_record()) cuenta._actualizar_saldo('retirar', 10000) print(cuenta.consultar_record()) # Verificando el acceso al metodo privado #cuenta.__registrar_transaccion('retirar', 1000) # AttributeError: 'CuentaBancaria' object has no attribute '__registrar_transaccion' porque es privado ```
Aquí mi código para el reto de esta clase:import datetime """Clase que contiene el identificador, el saldo yel registro de transacciones de una cuenta bancaria"""class CuentaBancaria: def \_\_init\_\_(self, id: int, saldo: float = 0.00): self.id = id self.saldo = saldo self.registro = \[ # { # 'id': 1, # 'saldo\_anterior': 0.00, # 'tipo\_transacción': TransactionType.INCOME, # 'fecha': datetime.datetime.now(), # 'importe': 2100.00, # 'nuevo\_saldo': 2100.00 # }, # { # 'id': 2, # 'saldo\_anterior': 2100.00, # 'tipo\_transacción': TransactionType.EXPENSE, # 'fecha': datetime.datetime.now(), # 'importe': 15.50, # 'nuevo\_saldo': 2084.50 # }, # { # 'id': 3, # 'saldo\_anterior': 2084.50, # 'tipo\_transacción': TransactionType.EXPENSE, # 'fecha': datetime.datetime.now(), # 'importe': 33.75, # 'nuevo\_saldo': 2050.75 # }, # { # 'id': 4, # 'saldo\_anterior': 2025.75, # 'tipo\_transacción': TransactionType.INCOME, # 'fecha': datetime.datetime.now(), # 'importe': 200.00, # 'nuevo\_saldo': 2250.75 # }, ] def mostrar\_transacciones(self): print("\n\n=======================================================================================") print(f"REGISTRO DE TRANSACCIONES \[CUENTA {self.id}]") print("---------------------------------------------------------------------------------------") print("#TRANSACCIÓN\tSALDO\_ANTERIOR\tTIPO\_TRANSACCIÓN\tIMPORTE\t\tNUEVO\_SALDO") print("=======================================================================================\n") transaction\_type = 0 for transaccion in self.registro: if transaccion\['tipo\_transacción'] == 2: transaction\_type = 'GASTO' else: transaction\_type = 'INGRESO' print(f"{transaccion\['id']}\t\t{transaccion\['saldo\_anterior']}\t\t{transaction\_type}\t\t\t{transaccion\['importe']}\t\t{transaccion\['nuevo\_saldo']}") print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -") # Calcula el ID de una nueva rtransacción (si no hay transacciones registradas, será 1) def \_new\_transaction\_id(self) -> int: # Calculamos el ID de la nueva transacción (si no hay transacciones, será 1) if len(self.registro) == 0: return 1 else: new\_id = max(self.registro, key=lambda transaccion: transaccion\['id'])\['id'] + 1 return new\_id # Método protegido. Se avisa por convencion de que no debe ser usado # fuera de la clase, aunque puede serlo def \_actualizar\_saldo(self, tipo\_transaccion: int, importe: float): saldo\_anterior = self.saldo fecha\_transaccion = datetime.datetime.now() if tipo\_transaccion == 2: self.saldo -= importe # Gasto else: # print("Transacción de tipo INGRESO") self.saldo += importe # Ingreso self.\_\_registrar\_transaccion(saldo\_anterior, tipo\_transaccion, importe, self.saldo) # Método privado. Solo puedes ser usado dentro de la clase def \_\_registrar\_transaccion(self, saldo\_anterior, tipo\_transaccion: int, importe: float, nuevo\_saldo: float): transaccion = { 'id': self.\_new\_transaction\_id(), 'saldo\_anterior': saldo\_anterior, 'tipo\_transacción': tipo\_transaccion, 'fecha': datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S"), 'importe': importe, 'nuevo\_saldo': nuevo\_saldo } self.registro.append(transaccion) print(f"\nSe ha registrado la siguiente transacción:\n\t{transaccion}") cuenta\_bancaria\_1 = CuentaBancaria(18201540679321456789) cuenta\_bancaria\_1.mostrar\_transacciones() cuenta\_bancaria\_1.\_actualizar\_saldo(1, 2100.00) # 1 = INGRESOcuenta\_bancaria\_1.\_actualizar\_saldo(2, 15.50) # 2 = GASTOcuenta\_bancaria\_1.\_actualizar\_saldo(2, 33.75) # 2 = GASTOcuenta\_bancaria\_1.\_actualizar\_saldo(1, 200.00) # 1 = INGRESO cuenta\_bancaria\_1.mostrar\_transacciones() ```js import datetime """ Clase que contiene el identificador, el saldo y el registro de transacciones de una cuenta bancaria """ class CuentaBancaria: def __init__(self, id: int, saldo: float = 0.00): self.id = id self.saldo = saldo self.registro = [ # { # 'id': 1, # 'saldo_anterior': 0.00, # 'tipo_transacción': TransactionType.INCOME, # 'fecha': datetime.datetime.now(), # 'importe': 2100.00, # 'nuevo_saldo': 2100.00 # }, # { # 'id': 2, # 'saldo_anterior': 2100.00, # 'tipo_transacción': TransactionType.EXPENSE, # 'fecha': datetime.datetime.now(), # 'importe': 15.50, # 'nuevo_saldo': 2084.50 # }, # { # 'id': 3, # 'saldo_anterior': 2084.50, # 'tipo_transacción': TransactionType.EXPENSE, # 'fecha': datetime.datetime.now(), # 'importe': 33.75, # 'nuevo_saldo': 2050.75 # }, # { # 'id': 4, # 'saldo_anterior': 2025.75, # 'tipo_transacción': TransactionType.INCOME, # 'fecha': datetime.datetime.now(), # 'importe': 200.00, # 'nuevo_saldo': 2250.75 # }, ] def mostrar_transacciones(self): print("\n\n=======================================================================================") print(f"REGISTRO DE TRANSACCIONES [CUENTA {self.id}]") print("---------------------------------------------------------------------------------------") print("#TRANSACCIÓN\tSALDO_ANTERIOR\tTIPO_TRANSACCIÓN\tIMPORTE\t\tNUEVO_SALDO") print("=======================================================================================\n") transaction_type = 0 for transaccion in self.registro: if transaccion['tipo_transacción'] == 2: transaction_type = 'GASTO' else: transaction_type = 'INGRESO' print(f"{transaccion['id']}\t\t{transaccion['saldo_anterior']}\t\t{transaction_type}\t\t\t{transaccion['importe']}\t\t{transaccion['nuevo_saldo']}") print("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -") # Calcula el ID de una nueva rtransacción (si no hay transacciones registradas, será 1) def _new_transaction_id(self) -> int: # Calculamos el ID de la nueva transacción (si no hay transacciones, será 1) if len(self.registro) == 0: return 1 else: new_id = max(self.registro, key=lambda transaccion: transaccion['id'])['id'] + 1 return new_id # Método protegido. Se avisa por convencion de que no debe ser usado # fuera de la clase, aunque puede serlo def _actualizar_saldo(self, tipo_transaccion: int, importe: float): saldo_anterior = self.saldo fecha_transaccion = datetime.datetime.now() if tipo_transaccion == 2: self.saldo -= importe # Gasto else: # print("Transacción de tipo INGRESO") self.saldo += importe # Ingreso self.__registrar_transaccion(saldo_anterior, tipo_transaccion, importe, self.saldo) # Método privado. Solo puedes ser usado dentro de la clase def __registrar_transaccion(self, saldo_anterior, tipo_transaccion: int, importe: float, nuevo_saldo: float): transaccion = { 'id': self._new_transaction_id(), 'saldo_anterior': saldo_anterior, 'tipo_transacción': tipo_transaccion, 'fecha': datetime.datetime.now().strftime("%d/%m/%Y %H:%M:%S"), 'importe': importe, 'nuevo_saldo': nuevo_saldo } self.registro.append(transaccion) print(f"\nSe ha registrado la siguiente transacción:\n\t{transaccion}") cuenta_bancaria_1 = CuentaBancaria(18201540679321456789) cuenta_bancaria_1.mostrar_transacciones() cuenta_bancaria_1._actualizar_saldo(1, 2100.00) # 1 = INGRESO cuenta_bancaria_1._actualizar_saldo(2, 15.50) # 2 = GASTO cuenta_bancaria_1._actualizar_saldo(2, 33.75) # 2 = GASTO cuenta_bancaria_1._actualizar_saldo(1, 200.00) # 1 = INGRESO cuenta_bancaria_1.mostrar_transacciones() ```
Aquí mi solución al reto: ```python import datetime class BankAccount: def __init__(self, id: int, balance: int): self.id = id self.balance = balance self.registro = [] def _actualizar_saldo(self, transaction_type: str, amount: int): #solo debe ser utilizado dentro de la clase y sus subclases if isinstance(transaction_type, str) and isinstance(amount, int): try: if transaction_type == "retiro": if self.balance < amount: print(f"El saldo a retirar, es mayor al saldo en su cuenta") return #no actualizamos el saldo, pues no es posible. self.balance -= amount elif transaction_type == "deposito": self.balance += amount self.__registrar_transaccion(transaction_type,amount) except: raise ValueError("El tipo de transacción debe ser retiro o depósito") def __registrar_transaccion(self, transaction_type: str, amount: int): #Debe ser completamente interno y no accesible fuera de la clase. self.registro.append((self.balance, datetime.datetime.now(), transaction_type, amount)) def retirar(self, amount: int): self._actualizar_saldo("retiro", amount) print(f"Se ha realizado el retiro, el nuevo saldo es $ {self.balance}.") def depositar(self, amount: int): self._actualizar_saldo("deposito", amount) print(f"Se ha realizado el deposito, el nuevo saldo es $ {self.balance}.") def ver_registro(self): for saldo, fecha, tipo, monto in self.registro: print(f" {fecha} - {tipo.capitalize()} de $ {monto}. Saldo: ${saldo}") account1 = BankAccount(123, 1000) account1.depositar(500) # Depósito account1.retirar(300) # Retiro account1.ver_registro() # Ver historial de transacciones ```
1. ```js class CuentaBancaria: """ Clase base para una cuenta bancaria con un saldo inicial. Args: saldo (int): Saldo inicial de la cuenta bancaria. Por defecto es 0. Attributes: saldo (int): Saldo actual de la cuenta bancaria. """ def __init__(self, saldo=0): self.__saldo = saldo # Método protegido que solo puede ser utilizado dentro de la clase y sus subclases def _actualizar_saldo(self, cantidad): self.__saldo += cantidad self.__registrar_transaccion(cantidad) # Método privado totalmente internon y no accesible fuera de la clase def __registrar_transaccion(self, cantidad): print(f'Transacción por {cantidad} registrada, saldo actual: {self.__saldo}') class CuentaDeAhorros(CuentaBancaria): """ Clase para una cuenta de ahorros que hereda de CuentaBancaria. Args: saldo (int): Saldo inicial de la cuenta de ahorros. Por defecto es 0. Attributes: saldo (int): Saldo actual de la cuenta de ahorros. """ def __init__(self, saldo=0): super().__init__(saldo) def depositar(self, cantidad): self._actualizar_saldo(cantidad) def retirar(self, cantidad): self._actualizar_saldo(-cantidad) cuenta = CuentaDeAhorros(100) cuenta.depositar(50) cuenta.retirar(25) cuenta.depositar(10) cuenta.retirar(15) cuenta.depositar(20) # Output: # Transacción por 50 registrada, saldo actual: 150 # Transacción por -25 registrada, saldo actual: 125 # Transacción por 10 registrada, saldo actual: 135 # Transacción por -15 registrada, saldo actual: 120 # Transacción por 20 registrada, saldo actual: 140 ```
```js class CuentaBancaria: """ Clase que representa una cuenta bancaria. Atributos: - _saldo: Saldo actual de la cuenta. - _historial_transacciones: Lista de transacciones registradas. """ def __init__(self, saldo_inicial): """ Inicializa una nueva cuenta bancaria con un saldo inicial. Parámetros: - saldo_inicial (float): El saldo inicial de la cuenta. """ self._saldo = saldo_inicial self._historial_transacciones = [] # Almacena un historial de transacciones def depositar(self, monto): """ Realiza un depósito en la cuenta, incrementando el saldo. Parámetros: - monto (float): Cantidad a depositar. """ if monto > 0: self._actualizar_saldo(monto) self.__registrar_transaccion(f"Depósito de {monto}") else: print("El monto a depositar debe ser positivo.") def retirar(self, monto): """ Realiza un retiro de la cuenta, disminuyendo el saldo si hay fondos suficientes. Parámetros: - monto (float): Cantidad a retirar. """ if 0 < monto <= self._saldo: self._actualizar_saldo(-monto) self.__registrar_transaccion(f"Retiro de {monto}") else: print("Fondos insuficientes o monto no válido.") def consultar_saldo(self): """ Devuelve el saldo actual de la cuenta. Retorno: - float: Saldo actual. """ return self._saldo def _actualizar_saldo(self, monto): """ Método protegido que actualiza el saldo de la cuenta. Parámetros: - monto (float): Cantidad a añadir (o restar si es negativa) al saldo. """ self._saldo += monto def __registrar_transaccion(self, descripcion): """ Método privado que registra internamente una transacción en el historial. Parámetros: - descripcion (str): Descripción de la transacción. """ self._historial_transacciones.append(descripcion) def mostrar_historial(self): """ Muestra el historial de transacciones realizadas en la cuenta. """ print("Historial de transacciones:") for transaccion in self._historial_transacciones: print("-", transaccion) # Ejemplo de uso cuenta = CuentaBancaria(500) cuenta.depositar(200) cuenta.retirar(100) cuenta.mostrar_historial() print("Saldo actual:", cuenta.consultar_saldo()) ```class CuentaBancaria:    """    Clase que representa una cuenta bancaria.        Atributos:    - \_saldo: Saldo actual de la cuenta.    - \_historial\_transacciones: Lista de transacciones registradas.    """     def \_\_init\_\_(self, saldo\_inicial):        """        Inicializa una nueva cuenta bancaria con un saldo inicial.         Parámetros:        - saldo\_inicial (float): El saldo inicial de la cuenta.        """        self.\_saldo = saldo\_inicial        self.\_historial\_transacciones = \[]  *# Almacena un historial de transacciones*     def depositar(self, monto):        """        Realiza un depósito en la cuenta, incrementando el saldo.        Parámetros:        - monto (float): Cantidad a depositar.        """        if monto > 0:            self.\_actualizar\_saldo(monto)            self.\_\_registrar\_transaccion(f"Depósito de {monto}")        else:            print("El monto a depositar debe ser positivo.")     def retirar(self, monto):        """        Realiza un retiro de la cuenta, disminuyendo el saldo si hay fondos suficientes.        Parámetros:        - monto (float): Cantidad a retirar.        """        if 0 < monto <= self.\_saldo:            self.\_actualizar\_saldo(-monto)            self.\_\_registrar\_transaccion(f"Retiro de {monto}")        else:            print("Fondos insuficientes o monto no válido.")     def consultar\_saldo(self):        """        Devuelve el saldo actual de la cuenta.        Retorno:        - float: Saldo actual.        """        return self.\_saldo     def \_actualizar\_saldo(self, monto):        """        Método protegido que actualiza el saldo de la cuenta.        Parámetros:        - monto (float): Cantidad a añadir (o restar si es negativa) al saldo.        """        self.\_saldo += monto     def \_\_registrar\_transaccion(self, descripcion):        """        Método privado que registra internamente una transacción en el historial.        Parámetros:        - descripcion (str): Descripción de la transacción.        """        self.\_historial\_transacciones.append(descripcion)     def mostrar\_historial(self):        """        Muestra el historial de transacciones realizadas en la cuenta.        """        print("Historial de transacciones:")        for transaccion in self.\_historial\_transacciones:            print("-", transaccion) *# Ejemplo de uso*cuenta = CuentaBancaria(500)cuenta.depositar(200)cuenta.retirar(100)cuenta.mostrar\_historial()print("Saldo actual:", cuenta.consultar\_saldo())
```python class CuentaBancaria: def __init__(self): self.__saldo = 0 self.__registro = [] def _actualizar_saldo(self, amount): self.__saldo += amount self.__registrar_transaccion(f'Acreditación de ${amount} en la cuenta') def __registrar_transaccion(self, message): self.__registro.append(message) print(message) cuenta = CuentaBancaria() cuenta._actualizar_saldo(1000) ```
Código: ```python class CuentaBancaria: def __init__(self, titular, saldo_inicial=0): self.titular = titular self.saldo = saldo_inicial self.__acciones = [] # Lista privada para registrar las acciones # Método protegido para actualizar el saldo def _actualizar_saldo(self, monto): self.saldo += monto self.__registrar_accion(f"Se ha actualizado el saldo en {monto}. Nuevo saldo: {self.saldo}") # Método público para hacer un depósito def depositar(self, monto): if monto > 0: self._actualizar_saldo(monto) print(f"Depósito de {monto} realizado exitosamente.") else: print("El monto a depositar debe ser mayor a 0.") # Método público para hacer un retiro def retirar(self, monto): if monto > 0 and self.saldo >= monto: self._actualizar_saldo(-monto) print(f"Retiro de {monto} realizado exitosamente.") else: print("Fondos insuficientes o monto inválido.") # Método privado para registrar las acciones internamente def __registrar_accion(self, accion): self.__acciones.append(accion) # Método público para ver el historial de acciones def ver_acciones(self): return self.__acciones # Ejemplo de uso cuenta = CuentaBancaria("Juan", 1000) cuenta.depositar(500) cuenta.retirar(200) print(cuenta.ver_acciones()) # Mostrar historial de acciones ```class CuentaBancaria: def \_\_init\_\_(self, titular, saldo\_inicial=0): self.titular = titular self.saldo = saldo\_inicial self.\_\_acciones = \[] # Lista privada para registrar las acciones # Método protegido para actualizar el saldo def \_actualizar\_saldo(self, monto): self.saldo += monto self.\_\_registrar\_accion(f"Se ha actualizado el saldo en {monto}. Nuevo saldo: {self.saldo}") # Método público para hacer un depósito def depositar(self, monto): if monto > 0: self.\_actualizar\_saldo(monto) print(f"Depósito de {monto} realizado exitosamente.") else: print("El monto a depositar debe ser mayor a 0.") # Método público para hacer un retiro def retirar(self, monto): if monto > 0 and self.saldo >= monto: self.\_actualizar\_saldo(-monto) print(f"Retiro de {monto} realizado exitosamente.") else: print("Fondos insuficientes o monto inválido.") # Método privado para registrar las acciones internamente def \_\_registrar\_accion(self, accion): self.\_\_acciones.append(accion) # Método público para ver el historial de acciones def ver\_acciones(self): return self.\_\_acciones # Ejemplo de uso cuenta = CuentaBancaria("Juan", 1000) cuenta.depositar(500) cuenta.retirar(200) print(cuenta.ver\_acciones()) # Mostrar historial de acciones
```python class Bank_account: def __init__(self, name: str, id: int) : self.name = name self.id = id self.balance = 0 self.__transactions = [] def transaction(self, amount: float): if amount > 0 : self.balance += amount transaction = f'- Usted realizo el siguiente movimiento bancario: + {amount} USD' self.__transactions.append(transaction) elif amount < 0 and self.balance > (-1 * amount): self.balance += amount transaction = f'- Usted realizo el siguiente movimiento bancario: {amount} USD' self.__transactions.append(transaction) elif amount < 0 and self.balance < (-1 * amount): print('No tiene suficiente saldo') else: print('no es tenido en cuenta') def _get_account_balance(self): print(f'Su saldo actual es de {self.balance} USD') def __get_transactions(self): print(f'Sus movientos son: ') print(self.__transactions) def public_method(self): self.__get_transactions() account_1 = Bank_account('Daniel', 1) account_1._get_account_balance() account_1.transaction(1000) account_1.transaction(-200) account_1._get_account_balance() account_1.public_method() ```class Bank\_account:    def \_\_init\_\_(self, name: str, id: int) :        self.name = name         self.id = id        self.balance = 0         self.\_\_transactions = \[]     def transaction(self, amount: float):        if amount > 0 :             self.balance += amount            transaction = f'- Usted realizo el siguiente movimiento bancario: + {amount} USD'            self.\_\_transactions.append(transaction)        elif amount < 0 and self.balance > (-1 \* amount):             self.balance += amount            transaction = f'- Usted realizo el siguiente movimiento bancario: {amount} USD'            self.\_\_transactions.append(transaction)        elif amount < 0 and self.balance < (-1 \* amount):            print('No tiene suficiente saldo')        else:            print('no es tenido en cuenta')     def \_get\_account\_balance(self):        print(f'Su saldo actual es de {self.balance} USD')     def \_\_get\_transactions(self):        print(f'Sus movientos son: ')        print(self.\_\_transactions)        def public\_method(self):        self.\_\_get\_transactions() account\_1 = Bank\_account('Daniel', 1)account\_1.\_get\_account\_balance()account\_1.transaction(1000)account\_1.transaction(-200)account\_1.\_get\_account\_balance()account\_1.public\_method()
![](https://static.platzi.com/media/user_upload/imagen-572060bd-97e2-4534-9e1b-d700894df12e.jpg)