🚎 🚁 🖐🏾 Métodos particulares sem sublinhados e interfaces em Python 👫 😅 👨‍👨‍👦

Oi Habr. Recentemente, fiquei louco por modificadores de acesso a design e interfaces, depois o transportei para a linguagem de programação Python. Eu pergunto no kat - eu compartilho os resultados e como ele funciona. Para os interessados, no final do artigo, há um link para o projeto no Github.

Modificadores de acesso

Modificadores de acesso restringem o acesso a objetos - a métodos de sua classe ou a classes filho - a métodos de sua classe pai. O uso de modificadores de acesso ajuda a ocultar dados na classe para que ninguém de fora possa interferir no trabalho dessa classe.

métodos privados estão disponíveis apenas dentro da classe, protected (inside) - dentro da classe e nas classes filho.

Como métodos privados e protegidos são implementados no Python

Spoiler - no nível do acordo que os adultos simplesmente não os chamarão fora da sala de aula. Antes dos métodos privados, você precisa escrever um sublinhado duplo antes de proteger. E você ainda pode acessar os métodos, apesar do acesso "limitado".

class Car: def _start_engine(self): return "Engine's sound." def run(self): return self._start_engine() if __name__ == '__main__': car = Car() assert "Engine's sound." == car.run() assert "Engine's sound." == car._start_engine()

As seguintes desvantagens podem ser determinadas:

Se o método _start_engine atualizou algumas variáveis de classe ou manteve o estado, e não apenas retornou um “cálculo burro”, você poderia ter quebrado algo para trabalhos futuros com a classe. Você não se permite reparar algo no motor do seu carro, porque não vai a lugar algum, certo?
O ponto de fluxo do anterior - para garantir que você possa "com segurança" (chamar o método não prejudique a própria classe) usar um método protegido - é necessário examinar seu código e gastar tempo.
Os autores das bibliotecas esperam que ninguém use os métodos protegidos e privados das classes que você usa em seus projetos. Portanto, eles podem alterar sua implementação em qualquer versão (que não afetará os métodos públicos devido à compatibilidade com versões anteriores, mas você sofrerá).
O autor da classe, seu colega, espera que você não aumente a dívida técnica do projeto usando um método protegido ou privado fora da classe que ele criou. Afinal, quem irá refatorá-lo ou modificá-lo (método de classe privada) terá que garantir (por exemplo, através de testes) que as alterações dele não quebrem seu código. E se eles quebrarem, ele terá que gastar tempo tentando resolver esse problema (com uma muleta, porque ele precisa ontem).
Talvez você tenha certeza de que outros programadores não usem métodos privados ou protegidos na revisão de código e “vença por isso”; portanto, gaste tempo.

Como implementar métodos protegidos usando uma biblioteca

 from accessify import protected class Car: @protected def start_engine(self): return "Engine's sound." def run(self): return self.start_engine() if __name__ == '__main__': car = Car() assert "Engine's sound." == car.run() car.start_engine()

Tentar chamar o método start_engine fora da classe resultará no seguinte erro (o método não está disponível de acordo com a política de acesso):

 Traceback (most recent call last): File "examples/access/private.py", line 24, in <module> car.start_engine() File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/accessify/main.py", line 92, in private_wrapper class_name=instance_class.__name__, method_name=method.__name__, accessify.errors.InaccessibleDueToItsProtectionLevelException: Car.start_engine() is inaccessible due to its protection level

Usando a biblioteca:

Você não precisa usar sublinhados feios (subjetivos) ou sublinhados duplos.
Você obtém um belo método (subjetivo) para implementar modificadores de acesso no código - decoradores privados e protegidos .
Transferir a responsabilidade de pessoa para intérprete.

Como funciona:

O decorador privado ou protegido - o decorador mais "alto", é acionado antes do método de classe , que foi declarado um modificador de acesso privado ou protegido.
Usando a biblioteca de inspeção interna , o decorador recupera o objeto atual da pilha de chamadas - inspect.currentframe () . Este objeto possui os seguintes atributos que são úteis para nós: o espaço para nome (locais) e o link para o objeto anterior da pilha de chamadas (o objeto que chama o método com o modificador de acesso).

(Ilustração muito simplificada)
inspect.currentframe (). f_back - use este atributo para verificar se o objeto anterior da pilha de chamadas está no corpo da classe ou não. Para fazer isso, observe o espaço para nome - f_locals . Se o atributo próprio estiver no espaço para nome, o método será chamado dentro da classe, se não, fora da classe. Se você chamar um método com um modificador de acesso privado ou protegido fora da classe, haverá um erro na política de acesso.

Interfaces

Interfaces são um contrato de interação com uma classe que a implementa. A interface contém as assinaturas do método (o nome das funções, os argumentos de entrada) e a classe que implementa a interface, seguindo as assinaturas, implementa a lógica. Resumindo, se duas classes implementam a mesma interface, você pode ter certeza de que os dois objetos dessas classes têm os mesmos métodos.

Exemplo

Temos uma classe de usuário que usa o objeto de armazenamento para criar um novo usuário.

 class User: def __init__(self, storage): self.storage = storage def create(self, name): return storage.create_with_name(name=name)

Você pode salvar o usuário no banco de dados usando DatabaseStorage.create_with_name .

 class DatabaseStorage: def create_with_name(self, name): ...

Você pode salvar o usuário em arquivos usando FileStorage.create_with_name .

 class FileStorage: def create_with_name(self, name): ...

Devido ao fato de as assinaturas dos métodos create_with_name (nome, argumentos) serem as mesmas para as classes - a classe User não precisa se preocupar com qual objeto foi substituído se ambos tiverem os mesmos métodos. Isso pode ser alcançado se as classes FileStorage e DatabaseStorage implementarem a mesma interface (ou seja, elas estão vinculadas pelo contrato para definir algum método com lógica interna).

 if __name__ == '__main__': if settings.config.storage = FileStorage: storage = FileStorage() if settings.config.storage = DatabaseStorage: storage = DatabaseStorage() user = User(storage=storage) user.create_with_name(name=...)

Como trabalhar com interfaces usando a biblioteca

Se uma classe implementa uma interface, ela deve conter todos os métodos da interface . No exemplo abaixo, a interface HumanInterface contém o método eat, e a classe Human o implementa, mas não implementa o método eat.

 from accessify import implements class HumanInterface: @staticmethod def eat(food, *args, allergy=None, **kwargs): pass if __name__ == '__main__': @implements(HumanInterface) class Human: pass