__getitem__ y __setitem__ en Python

Los métodos de Dunder son métodos con subrayado doble que se utilizan para emular el comportamiento de los tipos integrados. Son métodos predefinidos que simplifican muchas operaciones que se pueden realizar en una instancia de clase, como __init__(), __str__(), __call__(), etc. Estos métodos son muy útiles porque se usan en operaciones binarias, operaciones de asignación, unarias y binarias. operaciones de comparación.

Nota: Para obtener más información, consulte Dunder o métodos mágicos en Python

__getitem__ y __setitem__

Hay métodos getter y setter como parte de estos métodos mágicos. Se implementan mediante __getitem__()y __setitem__()métodos. Pero, estos métodos se usan solo en atributos indexados como arrays, diccionarios, listas, etc. En lugar de acceder y manipular directamente los atributos de clase, proporciona dichos métodos, por lo que estos atributos solo pueden modificarse por sus propias instancias y, por lo tanto, implementa la abstracción.

En lugar de hacer que los atributos de clase sean públicos, estos métodos los hacen privados, brindan validación de que solo se establecen valores correctos para los atributos y que la única persona que llama tiene acceso a estos atributos.

Tomemos el ejemplo de un registro bancario de una persona. Contiene saldo, historial de transacciones y otros registros confidenciales como parte de él. Ahora, este registro bancario debe manejarse como un tipo de datos incorporado para facilitar muchas operaciones. Hay varios métodos que necesitan acceso para el saldo y el historial de transacciones. Si modifican directamente el saldo, pueden terminar insertando valores nulos, o valores negativos que son muy vulnerables. Por lo tanto, el __getitem__()y __setitem__()ayuda a presentar los detalles de forma segura.

Ejemplo:

class bank_record:
      
    def __init__(self, name):
          
        self.record = {
                        "name": name,
                        "balance": 100,
                        "transaction":[100]
                        }
  
    def __getitem__(self, key):
          
        return self.record[key]
  
    def __setitem__(self, key, newvalue):
          
        if key =="balance" and newvalue != None and newvalue>= 100:
            self.record[key] += newvalue
              
        elif key =="transaction" and newvalue != None:
            self.record[key].append(newvalue)
      
    def getBalance(self):
        return self.__getitem__("balance")
  
    def updateBalance(self, new_balance):
          
        self.__setitem__("balance", new_balance)
        self.__setitem__("transaction", new_balance)    
      
    def getTransactions(self):
        return self.__getitem__("transaction")
  
    def numTransactions(self):
        return len(self.record["transaction"])
  
sam = bank_record("Sam")
print("The balance is : "+str(sam.getBalance()))
  
sam.updateBalance(200)
print("The new balance is : "+str(sam.getBalance()))
print("The no. of transactions are: "+str(sam.numTransactions()))
  
sam.updateBalance(300)
print("The new balance is : "+str(sam.getBalance()))
print("The no. of transactions are: "+str(sam.numTransactions()))
print("The transaction history is: "+ str(sam.getTransactions()))

Producción

The balance is : 100
The new balance is : 300
The no. of transactions are: 2
The new balance is : 600
The no. of transactions are: 3
The transaction history is: [100, 200, 300]

Aquí puede ver lo fácil que es implementar numTransactions(), getTransactions(), getBalance(), setBalance(), simplemente implementando __getitem__()y __setitem__()métodos. Además, se encarga de la validación del saldo y el historial de transacciones.