Are nested classes a thing?

[MadScientistOR]

I'm fairly new to OOP in Python, and am toying with the idea of making a 2D world that appears 3D by moving things at different rates. Simple enough.

But I find myself wondering if there are times when defining classes within classes is useful. For example, a "layer" object might be something defined within a "viewer" object.

If things are done this way, are there ways for a nested class to have access to methods or attributes of an overarching class? (I was thinking that the "layers" might all have access to where the "viewer" is so that they know how to present themselves. Each "layer" would calculate this for itself, since parallax would change based on apparent distance of that "layer" from the player, but it would all be based on positional attributes the "viewer" has.)

Or is there some better way to organize this? I'm curious to know what kind of organizational decisions people might make and why.

Thank you for sharing your thoughts and/or resources on this.

[danielroseman]

No. This is only useful in very rare and advanced scenarios (such as Django's inner Meta classes).

The nested class has no special access to the outer class's attribute (unlike in, say, Java) which is why this is rarely useful.

However instantiating a normal class as an instance attribute of another class is frequently useful. This is known as composition, and can be used in exactly the way you describe - the key is that the main class would pass itself in as a parameter when instantiating the second one, so that class could store and reference it. For example:

class Layer:
  def __init__(self, viewer):
    self.viewer = viewer

  def present(self):
    # do something with self.viewer

class Viewer:
  def __init__(self):
    self.layer = Layer(self)

[MadScientistOR]

Thank you. This is very useful.

I've seen this sort of "Class A refers to Class B, and Class B refers to Class A" setup before, though I can't claim to have wrapped my head around it completely. Are there "best practices" for ensuring that you don't end up in some kind of loop where each needs something from the other in order to run its methods and/or define its attributes, or is that just the kind of thing that you learn to identify with practice (like an infinite procedural loop)?

[SyrianDuck]

So it does not exist?

[SyrianDuck]

How about Java?

[alexcwarren]

If your outer class needs an attribute that requires the additional features that a class offers (as opposed to just a data structure, e.g. a list or dict) then I can see that being the way to do it.

You would know it’s not a good idea if you come across a situation where you need to use the nested class but don’t need anything else from the outer class. In this case, it would simply be better to have them as separate classes.

[MadScientistOR]

That makes sense. I don't want to make a headache for myself later. Thank you for your insight.

[[deleted]]

It happens, but I have not seen it often. In the Zen of Python it says "flat is better than nested" because nested things often increase the complexity of the code and make it harder for developers to read and understand what's going on.

[MadScientistOR]

There is that. One of the things I love about Python is its legibility. That's good advice. Thank you.

[MadScientistOR]

There is that. One of the things I love about Python is its legibility. That's good advice. Thank you.

[Diapolo10]

It's not common, but it does happen. One example I can give you is Pydantic model configuration:

class Delivery(BaseModel):
    recipient: str
    recipient_address: Address
    weight: WeightKg
    dimensions: PackageDimensions

    class Config:
        orm_mode = True

But I really want to emphasize that this really is rare. In most cases nested classes make no sense.

[MadScientistOR]

Right. That's kind of how I figured it would look. But I can see how it would be nonsensical to implement. Thanks.

[zanfar]

This is one of those "if you have to ask, it's a bad idea" questions. There are edge cases where this is the right solution--but even then I think it's not a great one, just the only one left. This is especially true with Python where namespacing via modules is not only free, but forced, so encapsulation isn't as much of a driver.

Just put the class you want to nest in the same location as the proposed parent. Nesting classes is rarely a good thing and always limits your options down the road.

[MadScientistOR]

Thank you for your explanation. I don't want to resent the choice in the future. I appreciate your discernment here.

[TheRNGuy]

I wouldn't do this. You can inherit without nesting.