c737cde947
Anywhere a module is mentioned, use its "non-u" name for consistency. The "import module" vs "import umodule" is something of a FAQ, and this commit intends to help clear that up. As a first approximation MicroPython is Python, and so imports should work the same as Python and use the same name, to a first approximation. The u-version of a module is a detail that can be learned later on, when the user wants to understand more and have finer control over importing. Existing Python code should just work, as much as it is possible to do that within the constraints of embedded systems, and the MicroPython documentation should match the idiomatic way to write Python code. With universal weak links for modules (via MICROPY_MODULE_WEAK_LINKS) users can consistently use "import foo" across all ports (with the exception of the minimal ports). And the ability to override/extend via "foo.py" continues to work well. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
85 lines
2.7 KiB
ReStructuredText
85 lines
2.7 KiB
ReStructuredText
:mod:`collections` -- collection and container types
|
|
=====================================================
|
|
|
|
.. include:: ../templates/unsupported_in_circuitpython.inc
|
|
|
|
.. module:: collections
|
|
:synopsis: collection and container types
|
|
|
|
|see_cpython_module| :mod:`cpython:collections`.
|
|
|
|
This module implements advanced collection and container types to
|
|
hold/accumulate various objects.
|
|
|
|
Classes
|
|
-------
|
|
|
|
.. function:: deque(iterable, maxlen[, flags])
|
|
|
|
Deques (double-ended queues) are a list-like container that support O(1)
|
|
appends and pops from either side of the deque. New deques are created
|
|
using the following arguments:
|
|
|
|
- *iterable* must be the empty tuple, and the new deque is created empty.
|
|
|
|
- *maxlen* must be specified and the deque will be bounded to this
|
|
maximum length. Once the deque is full, any new items added will
|
|
discard items from the opposite end.
|
|
|
|
- The optional *flags* can be 1 to check for overflow when adding items.
|
|
|
|
As well as supporting `bool` and `len`, deque objects have the following
|
|
methods:
|
|
|
|
.. method:: deque.append(x)
|
|
|
|
Add *x* to the right side of the deque.
|
|
Raises IndexError if overflow checking is enabled and there is no more room left.
|
|
|
|
.. method:: deque.popleft()
|
|
|
|
Remove and return an item from the left side of the deque.
|
|
Raises IndexError if no items are present.
|
|
|
|
.. function:: namedtuple(name, fields)
|
|
|
|
This is factory function to create a new namedtuple type with a specific
|
|
name and set of fields. A namedtuple is a subclass of tuple which allows
|
|
to access its fields not just by numeric index, but also with an attribute
|
|
access syntax using symbolic field names. Fields is a sequence of strings
|
|
specifying field names. For compatibility with CPython it can also be a
|
|
a string with space-separated field named (but this is less efficient).
|
|
Example of use::
|
|
|
|
from collections import namedtuple
|
|
|
|
MyTuple = namedtuple("MyTuple", ("id", "name"))
|
|
t1 = MyTuple(1, "foo")
|
|
t2 = MyTuple(2, "bar")
|
|
print(t1.name)
|
|
assert t2.name == t2[1]
|
|
|
|
.. function:: OrderedDict(...)
|
|
|
|
``dict`` type subclass which remembers and preserves the order of keys
|
|
added. When ordered dict is iterated over, keys/items are returned in
|
|
the order they were added::
|
|
|
|
from collections import OrderedDict
|
|
|
|
# To make benefit of ordered keys, OrderedDict should be initialized
|
|
# from sequence of (key, value) pairs.
|
|
d = OrderedDict([("z", 1), ("a", 2)])
|
|
# More items can be added as usual
|
|
d["w"] = 5
|
|
d["b"] = 3
|
|
for k, v in d.items():
|
|
print(k, v)
|
|
|
|
Output::
|
|
|
|
z 1
|
|
a 2
|
|
w 5
|
|
b 3
|