mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 11:30:18 +00:00
c82bfb5455
* Initial integration of deque in collections * some fix * WIP: Implemented a int-only deque with limited capabilities * WIP: added some more functionality -> changed int to arbitrary objects * WIP: Added more functionalities in deque * WIP: switched to std::deque * WIP: added more functionalities * WIP: minor fix * WIP: added constructor * WIP: added deque iterator * WIP: added more functionalities * Cleaned up and added more functionalities * minor fix, std::min * minor fix, rotate, n=0 case * fix `collections` module * support pickle * refactored collections module * Added some tests, more to follow * Fixed the tests, more to follow * Fixed some functionalities and added more tests * added more tests, called __init__ from pickle, added reverse iterator option * added the tests * dropped support for __init__ for now * moved deque iterator to collections.cpp * undo unnecessary changes * Cleaned up and added __str__() support --------- Co-authored-by: blueloveTH <blueloveTH@foxmail.com>
161 lines
4.3 KiB
Python
161 lines
4.3 KiB
Python
# class _LinkedListNode:
|
|
# def __init__(self, prev, next, value) -> None:
|
|
# self.prev = prev
|
|
# self.next = next
|
|
# self.value = value
|
|
|
|
# class deque:
|
|
# def __init__(self, iterable=None) -> None:
|
|
# self.head = _LinkedListNode(None, None, None)
|
|
# self.tail = _LinkedListNode(None, None, None)
|
|
# self.head.next = self.tail
|
|
# self.tail.prev = self.head
|
|
# self.size = 0
|
|
# if iterable is not None:
|
|
# for value in iterable:
|
|
# self.append(value)
|
|
|
|
# def __getitem__(self, index):
|
|
# assert 0 <= index < len(self)
|
|
# node = self.head.next
|
|
# for _ in range(index):
|
|
# node = node.next
|
|
# return node.value
|
|
|
|
# def __setitem__(self, index, value):
|
|
# assert 0 <= index < len(self)
|
|
# node = self.head.next
|
|
# for _ in range(index):
|
|
# node = node.next
|
|
# node.value = value
|
|
|
|
# def __delitem__(self, index):
|
|
# assert 0 <= index < len(self)
|
|
# node = self.head.next
|
|
# for _ in range(index):
|
|
# node = node.next
|
|
# node.prev.next = node.next
|
|
# node.next.prev = node.prev
|
|
# self.size -= 1
|
|
|
|
# def clear(self):
|
|
# self.head.next = self.tail
|
|
# self.tail.prev = self.head
|
|
# self.size = 0
|
|
|
|
# def extend(self, iterable):
|
|
# for value in iterable:
|
|
# self.append(value)
|
|
|
|
# def append(self, value):
|
|
# node = _LinkedListNode(self.tail.prev, self.tail, value)
|
|
# self.tail.prev.next = node
|
|
# self.tail.prev = node
|
|
# self.size += 1
|
|
|
|
# def appendleft(self, value):
|
|
# node = _LinkedListNode(self.head, self.head.next, value)
|
|
# self.head.next.prev = node
|
|
# self.head.next = node
|
|
# self.size += 1
|
|
|
|
# def pop(self):
|
|
# assert self.size > 0
|
|
# node = self.tail.prev
|
|
# node.prev.next = self.tail
|
|
# self.tail.prev = node.prev
|
|
# self.size -= 1
|
|
# return node.value
|
|
|
|
# def popleft(self):
|
|
# assert self.size > 0
|
|
# node = self.head.next
|
|
# node.next.prev = self.head
|
|
# self.head.next = node.next
|
|
# self.size -= 1
|
|
# return node.value
|
|
|
|
# def copy(self):
|
|
# new_list = deque()
|
|
# for value in self:
|
|
# new_list.append(value)
|
|
# return new_list
|
|
|
|
# def __len__(self):
|
|
# return self.size
|
|
|
|
# def __iter__(self):
|
|
# node = self.head.next
|
|
# while node is not self.tail:
|
|
# yield node.value
|
|
# node = node.next
|
|
|
|
# def __repr__(self) -> str:
|
|
# a = list(self)
|
|
# return f"deque({a})"
|
|
|
|
# def __eq__(self, __o: object) -> bool:
|
|
# if not isinstance(__o, deque):
|
|
# return False
|
|
# if len(self) != len(__o):
|
|
# return False
|
|
# t1, t2 = self.head.next, __o.head.next
|
|
# while t1 is not self.tail:
|
|
# if t1.value != t2.value:
|
|
# return False
|
|
# t1, t2 = t1.next, t2.next
|
|
# return True
|
|
|
|
def Counter(iterable):
|
|
a = {}
|
|
for x in iterable:
|
|
if x in a:
|
|
a[x] += 1
|
|
else:
|
|
a[x] = 1
|
|
return a
|
|
|
|
class defaultdict:
|
|
def __init__(self, default_factory) -> None:
|
|
self.default_factory = default_factory
|
|
self._a = {}
|
|
|
|
def __getitem__(self, key):
|
|
if key not in self._a:
|
|
self._a[key] = self.default_factory()
|
|
return self._a[key]
|
|
|
|
def __setitem__(self, key, value):
|
|
self._a[key] = value
|
|
|
|
def __repr__(self) -> str:
|
|
return f"defaultdict({self.default_factory}, {self._a})"
|
|
|
|
def __eq__(self, __o: object) -> bool:
|
|
if not isinstance(__o, defaultdict):
|
|
return False
|
|
if self.default_factory != __o.default_factory:
|
|
return False
|
|
return self._a == __o._a
|
|
|
|
def __iter__(self):
|
|
return iter(self._a)
|
|
|
|
def __contains__(self, key):
|
|
return key in self._a
|
|
|
|
def __len__(self):
|
|
return len(self._a)
|
|
|
|
def keys(self):
|
|
return self._a.keys()
|
|
|
|
def values(self):
|
|
return self._a.values()
|
|
|
|
def items(self):
|
|
return self._a.items()
|
|
|
|
def pop(self, *args):
|
|
return self._a.pop(*args)
|