pDoubly Linked List

# We define: the basic class for a node where it is stored
#            the data of the same node
#            the index of the next node
#            the index of the previous node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

# The doubly linked list class is created
class DoublyLinkedList:
    # Builder
    def __init__(self):
        self.first = None
        self.last = None

    # Enter the index of the node you want to obtain
    def get_node(self, index):
        # the current node is the first in the list
        current = self.first
        # the list is scrolled to the indicated index
        for i in range(index):
        # if the current node is none it is because the list is empty
            if current is None:
            # none is returned as there are no nodes
                return None
            # if the current node is none, the following is obtained
            # to continue browsing the list until you reach the requested index
            current = current.next
            return current

    # enter the node after a reference node
    # the reference node index is entered
    def insert_after(self, ref_node, new_node):
        new_node.prev = ref_node
        if ref_node.next is None:
            self.last = new_node
        else:
            new_node.next = ref_node.next
            new_node.next.prev = new_node
        ref_node.next = new_node

    def insert_before(self, ref_node, new_node):
        new_node.next = ref_node
        if ref_node.prev is None:
            self.first = new_node
        else:
            new_node.prev = ref_node.prev
            new_node.prev.next = new_node
        ref_node.prev = new_node

    def insert_at_beg(self, new_node):
        if self.first is None:
            self.first = new_node
            self.last = new_node
        else:
            self.insert_before(self.first, new_node)

    def insert_at_end(self, new_node):
        if self.last is None:
            self.last = new_node
            self.first = new_node
        else:
            self.insert_after(self.last, new_node)

    def remove(self, node):
        if node.prev is None:
            self.first = node.next
        else:
            node.prev.next = node.next

        if node.next is None:
            self.last = node.prev
        else:
            node.next.prev = node.prev

    def items(self):
        x = self.first
        while x:
            yield x
            x = x.next

    def values(self):
        x = self.first
        while x:
            yield x.data
            x = x.next

    def display(self):
        return ', '.join([str(x) for x in self.values()])


    def sort(self, ref_node, new_node):
        new_node.prev = ref_node
        if ref_node.next is None:
            j = self.last
            self.last = new_node.prev
            new_node.prev = j #self.last(old)
            self.display(self)
        else:
            new_node.next = ref_node.next
            new_node.next.prev = new_node
        ref_node.next = new_node

a_dllist = DoublyLinkedList()

print('Menu')
print('insert <data> after <index>')
print('insert <data> before <index>')
print('insert <data> at beg')
print('insert <data> at end')
print('remove <index>')
print('find <data>')
print('sort')
print('quit')

while True:
    print('The list: ', end='')
    a_dllist.display()
    print()
    do = input('What would you like to do? ').split()

    operation = do[0].strip().lower()

    if operation == 'insert':
        data = int(do[1])
        position = do[3].strip().lower()
        new_node = Node(data)
        suboperation = do[2].strip().lower()
        if suboperation == 'at':
            if position == 'beg':
                a_dllist.insert_at_beg(new_node)
            elif position == 'end':
                a_dllist.insert_at_end(new_node)
        else:
            index = int(position)
            ref_node = a_dllist.get_node(index)
            if ref_node is None:
                print('No such index.')
                continue
            if suboperation == 'after':
                a_dllist.insert_after(ref_node, new_node)
            elif suboperation == 'before':
                a_dllist.insert_before(ref_node, new_node)
            elif operation =='sort':
                a_dllist.sort(ref_node, new_node)

    elif operation == 'remove':
        index = int(do[1])
        node = a_dllist.get_node(index)
        if node is None:
            print('No such index.')
            continue
        a_dllist.remove(node)

    elif operation =='find':
        a_dllist.find()

    elif operation == 'quit':
        break