pattern di design in pitone [chiuso]

Sto cercando qualsiasi risorsa che fornisca esempi di Best Practices, Pattern di progettazione e principi SOLID usando Python.

Alcuni si sovrappongono in questi

Carpenteria software intermedia e avanzata in Python

Code Like a Pythonista: Idiomatic Python

Idiomi ed efficienza di Python

Google Developers Day US - Python Design Patterns

Un'altra risorsa è ad esempio nelle ricette Python . Un buon numero non segue le migliori pratiche ma è possibile trovare alcuni schemi utili

genere

>>> import this

in una console Python.

Sebbene questo sia generalmente trattato come uno scherzo (bene!), Contiene un paio di assiomi validi specifici per il pitone.

" Thinking in Python " di Bruce Eckel si appoggia fortemente su Design Patterns

Puoi iniziare qui e qui .

Per uno sguardo più approfondito ai partecipanti al design, dovresti esaminare Design Patterns: Elements of Reusable Object-Oriented Software . Il codice sorgente non è in Python, ma non è necessario che tu comprenda gli schemi.

Qualcosa che puoi usare per semplificare il tuo codice quando chiami attributi su oggetti che potrebbero o meno esistere è usare il Null Object Design Pattern (a cui sono stato introdotto in Python Cookbook ).

All'incirca, l'obiettivo con gli oggetti Null è quello di fornire una sostituzione "intelligente" per il tipo di dati primitivo spesso usato None in Python o Null (o puntatori Null) in altre lingue. Questi sono usati per molti scopi incluso il caso importante in cui un membro di un gruppo di elementi altrimenti simili è speciale per qualsiasi motivo. Molto spesso ciò si traduce in istruzioni condizionali per distinguere tra elementi ordinari e il valore Null primitivo.

Questo oggetto mangia solo la mancanza dell'errore di attributo e puoi evitare di verificarne l'esistenza.

Non è altro che

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"

Con questo, se lo fai Null("any", "params", "you", "want").attribute_that_doesnt_exists()non esploderà, ma diventerà silenziosamente l'equivalente di pass.

Normalmente faresti qualcosa del genere

if obj.attr:
    obj.attr()

Con questo, fai semplicemente:

obj.attr()

e non pensarci più. Attenzione che un uso estensivo Nulldell'oggetto può potenzialmente nascondere bug nel codice.

Potresti anche voler leggere questo articolo (seleziona il file .pdf), che tratta i modelli di progettazione in linguaggi dinamici orientati agli oggetti (ad esempio Python). Per citare la pagina:

Questo documento esplora come i modelli della "Banda dei quattro", o libro "GOF", come viene spesso chiamato, compaiono quando problemi simili vengono affrontati usando un linguaggio di programmazione dinamico, di ordine superiore, orientato agli oggetti. Alcuni dei pattern scompaiono, ovvero sono supportati direttamente dalle funzionalità del linguaggio, alcuni sono più semplici o hanno un focus diverso e alcuni sono sostanzialmente invariati.