Python - Best/Cleanest way to define constant lists or dictionarys

Question

First time user on stack overflow and I'm excited to be here.

INTRO: I recently began the magical adventure into the world of Python programming - I love it. Now everything has gone smoothly in my awkward transition from C, but I'm having trouble creating something which would be synonymous to a HEADER file (.h).

PROBLEM: I have medium sized dictionaries and lists (about 1,000 elements), lengthy enums, and '#defines' (well not really), but I can't find a CLEAN way to organize them all. In C, I would throw them all in a header file and never think again about it, however, in Python that's not possible or so I think.

CURRENT DIRTY SOLUTION: I'm initializing all CONSTANT variables at the top of either the MODULE or FUNCTION (module if multiple functions need it).

CONCLUSION: I would be forever grateful if someone had come up with a way to CLEANLY organize constant variable's.

THANK YOU SO MUCH!

I just wanted to say, welcome to Stack, and thanks for starting out on here with a well organized question! — jdi, Jun 20 '12 at 01:26

score 27 · Answer 1 · answered Jun 20 '12 at 01:23

27

Put your constants into their own module:

# constants.py

RED = 1
BLUE = 2
GREEN = 3

Then import that module and use the constants:

import constants

print "RED is", constants.RED

The constants can be any value you like, I've shown integers here, but lists and dicts would work just the same.

answered Jun 20 '12 at 01:23

Ned Batchelder

364,293
75
561
662

Great idea. Do you know what the latency or efficiency loss is like? Because technically you're importing it and doesn't that require a look-up every time you reference the value? – TSmith Jun 20 '12 at 01:30
You're doing an attribute lookup each time, which is the kind of operation that happens all the time anyway, it really isn't something to worry about. – Ned Batchelder Jun 20 '12 at 01:31
1

@TSmith: And if you are super concerned with shaving off that little bit of time, you can always do `from constants import RED`, or assign it to a variable just before a super long loop: `red = constants.RED` – jdi Jun 20 '12 at 01:35
Thank you Ned and jdi! I really appreciate it and yeah jdi that's more of what I wanted to hear, but will a local variable get a copy or a reference to the globally imported constant? Just out of curiosity. – TSmith Jun 20 '12 at 01:37
@TSmith: don't go crazy with optimizations. Chances are good your code isn't compute-bound, for example. – Ned Batchelder Jun 20 '12 at 01:42
No it's not by any means but I'm trying to get a feel for pythons personality if you know what I'm saying. – TSmith Jun 20 '12 at 01:47
This doesn't seem to work for me. I've done as suggested, putting all my constants in a file constants.py, importing them at the beginning of my script with import constants, but for some reason the constants are visible everywhere except in the main() function. When I try to use `print constants.NUM_CELLS` in main(), I get `UnboundLocalError: local variable 'constants' referenced before assignment` – Bill Dec 28 '14 at 21:57

score 13 · Answer 2 · answered Jun 20 '12 at 01:24

13

Usually I do this:

File: constants.py

CONSTANT1 = 'asd'
CONSTANT_FOO = 123
CONSTANT_BAR = [1, 2, 5]

File: your_script.py

from constants import CONSTANT1, CONSTANT_FOO
# or if you want *all* of them
# from constants import *

...

Now your constants are in one file and you can nicely import and use them.

answered Jun 20 '12 at 01:24

Blender

289,723
53
439
496

Thank you, CC'ing you to the efficiency question if you can help. – TSmith Jun 20 '12 at 01:34
If you import all of them, the constants become global variables and won't require a lookup. Do note that Python is about 200 times slower than C so you won't notice much of a speed boost if you try to micro optimize. – Blender Jun 20 '12 at 01:37
Thank you blender. Quick curiosity question, if I assign a local variable (within a function) to that imported global variable, will that local var have a copy or a reference to the global? – TSmith Jun 20 '12 at 01:45
@TSmith: It will have a reference, but take note that the behavior will depend on whether its a mutable or immutable type. If its a string, any changes you make to that local will simply shadow the global constant. If the constant is say a list object, you can append to the local var and it will reflect in the constant because its still the same reference – jdi Jun 20 '12 at 01:48
@jdi: Yeah I learned about mutable and immutable types the hard way haha. Thank you so much for the help, I seriously appreciate it. – TSmith Jun 20 '12 at 01:52

score 5 · Answer 3 · answered Jun 20 '12 at 01:24

5

Make a separate file constants.py, and put all globally-relevant constants in there. Then you can import constants to refer to them as constants.SPAM or do the (questionable) from constants import * to refer to them simply as SPAM or EGGS.

While we're here, note that Python doesn't support constant constants. The convention is just to name them in ALL_CAPS and promise not to mutate them.

answered Jun 20 '12 at 01:24

tsm

3,598
2
21
35

1

Haha yeah I promise :), but what about run time efficiency? When you import a module is that like "__inline" in C? – TSmith Jun 20 '12 at 01:32
@TSmith: I wouldn't compare it to an inline because its really just importing into a namespace module object, and it does it only once, and shares it in memory for subsequent imports. – jdi Jun 20 '12 at 01:39
Yes, that was a silly question now that I think about it. Thank you and have a great day! – TSmith Jun 20 '12 at 01:50

Mark Z. · Answer 4 · 2021-08-25T17:19:17.490

Accepted answer is fine, to take it one step further can use typings when defining your constants; you could just specify Final, or go a step further and provide Final[type] as well, e.g.:

from typing import Final, List
CONSTANT1: Final = 'asd'
CONSTANT_FOO: Final[int] = 123
ADLS_ENVIRONMENTS: Final[List[str]] = ["sandbox", "dev", "uat", "prod"]

# etc.

See https://www.python.org/dev/peps/pep-0591/#the-final-annotation

score 0 · Answer 5 · answered Oct 23 '19 at 02:22

If you want to mess with nested constants and don't like dicts, I came up with this fun solution:

# Recursively transform a dict to instances of the desired class

import json
from collections import namedtuple

class DictTransformer():
    @classmethod
    def constantize(self, d):
        return self.transform(d, klass=namedtuple, klassname='namedtuple')

    @classmethod
    def transform(self, d, klass, klassname):
        return self._from_json(self._to_json(d), klass=klass, klassname=klassname)

    @classmethod
    def _to_json(self, d, access_method='__dict__'):
        return json.dumps(d, default=lambda o: getattr(o, access_method, str(o)))

    @classmethod
    def _from_json(self, jsonstr, klass, klassname):
        return json.loads(jsonstr, object_hook=lambda d: klass(klassname, d.keys())(*d.values()))

Ex:

constants = {
  'A': {
    'B': {
      'C': 'D'
    }
  }
}
CONSTANTS = DictTransformer.transform(d, klass=namedtuple, klassname='namedtuple')
CONSTANTS.A.B.C == 'D'

Pros:

handles nested dicts
can potentially generate other types of dicts/classes
namedtuples provide immutability for constants

Cons:

may not respond to .keys and .values if those are not provided on your klass (though you can sometimes mimic with ._fields and list(A.B.C))

Thoughts?

h/t to @hlzr and you guys for the original class idea

Python - Best/Cleanest way to define constant lists or dictionarys

5 Answers5

Linked