{"id":1286,"date":"2012-09-19T14:55:44","date_gmt":"2012-09-19T12:55:44","guid":{"rendered":"http:\/\/linux.leunen.com\/?p=1286"},"modified":"2012-09-19T14:55:44","modified_gmt":"2012-09-19T12:55:44","slug":"python-les-iterateurs-et-generateurs","status":"publish","type":"post","link":"https:\/\/www.leunen.com\/linux\/2012\/09\/python-les-iterateurs-et-generateurs\/","title":{"rendered":"Python: les it\u00e9rateurs et g\u00e9n\u00e9rateurs"},"content":{"rendered":"

Pour une petite application que j’avais d\u00e9cid\u00e9 d’\u00e9crire en Python, j’avais besoin de parcourir des cha\u00eenes de caract\u00e8res en prenant les caract\u00e8res 3 par 3. En tant qu’amateur de C++, ma premi\u00e8re id\u00e9e \u00e9tait forc\u00e9ment de cr\u00e9er une boucle for<\/em> du genre de celle qu’on \u00e9crit en C++:<\/p>\n

\r\nstd::string my_string(\"azertyuiop\"<\/span>);\r\nfor<\/span>(unsigned<\/span> int<\/span> i  = 0; i < my_string.length(); i+=3)\r\n{\r\n  std::cout << my_string.substr(i, 3) << std::endl;\r\n}\r\n<\/pre>\n
Cette fa\u00e7on d’\u00e9crire une boucle n’est pas tr\u00e8s compliqu\u00e9e \u00e0 transcrire en Python. On peut utiliser la fonction range()<\/em> \u00e0 laquelle on peut passer des param\u00e8tres dont le d\u00e9but, la fin et le ‘pas’ (step) de la boucle. Cela donne quelque chose comme:<\/p>\n
\r\nmy_string = \"azertyuiop\"<\/span>\r\nfor<\/span> i in<\/span> range(0, len(my_string), 3):\r\n  print<\/span> i, t[i:i + 3]\r\n<\/pre>\n
C’est consid\u00e9r\u00e9 comme une m\u00e9thode pas tr\u00e8s pythonique. On pr\u00e9f\u00e9rera utiliser un it\u00e9rateur<\/em> ou un g\u00e9n\u00e9rateur<\/em>.
\nVoyons bri\u00e8vement et basiquement de quoi il s’agit.<\/p>\n
Les it\u00e9rateurs<\/h3>\n
Les it\u00e9rateurs<\/em> sont des objets permettant de parcourir facilement des containers que ce soient des strings – qui ne sont que des containers de caract\u00e8res – des listes ou des containers d’objets. Par exemple, pour r\u00e9cup\u00e9rer tous les caract\u00e8res constituant une cha\u00eene de caract\u00e8res, on proc\u00e8de comme ceci:<\/p>\n
\r\nfor c in my_string:\r\n  print c\r\n<\/pre>\n
C’est tr\u00e8s simple \u00e0 utiliser.<\/p>\n
Il est tr\u00e8s facile aussi de cr\u00e9er soi-m\u00eame un it\u00e9rateur<\/em> de fa\u00e7on \u00e0 ce qu’il se plie \u00e0 ce que l’on veut faire. Pour cela, il suffit de cr\u00e9er un objet qui contient deux m\u00e9thodes: __iter__() et next().
\n__iter__()<\/em> est appel\u00e9 implicitement au d\u00e9but de la boucle et doit renvoyer un objet it\u00e9rateur.
\nnext()<\/em> doit lever une exception StopIteration<\/em> quand on est \u00e0 la fin de la boucle et qu’il n’y a plus d’\u00e9l\u00e9ments \u00e0 traiter. <\/p>\n
Dans le cas d’un it\u00e9rateur<\/em> qui renvoie les caract\u00e8res trois par trois, l’it\u00e9rateur<\/em> ressemblerait \u00e0 ceci:<\/p>\n
\r\nclass<\/span> triplet:\r\n  def<\/span> __init__(self, data):\r\n    self.data = data\r\n    self.count = 0\r\n    self.length = len(data)\r\n  \r\n  def<\/span> __iter__(self):\r\n    return<\/span> self\r\n    \r\n  def<\/span> next(self):\r\n    if<\/span> self.count > len(self.length):\r\n      raise<\/span> StopIteration\r\n    else<\/span>:\r\n      result = self.data[self.count:self.count+3]\r\n      self.count += 3\r\n      return<\/span> result\r\n<\/pre>\n
Et on peut l’utiliser dans une boucle de cette fa\u00e7on:<\/p>\n
\r\ntest = triplet(\"azertyuiop\"<\/span>)\r\n     for<\/span> item in<\/span> test:\r\n       print<\/span> item\r\n<\/pre>\n
Les g\u00e9n\u00e9rateurs<\/h3>\n
Cette m\u00e9thode utilisant un objet it\u00e9rateur<\/em> me pla\u00eet bien. C’est clair, efficace et tr\u00e8s OOP.
\nIl existe une autre m\u00e9thode qui est tr\u00e8s simple et qui utilise les principes de l’it\u00e9rateur<\/em> m\u00eame si c’est bien cach\u00e9. Il s’agit des fonctions g\u00e9n\u00e9rateurs<\/em>. Il s’agit en fait d’une fonction qui retourne un it\u00e9rateur<\/em> qui, lui-m\u00eame, peut \u00eatre utilis\u00e9 pour contr\u00f4ler une boucle par exemple.
\nLe simple fait d’utiliser le mot-clef yield<\/em> fait de la fonction une fonction g\u00e9n\u00e9rateur<\/em>. Lorsque ce mot clef est rencontr\u00e9, il retourne la valeur en argument et l’execution est suspendue jusqu’\u00e0 la prochaine it\u00e9ration. <\/p>\n
Dans notre cas, cela donne ceci:<\/p>\n
\r\ndef<\/span> triplet(str):\r\n  current=0\r\n  while<\/span> current <= len(str):\r\n    yield str[current:current+3]\r\n    current += 3\r\n<\/pre>\n
Et on l’utilise dans une boucle comme d’habitude:<\/p>\n
\r\nfor<\/span> t in<\/span> triplet(\"azertyuiop\"<\/span>):\r\n  print<\/span> t\r\n<\/pre>\n
Comme on l’a vu bri\u00e8vement ici, les it\u00e9rateurs<\/em> et les g\u00e9n\u00e9rateurs<\/em> sont tr\u00e8s simple d’emploi et on les retrouve tr\u00e8s fr\u00e9quemment dans les codes \u00e9crits en Python. Je vous renvoie \u00e0 la documentation si vous voulez en savoir plus.<\/p>\n","protected":false},"excerpt":{"rendered":"
Pour une petite application que j’avais d\u00e9cid\u00e9 d’\u00e9crire en Python, j’avais besoin de parcourir des cha\u00eenes de caract\u00e8res en prenant les caract\u00e8res 3 par 3. En tant qu’amateur de C++, ma premi\u00e8re id\u00e9e \u00e9tait forc\u00e9ment de cr\u00e9er une boucle for du genre de celle qu’on \u00e9crit en C++: std::string my_string(\u00ab\u00a0azertyuiop\u00a0\u00bb); for(unsigned int i = 0; […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[15],"tags":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t