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

Public Member Functions

def __init__ (self, *args, **kwds)
 
def __setitem__ (self, key, value, dict_setitem=dict.__setitem__)
 
def __delitem__ (self, key, dict_delitem=dict.__delitem__)
 
def __iter__ (self)
 
def __reversed__ (self)
 
def clear (self)
 
def popitem (self, last=True)
 
def keys (self)
 
def values (self)
 
def items (self)
 
def iterkeys (self)
 
def itervalues (self)
 
def iteritems (self)
 
def update (*args, **kwds)
 
def pop (self, key, default=__marker)
 
def setdefault (self, key, default=None)
 
def __repr__ (self, _repr_running=None)
 
def __reduce__ (self)
 
def copy (self)
 
def fromkeys (cls, iterable, value=None)
 
def __eq__ (self, other)
 
def __ne__ (self, other)
 
def viewkeys (self)
 
def viewvalues (self)
 
def viewitems (self)
 

Constructor & Destructor Documentation

◆ __init__()

def __init__ (   self,
args,
**  kwds 
)
Initialize an ordered dictionary.  Signature is the same as for
regular dictionaries, but keyword arguments are not recommended
because their insertion order is arbitrary.

Member Function Documentation

◆ __delitem__()

def __delitem__ (   self,
  key,
  dict_delitem = dict.__delitem__ 
)

◆ __eq__()

def __eq__ (   self,
  other 
)
od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
while comparison to a regular mapping is order-insensitive.

◆ __iter__()

def __iter__ (   self)

◆ __ne__()

def __ne__ (   self,
  other 
)

◆ __reduce__()

def __reduce__ (   self)

◆ __repr__()

def __repr__ (   self,
  _repr_running = None 
)

◆ __reversed__()

def __reversed__ (   self)

◆ __setitem__()

def __setitem__ (   self,
  key,
  value,
  dict_setitem = dict.__setitem__ 
)

◆ clear()

def clear (   self)

◆ copy()

def copy (   self)

◆ fromkeys()

def fromkeys (   cls,
  iterable,
  value = None 
)
OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
and values equal to v (which defaults to None).

◆ items()

def items (   self)

◆ iteritems()

def iteritems (   self)

◆ iterkeys()

def iterkeys (   self)

◆ itervalues()

def itervalues (   self)

◆ keys()

def keys (   self)

◆ pop()

def pop (   self,
  key,
  default = __marker 
)
od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised.

◆ popitem()

def popitem (   self,
  last = True 
)
od.popitem() -> (k, v), return and remove a (key, value) pair.
Pairs are returned in LIFO order if last is true or FIFO order if false.

◆ setdefault()

def setdefault (   self,
  key,
  default = None 
)

◆ update()

def update ( args,
**  kwds 
)
od.update(E, **F) -> None.  Update od from dict/iterable E and F.

If E is a dict instance, does:           for k in E: od[k] = E[k]
If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
Or if E is an iterable of items, does:   for k, v in E: od[k] = v
In either case, this is followed by:     for k, v in F.items(): od[k] = v

◆ values()

def values (   self)

◆ viewitems()

def viewitems (   self)

◆ viewkeys()

def viewkeys (   self)

◆ viewvalues()

def viewvalues (   self)

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