Hermetyzacja w Pythonie

Hermetyzacja jako słowo, gdy słyszy się je po raz pierwszy, wydaje się bardzo fantazyjną, techniczną i złożoną rzeczą w świecie programowania, szczególnie jeśli jesteś początkującym. Kiedy próbowałem dowiedzieć się o enkapsulacji z różnych źródeł, chciałem, aby ktoś mógł ułatwić zrozumienie w sposób narracyjny. Więc tutaj próbuję wyjaśnić enkapsulację tak, jak ją zrozumiałem po przejrzeniu ton materiałów zarówno online, jak i offline.

• Ponieważ jesteś tutaj, aby dowiedzieć się o enkapsulacji, zakładam, że masz już pewną wiedzę na temat OOP (programowanie obiektowe).

„ Enkapsulacja to mechanizm łączenia danych (zmiennych) i kodu działającego na danych (metodach) w jedną całość ”

Sama w sobie wydaje się dość niebezpieczną definicją. zrozummy to w prosty sposób.

Załóżmy, że jesteś starszym programistą startupu i masz zespół, który jest odpowiedzialny za zbudowanie mechanizmu, który pozwoli użytkownikom rozliczać się z aplikacji Twojego startupu. Załóżmy na razie, że chcesz skonfigurować konto tylko przy użyciu nazwy i hasła użytkownika, a jedyne dozwolone hasła to numeryczne. Tak! Wiem, że w prawdziwym świecie niepraktyczne jest, aby hasła były tylko numeryczne, ale załóżmy to dla zrozumienia tematu. Jako starszy programista będziesz odpowiedzialny za utworzenie klasy konta, a młodsi programiści będą odpowiedzialni za korzystanie z tej klasy.

załóżmy, że utworzyłeś klasę w następujący sposób:

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"

powiedzmy, że „Rohit” jest użytkownikiem i utworzył konto za pomocą następującego polecenia:

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

Teraz, aby poradzić sobie z tego typu sytuacjami, enkapsulacja jest naszym superbohaterem, który ratuje nasze miejsca pracy i tożsamość naszych użytkowników.

Enkapsulacja polega na tym, że pozwala uczynić zmienne prywatnymi. To właśnie oznacza zawijanie zmiennych (danych) . Jak możemy to zrobić w Pythonie. Po prostu dodaj podwójne podkreślenie w przedrostku danych, które chcesz ustawić jako prywatne ( __data ).

Teraz w przypadku naszej klasy Account nie chcemy, aby ktoś inny znał hasło naszych użytkowników. więc dokonamy zmiany w naszym kodzie w następujący sposób:

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"

Teraz, jeśli ktoś spróbuje uzyskać dostęp do zmiennej hasła, zostanie wyświetlony następujący błąd:

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

Ale dlaczego w ogóle istnieje koncepcja enkapsulacji, jeśli nic nie jest prywatne? Wiem, że to właśnie dzieje się w twoim umyśle, prawda? Chodzi o to, że enkapsulacja jest potrzebna, gdy nie chcesz, aby inni (młodsi programiści, użytkownicy) znali lub wprowadzali zmiany w ważnych zmiennych, metodach. Dopóki nie uzyskają dostępu do kodu źródłowego, nie będą mogli wiedzieć, które zmienne lub metody są prywatne, a zatem nie będą mogli uzyskać do nich dostępu ani ich zmienić.

Ale co, jeśli Rohit zapomniał hasła i chce je odzyskać lub zmienić. Konwencja polega na tym, że tworzymy w naszej klasie 2 metody, które pozwolą na dostęp i zmianę zmiennej prywatnej znanej jako metody Getter i Setter . jak je zrobić? użyj następującego kodu:

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

Nie tylko zmienne, python pozwala nawet uczynić twoje metody prywatnymi. Proces jest taki sam, po prostu zmień nazwę metody na „__method”, a Twoja metoda zostanie ustawiona jako prywatna.

Cała ta koncepcja tworzenia zmiennych prywatnych, uzyskiwania dostępu do zmiennych prywatnych za pomocą metod pobierających i zmieniania wartości zmiennych prywatnych za pomocą metod ustawiających jest znana jako Encapsulation .

Mam nadzieję, że ten blog może ci w jakiś sposób pomóc. wylogować się! pa