Importazione di un lungo elenco di costanti in un file Python

In Python, esiste un analogo Cdell'istruzione del preprocessore come ?:

#define MY_CONSTANT 50

Inoltre, ho un ampio elenco di costanti che vorrei importare in diverse classi. Esiste un analogo della dichiarazione delle costanti come una lunga sequenza di istruzioni come quella sopra in un .pyfile e dell'importazione in un altro .pyfile?

Modificare.

Il file Constants.pylegge:

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

MY_CONSTANT_ONE = 50
MY_CONSTANT_TWO = 51

E myExample.pylegge:

#!/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()

Modificare.

Dal compilatore,

NameError: "il nome globale" MY_CONSTANT_ONE "non è definito"

function init in myExample alla riga 13 self.someValueOne = Constants.MY_CONSTANT_ONE + 1 copia output Programma terminato con codice # 1 dopo 0,06 secondi.

Python non è preelaborato. Puoi semplicemente creare un file myconstants.py:

MY_CONSTANT = 50

E importarli funzionerà:

import myconstants
print myconstants.MY_CONSTANT * 2

Python non ha un preprocessore, né ha costanti nel senso che non possono essere modificate: puoi sempre cambiare (quasi, puoi emulare proprietà costanti dell'oggetto, ma farlo per amore della costanza è raramente fatto e non ritenuto utile) tutto. Quando definiamo una costante, definiamo un nome che è maiuscolo con trattini bassi e lo chiamiamo giorno: "Siamo tutti adulti consenzienti qui", nessun uomo sano di mente cambierebbe una costante. A meno che ovviamente non abbia ottime ragioni e sappia esattamente cosa sta facendo, nel qual caso non puoi (e probabilmente non dovresti) fermarlo in entrambi i casi.

Ma ovviamente puoi definire un nome a livello di modulo con un valore e usarlo in un altro modulo. Questo non è specifico per le costanti o altro, leggi sul sistema del modulo.

# a.py
MY_CONSTANT = ...

# b.py
import a
print a.MY_CONSTANT

E naturalmente puoi fare:

# a.py
MY_CONSTANT = ...

# b.py
from a import *
print MY_CONSTANT

Certo, puoi mettere le tue costanti in un modulo separato. Per esempio:

const.py:

A = 12
B = 'abc'
C = 1.2

main.py:

import const

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

Si noti che, come dichiarato in precedenza, A, Be Csono variabili, cioè possono essere modificate in fase di esecuzione.

Prova a cercare creare costanti utilizzando un modulo "impostazioni"? e posso impedire la modifica di un oggetto in Python?

Un altro collegamento utile: http://code.activestate.com/recipes/65207-constants-in-python/ ci parla della seguente opzione:

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'

Quindi potresti creare una classe come questa e poi importarla dal tuo modulo contants.py. Ciò ti consentirà di essere sicuro che il valore non verrà modificato, eliminato.

In alternativa all'utilizzo dell'approccio di importazione descritto in diverse risposte, dai un'occhiata al modulo configparser .

La classe ConfigParser implementa un linguaggio parser di file di configurazione di base che fornisce una struttura simile a quella che si trova nei file INI di Microsoft Windows. Puoi usarlo per scrivere programmi Python che possono essere personalizzati facilmente dagli utenti finali.

Se vuoi davvero le costanti, non solo le variabili che sembrano costanti, il modo standard per farlo è usare dizionari immutabili. Sfortunatamente non è ancora integrato, quindi devi usare ricette di terze parti (come questa o quella ).

crea un file costante con qualsiasi nome come my_constants.py dichiara costante in questo modo

CONSTANT_NAME = "SOME VALUE"

Per accedere alla costante nel tuo file di importazione del codice in questo modo

import my_constants as constant

e accedi al valore costante come -

constant.CONSTANT_NAME