Vfrdtyky

I am writing a program in python which contains many constant variables. I would like to create a file which will hold all these variables like .h file in C that contains many #define. I tried to use configparser however I didn't find it easy and fun to use.

Do you know a better way?

Python is not allowing constants declaration like in C or C++.

Normally in Python, constants are capitalized (PEP 8 standards) which helps the programmer know it's a constant.

Ex. MY_CONSTANT = "Whatever"

Another valid way of doing it which I don't use but heard of, is using a method:

def MY_CONSTANT():

    return "Whatever"

Now in theory, calling MY_CONSTANT() acts just like a constant.

EDIT

Like the comments says, someone can go and change the value by calling

MY_CONSTANT = lambda: 'Something else'

but don't forget the same person can call MY_CONSTANT = "Something else" in the first example and change the initial value. In both cases it is unlikely but possible.

There are no constants in Python, the way they exist in C or Java. You can imitate them by functions:

def FOO():

  return "foo"

You can wrap the function call in a property, and thus make it look like a variable:

class Const:

  @property

  def FOO(self):

    return "foo"



CONST = Const()  # You need an instance



if something == CONST.FOO:

  ...

With a bit of meta stuff, one can get unsettable attributes with a terse syntax:

def const(cls):

    # Replace a class's attributes with properties,

    # and itself with an instance of its doppelganger.

    is_special = lambda name: (name.startswith("__") and name.endswith("__"))

    class_contents = {n: getattr(cls, n) for n in vars(cls) if not is_special(n)}

    def unbind(value):  # Get the value out of the lexical closure.

        return lambda self: value

    propertified_contents = {name: property(unbind(value))

                             for (name, value) in class_contents.items()}

    receptor = type(cls.__name__, (object,), propertified_contents)

    return receptor()  # Replace with an instance, so properties work.





@const

class Paths(object):

    home = "/home"

    null = "/dev/null"

Now you can access Paths.home as a normal value, but can't assign to it. You can define several classes decorated with @const, as you might use several .h files.

You can use something like this:

Files structure:

myapp/

    __init__.py

    settings.py

    main.py

settings.py

CONST_A = 'A'

CONST_B = 'B'

__init__.py

from . import settings as global_settings





class Settings:



def __init__(self):

    for setting in dir(global_settings):

        if setting.isupper():

            setattr(self, setting, getattr(global_settings, setting))



def __setattr__(self, attr, value):

    if not getattr(self, attr, None):

        super().__setattr__(attr, value)

    else:

        raise TypeError("'constant' does not support item assignment")





settings = Settings()

main.py

import settings



print(settings.CONST_A)  # prints A



settings.CONST_A = 'C'  # raises TypeError error



print(settings.CONST_A)  # prints A



settings.CONST_C = 'C'  # also able to add new constants

print(settings.CONST_C)  # prints C

Overwritten __setattr__ in Settings class makes all the attributes read-only.
The only requirement is to have all the constants in your settings.py written in capital letters.
But be aware, that it's not gonna work if you import variables directly:

from settings import CONST_A



print(settings.CONST_A)  # prints A



settings.CONST_A = 'C'  # sets C



print(settings.CONST_A)  # prints C