Encapsulación en Python

La palabra encapsulación cuando se escucha por primera vez parece algo muy elegante, técnico y complejo en el mundo de la programación, especialmente si eres un principiante. Cuando traté de aprender sobre la encapsulación de varias fuentes, deseé que alguien pudiera hacerlo más fácil de entender de una manera narrativa. Así que aquí estoy tratando de explicar la encapsulación como la entendí después de leer toneladas de material tanto en línea como fuera de línea.

• Como está aquí para aprender sobre la encapsulación, asumo que ya tiene algún conocimiento sobre OOP (Programación Orientada a Objetos).

“ La encapsulación es un mecanismo para envolver los datos (variables) y el código que actúa sobre los datos (métodos) como una sola unidad ”

Parece una definición bastante peligrosa por sí sola. vamos a entenderlo de una manera simple.

Suponga que usted es el programador senior de una startup y tiene un equipo que es responsable de construir un mecanismo que pueda permitir a los usuarios crear una cuenta en la aplicación de su startup. Supongamos que por ahora solo desea configurar la cuenta con el nombre y la contraseña del usuario y las únicas contraseñas que permite son numéricas. ¡Sí! Sé que no es práctico en el mundo real que las contraseñas sean solo numéricas, pero asumámoslo para entender el tema. Como programador senior, será responsable de crear la clase de cuenta y los programadores junior serán responsables de usar esa clase.

supongamos que creó la clase de la siguiente manera:

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' es el usuario y creó la cuenta usando el siguiente 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

Ahora, para hacer frente a este tipo de situaciones, la encapsulación viene como nuestro superhéroe para salvar nuestros trabajos y las identidades de nuestros usuarios.

Lo que hace la encapsulación es que te permite hacer que tus variables sean privadas. Eso es lo que significa envolver las variables (datos) . ¿Cómo podemos hacerlo en python? Simplemente agregue un guión bajo doble en el prefijo de los datos que desea hacer privados (__data).

Ahora, en el caso de nuestra clase Cuenta, no queremos que nadie más sepa la contraseña de nuestros usuarios. así que haremos un cambio en nuestro código como sigue:

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"

Ahora, si alguien intenta acceder a la variable de contraseña, recibirá un error como el siguiente:

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

Pero, ¿por qué existe el concepto de encapsulación si nada es privado? Sé que eso es lo que está pasando en tu mente, ¿verdad?. Entonces, la cuestión es que la encapsulación es necesaria cuando no desea que otros (programadores junior, usuarios) sepan o realicen cambios en variables importantes, métodos. Hasta que ya menos que puedan acceder al código fuente, no podrán saber qué variables o métodos son privados y, por lo tanto, no podrán acceder a ellos ni modificarlos.

Pero, ¿qué pasa si Rohit olvidó su contraseña y quiere recuperarla o cambiarla? La convención es que creamos 2 métodos en nuestra clase que permitirán acceder y cambiar variables privadas conocidas como métodos Getter y Setter . ¿Cómo hacer estos? utiliza el siguiente 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

No solo las variables, python incluso le permite hacer que sus métodos sean privados. El proceso es el mismo, simplemente cambie el nombre de su método a "__method" y su método se hará privado.

Todo este concepto de hacer variables privadas, acceder a variables privadas a través de métodos getter y cambiar el valor de variable privada usando métodos setter se conoce como Encapsulación .

Espero que este blog pueda ayudarte de alguna manera. firmando! adios