Importing a long list of constants to a Python file
PythonConstantsPython ImportPython Problem Overview
In Python, is there an analogue of the C
preprocessor statement such as?:
#define MY_CONSTANT 50
Also, I have a large list of constants I'd like to import to several classes. Is there an analogue of declaring the constants as a long sequence of statements like the above in a .py
file and importing it to another .py
file?
Edit.
The file Constants.py
reads:
#!/usr/bin/env python
# encoding: utf-8
"""
Constants.py
"""
MY_CONSTANT_ONE = 50
MY_CONSTANT_TWO = 51
And myExample.py
reads:
#!/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.
From the compiler,
> NameError: "global name > 'MY_CONSTANT_ONE' is not defined" > > function init in myExample at line > 13 self.someValueOne = > Constants.MY_CONSTANT_ONE + 1 copy > output Program exited with code #1 > after 0.06 seconds.
Python Solutions
Solution 1 - Python
Python isn't preprocessed. You can just create a file myconstants.py
:
MY_CONSTANT = 50
And importing them will just work:
import myconstants
print myconstants.MY_CONSTANT * 2
Solution 2 - Python
Python doesn't have a preprocessor, nor does it have constants in the sense that they can't be changed - you can always change (nearly, you can emulate constant object properties, but doing this for the sake of constant-ness is rarely done and not considered useful) everything. When defining a constant, we define a name that's upper-case-with-underscores and call it a day - "We're all consenting adults here", no sane man would change a constant. Unless of course he has very good reasons and knows exactly what he's doing, in which case you can't (and propably shouldn't) stop him either way.
But of course you can define a module-level name with a value and use it in another module. This isn't specific to constants or anything, read up on the module system.
# a.py
MY_CONSTANT = ...
# b.py
import a
print a.MY_CONSTANT
Solution 3 - Python
And ofcourse you can do:
# a.py
MY_CONSTANT = ...
# b.py
from a import *
print MY_CONSTANT
Solution 4 - Python
Sure, you can put your constants into a separate module. For example:
const.py:
A = 12
B = 'abc'
C = 1.2
main.py:
import const
print const.A, const.B, const.C
Note that as declared above, A
, B
and C
are variables, i.e. can be changed at run time.
Solution 5 - Python
Try to look https://stackoverflow.com/questions/3824455/python-constants and https://stackoverflow.com/questions/3711657/can-i-prevent-modifying-an-object-in-python
Another one useful link: http://code.activestate.com/recipes/65207-constants-in-python/ tells us about the following option:
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'
So you could create a class like this and then import it from you contants.py module. This will allow you to be sure that value would not be changed, deleted.
Solution 6 - Python
As an alternative to using the import approach described in several answers, have a look a the configparser module.
The ConfigParser class implements a basic configuration file parser language which provides a structure similar to what you would find on Microsoft Windows INI files. You can use this to write Python programs which can be customized by end users easily.
Solution 7 - Python
create constant file with any name like my_constants.py declare constant like that
CONSTANT_NAME = "SOME VALUE"
For accessing constant in your code import file like that
import my_constants as constant
and access the constant value as -
constant.CONSTANT_NAME
Solution 8 - Python
If you really want constants, not just variables looking like constants, the standard way to do it is to use immutable dictionaries. Unfortunately it's not built-in yet, so you have to use third party recipes (like this one or that one).
Solution 9 - Python
In commercial software, the constant(s) will frequently be buried many folders deep. Use solution below in combination with above solutions for best results. Here's the syntax that worked for me:
folder_a
folder_b
constants.py
# -----------
# constants.py
# ------------
MAXVAL = 1000
folder_c
folder_d
my_file.py
# ------------------------
# my_file.py
# ------------------------
import folder_a.folder_b.constants as consts
print(consts.MAXVAL)
Solution 10 - Python
You create a constant def / function and call it in any python script / different file. try def and set a value
Solution 11 - Python
In more recent editions, it seems a bit pickier.
the mode in the top answer
Main.py
import constants
print(token)
constants.py
enter code here
token = "12345"
failed. Instead, I had to import individual variable from constants.
Main.py
from constants import token
print(token)