0

I'm writing a class, which has some class variables, which are required for a class method, so it's not an option to make them instance variables. Some of those class variables are dictionaries, with (partially) the same keys, which could be easily defined by writing the first dict manually and then using dict comprehensions to create the other ones.

My idea was something like

class MyClass:
    A: dict = { some manually written items }
    B: dict = { k: *stuff containing A[k]* for k in { *subset of keys from A* } }
    *some more dicts like this*

My hope was, that when the interpreter is reading the class body from top to bottom, A would be in scope while interpreting the expression for B but that proved to be wrong and the class object also cannot be accessed, while the interpretation of the same class isn't completed yet.

Does python have a way to solve this, like, let's say, a method similar to __init__ but that isn't called after the instantiation of the class but right after the interpretation?

Niclas
  • 66
  • 6
  • 1
    Can't use a comprehension because of the way that class scope works. Just use a for-loop – juanpa.arrivillaga Aug 03 '22 at 23:25
  • I had no idea, I could write entire loops directly inside the class body. Also it isn't obvious, that it solves this problem, but it works. Thanks! – Niclas Aug 03 '22 at 23:42
  • Yep, a class body is a code block that is executed at runtime. The one thing is it doesn't create an enclosing scope, which is why you cannot access variables defined in the class body from a method, for example (and why you need `self.whatever`). Since comprehensions basically just use a function scope (use `dis` to see) it can't access those variables just like in methods! – juanpa.arrivillaga Aug 04 '22 at 01:15

0 Answers0