input: Write a function to create a doubly linked-list in Python that supports appending elements to the end, prepending elements to the beginning, and reversing the direction of traversal. If the list is empty, the operations should still function correctly.
  
  
  class Node:
      def __init__(self, data):
          self.data = data
          self.next = None
          self.prev = None
  
  class DoubleLinkedList:
      def __init__(self): 
          self.head = None
   
      def append(self, new_data): 
          new_node = Node(new_data) 
          if self.head is None:
              self.head =  new_node
          else: 
              curr_node = self.head
              while curr_node.next != None:
                  curr_node = curr_node.next
              curr_node.next = new_node
              new_node.prev = curr_node
   
      def prepend(self, new_data):
          new_node = Node(new_data) 
          if self.head is None: 
              self.head = new_node
              return
          new_node.next = self.head
          self.head.prev = new_node 
          self.head = new_node
  
      def reverse(self):
          curr_node = self.head
          while curr_node:
              temp = curr_node.next
              curr_node.next = curr_node.prev
              curr_node.prev = temp
              curr_node = curr_node.prev
          if temp:
              self.head = temp.prev
              
  assert list_from_linked(DoubleLinkedList().append(1).append(2).append(3)) == [1, 2, 3]
  assert list_from_linked(DoubleLinkedList().prepend(1).prepend(2).prepend(3)) == [3, 2, 1]
  assert list_from_linked(DoubleLinkedList().append(1).reverse().reverse()) == [1]
  assert list_from_linked(DoubleLinkedList().append(1).append(2).reverse()) == [2, 1]
  assert list_from_linked(DoubleLinkedList().reverse()) == []
  
  def list_from_linked(dll):
      result = []
      current = dll.head
      while current:
          result.append(current.data)
          current = current.next
      return result
  
output: 
  class Node:
      def __init__(self, data):
          self.data = data
          self.next = None
          self.prev = None
  
  class DoubleLinkedList:
      def __init__(self): 
          self.head = None
   
      def append(self, new_data): 
          new_node = Node(new_data) 
          if self.head is None:
              self.head =  new_node
          else: 
              curr_node = self.head
              while curr_node.next != None:
                  curr_node = curr_node.next
              curr_node.next = new_node
              new_node.prev = curr_node
          return self
   
      def prepend(self, new_data):
          new_node = Node(new_data) 
          if self.head is None: 
              self.head = new_node
              return self
          new_node.next = self.head
          self.head.prev = new_node 
          self.head = new_node
          return self
  
      def reverse(self):
          curr_node = self.head
          while curr_node:
              temp = curr_node.next
              curr_node.next = curr_node.prev
              curr_node.prev = temp
              curr_node = curr_node.prev
          if temp:
              self.head = temp.prev
          return self
  