Ordereddict

把 这个和 sorted 使用的栗子 也顺便看了！

class collections.abc.MutableMapping

继承类必须实现的 Abstract Methods 有:

__getitem__, __setitem__, __delitem__, __iter__, __len__

class MutableMapping(Mapping):

__slots__ = ()

"""A MutableMapping is a generic container for associating

key/value pairs.

This class provides concrete generic implementations of all

methods except for __getitem__, __setitem__, __delitem__,

__iter__, and __len__.

"""

@abstractmethod

def __setitem__(self, key, value):

raise KeyError

@abstractmethod

def __delitem__(self, key):

raise KeyError

__marker = object()

def pop(self, key, default=__marker):

'''D.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.

'''

try:

value = self[key]

except KeyError:

if default is self.__marker:

raise

return default

else:

del self[key]

return value

def popitem(self):

'''D.popitem() -> (k, v), remove and return some (key, value) pair

as a 2-tuple; but raise KeyError if D is empty.

'''

try:

key = next(iter(self))

except StopIteration:

raise KeyError

value = self[key]

del self[key]

return key, value

def clear(self):

'D.clear() -> None. Remove all items from D.'

try:

while True:

self.popitem()

except KeyError:

pass

def update(*args, **kwds):

''' D.update([E, ]**F) -> None. Update D from mapping/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k]

If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v

In either case, this is followed by: for k, v in F.items(): D[k] = v

'''

if not args:

raise TypeError("descriptor 'update' of 'MutableMapping' object "

"needs an argument")

self, *args = args

if len(args) > 1:

raise TypeError('update expected at most 1 arguments, got %d' %

len(args))

if args:

other = args[0]

if isinstance(other, Mapping):

for key in other:

self[key] = other[key]

elif hasattr(other, "keys"):

for key in other.keys():

self[key] = other[key]

else:

for key, value in other:

self[key] = value

for key, value in kwds.items():

self[key] = value

def setdefault(self, key, default=None):

'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'

try:

return self[key]

except KeyError:

self[key] = default

return default

MutableMapping.register(dict)

对应父类 Mapping 的源码

class Mapping(Collection):

__slots__ = ()

"""A Mapping is a generic container for associating key/value

pairs.

This class provides concrete generic implementations of all

methods except for __getitem__, __iter__, and __len__.

"""

@abstractmethod

def __getitem__(self, key):

raise KeyError

def get(self, key, default=None):

'D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.'

try:

return self[key]

except KeyError:

return default

def __contains__(self, key):

try:

self[key]

except KeyError:

return False

else:

return True

def keys(self):

"D.keys() -> a set-like object providing a view on D's keys"

return KeysView(self)

def items(self):

"D.items() -> a set-like object providing a view on D's items"

return ItemsView(self)

def values(self):

"D.values() -> an object providing a view on D's values"

return ValuesView(self)

def __eq__(self, other):

if not isinstance(other, Mapping):

return NotImplemented

return dict(self.items()) == dict(other.items())

__reversed__ = None

Mapping.register(mappingproxy)

class KeysView(MappingView, Set):

__slots__ = ()

@classmethod

def _from_iterable(self, it):

return set(it)

def __contains__(self, key):

return key in self._mapping

def __iter__(self):

yield from self._mapping

KeysView.register(dict_keys)

class MappingView(Sized):

__slots__ = '_mapping',

def __init__(self, mapping):

self._mapping = mapping

def __len__(self):

return len(self._mapping)

def __repr__(self):

return '{0.__class__.__name__}({0._mapping!r})'.format(self)

参考

python documentation: collections.abc

python documentation: collections