nanshe.util.iters module

The module iters provides support working with and creating generators.

Overview

The module iters provides a variety of functions targeted at working with or creating generators. It also borrows some functions from kenjutsu targeted at working with slices and tuples of slices. However, this borrowed API should be considered deprecated and is subject to removal.

API

nanshe.util.iters.filled_stringify_enumerate(*args, **kwargs)

Takes each element yielded by new_iter and reverses it using reversed.

Parameters:new_iter (iter) – an iterator to use for enumeration over. Returns:an iterator over the reversed elements. Return type:(generator object)

Examples

>>> filled_stringify_enumerate([5, 7]) #doctest: +ELLIPSIS
<generator object filled_stringify_enumerate at 0x...>

>>> list(filled_stringify_enumerate([]))
[]

>>> list(filled_stringify_enumerate(irange(5)))
[(0, '0', 0), (1, '1', 1), (2, '2', 2), (3, '3', 3), (4, '4', 4)]

>>> list(filled_stringify_enumerate(irange(2, 5)))
[(0, '0', 2), (1, '1', 3), (2, '2', 4)]

>>> list(filled_stringify_enumerate([5]))
[(0, '0', 5)]

>>> list(filled_stringify_enumerate([5, 7]))
[(0, '0', 5), (1, '1', 7)]

>>> list(filled_stringify_enumerate(iter([5, 7])))
[(0, '0', 5), (1, '1', 7)]

>>> list(filled_stringify_enumerate(range(11)))
[(0, '00', 0), (1, '01', 1), (2, '02', 2), (3, '03', 3), (4, '04', 4), (5, '05', 5), (6, '06', 6), (7, '07', 7), (8, '08', 8), (9, '09', 9), (10, '10', 10)]

nanshe.util.iters.filled_stringify_numbers(*args, **kwargs)

Like enumerate except it also returns a string with the number from enumeration with left padding by zero.

Parameters:new_iter (iter) – an iterator to use for enumeration over. Returns:an iterator over the reversed elements. Return type:(generator object)

Examples

>>> filled_stringify_numbers([5, 7]) #doctest: +ELLIPSIS
<generator object filled_stringify_numbers at 0x...>

>>> list(filled_stringify_numbers([]))
[]

>>> list(filled_stringify_numbers(irange(5)))
['0', '1', '2', '3', '4']

>>> list(filled_stringify_numbers([5]))
['5']

>>> list(filled_stringify_numbers([5, 7]))
['5', '7']

>>> list(filled_stringify_numbers([5, 7, 11]))
['05', '07', '11']

>>> list(
...     filled_stringify_numbers([5, 7, 11], include_numbers=True)
... )
[(5, '05'), (7, '07'), (11, '11')]

>>> list(
...     filled_stringify_numbers(
...         iter([5, 7, 11]),
...         include_numbers=True
...     )
... )
[(5, '05'), (7, '07'), (11, '11')]

nanshe.util.iters.filled_stringify_xrange(*args, **kwargs)

Takes each element yielded by new_iter and reverses it using reversed.

Parameters:new_iter (iter) – an iterator to use for enumeration over. Returns:an iterator over the reversed elements. Return type:(generator object)

Examples

>>> filled_stringify_xrange([5, 7]) #doctest: +ELLIPSIS
<generator object filled_stringify_xrange at 0x...>

>>> list(filled_stringify_xrange([]))
[]

>>> list(filled_stringify_xrange(irange(5)))
[(0, '0'), (1, '1'), (2, '2'), (3, '3'), (4, '4')]

>>> list(filled_stringify_xrange(irange(2, 5)))
[(0, '0'), (1, '1'), (2, '2')]

>>> list(filled_stringify_xrange([5]))
[(0, '0')]

>>> list(filled_stringify_xrange([5, 7]))
[(0, '0'), (1, '1')]

>>> list(filled_stringify_xrange(iter([5, 7])))
[(0, '0'), (1, '1')]

>>> list(filled_stringify_xrange(list(irange(11))))
[(0, '00'), (1, '01'), (2, '02'), (3, '03'), (4, '04'), (5, '05'), (6, '06'), (7, '07'), (8, '08'), (9, '09'), (10, '10')]

nanshe.util.iters.index_enumerator(*args, **kwargs)

Takes an argument list of sizes and iterates through them from 0 up to (but not including) each size (i.e. like index_generator). However, also included is an index corresponding to how many elements have been seen.

Parameters:*sizes (int) – an argument list of ints for the max sizes in each index. Returns:a generator over every possible coordinated Return type:chain_gen(generator)

Examples

>>> index_enumerator(0) #doctest: +ELLIPSIS
<enumerate object at 0x...>

>>> list(index_enumerator(0))
[]

>>> list(index_enumerator(0, 2))
[]

>>> list(index_enumerator(2, 0))
[]

>>> list(index_enumerator(2, 1))
[(0, (0, 0)), (1, (1, 0))]

>>> list(index_enumerator(1, 2))
[(0, (0, 0)), (1, (0, 1))]

>>> list(index_enumerator(3, 2))
[(0, (0, 0)), (1, (0, 1)), (2, (1, 0)), (3, (1, 1)), (4, (2, 0)), (5, (2, 1))]

nanshe.util.iters.iter_with_skip_indices(*args, **kwargs)

Behaves as a normal iterator except allows for skipping arbitrary values, as well. These values to be skipped should be specified by their indices using some iterable.

Parameters:

• a_iter (iter) – an iterator that will skip some values
• to_skip (iter) – some form of iterable or list of indices to skip (can be a single value as well).

Returns:

a generator that skips some values with

indices in to_skip.

Return type:

(generator object)

Examples

>>> iter_with_skip_indices(irange(10)) #doctest: +ELLIPSIS
<generator object iter_with_skip_indices at 0x...>

>>> list(iter_with_skip_indices(irange(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_indices(irange(10), to_skip = 2))
[0, 1, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_indices(irange(1, 10), to_skip = 2))
[1, 2, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_indices(irange(10), to_skip = [2, 7]))
[0, 1, 3, 4, 5, 6, 8, 9]

>>> list(iter_with_skip_indices(irange(10), to_skip = [0]))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_indices(irange(1, 10), to_skip = [0]))
[2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_indices(irange(10), to_skip = [9]))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

nanshe.util.iters.iter_with_skip_values(*args, **kwargs)

Behaves as a normal iterator except allows for skipping arbitrary values, as well. These values to be skipped should be specified by their indices using some iterable.

Parameters:

• a_iter (iter) – an iterator that will skip some values
• to_skip (iter) – some form of iterable or list of indices to skip (can be a single value as well).

Returns:

a generator that skips some values with

indices in to_skip.

Return type:

(generator object)

Examples

>>> iter_with_skip_values(irange(10)) #doctest: +ELLIPSIS
<generator object iter_with_skip_values at 0x...>

>>> list(iter_with_skip_values(irange(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_values(irange(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_values(irange(1, 10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_values(irange(0, 10, 2)))
[0, 2, 4, 6, 8]

>>> list(iter_with_skip_values(irange(1, 10, 2)))
[1, 3, 5, 7, 9]

>>> list(iter_with_skip_values(irange(10), to_skip = 2))
[0, 1, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_values(irange(1, 10), to_skip = 2))
[1, 3, 4, 5, 6, 7, 8, 9]

>>> list(iter_with_skip_values(irange(0, 10, 2), to_skip = [2,6]))
[0, 4, 8]

nanshe.util.iters.lagged_generators(*args, **kwargs)

Creates a tuple of generators with each next generator one step ahead of the previous generator.

Parameters:

• new_iter (iter) – an iterator or something that can be turned into an iterator
• n (int) – number of generators to create as lagged

Returns:

a tuple of iterators with each one

step in front of the others.

Return type:

(tuple of generator objects)

Examples

>>> lagged_generators(irange(5), 1) #doctest: +ELLIPSIS
(<itertools... object at 0x...>,)

>>> list(izip(*lagged_generators(irange(5), 1)))
[(0,), (1,), (2,), (3,), (4,)]

>>> list(izip(*lagged_generators(irange(5), 2)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(izip(*lagged_generators(irange(5))))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(izip(*lagged_generators(irange(5), 3)))
[(0, 1, 2), (1, 2, 3), (2, 3, 4)]

>>> list(izip_longest(*lagged_generators(irange(5))))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, None)]

>>> list(izip_longest(*lagged_generators(irange(5), 3)))
[(0, 1, 2), (1, 2, 3), (2, 3, 4), (3, 4, None), (4, None, None)]

nanshe.util.iters.lagged_generators_zipped(new_iter, n=2, longest=False, fillvalue=None)

nanshe.util.iters.list_indices_to_index_array(*args, **kwargs)

Converts a list of tuple indices to numpy index array.

Parameters:list_indices (list) – a list of indices corresponding to some array object Returns:

a tuple containing a numpy array for each

index

Return type:chain_gen(tuple)

Examples

>>> list_indices_to_index_array([])
()

>>> list_indices_to_index_array([(1,2)])
(array([1]), array([2]))

>>> list_indices_to_index_array([(1, 2), (5, 7), (33, 2)])
(array([ 1,  5, 33]), array([2, 7, 2]))

nanshe.util.iters.list_indices_to_numpy_bool_array(*args, **kwargs)

Much like list_indices_to_index_array except that it constructs numpy.ndarray with dtype of bool. All indices in list_indices are set to True in the numpy.ndarray. The rest are False by default.

Parameters:

• list_indices (list) – a list of indices corresponding to some numpy.ndarray object
• shape (tuple) – a tuple used to set the shape of the numpy.ndarray to return

Returns:

a numpy.ndarray with dtype bool (True for

indices in list_indices and False otherwise).

Return type:

result(numpy.ndarray)

Examples

>>> list_indices_to_numpy_bool_array([], ())
array(False, dtype=bool)

>>> list_indices_to_numpy_bool_array([], (0))
array([], dtype=bool)

>>> list_indices_to_numpy_bool_array([], (0,0))
array([], shape=(0, 0), dtype=bool)

>>> list_indices_to_numpy_bool_array([], shape=(1))
array([False], dtype=bool)

>>> list_indices_to_numpy_bool_array([(0,0)], (1,1))
array([[ True]], dtype=bool)

>>> list_indices_to_numpy_bool_array(
...     [(2,3), (0,0), (0,2), (1,1)], (3,4)
... )
array([[ True, False,  True, False],
       [False,  True, False, False],
       [False, False, False,  True]], dtype=bool)

nanshe.util.iters.reverse_each_element(*args, **kwargs)

Takes each element yielded by new_iter and reverses it using reversed.

Parameters:new_iter (iter) – an iterator or something that can be turned into an iterator. Returns:an iterator over the reversed elements. Return type:(generator object)

Examples

>>> reverse_each_element(
...     zip(irange(5, 11), irange(5))
... ) #doctest: +ELLIPSIS
<generator object reverse_each_element at 0x...>

>>> list(reverse_each_element(zip(irange(5, 11), irange(5))))
[(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]

>>> list(reverse_each_element(iter([[5]])))
[[5]]

>>> list(reverse_each_element(iter([[5,2,3], [1, 7, 9]])))
[[3, 2, 5], [9, 7, 1]]

nanshe.util.iters.splitting_xrange(a, *args)

nanshe.util.iters.xrange_with_skip(*args, **kwargs)

Behaves as irange does except allows for skipping arbitrary values, as well. These values to be skipped should be specified using some iterable.

Parameters:

• start (int) – start for irange or if stop is not specified this will be stop.
• stop (int) – stop for irange.
• stop – step for irange.
• to_skip (iter) – some form of iterable or list of elements to skip (can be a single value as well).

Returns:

an irange-like generator that skips some

values.

Return type:

(generator object)

Examples

>>> xrange_with_skip(10) #doctest: +ELLIPSIS
<generator object xrange_with_skip at 0x...>

>>> list(xrange_with_skip(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(xrange_with_skip(0, 10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(xrange_with_skip(1, 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(xrange_with_skip(0, 10, 2))
[0, 2, 4, 6, 8]

>>> list(xrange_with_skip(1, 10, 2))
[1, 3, 5, 7, 9]

>>> list(xrange_with_skip(10, to_skip = 2))
[0, 1, 3, 4, 5, 6, 7, 8, 9]

>>> list(xrange_with_skip(10, to_skip = [2, 7]))
[0, 1, 3, 4, 5, 6, 8, 9]

>>> list(xrange_with_skip(10, to_skip = [0]))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(xrange_with_skip(1, 10, to_skip = [0]))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(xrange_with_skip(10, to_skip = [9]))
[0, 1, 2, 3, 4, 5, 6, 7, 8]