constantes en Python: en la raíz del módulo o en un espacio de nombres dentro del módulo?

Question

Estoy construyendo un módulo de Python con aproximadamente cien constantes.

Me gustaría evitar problemas de nomenclatura cuando las personas importan mi módulo por lo que me preguntaba cuál sería la mejor manera de hacerlo.

MY_CONSTANT = 1 
MY_SECOND_CONSTANT = 2 
... 
MY2_CONSTANT = "a" 
MY2_SECOND_CONSTANT = "b" 
... 

O

class My: 
    CONSTANT = 1 
    SECOND_CONSTANT = 2 
    ... 

class My2 
    CONSTANT = "a" 
    SECOND_CONSTANT = "b" 
    ... 

O tal vez otro de sus sugerencias?

Viniendo de Java, que sin duda prefieren el segundo camino, pero algunos podrían encontrar una exageración ...

Answer 1

Bueno, depende. Por lo general, las constantes se definen a nivel de módulo. Pero si tiene muchas constantes para category_a y category_b, incluso podría tener sentido agregar un subpaquete constants con los módulos constants.category_a y constants.category_b.

Me abstendría de usar un class - podría ser instanciado, lo que no tendría sentido, y no tiene ninguna ventaja sobre un módulo aparte de permitir meter más de uno en un archivo físico (lo que probablemente no debería 't si hay tantas constantes). La versión de Java usaría una clase estática, pero el equivalente de Python es un módulo.

Los conflictos de nombres no son un problema en Python, excepto cuando import * - but you shouldn't do that anyway. Mientras no haya conflictos de nombres dentro del módulo, puede estar seguro de que el usuario no extraerá todos los nombres de su módulo ni los importará bajo un nombre que choca con otro módulo.

Answer 2

De style guide: Las constantes se definen generalmente en un nivel de módulo y se escriben en todos los letras mayúsculas y subrayado que separa palabras. Los ejemplos incluyen MAX_OVERFLOW y TOTAL.

Answer 3

Cada módulo proporciona su propio espacio de nombres, por lo que no es necesario crear otro.

Tener módulo foo.py:

FOO = 1 
BAR = 2 
SHMOO = 3

se puede utilizar de esta manera:

import foo 
foo.BAR

Answer 4

Si utiliza clases, puede prohibir la sobrescritura de constantes (o prohibir incluso agregar constantes a esa clase). También se aprovecha la ventaja de utilizar los archivos de clase sobre (módulos) cuando tiene muchos grupos y no necesita tener muchos archivos.

Por lo que se vería así:

class MyConstBaseClass: 
    """ 
    forbids to overwrite existing variables 
    forbids to add new values if "locked" variable exists 
    """ 
    def __setattr__(self,name,value): 
     if(self.__dict__.has_key("locked")):  
      raise NameError("Class is locked can not add any attributes (%s)"%name) 
     if self.__dict__.has_key(name): 
      raise NameError("Can't rebind const(%s)"%name) 
     self.__dict__[name]=value 

class MY_CONST_GRP1(MyConstBaseClass): 
    def __init__(self): 
     self.const1 = "g1c1" 
     self.const2 = "g1c2" 
my_const_grp1 = MY_CONST_GRP1() 

class MY_CONST_GRP2(MyConstBaseClass): 
    def __init__(self): 
     self.const1 = "g2c1" 
     self.const3 = "g2c3" 
     self.locked = 1 # this will create lock for adding constants 
my_const_grp2 = MY_CONST_GRP2() 

print my_const_grp1.const1 # prints "g1c1" 
print my_const_grp1.const2 # prints "g1c2" 
print my_const_grp2.const1 # prints "g2c1" 
print my_const_grp2.const3 # prints "g2c3" 
my_const_grp1.new_constant = "new value" #adding constants is allowed to this group 
#my_const_grp1.const1 = "new value" #redefine would raise an error 
#my_const_grp2.new_constant = "first value" #adding constant is also forbidden 
#my_const_grp2.const1 = "new value" #redefine would raise an error 

Here is simillar example