Doubly Linked List

class DoublyLinkedNode():
    def __init__(self,value,previousNode=None,nextNode=None):
        self.value = value
        self.previousNode = previousNode
        self.nextNode = nextNode

    def get(self):
        return self.value

    def __str__(self):
        return str(self.get())

    def next(self):
        return self.nextNode

    def previous(self):
        return self.previousNode

    def setNextNode(self,nextNode):
        self.nextNode = nextNode

    def setPreviousNode(self,previousNode):
        self.previousNode = previousNode

class DoublyLinkedList():
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def __len__(self):
        return self.size

    def __str__(self):
        if self.__len__() == 0:
            return "[]"
        else:
            theString = "["
            currentNode = self.head
            while currentNode != None:
                theString += str(currentNode)
                if currentNode.next() != None:
                    theString += ", "
                currentNode = currentNode.next()
            theString += "]"
            return theString


    def _findNode(self,index):
        if (index + 1) > self.__len__() or (index < 0 and -index > self.__len__()):
            raise IndexError("List index out of range")
        elif index < 0:
            current = self.tail
            for i in range(-(index+1)):
                current = current.previous()
        else:
            current = self.head
            for i in range(index):
                current = current.next()
        return current

    def append(self,value):
        if self.head != None:
            newNode = DoublyLinkedNode(value,self.tail)
            self.tail.setNextNode(newNode)
        else:
            newNode = DoublyLinkedNode(value)
            self.head = newNode
        self.tail = newNode
        self.size += 1

    def insert(self,index,value):
        if (index+2) > self.__len__() or (index < 0 and -(index-1) > self.__len__()): # if past the start or end of the list, defaults to last or first
            if index < 0:
                oldHead = self.head
                newNode = DoublyLinkedNode(value,nextNode=oldHead)
                oldHead.setPreviousNode(newNode)
                self.head = newNode
            elif index > 0:
                oldTail = self.tail
                newNode = DoublyLinkedNode(value,oldTail)
                oldTail.setNextNode(newNode)
                self.tail = newNode

        else:
            if index > 0:
                nextNode = self._findNode(index)
                previousNode = nextNode.previous()
                newNode = DoublyLinkedNode(value,previousNode,nextNode)
                previousNode.setNextNode(newNode)
                nextNode.setPreviousNode(newNode)
        self.size += 1

    def pop(self,index):
        theNode = self._findNode(index)
        if theNode.previous() != None:
            theNode.previous().setNextNode(theNode.next())
        if theNode.next() != None:
            theNode.next().setPreviousNode(theNode.previous())
        self.size -= 1
        return theNode.get()

    def __iter__(self):
        self.index = 0
        return (self)

    def next(self):
        try:
            result = self._findNode(self.index).get()
        except IndexError:
            self.index = 0
            raise StopIteration
        self.index += 1
        return result

    def __getitem__(self, item):
        return self._findNode(item).get()