padrões de design de python [fechados]

Estou procurando qualquer recurso que dê exemplos de práticas recomendadas, padrões de design e os princípios do SOLID usando Python.

Alguma sobreposição nestes

Carpintaria de Software Intermediária e Avançada em Python

Código Como um Pythonista: Python Idiomatic

Expressões e eficiência em Python

Dia do desenvolvedor do Google nos EUA - padrões de design do Python

Outro recurso é o exemplo das Receitas Python . Um bom número não segue as práticas recomendadas, mas você pode encontrar alguns padrões úteis

Tipo

>>> import this

em um console Python.

Embora isso geralmente seja tratado como uma piada (excelente!), Ele contém alguns axiomas específicos para python válidos.

" Thinking in Python " de Bruce Eckel se apóia fortemente em Design Patterns

Você pode começar aqui e aqui .

Para uma análise mais aprofundada dos padrões de design, você deve consultar Padrões de Design: Elementos de Software Orientado a Objetos Reutilizáveis . O código fonte não está no Python, mas não precisa ser para você entender os padrões.

Algo que você pode usar para simplificar seu código ao chamar atributos em objetos que podem ou não existir é usar o Null Object Design Pattern (ao qual fui apresentado no Python Cookbook ).

Grosso modo, o objetivo com objetos Nulos é fornecer uma substituição 'inteligente' para o tipo de dados primitivo Nenhum usado em Python ou Nulo (ou ponteiros Nulos) em outros idiomas. Eles são usados ​​para muitos propósitos, incluindo o caso importante em que um membro de algum grupo de elementos similares é especial por qualquer motivo. Na maioria das vezes, isso resulta em instruções condicionais para distinguir entre elementos comuns e o valor nulo primitivo.

Este objeto apenas come a falta de erro de atributo e você pode evitar verificar a existência deles.

Não é nada além de

class Null(object):

    def __init__(self, *args, **kwargs):
        "Ignore parameters."
        return None

    def __call__(self, *args, **kwargs):
        "Ignore method calls."
        return self

    def __getattr__(self, mname):
        "Ignore attribute requests."
        return self

    def __setattr__(self, name, value):
        "Ignore attribute setting."
        return self

    def __delattr__(self, name):
        "Ignore deleting attributes."
        return self

    def __repr__(self):
        "Return a string representation."
        return "<Null>"

    def __str__(self):
        "Convert to a string and return it."
        return "Null"

Com isso, se você fizer Null("any", "params", "you", "want").attribute_that_doesnt_exists()isso, não explodirá, mas apenas silenciosamente se tornará o equivalente a pass.

Normalmente você faria algo como

if obj.attr:
    obj.attr()

Com isso, você apenas faz:

obj.attr()

e esqueça isso. Cuidado que o uso extensivo do Nullobjeto pode ocultar erros no seu código.

Você também pode ler este artigo (selecione o arquivo .pdf), que discute os Padrões de design em linguagens dinâmicas orientadas a objetos (por exemplo, Python). Para citar a página:

Este artigo explora como os padrões do livro "Gang of Four", ou "GOF", como costuma ser chamado, aparecem quando problemas semelhantes são abordados usando uma linguagem de programação dinâmica, de ordem superior e orientada a objetos. Alguns dos padrões desaparecem - ou seja, eles são suportados diretamente pelos recursos da linguagem, alguns são mais simples ou têm um foco diferente e alguns são essencialmente inalterados.