OpenQuizz
Une application de gestion des contenus pédagogiques
OrderedSet Class Reference
Inheritance diagram for OrderedSet:
Collaboration diagram for OrderedSet:

Public Member Functions

def __init__ (self, iterable=None)
 
def __len__ (self)
 
def __getitem__ (self, index)
 
def copy (self)
 
def __getstate__ (self)
 
def __setstate__ (self, state)
 
def __contains__ (self, key)
 
def add (self, key)
 
def update (self, sequence)
 
def index (self, key)
 
def pop (self)
 
def discard (self, key)
 
def clear (self)
 
def __iter__ (self)
 
def __reversed__ (self)
 
def __repr__ (self)
 
def __eq__ (self, other)
 
def union (self, *sets)
 
def __and__ (self, other)
 
def intersection (self, *sets)
 
def difference (self, *sets)
 
def issubset (self, other)
 
def issuperset (self, other)
 
def symmetric_difference (self, other)
 
def difference_update (self, *sets)
 
def intersection_update (self, other)
 
def symmetric_difference_update (self, other)
 

Data Fields

 items
 
 map
 

Static Public Attributes

 append
 
 get_loc
 
 get_indexer
 

Detailed Description

An OrderedSet is a custom MutableSet that remembers its order, so that
every entry has an index that can be looked up.

Example:
    >>> OrderedSet([1, 1, 2, 3, 2])
    OrderedSet([1, 2, 3])

Constructor & Destructor Documentation

◆ __init__()

def __init__ (   self,
  iterable = None 
)

Member Function Documentation

◆ __and__()

def __and__ (   self,
  other 
)

◆ __contains__()

def __contains__ (   self,
  key 
)
Test if the item is in this ordered set

Example:
    >>> 1 in OrderedSet([1, 3, 2])
    True
    >>> 5 in OrderedSet([1, 3, 2])
    False

◆ __eq__()

def __eq__ (   self,
  other 
)
Returns true if the containers have the same items. If `other` is a
Sequence, then order is checked, otherwise it is ignored.

Example:
    >>> oset = OrderedSet([1, 3, 2])
    >>> oset == [1, 3, 2]
    True
    >>> oset == [1, 2, 3]
    False
    >>> oset == [2, 3]
    False
    >>> oset == OrderedSet([3, 2, 1])
    False

◆ __getitem__()

def __getitem__ (   self,
  index 
)
Get the item at a given index.

If `index` is a slice, you will get back that slice of items, as a
new OrderedSet.

If `index` is a list or a similar iterable, you'll get a list of
items corresponding to those indices. This is similar to NumPy's
"fancy indexing". The result is not an OrderedSet because you may ask
for duplicate indices, and the number of elements returned should be
the number of elements asked for.

Example:
    >>> oset = OrderedSet([1, 2, 3])
    >>> oset[1]
    2

◆ __getstate__()

def __getstate__ (   self)

◆ __iter__()

def __iter__ (   self)
Example:
    >>> list(iter(OrderedSet([1, 2, 3])))
    [1, 2, 3]

◆ __len__()

def __len__ (   self)
Returns the number of unique elements in the ordered set

Example:
    >>> len(OrderedSet([]))
    0
    >>> len(OrderedSet([1, 2]))
    2

◆ __repr__()

def __repr__ (   self)

◆ __reversed__()

def __reversed__ (   self)
Example:
    >>> list(reversed(OrderedSet([1, 2, 3])))
    [3, 2, 1]

◆ __setstate__()

def __setstate__ (   self,
  state 
)

◆ add()

def add (   self,
  key 
)
Add `key` as an item to this OrderedSet, then return its index.

If `key` is already in the OrderedSet, return the index it already
had.

Example:
    >>> oset = OrderedSet()
    >>> oset.append(3)
    0
    >>> print(oset)
    OrderedSet([3])

◆ clear()

def clear (   self)
Remove all items from this OrderedSet.

◆ copy()

def copy (   self)
Return a shallow copy of this object.

Example:
    >>> this = OrderedSet([1, 2, 3])
    >>> other = this.copy()
    >>> this == other
    True
    >>> this is other
    False

◆ difference()

def difference (   self,
sets 
)
Returns all elements that are in this set but not the others.

Example:
    >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
    OrderedSet([1, 3])
    >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
    OrderedSet([1])
    >>> OrderedSet([1, 2, 3]) - OrderedSet([2])
    OrderedSet([1, 3])
    >>> OrderedSet([1, 2, 3]).difference()
    OrderedSet([1, 2, 3])

◆ difference_update()

def difference_update (   self,
sets 
)
Update this OrderedSet to remove items from one or more other sets.

Example:
    >>> this = OrderedSet([1, 2, 3])
    >>> this.difference_update(OrderedSet([2, 4]))
    >>> print(this)
    OrderedSet([1, 3])

    >>> this = OrderedSet([1, 2, 3, 4, 5])
    >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
    >>> print(this)
    OrderedSet([3, 5])

◆ discard()

def discard (   self,
  key 
)
Remove an element.  Do not raise an exception if absent.

The MutableSet mixin uses this to implement the .remove() method, which
*does* raise an error when asked to remove a non-existent item.

Example:
    >>> oset = OrderedSet([1, 2, 3])
    >>> oset.discard(2)
    >>> print(oset)
    OrderedSet([1, 3])
    >>> oset.discard(2)
    >>> print(oset)
    OrderedSet([1, 3])

◆ index()

def index (   self,
  key 
)
Get the index of a given entry, raising an IndexError if it's not
present.

`key` can be an iterable of entries that is not a string, in which case
this returns a list of indices.

Example:
    >>> oset = OrderedSet([1, 2, 3])
    >>> oset.index(2)
    1

◆ intersection()

def intersection (   self,
sets 
)
Returns elements in common between all sets. Order is defined only
by the first set.

Example:
    >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
    >>> print(oset)
    OrderedSet([1, 2, 3])
    >>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
    OrderedSet([2])
    >>> oset.intersection()
    OrderedSet([1, 2, 3])

◆ intersection_update()

def intersection_update (   self,
  other 
)
Update this OrderedSet to keep only items in another set, preserving
their order in this set.

Example:
    >>> this = OrderedSet([1, 4, 3, 5, 7])
    >>> other = OrderedSet([9, 7, 1, 3, 2])
    >>> this.intersection_update(other)
    >>> print(this)
    OrderedSet([1, 3, 7])

◆ issubset()

def issubset (   self,
  other 
)
Report whether another set contains this set.

Example:
    >>> OrderedSet([1, 2, 3]).issubset({1, 2})
    False
    >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
    True
    >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
    False

◆ issuperset()

def issuperset (   self,
  other 
)
Report whether this set contains another set.

Example:
    >>> OrderedSet([1, 2]).issuperset([1, 2, 3])
    False
    >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
    True
    >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
    False

◆ pop()

def pop (   self)
Remove and return the last element from the set.

Raises KeyError if the set is empty.

Example:
    >>> oset = OrderedSet([1, 2, 3])
    >>> oset.pop()
    3

◆ symmetric_difference()

def symmetric_difference (   self,
  other 
)
Return the symmetric difference of two OrderedSets as a new set.
That is, the new set will contain all elements that are in exactly
one of the sets.

Their order will be preserved, with elements from `self` preceding
elements from `other`.

Example:
    >>> this = OrderedSet([1, 4, 3, 5, 7])
    >>> other = OrderedSet([9, 7, 1, 3, 2])
    >>> this.symmetric_difference(other)
    OrderedSet([4, 5, 9, 2])

◆ symmetric_difference_update()

def symmetric_difference_update (   self,
  other 
)
Update this OrderedSet to remove items from another set, then
add items from the other set that were not present in this set.

Example:
    >>> this = OrderedSet([1, 4, 3, 5, 7])
    >>> other = OrderedSet([9, 7, 1, 3, 2])
    >>> this.symmetric_difference_update(other)
    >>> print(this)
    OrderedSet([4, 5, 9, 2])

◆ union()

def union (   self,
sets 
)
Combines all unique items.
Each items order is defined by its first appearance.

Example:
    >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
    >>> print(oset)
    OrderedSet([3, 1, 4, 5, 2, 0])
    >>> oset.union([8, 9])
    OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
    >>> oset | {10}
    OrderedSet([3, 1, 4, 5, 2, 0, 10])

◆ update()

def update (   self,
  sequence 
)
Update the set with the given iterable sequence, then return the index
of the last element inserted.

Example:
    >>> oset = OrderedSet([1, 2, 3])
    >>> oset.update([3, 1, 5, 1, 4])
    4
    >>> print(oset)
    OrderedSet([1, 2, 3, 5, 4])

Field Documentation

◆ append

append
static

◆ get_indexer

get_indexer
static

◆ get_loc

get_loc
static

◆ items

items

◆ map

map

The documentation for this class was generated from the following file: