Encapsulation en Python

L'encapsulation en tant que mot lorsqu'elle est entendue pour la première fois semble très sophistiquée, technique et complexe à faire dans le monde de la programmation, surtout si vous êtes débutant. Lorsque j'ai essayé d'en savoir plus sur l'encapsulation à partir de diverses sources, j'ai souhaité que quelqu'un puisse faciliter la compréhension de manière narrative. Donc, ici, j'essaie d'expliquer l'encapsulation comme je l'ai compris après avoir parcouru des tonnes de matériel à la fois en ligne et hors ligne.

• Comme vous êtes ici pour en savoir plus sur l'encapsulation, je suppose que vous avez déjà des connaissances sur la POO (programmation orientée objet).

" L'encapsulation est un mécanisme d'emballage des données (variables) et du code agissant sur les données (méthodes) ensemble comme une seule unité "

Cela semble être une définition assez dangereuse en soi. permet de le comprendre d'une manière simple.

Supposons que vous soyez programmeur senior d'une startup et que vous ayez une équipe chargée de construire un mécanisme pouvant permettre aux utilisateurs de rendre compte sur l'application de votre startup. Supposons que pour l'instant vous souhaitiez uniquement que le compte soit configuré à l'aide du nom et du mot de passe de l'utilisateur et que les seuls mots de passe que vous autorisez soient numériques. Oui! Je sais que ce n'est pas pratique dans le monde réel que les mots de passe soient uniquement numériques, mais supposons-le simplement pour comprendre le sujet. En tant que programmeur senior, vous serez responsable de la création de la classe de compte et les programmeurs juniors seront responsables de l'utilisation de cette classe.

supposons que vous ayez créé la classe comme suit :

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"

disons que ' Rohit ' est l'utilisateur et il a créé le compte en utilisant la commande suivante :

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

Maintenant, pour faire face à ce type de situations, l'encapsulation est notre super-héros pour sauver nos emplois et l'identité de nos utilisateurs.

Ce que fait l'encapsulation, c'est qu'elle vous permet de rendre vos variables privées. C'est ce que signifie en enveloppant les variables(data) . Comment pouvons-nous le faire en python . Ajoutez simplement un double trait de soulignement dans le préfixe des données que vous souhaitez rendre privées ( __data ).

Maintenant, dans le cas de notre classe Account , nous ne voulons pas que quelqu'un d'autre connaisse le mot de passe de nos utilisateurs. nous allons donc faire un changement dans notre code comme suit :

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"

Maintenant, si quelqu'un essaie d'accéder à la variable password , il recevra une erreur comme suit :

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

Mais pourquoi y a-t-il même un concept d'encapsulation si rien n'est privé ? Je sais que c'est ce qui se passe dans votre esprit, n'est-ce pas ?. Donc, le fait est que l'encapsulation est nécessaire lorsque vous ne voulez pas que d'autres (programmeurs juniors, utilisateurs) connaissent ou modifient des variables ou des méthodes importantes. Tant qu'ils ne peuvent pas accéder au code source, ils ne pourront pas savoir quelles variables ou méthodes sont privées et, par conséquent, ne pourront pas y accéder ni les modifier.

Mais que faire si Rohit a oublié son mot de passe et veut le récupérer ou le changer. La convention est que nous créons 2 méthodes dans notre classe qui permettront d'accéder et de modifier une variable privée connue sous le nom de méthodes Getter et Setter . comment faire ceux-ci ? utilisez le code suivant :

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

Pas seulement des variables, python vous permet même de rendre vos méthodes privées. Le processus est le même, changez simplement le nom de votre méthode en " __method " et votre méthode sera rendue privée.

Tout ce concept de création de variables privées, d'accès aux variables privées via des méthodes getter et de modification de la valeur de la variable privée à l'aide de méthodes setter est connu sous le nom d ' Encapsulation .

J'espère que ce blog pourra vous aider d'une manière ou d'une autre. se déconnecter ! au revoir