Back to index

python3.2  3.2.2
Classes | Functions | Variables
test.test_iterlen Namespace Reference


class  TestInvariantWithoutMutations
class  TestTemporarilyImmutable
class  TestRepeat
 ------- Concrete Type Tests ------- More...
class  TestXrange
class  TestXrangeCustomReversed
class  TestTuple
class  TestDeque
 ------- Types that should not be mutated during iteration ------- More...
class  TestDequeReversed
class  TestDictKeys
class  TestDictItems
class  TestDictValues
class  TestSet
class  TestList
 ------- Types that can mutate during iteration ------- More...
class  TestListReversed
class  BadLen
 -- Check to make sure exceptions are not suppressed by length_hint() More...
class  BadLengthHint
class  NoneLengthHint
class  TestLengthHintExceptions


def len
def test_main


int n = 10

Detailed Description

Test Iterator Length Transparency

Some functions or methods which accept general iterable arguments have
optional, more efficient code paths if they know how many items to expect.
For instance, map(func, iterable), will pre-allocate the exact amount of
space required whenever the iterable can report its length.

The desired invariant is:  len(it)==len(list(it)).

A complication is that an iterable and iterator can be the same object. To
maintain the invariant, an iterator needs to dynamically update its length.
For instance, an iterable such as range(10) always reports its length as ten,
but it=iter(range(10)) starts at ten, and then goes to nine after next(it).
Having this capability means that map() can ignore the distinction between
map(func, iterable) and map(func, iter(iterable)).

When the iterable is immutable, the implementation can straight-forwardly
report the original length minus the cumulative number of calls to next().
This is the case for tuples, range objects, and itertools.repeat().

Some containers become temporarily immutable during iteration.  This includes
dicts, sets, and collections.deque.  Their implementation is equally simple
though they need to permanently set their length to zero whenever there is
an attempt to iterate after a length mutation.

The situation slightly more involved whenever an object allows length mutation
during iteration.  Lists and sequence iterators are dynamically updatable.
So, if a list is extended during iteration, the iterator will continue through
the new items.  If it shrinks to a point before the most recent iteration,
then no further items are available and the length is reported at zero.

Reversed objects can also be wrapped around mutable objects; however, any
appends after the current position are ignored.  Any other approach leads
to confusion and possibly returning the same item more than once.

The iterators not listed above, such as enumerate and the other itertools,
are not length transparent because they have no way to distinguish between
iterables that report static length and iterators whose length changes with
each call (i.e. the difference between enumerate('abc') and

Function Documentation

def test.test_iterlen.len (   obj)

Definition at line 52 of file

00053 def len(obj):
00054     try:
00055         return _len(obj)
00056     except TypeError:
00057         try:
00058             # note: this is an internal undocumented API,
00059             # don't rely on it in your own programs
00060             return obj.__length_hint__()
00061         except AttributeError:
00062             raise TypeError

Here is the caller graph for this function:

Definition at line 232 of file

00233 def test_main():
00234     unittests = [
00235         TestRepeat,
00236         TestXrange,
00237         TestXrangeCustomReversed,
00238         TestTuple,
00239         TestDeque,
00240         TestDequeReversed,
00241         TestDictKeys,
00242         TestDictItems,
00243         TestDictValues,
00244         TestSet,
00245         TestList,
00246         TestListReversed,
00247         TestLengthHintExceptions,
00248     ]
00249     support.run_unittest(*unittests)

Variable Documentation

Definition at line 50 of file