If I have this situation:

class Foo(object):def __init__(self):self.bar = Bar()def do_something(self):print 'doing something'class Bar(object):def __init(self):self.a = 'a'def some_function(self):

I want to call do_something function inside some_function function but this function doesn't belong to the class, what can I do to call this function? I don't want to use it with Foo().do_something, there are another option? I don't want to create new instance

another example:

class A(object):def __init__(self):self.content = 'abcdabcabcabc'self.b = self.B()self.c = self.C()    def some_function(self):print self.contentclass B(object):def foo(self):A.some_function()class C(object):def foo(self):A.some_function()

There is no practical use case for nested classes in Python, but for scoping some class attributes with namespaces. And in that case, you should not create instances of them at all.

All you get if you have instances of nested classes is a headache - there is no benneffit. The "Outter" class won't see them as anything special - that is unlike in C++, from where it looks like this pattern originated, that the nested class is, in its whole, private to the container class.

The concept of being private in Python is done purely by convention, and if no other code than Foo should use instances of Bar, indicate that by calling it _Bar and in the documentation.

Other than that being nested won't help Bar to get a reference to Foo by any other means than through its name (ok, there are ways using the descriptor protocol, but it is not meant for this) - and them, if you want to run Foo.do_something without having a Foo instance, do_something should be a classmethod anyway.

Now, if you want to have aggregated objects, that is another thing. You have to do is:

class Bar(object):def __init(self, parent):self.parent = parentself.a = 'a'def some_function(self):self.parent.do_something(...)class Foo(object):def __init__(self):self.bar = Bar(self)def do_something(self):print 'doing something'