Yes, a class can contain an instance of itself, you just can't create it on initiation for the reasons described by others.

For example, this class will do it:

class A:
    def __init__(self, value):
        self.value = value

    def setProperty(self, subvalue):
        self.innerInstance = A(subvalue)

You can then instantiate it and set its inner copy of itself like this:

>>> outerInstance = A(123)
>>> outerInstance.setProperty(456)

And verify it worked with:

>>> outerInstance.innerInstance.value
456

class Organism(object):
    def reproduce(self):
        #use self here to customize the new organism ...
        return Organism()

Another option -- if the instance (self) isn't used within the method:

class Organism(object):
    @classmethod
    def reproduce(cls):
        return cls()

This makes sure that Organisms produce more Organisms and (hypothetical Borgs which are derived from Organisms produce more Borgs).

A side benefit of not needing to use self is that this can now be called from the class directly in addition to being able to be called from an instance:

new_organism0 = Organism.reproduce()  # Creates a new organism
new_organism1 = new_organism0.reproduce()  # Also creates a new organism

Finally, if both the instance (self) and the class (Organism or subclasses if called from a subclass) are used within the method:

class Organism(object):
    def reproduce(self):
        #use self here to customize the new organism ...
        return self.__class__()  # same as cls = type(self); return cls()

In each case, you'd use it as:

organism = Organism()
new_organism = organism.reproduce()

No. annotations only applies to variable and function annotations. Until the class statement as been completely executed, there is no class Foo to instantiate. You must wait until after Foo is defined to create an instance of it.

class Foo:
    def __init__(self, name):
        self.name = name

Foo.BAR = Foo("bar")

You can always initialize BAR = None, then change the value of the attribute after the class is defined.

class Foo:
    BAR = None  # To be a Foo instance once Foo is defined
    ...

Foo.BAR = Foo("bar")  # Fulfilling our earlier promise

That might be desirable for documentation purposes, to make it clearer in the definition that Foo.BAR will exist, though with a different value. I can't think of a situation where that would be necessary, though.

m = self.__class__(sz-1, sz-1)

or

m = type(self)(sz-1, sz-1)

I figured out the answer to the question I had that brought me to this page. Since no one has actually suggested the answer to my question, I thought I'd post it.

class k:
  pass

a = k()
k2 = a.__class__
a2 = k2()

At this point, a and a2 are both instances of the same class (class k).

Well, it fails because it has infinite recursion. Think about it, if every MyClass has a child which is a MyClass, it will go on for infinity!

You can resolve this a couple of ways. First, you can have a parameter to the constructor:

class MyClass:
   def __init__(self, create = True):
      if create:
         self.child = MyClass(False)

mc = MyClass()

Or, you can have another, external method:

class MyClass:
    def set_child(self,child = None):
        # I prefer to make child optional for ease of use.
        child = MyClass() if child is None else child
        self.child=child

mc=MyClass()
mc.set_child()

I personally prefer the first solution as it means that outside objects don't need to know anything about the class. Of course, you could combine the two:

class MyClass:
    def __init__(self, create):
        if create:
            self.set_child(create=False)

    def set_child(self,child = None, create = True):
        child = MyClass(create) if child is None else child
        self.child=child

mc=MyClass()

This way mc has a child by default and you have the option of setting the child whenever you like.

Then there is also the "let's create a certain number" approach:

class MyClass:
    def __init__(self, count = 10):
        count -= 1
        if count:
           # the first child gets the value 9.
           # the second gets 8.
           # when the count gets to 0, stop!
           self.child = MyClass(count)

Aside: If you want to get an object's class, you can use the value obj.__class__. That will output MyClass in all of the examples above.

Given a Python class which will be instantiated only once, i.e. there will be only one object of the class. I was wondering in which cases it makes sense to create a single class instance instead of working directly with the class instead.

So it's this:

class Singleton:
    '''don't bother instantiating me'''
    clsvar1 = 'foo'

    @classmethod
    def foobar(cls, *args, **kwargs):
        if condition():
            cls.clsvar1 = 'bar'

versus this?

class Singleton:
    '''instantiate and use me'''
    def __init__(self):
        self.var1 = 'foo'

    def foobar(self, *args, **kwargs):
        if condition():
            self.var1 = 'bar'

Recommendation

I definitely would prefer the one that's intended to be instantiated. When you create a "type of thing" that implies that you create things of that type.

The motivation is to group related code and data and having an interface to it.

That said, why not just use a module since all you want is a namespace? Modules are singletons, group related code and data, and this is a bit simpler and probably would be considered more Pythonic:

var1 ='foo'

def foobar(*args, **kwargs):
    global var1
    if condition():
        var1 = 'bar'

So the usage would be instead of:

from modules.singleton import Singleton
Singleton.foobar()

or

from modules.singleton import Singleton
the_singleton = Singleton()
the_singleton.foobar()

do this:

from modules import singleton
singleton.foobar()