Encapsulamento em Python

Jan 21 2023

Encapsulamento como uma palavra quando ouvida pela primeira vez parece uma coisa muito sofisticada, técnica e complexa de se fazer no mundo da programação, especialmente se você é iniciante. Quando tentei aprender sobre encapsulamento de várias fontes, desejei que alguém pudesse facilitar a compreensão de uma forma narrativa.

Como você está aqui para aprender sobre encapsulamento, presumo que já tenha algum conhecimento sobre OOP's (Programação Orientada a Objetos).

“ Encapsulamento é um mecanismo de agrupar os dados (variáveis) e o código que age sobre os dados (métodos) juntos como uma única unidade ”

Parece uma definição bastante perigosa por conta própria. vamos entender de forma simples.

Suponha que você seja programador sênior de uma startup e tenha uma equipe responsável por construir um mecanismo que possa permitir que usuários façam contas no aplicativo de sua startup. Suponha que, por enquanto, você queira apenas que a conta seja configurada usando o nome e a senha do usuário e as únicas senhas permitidas sejam numéricas. Sim! Eu sei que não é prático no mundo real que as senhas sejam apenas numéricas, mas vamos supor isso para entender o tópico. Sendo um programador sênior, você será responsável por criar a classe de conta e os programadores juniores serão responsáveis por usar essa classe.

suponha que você criou a classe da seguinte forma:

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"

digamos que 'Rohit' é o usuário e ele criou a conta usando o seguinte 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

Agora, para enfrentar esse tipo de situação, o encapsulamento vem como nosso super-herói para salvar nossos empregos e as identidades de nossos usuários.

O que o encapsulamento faz é permitir que você torne suas variáveis privadas. Isso é o que significa envolver as variáveis (dados) . Como podemos fazer isso em python. Basta adicionar sublinhado duplo no prefixo dos dados que você deseja tornar privados ( __data ).

Agora, no caso de nossa classe Account, não queremos que outra pessoa saiba a senha de nossos usuários. então vamos fazer uma alteração em nosso código como 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"

Agora, se alguém tentar acessar a variável de senha, será lançado um erro como o seguinte:

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

Mas por que existe o conceito de encapsulamento se nada é privado? Eu sei que é isso que se passa na sua cabeça, certo? Portanto, o encapsulamento é necessário quando você não deseja que outros (programadores juniores, usuários) saibam ou façam alterações em variáveis e métodos importantes. Até e a menos que eles possam acessar o código-fonte, eles não poderão saber quais variáveis ou métodos são privados e, portanto, não poderão acessá-los ou alterá-los.

Mas e se Rohit esquecer sua senha e quiser recuperá-la ou alterá-la? A convenção é que criamos 2 métodos em nossa classe que permitirão acessar e alterar variáveis privadas conhecidas como métodos Getter e Setter . como fazer isso? use o seguinte código:

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

Não apenas variáveis, o python permite que você torne seus métodos privados. O processo é o mesmo, apenas mude o nome do seu método para “__method” e seu método se tornará privado.

Todo esse conceito de criar variáveis privadas, acessar variáveis privadas por meio de métodos getter e alterar o valor de variáveis privadas usando métodos setter é conhecido como Encapsulamento .