Importer une longue liste de constantes dans un fichier Python
en Python, y a-t-il un analogue du préprocesseur C tel que?:
#define MY_CONSTANT 50
Aussi, j'ai une grande liste de constantes j'aimerais importer à plusieurs classes. Est-il un analogue de déclarer les constantes comme une longue séquence d'instructions comme ci-dessus dans un .py fichier et l'importer dans un autre .py fichier?
Edit.
Le fichier Constants.py se lit comme suit:
#!/usr/bin/env python
# encoding: utf-8
"""
Constants.py
"""
MY_CONSTANT_ONE = 50
MY_CONSTANT_TWO = 51
et myExample.py se lit:
#!/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()
Edit.
du compilateur,
NameError: "nom global "MY_CONSTANT_ONE" n'est pas défini "
fonction init dans mon exemple à la ligne 13 auto.someValueOne = Constantes.MY_CONSTANT_ONE + 1 copie programme de sortie sorti avec le code #1 après de 0,06 secondes.
7 réponses
Python n'est pas pré-traité. Vous pouvez juste créer un fichier myconstants.py :
MY_CONSTANT = 50
et leur importation ne fera que fonctionner:
import myconstants
print myconstants.MY_CONSTANT * 2
Python n'a pas de préprocesseur, pas plus qu'il n'a de constantes dans le sens où elles ne peuvent pas être changées - vous pouvez toujours changer (presque, vous pouvez émuler les propriétés des objets constants, mais faire cela pour le bien de la constante-ness est rarement fait et n'est pas considéré comme utile) tout. En définissant une constante, nous définissons un nom qui est majuscule-avec-souligne et l'appelons un jour-"nous sommes tous des adultes consentants ici", aucun homme sain d'esprit ne changerait une constante. A moins bien sûr qu'il ait de très bons les raisons et sait exactement ce qu'il fait, dans ce cas, vous ne pouvez pas (et ne devriez 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 sur le système du module.
# a.py
MY_CONSTANT = ...
# b.py
import a
print a.MY_CONSTANT
bien sûr, vous pouvez mettre 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 déclaré ci-dessus, A , B et C sont des variables, c'est-à-dire qu'elles peuvent être modifiées au moment de l'exécution.
et bien sûr vous pouvez faire:
# a.py
MY_CONSTANT = ...
# b.py
from a import *
print MY_CONSTANT
comme une alternative à l'utilisation de l'approche d'importation décrite dans plusieurs réponses, ont un regard sur le module configparser .
la classe ConfigParser implémente un langage d'analyse de fichier de configuration de base qui fournit une structure similaire à ce que vous trouverez sur les fichiers INI de Microsoft Windows. Vous pouvez l'utiliser pour écrire des programmes Python qui peuvent être personnalisés par les utilisateurs finaux facilement.
Essayer pour voir Créer des constantes à l'aide d'un "paramètres" module? et puis-je empêcher de modifier un objet en Python?
un autre lien utile: http://code.activestate.com/recipes/65207-constants-in-python / nous parle de 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'
pour que vous puissiez créer une classe comme celle-ci et ensuite l'importer de vous contants.py module. Cela vous permettra pour être sûr que cette valeur ne serait pas changé, supprimé.
si vous voulez vraiment des constantes, pas seulement des variables ressemblant à des constantes, la façon standard de le faire est d'utiliser des dictionnaires immuables. Malheureusement, il n'est pas encore intégré, donc vous devez utiliser des recettes de tiers (comme celui-ci ou celui-là ).