python: how to refer to the class from within it ( like the recursive function)

Question

For a recursive function we can do:

def f(i):
  if i<0: return
  print i
  f(i-1)

f(10)

However is there a way to do the following thin

Answer 1

Most code in the class will be inside method definitions, in which case you can simply use the name A.

Answer 2

If you want to refer to the same object, just use 'self':

class A:
    def some_func(self):
        another_func(self)

If you want to create a new object of the same class, just do it:

class A:
    def some_func(self):
        foo = A()

If you want to have access to the metaclass class object (most likely not what you want), again, just do it:

class A:
    def some_func(self):
        another_func(A) # note that it reads A, not A()

Answer 3

Maybe you could try calling __class__. Right now I'm writing a code that calls a class method from within the same class. It is working well so far.

I'm creating the class methods using something like:

@classmethod
    def my_class_method(cls):
       return None

And calling then by using:

x = __class__.my_class_method()

Answer 4

If you want to do just a little hacky thing do

class A(object):
    ...
some_func(A)

If you want to do something more sophisticated you can use a metaclass. A metaclass is responsible for manipulating the class object before it gets fully created. A template would be:

class AType(type):
    def __new__(meta, name, bases, dct):
        cls = super(AType, meta).__new__(meta, name, bases, dct)
        some_func(cls)
        return cls

class A(object):
    __metaclass__ = AType
    ...

type is the default metaclass. Instances of metaclasses are classes so __new__ returns a modified instance of (in this case) A.

For more on metaclasses, see http://docs.python.org/reference/datamodel.html#customizing-class-creation.

Answer 5

You can't with the specific syntax you're describing due to the time at which they are evaluated. The reason the example function given works is that the call to f(i-1) within the function body is because the name resolution of f is not performed until the function is actually called. At this point f exists within the scope of execution since the function has already been evaluated. In the case of the class example, the reference to the class name is looked up during while the class definition is still being evaluated. As such, it does not yet exist in the local scope.

Alternatively, the desired behavior can be accomplished using a metaclass like such:

class MetaA(type):

    def __init__(cls):
        some_func(cls)

class A(object):
    __metaclass__=MetaA
  # do something
  # ...

Using this approach you can perform arbitrary operations on the class object at the time that the class is evaluated.

Answer 6

There isn't a way to do that within the class scope, not unless A was defined to be something else first (and then some_func(A) will do something entirely different from what you expect)

Unless you're doing some sort of stack inspection to add bits to the class, it seems odd why you'd want to do that. Why not just:

class A:
    # do something
    pass

some_func(A)

That is, run some_func on A after it's been made. Alternately, you could use a class decorator (syntax for it was added in 2.6) or metaclass if you wanted to modify class A somehow. Could you clarify your use case?