OpenQuizz
Une application de gestion des contenus pédagogiques
setuptools._vendor.more_itertools.recipes Namespace Reference

Functions

def take (n, iterable)
 
def tabulate (function, start=0)
 
def tail (n, iterable)
 
def consume (iterator, n=None)
 
def nth (iterable, n, default=None)
 
def all_equal (iterable)
 
def quantify (iterable, pred=bool)
 
def pad_none (iterable)
 
def ncycles (iterable, n)
 
def dotproduct (vec1, vec2)
 
def flatten (listOfLists)
 
def repeatfunc (func, times=None, *args)
 
def pairwise (iterable)
 
def grouper (iterable, n, fillvalue=None)
 
def roundrobin (*iterables)
 
def partition (pred, iterable)
 
def powerset (iterable)
 
def unique_everseen (iterable, key=None)
 
def unique_justseen (iterable, key=None)
 
def iter_except (func, exception, first=None)
 
def first_true (iterable, default=None, pred=None)
 
def random_product (*args, repeat=1)
 
def random_permutation (iterable, r=None)
 
def random_combination (iterable, r)
 
def random_combination_with_replacement (iterable, r)
 
def nth_combination (iterable, r, index)
 
def prepend (value, iterator)
 
def convolve (signal, kernel)
 

Variables

 padnone
 
 pairwise
 

Detailed Description

Imported from the recipes section of the itertools documentation.

All functions taken from the recipes section of the itertools library docs
[1]_.
Some backward-compatible usability improvements have been made.

.. [1] http://docs.python.org/library/itertools.html#recipes

Function Documentation

◆ all_equal()

def setuptools._vendor.more_itertools.recipes.all_equal (   iterable)
Returns ``True`` if all the elements are equal to each other.

    >>> all_equal('aaaa')
    True
    >>> all_equal('aaab')
    False

◆ consume()

def setuptools._vendor.more_itertools.recipes.consume (   iterator,
  n = None 
)
Advance *iterable* by *n* steps. If *n* is ``None``, consume it
entirely.

Efficiently exhausts an iterator without returning values. Defaults to
consuming the whole iterator, but an optional second argument may be
provided to limit consumption.

    >>> i = (x for x in range(10))
    >>> next(i)
    0
    >>> consume(i, 3)
    >>> next(i)
    4
    >>> consume(i)
    >>> next(i)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

If the iterator has fewer items remaining than the provided limit, the
whole iterator will be consumed.

    >>> i = (x for x in range(3))
    >>> consume(i, 5)
    >>> next(i)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

◆ convolve()

def setuptools._vendor.more_itertools.recipes.convolve (   signal,
  kernel 
)
Convolve the iterable *signal* with the iterable *kernel*.

    >>> signal = (1, 2, 3, 4, 5)
    >>> kernel = [3, 2, 1]
    >>> list(convolve(signal, kernel))
    [3, 8, 14, 20, 26, 14, 5]

Note: the input arguments are not interchangeable, as the *kernel*
is immediately consumed and stored.

◆ dotproduct()

def setuptools._vendor.more_itertools.recipes.dotproduct (   vec1,
  vec2 
)
Returns the dot product of the two iterables.

>>> dotproduct([10, 10], [20, 20])
400

◆ first_true()

def setuptools._vendor.more_itertools.recipes.first_true (   iterable,
  default = None,
  pred = None 
)
Returns the first true value in the iterable.

If no true value is found, returns *default*

If *pred* is not None, returns the first item for which
``pred(item) == True`` .

    >>> first_true(range(10))
    1
    >>> first_true(range(10), pred=lambda x: x > 5)
    6
    >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
    'missing'

◆ flatten()

def setuptools._vendor.more_itertools.recipes.flatten (   listOfLists)
Return an iterator flattening one level of nesting in a list of lists.

    >>> list(flatten([[0, 1], [2, 3]]))
    [0, 1, 2, 3]

See also :func:`collapse`, which can flatten multiple levels of nesting.

◆ grouper()

def setuptools._vendor.more_itertools.recipes.grouper (   iterable,
  n,
  fillvalue = None 
)
Collect data into fixed-length chunks or blocks.

>>> list(grouper('ABCDEFG', 3, 'x'))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]

◆ iter_except()

def setuptools._vendor.more_itertools.recipes.iter_except (   func,
  exception,
  first = None 
)
Yields results from a function repeatedly until an exception is raised.

Converts a call-until-exception interface to an iterator interface.
Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel
to end the loop.

    >>> l = [0, 1, 2]
    >>> list(iter_except(l.pop, IndexError))
    [2, 1, 0]

◆ ncycles()

def setuptools._vendor.more_itertools.recipes.ncycles (   iterable,
  n 
)
Returns the sequence elements *n* times

>>> list(ncycles(["a", "b"], 3))
['a', 'b', 'a', 'b', 'a', 'b']

◆ nth()

def setuptools._vendor.more_itertools.recipes.nth (   iterable,
  n,
  default = None 
)
Returns the nth item or a default value.

>>> l = range(10)
>>> nth(l, 3)
3
>>> nth(l, 20, "zebra")
'zebra'

◆ nth_combination()

def setuptools._vendor.more_itertools.recipes.nth_combination (   iterable,
  r,
  index 
)
Equivalent to ``list(combinations(iterable, r))[index]``.

The subsequences of *iterable* that are of length *r* can be ordered
lexicographically. :func:`nth_combination` computes the subsequence at
sort position *index* directly, without computing the previous
subsequences.

    >>> nth_combination(range(5), 3, 5)
    (0, 3, 4)

``ValueError`` will be raised If *r* is negative or greater than the length
of *iterable*.
``IndexError`` will be raised if the given *index* is invalid.

◆ pad_none()

def setuptools._vendor.more_itertools.recipes.pad_none (   iterable)
Returns the sequence of elements and then returns ``None`` indefinitely.

    >>> take(5, pad_none(range(3)))
    [0, 1, 2, None, None]

Useful for emulating the behavior of the built-in :func:`map` function.

See also :func:`padded`.

◆ pairwise()

def setuptools._vendor.more_itertools.recipes.pairwise (   iterable)

◆ partition()

def setuptools._vendor.more_itertools.recipes.partition (   pred,
  iterable 
)
Returns a 2-tuple of iterables derived from the input iterable.
The first yields the items that have ``pred(item) == False``.
The second yields the items that have ``pred(item) == True``.

    >>> is_odd = lambda x: x % 2 != 0
    >>> iterable = range(10)
    >>> even_items, odd_items = partition(is_odd, iterable)
    >>> list(even_items), list(odd_items)
    ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])

If *pred* is None, :func:`bool` is used.

    >>> iterable = [0, 1, False, True, '', ' ']
    >>> false_items, true_items = partition(None, iterable)
    >>> list(false_items), list(true_items)
    ([0, False, ''], [1, True, ' '])

◆ powerset()

def setuptools._vendor.more_itertools.recipes.powerset (   iterable)
Yields all possible subsets of the iterable.

    >>> list(powerset([1, 2, 3]))
    [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

:func:`powerset` will operate on iterables that aren't :class:`set`
instances, so repeated elements in the input will produce repeated elements
in the output. Use :func:`unique_everseen` on the input to avoid generating
duplicates:

    >>> seq = [1, 1, 0]
    >>> list(powerset(seq))
    [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
    >>> from more_itertools import unique_everseen
    >>> list(powerset(unique_everseen(seq)))
    [(), (1,), (0,), (1, 0)]

◆ prepend()

def setuptools._vendor.more_itertools.recipes.prepend (   value,
  iterator 
)
Yield *value*, followed by the elements in *iterator*.

    >>> value = '0'
    >>> iterator = ['1', '2', '3']
    >>> list(prepend(value, iterator))
    ['0', '1', '2', '3']

To prepend multiple values, see :func:`itertools.chain`
or :func:`value_chain`.

◆ quantify()

def setuptools._vendor.more_itertools.recipes.quantify (   iterable,
  pred = bool 
)
Return the how many times the predicate is true.

>>> quantify([True, False, True])
2

◆ random_combination()

def setuptools._vendor.more_itertools.recipes.random_combination (   iterable,
  r 
)
Return a random *r* length subsequence of the elements in *iterable*.

    >>> random_combination(range(5), 3)  # doctest:+SKIP
    (2, 3, 4)

This equivalent to taking a random selection from
``itertools.combinations(iterable, r)``.

◆ random_combination_with_replacement()

def setuptools._vendor.more_itertools.recipes.random_combination_with_replacement (   iterable,
  r 
)
Return a random *r* length subsequence of elements in *iterable*,
allowing individual elements to be repeated.

    >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
    (0, 0, 1, 2, 2)

This equivalent to taking a random selection from
``itertools.combinations_with_replacement(iterable, r)``.

◆ random_permutation()

def setuptools._vendor.more_itertools.recipes.random_permutation (   iterable,
  r = None 
)
Return a random *r* length permutation of the elements in *iterable*.

If *r* is not specified or is ``None``, then *r* defaults to the length of
*iterable*.

    >>> random_permutation(range(5))  # doctest:+SKIP
    (3, 4, 0, 1, 2)

This equivalent to taking a random selection from
``itertools.permutations(iterable, r)``.

◆ random_product()

def setuptools._vendor.more_itertools.recipes.random_product ( args,
  repeat = 1 
)
Draw an item at random from each of the input iterables.

    >>> random_product('abc', range(4), 'XYZ')  # doctest:+SKIP
    ('c', 3, 'Z')

If *repeat* is provided as a keyword argument, that many items will be
drawn from each iterable.

    >>> random_product('abcd', range(4), repeat=2)  # doctest:+SKIP
    ('a', 2, 'd', 3)

This equivalent to taking a random selection from
``itertools.product(*args, **kwarg)``.

◆ repeatfunc()

def setuptools._vendor.more_itertools.recipes.repeatfunc (   func,
  times = None,
args 
)
Call *func* with *args* repeatedly, returning an iterable over the
results.

If *times* is specified, the iterable will terminate after that many
repetitions:

    >>> from operator import add
    >>> times = 4
    >>> args = 3, 5
    >>> list(repeatfunc(add, times, *args))
    [8, 8, 8, 8]

If *times* is ``None`` the iterable will not terminate:

    >>> from random import randrange
    >>> times = None
    >>> args = 1, 11
    >>> take(6, repeatfunc(randrange, times, *args))  # doctest:+SKIP
    [2, 4, 8, 1, 8, 4]

◆ roundrobin()

def setuptools._vendor.more_itertools.recipes.roundrobin ( iterables)
Yields an item from each iterable, alternating between them.

    >>> list(roundrobin('ABC', 'D', 'EF'))
    ['A', 'D', 'E', 'B', 'F', 'C']

This function produces the same output as :func:`interleave_longest`, but
may perform better for some inputs (in particular when the number of
iterables is small).

◆ tabulate()

def setuptools._vendor.more_itertools.recipes.tabulate (   function,
  start = 0 
)
Return an iterator over the results of ``func(start)``,
``func(start + 1)``, ``func(start + 2)``...

*func* should be a function that accepts one integer argument.

If *start* is not specified it defaults to 0. It will be incremented each
time the iterator is advanced.

    >>> square = lambda x: x ** 2
    >>> iterator = tabulate(square, -3)
    >>> take(4, iterator)
    [9, 4, 1, 0]

◆ tail()

def setuptools._vendor.more_itertools.recipes.tail (   n,
  iterable 
)
Return an iterator over the last *n* items of *iterable*.

>>> t = tail(3, 'ABCDEFG')
>>> list(t)
['E', 'F', 'G']

◆ take()

def setuptools._vendor.more_itertools.recipes.take (   n,
  iterable 
)
Return first *n* items of the iterable as a list.

    >>> take(3, range(10))
    [0, 1, 2]

If there are fewer than *n* items in the iterable, all of them are
returned.

    >>> take(10, range(3))
    [0, 1, 2]

◆ unique_everseen()

def setuptools._vendor.more_itertools.recipes.unique_everseen (   iterable,
  key = None 
)
Yield unique elements, preserving order.

    >>> list(unique_everseen('AAAABBBCCDAABBB'))
    ['A', 'B', 'C', 'D']
    >>> list(unique_everseen('ABBCcAD', str.lower))
    ['A', 'B', 'C', 'D']

Sequences with a mix of hashable and unhashable items can be used.
The function will be slower (i.e., `O(n^2)`) for unhashable items.

Remember that ``list`` objects are unhashable - you can use the *key*
parameter to transform the list to a tuple (which is hashable) to
avoid a slowdown.

    >>> iterable = ([1, 2], [2, 3], [1, 2])
    >>> list(unique_everseen(iterable))  # Slow
    [[1, 2], [2, 3]]
    >>> list(unique_everseen(iterable, key=tuple))  # Faster
    [[1, 2], [2, 3]]

Similary, you may want to convert unhashable ``set`` objects with
``key=frozenset``. For ``dict`` objects,
``key=lambda x: frozenset(x.items())`` can be used.

◆ unique_justseen()

def setuptools._vendor.more_itertools.recipes.unique_justseen (   iterable,
  key = None 
)
Yields elements in order, ignoring serial duplicates

>>> list(unique_justseen('AAAABBBCCDAABBB'))
['A', 'B', 'C', 'D', 'A', 'B']
>>> list(unique_justseen('ABBCcAD', str.lower))
['A', 'B', 'C', 'A', 'D']

Variable Documentation

◆ padnone

padnone

◆ pairwise

pairwise