Ë
|
Añúh¯o ã ó d Z ddlZddlZddlmZ ddlmZ ddlmZm Z ddl
|
m Z m Z m Z mZmZmZmZmZmZmZmZmZ ddlmZmZmZ ddlm Z g d ¢Z e « Z e d
|
¬ « ee d
|
¬ « Z! e#ed d « Z$d Z%dGdZ&d Z'dHdZ(dHdZ)dHdZ*e+fdZ,d Z-e-Z.d Z/d Z0d Z1dHdZ2d Z3 ddl
|
m4Z5 d Z4e3j e4_ G d d e7« Z8d Z9d Z:dId!Z;d" Z<d# Z=d$ Z>dHd%Z?dHd&Z@dJd(ZAdHd)ZBdKd*ZCd+d,d-ZDdHd.ZEd/ ZFd0 ZGd1 ZHd2 ZId3 ZJd4 ZKd5 ZLd6 ZMd7 ZNd8 ZOdLd9ZPd: ZQd'd d;ZRe d<k\ r dd=l
|
mSZT d'd d>ZSneRZSeRj eS_ d? ZUd@ ZVdA ZWdB ZXdC ZYdD ZZdE Z[dF Z\y# e"$ r e Z!Y w xY w# e6$ r e3Z4Y ¼w xY w)Ma 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
|
|
é N)Údeque)ÚSized)ÚpartialÚreduce) ÚchainÚ combinationsÚcompressÚcountÚcycleÚgroupbyÚisliceÚproductÚrepeatÚstarmapÚteeÚ zip_longest)Ú randrangeÚsampleÚchoice)Ú
|
hexversion).Ú all_equalÚbatchedÚbefore_and_afterÚconsumeÚconvolveÚ
|
dotproductÚ
|
first_trueÚfactorÚflattenÚgrouperÚ iter_exceptÚ
|
iter_indexÚmatmulÚncyclesÚnthÚnth_combinationÚpadnoneÚpad_noneÚpairwiseÚ partitionÚpolynomial_evalÚpolynomial_from_rootsÚpolynomial_derivativeÚpowersetÚprependÚquantifyÚreshapeÚ#random_combination_with_replacementÚrandom_combinationÚrandom_permutationÚrandom_productÚ
|
repeatfuncÚ
|
roundrobinÚsieveÚsliding_windowÚ subslicesÚsum_of_squaresÚtabulateÚtailÚtakeÚtotientÚ transposeÚ
|
triplewiseÚuniqueÚunique_everseenÚunique_justseenT©ÚstrictÚsumprodc ó t | |« S ©N)r )ÚxÚys ú\H:\Change_password\venv_build\Lib\site-packages\setuptools/_vendor/more_itertools/recipes.pyú<lambda>rM _ s ´¸A¸qÓ1A ó c ó, t t || « « S )zñ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]
|
|
)Úlistr ©ÚnÚiterables rL r> r> b s ô x Ó#Ó $Ð$rN c ó, t | t |« « S )a© 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]
|
|
)Úmapr
|
)ÚfunctionÚstarts rL r< r< r s ô xu Ó &Ð&rN c # óÈ K t |t « r,t |t dt |« | z
|
« d« E d{ yt t || ¬« « E d{ y7 $7 w)zReturn an iterator over the last *n* items of *iterable*.
|
|
>>> t = tail(3, 'ABCDEFG')
|
>>> list(t)
|
['E', 'F', 'G']
|
|
r N©Úmaxlen)Ú
|
isinstancer r ÚmaxÚlenÚiterr rQ s rL r= r= sS è ø ô (EÔ"Ü(¤C¨¬3¨x«=¸1Ñ+<Ó$=¸tÓD×DÑDäh¨qÔ1Ó2×2Ñ2ð Eøà2ús! 7A"¹A º A"ÁA ÁA"Á A"c óR |t | d¬« yt t | ||« d« y)aX 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
|
|
Nr rY )r Únextr )ÚiteratorrR s rL r r s) ð@ yä hqÖ!ô VHa Ó # TÕ*rN c ó0 t t | |d« |« S )z
Returns the nth item or a default value.
|
|
>>> l = range(10)
|
>>> nth(l, 3)
|
3
|
>>> nth(l, 20, "zebra")
|
'zebra'
|
|
N)r` r )rS rR Údefaults rL r% r% ¾ s ô x DÓ)¨7Ó 3Ð3rN c
|
óX t t t t | |« d« « « dk S )a§
|
Returns ``True`` if all the elements are equal to each other.
|
|
>>> all_equal('aaaa')
|
True
|
>>> all_equal('aaab')
|
False
|
|
A function that accepts a single argument and returns a transformed version
|
of each input item can be specified with *key*:
|
|
>>> all_equal('AaaA', key=str.casefold)
|
True
|
>>> all_equal([1, 2, 3], key=lambda x: x < 10)
|
True
|
|
é é )r] rP r r ©rS Úkeys rL r r Ë s' ô$ tF7 8¨SÓ1°1Ó5Ó6Ó 7¸1Ñ <Ð<rN c ó, t t || « « S )zcReturn the how many times the predicate is true.
|
|
>>> quantify([True, False, True])
|
2
|
|
)ÚsumrU )rS Úpreds rL r0 r0 à s ô s4Ó"Ó #Ð#rN c ó, t | t d« « S )a 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`.
|
|
N)r r ©rS s rL r( r( ê s ô 6 $<Ó (Ð(rN c óR t j t t | « |« « S )zvReturns the sequence elements *n* times
|
|
>>> list(ncycles(["a", "b"], 3))
|
['a', 'b', 'a', 'b', 'a', 'b']
|
|
)r Ú from_iterabler Útuple)rS rR s rL r$ r$ û s ô × Ñ v¤e¨H£o°qÓ 9Ó :Ð:rN c óJ t t t j | |« « S )zcReturns the dot product of the two iterables.
|
|
>>> dotproduct([10, 10], [20, 20])
|
400
|
|
)rj rU ÚoperatorÚmul)Úvec1Úvec2s rL r r s ô s8<< tÓ,Ó -Ð-rN c ó, t j | « S )zÜ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.
|
|
)r ro )Ú listOfListss rL r r s ô × Ñ {Ó +Ð+rN c ó\ |t | t |« « S t | t ||« « S )aG 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]
|
|
)r r )ÚfuncÚtimesÚargss rL r6 r6 s. ð, }ÜtV D\Ó*Ð*Ü 4 eÓ,Ó -Ð-rN c óN t | « \ }}t |d« t ||« S )zâReturns an iterator of paired items, overlapping, from the original
|
|
>>> take(4, pairwise(count()))
|
[(0, 1), (1, 2), (2, 3), (3, 4)]
|
|
On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`.
|
|
N)r r` Úzip)rS ÚaÚbs rL Ú _pairwiser 6 s& ô x=DAqÜDMÜ q!9ÐrN ©r) c ó t | « S rI )Úitertools_pairwiserm s rL r) r) J s Ü! (Ó+Ð+rN c ó e Zd Zd fd Z xZS )ÚUnequalIterablesErrorc óP d}|| dj | z }t | |« y )Nz Iterables have different lengthsz/: index 0 has length {}; index {} has length {})ÚformatÚsuperÚ__init__)ÚselfÚdetailsÚmsgÚ __class__s rL r z UnequalIterablesError.__init__Q s; ø Ø0Ø Ð Ø ÐMÐE×MÑMØðñ Cô ÑÕ rN rI )Ú__name__Ú
|
__module__Ú __qualname__r Ú __classcell__)r s @rL r
r
P s ø ÷ ñ rN r
c # ón K t | dt iD ] }|D ] }|t u s t « | ! y w)NÚ fillvalue)r Ú_markerr
)Ú iterablesÚcomboÚvals rL Ú_zip_equal_generatorr [ sE è ø Ü iÐ;´7Ñ;ò Øò .CØg~Ü+Ó-Ð-ð .ð ñ ùs 5£5c óÐ t | d « }t | dd d« D ]$ \ }}t |« }||k7 st |||f¬« t | S # t $ r t | « cY S w xY w)Nr rf )r )r] Ú enumerater
r} Ú TypeErrorr )r Ú
|
first_sizeÚiÚitÚsizes rL Ú
|
_zip_equalr c s ð /Ü 1 Ó&
|
Ü y¨¨}¨aÓ0ò KEArÜr7DØzÓ!Ü+°ZÀÀDÐ4IÔJÐJð Kô
|
IÐ øô ò /Ü# IÓ.Ò.ð/ús 3A ¶A ÁA%Á$A%c ó t | « g|z }|dk( r t |d|iS |dk( rt | S |dk( rt | S t d« )a½ Group elements from *iterable* into fixed-length groups of length *n*.
|
|
>>> list(grouper('ABCDEF', 3))
|
[('A', 'B', 'C'), ('D', 'E', 'F')]
|
|
The keyword arguments *incomplete* and *fillvalue* control what happens for
|
iterables whose length is not a multiple of *n*.
|
|
When *incomplete* is `'fill'`, the last group will contain instances of
|
*fillvalue*.
|
|
>>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x'))
|
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]
|
|
When *incomplete* is `'ignore'`, the last group will not be emitted.
|
|
>>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x'))
|
[('A', 'B', 'C'), ('D', 'E', 'F')]
|
|
When *incomplete* is `'strict'`, a subclass of `ValueError` will be raised.
|
|
>>> it = grouper('ABCDEFG', 3, incomplete='strict')
|
>>> list(it) # doctest: +IGNORE_EXCEPTION_DETAIL
|
Traceback (most recent call last):
|
...
|
UnequalIterablesError
|
|
Úfillr rF Úignorez Expected fill, strict, or ignore)r^ r r r} Ú
|
ValueError)rS rR Ú
|
incompleter r{ s rL r r s s^ ô: NÐ aÑ DØVÒÜDÐ6¨IÑ6Ð6ØXÒ Ü4Ð Ð ØXÒ ÜDzÐäÐ;Ó<Ð<rN c ' óÀ K t t | « }t t | « dd« D ]/ }t t ||« « }t t |« E d{ 1 y7 w)aJ 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).
|
|
r éÿÿÿÿN)rU r^ Úranger] r r r` )r Ú iteratorsÚ
|
num_actives rL r7 r7 sT è ø ô D)Ó$IÜC N¨A¨rÓ2ò (
|
Ü& ¨JÓ7Ó8 ÜtYÓ'×'Ñ'ñ(à'ús AA ÁA ÁA c óÂ | t } t |d« \ }}}t t | |« « \ }}t |t t j
|
|« « t ||« fS )a¯
|
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, ' '])
|
|
é )Úboolr rU r rr Únot_)rk rS Út1Út2ÚpÚp1Úp2s rL r* r* sX ð( |ÜäHaÓ IBAÜ T1 Ó FBÜ RX]]¨BÓ/Ó 0´(¸2¸rÓ2BÐ CÐCrN c ó t | « t j fdt t « dz « D « « S )a1 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.
|
|
>>> seq = [1, 1, 0]
|
>>> list(powerset(seq))
|
[(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
|
|
For a variant that efficiently yields actual :class:`set` instances, see
|
:func:`powerset_of_sets`.
|
c 3 ó6 K | ] }t |« y wrI )r )Ú.0ÚrÚss rL ú <genexpr>zpowerset.<locals>.<genexpr>Û s øè ø Ò M°a|¨A¨q× 1Ñ Mùs rf )rP r ro r¨ r] )rS r¸ s @rL r. r. É s2 ø ô" XAÜ × Ñ Ó M¼5ÄÀQÃÈ!ÁÓ;LÔ MÓ MÐMrN c # óâ K t « }|j }g }|j }|du}| D ] }|r ||« n|} ||vr ||« | ! y# t $ r ||vr ||« | Y >w xY ww)a
|
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]]
|
|
Similarly, you may want to convert unhashable ``set`` objects with
|
``key=frozenset``. For ``dict`` objects,
|
``key=lambda x: frozenset(x.items())`` can be used.
|
|
N)ÚsetÚaddÚappendr ) rS rh ÚseensetÚ seenset_addÚseenlistÚ seenlist_addÚuse_keyÚelementÚks rL rC rC Þ s è ø ô6 eGØ++KØHØ??LØoGàò Ù #CL¨ð ØÑ ÙAØ øñ øô ò ØÑ Ù QØ ùð üs( :A/½AÁ A/ÁA,Á)A/Á+A,Á,A/c
|
óÄ |(t t j d« t | « « S t t t t j d« t | |« « « S )zá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']
|
|
r rf )rU rr Ú
|
itemgetterr r` rg s rL rD rD sL ð {Ü8×&Ñ& qÓ)¬7°8Ó+<Ó=Ð=ä tS×,Ñ,¨QÓ/´¸À3Ó1GÓHÓ IÐIrN Fc ó4 t t | ||¬« |¬« S )a° Yields unique elements in sorted order.
|
|
>>> list(unique([[1, 2], [3, 4], [1, 2]]))
|
[[1, 2], [3, 4]]
|
|
*key* and *reverse* are passed to :func:`sorted`.
|
|
>>> list(unique('ABBcCAD', str.casefold))
|
['A', 'B', 'c', 'D']
|
>>> list(unique('ABBcCAD', str.casefold, reverse=True))
|
['D', 'c', 'B', 'A']
|
|
The elements in *iterable* need not be hashable, but they must be
|
comparable for sorting to work.
|
)rh Úreverse)rh )rD Úsorted)rS rh rÈ s rL rB rB s ô 6 (°¸WÔEÈ3Ô OÐOrN c # óN K | |« | «
|
# |$ r Y yw xY ww)aÙ 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]
|
|
Multiple exceptions can be specified as a stopping condition:
|
|
>>> l = [1, 2, 3, '...', 4, 5, 6]
|
>>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
|
[7, 6, 5]
|
>>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
|
[4, 3, 2]
|
>>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
|
[]
|
|
N© )ry Ú exceptionÚfirsts rL r! r! - s8 è ø ð, Ø Ð Ù'MØÙ&Lð øà ò Ù ð üs % "%¡"¢%c ó. t t || « |« S )a
|
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'
|
|
)r` Úfilter)rS rc rk s rL r r L s ô" tXÓ&¨Ó 0Ð0rN rf )r c óh |D cg c] }t |« c}| z }t d |D « « S c c}w )aÇ 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)``.
|
|
c 3 ó2 K | ] }t |« y wrI )r )r¶ Úpools rL r¹ z!random_product.<locals>.<genexpr>q s è ø Ò0 $ Ñ0ùs )rp )r r{ rÒ Úpoolss rL r5 r5 ` s3 ð &*Ö *TU4[Ò *¨VÑ 3EÜ Ñ0¨%Ô0Ó 0Ð0ùò +s
/c ó` t | « }| t |« n|}t t ||« « S )ab 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)``.
|
|
)rp r] r )rS r· rÒ s rL r4 r4 t s- ô ?DØYD AAÜ a Ó !Ð!rN c ó t | « t « }t t t |« |« « }t fd|D « « S )zÿ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)``.
|
|
c 3 ó( K | ] }| y wrI rË ©r¶ r rÒ s rL r¹ z%random_combination.<locals>.<genexpr> ó øè ø Ò*QaÑ*ùó )rp r] rÉ r r¨ )rS r· rR ÚindicesrÒ s @rL r3 r3 s= ø ô ?DÜ D AÜVE !H aÓ(Ó)GÜ Ó* 'Ô*Ó *Ð*rN c ó t | « t « t fdt |« D « « }t fd|D « « S )aS 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)``.
|
|
c 3 ó4 K | ] }t « y wrI )r )r¶ r rR s rL r¹ z6random_combination_with_replacement.<locals>.<genexpr>£ s øè ø Ò4 aYq\Ñ4ùs c 3 ó( K | ] }| y wrI rË r× s rL r¹ z6random_combination_with_replacement.<locals>.<genexpr>¤ rØ rÙ )rp r] rÉ r¨ )rS r· rÚ rR rÒ s @@rL r2 r2 s< ù ô ?DÜ D AÜÓ4¬5°«8Ô4Ó4GÜ Ó* 'Ô*Ó *Ð*rN c ó t | « }t |« }|dk s||kD rt d}t |||z
|
« }t d|dz « D ] }|||z
|
|z z |z } |dk r||z }|dk s||k\ rt
|
g }|rL||z |z |dz
|
|dz
|
}}}||k\ r||z }|||z
|
z |z |dz
|
}}||k\ r|j |d|z
|
« |rLt |« S )a 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.
|
r rf r§ )rp r] r¤ Úminr¨ Ú
|
IndexErrorr½ ) rS r· ÚindexrÒ rR ÚcrÄ r Úresults rL r& r& § s ô ?DÜ D AØ A1q5ÜÐà AÜ Aq1u AÜ 1a!e_ò !Ø QOqÑ ð!ð qyØ
|
à u zÜÐà FÙ
|
Øa%1*a !e Q¨¡Ua1ØqjØ QJEØA; !Ñ# Q¨¡UqAð qjð d2 6lÔ#ò ô =ÐrN c ó t | g|« S )a 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`.
|
|
)r )Úvaluera s rL r/ r/ Ñ s ô %(Ó #Ð#rN c # óà K t |« ddd
}t |« }t dg|¬« |z }t | t d|dz
|
« « D ]! }|j |« t ||« # yw)aB 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.
|
|
Nr§ r rY rf )rp r] r r r r½ Ú_sumprod)ÚsignalÚkernelrR ÚwindowrJ s rL r r à sp è ø ô 6]4R4Ñ FÜ F AÜ A3qÔ ! AÑ %FÜ 66 ! Q¨¡UÓ+Ó ,ò 'Ø aÔÜvvÓ&Ó&ñ'ùs A,A.c óZ t « g fd}t « } |« |fS )aÆ A variant of :func:`takewhile` that allows complete access to the
|
remainder of the iterator.
|
|
>>> it = iter('ABCdEfGhI')
|
>>> all_upper, remainder = before_and_after(str.isupper, it)
|
>>> ''.join(all_upper)
|
'ABC'
|
>>> ''.join(remainder) # takewhile() would lose the 'd'
|
'dEfGhI'
|
|
Note that the first iterator must be fully consumed before the second
|
iterator can generate valid results.
|
c 3 óZ K D ]! } | « r| j | « y y wrI )r½ )Úelemr Ú predicateÚ
|
transitions rL Ú true_iteratorz'before_and_after.<locals>.true_iterator s3 øè ø Øò DÙØ
|
à×!Ñ! $Ô'Ùñ ùs (+)r^ r )rî r rð Úremainder_iteratorrï s `` @rL r r ö s5 ú ô
|
bBØJöô z¨2Ó.Ðá ?Ð .Ð .Ð.rN c # ó^ K t t | « « D ] \ \ }}\ }}|||f yw)zReturn overlapping triplets from *iterable*.
|
|
>>> list(triplewise('ABCDE'))
|
[('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')]
|
|
Nr )rS r~ Ú_r râ s rL rA rA s8 è ø ô #¤8¨HÓ#5Ó6ò AAØAg ñùs +-c # ó K t | « }t t ||dz
|
« |¬« }|D ] }|j |« t |« " yw)aY Return a sliding window of width *n* over *iterable*.
|
|
>>> list(sliding_window(range(6), 4))
|
[(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)]
|
|
If *iterable* has fewer than *n* items, then nothing is yielded:
|
|
>>> list(sliding_window(range(3), 4))
|
[]
|
|
For a variant with more features, see :func:`windowed`.
|
rf rY N)r^ r r r½ rp )rS rR r rê rJ s rL r9 r9 " sM è ø ô
|
h BÜ 6"a !eÓ$¨QÔ /FØ ò Ø aÔÜFmÓñ ùs A Ac
|
ó¾ t | « }t t t t t |« dz « d« « }t t j t |« |« S )zþReturn all contiguous non-empty subslices of *iterable*.
|
|
>>> list(subslices('ABC'))
|
[['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']]
|
|
This is similar to :func:`substrings`, but emits items in a different
|
order.
|
rf re )
|
rP r Úslicer r¨ r] rU rr Úgetitemr )rS ÚseqÚslicess rL r: r: 6 sF ô x.CÜ UL¬¬s°3«x¸!©|Ó)<¸aÓ @Ó AFÜ x× Ñ ¤¨£¨fÓ 5Ð5rN c ó t t d« t t j | « « }t t t |dg« « S )zÌCompute a polynomial's coefficients from its roots.
|
|
>>> roots = [5, -4, 3] # (x - 5) * (x + 4) * (x - 3)
|
>>> polynomial_from_roots(roots) # x^3 - 4 * x^2 - 17 * x + 60
|
[1, -4, -17, 60]
|
rf )r} r rU rr ÚnegrP r r )ÚrootsÚfactorss rL r, r, D s5 ô &)S¤§ ¡ ¨uÓ 5Ó6GÜ x ¨1¨#Ó.Ó /Ð/rN c # óö K t | dd« }|0t | ||« }t ||« D ] \ }}||u s||k( s| y| t | « n|}|dz
|
} |||dz |« x} # t $ r Y yw xY ww)aû Yield the index of each place in *iterable* that *value* occurs,
|
beginning with index *start* and ending before index *stop*.
|
|
|
>>> list(iter_index('AABCADEAF', 'A'))
|
[0, 1, 4, 7]
|
>>> list(iter_index('AABCADEAF', 'A', 1)) # start index is inclusive
|
[1, 4, 7]
|
>>> list(iter_index('AABCADEAF', 'A', 1, 7)) # stop index is not inclusive
|
[1, 4]
|
|
The behavior for non-scalar *values* matches the built-in Python types.
|
|
>>> list(iter_index('ABCDABCD', 'AB'))
|
[0, 4]
|
>>> list(iter_index([0, 1, 2, 3, 0, 1, 2, 3], [0, 1]))
|
[]
|
>>> list(iter_index([[0, 1], [2, 3], [0, 1], [2, 3]], [0, 1]))
|
[0, 2]
|
|
See :func:`locate` for a more general means of finding the indexes
|
associated with particular values.
|
|
rá Nrf )Úgetattrr r r] r¤ )rS rå rW ÚstopÚ seq_indexr r rà s rL r" r" O s¨ è ø ô2 '¨4Ó0IØÐä He TÓ *Ü# B¨Ó.ò JAwØ%Ñ 7¨eÓ#3Øñ ð
|
!% s8}°$Ø AIð ØÙ % e¨Q°©U°DÓ 9Ð9qÒ:ð øäò Ù ð üs( 8A9»A9ÁA* Á* A6Á3A9Á5A6Á6A9c # ój K | dkD rd d}t d« | dz z }t j | « dz }t |d||« D ]Q }t |d|||z « E d{ t t t ||z | ||z « « « |||z | ||z
< ||z }S t |d|« E d{ y7 R7 w)zdYield the primes less than n.
|
|
>>> list(sieve(30))
|
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
|
re r¬ )r rf rf N)Ú bytearrayÚmathÚisqrtr" Úbytesr] r¨ )rR rW ÚdataÚlimitr± s rL r8 r8 z sÌ è ø ð 1uØØ EÜ VÓ Q¡Ñ 'DÜ JJqMAÑ EÜ a ¨Ó .ò Ü d A u¨a°!©eÓ4×4Ð4Ü"'¬¬E°!°a±%¸¸AÀ¹EÓ,BÓ(CÓ"DQUQQÐ Ñ ØAðô $ 5Ó)×)Ñ)ð 5øð *ús% AB3Á B/Á A B3Â)B1Â*B3Â1B3c # óà K |dk r t d« t | « }t t ||« « x}r8|rt |« |k7 r t d« | t t ||« « x}r7yyw)a Batch data into tuples of length *n*. If the number of items in
|
*iterable* is not divisible by *n*:
|
* The last batch will be shorter if *strict* is ``False``.
|
* :exc:`ValueError` will be raised if *strict* is ``True``.
|
|
>>> list(batched('ABCDEFG', 3))
|
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]
|
|
On Python 3.13 and above, this is an alias for :func:`itertools.batched`.
|
rf zn must be at least onezbatched(): incomplete batchN)r¤ r^ rp r r] )rS rR rF r Úbatchs rL Ú_batchedr sp è ø ð 1uÜÐ1Ó2Ð2Ü h BÜ A Ó'Ð
|
'%Ð
|
'Ù c%j AoÜ Ð :Ó;Ð ;Ø ô A Ó'Ð
|
'%Ó
|
'ùs A)A.Á,A.i¢ )r c ó t | ||¬« S )NrE )Úitertools_batched)rS rR rF s rL r r £ s Ü ¨1°VÔ<Ð<rN c ó t | S )a Swap the rows and columns of the input matrix.
|
|
>>> list(transpose([(1, 2, 3), (11, 22, 33)]))
|
[(1, 11), (2, 22), (3, 33)]
|
|
The caller should ensure that the dimensions of the input are compatible.
|
If the input is empty, no output will be produced.
|
)Ú _zip_strict©r s rL r@ r@ ¬ s ô Ð ÐrN c ó@ t t j | « |« S )zÆReshape the 2-D input *matrix* to have a column count given by *cols*.
|
|
>>> matrix = [(0, 1), (2, 3), (4, 5)]
|
>>> cols = 3
|
>>> list(reshape(matrix, cols))
|
[(0, 1, 2), (3, 4, 5)]
|
)r r ro )ÚmatrixÚcolss rL r1 r1 ¸ s ô 5×&Ñ& vÓ.°Ó 5Ð5rN c óx t |d « }t t t t | t |« « « |« S )zÚMultiply two matrices.
|
|
>>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)]))
|
[(49, 80), (41, 60)]
|
|
The caller should ensure that the dimensions of the input matrices are
|
compatible with each other.
|
r )r] r r rç r r@ )Úm1Úm2rR s rL r# r# Ã s0 ô BqE
|
AÜ 78¤W¨R´¸2³ Ó%?Ó@À!Ó DÐDrN c # ó¤ K t t j | « dz « D ] }| |z r | | |z } | dk( r y| |z s | dkD r| yyw)zTYield the prime factors of n.
|
|
>>> list(factor(360))
|
[2, 2, 2, 3, 3, 5]
|
rf N)r8 r r )rR Úprimes rL r r Ð sd è ø ô tzz !} qÑ(Ó)ò Øe)ØKØ %KAØAvÙð e)ðð 1uØð ùs *AAÁ Ac ó t | « }|dk( r|dz S t t t |« t t |« « « }t | |« S )zÜEvaluate a polynomial at a specific value.
|
|
Example: evaluating x^3 - 4 * x^2 - 17 * x + 60 at x = 2.5:
|
|
>>> coefficients = [1, -4, -17, 60]
|
>>> x = 2.5
|
>>> polynomial_eval(coefficients, x)
|
8.125
|
r )r] rU Úpowr Úreversedr¨ rç )Ú coefficientsrJ rR Úpowerss rL r+ r+ à sF ô LÓAØAvØ1u Ü fQi¤¬%°«(Ó!3Ó 4FÜ L &Ó )Ð)rN c ó$ t t | « S )zfReturn the sum of the squares of the input values.
|
|
>>> sum_of_squares([10, 20, 30])
|
1400
|
)rç r r s rL r; r; ñ s ô SWÐ Ð rN c ó t | « }t t d|« « }t t t
|
j | |« « S )a Compute the first derivative of a polynomial.
|
|
Example: evaluating the derivative of x^3 - 4 * x^2 - 17 * x + 60
|
|
>>> coefficients = [1, -4, -17, 60]
|
>>> derivative_coefficients = polynomial_derivative(coefficients)
|
>>> derivative_coefficients
|
[3, -8, -17]
|
rf )r] r r¨ rP rU rr rs )r rR r s rL r- r- ú s6 ô LÓAÜ eAqkÓ "FÜ HLL ,°Ó7Ó 8Ð8rN c óN t t | « « D ] }| |z |dz
|
z } | S )zReturn the count of natural numbers up to *n* that are coprime with *n*.
|
|
>>> totient(9)
|
6
|
>>> totient(12)
|
4
|
rf )r» r )rR r± s rL r? r? s4 ô ^ò Ø Fa!eÑ ð ð HrN )r rI )r¢ N)NF)NN)r N)]Ú__doc__r rr Ú collectionsr Úcollections.abcr Ú functoolsr r Ú itertoolsr r r r
|
r r r r r r r r Úrandomr r r Úsysr Ú__all__Úobjectr r} r r rÿ rç r> r< r= r r% r r r0 r( r' r$ r r r6 r r) r Ú ImportErrorr¤ r
r r r r7 r* r. rC rD rB r! r r5 r4 r3 r2 r& r/ r r rA r9 r: r, r" r8 r r r r@ r1 r# r r+ r; r- r? rË rN rL ú<module>r+ s ðñó Û å Ý !ß %÷ ÷ ÷ ó ÷ -Ñ ,Ý ò/ ñb (ð,ÙtÕñ # dÔ+Kñ 4Ñ$AÓ Bò %ó 'ò$3ó$%+óP
|
4ó=ð* !ó $ò )ð ò;ò.ò ,ó.ò6 ð )Ý8ò
|
,ð !×(Ñ(HÔô Jô òò /ó %=òP(ò$Dò8Nó** óZ Jó Pó& ó>1ð( "#ô 1ó("ò$ +ò +ò"'òT $ò 'ò, /òBò ò( 6ò 0ó(òV*ð$ %*ô ð( ÒÝ6à',õ =ð Gà ×&Ñ&GOò ò6ò
|
Eò ò *ò" ò 9ó øða ò ØKðûðZ ò ØHðús$ Á E% Â&E3 Å%E0Å/E0Å3E=Å<E=
|
