Importer une longue liste de constantes dans un fichier Python

En Python, existe-t-il un analogue de l' Cinstruction du préprocesseur tel que?:

#define MY_CONSTANT 50

De plus, j'ai une grande liste de constantes que j'aimerais importer dans plusieurs classes. Existe-t-il un analogue de la déclaration des constantes comme une longue séquence d'instructions comme celle ci-dessus dans un .pyfichier et de son importation dans un autre .pyfichier?

Éditer.

Le fichier Constants.pylit:

#!/usr/bin/env python
# encoding: utf-8
"""
Constants.py
"""

MY_CONSTANT_ONE = 50
MY_CONSTANT_TWO = 51

Et myExample.pylit:

#!/usr/bin/env python
# encoding: utf-8
"""
myExample.py
"""

import sys
import os

import Constants

class myExample:
    def __init__(self):
        self.someValueOne = Constants.MY_CONSTANT_ONE + 1
        self.someValueTwo = Constants.MY_CONSTANT_TWO + 1

if __name__ == '__main__':
    x = MyClass()

Éditer.

Depuis le compilateur,

NameError: "le nom global 'MY_CONSTANT_ONE' n'est pas défini"

function init dans monExemple à la ligne 13 self.someValueOne = Constants.MY_CONSTANT_ONE + 1 sortie de copie Programme sorti avec le code # 1 après 0,06 seconde.

Python n'est pas prétraité. Vous pouvez simplement créer un fichier myconstants.py:

MY_CONSTANT = 50

Et les importer fonctionnera simplement:

import myconstants
print myconstants.MY_CONSTANT * 2

Python n'a pas de préprocesseur, ni de constantes dans le sens où elles ne peuvent pas être modifiées - vous pouvez toujours changer (presque, vous pouvez émuler des propriétés d'objet constantes, mais le faire pour des raisons de constance est rarement fait et non considéré comme utile) tout. Lors de la définition d'une constante, nous définissons un nom qui est en majuscules avec des traits de soulignement et l'appelons un jour - «Nous sommes tous des adultes consentants ici», aucun homme sensé ne changerait une constante. À moins bien sûr qu'il ait de très bonnes raisons et qu'il sache exactement ce qu'il fait, auquel cas vous ne pouvez pas (et ne devriez probablement pas) l'arrêter de toute façon.

Mais bien sûr, vous pouvez définir un nom au niveau du module avec une valeur et l'utiliser dans un autre module. Ce n'est pas spécifique aux constantes ou à quoi que ce soit, lisez le système de modules.

# a.py
MY_CONSTANT = ...

# b.py
import a
print a.MY_CONSTANT

Et bien sûr, vous pouvez faire:

# a.py
MY_CONSTANT = ...

# b.py
from a import *
print MY_CONSTANT

Bien sûr, vous pouvez placer vos constantes dans un module séparé. Par exemple:

const.py:

A = 12
B = 'abc'
C = 1.2

main.py:

import const

print const.A, const.B, const.C

Notez que comme mentionnées ci - dessus, A, Bet Csont des variables, par exemple peuvent être modifiés lors de l'exécution.

Essayez de chercher Créer des constantes en utilisant un module "paramètres"? et Puis-je empêcher la modification d'un objet en Python?

Un autre lien utile: http://code.activestate.com/recipes/65207-constants-in-python/ nous indique l'option suivante:

from copy import deepcopy

class const(object):

    def __setattr__(self, name, value):
        if self.__dict__.has_key(name):
            print 'NO WAY this is a const' # put here anything you want(throw exc and etc)
            return deepcopy(self.__dict__[name])
        self.__dict__[name] = value

    def __getattr__(self, name, value):
        if self.__dict__.has_key(name):
            return deepcopy(self.__dict__[name])

    def __delattr__(self, item):
        if self.__dict__.has_key(item):
            print 'NOOOOO' # throw exception if needed

CONST = const()
CONST.Constant1 = 111
CONST.Constant1 = 12
print a.Constant1 # 111
CONST.Constant2 = 'tst'
CONST.Constant2 = 'tst1'
print a.Constant2 # 'tst'

Vous pouvez donc créer une classe comme celle-ci, puis l'importer depuis votre module contants.py. Cela vous permettra d'être sûr que cette valeur ne sera pas modifiée, supprimée.

Au lieu d'utiliser l'approche d'importation décrite dans plusieurs réponses, jetez un œil au module configparser .

La classe ConfigParser implémente un langage d'analyseur de fichiers de configuration de base qui fournit une structure similaire à celle que vous trouveriez sur les fichiers INI de Microsoft Windows. Vous pouvez l'utiliser pour écrire des programmes Python qui peuvent être facilement personnalisés par les utilisateurs finaux.

Si vous voulez vraiment des constantes, pas seulement des variables ressemblant à des constantes, la manière standard de le faire est d'utiliser des dictionnaires immuables. Malheureusement, ce n'est pas encore intégré, vous devez donc utiliser des recettes tierces (comme celle-ci ou celle-là ).

créer un fichier de constante avec n'importe quel nom comme my_constants.py déclarer une constante comme ça

CONSTANT_NAME = "SOME VALUE"

Pour accéder à la constante dans votre fichier d'importation de code comme ça

import my_constants as constant

et accédez à la valeur constante comme -

constant.CONSTANT_NAME