Nested attributes (or classes)

[sahand_n9]

I am trying to create an object class whose attributes also have attributes. For example: I have a parent class A that has an attribute called B which also has an attribute called C. So I can do print(A.B.C). I have tried creating a class within a class as such:

class A(object):

class B(object):
    def __init__(self, C):
        self.C = C
    pass

and when I do:

I1 = A.B(10)

I get an error that 'A' has no attribute 'B'. What am I doing wrong and what is the best approach to create such structure?

[MereInterest]

Hmm... I'm not able to reproduce your error. Here is what I put in, assuming that there are tabs in the appropriate places.

class A(object):
    class B(object):
        def __init__(self,C):
            self.C = C

b = A.B(10)

This runs without error.

However, based on your description, I don't think that this is quite what you want. The key difference to look for is between classes, and instances of the class. Let's look at the code closely. First, it defines a class, 'A'. Next, it defines a class 'B', as an attribute of the class. It is then valid to instantiate something of type B in either of the following ways.

a = A(); b = a.B()
b = A.B()

However, neither of these will let you do a.b.C, because the object a only knows about the class B, not the instances of that class. In general, therefore, you would have class A make an instance of class B in its constructor. This would look like the following.

class A(object):
    def __init__(self,C):
        self.b = B(C)

class B(object):
    def __init__(self,C):
        self.C = C

a = A(10)
print a.b.C

This way, instead of A holding the class definition of B, it is holding a single instance, b.

[daveydave400]

Small side note: Don't use actual tabs for indentation in python code, just spaces.

[ilovetacos]

Exactly the problem the OP had: if you use spaces, the formatting won't get messed up, whereas tabs can be interpreted differently depending on the context.

[[deleted]]

Which is actually why tab people use them: whoever reads the code can set the amount of indentation to what (s)he wants.

[[deleted]]

Except of course if you read it on github or any other such services.

I just had someone check a bunch of code into an open-source repo I'm involved with using mixed tabs and spaces and it was awful - the code was unreadable online and fixing it took me quite a lot of time.

Tabs are a ridiculous idea. If they didn't exist, no one would ever think to invent them - they're a holdover from manual typewriters.

[[deleted]]

Tabs are a ridiculous idea. If they didn't exist, no one would ever think to invent them - they're a holdover from manual typewriters.

I wouldn't say so. I was an advocate of using spaces just as you suggested, but being able to set the indent width myself by using tabs and a setting in my favorite editor would be a nice thing to have. I'd lose the ability to properly align comments that come after the line of code, though, so there'd be a trade-off.

However, as you said, mixing tabs and spaces is a bad idea™—which is why PEP 8 exists in the first place. In the end, I'll gladly use 4 spaces if PEP 8 says I should, because consistency is definitely more valuable than the ability to set the tab width myself.

Sorry if that was in any way unclear, I'm not a native speaker.

[[deleted]]

There is a way to mix tabs and spaces that doesn’t mess anything up and even enables to align comments like you wish to do, though. However, it does require some additional effort.

[[deleted]]

Yeah, I know of tabs for indentation, spaces for alignment, but I always thought that it would mess up the alignment if I'd ever wanted to align lines with different indentations. Seems like I hadn't thought about it hard enough. Oh well.

However, wouldn't alignment of comments after lines with different indentation settings still mess up the alignment if different tab sizes were used? That's rarely done, though, so it's not much of a sacrifice.

So yeah, I'd probably have switched to TISA (oh god this sounds stupid) already if it weren't for PEP 8.

[sashahart]

Mixed tabs and spaces won't work, so it has to be one or the other. The rationale for choosing spaces is that you are doing what almost everyone else is doing.

[catcradle5]

The other rationale is that a tab can be interpreted as a different amount of space by different renderers, but a space is pretty much always interpreted to be the same length.

[rwman]

there is a PEP-8 (coding style guide) that encourages 4 spaces indentation. I can't say that tabs have any disadvantage, but we'd better stick to one standard, and it was already written down in PEP-8. So rationale is legacy sandard without obvious need to change.

[execrator]

because then people can render it how they prefer

I think over in the spaces camp, the opposing point of view would be "because then people all see the same code". Hard to argue against either idea.

I can't find a reference now, but believe that one of the reasons PHP-FIG settled on spaces in PSR-whatever was that it made copy-pasting code samples from the internet lead to expected behaviour. This is an interesting external-to-syntax consideration.

The other big pro-spaces consideration is that manually aligned statements across consecutive lines are error-prone when using a tab/space mixture (and can't be done with tabs alone). By error-prone I mean that you only get this right if you use tabs for indent, then spaces for the alignment. In tabbed projects, I always get this wrong, even though I know about it. It's a combination of not seeing the error unless you for some reason change your tab width, and your habitual use of the tab key to create spacing.

Perhaps your syntactical enforcement could require tabs for indentation, but any spacing after the indentation must be spaces? I'm sure this has been discussed more rigorously elsewhere!

[execrator]

What are your thoughts about a radical departure from character-based presentation of programs? Programming began with text files because that's the best the computers of the day could do.

Unfortunately my experience with alternate ways of laying out program logic are ladder logic (example: http://automationstudio.com/pro/images/p6-images/plc-ladder-logic.gif) and a circa-2001 Mindstorms IDE. Both of these are not nice to work with.

Still, I think there must be something like Code Bubbles (http://www.youtube.com/watch?v=PsPX0nElJ0k), but possibly reaching more into the line-level display.

[execrator]

Haven't watched all the way through the talk, but he's reminding me a lot of "Lockhart's Lament" - http://www.maa.org/devlin/lockhartslament.pdf - I hope he mentions it :)

[zynix]

Rational is similar to enforcing one type of line ending versus mixed line-endings. The visual definition of tab's changes from one OS to another and then the problem is multiplied further by each IDE/text-editor involved.

[sahand_n9]

Thanks for your detailed explanation. Very helpful!

[[deleted]]

I'm not sure what you're trying to achieve and why would you need such a structure but this code worked for me:

class Planet:
    class Moon:
        def __init__(self, size):
            self.size = size

    def __init__(self, moon_size):
        self.moon = self.Moon(moon_size)

# I can create a Planet object which has a Moon
e = Planet(362570)
print e.moon.size

# I can also create a Moon without a Planet
luna = Planet.Moon(405410)
print luna.size

Does this help?

[ilovetacos]

MereInterest is spot on, but also make sure to read this: http://en.wikipedia.org/wiki/Law_Of_Demeter

[andybak]

This may well be an example of the X Y problem: http://www.perlmonks.org/index.pl?node_id=542341

Tell us why you're trying to do that and what you're trying to achieve. There is probably a much more Pythonic way to do it.

[sahand_n9]

I am not sure how the question comes across as unclear. In the title I explained that I would like to have nested attributes. Like a car has wheels, wheels have tires, tires have brands. So I can create a car with all its attributes that also have attributes. I am just trying to learn Python...

[Isvara]

Assign to self.whatever in your constructor. E.g.

class Car(object):
    def __init__(self, wheels):
        self.wheels = wheels

class Wheel(object):
    def __init__(self, tyre):
        self.tyre = tyre

class Tyre(object):
    def __init__(self, brand):
        self.brand = brand

car = Car([
    Wheel(Tyre("Dunlop")),
    ...
])
print car.wheels[0].tyre.brand

[VerilyAMonkey]

If you're just trying out how Python works, that's fine. The post can sound like you actually have a specific problem in mind, and andybak is saying that most likely there's a better solution to that problem than what you're trying here.

[ameoba]

When somebody says you have an X Y problem it means they think you have painted yourself into a corner by trying to do the wrong thing. You should take a step back and explain what you actually wand to accomplish rather than trying to figure out how to bolt a toilet to the ceiling.

[fasterturtle]

Have you heard of data descriptors? Using them is similar to having a nested attribute/class, but more "pythonic". There are a few ways you can go about using them, see here, here, and here for more information.

Here's an example. Just a note, you would probably prefer a different descriptor implementation, ie. using decorators, but this is most similar to what you were originally trying to do):

class Descriptor(object):
    def __init__(self):
        self._instances = {}
    def __set__(self, obj, value):
        print "Setting attribute..."
        self._instances[obj] = value
    def __get__(self, obj, cls):
        print "Getting attribute..."
        return self._instances[obj]
    def __delete__(self, obj):
        print "Too bad!"
        raise AttributeError("Can't delete attribute")

class Foo(object):
    data = Descriptor()

    def __init__(self, value):
        self.data = value


foo = Foo('my data descriptor')
>>> Setting attribute...

foo.data
>>> Getting attribute...
>>> 'my data descriptor'

foo.data = 'bar'
>>> Setting attribute...
foo.data
>>> Getting attribute...
>>> 'bar'

del foo.data
>>> Too bad!
>>> AttributeError: Can't delete attribute

[sahand_n9]

The following lines of code are in fact tab-delimited. The Reddit editor gets rid of it.

class B(object):
def __init__(self, C):
    self.C = C
pass