Создать эффективную реализацию дека

from collections import deque
 
f = open("file.txt",  "r")  
m =int(f.readline())
n =int(f.readline())
d = deque()
for i in range(n):
   if len(d)>m :
      print("Deque size>m")
      break
   s=f.readline().split()
   command=s[0]
   if len(s)==2:
      value = s[1]
   if command=="push_back":
      d.append(value)
   elif command=="push_front":
      d.appendleft(value)
   elif command=="pop_front":
         print(d[0])
         d.popleft()
   elif command=="pop_back":
         print(d[-1])
         d.pop()
   else:
      print("Error command: "+command)
f.close()

class Deque(object):
    def __init__(self):
        self.dllist = []
 
    def is_empty(self):
        return self.dllist == []
 
    def addfront(self, item):
        self.dllist.append(item)
 
    def addrear(self, item):
        self.dllist.insert(0, item)
 
    def removefront(self):
        return self.dllist.pop()
 
    def removerear(self):
        return self.dllist.pop(0)
 
    def size(self):
        return len(self.dllist)
 
 
if __name__ == '__main__':
    d=Deque()
    print(d.is_empty())
    print(d.addrear(4))
    print(d.addrear('dog'))
    print(d.addrear('cat'))
    print(d.addfront(True))
    print(d.size())
    print(d.is_empty())
    print(d.addrear(8.4))
    print(d.removerear())
    print(d.removefront())

import re
#a=["push_front 861","push_front -819","pop_back","pop_back"]
#a=["push_front -855","push_front 720","pop_back","pop_back","push_back 844","pop_back","push_back 823"]
#n=len(a)
#m=10;
n,m=input().split()
n=int(n)
m=int(m)
dq=[0]*m
p=0;
for i in range(n):
    #l=re.split(' |_',a[i])
    l=re.split(' |_',input())
    if len(l)==3:
        if l[1]=='back':
            dq[p]=int(l[2])
        else:
            for j in range(p-1,-1,-1):
                dq[j+1]=dq[j]
            dq[0]=int(l[2])
                           
        p+=1
    else:
        if l[1]=='back':
            print(dq[p-1])
        else:
            print(dq[0])
            for j in range(1,p):
                dq[j-1]=dq[j]
        p-=1

class ArrayDeque:
    def __init__(self, capacity):
        self.__deque = [None] * capacity
        self.__size = 0
        self.__head = 0
        
    def _ensureCapacity(self, x):
        if not 0 <= self.__size + x < len(self.__deque):
            raise ValueError("error")
 
    def _addHeadSize(self, head, size):
        self.__head = (self.__head + head) % len(self.__deque)
        self.__size += size
 
    def pushBack(self, value):
        self._ensureCapacity(1)
        d = self.__deque
        n = len(self.__deque)
        index = (self.__head + self.__size + 1) % n
        d[index] = value
        self._addHeadSize(0, 1)
        
    def pushFront(self, value):
        self._ensureCapacity(1)
        d = self.__deque
        n = len(d)
        d[self.__head] = value
        self._addHeadSize(-1, 1)
        
    def popFront(self):
        self._ensureCapacity(-1)
        d = self.__deque
        n = len(d)
        index = (self.__head + 1) % n
        result = d[index]
        d[index] = None
        self._addHeadSize(1, -1)
        return result
        
    def popBack(self):
        self._ensureCapacity(-1)
        d = self.__deque
        n = len(d)
        index = (self.__head + self.__size) % n
        result = d[index]
        d[index] = None
        self._addHeadSize(0, -1)
        return result
        
def solution():
    n = int(input())
    m = int(input())
    deque = ArrayDeque(m)
    commands = {
        "push_back": deque.pushBack,
        "push_front": deque.pushFront,
        "pop_front": deque.popFront,
        "pop_back": deque.popBack,
    }
    for _ in range(n):
        command, *values = input().split()
        try:
            result = commands[command](*values)
            if result is not None:
                print(result)
        except ValueError as e:
            print(e)
       
if __name__ == "__main__":
    solution()