Les Conventions sur la création de constantes en Python

Je suis en train d'écrire une application qui a besoin de trouver le schéma d'une base de données, l'ensemble des moteurs. À cette fin, je suis en train d'écrire un petit adaptateur de base de données à l'aide de Python. J'ai décidé de commencer par écrire une classe de base qui décrit les fonctionnalités dont j'ai besoin, et puis le mettre en œuvre à l'aide de classes qui héritent de cette base. Le long du chemin, j'ai besoin de mettre en œuvre certaines constantes qui doivent être accessibles à travers toutes ces classes. Certaines de ces constantes doivent être combinées à l'aide de style C OU au niveau du bit.

Ma question est,

ce qui est la façon standard de partage de ces constantes?
quelle est la bonne façon de créer des constantes qui peuvent être combinés? Je me réfère à MAP_FIXED | MAP_FILE | MAP_SHARED code de style que C le permet.

Pour le premier, je suis venu à travers les threads où toutes les constantes ont été mis dans un module premier. Pour ce dernier, j'ai brièvement pensé à utiliser un dict de booléens. Ces deux semblait trop difficile. J'imagine que c'est assez courant, et pense que certaines bon moyen doit en effet exister!

OriginalL'auteur susmits | 2011-08-16

coding-style python

16

ce qui est la façon standard de partage de ces constantes?

Tout au long de la bibliothèque standard, la méthode la plus courante consiste à définir des constantes comme les variables de niveau module à l'aide de UPPER_CASE_WITH_UNDERSCORES noms.

quelle est la bonne façon de créer des constantes qui peuvent être combinés? Je me réfère à MAP_FIXED | MAP_FILE | MAP_SHARED code de style que C le permet.

Les mêmes règles que dans C s'appliquent. Vous devez vous assurer que chaque valeur de la constante correspond à un seul et unique bits, c'est à dire des pouvoirs de 2 (2, 4, 8, 16, ...).

La plupart du temps, les gens utilisent des nombres hexadécimaux pour cela:
```
OPTION_A = 0x01
OPTION_B = 0x02
OPTION_C = 0x04
OPTION_D = 0x08
OPTION_E = 0x10
# ...
```
Certains préfèrent un plus lisible par l'homme, le style, le calcul de la constante de valeurs dynamiquement à l'aide d'opérateurs de décalage:
```
OPTION_A = 1 << 0
OPTION_B = 1 << 1
OPTION_C = 1 << 2
# ...
```
En Python, vous pouvez également utiliser la notation binaire pour rendre le tout encore plus évident:
```
OPTION_A = 0b00000001
OPTION_B = 0b00000010
OPTION_C = 0b00000100
OPTION_D = 0b00001000
```
Mais depuis cette notation est long et difficile à lire, à l'aide hexadécimal ou binaire changement de notation est probablement préférable.

OriginalL'auteur Ferdinand Beyer
14

Constantes vont généralement au niveau du module. De PEP 8:

Constantes

Constantes sont généralement définis sur un module de niveau et à l'écrit dans toutes les lettres majuscules avec des traits de soulignement séparant les mots. Les exemples incluent MAX_OVERFLOW et TOTAL.

Si vous voulez des constantes au niveau de la classe, de les définir comme des propriétés de la classe.

OriginalL'auteur Mike DeSimone
3

Vous trouverez souvent des constantes au niveau mondial, et ils sont l'un des quelques variables qui existent là-haut. Il y a aussi des gens qui écrivent Constante des espaces de noms à l'aide dicts ou des objets comme cette
```
class Const:
    x = 33

Const.x
```
Il y a des gens qui les ont mis dans des modules et d'autres qui s'attachent comme des variables de classe que les instances d'accès. La plupart du temps, ses goûts personnels, mais seulement quelques variables globales ne pouvez pas vraiment de mal que bien.

OriginalL'auteur Jakob Bowyer

Stdlib est une grande source de connaissances exemple de ce que vous voulez peut être trouvé dans doctest code:

OPTIONS = {}

# A function to add (register) an option.
def register_option(name):
    return OPTIONS.setdefault(name, 1 << len(OPTIONS))

# A function to test if an option exist.
def has_option(options, name):
    return bool(options & name)

# All my option defined here.
FOO = register_option('FOO')
BAR = register_option('BAR')
FOOBAR = register_option('FOOBAR')


# Test if an option figure out in `ARG`.
ARG = FOO | BAR
print has_option(ARG, FOO)
# True
print has_option(ARG, BAR)
# True
print has_option(ARG, FOOBAR)
# False

N. B: Le module re également utiliser bit-wise argument de style aussi, si vous voulez un autre exemple.

OriginalL'auteur mouad

De nommage est généralement UPPERCASE_WITH_UNDERSCORE, et ils sont généralement de niveau module, mais parfois ils vivent dans leur propre classe. Une bonne raison d'être dans une classe, c'est quand les valeurs sont spéciales, telles que besoin d'être des puissances de deux:

class PowTwoConstants(object):
    def __init__(self, items):
        self.names = items
        enum = 1
        for name in items:
            setattr(self, name, enum)
            enum <<= 1

constants = PowTwoConstants('ignore_case multiline newline'.split())
print constants.newline # prints 4

Si vous voulez être en mesure d'exporter ces constantes au niveau du module (ou tout autre espace de noms), vous pouvez ajouter les lignes suivantes à la classe:

    def export(self, namespace):
        for name in self.names:
            setattr(namespace, name, getattr(self, name))

et puis

import sys
constants.export(sys.modules[__name__])

OriginalL'auteur Ethan Furman

Vous devez vous connecter pour publier un commentaire.