input: Write a function to create a Python class with methods to append and prepend nodes, and to reverse the order of a doubly linked list. The methods should ensure that each node can be accessed both forward and backward. If there are no elements in the linked list or during the reversal, the function should handle it appropriately.
  
  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 DoubleLinkedList().append(1).append(2).append(3).head.data == 1
  assert DoubleLinkedList().append(1).append(2).head.next.data == 2
  assert DoubleLinkedList().prepend(1).prepend(2).head.data == 2
  assert DoubleLinkedList().reverse().head.data == None
output: 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