doublelinkedlist

dll.py

class Node(object):
    """The class the handles the Node objects"""
    def __init__(self, data=None, prev=None, next=None):
        self.data = data
        self.prev = prev
        self.next = next

    def __str__(self):
        return "Node[Data = %s]" % (self.data,)

class DLinkList(object):
    """The class that handles the Actual List and Head and Tail"""
    def __init__(self):
        """
        The constructor sets head and tail to None and the size to zero.
        :return: The reference for self.
        """
        self.head = None
        self.tail = None
        self.size = 0

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

    def __next__(self):
        if self.current is None:
            raise StopIteration
        current = self.current
        self.current = current.next
        return current

    def append(self, data):
        new_node = Node(data, None, None)
        if self.head is None:
            self.head = self.tail = new_node
            self.size = 1  
        else:
            new_node.prev = self.tail
            new_node.next = None
            self.tail.next = new_node
            self.tail = new_node
            self.size += 1

    def find(self, value):
        '''return node where node.data == node.value'''
        for node in self:
            if node.data == value:
                break
        else:
            raise ValueError('{} not in DL'.format(value))

        return node

    def contains(self, value):
        try:
            self.find(value)
            return True
        except ValueError:
            return False

    def as_list(self):
        return list(self)

    def as_enum(self):
        return {idx:node for idx,node in enumerate(self)}

    def delete(self, node):
        if node is self.head:
            self.head = node.next
        if node is self.tail:
            self.tail = node.prev
        if node.next is not None:
            node.next.prev = node.prev
        if node.prev is not None:
            node.prev.next = node.next

    def remove(self, value):
        node = self.find(value)
        self.delete(node)

    def remove_at(self, index):
        for idx, node in enumerate(self):
            if idx == index:
                self.delete(node)
                return

        raise IndexError('index {} not found'.format(index))

    def __str__(self):
        return 'LL({})'.format(', '.join(str(n) for n in self))
        
        
            

l = DLinkList()
l.append(1)
l.append(2)
l.append(3)
l.append(4)
print(l)

l.remove(1)
l.remove(3)
print(l)
l.remove(4)
print(l)
l.remove_at(0)
print(l)