input: Write a function to create a doubly linked list in Python that supports both forward and backward traversal. The function should include methods to append a node at the end, prepend a node at the beginning, and reverse the list. The function should return an instance of the linked list.
  
  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 create_dll().append(1).append(2).append(3).reverse().head.data == 1
  assert create_dll().prepend(1).prepend(2).prepend(3).head.data == 3
  assert create_dll().append(1).prepend(2).head.data == 2
output: def create_dll():
      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
  
      return DoubleLinkedList()