双链接的前哨列表中的__next__和__iter__方法

Question

I'm working on a doubly linked list class right now and I'm running into trouble with my next and iter methods. This is for a project for my class that I've already turned in and now just want to understand how to actually fix it to make it useful.

What I want my code to do is set a current pointer, starting at the header, and then continue advancing through until instructed to terminate or when it reaches the trailer. I want to access the value stored at each node. The node class is a subclass of the main linked list class. Here is the code I have. My problem appears when I call upon my methods (posting my append method); the current pointer is not recognized. Any ideas on how to fix this?

class Linked_List:

    class __Node:
        def __init__(self, val):
          self.val = val
          self.size = 0

    def __init__(self):
        self.header = Linked_List.__Node('header')
        self.trailer = Linked_List.__Node('trailer')
        self.header.next = self.trailer
        self.trailer.prev = self.header
        self.size = 0
        self.current = self.header
        self.current.next = self.trailer

    def __iter__(self):
        self.current = self.header
        return self


    def __next__(self):
        if self.current == self.trailer:
            raise StopIteration
        result = self.Linked_List.__Node[self.current]
        self.current = self.current.next
        return result

    def append(self, val):
        new_node = Linked_List.__Node(val)

        if self.header.next is self.trailer:
            self.header.next = new_node
            self.trailer.prev = new_node
            self.current = self.header
        else:
            while self.current is not self.trailer:
                self.current = self.current.next
            self.current.next = new_node
            new_node.next = self.trailer
            new_node.prev = self.current
        self.size += 1

I'm newer to python (and coding in general) so any advice would be amazing.

Answer 1

Your code has multiple issues, which get apparent as you attempt to use it. Let's assume the following code to test it:

l = Linked_List()
l.append('foo')
l.append('bar')
l.append('baz')

print([x.val for x in l])

---

AttributeError: '__Node' object has no attribute 'next'

First issue: Your __Node type does not have fields for next and prev :

class __Node:
    def __init__(self, val):
      self.val = val
      self.size = 0
      self.prev = None
      self.next = None

AttributeError: 'NoneType' object has no attribute 'next'

Second issue: next is not always being filled for appended nodes. In one of your paths in append , you do not set next and prev of the new node:

def append(self, val):
    new_node = Linked_List.__Node(val)

    if self.header.next is self.trailer:
        # set the attributes on new_node
        new_node.prev = self.header
        new_node.next = self.trailer

        self.header.next = new_node
        self.trailer.prev = new_node
        self.current = self.header
    # …

AttributeError: 'Linked_List' object has no attribute 'Linked_List'

Third issue: No idea what you were trying to do in __next__ there. You should simply access self.current there:

def __next__(self):
    if self.current == self.trailer:
        raise StopIteration
    result = self.current
    self.current = self.current.next
    return result

Once we have fixed all that, we have a code that runs successfully. But we only get the following output: ['header', 'foo'] . Of course, that's not what we want.

The reason this happens is because the actual order of the items is the following:

header
foo
trailer
baz
trailer

(Yes, there is a recursion) So apparently, the append did not work correctly after all. If you just append two elements, you can see that the element is being added after the trailer element. This means that self.current does hit the trailer element in the append loop after all:

while self.current is not self.trailer:
    self.current = self.current.next

And if you look at it, it makes sense that this happens: self.current is updated first, and then the check is made to eventually cancel the loop. At that time self.current is self.trailer . So we should check self.current.next instead:

while self.current.next is not self.trailer:
    self.current = self.current.next

Once we have that fixed, we get the following output: ['header', 'foo', 'bar', 'baz'] . That's almost what we would like to see. All we need to do now is to skip the header element as well. We do that by simply starting from the element after the header:

def __iter__(self):
    self.current = self.header.next
    return self

And then it works.

---

This is all it takes to get your code running. However , I would generally advise against this approach. You are storing iteration state inside the list, which is very fragile. You should really have this state as local as you possibly can.

In particular, the linked list does not need to be both enumerable and an enumerator . Implementing __iter__ does the former, implementing __next__ does the latter. Enumerable means “you can iterate this thing” while the enumerator is the thing that is performing the iteration and which has the iteration state.

Try moving the iteration state off the linked list, by making it only enumerable and not an enumerator. To do this, add a LinkedListEnumerator type that has a reference to your list and keeps track of the current element:

class LinkedListEnumerator:
    def __init__ (self, lst):
        self.lst = lst
        self.current = lst.header.next

    def __iter__ (self):
        return self

    def __next__ (self):
        if self.current == self.lst.trailer:
            raise StopIteration
        result = self.current
        self.current = self.current.next
        return result

You can then delete the __next__ method in your linked list, and replace the __iter__ method by the following:

def __iter__(self):
    return LinkedListEnumerator(self)

And then you no longer have the state in the linked list. (At this point, you should also make current a local variable in append and get rid of self.current completely)