Kapselung in Python

Wenn man das Wort Kapselung zum ersten Mal hört, scheint es in der Programmierwelt eine sehr ausgefallene, technische und komplexe Angelegenheit zu sein, insbesondere wenn man Anfänger ist. Als ich versuchte, aus verschiedenen Quellen etwas über Kapselung zu lernen, wünschte ich mir, jemand könnte es auf erzählerische Weise leichter verständlich machen. Hier versuche ich die Kapselung so zu erklären, wie ich sie verstanden habe, nachdem ich Unmengen von Material online und offline durchgesehen habe.

• Da Sie hier sind, um mehr über Kapselung zu erfahren, gehe ich davon aus, dass Sie bereits über Kenntnisse über OOPs (objektorientierte Programmierung) verfügen.

„ Kapselung ist ein Mechanismus, bei dem die Daten (Variablen) und der auf die Daten wirkende Code (Methoden) als eine einzige Einheit zusammengefasst werden. “

Es scheint eine ziemlich gefährliche Definition für sich zu sein. Lassen Sie es uns auf einfache Weise verstehen.

Angenommen, Sie sind leitender Programmierer eines Startups und haben ein Team, das für den Aufbau eines Mechanismus verantwortlich ist, der es Benutzern ermöglicht, Konten für die Anwendung Ihres Startups zu erstellen. Angenommen, Sie möchten, dass das Konto vorerst nur mit dem Namen und dem Passwort des Benutzers eingerichtet wird und Sie nur numerische Passwörter zulassen. Ja! Ich weiß, dass es in der Praxis nicht praktikabel ist, dass Passwörter nur numerisch sind, aber um das Thema zu verstehen, nehmen wir es einfach an. Als leitender Programmierer sind Sie für die Erstellung der Kontoklasse verantwortlich und Junior-Programmierer sind für die Verwendung dieser Klasse verantwortlich.

Angenommen, Sie haben die Klasse wie folgt erstellt:

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"

Nehmen wir an, „Rohit“ ist der Benutzer und er hat das Konto mit dem folgenden Befehl erstellt:

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

Um diese Art von Situationen anzugehen, ist die Kapselung unser Superheld, um unsere Arbeitsplätze und die Identität unserer Benutzer zu retten.

Durch die Kapselung können Sie Ihre Variablen privat machen. Das bedeutet, die Variablen (Daten) einzuschließen . Wie können wir das in Python machen? Fügen Sie einfach einen doppelten Unterstrich im Präfix der Daten hinzu, die Sie privat machen möchten ( __data ).

Im Fall unserer Account-Klasse möchten wir nicht, dass jemand anderes das Passwort unseres Benutzers kennt. Deshalb werden wir eine Änderung in unserem Code wie folgt vornehmen:

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"

Wenn nun jemand versucht, auf die Passwortvariable zuzugreifen, wird ihm/ihr eine Fehlermeldung wie folgt angezeigt:

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

Aber warum gibt es überhaupt das Konzept der Kapselung, wenn nichts privat ist? Ich weiß, dass das in deinem Kopf vorgeht, oder? Die Sache ist also, dass eine Kapselung erforderlich ist, wenn Sie nicht möchten, dass andere (Nachwuchsprogrammierer, Benutzer) wichtige Variablen und Methoden kennen oder Änderungen daran vornehmen. Solange sie nicht auf den Quellcode zugreifen können, können sie nicht wissen, welche Variablen oder Methoden privat sind, und daher nicht auf sie zugreifen oder sie ändern können.

Was aber, wenn Rohit sein Passwort vergessen hat und es abrufen oder ändern möchte? Die Konvention besteht darin, dass wir in unserer Klasse zwei Methoden erstellen, die den Zugriff auf und die Änderung privater Variablen ermöglichen, die als Getter- und Setter -Methoden bekannt sind. Wie macht man diese? Verwenden Sie den folgenden Code:

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

Mit Python können Sie nicht nur Variablen, sondern auch Ihre Methoden privat machen. Der Vorgang ist derselbe. Ändern Sie einfach Ihren Methodennamen in „__method“ und Ihre Methode wird privat gemacht.

Dieses gesamte Konzept, private Variablen zu erstellen, über Getter-Methoden auf private Variablen zuzugreifen und den Wert privater Variablen mithilfe von Setter-Methoden zu ändern, wird als Kapselung bezeichnet .

Ich hoffe, dieser Blog könnte Ihnen irgendwie helfen. Abmeldung ! Tschüss