2

I want to define own tree-like class. I've written code like this:

class forest:
        class tree:
                def __init__(self):
                        self.var_a = []
                        self.var_b = []
                        #Or something as simple
                def mk(self,something):
                        #Some instructions
                        self.a = tree()
                        b_var = self.a.mk(a_var)
                        self.b = tree()
                        c_var = self.a.mk(b_var)
                        #Some instructions
                        return ret
        #Some code for class forest

Well tree() doesn't work.

NameError: global name 'tree' is not defined

The error for self.tree():

AttributeError: 'tree' object has no attribute 'tree'

I do not know how (or if) to use self.__init__ or self.__new__ in this context.

The question
It is possible to use recursive class in Python3? How does the code for this look like?

Improve this question
3
  • You want forest.tree since the tree class is inside the forest class. Commented Dec 3, 2011 at 19:50
  • It looks it works. However, I have problems in writing simple test case... Commented Dec 3, 2011 at 20:39
  • 1
    @Michas If your question was answered, please mark it as accepted. Commented Dec 8, 2011 at 4:56

2 Answers 2

Reset to default
7

You don't need to nest the classes in order to implement a container pattern.

Move the Tree class outside of Forest. Each time a tree is instantianted, it can add itself to the forest:

    class Forest:
            def __init__(self):
                self.mytrees = []
            def add(self, tree):
                self.mytrees.append(self)
            def drop_leaves(self):
                for tree in self.mytrees:
                    tree.drop_leaves()


    class Tree:
            def __init__(self, forest):
                forest.add(self)
                self.var_a = []
                self.var_b = []
                #Or something as simple
            def drop_leaves(self):
                print 'Drop'

    sherwood = Forest()
    t1 = Tree(sherwood)
    t2 = Tree(sherwood)
    sherwood.drop_leaves()

The question:

It is possible to use recursive class in Python3? How does the code for this look like?

Straight answer:

Nesting class definitions does not confer any benefit in Python because their scopes don't nest (the contents of the inner class cannot refer directly to the enclosing class).

Accordingly, the usual pattern in Python is to make two of more classes than can refer directly to one another (using composition rather than inheritance).

Subsequent comment:

Well. I don't need to use classes. The functions and dictionaries would be enough.

Functions and dictionaries are always enough (the early versions of Python did not have classes). OTOH, we've found that classes are a convenient way to organize code, making it clear which functions operate on which data. How you do it is a matter of taste.

A later comment:

There is one benefit of nested class. Its definition doesn't reside in global scope.

That can be a disadvantage as well, making it more difficult to reuse code, more difficult to test, and possibly confounding introspection tools.

Improve this answer
Sign up to request clarification or add additional context in comments.

10 Comments

Well. I don't need to use classes. The functions and dictionaries would be enough.
@Michas: That would come with huge inconveniences and be non-idiomatic. Not nesting classes is at least as convenient, and far more common in the Python world.
I sometimes find nested classes useful in place of creating a separate module just for namespacing purposes. E.g., I have a class tree, and then a class inside it which is a subclass called deciduous so users can just go tree.deciduous to access the class. Also, when I'm using metaclasses, I like to declare the metaclass directly inside the class rather than separately. But yes, the circumstances in which class nesting is arguably useful are somewhat narrow.
@Michas: Nested classes are less readable. It just creates confusion, as people expect the class to be defined in a global scope. Putting class definitions in other scopes are only useful (but still confusing) when you need to define the class dynamically or when the class needs a specific dynamic scope. Just nesting classes has no benefits at all, only drawbacks.
@Michas: But making them nested will only be more confusing. And it's not confusing to have more than 7 classes in the global scope, unless you have confusing naming. Most people can't keep more that 3 to 5 things in the head at once, and that doesn't stop them from using modules who has loads of classes and methods. If you want to separate the classes by namespace, I suggest using modules. Again: Nested classes adds confusion and complexity. There is no benefit.
|
0

I just experimented with this and it can be done in Python3

class forest:
    #Interal Class _tree
    class _tree:
            def __init__(self):
                    self.var_a = []
                    self.var_b = []
                    #Or something as simple
            def mk(self,something):
                    #Some instructions on self.var_a or self.var_b
    def __init__(self):
        #Assign internal class _tree to public variable tree
        self.tree=self._tree()

sherwood=forest()
sherwood.tree.mk()

This way you don't have to pollute global name space with a 'tree' class

Though if you dislike this due to confusion/readibility issues, you can always make a separate tree class as previously described.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.