fork download
copy 
  1. from typing import TypeVar, Generic, Optional, Iterable, AbstractSet, Union, Iterator, Any, Dict
  2.  
  3. T = TypeVar("T")
  4. S = TypeVar("S")
  5.  
  6.  
  7. class OrderedSet(Generic[T], AbstractSet[T]):
  8.     def __init__(self, base: Optional[Union[Dict[T, None], Iterable[T]]] = None):
  9.         super().__init__()
  10.  
  11.         self.the_dict: Dict[T, None]
  12.         if not base:
  13.             self.the_dict = {}
  14.         elif isinstance(base, dict):
  15.             self.the_dict = base
  16.         else:
  17.             self.the_dict = dict.fromkeys(base)
  18.  
  19.     def __eq__(self, o: object) -> bool:
  20.         return isinstance(o, OrderedSet) and list(self.the_dict) == list(o.the_dict)
  21.  
  22.     def __ne__(self, o: object) -> bool:
  23.         return not self.__eq__(o)
  24.  
  25.     def __str__(self) -> str:
  26.         return "{" + ", ".join(list(map(str, self.the_dict))) + "}"
  27.  
  28.     def __repr__(self) -> str:
  29.         return f"OrderedSet({repr(self.the_dict)})"
  30.  
  31.     def add(self, element: T) -> None:
  32.         self.the_dict = {**self.the_dict, **{element: None}}
  33.  
  34.     def clear(self) -> None:
  35.         self.the_dict.clear()
  36.  
  37.     def copy(self) -> 'OrderedSet[T]':
  38.         return OrderedSet(self.the_dict.copy())
  39.  
  40.     def difference(self, s: Iterable[Any]) -> 'OrderedSet[T]':
  41.         return OrderedSet({e: None for e in self.the_dict if e not in s})
  42.  
  43.     def difference_update(self, s: Iterable[Any]) -> None:
  44.         self.the_dict = {e: None for e in self.the_dict if e not in s}
  45.  
  46.     def discard(self, element: T) -> None:
  47.         del self.the_dict[element]
  48.  
  49.     def intersection(self, s: Iterable[Any]) -> 'OrderedSet[T]':
  50.         return OrderedSet({e: None for e in self.the_dict if e in s})
  51.  
  52.     def intersection_update(self, s: Iterable[Any]) -> None:
  53.         self.the_dict = {e: None for e in self.the_dict if e in s}
  54.  
  55.     def isdisjoint(self, s: Iterable[Any]) -> bool:
  56.         return self.the_dict.keys().isdisjoint(s)
  57.  
  58.     def issubset(self, s: Iterable[Any]) -> bool:
  59.         return set(iter(self)).issubset(iter(s))
  60.  
  61.     def issuperset(self, s: Iterable[Any]) -> bool:
  62.         return set(iter(self)).issuperset(iter(s))
  63.  
  64.     def pop(self) -> T:
  65.         items = list(self.the_dict)
  66.         result = items.pop()
  67.         self.the_dict = dict.fromkeys(items)
  68.         return result
  69.  
  70.     def remove(self, element: T) -> None:
  71.         del self.the_dict[element]
  72.  
  73.     def symmetric_difference(self, s: Iterable[T]) -> 'OrderedSet[T]':
  74.         return OrderedSet(
  75.             dict.fromkeys([e for e in self.the_dict if e not in s] +
  76.                           [e for e in s if e not in self.the_dict]))
  77.  
  78.     def symmetric_difference_update(self, s: Iterable[T]) -> None:
  79.         self.the_dict = self.symmetric_difference(s).the_dict
  80.  
  81.     def union(self, s: Iterable[T]) -> 'OrderedSet[T]':
  82.         return OrderedSet({**self.the_dict, **dict.fromkeys(s)})
  83.  
  84.     def update(self, s: Iterable[T]) -> None:
  85.         self.the_dict = self.union(s).the_dict
  86.  
  87.     def __len__(self) -> int:
  88.         return len(self.the_dict)
  89.  
  90.     def __contains__(self, o: object) -> bool:
  91.         return o in self.the_dict
  92.  
  93.     def __iter__(self) -> Iterator[T]:
  94.         return iter(self.the_dict)
  95.  
  96.     def __and__(self, s: AbstractSet[object]) -> 'OrderedSet[T]':
  97.         return self.intersection(s)
  98.  
  99.     def __iand__(self, s: AbstractSet[object]) -> 'OrderedSet[T]':
  100.         result = self.intersection(s)
  101.         self.the_dict = result.the_dict
  102.         return result
  103.  
  104.     def __or__(self, s: AbstractSet[S]) -> 'OrderedSet[Union[T, S]]':
  105.         return self.union(s)
  106.  
  107.     def __ior__(self, s: AbstractSet[S]) -> 'OrderedSet[Union[T, S]]':
  108.         result = self.union(s)
  109.         self.the_dict = result.the_dict
  110.         return result
  111.  
  112.     def __sub__(self, s: AbstractSet[Optional[T]]) -> 'OrderedSet[T]':
  113.         return self.difference(s)
  114.  
  115.     def __isub__(self, s: AbstractSet[Optional[T]]) -> 'OrderedSet[T]':
  116.         result = self.difference(s)
  117.         self.the_dict = result.the_dict
  118.         return result
  119.  
  120.     def __xor__(self, s: AbstractSet[S]) -> 'OrderedSet[Union[T, S]]':
  121.         return self.symmetric_difference(s)
  122.  
  123.     def __ixor__(self, s: AbstractSet[S]) -> 'OrderedSet[Union[T, S]]':
  124.         result = self.symmetric_difference(s)
  125.         self.the_dict = result.the_dict
  126.         return result
  127.  
  128.     def __le__(self, s: AbstractSet[object]) -> bool:
  129.         return self.issubset(s)
  130.  
  131.     def __lt__(self, s: AbstractSet[object]) -> bool:
  132.         return self.issubset(s) and len(self) < len(s)
  133.  
  134.     def __ge__(self, s: AbstractSet[object]) -> bool:
  135.         return set(iter(self)) >= set(iter(s))
  136.  
  137.     def __gt__(self, s: AbstractSet[object]) -> bool:
  138.         return set(iter(self)) > set(iter(s))
  139. obj = OrderedSet()
  140. obj.add(1)
  141. obj.add(2)
  142. obj.add(3)
  143. print(set(obj))
Success #stdin #stdout 0.03s 9772KB
comments ()
stdin
copy 
Standard input is empty
stdout
copy 
{1, 2, 3}
https://ideone.com/bgJVIR
language:
Python 3 (python  3.12)
created:
3 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!