<p>What I'm talking about here are nested classes. Essentially, I have two classes that I'm modeling. A DownloadManager class and a DownloadThread class. The obvious OOP concept here is composition. However, composition doesn't necessarily mean nesting, right?</p>

<p>I have code that looks something like this:</p>

<pre><code>class DownloadThread:
    def foo(self):
        pass

class DownloadManager():
    def __init__(self):
        dwld_threads = []
    def create_new_thread():
        dwld_threads.append(DownloadThread())
</code></pre>

<p>But now I'm wondering if there's a situation where nesting would be better. Something like:</p>

<pre><code>class DownloadManager():
    class DownloadThread:
        def foo(self):
            pass
    def __init__(self):
        dwld_threads = []
    def create_new_thread():
        dwld_threads.append(DownloadManager.DownloadThread())
</code></pre>

You might want to do this when the "inner" class is a one-off, which will never be used outside the
definition
of the outer class. For example to use a metaclass, it's sometimes handy to do
```
```
class Foo(object):
    class __metaclass__(type):
        ....
```
```
instead of defining a metaclass separately, if you're only using it once.
The only other time I've used nested classes like that, I used the outer class only as a namespace to group a bunch of closely related classes together:
```
```
class Group(object):
    class cls1(object):
       ...

    class cls2(object):
       ...
```
```
Then from another module, you can import Group and refer to these as Group.cls1, Group.cls2 etc. However one might argue that you can accomplish exactly the same (perhaps in a less confusing way) by using a module.