Itertool functions¶
Les fonctions du module suivant construisent et renvoient tous les itérateurs. Certains providestreams de longueur infinie, ils ne devraient donc être accessibles que par des fonctions ouloops qui tronquent le flux.
itertools.accumulate(itérable)¶
Créer un itérateur qui renvoie les sommes accumulées ou les résultats accumulés d’autres fonctions binaires (spécifiés via l’argument optionalfunc).,
Si func est fourni, il devrait s’agir d’une fonction de deux arguments. Les éléments de l’itérable d’entrée peuvent être de n’importe quel typece qui peut être accepté comme arguments à func. (Par exemple, avec l’opération par défaut d’addition, les éléments peuvent être n’importe quel type addabletype, y compris Decimal ouFraction.)
Habituellement, le nombre d’éléments en sortie correspond à l’itérable d’entrée.Cependant, si l’argument de mot clé initial est fourni, theaccumulation conduit avec la valeur initiale de sorte que outputhas un élément de plus que l’itérable d’entrée.,
À peu près équivalent à:
Il existe un certain nombre d’utilisations pour l’argument func. Il peut être réglé àmin() pour l’exécution d’un minimum, un max() pour l’exécution d’un maximum ou unoperator.mul() pour l’exécution d’un produit. Les tables d’amortissement peuvent êtreconstruit en accumulant des intérêts et en appliquant des paiements. Les relations de premier ordre peuvent être modélisées en fournissant la valeur initiale dans l’itérable et en utilisant uniquement le total accumulé dans l’argument func:
Voir functools.reduce() pour une fonction similaire qui ne renvoie que la valeur finale accumulée.,
Nouveau dans la version 3.2.
Modifié dans la version 3.3: Ajout du paramètre optionnel func.
Modifié dans la version 3.8: Ajout de l’option initiale du paramètre.
itertools.chain(*itérables)¶
Crée un itérateur qui renvoie les éléments du premier itérable jusqu’à ce qu’il soit exhaussé, puis passe à l’itérable suivant, jusqu’à ce que tous les itérables soient exhaussés. Utilisé pour traiter des séquences consécutives comme une seule séquence.,À peu près équivalent à:
def chain(*iterables): # chain('ABC', 'DEF') --> A B C D E F for it in iterables: for element in it: yield element
classmethodchain.from_iterable(itératif)¶
Suppléant constructeur de chain(). Obtient des entrées chaînées à partir d’un seul argument itérable évalué paresseusement. À peu près équivalent à:
def from_iterable(iterables): # chain.from_iterable() --> A B C D E F for it in iterables: for element in it: yield element
itertools.combinations(itérable, r)¶
Renvoie les sous-séquences de longueur r des éléments de l’itérable d’entrée.,
Les tuples de combinaison sont émis dans l’ordre lexicographique selon l’ordre de l’itérable d’entrée. Donc, si l’itérable d’entrée est trié, les tuples de combinaison seront produits dans l’ordre trié.
Les éléments sont traités comme uniques en fonction de leur position et non de leur valeur. Donc, si les éléments d’entrée sont uniques, il n’y aura pas repeatvalues dans chaque combinaison.,
À peu près équivalent à:
Le code de combinations() peut également être exprimé sous la forme d’une sous-séquence de permutations() après filtrage des entrées où les éléments ne sont pas triés (selon leur position dans le pool d’entrées):
Le nombre »>
quand0 <= r <= nou zéro quandr > n.,itertools.combinations_with_replacement(iterable, r)¶
Renvoie les sous-séquences de longueur r des éléments de l’iterableallowing d’entrée des éléments individuels à répéter plus d’une fois.
Les tuples de combinaison sont émis dans l’ordre lexicographique selon l’ordre de l’itérable d’entrée. Donc, si l’itérable d’entrée est trié, les tuples de combinaison seront produits dans l’ordre trié.
Les éléments sont traités comme uniques en fonction de leur position et non de leur valeur. Donc, si les éléments d’entrée sont uniques, les combinaisons générées seront également uniques.,
À peu près équivalent à:
Le code de combinations_with_replacement() peut également être exprimé sous forme de sous-séquence de product() après filtrage des entrées où les éléments ne sont pas triés (selon leur position dans le pool d’entrées):
Le nombre 4412cf2e0a »> quandn > 0.
Nouveau dans la version 3.1.,
itertools.compress(data, selectors)¶
Crée un itérateur qui filtre les éléments des données renvoyant uniquement ceux qui ont un élément correspondant dans les sélecteurs qui est évalué àTrue.S’arrête lorsque les données ou les sélecteurs itérables ont été épuisés.À peu près équivalent à:
def compress(data, selectors): # compress('ABCDEF', ) --> A C E F return (d for d, s in zip(data, selectors) if s)
Nouveau dans la version 3.1.
itertools.count(start=0, step=1)¶
Créer un itérateur qui renvoie des valeurs uniformément espacées commençant par le nombre start., Souvent utilisé comme argument pourmap() pour générer des points de données consécutifs.Aussi, utilisé avec zip() pour ajouter des numéros de séquence. À peu près équivalent à:
def count(start=0, step=1): # count(10) --> 10 11 12 13 14 ... # count(2.5, 0.5) -> 2.5 3.0 3.5 ... n = start while True: yield n n += step
Lors du comptage avec des nombres à virgule flottante, une meilleure précision peut parfois être obtenue en substituant un code multiplicatif tel que: (start + step * ifor i in count()).
Modifié dans la version 3.1: Ajout de l’argument step et autorisation des arguments non entiers.,
itertools.cycle(itérable)¶
Créer un itérateur renvoyant des éléments de l’itérable et enregistrant une copie de chacun.Lorsque l’itérable est épuisé, renvoyez les éléments de la copie enregistrée. Repeatsindefinitely. À peu près équivalent à:
Remarque, ce membre de la boîte à outils peut nécessiter un stockage auxiliaire important(en fonction de la longueur de l’itérable).,
itertools.dropwhile(prédicat, itérable)¶
Créer un itérateur qui supprime des éléments de l’itérable tant que le prédicat est vrai; ensuite, retourne chaque élément. Notez que l’itérateur ne produit aucune sortie jusqu’à ce que le prédicat devienne false, il peut donc avoir un temps de démarrage lengthystart-up. À peu près équivalent à:
itertools.filterfalse(prédicat, itérable)¶
Faire un itérateur qui filtre les éléments de itérable ne renvoyant que ceux pour lesquels le prédicat est False., Si le prédicat est None, retournez les itemsthat sont faux. À peu près équivalent à:
itertools.groupby(itérable, key=None)¶
Créer un itérateur qui renvoie des clés et des groupes consécutifs à partir de l’itérable.La clé est une fonction calculant une valeur de clé pour chaque élément. If notspecified or is None, la clé par défaut est une fonction d’identité et renvoie l’élément inchangé. Généralement, l’itérable doit déjà être trié sur la même fonction clé.,
L’opération de groupby() est similaire à la balise uniq filtre Unix. Itgenerates un break ou un nouveau groupe chaque fois que la valeur de la fonction key change (c’est pourquoi il est généralement nécessaire d’avoir trié les données en utilisant la même fonction key). Ce comportement diffère du GROUPE SQL PAR lequel agrège commonelements quel que soit leur ordre d’entrée.
Le groupe renvoyé est lui-même un itérateur qui partage l’itérableavecgroupby()., Comme la source est partagée, lorsque l’objet groupby()est avancé, le groupe précédent n’est plus visible. Donc, si le datais besoin plus tard, il doit être stocké comme une liste:
groupby() est équivalent à:
itertools.islice(itératif, stop)¶itertools.islice(itératif, start, stop)
Faire un itérateur qui renvoie les éléments sélectionnés à partir de l’itératif. Si start n’est pas nul, les éléments de l’itérable sont ignorés jusqu’à ce que start soit atteint.,Par la suite, les éléments sont renvoyés consécutivement à moins que step ne soit défini plus haut que one, ce qui entraîne le saut d’éléments. Si stop est None, alors iterationcontinue jusqu’à ce que l’itérateur soit épuisé, le cas échéant; sinon, il s’arrête à la position spécifiée. Contrairement au découpage régulier, islice() ne prend pas en charge les valeurs négatives pour start, stop ou step. Peut être utilisé pour extraire relatedfields à partir de données où la structure interne a été aplatie (par exemple, le rapport amulti-line peut répertorier un champ de nom sur une troisième ligne)., À peu près équivalent à:
Si start est None, alors l’itération commence à zéro. Si l’étape est None,alors l’étape par défaut est une.
itertools.permutations(itérable, r=None)¶
Renvoie les permutations successives de longueur r des éléments dans l’itérable.
Si r n’est pas spécifié ou estNone, alors r par défaut est la longueur de l’itérable et toutes les permutations pleine longueur possibles sont générées.
Les tuples de permutation sont émis dans l’ordre lexicographique selon l’ordre de l’itérable d’entrée., Donc, si l’itérable d’entrée est trié, les tuples de combinaison seront produits dans l’ordre trié.
Les éléments sont traités comme uniques en fonction de leur position et non de leur valeur. Donc, si les éléments d’entrée sont uniques, il n’y aura pas repeatvalues dans chaque permutation.,
À peu près équivalent à:
Le code de permutations() peut également être exprimé sous la forme d’une sous-séquence deproduct(), filtré pour exclure les entrées avec des éléments répétés (ceux de la même position dans le pool d’entrées):
Le nombre »> quand0 <= r <= nou zéro quandr > n.
itertools.product(*itérables, repeat=1)¶
Produit cartésien des itérables d’entrée.,
Les boucles imbriquées roulent comme un odomètre avec l’élément le plus à droite avançant à chaque itération. Ce modèle crée un ordre lexicographique de sorte que si les itérables de l’entrée sont triés, les tuples du produit sont émis dans sortedorder.
Pour calculer le produit d’un itérable avec lui-même, spécifiez le nombre de répétitions avec l’argument facultatif repeat keyword. Par exemple, la baliseproduct(A, repeat=4) signifie la même chose que product(A, A, A, A).,
Cette fonction est à peu près équivalente au code suivant, sauf que theactual implementation ne construit pas de résultats intermédiaires en mémoire:
Avant l’exécution deproduct(), elle consomme complètement les itérables d’entrée,gardant des pools de valeurs en mémoire pour générer les produits. En conséquence, il n’est utile qu’avec des entrées finies.
itertools.repeat(objet)¶
Faire un itérateur qui renvoie l’objet, encore et encore. S’exécute indéfiniment sans que l’argument times soit spécifié., Utilisé comme argument pour map() forinvariant paramètres à la fonction appelée. Également utilisé avec zip() pour créer une partie invariante d’un enregistrement tuple.
à peu près équivalent à:
Une utilisation courante de répétition est de fournir un flux de valeurs constantes à mapor zip:
>>> list(map(pow, range(10), repeat(2)))
itertools.starmap(fonction, objet iterable)¶
Faire un itérateur qui calcule la fonction à l’aide des arguments obtenu de l’itératif., Utilisé à la place de map() lorsque les paramètres d’argument sont déjà groupés dans des tuples à partir d’un seul itérable (les données ont été”pré-compressées »). La différence entre map() et starmap() est parallèle à la distinction entre function(a,b) et function(*c). À peu près équivalent à:
def starmap(function, iterable): # starmap(pow, ) --> 32 9 1000 for args in iterable: yield function(*args)
itertools.takewhile(prédicat, itérable)¶
Faire un itérateur qui renvoie des éléments de l’itérable tant que thepredicate est vrai., À peu près équivalent à:
def takewhile(predicate, iterable): # takewhile(lambda x: x<5, ) --> 1 4 for x in iterable: if predicate(x): yield x else: break
itertools.tee(itérable, n=2)¶
Renvoie n itérateurs indépendants à partir d’un seul itérable.
Le code Python suivant aide à expliquer ce que fait tee (bien que la mise en œuvre actuelle soit plus complexe et n’utilise qu’une seule file d’attente underlyingFIFO).
À peu près équivalent à:
Une fois quetee() a fait une scission, l’itérable d’origine ne devrait pas être utilisé ailleurs; sinon, l’itérable pourrait être avancé sans que les objets tee soient informés.,
tee itérateurs ne sont pas thread-safe. UnRuntimeError peut être utilisé lors de l’utilisation simultanée d’itérateurs renvoyés par le même appeltee(), même si l’itérable d’origine est threadsafe.
Cet itertool peut nécessiter un stockage auxiliaire important (en fonction de la façon dont les données temporaires doivent être stockées). En général, si un itérateur utilise la plupart ou toutes les données avant le démarrage d’un autre itérateur, il est plus rapide d’utiliserlist() au lieu de tee().,
itertools.zip_longest(*itérables, fillvalue=None)¶
Créer un itérateur qui agrège les éléments de chacun des itérables. Si theiterables sont de longueur inégale, les valeurs manquantes sont remplies avec fillvalue.L’itération continue jusqu’à ce que l’itérable le plus long soit épuisé. À peu près équivalent à:
Si l’un des itérables est potentiellement infini, alors la fonction zip_longest()doit être encapsulée avec quelque chose qui limite le nombre d’appels(par exemple islice() ou takewhile())., Si non spécifié,fillvalue est par défaut None.