How to refer to current class object

Python Help
1

Is there some way I can refer to the current class object from within itself before it’s definition is completed? I have found a number of times where it would be very useful to be able to reference the currently running code object, something like ‘self’ but obviously not that. See code below which fails because ‘myClass’ is not defined at the time it is referenced:

class myClass():

    Var1 = 0

    @classmethod
    def func1():
        print("In func1")
        myClass.Var1 += 1

    myClass.func1()
    print(myClass.Var1)
2

Shouldn’t the classmethod have a parameter taking the class?

3

You’re almost there, but you need to add an argument to your classmethod which will implicitly receive the class. See the docs here.

>>> class MyClass:
...     Var1 = 0
...
...     @classmethod
...     def func1(cls):
...         print("In func1")
...         cls.Var1 += 1
...
>>> MyClass.func1()
In func1
>>> MyClass.Var1
1
>>>
4

@Monarch No, you moved the last two lines out of the class.

5

No, the class does not yet exists. You will need to solve your underlying problem in a different way. What does exists is the local namespace, of which a writable view can be accessed with locals()

6

That’s the problem here. I want to encapsulate everything inside the class definition as that is just good object oriented practice but Python doesn’t seem to allow this.

7

I am quite curious where you’ve learned this practice - it does not align at all with what I’ve been taught about encapsulation, but I also didn’t have the greatest education so perhaps I’m just unfamiliar with this particular practice. To mii, running code with these sorts of side effects inside a class definition seems well outside of the paradigm haha

8

Consider the following where I would like the timer to start when the class is imported rather than each time it is instantiated. However this won’t work because at the time of it’s definition there is no ‘self’:

class MyAsyncTimer:

    count: int = 0

    def CleanupRoutine(self):
        print("In CleanupRoutine")
        while True:
            print("count=", self.count)
            self.count += 1
            time.sleep(1)

    t = threading.Thread(target=CleanupRoutine, daemon=True)
    t.start()
9

This shouldn’t be in a class. Just make it a regular function, nothing more.

10

Why would you want this behavior? I don’t really understand the use case here.

Edit: To be clear, that’s an earnest question. It does seem like you have some use case in mind, I’m just not seeing it yet.

11

In Python, this is done by calling a function or class at the module level:

class MyAsyncTimer:
    def __init__(self):
        self.count = 0

    def start(self):
        t = threading.Thread(target=self._cleanup_routine, daemon=True)
        t.start()

    def _cleanup_routine(self):
        print("In CleanupRoutine")
        while True:
            print("count=", self.count)
            self.count += 1
            time.sleep(1)

MyAsyncTimer().start()  # runs at import time
12

Note the following code does work, tested in Python 3.14

>>> class myClass():
... 
...     Var1 = 0
... 
...     @staticmethod
...     def func1():
...         print("In func1")
...         myClass.Var1 += 1
... 
... myClass.func1()
... print(myClass.Var1)
13

If you want to visit the external class itself in the class code straightly, it is impossible because that in this time, the class is not created. You need to use a function and visit it in the function. Of course, it is better to add staticmethod. If you use cls as the parameter in classmethod, it may be the subclass.

14

@warden Your code example has raised a, new to me, piece of information and that is that init runs not just when an instance is created but also when the first class method is run.

15

@NickC Hmm? It runs there because of the instance creation.

16

@Stefan2 But I didn’t think that code was creating an instance, just running a class method.

My understanding is that MyAsyncTimer().start() is just running the class method, not creating an instance or it?

17

MyAsyncTimer().start() is a contraction of

inst = MyAsyncTimer()
inst.start()

MyAsyncTimer()is the part that instantiates the class (and runs _init_) in both cases.

start() is an instance method, not a classmethod. Those are something different.

18

@warden making start an @classmethod doesn’t make any difference, it still runs init which I find difficult to understand as it is not creating an instance of the class, merely running a class method.

19 
MyAsyncTimer()

is the part the instantiates a class. It doesn’t matter if you call an instance method or a classmethod on this instance afterwards: _init_ has already run. You can check by not calling start at all.

20

Is there any logical reason why a class is not available to the code within itself at load time or is this just a side-effect of the way Python is currently implemented? Could Python be changed so that it is available?

In the code below you can see that ‘myClass’ is listed in locals() but for some reason just cannot be accessed at this time.

class myClass:

    Var1 = 0

    print(locals())
    thisObjA = sys._getframe(0)
    thisObjB = inspect.currentframe()
    print(f"{thisObjA=}")
    print(f"{thisObjB=}")