Is there a static constructor or static initializer in Python?

Hint: anything that references self is going to require an instantiation of the class. You could do it like this:

class App:
    email_queue = EmailQueue()

App.email_queue.do_something()

But come on, that seems like a lot of fluff. I'm with SLaks, just initialize it outside of the class. Alternatively, you could look into the singleton pattern.

There's a fundamental difference between static and dynamic languages that isn't always apparent at first.

In a static language, the class is defined at compile time and everything is all nice and set in concrete before the program ever runs.

In a dynamic language, the class is actually defined at runtime. As soon as the interpreter parses and starts executing all of those classes and def statements, the equivalent of a static constructor is being run. The class definitions are being executed at that point.

You can put any number of statements anywhere inside the class body and they are in effect a static constructor. If you want, you can place them all in a function that doesn't take self as a parameter, and call that function at the end of the class.

You can use the class method - see @classmethod decorator in the the code sample bellow:

class A(object):
    _some_private_static_member = None

    @classmethod
    def reset_static_data_members(cls, some_value):
        cls._some_private_static_member = some_value

A.reset_static_data_members("some static value")

However, be aware, that this is most probably something you do NOT want to do, since it modifies state of type - so it will affect all further calls to methods of that type which use/depend-on the changed static class data members. Situation can get nasty if such static class data members are accessed & set via self. in instances of such class when you will easily get unexpected behaviour.

Really correct way to do this (or the common sense way which most developers expect that behavior will be), is to make sure the static data members will be set only once - during import (the analogical way static data member initialisation behave in C++, C#, Java). Python has mechanism for that- the in-place initialisation:

class A(object):
    _some_private_static_member_0 = "value 0"
    _some_private_static_member_1 = "value 1"

Potentially you can initialise the static class members with return values from functions which abstract out (of the class) more complex value generation:

class A(object):
    _some_private_static_member_0 = some_function_0()
    _some_private_static_member_1 = some_function_1()

I create a static_init decorator which calls a static_init class method if it exists.

Here is the decorator and example of how to use it to initialize a class variable on an enum class:

# pylint: disable=missing-docstring,no-member

import enum

def static_init(cls):
    if getattr(cls, "static_init", None):
        cls.static_init()
    return cls

@static_init
class SomeEnum(enum.Enum):
    VAL_A = enum.auto()
    VAL_B = enum.auto()
    VAL_C = enum.auto()
    VAL_D = enum.auto()

    @classmethod
    def static_init(cls):
        text_dict = {}
        setattr(cls, 'text_dict', text_dict)
        for value in cls:
            text_dict[value.name.lower().replace("_", " ").title()] = value

def test_static_init():
    assert SomeEnum.text_dict["Val A"] == SomeEnum.VAL_A
    assert SomeEnum.text_dict["Val B"] == SomeEnum.VAL_B
    assert SomeEnum.text_dict["Val C"] == SomeEnum.VAL_C
    assert SomeEnum.text_dict["Val D"] == SomeEnum.VAL_D