In python, come memorizzare 'costanti' per le funzioni solo una volta?

Question

Alcune funzioni richiedono valori "costanti" (cioè non progettati per essere ridefiniti in un secondo momento) che non devono essere parametrizzati. Mentre gli argomenti predefiniti sono stored only once per each function, alcuni non sono molto significativi per essere inseriti come parametri (ad esempio, per far parte dello signature). Per esempio (non molto utile):

def foo(bar): 
    my_map = {"rab": barType, "oof": fooType} 
    return my_map.get(bar,defaultType)() 

Ha sprecato tempo CPU e spazio RAM per ridefinire una costante di questo tipo per ogni chiamata. Alcuni altri modi sono di memorizzare costanti come le globali a livello di modulo o rendere la funzione una classe richiamabile, ma potrebbero esserci altri modi, forse?

Nel fare livello di modulo maniera globale, ho prefisso mia (inteso come) variabile costante con un "_" per mostrare che è lì non per interesse di nessuno. Ancora sento il namespace del modulo leggermente "inquinato", per non parlare della shame of using qualcosa as discouraged as globals affatto:

_my_map = {"rab": barType, "oof": fooType} 
def foo(bar): 
    return _my_map.get(bar,defaultType)() 

O il trasformarla in una classe modo. Faccio il __call__ un classmethod, per evitare la necessità di istanze che creano:

class foo: 
    my_map = {"rab": barType, "oof": fooType} 
    @classmethod 
    def __call__(cls,bar): 
     return cls.my_map.get(bar,defaultType)() 

Sono queste soluzioni Pythonic abbastanza?

Ci sono altri modi per farlo?

È anche una pratica regolare utilizzare tali "costanti"?

Nota questi oggetti nei miei esempi non sono necessariamente reali costanti, ma utilizzato (e potrebbe essere pensato) come tali dai loro scopo.

Answer 1

Imposta come un attributo della funzione:

def foo(bar): 
    return foo.my_map.get(bar, defaultType)() 
foo.my_map = {"rab": barType, "oof": fooType} 

 

Una classe callable o una chiusura non è abbastanza semplice IMO.

Answer 2

Si potrebbe anche usare le chiusure:

def make_foo(): 
    my_map = {"rab": barType, "oof": fooType} 
    def foo(bar): 
     return my_map.get(bar,defaultType)() 
    return foo 
foo = make_foo() 

Answer 3

IMHO, non c'è niente di sbagliato con le costanti livello di modulo.

Nota che secondo PEP8, costanti dovrebbe essere tutto in maiuscolo, come questo:

_MY_MAP = {"rab": barType, "oof": fooType} 
def foo(bar): 
    return _MY_MAP.get(bar,defaultType)() 

Il modulo espressione regolare nella libreria standard utilizza questo stile e molte librerie di terze parti stabilite fare pure. Se non siete convinti, basta andare al vostro site-packages directory e grep:

egrep "^_?[A-Z]+ =" * 

Answer 4

di fare qualcosa che sia il più autosufficiente possibile.È possibile creare un (aka functor) Classe function object e dargli un metodo __call__()o un classmethod (ma probabilmente non entrambi):

class bazType(object): pass 
class barType(object): pass 
class fooType(object): pass 

class Foo(object): 
    _DEFAULT_TYPE = bazType 
    _MY_MAP = {"rab": barType, "oof": fooType} 

    def __call__(self, bar): 
     return self._MY_MAP.get(bar, self._DEFAULT_TYPE)() 

    @classmethod 
    def foo(cls, bar): 
     return cls._MY_MAP.get(bar, cls._DEFAULT_TYPE)() 

# using classmethod 
print Foo.foo("rab") 

# using __call__ method 
foo = Foo() 
print foo("baz") 

# alternative way to use classmethod 
foo = Foo.foo 
print foo("oof") 

Ancora un'altra alternativa potrebbe essere quella di definire un staticmethod, che ho vinto Illustrare perché è così simile agli altri due - ma tu hai l'idea che spero.