Repository with sources and generator of https://larlet.fr/david/ https://larlet.fr/david/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665
  1. title: Bonnes pratiques et astuces Python
  2. slug: bonnes-pratiques-et-astuces-python
  3. date: 2008-05-11 20:50:44
  4. type: post
  5. vignette: images/logos/python_nouveau.png
  6. contextual_title1: ★ Astuces et bonnes pratiques Django
  7. contextual_url1: 20080211-astuces-et-bonnes-pratiques-django
  8. contextual_title2: Présentation de Django aux journées Python francophones
  9. contextual_url2: 20070519-presentation-de-django-aux-journees-python-francophones
  10. contextual_title3: ★ Pourquoi programmer en Python ?
  11. contextual_url3: 20060505-pourquoi-programmer-en-python
  12. Ça faisait un moment que je n'avais pas parlé des
  13. bonnes pratiques Python mais l'approche de
  14. [Pycon fr](http://fr.pycon.org/) (où je présenterai Django :
  15. [le pourquoi](http://fr.pycon.org/programme/pourquoi-django/) et
  16. [le comment](http://fr.pycon.org/programme/django-au-quotidien-qualite-et-performances/)
  17. le 18 mai), l'événement Python incontournable avec
  18. [un programme des plus alléchants](http://fr.pycon.org/programme/), m'a bien
  19. motivé pour effectuer la traduction de
  20. l'[une des meilleures présentation](http://python.net/~goodger/projects/pycon/2007/idiomatic/)
  21. par [David Goodger](http://python.net/~goodger/) que je connaisse qui remet
  22. les bonnes pratiques Python à plat, ce qui est toujours bon avant d'aller plus loin.
  23. La lisibilité est importante
  24. ----------------------------
  25. > Les programmes doivent être écrits pour être lus par des gens et
  26. accidentellement exécutés par les machines.
  27. >
  28. > -- Abelson & Sussman, *Structure and Interpretation of Computer Programs*
  29. Essayez de rendre vos programmes faciles à lire et évidents.
  30. PEP 8 : Style Guide pour le code Python
  31. ---------------------------------------
  32. Une lecture immanquable : [http://www.python.org/dev/peps/pep-0008/](http://www.python.org/dev/peps/pep-0008/)
  33. (PEP = Python Enhancement Proposal)
  34. Un PEP est une document procurant des informations à la communauté Python, ou
  35. décrivant une nouvelle fonctionnalité de Python et ses processus ou de son
  36. environnement.
  37. La communauté Python a ses propres standards sur ce à quoi doit ressembler le
  38. code, codifiés dans le PEP8. Ces standards sont différents de ceux des autres
  39. communautés, comme C, Java, etc.
  40. L'indentation et les espaces étant si importants en Python, ce Style Guide est
  41. une standard. Il est important que vous adhériez au guide ! La plupart des
  42. projets suivent ces conventions.
  43. Whitespace 1
  44. ------------
  45. * 4 espaces par niveau d'indentation.
  46. * Pas de tabs.
  47. * Ne **jamais** mixer des tabs et des espaces.
  48. * Un saut de ligne entre les fonctions.
  49. * Deux sauts de ligne entre les classes.
  50. Whitespace 2
  51. ------------
  52. * Ajoutez un espace après ", ", dans les dictionnaires, les listes, les
  53. tuples, les arguments d'une liste d'arguments et après ":" dans les
  54. dictionnaires mais pas avant.
  55. * Mettez des espaces autour des assignements et des comparaisons (excepté
  56. pour les arguments d'une liste).
  57. * Pas d'espace aux ouvertures/fermetures de parenthèses ou juste avant une
  58. liste d'arguments.
  59. * Pas d'espace en ouverture/fermeture de docstrings.
  60. def make_squares(key, value=0):
  61. """Return a dictionary and a list..."""
  62. d = {key: value}
  63. l = [key, value]
  64. return d, l
  65. Nommage
  66. -------
  67. * ``joined_lower`` pour les fonctions, méthodes et attributs
  68. * ``joined_lower`` ou ``ALL_CAPS`` pour les constantes
  69. * ``StudlyCaps`` pour les classes
  70. * ``camelCase`` **seulement** pour suivre des conventions pré-existantes
  71. * Attributs: ``interface``, ``_internal``, ``__private``
  72. Mais essayez d'éviter la forme ``__privée``. Je ne l'utilise jamais.
  73. Faites moi confiance. Si vous l'utilisez, vous le regretterez plus tard.
  74. Longues lignes et continuité
  75. ----------------------------
  76. Garder une taille de ligne inférieure à 80 caractères.
  77. Utilisez la continuité implicite des lignes au sein des
  78. parenthèses/crochets/accolades :
  79. def __init__(self, first, second, third,
  80. fourth, fifth, sixth):
  81. output = (first + second + third
  82. + fourth + fifth + sixth)
  83. Utilisez les backslashs en dernier recours :
  84. VeryLong.left_hand_side \
  85. = even_longer.right_hand_side()
  86. Les backslashs sont locaux, ils doivent terminer la ligne sur laquelle
  87. ils sont. Si vous ajoutez un espace après le backslash, ça ne sert à rien.
  88. Ah aussi, c'est laid.
  89. Longues chaînes de caractères
  90. -----------------------------
  91. Les chaînes de caractères adjacentes sont concaténées par le parser:
  92. >>> print 'o' 'n' "e"
  93. one
  94. Les espaces entre les chaînes ne sont pas requis, mais aident à la
  95. lisibilité. Tous les types de quotes sont utilisable :
  96. >>> print 't' r'\/\/' """o"""
  97. t\/\/o
  98. La chaîne précédée par "r" est une chaîne de type "raw". Les backslashs
  99. ne sont pas évalués comme étant des caractères d'échappement dans les
  100. chaînes de type raw. Elles sont utiles pour les expressions régulières
  101. et les chemins de fichiers Windows.
  102. Notez que les chaînes de caractères nommées **ne sont pas** concaténées :
  103. >>> a = 'three'
  104. >>> b = 'four'
  105. >>> a b
  106. File "<stdin>", line 1
  107. a b
  108. ^
  109. SyntaxError: invalid syntax
  110. Cela vient du fait que la concaténation automatique est une fonctionnalité
  111. du parser/compiler Python, pas de l'interpréteur. Vous devez utiliser le
  112. signe "+" pour concaténer des chaînes de caractères à l'éxecution.
  113. text = ('Long strings can be made up '
  114. 'of several shorter strings.')
  115. Les parenthèses autorisent la continuité implicite des lignes.
  116. Les chaînes de caractères sur plusieurs lignes utilisent les triple quotes :
  117. """Triple
  118. double
  119. quotes"""
  120. '''\
  121. Triple
  122. single
  123. quotes\
  124. '''
  125. Dans le dernier exemple ci-dessus (simple triple quotes), notez
  126. l'utilisation du backslash pour échapper les nouvelles lignes. Cela élimine
  127. les nouvelles lignes en conservant les quotes joliment alignées à gauche.
  128. Les backslashs doivent être à la fin de leurs lignes.
  129. Déclarations
  130. ------------
  131. Bon :
  132. if foo == 'blah':
  133. do_something()
  134. do_one()
  135. do_two()
  136. do_three()
  137. Mauvais :
  138. if foo == 'blah': do_something()
  139. do_one(); do_two(); do_three()
  140. Les espaces et l'indentation sont de bons indicateurs visuels du flot du
  141. programme. L'indentation de la seconde ligne du "Bon" ci-dessus montre
  142. au lecteur que quelque chose va se produire, alors que le manque
  143. d'indentation dans le "Mauvais" exemple cache le "if".
  144. Les déclarations multiples sur une même ligne sont une torture.
  145. En Python, *la lisibilité compte*.
  146. Docstrings et Commentaires
  147. --------------------------
  148. Docstrings = **Comment utiliser** le code
  149. Commentaires = **Pourquoi** (rationnel) et **comment le code fonctionne**
  150. Les docstrings expliquent **comment** utiliser le code et sont là pour
  151. **les utilisateurs** de votre code. Quelques usages :
  152. * Expliquer le but d'une fonction même si ça vous semble évident car ça ne
  153. semblera pas forcément évident à une personne plus tard.
  154. * Décrire les paramètres attendus, les valeurs retournées et les exceptions
  155. levées.
  156. * Si la méthode est fortement couplée à un seul appelant, mentionner
  157. la fonction appelante (attention au fait que celle-ci puisse changer).
  158. Les commentaires expliquent **pourquoi** et sont pour les mainteneurs de
  159. votre code. Examples incluant des notes pour vous-même, comme :
  160. # !!! BUG: ...
  161. # !!! FIX: This is a hack
  162. # ??? Why is this here?
  163. Les deux types sont de **votre** ressort donc écrivez de bonnes docstrings
  164. et de bons commentaires !
  165. Les docstrings sont utiles pour un usage interactif (``help()``) et pour
  166. les systèmes d'auto-documentation.
  167. Les commentaires et docstrings faux sont pire que tout. Donc conservez les
  168. à jour ! Lorsque vous effectuez des modifications, assurez vous que les
  169. commentaires et les docstrings sont cohérents avec le code.
  170. Il y a [un PEP entier consacré aux docstrings, PEP 257, "Docstring
  171. Conventions"](http://www.python.org/dev/peps/pep-0257/).
  172. La pratique a raison de la théorie
  173. ----------------------------------
  174. Il y a toujours des exceptions. Issu du PEP 8 :
  175. > Mais plus important : sachez être pertinents - parfois le style guide ne
  176. s'applique pas. Lorsque vous avez un doute, utilisez votre raison. Étudiez
  177. d'autres possibilités et décidez de ce qui vous semble le mieux.
  178. Et n'hésitez pas à demander !
  179. > Deux bonnes raisons de ne pas suivre une règle particulière :
  180. >
  181. > (1) Lorsque appliquer la règle va rendre le code moins lisible, même pour
  182. quelqu'un qui est habitué à lire du code qui suit les règles.
  183. >
  184. > (2) Pour être cohérent avec du code préexistant qui enfreint aussi ces règles
  185. (peut-être pour des raisons historiques) -- même si c'est aussi une opportunité
  186. pour faire un peu de nettoyage (dans un pur style XP).
  187. ... mais la pratique ne doit pas réduire la théorie à néant !
  188. On plonge maintenant au cœur du tutoriel : les astuces. On va commencer avec
  189. les plus faciles et augmenter progressivement le niveau.
  190. Variables intermédiaires
  191. ------------------------
  192. Dans les autres langages :
  193. temp = a
  194. a = b
  195. b = temp
  196. En Python :
  197. b, a = a, b
  198. Vous l'avez peut-être déjà rencontré mais savez vous comment ça fonctionne ?
  199. * La **virgule** est la syntaxe de construction du tuple.
  200. * Un tuple est créé à droite (tuple packing).
  201. * Un tuple en est la cible à gauche (tuple unpacking).
  202. La partie à droite est **unpackée** dans les noms de tuple de la partie à
  203. gauche.
  204. D'autres exemples:
  205. >>> l =['David', 'Pythonista', '+1-514-555-1234']
  206. >>> name, title, phone = l
  207. >>> name
  208. 'David'
  209. >>> title
  210. 'Pythonista'
  211. >>> phone
  212. '+1-514-555-1234'
  213. Utile dans les boucles sur des données structurées (la variable ``l``
  214. ci-dessus a été conservée) :
  215. >>> people = [l, ['Guido', 'BDFL', 'unlisted']]
  216. >>> for (name, title, phone) in people:
  217. ... print name, phone
  218. ...
  219. David +1-514-555-1234
  220. Guido unlisted
  221. Chaque item de ``people`` est unpacké dans le tuple ``(name, title, phone)``.
  222. Il est aussi possible de faire le chemin inverse, il faut juste s'assurer
  223. d'avoir la même structure à droite et à gauche :
  224. >>> david, (gname, gtitle, gphone) = people
  225. >>> gname
  226. 'Guido'
  227. >>> gtitle
  228. 'BDFL'
  229. >>> gphone
  230. 'unlisted'
  231. >>> david
  232. ['David', 'Pythonista', '+1-514-555-1234']
  233. Aller plus loin avec les tuples
  234. -------------------------------
  235. On a vu que la **virgule** était le constructeur du tuple, pas les
  236. parenthèses. Par exemple :
  237. >>> 1,
  238. (1,)
  239. L'interpréteur Python montre les parenthèses pour que ce soit plus clair
  240. et je vous conseille de faire de même :
  241. >>> (1,)
  242. (1,)
  243. Mais n'oubliez pas la virgule !
  244. >>> (1)
  245. 1
  246. Dans un tuple contenant un seul élément, la virgule est nécessaire. Dans
  247. un tuple avec plus de 2 éléments, la virgule finale est optionnelle.
  248. Pour un tuple vide, une paire de parenthèses suffit :
  249. >>> ()
  250. ()
  251. >>> tuple()
  252. ()
  253. Une erreur de typo courante est de laisser une virgule alors que vous ne
  254. souhaitez pas avoir un tuple. Il est très facile de l'oublier dans votre
  255. code :
  256. >>> value = 1,
  257. >>> value
  258. (1,)
  259. Donc si vous vous retrouvez avec un tuple alors que vous ne vous y
  260. attendiez pas, cherchez la virgule ! (*Note du traducteur* : de ma propre
  261. expérience, il est plus courant d'oublier la virgule pour un tuple ne
  262. contenant qu'un seul élément, dans les settings de Django par exemple,
  263. cherchez plutôt la virgule manquante dans ces cas là).
  264. Le "_" interactif
  265. -----------------
  266. C'est une fonctionnalité très utile que peu de développeurs connaissent.
  267. (*Note du traducteur* : bien entendu
  268. [vous n'en faites pas partie](https://larlet.fr/david/biologeek/archives/20060425-python-et-underscore/)
  269. et vous connaissez les dangers associés.)
  270. Dans un interpréteur interactif, que vous évaluiez une expression ou que
  271. vous appeliez une fonction, le résultat est stocké dans une variable
  272. temporaire, ``_`` (un underscore) :
  273. >>> 1 + 1
  274. 2
  275. >>> _
  276. 2
  277. ``_`` stocke la dernière valeur *affichée*.
  278. Lorsqu'un résultat vaut ``None``, rien n'est affiché, donc ``_`` ne change
  279. pas. C'est normal !
  280. Ça ne marche que dans un interpréteur interactif, pas dans un module.
  281. C'est particulièrement utile lorsque vous travaillez sur un problème de
  282. manière interactive, et que vous souhaitez stocker la valeur du dernier
  283. résultat :
  284. >>> import math
  285. >>> math.pi / 3
  286. 1.0471975511965976
  287. >>> angle = _
  288. >>> math.cos(angle)
  289. 0.50000000000000011
  290. >>> _
  291. 0.50000000000000011
  292. Construction de chaînes de caractères
  293. -------------------------------------
  294. Commençons avec une liste de chaînes de caractères :
  295. colors = ['red', 'blue', 'green', 'yellow']
  296. On veut concaténer ces chaînes ensemble pour en créer une longue.
  297. Particulièrement lorsque le nombre de sous-chaînes est gros...
  298. Ne faites pas :
  299. result = ''
  300. for s in colors:
  301. result += s
  302. C'est très lent.
  303. Ça utilise énormément de mémoire et de performances. La somme va additionner,
  304. stocker, et ensuite passer à la suite pour chaque étape intermédiaire.
  305. Faites plutôt ceci :
  306. result = ''.join(colors)
  307. La méthode ``join()`` fait toute la copie en une seule passe.
  308. Lorsque vous ne traitez qu'une petite centaine de chaînes de caractères,
  309. ça ne fait aucune différence. Mais prenez l'habitude de construire vos
  310. chaînes de façon optimale, car avec des milliers ou des boucles, ça **va**
  311. faire la différence.
  312. Construire des chaînes, solutions 1
  313. -----------------------------------
  314. Voici quelques techniques pour utiliser la méthode ``join()``.
  315. Si vous voulez un espace comme séparateur :
  316. result = ' '.join(colors)
  317. ou une virgule et un espace :
  318. result = ', '.join(colors)
  319. voici un cas courant d'utilisation :
  320. colors = ['red', 'blue', 'green', 'yellow']
  321. print 'Choose', ', '.join(colors[:-1]), \
  322. 'or', colors[-1]
  323. Pour faire une phrase grammaticalement correcte, on veut des virgules entre
  324. chaque valeurs sauf la dernière, où l'on préfère un "ou". La syntaxe de
  325. découpage d'une liste s'occupe du reste. La "partie jusqu'à -1" (``[:-1]``)
  326. retourne tout sauf la dernière valeur, que l'on peut concaténer avec nos
  327. virgules.
  328. Bien sûr, ce code ne fonctionnera pas avec les cas particuliers comme une
  329. liste de taille 0 ou 1. Ce qui retourne :
  330. Choose red, blue, green or yellow
  331. Construire des chaînes, solutions 2
  332. -----------------------------------
  333. Vous avez besoin d'appliquer une fonction pour générer les chaînes initiales :
  334. result = ''.join(fn(i) for i in items)
  335. Ça utilise une *generator expression*, dont on parlera plus tard.
  336. Si vous devez modifier les chaînes de manière incrémentale, commencez par
  337. les stocker dans une liste pour commencer :
  338. items = []
  339. ...
  340. items.append(item) # de nombreuses fois
  341. ...
  342. # une fois la liste complétée
  343. result = ''.join(fn(i) for i in items)
  344. On accumule les parties de la liste afin de pouvoir appliquer le ``join``,
  345. ce qui est plus rapide.
  346. Utilisez ``in`` lorsque c'est possible (1)
  347. ------------------------------------------
  348. Bon :
  349. for key in d:
  350. print key
  351. * ``in`` est généralement plus rapide.
  352. * Ce pattern marche aussi pour des items dans des containers arbitraires
  353. (comme les listes, les tuples ou les tests).
  354. * ``in`` est aussi un opérateur (comme on va le voir).
  355. Mauvais :
  356. for key in d.keys():
  357. print key
  358. C'est limité aux objects ayant une méthode ``keys()``.
  359. Utilisez ``in`` lorsque c'est possible (2)
  360. ------------------------------------------
  361. Mais ``.keys()`` est **nécessaire** lorsque vous modifiez le dictionnaire :
  362. for key in d.keys():
  363. d[str(key)] = d[key]
  364. ``d.keys()`` crée une liste statique des clés du dictionnaire. Sinon, vous
  365. allez lever une exception "RuntimeError: dictionary changed size during iteration".
  366. Utilisez ``key in dict``, et non ``dict.has_key()`` :
  367. # faites ça :
  368. if key in d:
  369. ...do something with d[key]
  370. # mais pas ça :
  371. if d.has_key(key):
  372. ...do something with d[key]
  373. ``in`` est ici utilisé comme un opérateur.
  374. La méthode ``get`` des dictionnaires
  375. ------------------------------------
  376. On doit souvent initialiser les entrées d'un dictionnaire avant de les utiliser:
  377. Voici la manière naïve de faire :
  378. navs = {}
  379. for (portfolio, equity, position) in data:
  380. if portfolio not in navs:
  381. navs[portfolio] = 0
  382. navs[portfolio] += position * prices[equity]
  383. ``dict.get(key, default)`` permet de ne pas avoir à se soucier du test :
  384. navs = {}
  385. for (portfolio, equity, position) in data:
  386. navs[portfolio] = (navs.get(portfolio, 0)
  387. + position * prices[equity])
  388. Beaucoup mieux.
  389. La méthode ``setdefault`` des dictionnaires (1)
  390. -----------------------------------------------
  391. Ici on doit initialiser les valeurs d'un dictionnaire mutables. Chaque valeur
  392. du dictionnaire sera une liste. Voici la manière naïve :
  393. equities = {}
  394. for (portfolio, equity) in data:
  395. if portfolio in equities:
  396. equities[portfolio].append(equity)
  397. else:
  398. equities[portfolio] = [equity]
  399. ``dict.setdefault(key, default)`` s'occupe de ça de manière beaucoup plus rapide :
  400. equities = {}
  401. for (portfolio, equity) in data:
  402. equities.setdefault(portfolio, []).append(equity)
  403. ``dict.setdefault()`` est équivalent à "get ou set & get". Ou
  404. "set si nécessaire, puis get". C'est particulièrement rapide si votre clé de
  405. dictionnaire est coûteuse à générer ou longue à taper.
  406. Le seul problème avec ``dict.setdefault()`` c'est que la valeur par défaut est
  407. évaluée, qu'elle soit utilisée ou non. Ça ne pose problème que si la clé est
  408. coûteuse à calculer.
  409. Si la valeur par défaut **est** coûteuse à calculer, vous devriez plutôt
  410. utiliser la classe ``defaultdict``.
  411. La méthode ``setdefault`` des dictionnaires (2)
  412. -----------------------------------------------
  413. On va voir qu'il est possible d'utiliser ``setdefault`` pour déclarer une valeur par défaut :
  414. navs = {}
  415. for (portfolio, equity, position) in data:
  416. navs.setdefault(portfolio, 0)
  417. navs[portfolio] += position * prices[equity]
  418. La méthode ``setdefault`` d'un dictionnaire retourne la valeur par défaut, mais
  419. nous l'ignorons ici. On tire profit d'une conséquence de l'utilisation de
  420. ``setdefault``, la valeur n'est initialisée que si elle n'existe pas déjà.
  421. ``defaultdict``
  422. ---------------
  423. Nouveau avec Python 2.5.
  424. ``defaultdict`` est nouveau dans Python 2.5, il fait partie du module
  425. ``collections``. ``defaultdict`` est identique aux dictionnaires classiques,
  426. excepté pour deux cas :
  427. * il prend un premier argument optionnel : une fonction factory par défaut
  428. * lorsqu'une clé de dictionnaire est rencontrée pour la première fois, la
  429. fonction factory par défaut est appelée et le résultat initialise la
  430. valeur du dictionnaire.
  431. Il y a deux manières d'accéder à ``defaultdict`` :
  432. * importer le module ``collections`` et l'appeler à travers le module :
  433. import collections
  434. d = collections.defaultdict(...)
  435. * ou importer ``defaultdict`` directement :
  436. from collections import defaultdict
  437. d = defaultdict(...)
  438. Voici l'exemple déjà traité, où chaque valeur du dictionnaire fois être
  439. initialisé pour être une liste vide, réécrit en utilisant ``defaultdict`` :
  440. from collections import defaultdict
  441. equities = defaultdict(list)
  442. for (portfolio, equity) in data:
  443. equities[portfolio].append(equity)
  444. Il n'y a plus d'astuce ici. Dans ce cas, la fonction factory par défaut est
  445. ``list``, ce qui retourne une liste vide.
  446. C'est la manière d'avoir un dictionnaire avec les valeurs par défaut à 0,
  447. utilisez ``int`` comme factory :
  448. navs = defaultdict(int)
  449. for (portfolio, equity, position) in data:
  450. navs[portfolio] += position * prices[equity]
  451. Il faut faire attention à ``defaultdict`` quand même. Vous ne pouvez pas
  452. utiliser l'exception ``KeyError`` sur un dictionnaire initialisé avec ``defaultdict``.
  453. Vous devez utiliser la condition "key in dict" si vous voulez vérifier
  454. l'existence d'une clé de manière spécifique.
  455. Construire et scinder des dictionnaires
  456. ---------------------------------------
  457. Voila une technique utile pour construire un dictionnaire à partir de deux
  458. listes (ou séquences), une liste pour les clés, une liste pour les valeurs :
  459. given = ['John', 'Eric', 'Terry', 'Michael']
  460. family = ['Cleese', 'Idle', 'Gilliam', 'Palin']
  461. pythons = dict(zip(given, family))
  462. >>> pprint.pprint(pythons)
  463. {'John': 'Cleese',
  464. 'Michael': 'Palin',
  465. 'Eric': 'Idle',
  466. 'Terry': 'Gilliam'}
  467. L'inverse est trivial bien sûr :
  468. >>> pythons.keys()
  469. ['John', 'Michael', 'Eric', 'Terry']
  470. >>> pythons.values()
  471. ['Cleese', 'Palin', 'Idle', 'Gilliam']
  472. Notez que l'ordre du résultat des .keys() et .values() à est différent des
  473. listes utilisées lors de la création du dictionnaire. L'ordre d'entrée est
  474. différent de l'ordre de sortie car un dictionnaire n'est pas ordonné.
  475. Par contre, l'ordre des clés est consistant avec celui des valeurs, à condition
  476. que le dictionnaire n'ait pas été modifié entre temps.
  477. Tester des valeurs vraies
  478. -------------------------
  479. Il est élégant et rapide de tirer partie des avantages de Python en ce qui
  480. concerne les valeurs booléennes :
  481. # faites ça : # et pas ça :
  482. if x: if x == True:
  483. pass pass
  484. Test d'une liste :
  485. # faites ça : # et pas ça :
  486. if items: if len(items) != 0:
  487. pass pass
  488. # et surtout pas ça :
  489. if items != []:
  490. pass
  491. Valeurs vraies
  492. --------------
  493. Les noms ``True`` et ``False`` sont des instances intrinsèques à Python de type
  494. ``bool``, des valeurs booléennes. Comme ``None``, il n'existe qu'une seule
  495. instance de chaque.
  496. <table>
  497. <thead>
  498. <tr>
  499. <th>
  500. False
  501. </th>
  502. <th>
  503. True
  504. </th>
  505. </tr>
  506. </thead>
  507. <tbody>
  508. <tr>
  509. <td>
  510. <code>False</code> (== 0)
  511. </td>
  512. <td>
  513. <code>True</code> (== 1)
  514. </td>
  515. </tr>
  516. <tr>
  517. <td>
  518. <code>""</code> (empty string)
  519. </td>
  520. <td>
  521. toutes les chaînes à part <code>""</code> (<code>" "</code>,
  522. <code>"nimportequoi"</code>)
  523. </td>
  524. </tr>
  525. <tr>
  526. <td>
  527. <code>0</code>, <code>0.0</code>
  528. </td>
  529. <td>
  530. n'importe quel chiffre à part <code>0</code>
  531. (1, 0.1, -1, 3.14)
  532. </td>
  533. </tr>
  534. <tr>
  535. <td>
  536. <code>[]</code>, <code>()</code>,
  537. <code>{}</code>, <code>set()</code>
  538. </td>
  539. <td>
  540. n'importe quel container non vide
  541. (<code>[0]</code>, <code>(None,)</code>, <code>['']</code>)
  542. </td>
  543. </tr>
  544. <tr>
  545. <td>
  546. <code>None</code>
  547. </td>
  548. <td>
  549. pratiquement tous les objets qui ne sont
  550. explicitement équivalents à False
  551. </td>
  552. </tr>
  553. </tbody>
  554. </table>
  555. Voici par exemple un objet qui est toujours vrai :
  556. >>> class C:
  557. ... pass
  558. ...
  559. >>> o = C()
  560. >>> bool(o)
  561. True
  562. >>> bool(C)
  563. True
  564. Pour contrôler la valeur booléenne d'une instance ou d'une classe définie,
  565. utilisez les méthodes spéciales ``__nonzero__`` ou ``__len__``. Utilisez
  566. ``__len__`` si votre classe est un container qui a une taille :
  567. class MyContainer(object):
  568. def __init__(self, data):
  569. self.data = data
  570. def __len__(self):
  571. """Return my length."""
  572. return len(self.data)
  573. Si votre classe n'est pas un container, utilisez ``__nonzero__`` :
  574. class MyClass(object):
  575. def __init__(self, value):
  576. self.value = value
  577. def __nonzero__(self):
  578. """Return my truth value (True or False)."""
  579. # This could be arbitrarily complex:
  580. return bool(self.value)
  581. En Python 3.0, ``__nonzero__`` a été renommé ``__bool__`` afin d'être consistant
  582. avec le type ``bool`` natif. Pour être compatible, ajoutez ceci à la définition
  583. de votre classe :
  584. __bool__ = __nonzero__
  585. Index & Item (1)
  586. ----------------
  587. Voici une manière élégante de vous épargner quelques lignes si vous avez
  588. besoin d'une liste de mots :
  589. >>> items = 'zero one two three'.split()
  590. >>> print items
  591. ['zero', 'one', 'two', 'three']
  592. Prenons l'exemple d'un itération entre les items d'une liste, pour laquelle
  593. nous voulons à la fois l'item et la position (l'index) de cet item dans la liste :
  594. - ou -
  595. i = 0
  596. for item in items: for i in range(len(items)):
  597. print i, item print i, items[i]
  598. i += 1
  599. Index & Item (2): ``enumerate``
  600. -------------------------------
  601. La fonction ``enumerate`` prend une liste et retourne des paires (index, item) :
  602. >>> print list(enumerate(items))
  603. [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
  604. Il est nécessaire d'avoir recours à une ``list`` pour afficher les résultats
  605. car ``enumerate`` est une fonction fainéante, générant un item (une paire) à
  606. la fois, seulement lorsqu'il est demandé. Une boucle ``for`` nécessite un tel
  607. mécanisme. ``enumerate`` est un exemple de **générateur** dont on parlera plus
  608. tard des détails. ``print`` ne prend pas un résultat à la fois mais doit être
  609. en possession de la totalité du message à afficher. On a donc converti
  610. automatiquement le générateur en une liste avant d'utiliser print.
  611. Notre boucle devient beaucoup plus simple :
  612. for (index, item) in enumerate(items):
  613. print index, item
  614. # comparé à : # comparé à :
  615. index = 0 for i in range(len(items)):
  616. for item in items: print i, items[i]
  617. print index, item
  618. index += 1
  619. La version avec ``enumerate`` est plus courte et plus simple que la version
  620. de gauche, et plus facile à lire que les deux autres.
  621. Un exemple montrant que la fonction ``enumerate`` retourne un itérateur
  622. (un générateur est une sorte d'itérateur) :
  623. >>> enumerate(items)
  624. <enumerate object at 0x011EA1C0>
  625. >>> e = enumerate(items)
  626. >>> e.next()
  627. (0, 'zero')
  628. >>> e.next()
  629. (1, 'one')
  630. >>> e.next()
  631. (2, 'two')
  632. >>> e.next()
  633. (3, 'three')
  634. >>> e.next()
  635. Traceback (most recent call last):
  636. File "<stdin>", line 1, in ?
  637. StopIteration
  638. Les autres langages ont des "variables"
  639. ---------------------------------------
  640. Dans de nombreux autres langages, assigner une variable revient à mettre une
  641. valeur dans une boîte.
  642. int a = 1;
  643. <p>
  644. <img
  645. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/a1box.png"
  646. alt="Boîte 1 a"
  647. style="margin: 0pt auto; display: block;"/>
  648. </p>
  649. La boîte "a" contient maintenant un integer 1.
  650. Assigner une autre valeur à la même variable remplace le contenu de la boîte :
  651. a = 2;
  652. <p>
  653. <img
  654. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/a2box.png"
  655. alt="Boîte 2 a"
  656. style="margin: 0pt auto; display: block;"/>
  657. </p>
  658. Maintenant la boîte "a" contient un integer 2.
  659. Assigner une variable à une autre crée une copie de la valeur et la met
  660. dans une nouvelle boîte :
  661. int b = a;
  662. <p>
  663. <img
  664. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/a2box.png"
  665. alt="Boîte 2 a"
  666. style="margin: 0pt auto; display: block;"/>
  667. </p>
  668. <p>
  669. <img
  670. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/b2box.png"
  671. alt="Boîte 2 b"
  672. style="margin: 0pt auto; display: block;"/>
  673. </p>
  674. "b" est une seconde boîte, avec une copie de l'entier 2. La boîte "a" en a
  675. une copie séparée.
  676. Python a des "noms"
  677. -------------------
  678. En Python, un "nom" ou "identifiant" est comme une étiquette attachée à un
  679. objet.
  680. a = 1
  681. <p>
  682. <img
  683. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/a1tag.png"
  684. alt="Tag 1 a"
  685. style="margin: 0pt auto; display: block;"/>
  686. </p>
  687. Ici, un objet integer 1 a une étiquette appelée "a".
  688. Si on réassigne "a", on déplace juste l'étiquette sur un autre objet :
  689. a = 2
  690. <p>
  691. <img
  692. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/a2tag.png"
  693. alt="Tag 2 a"
  694. style="margin: 0pt auto; display: block;"/>
  695. </p>
  696. <p>
  697. <img
  698. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/1.png"
  699. alt="1"
  700. style="margin: 0pt auto; display: block;"/>
  701. </p>
  702. Maintenant le nom "a" est attaché à un objet entier 2.
  703. L'objet entier 1 n'a plus le tag "a". Il peut encore exister mais on n'y a
  704. plus accès via le nom "a". (Lorsqu'un objet n'a plus aucune référence ou
  705. étiquette, il est supprimé de la mémoire.)
  706. Si l'on assigne un nom à un autre, on attache juste une autre étiquette à
  707. un objet existant :
  708. b = a
  709. <p>
  710. <img
  711. src="/static/david/biologeek/images/python_astuces_bonnes_pratiques/ab2tag.png"
  712. alt="Tag 2 a b"
  713. style="margin: 0pt auto; display: block;"/>
  714. </p>
  715. Le nom "b" est juste une seconde étiquette attachée au même objet que "a".
  716. Bien que l'on réfère communément aux "variables" en Python (car c'est une
  717. terminologie commune aux autres langages), on manipule vraiment de "noms" ou
  718. "identifiants". En Python, les "variables" sont des étiquettes pour des
  719. valeurs, non des boîtes nommés.
  720. Si vous ne comprenez rien au reste de ce tutoriel, j'espère que vous aurez$
  721. au moins retenu la façon dont les noms fonctionnent. Une bonne compréhension
  722. vous permettra d'apprendre rapidement et d'éviter des erreurs comme celle-ci:
  723. Valeurs de paramètres par défaut
  724. --------------------------------
  725. C'est une erreur courante que les débutants font souvent. Même les
  726. développeurs plus expérimentés la font s'ils n'ont pas compris comment
  727. fonctionnent les noms en Python.
  728. def bad_append(new_item, a_list=[]):
  729. a_list.append(new_item)
  730. return a_list
  731. Le problème ici c'est que la valeur par défaut ``a_list``, une liste vide,
  732. est évaluée lors de la définition de la fonction. Ainsi à chaque fois que
  733. vous appelez la fonction vous obtenez la **même** valeur par défaut.
  734. Essayez plusieurs fois :
  735. >>> print bad_append('one')
  736. ['one']
  737. >>> print bad_append('two')
  738. ['one', 'two']
  739. Les listes sont modifiables, vous pouvez modifier leur contenu. La bonne
  740. manière d'avoir une liste par défaut (ou dictionnaire, ou set) est de la
  741. créer au moment du lancement, **au sein de la fonction** :
  742. def good_append(new_item, a_list=None):
  743. if a_list is None:
  744. a_list = []
  745. a_list.append(new_item)
  746. return a_list
  747. Formattage des chaînes de caractères avec %
  748. -------------------------------------------
  749. L'opérateur ``%`` fonctionne en Python comme la fonction ``sprintf`` de C.
  750. Bien sûr si vous ne connaissez pas C, ça ne vous aide pas. Pour faire simple,
  751. vous définissez un template ou format et des valeurs qui seront interprétées.
  752. Dans cet exemple, le template contient deux spécifications de conversion
  753. "%s" signifie "insérer une chaîne de caractère ici" et "%i" signifie
  754. "convertir un integer en string et l'insérer ici". "%s" est particulièrement
  755. utile car il utilise la fonction standard ``str()`` pour convertir un objet
  756. en une chaîne de caractères.
  757. Les valeurs proposées doivent correspondrent au template, on a deux valeurs
  758. ici, un tuple.
  759. name = 'David'
  760. messages = 3
  761. text = ('Hello %s, you have %i messages'
  762. % (name, messages))
  763. print text
  764. Ce qui donne :
  765. Hello David, you have 3 messages
  766. Les détails sont dans la *Python Library Reference*, section 2.3.6.2,
  767. "String Formatting Operations". Mettez cette page en favoris !
  768. Si vous ne l'avez pas encore fait, allez sur python.org, téléchargez la
  769. documentation en HTML (dans un .zip ou une archive), et installez la sur
  770. votre machine. Il n'y a rien de mieux que d'avoir la ressource de référence
  771. à portée de clavier.
  772. Formattage des chaînes de caractères avancé
  773. -------------------------------------------
  774. Pourquoi est-ce qu'il y a autant de personnes qui ne réalisent pas qu'il y
  775. a d'autres façons de formater les chaînes de caractères qui peuvent s'avérer
  776. plus puissantes ?
  777. Avec des noms grâce à un dictionnaire :
  778. values = {'name': name, 'messages': messages}
  779. print ('Hello %(name)s, you have %(messages)i '
  780. 'messages' % values)
  781. Ici on a spécifié les noms des valeurs interprétées, qui constituent les
  782. clés du dictionnaire.
  783. Vous trouvez qu'il y a de la redondance ? Les noms "name" et "messages"
  784. sont déjà définis localement. On peut en tirer parti.
  785. En utilisant les variables locales :
  786. print ('Hello %(name)s, you have %(messages)i '
  787. 'messages' % locals())
  788. La fonction ``locals()`` retourne un dictionnaire de toutes les variables
  789. locales disponibles.
  790. C'est très puissant. Grâce à ça, vous pouvez formater toutes les chaînes de
  791. caractères que vous voulez sans avoir à vous soucier de la correspondance
  792. positionnelle avec les valeurs soumises en argument.
  793. Mais le pouvoir peut être dangereux. ("With great power comes great
  794. responsibility.") Si vous utilisez ``locals()`` avec un template issu d'une
  795. ressource externe, vous exposez l'intégralité de votre espace de noms local.
  796. C'est une chose à garder en tête.
  797. Pour examiner votre espace de nom local :
  798. >>> from pprint import pprint
  799. >>> pprint(locals())
  800. ``pprint`` est un module très utile. Si vous ne le connaissiez pas déjà,
  801. essayez de jouer avec. Ça rend le debugging des données structurées beaucoup
  802. plus simple !
  803. Formattage des chaînes de caractères avancé
  804. -------------------------------------------
  805. L'espace de nom des attributs d'une instance d'objet est simplement un
  806. dictionnaire, ``self.__dict__``.
  807. En utilisant l'espace de nom d'une instance :
  808. print ("We found %(error_count)d errors"
  809. % self.__dict__)
  810. Equivalent à, mais moins flexible que :
  811. print ("We found %d errors"
  812. % self.error_count)
  813. Note: Les attributs d'une classe sont dans le ``__dict__`` de la classe.
  814. Les espaces de noms sont hérités et constituent donc des dictionnaires
  815. chaînés.
  816. List Comprehensions
  817. -------------------
  818. Les list comprehensions ("listcomps" pour les intimes) sont des raccourcis
  819. syntaxiques pour ce pattern généralement utilisé.
  820. La manière traditionnelle avec ``for`` et ``if`` :
  821. new_list = []
  822. for item in a_list:
  823. if condition(item):
  824. new_list.append(fn(item))
  825. En utilisant une list comprehension :
  826. new_list = [fn(item) for item in a_list
  827. if condition(item)]
  828. Les listcomps sont claires et concises, directes. Vous pouvez avoir plusieurs
  829. boucles ``for`` et conditions ``if`` au sein d'une même listcomp, mais
  830. au-delà de deux ou trois, ou si les conditions sont complexes, je vous
  831. suggère d'utiliser l'habituelle boucle ``for``. En appliquant le Zen de Python,
  832. utilisez la méthode la plus lisible.
  833. Par exemple, la liste des carrés de 0 à 9 :
  834. >>> [n ** 2 for n in range(10)]
  835. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  836. La liste des nombres impairs au sein de la précédente liste :
  837. >>> [n ** 2 for n in range(10) if n % 2]
  838. [1, 9, 25, 49, 81]
  839. Generator Expressions (1)
  840. -------------------------
  841. Faisons la somme des carrés des nombres inférieurs à 100 :
  842. Avec une boucle :
  843. total = 0
  844. for num in range(1, 101):
  845. total += num * num
  846. On peut aussi utiliser la fonction ``sum`` qui fait plus rapidement le
  847. travail pour nous en construisant la bonne séquence.
  848. Avec une list comprehension :
  849. total = sum([num * num for num in range(1, 101)])
  850. Avec une generator expression :
  851. total = sum(num * num for num in xrange(1, 101))
  852. Les generator expressions ("genexps") sont comme les list
  853. comprehensions, excepté dans leur calcul, les genexps sont fainéantes.
  854. Les listcomps calculent l'intégralité du résultat en une seule passe, pour
  855. le stocker dans une liste. Les generator expressions calculent une valeur à
  856. la fois, lorsqu'elle est nécessaire. C'est particulièrement utile lorsque la
  857. séquence est très longue lorsque la liste générée n'est qu'une étape
  858. intermédiaire et non le résultat final.
  859. Dans ce cas, on est uniquement intéressé par la somme, on n'a pas besoin de
  860. la liste des résultats intermédiaires. On utilise ``xrange`` pour la même
  861. raison, ça génère les valeurs une par une.
  862. Generator Expressions (2)
  863. -------------------------
  864. Par exemple si on doit faire la somme des carrés de plusieurs milliards
  865. d'entiers, on va arriver à une saturation de la mémoire avec une list
  866. comprehension, mais les generator expressions ne vont avoir aucun problème.
  867. Bon ça va prendre un certain temps par contre !
  868. total = sum(num * num
  869. for num in xrange(1, 1000000000))
  870. La différence de syntaxe est que les listcomps ont des crochets, alors que
  871. les genexps n'en ont pas. Les generator expressions nécessitent parfois des
  872. parenthèses par contre, vous devriez donc toujours les utiliser.
  873. En bref :
  874. * Utilisez une list comprehension lorsque le résultat escompté est la liste.
  875. * Utilisez une generator expression lorsque la liste n'est qu'un résultat
  876. intermédiaire.
  877. Voici un récent exemple de ce que j'ai vu au boulot.
  878. On avait besoin d'un dictionnaire qui corresponde aux chiffres des mois (à
  879. la fois via des chaînes de caractères et via des integers) au code des mois
  880. pour un client. Cela peut être fait avec une ligne de code.
  881. Ça fonctionne de la manière suivante :
  882. * La fonction de référence ``dict()`` prend en argument une liste de paires
  883. de clés/valeurs (2-tuples).
  884. * On a une liste des codes des mois (chaque code est une simple lettre, et
  885. une chaîne de caractères est aussi une simple liste de lettres). On parcours
  886. cette liste pour obtenir à la fois le code du mois et l'index.
  887. * Le nombre des mois commence à 1 mais Python commence l'indexation à 0,
  888. le nombre des mois correspond dont à index+1.
  889. * On veut avoir la correspondance à la fois avec les nombres et les chaînes
  890. de caractères. On peut utiliser les fonctions ``int()`` et ``str()`` pour
  891. ça et itérer dessus.
  892. L'exemple en question :
  893. month_codes = dict((fn(i+1), code)
  894. for i, code in enumerate('FGHJKMNQUVXZ')
  895. for fn in (int, str))
  896. Le résultat obtenu pour ``month_codes`` :
  897. { 1: 'F', 2: 'G', 3: 'H', 4: 'J', ...
  898. '1': 'F', '2': 'G', '3': 'H', '4': 'J', ...}
  899. Ordonner
  900. --------
  901. Il est très simple d'ordonner une liste en Python :
  902. a_list.sort()
  903. (Notez que la liste est ordonnée sur place, la liste originale est ordonnée
  904. et la fonction ``sort`` **ne retourne pas** une liste ou une copie.)
  905. Mais que faire lorsque vous avec une liste de données à ordonner, mais
  906. quelle ne s'ordonne pas de manière naturelle ? Par exemple ordonner selon
  907. la première colonne, puis la quatrième.
  908. On peut utiliser la fonction de référence ``sort`` avec une méthode définie
  909. par nos soins :
  910. def custom_cmp(item1, item2):
  911. returm cmp((item1[1], item1[3]),
  912. (item2[1], item2[3]))
  913. a_list.sort(custom_cmp)
  914. Ça marche, mais c'est extrêmement lent pour les listes énormes.
  915. Ordonner avec DSU
  916. -----------------
  917. DSU = Decorate-Sort-Undecorate
  918. Note: DSU n'est bien souvent plus nécessaire, cf. section suivante.
  919. Au lieu de créer une fonction de comparaison personnalisée, on crée une
  920. liste intermédiaire qui va pourvoir être ordonnée naturellement :
  921. # Decorate:
  922. to_sort = [(item[1], item[3], item)
  923. for item in a_list]
  924. # Sort:
  925. to_sort.sort()
  926. # Undecorate:
  927. a_list = [item[-1] for item in to_sort]
  928. La première ligne crée une liste contenant des tuples, une copie de la valeur
  929. à ordonner en premier argument, suivi de la valeur complète de la liste.
  930. La seconde ligne ordonne grâce à la fonction Python, ce qui est très rapide.
  931. La troisième ligne récupère la **dernière** valeur de la liste une fois
  932. ordonnée. Souvenez-vous, cette dernière valeur correspond à l'item complet.
  933. On n'utilise plus la partie ayant permis d'ordonner, elle a joué son rôle
  934. et n'est plus utile.
  935. C'est un compromis espace mémoire + complexité vs. temps. Plus simple et
  936. rapide mais on est obligé de dupliquer la liste originale.
  937. Ordonner avec keys
  938. ------------------
  939. Python 2.4 a introduit un nouvel argument à la méthode ``sort`` des listes,
  940. "key", qui permet de spécifier une fonction à un argument qui est utilisée
  941. pour comparer chaque élément d'une liste avec les autres. Par exemple :
  942. def my_key(item):
  943. return (item[1], item[3])
  944. to_sort.sort(key=my_key)
  945. La fonction ``my_key`` va être appelée une fois par item de la liste ``to_sort``.
  946. Vous pouvez utiliser votre propre fonction ou utiliser une fonction existante
  947. qui ne prend qu'un seul argument :
  948. * ``str.lower`` pour ordonner alphabétiquement sans tenir compte de la casse.
  949. * ``len`` pour ordonner selon la taille des items (chaînes de caractères ou containers).
  950. * ``int`` ou ``float`` pour ordonner numériquement avec des valeurs qui sont
  951. des chaînes de caractères comme "2", "123", "35".
  952. Generators
  953. ----------
  954. On a déjà vu les generator expressions. On peut créer nos propres generators,
  955. comme des fonctions :
  956. def my_range_generator(stop):
  957. value = 0
  958. while value < stop:
  959. yield value
  960. value += 1
  961. for i in my_range_generator(10):
  962. do_something(i)
  963. Le mot-clé ``yield`` transforme une fonction en generator. Lorsque vous
  964. appelez une fonction generator, au lieu d'exécuter le code directement,
  965. Python retourne un objet generator, qui est un itérateur. Il a une méthode
  966. ``next``. Les boucles ``for`` appellent la méthode ``next`` de l'itérateur,
  967. jusqu'à ce qu'une exception du type ``StopIteration`` soit levée.
  968. Vous pouvez lever l'exception ``StopIteration`` explicitement ou de manière
  969. implicite comme dans le code ci-dessous.
  970. Les générateurs peuvent simplifier la manière de gérer les
  971. séquences/itérateurs, car on n'a pas besoin de créer des listes
  972. intermédiaires. Ça ne génère qu'une valeur à la fois.
  973. Voici comment la boucle ``for`` fonctionne réellement. Python analyse la
  974. séquence déclarée avec le mot-clé ``in``. Si c'est un simple container (comme
  975. une liste, un tuple, un dictionnaire, un set ou un container défini par
  976. l'utilisateur) Python le converti en itérateur. Si c'est déjà un itérateur,
  977. Python ne fait rien.
  978. Python appelle ensuite de manière itérative la méthode ``next`` de
  979. l'itérateur, assignant la valeur retournée au compteur de la boucle (``i``
  980. dans notre cas), et exécute le code indenté. C'est répété, encore et encore
  981. jusqu'à ce que ``StopIteration`` soit levée, ou qu'un ``break`` soit exécuté.
  982. Une boucle ``for`` peut être dotée d'un ``else``, au sein de laquelle le
  983. code est exécuté si rien ne s'est produit dans la boucle for, mais **non**
  984. après un ``break``. Cette distinction permet de faire des choses élégantes.
  985. ``else`` est rarement utilisé avec la boucle ``for`` mais peut s'avérer
  986. très puissant lorsque la logique correspond à ce que vous souhaitez faire.
  987. Par exemple, si on doit vérifier qu'une condition est toujours remplie par
  988. tous les items d'une liste :
  989. for item in sequence:
  990. if condition(item):
  991. break
  992. else:
  993. raise Exception('Condition not satisfied.')
  994. Exemple de generator
  995. --------------------
  996. Filtrer les colonnes vides à partir d'un fichier CSV (ou des items d'une liste) :
  997. def filter_rows(row_iterator):
  998. for row in row_iterator:
  999. if row:
  1000. yield row
  1001. data_file = open(path, 'rb')
  1002. irows = filter_rows(csv.reader(data_file))
  1003. Lire les lignes d'un fichier de données
  1004. ---------------------------------------
  1005. datafile = open('datafile')
  1006. for line in datafile:
  1007. do_something(line)
  1008. C'est possible car les fichiers sont dotés d'une méthode ``next``, comme
  1009. d'autres itérateurs : les listes, les tuples, les dictionnaires (pour leurs
  1010. clés), les generators.
  1011. Il y a un piège ici : étant donnée la façon dont sont mises en cache les
  1012. données, vous ne pouvez pas utiliser à la fois les méthodes ``.next`` et
  1013. ``.read*`` à moins que vous n'utilisez Python 2.5+.
  1014. EAFP vs. LBYL
  1015. -------------
  1016. Il est plus facile de demander le pardon que la permission (EAFP) vs. analyser
  1017. avant d'échouer (LBYL). Généralement EAFP est préféré, mais pas toujours.
  1018. * Duck typing
  1019. Si ça marche comme un canard, parle comme un canard et ressemble à un
  1020. canard : c'est un canard.
  1021. * Exceptions
  1022. Essayez de forcer le type si un objet doit être d'un type particulier.
  1023. Si ``x`` doit être une chaîne de caractères pour que votre code
  1024. fonctionne, pourquoi ne pas appeler ``str(x)`` au lieu d'essayer quelque`
  1025. chose comme ``isinstance(x, str)``.
  1026. Exemple EAFP ``try/except``
  1027. ---------------------------
  1028. Vous pouvez encapsuler vos exceptions dans un bloc ``try/except`` pour
  1029. pour récupérer les erreurs et vous allez probablement arriver à une solution
  1030. qui est beaucoup plus générale que si vous aviez essayer d'anticiper chaque
  1031. cas.
  1032. try:
  1033. return str(x)
  1034. except TypeError:
  1035. ...
  1036. Note: Spécifiez toujours l'exception à attraper. N'utilisez jamais
  1037. ``except`` tout seul. Sinon ``except`` va cacher d'autres exceptions qui
  1038. risquent d'être levées rendant votre code très difficile à debugger.
  1039. Importer
  1040. --------
  1041. from module import *
  1042. Vous avez probablement déjà vu cette manière de faires des imports avec une
  1043. "étoile". Vous l'appréciez peut-être. **Ne l'utilisez pas.**
  1044. Pour paraphraser un exemple très connu :
  1045. > LUKE: Est-ce que ``from module import *`` est meilleur que des imports explicites ?
  1046. > YODA: Non, pas meilleur. Plus rapide, plus simple, plus séduisant.
  1047. > LUKE: Mais comment saurais-je pourquoi les imports explicites sont meilleurs que les formes étoilées ?
  1048. > YODA: Tu sauras lorsque ton code dans 6 mois tu essayeras de lire.
  1049. Les imports étoilés sont le mauvais côté de la Force en Python.
  1050. Les imports de type ``from module import *`` polluent votre espace de nom.
  1051. Vous allez avoir des choses que vous n'attendiez pas. Vous pouvez avoir des
  1052. conflits avec les noms que vous avez défini localement. Vous n'allez plus
  1053. savoir d'où viennent certains noms. Bien que ce soit un raccourci pratique,
  1054. ça ne doit pas arriver en production.
  1055. Morale : **n'utilisez pas d'imports étoilés !**
  1056. Il est bien meilleur de référencer les noms à partir de leurs modules :
  1057. import module
  1058. module.name
  1059. importer un module avec un nom plus court si nécessaire (avec ``alias``) :
  1060. import long_module_name as mod
  1061. mod.name
  1062. ou importer juste les noms dont vous avez besoin de manière explicite :
  1063. from module import name
  1064. name
  1065. Notez qu'il est nécessaire d'utiliser "reload()" sur un module lorsque vous
  1066. utilisez le prompt interactif si vous éditez celui-ci.
  1067. Modules et scripts
  1068. ------------------
  1069. Pour faire à la fois un module importable et un script exécutable :
  1070. if __name__ == '__main__':
  1071. # script code here
  1072. Lorsqu'il est importé, un attribut``__name__`` est setté, correspondant au
  1073. nom du fichier du module, sans ".py". Le code ci-dessus ne va donc pas être
  1074. lancé lors d'un import. Lorsqu'il est lancé comme un script, l'attribut
  1075. ``__name__`` est setté à "__main__" et le script va être exécuté.
  1076. Excepté pour certains cas spéciaux, vous ne devriez placer aucun code
  1077. important au plus haut niveau. Placez votre code dans des fonctions, classes,
  1078. méthodes et protégez le avec ``if __name__ == '__main__'``.
  1079. Structure d'un module
  1080. ---------------------
  1081. """module docstring"""
  1082. # imports
  1083. # constants
  1084. # exception classes
  1085. # interface functions
  1086. # classes
  1087. # internal functions & classes
  1088. def main(...):
  1089. ...
  1090. if __name__ == '__main__':
  1091. status = main()
  1092. sys.exit(status)
  1093. C'est la façon dont un module devrait être structuré.
  1094. Utilisation de la ligne de commande
  1095. -----------------------------------
  1096. Exemple (*Note du traducteur* : [j'ai déjà parlé de ça aussi](https://larlet.fr/david/biologeek/archives/2006218-un-template-python-pour-parser-des-arguments/)) :
  1097. #!/usr/bin/env python
  1098. """
  1099. Module docstring.
  1100. """
  1101. import sys
  1102. import optparse
  1103. def process_command_line(argv):
  1104. """
  1105. Return a 2-tuple: (settings object, args list).
  1106. `argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
  1107. """
  1108. if argv is None:
  1109. argv = sys.argv[1:]
  1110. # initialize the parser object:
  1111. parser = optparse.OptionParser(
  1112. formatter=optparse.TitledHelpFormatter(width=78),
  1113. add_help_option=None)
  1114. # define options here:
  1115. parser.add_option( # customized description; put --help last
  1116. '-h', '--help', action='help',
  1117. help='Show this help message and exit.')
  1118. settings, args = parser.parse_args(argv)
  1119. # check number of arguments, verify values, etc.:
  1120. if args:
  1121. parser.error('program takes no command-line arguments; '
  1122. '"%s" ignored.' % (args,))
  1123. # further process settings & args if necessary
  1124. return settings, args
  1125. def main(argv=None):
  1126. settings, args = process_command_line(argv)
  1127. # application code here, like:
  1128. # run(settings, args)
  1129. return 0 # success
  1130. if __name__ == '__main__':
  1131. status = main()
  1132. sys.exit(status)
  1133. Packages
  1134. --------
  1135. package/
  1136. __init__.py
  1137. module1.py
  1138. subpackage/
  1139. __init__.py
  1140. module2.py
  1141. * Utilisés pour organiser un projet.
  1142. * Réduisent le nombre d'entrées lors du chargement.
  1143. * Réduisent les conflits en cas d'imports.
  1144. Exemple :
  1145. import package.module1
  1146. from package.subpackage import module2
  1147. from package.subpackage.module2 import name
  1148. En Python 2.5 on a maintenant les imports absolus et relatifs via un import
  1149. du futur :
  1150. from __future__ import absolute_import
  1151. Je n'ai pas encore eu l'occasion de tester ça moi-même, on va donc couper
  1152. court à toute discussion à ce sujet.
  1153. Simple is Better Than Complex
  1154. -----------------------------
  1155. > Débugger est deux fois plus difficile que d'écrire du code en premier jet.
  1156. > De plus, si vous écrivez le code aussi intelligemment que possible, vous
  1157. > êtes, par définition, pas assez intelligent pour le débugger.
  1158. >
  1159. > -- Brian W. Kernighan, co-auteur de *The C Programming Language*
  1160. > et le "K" dans "AWK"
  1161. En d'autres termes, gardez vos programmes simples !
  1162. Ne réinventez pas la roue
  1163. -------------------------
  1164. Avant d'écrire une seule ligne de code,
  1165. * Vérifiez que cela n'est pas dans la bibliothèque standard de Python.
  1166. * Vérifiez que cela n'est pas dans le [Python Package Index](http://cheeseshop.python.org/pypi) (the "Cheese Shop")
  1167. * Cherchez sur le web. *Google is your friend.*
  1168. Retour du traducteur
  1169. --------------------
  1170. Pour terminer, et si vous souhaitez aller plus loin, une
  1171. [excellente présentation sur les générateurs](http://www.dabeaz.com/generators/)
  1172. que je n'aurais malheureusement pas le temps de traduire permet d'envisager la
  1173. programmation Python d'une manière tout à fait différente. Elle est orientée
  1174. administration système mais elle peut vraiment être appliquée à de nombreux cas.
  1175. Et si vous voulez comprendre l'intérêt des décorateurs,
  1176. [un bon exemple](http://avinashv.net/2008/04/python-decorators-syntactic-sugar/)
  1177. vaut mieux que tous les discours. Mangez du Python, c'est bon pour la santé !