Incapsulamento in Python

L'incapsulamento come parola quando viene ascoltata per la prima volta sembra una cosa molto elaborata, tecnica e complessa da fare nel mondo della programmazione, specialmente se sei un principiante. Quando ho provato a conoscere l'incapsulamento da varie fonti, ho desiderato che qualcuno potesse renderlo più facile da capire in modo narrativo. Quindi qui sto cercando di spiegare l'incapsulamento come l'ho capito dopo aver esaminato tonnellate di materiale sia online che offline.

• Dato che sei qui per conoscere l'incapsulamento, presumo che tu abbia già una certa conoscenza di OOP (Programmazione orientata agli oggetti).

" L'incapsulamento è un meccanismo di avvolgimento dei dati (variabili) e del codice che agisce sui dati (metodi) insieme come una singola unità "

Sembra una definizione piuttosto pericolosa di per sé. capiamolo in modo semplice.

Supponi di essere un programmatore senior di una startup e di avere un team responsabile della creazione di un meccanismo che possa consentire agli utenti di rendere conto dell'applicazione della tua startup. Supponiamo per ora di voler configurare solo l'account utilizzando il nome e la password dell'utente e che le uniche password consentite siano numeriche. SÌ! So che non è pratico nel mondo reale che le password siano solo numeriche, ma supponiamolo solo per capire l'argomento. Essendo un programmatore senior, sarai responsabile della creazione della classe dell'account e i programmatori junior saranno responsabili dell'utilizzo di quella classe.

supponiamo di aver creato la classe come segue:

class Account:
    # constructor
    def __init__(self):
        self.user = ''
        self.password = 0
        self.menu()
    
    # display option
    def menu(self):
        user_input = input("""
        Select to Enter the following details:
        1. set account
        2. login
        5. Exit
        """)
        if user_input == '1':
            self.set_account()
        elif user_input == '2':
            self.login()
        else:
            exit()
    # To set account
    def set_account(self):
        user_name = input("set user id: ")
        self.user = user_name
        user_password = int(input("Set Password: "))
        self.password = user_password
    # To login
    def login(self):
        user_input = input("enter User id: ")
        if user_input == self.user:
            user_pass = int(input("enter password: "))
            if user_pass == self.password:
                return "Welcome {}".format(self.user)
            else:
                return "wrong password"
        else:
            return "user not found"

diciamo che ' Rohit ' è l'utente e ha creato l'account usando il seguente comando:

rohit = Account()

# after running the above code we get the prompt and add the following detail
"""
Select to Enter the following details:
        1. set account
        2. login
        5. Exit
        1
set user id: rohit
Set Password: 123
"""

rohit.password

Ora per affrontare questo tipo di situazioni, l'incapsulamento si presenta come il nostro supereroe per salvare i nostri posti di lavoro e le identità dei nostri utenti.

Ciò che fa l'incapsulamento è che ti consente di rendere private le tue variabili. Questo è ciò che significa racchiudere le variabili (dati) . Come possiamo farlo in Python . Aggiungi semplicemente il doppio trattino basso nel prefisso dei dati che desideri rendere privati ​​( __data ).

Ora, nel caso della nostra classe Account , non vogliamo che qualcun altro conosca la password dei nostri utenti. quindi faremo una modifica nel nostro codice come segue:

class Account:

    def __init__(self):
        self.user = ''
        self.__password = 0
        self.menu()
            
    def menu(self):
        user_input = input("""
        Select to Enter the following details:
        1. set account
        2. login
        5. Exit
        """)
        if user_input == '1':
            self.set_account()
        elif user_input == '2':
            self.login()
        else:
            exit()
    
    def set_account(self):
        user_name = input("set user id: ")
        self.user = user_name
        user_password = int(input("Set Password: "))
        self.__password = user_password
    
    def login(self):
        user_input = input("enter User id: ")
        if user_input == self.user:
            user_pass = int(input("enter password: "))
            if user_pass == self.__password:
                return "Welcome {}".format(self.user)
            else:
                return "wrong password"
        else:
            return "user not found"

Ora se qualcuno tenta di accedere alla variabile password , verrà generato un errore come segue:

rohit.password

# running the above piece of code will output the following error
"""
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-4-7ddf6c297392> in <module>
----> 1 rohit.password

AttributeError: 'Account' object has no attribute 'password'
"""

rohit._Account__password

# Output 
# 1234

Ma perché esiste anche il concetto di incapsulamento se nulla è privato? So che è quello che ti passa per la testa, giusto? Quindi il fatto è che l'incapsulamento è necessario quando non vuoi che altri (programmatori junior, utenti) sappiano o apportino modifiche a variabili e metodi importanti. Fino a quando ea meno che non possano accedere al codice sorgente, non saranno in grado di sapere quali variabili o metodi sono privati ​​e, quindi, non saranno in grado di accedervi o modificarli.

Ma cosa succede se Rohit ha dimenticato la sua password e vuole recuperarla o cambiarla. La convenzione è che creiamo 2 metodi nella nostra classe che consentiranno l'accesso e la modifica di variabili private note come metodi Getter e Setter . come fare questi? utilizzare il seguente codice:

class Account:

    def __init__(self):
        self.user = ''
        self.__password = 0
        self.menu()
    
    # GETTER
    def get_pass(self):
        return self._Account__password
    # SETTER
    def set_pass(self,newpass):
        if type(newpass) == int:
            self.__password = newpass
        else: return "Password should only be numeric"
            
    def menu(self):
        user_input = input("""
        Select to Enter the following details:
        1. set account
        2. login
        5. Exit
        """)
        if user_input == '1':
            self.set_account()
        elif user_input == '2':
            self.login()
        else:
            exit()
    
    def set_account(self):
        user_name = input("set user id: ")
        self.user = user_name
        user_password = int(input("Set Password: "))
        self.__password = user_password
    
    def login(self):
        user_input = input("enter User id: ")
        if user_input == self.user:
            user_pass = int(input("enter password: "))
            if user_pass == self.__password:
                return "Welcome {}".format(self.user)
            else:
                return "wrong password"
        else:
            return "user not found

Non solo variabili, Python ti consente persino di rendere privati ​​​​i tuoi metodi. Il processo è lo stesso, basta cambiare il nome del metodo in " __method " e il tuo metodo verrà reso privato.

L'intero concetto di creazione di variabili private, accesso a variabili private tramite metodi getter e modifica del valore della variabile privata utilizzando metodi setter è noto come Encapsulation .

Spero che questo blog possa aiutarti in qualche modo. firmare! ciao