|
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) |
|
◆ __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.
◆ __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__()
◆ __ne__()
def __ne__ |
( |
|
self, |
|
|
|
other |
|
) |
| |
◆ __reduce__()
◆ __repr__()
def __repr__ |
( |
|
self, |
|
|
|
_repr_running = None |
|
) |
| |
◆ __reversed__()
◆ __setitem__()
def __setitem__ |
( |
|
self, |
|
|
|
key, |
|
|
|
value, |
|
|
|
dict_setitem = dict.__setitem__ |
|
) |
| |
◆ clear()
◆ copy()
◆ 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()
◆ iteritems()
◆ iterkeys()
◆ itervalues()
◆ keys()
◆ 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()
◆ viewitems()
◆ viewkeys()
◆ viewvalues()
The documentation for this class was generated from the following file:
- /home/passerat/Stage/flaskProject/venv/lib/python3.8/site-packages/pip/_vendor/distlib/compat.py