{"id":714,"date":"2010-08-11T11:54:50","date_gmt":"2010-08-11T09:54:50","guid":{"rendered":"http:\/\/j-mad.com\/blog\/?p=714"},"modified":"2010-08-13T12:50:20","modified_gmt":"2010-08-13T10:50:20","slug":"petit-tour-du-cote-des-itertools-billet-sans-nucleaire-dedans-promis","status":"publish","type":"post","link":"https:\/\/j-mad.com\/blog\/2010\/08\/11\/petit-tour-du-cote-des-itertools-billet-sans-nucleaire-dedans-promis\/","title":{"rendered":"Petit tour du cot\u00e9 des itertools, billet sans nucl\u00e9aire dedans, promis"},"content":{"rendered":"

Le module itertools<\/a> est un module bien pratique auquel on ne pense pas assez souvent. En tout cas auquel, moi, je ne pense pas assez souvent. Et pourtant, il peut grandement simplifier pas mal de ligne de code, dans un bon nombre de situation. Il faut juste savoir que les fonctions qu’il propose existe.<\/p>\n

Ce billet a donc 2 objectifs, vous faire d\u00e9couvrir les itertools (je ne vais pas lister toutes les fonctions juste celles dont je devrais me servir plus souvent et que j’oublie) et me permettre de ne pas oublier que je pourrais les utiliser.<\/p>\n

Point important\u00a0: Un certain nombre des itertools permettent de g\u00e9rer les iterateur infinis, ce que ne permettent pas les fonctions ‘normales’ comme map par exemple (qui renvoie une sortie compl\u00e9tement calcul\u00e9e, ce qui est par d\u00e9finition impossible avec un iterateur infini).<\/p>\n

Pr\u00e9cision\u00a0: les exemples de code sont ceux fournis par la doc officielle des itertools<\/p>\n

itertools.chain (*iterables)<\/h2>\n

permet d’avoir un iterateur qui retourne tout les \u00e9l\u00e9ments du premier iterable pass\u00e9 en param\u00e8tre, puis du second, puis du troisi\u00e8me, etc etc… Bien pratique pour a\u00e9rer son code.<\/p>\n

def<\/span> chain(<\/span>*iterables)<\/span>:
\n# chain('ABC', 'DEF') --> A B C D E F<\/span>
\nfor<\/span> it in<\/span> iterables:
\nfor<\/span> element in<\/span> it:
\nyield<\/span> element<\/div><\/div>\n

Depuis python 2.6, il existe une classmethod de chain, from_iterable(iterable) qui ne prend qu’un argument, un iterable contenant tout les iterables.<\/p>\n

@<\/span>classmethod<\/span>
\ndef<\/span> from_iterable(<\/span>iterables)<\/span>:
\n# chain.from_iterable(['ABC', 'DEF']) --> A B C D E F<\/span>
\nfor<\/span> it in<\/span> iterables:
\nfor<\/span> element in<\/span> it:
\nyield<\/span> element<\/div><\/div>\n

itertools.compress(data, selectors)<\/h2>\n

compress n’est disponible qu’en python 2.7. Cette fonction retourne un iterateur contenant que uniquement les valeurs de data auxquelles correspondent un \u00e9l\u00e9ment \u00e9valu\u00e9 \u00e0 True dans le selectors. Compress s’arr\u00eate d\u00e8s que data ou selectors est vide.<\/p>\n

def<\/span> compress(<\/span>data,<\/span> selectors)<\/span>:
\n# compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F<\/span>
\nreturn<\/span> (<\/span>d for<\/span> d,<\/span> s in<\/span> izip(<\/span>data,<\/span> selectors)<\/span> if<\/span> s)<\/span><\/div><\/div>\n

itertools.count(start=0, step=1)<\/h2>\n

Cette fonction bien que pr\u00e9sente depuis longtemps a droit \u00e0 quelques modifications dans python 2.7. Count gagne en effet l’argument step et la possibilit\u00e9 d’it\u00e9rer sur des arguments non integer.<\/p>\n

def<\/span> count(<\/span>start=<\/span>0<\/span>,<\/span> step=<\/span>1<\/span>)<\/span>:
\n# count(10) --> 10 11 12 13 14 ...<\/span>
\n# count(2.5, 0.5) -> 3.5 3.0 4.5 ...<\/span>
\nn =<\/span> start
\nwhile<\/span> True<\/span>:
\nyield<\/span> n
\nn +=<\/span> step<\/div><\/div>\n

itertools.dropwhile(predicate, iterable)<\/h2>\n

Construit un iterateur qui ne renvoie aucun \u00e9l\u00e9ment de l’iterable tant que le pr\u00e9dicat est vrai, ensuite, tout les \u00e9l\u00e9ments de l’iterable sont renvoy\u00e9s<\/p>\n

def<\/span> dropwhile(<\/span>predicate,<\/span> iterable)<\/span>:
\n# dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1<\/span>
\niterable =<\/span> iter<\/span>(<\/span>iterable)<\/span>
\nfor<\/span> x in<\/span> iterable:
\nif<\/span> not<\/span> predicate(<\/span>x)<\/span>:
\nyield<\/span> x
\nbreak<\/span>
\nfor<\/span> x in<\/span> iterable:
\nyield<\/span> x<\/div><\/div>\n

itertools.takewhile(predicate, iterable)<\/h2>\n

Construit un iterateur qui, tant que le pr\u00e9dicat est vrai, renvoie les \u00e9l\u00e9ments de l’iterable.<\/p>\n

def<\/span> takewhile(<\/span>predicate,<\/span> iterable)<\/span>:
\n# takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4<\/span>
\nfor<\/span> x in<\/span> iterable:
\nif<\/span> predicate(<\/span>x)<\/span>:
\nyield<\/span> x
\nelse<\/span>:
\nbreak<\/span><\/div><\/div>\n

itertools.ifilter(predicate, iterable) et itertools.ifilterfalse(predicate, iterable)<\/h2>\n

Construit un iterateur qui ne renvoie que les \u00e9l\u00e9ments pour lesquels le pr\u00e9dicat est respectivement True ou False. Si predicate est \u00e0 None, l’iterateur renvoie les \u00e9l\u00e9ments respectivement True ou False.<\/p>\n

def<\/span> ifilter(<\/span>predicate,<\/span> iterable)<\/span>:
\n# ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9<\/span>
\nif<\/span> predicate is<\/span> None<\/span>:
\npredicate =<\/span> bool<\/span>
\nfor<\/span> x in<\/span> iterable:
\nif<\/span> predicate(<\/span>x)<\/span>:
\nyield<\/span> x<\/div><\/div>\n

itertools.imap(function, *iterables)<\/h2>\n

Renvoie un iterateur qui applique function en utilisant les iterables comme argument. Si function est None, les arguments sont retourn\u00e9s sous la forme d’un tuple. Imap s’arr\u00eate lorsqu’elle atteint la fin du plus petit des iterables. Imap est utile lorsque l’on utilise des iterateur infinie qui provoque une erreur avec map.<\/p>\n

def<\/span> imap(<\/span>function,<\/span> *iterables)<\/span>:
\n# imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000<\/span>
\niterables =<\/span> map<\/span>(<\/span>iter<\/span>,<\/span> iterables)<\/span>
\nwhile<\/span> True<\/span>:
\nargs =<\/span> [<\/span>next(<\/span>it)<\/span> for<\/span> it in<\/span> iterables]<\/span>
\nif<\/span> function is<\/span> None<\/span>:
\nyield<\/span> tuple<\/span>(<\/span>args)<\/span>
\nelse<\/span>:
\nyield<\/span> function(<\/span>*args)<\/span><\/div><\/div>\n

les autres i-versions des fonctions classiques.<\/h2>\n

Comme l’on trouve imap, il existe aussi izip, izip_longest et islice,<\/p>\n

Parmi les autres fonctions il y a des fonctions de combinaisons, de calcul, de cycle, de groupby, mais celles l\u00e0, vous les trouverez sur la doc officielle<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"

Le module itertools est un module bien pratique auquel on ne pense pas assez souvent. En tout cas auquel, moi, je ne pense pas assez souvent. Et pourtant, il peut grandement simplifier pas mal de ligne de code, dans un bon nombre de situation. Il faut juste savoir que les fonctions qu’il propose existe. Ce … Continue reading Petit tour du cot\u00e9 des itertools, billet sans nucl\u00e9aire dedans, promis<\/span><\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[5],"tags":[98],"class_list":["post-714","post","type-post","status-publish","format-standard","hentry","category-python","tag-python"],"aioseo_notices":[],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p12cdp-bw","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/posts\/714","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/comments?post=714"}],"version-history":[{"count":7,"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/posts\/714\/revisions"}],"predecessor-version":[{"id":718,"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/posts\/714\/revisions\/718"}],"wp:attachment":[{"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/media?parent=714"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/categories?post=714"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/j-mad.com\/blog\/wp-json\/wp\/v2\/tags?post=714"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}