Métodos privados em Python

1. o modificador de acesso privado em Python
2. Declare um método privado em Python

Este tutorial demonstra como declarar, manipular e utilizar métodos privados em Python.

private é uma palavra-chave para um tipo de modificador de acesso usado em linguagens de programação orientadas a objetos. Os modificadores de acesso limitam a visibilidade de uma função ou variável até certo ponto. Declarar sua função / variável como privada limita o acesso apenas à classe que a encapsula.

Uma comparação da vida real com um método privado seria um sistema de iluminação doméstica. O interruptor e a lâmpada são como métodos públicos porque a pessoa tem acesso direto e visibilidade a eles. Ao mesmo tempo, os fios elétricos dentro da borracha protetora são os métodos privados, já que geralmente não são visíveis, a menos que sejam adulterados, mas ainda fazem seu trabalho sem serem tratados na maior parte do tempo.

o modificador de acesso privado em Python

Em Python, os métodos privados são métodos que não podem ser acessados ​​fora da classe em que estão declarados, nem para qualquer outra classe base.

Para declarar um método privado em Python, insira sublinhados duplos no início do nome do método.

o método __init__()

Um método privado notável em Python é o método __init__(), que é usado como um construtor de classe para um objeto de classe. Este método é chamado quando um objeto de uma classe é instanciado, dependendo dos argumentos do método.

Por exemplo, declare uma classe Person com dois campos e um método __init__():

class Person:
    name = ""
    age = 0

    def __init__(self, n, a):
        self.name = n
        self.age = a

Agora, para acessar o método privado __init__() fora da classe, precisaríamos acessá-lo a partir do objeto da própria classe após instanciá-lo.

Por exemplo, em outro arquivo no mesmo diretório, crie uma instância da classe Person e chame o construtor usando o nome da classe.

from personClass import Person

sys.path.append(".")


person = Person("John Doe", 25)

print(person.name, person.age)

Resultado:

John Doe   25

O método __init__() pode ser chamado explicitamente após instanciar a classe Person em uma variável para reinstanciar o objeto.

Por exemplo:

person = Person("John Doe", 25)
person.__init__("Jane Doe", 29)

print(person.name, person.age)

Resultado:

Jane Doe   29

Além disso, o método __init()__ pode ser explicitamente chamado chamando-o da própria classe. Embora para esta abordagem, você precisaria colocar explicitamente o primeiro parâmetro self nos argumentos.

person = Person("John Doe", 25)
Person.__init__(person, "Jack Sparrow", 46)  # person is the 'self' argument

print(person.name, person.age)

Resultado:

Jack Sparrow   46

Todas essas abordagens retêm a propriedade privada do método __init__().

Agora que esse método embutido foi dissecado. Vamos continuar implementando nossos próprios métodos privados em uma classe e diferenciando seu acesso de um método público.

Declare um método privado em Python

Para declarar um método privado, prefixe o método em questão com sublinhados duplos __. Caso contrário, ele será tratado como um método público padrão.

Vamos estender a classe Person do exemplo anterior e criar uma subclasse Employee que baseia seu construtor na classe Person.

Além disso, crie dois novos métodos na classe pessoa, um método público e um método privado.

class Person:
    name = ""
    age = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def walk(self):
        print("Walking")

    def __call(self):
        print("Taking a call")

Agora, crie a classe derivada ou subclasse Employee que estende Person:

class Employee(Person):
    occupation = "Unemployed"
    salary = 0

    def __init__(self, name, age, occupation, salary):
        Person.__init__(self, name, age)
        self.occupation = occupation
        self.salary = salary

    def work(self):
        print("Employee is working")
        self.walk()

    def takeCall(self):
        self.__call()
        print("Employee is taking a call")

Nesta classe, os métodos work() e takeCall() chamam externamente as classes walk() e __call() da classe pai Person, respectivamente.

O outro método chama externamente um método público e o outro chama um método privado de sua classe pai. Vamos ver como esse comportamento funciona quando o executamos.

Por exemplo, dadas as declarações de classe acima:

employee_1 = Employee("John Doe", 25, "Software Engineer", 40000)

employee_1.work()
employee_1.takeCall()

Resultado:

Employee is working
Walking
Traceback (most recent call last):
  File "python/demo.py", line 35, in <module>
    employee_1.takeCall()
  File "python/demo.py", line 29, in takeCall
    self.__call()
AttributeError: 'Employee' object has no attribute '_Employee__call'

A chamada ao método work() é executada com sucesso, imprimindo as instruções dos métodos work() e walk(). No entanto, a chamada para takeCall() dispara um AttributeError porque não reconhece o método __call() da classe Person como um método da classe Employee. Estender uma classe para outra classe não inclui seus próprios métodos privados na extensão.

Em resumo, os métodos privados em Python são declarados prefixando um método com dois sublinhados, __. A declaração de métodos privados permite que um método seja reservado exclusivamente para a classe de encapsulamento. Uma classe que estende outra classe com um método privado não herdará esses métodos e disparará um erro se tentar acessá-los.