Structures de contrôle et de données

La clause else associée à un for s'exécute lorsque la boucle se termine sans avoir rencontré de break. range(4) ne contenant pas 9, break ne se produit jamais ; la boucle se déroule donc jusqu'au bout, puis le print du else s'exécute, affichant done. Le print(n) suivant affiche ensuite la dernière valeur restée dans n au moment de sortir de la boucle, soit 3. Inverser l'ordre de sortie ferait apparaître 3 en premier, et croire à tort que else est toujours sauté à la fin de la boucle ferait disparaître done. Ne pas remarquer que n reste défini après la sortie de la boucle ferait disparaître 3.

Au premier tour, c vaut a, donc print(c) s'exécute et affiche a. Au deuxième tour, c devient b, et break arrête la boucle. La règle voulant que la clause else d'un for ne s'exécute que si la boucle se termine sans break, elle est ici sautée et no break ne s'affiche pas. Croire que else s'exécute toujours ferait apparaître aussi no break, et mal lire que print(c) se trouve avant le break ferait apparaître aussi b. Négliger le break lui-même ferait apparaître a b c en entier.

La condition pour que la clause else d'un for s'exécute est que « la boucle se soit terminée sans break », et non « qu'il y ait eu au moins une itération ». items étant vide, le corps ne s'exécute pas une seule fois, mais comme il n'y a pas eu de break non plus, else s'exécute normalement et finished s'affiche. Penser que else est aussi sauté quand c'est vide ferait croire que rien ne s'affiche. Passer une liste vide à un for est une syntaxe parfaitement correcte en soi, qui ne lève donc pas d'exception ; ni TypeError ni StopIteration ne sont levées.

n diminue de 1 en 1 à partir de 5, passe par 4 et 3, et au moment où il vaut 2, break s'exécute. La clause else d'un while, comme celle d'un for, ne s'exécute que si la boucle se termine sans break ; ici elle est donc sautée et loop ended ne s'affiche pas. Il ne reste que le print(n) affichant 2. Croire qu'else s'exécute toujours ferait apparaître aussi loop ended, et négliger le break en lisant à tort que la boucle continue jusqu'à ce que la condition devienne fausse ferait croire que n vaut 0.

Lorsque i vaut 0, 1 ou 2, les deux if sont traversés sans effet et l'élément est ajouté par append. Lorsque i vaut 3, continue s'active, sautant le reste de ce tour, c'est-à-dire l'append. Lorsque i vaut 4, l'append s'exécute de nouveau, et lorsque i vaut 5, break arrête la boucle, si bien que l'append n'a pas lieu. Le résultat est donc [0, 1, 2, 4]. Croire que l'élément du tour de break est aussi ajouté ferait apparaître la liste jusqu'à 5, et traiter continue comme pass ferait apparaître 3 dans le résultat.

range(start, stop, step) commence à start, avance de step en step, et s'arrête juste avant d'atteindre stop. Ici, en partant de 10 et en soustrayant 3 à chaque fois, on obtient 10, 7, 4, 1, et la valeur suivante, -2, n'est pas retenue car elle est inférieure ou égale à 0. stop, qui vaut 0, n'étant pas inclus, la séquence ne se termine pas par 0. Croire à tort que start n'est pas inclus ferait commencer la séquence à 7, et penser qu'on compte à partir d'une position avant start ferait commencer à 9. Le fait que stop ne soit pas inclus est identique au cas d'un pas positif.

Ce que renvoie range est un objet de type range, qui calcule les entiers nécessaires au fur et à mesure. Ne conservant pas d'abord tous les éléments comme une liste, il ne consomme pas de mémoire même pour une grande plage. Pour vérifier son contenu en le voyant aligné, on le fait passer par list(). type(range(3)) vaut range, ni list ni tuple, et son affichage direct ne montre pas la suite des éléments mais range(0, 3). De plus, comme il n'est pas à usage unique et peut être parcouru autant de fois que voulu, ce n'est pas non plus un generator. Notons que le fait d'être accessible par indice sans pouvoir remplacer les éléments est identique au tuple, si bien que cette seule propriété ne permet pas de le distinguer d'un tuple.

or évalue de gauche à droite et renvoie directement la première valeur qui devient vraie. Une liste vide comme 0 étant fausses, c'est finalement "z" qui est renvoyé. and, à l'inverse, renvoie la première valeur qui devient fausse ; 1 étant vrai, c'est au 0 suivant que le résultat faux est déterminé, et 0 est renvoyé, sans que le 2 à l'extrémité droite ne soit évalué. Ce qui est renvoyé n'est pas une valeur booléenne mais la valeur au moment où l'évaluation s'est arrêtée, donc ni True ni False ne peuvent apparaître. and ne renvoie le 2 de l'extrémité droite que si tous les éléments intermédiaires étaient vrais.

1 < x < 5 équivaut à (1 < x) and (x < 5) ; si x vaut 3, les deux conditions sont vérifiées, donc le résultat est True. L'opérateur ternaire s'écrit valeur si vrai if condition else valeur si faux, et la condition est ici x % 2, soit 1. En Python, tout entier différent de 0 est traité comme vrai, donc yes est choisi. En lisant à tort la comparaison enchaînée en l'associant depuis la droite, comme 1 < (x < 5), on obtiendrait x < 5 égal à True, soit 1, puis 1 < 1 donnerait False par erreur. De même, considérer 1 comme faux mènerait à choisir no.

Python représentant les blocs par l'indentation, il n'est pas possible d'écrire un bloc vide. pass sert à remplir cet emplacement lorsqu'on prévoit d'écrire le contenu d'une classe ou d'une fonction plus tard, ou lorsqu'on souhaite volontairement ne rien faire dans un cas conditionnel donné. Il n'a aucun effet sur le déroulement du traitement. Passer à l'itération suivante est le rôle de continue, arrêter la boucle celui de break, et renvoyer une valeur à l'appelant celui de return ; leurs rôles diffèrent tous de celui de pass.

enumerate renvoie successivement des tuples (numéro, élément), et son second argument start permet de préciser la valeur à partir de laquelle compter. Ici, 1 étant passé, les numéros sont 1, 2, 3. Confondre cela avec le début par défaut à 0 (start omis) ferait croire que la numérotation commence à 0. Le tuple renvoyé plaçant le numéro avant l'élément, l'ordre dans print(i, name) suit également cet ordre, et le nom n'apparaît jamais en premier. Les 3 éléments étant tous extraits, l'affichage ne s'arrête pas non plus après 2 lignes.

zip extrait un élément à la fois de chacun des itérables passés pour former des tuples, et s'arrête dès que le plus court est épuisé. La seconde liste ayant ici 2 éléments, seuls 2 tuples sont créés, et le 3 restant est discrètement abandonné. Il n'y a pas d'erreur, le manquant n'est pas comblé par 0, et aucun tuple partiel n'est créé. Le contenu des tuples suit l'ordre des arguments passés ; il n'y a donc pas d'inversion comme 10 et 1.

Avec l'astérisque, chaque tuple de la liste est transmis à zip comme un argument séparé. Cela revient donc à appeler zip((1, 'a'), (2, 'b'), (3, 'c')), qui regroupe les premiers éléments de chaque tuple entre eux, et les seconds entre eux, donnant deux séries : (1, 2, 3) et ('a', 'b', 'c'). C'est la technique classique pour revenir des données mises en tuples à leurs deux séries d'origine ; passer deux fois par zip revient au point de départ. Ce qui est renvoyé étant des tuples et non des listes, il n'y a pas de crochets. En oubliant l'astérisque et en écrivant zip(pairs), c'est le tuple lui-même qui est transmis comme un seul argument, donnant des tuples à un seul élément comme ((1, 'a'),).

zip(keys, vals) renvoie successivement des tuples (clé, valeur), et dict() prend cette série de tuples pour construire un dictionnaire. Le premier élément d'un tuple devient la clé et le second la valeur ; les nombres ne peuvent donc pas devenir des clés dans ce cas. Passé par dict(), le résultat n'est pas non plus une liste de tuples. Même affiché avec des accolades, un dictionnaire se distingue par le fait que les paires sont reliées par des deux-points, contrairement à un ensemble où les valeurs sont simplement alignées.

range(1, 5) renvoie 1, 2, 3, 4 ; la valeur 5 passée comme stop n'est pas incluse. En élevant chacun au carré, on obtient 1, 4, 9, 16. Supposer à tort que range commence à 0 ferait débuter la séquence à 0, et croire que stop est inclus ferait apparaître 25. Lire n * n comme n * 2 ferait apparaître une progression de 2 en 2. Il est utile de retenir qu'une compréhension évalue l'expression de gauche pour chaque élément, et construit une nouvelle liste en alignant les résultats.

Une compréhension avec des deux-points à l'intérieur d'accolades est une compréhension de dictionnaire, où le côté gauche des deux-points devient la clé, et le côté droit la valeur. Ici, on obtient un dictionnaire ayant les mots comme clés et leur longueur comme valeurs. Lire clé et valeur en sens inverse ferait croire que la longueur devient la clé. Entourer d'accolades une compréhension donnerait une liste de tuples, mais ici il s'agit d'accolades, donc ce n'est pas le cas. Sans les deux-points, on obtiendrait une compréhension d'ensemble avec seulement les valeurs alignées, mais la présence des deux-points garantit qu'il s'agit bien d'un dictionnaire.

Il n'existe pas en Python d'écriture appelée « compréhension de tuple » ; cette forme entourée de parenthèses devient une expression génératrice. Son type est generator ; elle ne construit pas d'abord toutes les valeurs, mais les calcule une par une au moment où elles sont demandées, ce qui économise la mémoire, mais en tant qu'itérateur, elle s'épuise après un seul usage. Pour obtenir un tuple, il faut l'envelopper avec tuple(). Avec des crochets, on obtiendrait une compréhension de liste, de type list, et en affectant directement range(3), on obtiendrait un range. tuple ne s'obtient pas avec cette écriture.

Les restes de la division par 4 de chaque valeur de range(10) sont 0, 1, 2, 3, 0, 1, 2, 3, 0, 1. Une compréhension entre accolades sans deux-points étant une compréhension d'ensemble, les valeurs en double sont regroupées en une seule, et il ne reste que les 4 valeurs distinctes 0, 1, 2, 3. Négliger la disparition des doublons et compter simplement le nombre de valeurs donnerait 10. Négliger que 0 fasse partie des restes et ne compter que 3 valeurs distinctes 1, 2, 3 donnerait 3. 0 correspondrait à croire à tort que la compréhension ne produit rien, mais en parcourant range(10), le contenu n'est jamais vide. L'ordre d'affichage d'un ensemble n'étant pas défini, vérifier par le nombre d'éléments est la méthode la plus sûre.

Lorsqu'une compréhension aligne deux for, celui écrit à gauche devient la boucle extérieure. C'est exactement le même ordre que si l'on avait imbriqué deux instructions for classiques : x est fixé à 1 pendant que y parcourt a, b, puis x passe à 2 et le même parcours recommence. Lire le for de droite comme extérieur ferait avancer x en premier. Le contenu des tuples suit l'ordre écrit dans l'expression (x, y), donc la lettre ne peut jamais venir en premier.

Le second argument start d'enumerate détermine uniquement à partir de quel nombre commencer la numérotation attribuée. Sa valeur par défaut étant 0, passer 1 donne une numérotation ordinaire adaptée à l'humain. L'essentiel est que seule la manière de numéroter change, sans que la plage ou le nombre d'éléments extraits ne soient affectés. Il n'a aucun effet de limitation du nombre d'éléments ni de saut, et ne décale pas non plus la position de départ de l'extraction. Ces fonctionnalités correspondent à d'autres outils, comme le découpage (slice).

sort est une méthode qui trie la liste sur place, et sa valeur de retour est None. result contient donc None, et le résultat trié reste du côté de nums. Croire qu'une nouvelle liste triée est renvoyée ferait apparaître une liste dans result. Négliger que sort modifie la liste d'origine ferait croire que nums reste dans son ordre initial. Pour obtenir une liste triée tout en conservant l'originale, on utilise la fonction native sorted.

sort est une méthode de liste qui trie la liste elle-même et renvoie None comme valeur de retour. sorted est une fonction native qui ne modifie en rien l'ordre d'origine et renvoie une nouvelle liste triée. On choisit l'une ou l'autre selon qu'on souhaite conserver l'original. Inverser les rôles des deux donnerait une description où sort renverrait une nouvelle liste. Considérer les deux comme destructrices ou non de la même façon mènerait à dire que les deux trient sur place, ou que les deux ne modifient pas l'original. Notons que sorted peut aussi recevoir un itérable autre qu'une liste, et son résultat est toujours une liste.

append ajoute son argument tel quel comme un seul élément à la fin ; en lui passant une liste, elle devient donc imbriquée, et la longueur n'augmente que de 1. extend ajoute un par un les valeurs extraites en itérant sur l'argument, si bien que le contenu se déploie et la longueur augmente de 2. Inverser les rôles des deux inverserait les résultats de a et b. Considérer que les deux fonctionnent de la même façon mènerait soit à ce que les deux imbriquent, soit à ce que les deux aplatissent. Ces deux méthodes renvoyant toutes deux None, il est aussi utile de retenir qu'il ne faut pas récupérer leur résultat dans une variable.

La duplication par découpage est une copie superficielle : la liste extérieure est nouvellement créée, mais les éléments qu'elle contient restent partagés avec l'original. copy1[0] et orig[0] pointant vers la même liste, un append à cet endroit se répercute aussi du côté de l'original. Croire qu'elles sont complètement séparées ferait penser que l'original ne change pas. Seule la liste intérieure du début a été modifiée, donc cela ne s'étend pas aux éléments suivants, et comme rien n'a été ajouté à l'extérieur, 9 n'apparaît pas non plus dans la liste extérieure. Pour séparer complètement même les niveaux intérieurs, on utilise copy.deepcopy.

copy.deepcopy duplique jusqu'au contenu imbriqué, si bien que d[0] devient une liste distincte de base[0], et un append à cet endroit n'atteint pas base. En revanche, s étant une copie superficielle, s[1] et base[1] sont la même liste, si bien qu'un append à cet endroit se répercute aussi sur base. Seul le second élément s'allonge donc. Croire que les deux atteignent base ferait allonger les deux éléments intérieurs, et croire qu'aucun des deux ne l'atteint laisserait base inchangé. Confondre copie profonde et copie superficielle ferait allonger seulement le premier élément.

La multiplication extérieure ne crée pas de nouvelles lignes ; elle aligne simplement deux références vers une seule et même liste. grid[0] et grid[1] étant la même entité, modifier la position d'indice 1 de l'un fait apparaître le même changement à la même position dans l'autre. Croire que les lignes sont indépendantes ferait penser qu'une seule ligne change. La position modifiée étant l'indice 1, le premier élément ne devient pas non plus 5. Pour rendre chaque ligne indépendante, on écrit [[0] * 3 for _ in range(2)].

Ce qui détermine un tuple, ce n'est pas la parenthèse mais la virgule. (7) n'est qu'un entier entouré de parenthèses indiquant la priorité de calcul, son type est donc int ; ce n'est qu'avec la virgule finale de (7,) qu'on obtient un tuple à un seul élément. Croire qu'entourer de parenthèses suffit à créer un tuple ferait obtenir tuple dans les deux cas ; confondre les deux donnerait un ordre inversé ou les deux en int. Notons que le tuple vide fait exception : il s'écrit () sans virgule.

Ce qu'un tuple fige, c'est l'association vers quel élément il pointe, et non le contenu de ce vers quoi il pointe. t[1] est une liste, et cette liste elle-même étant mutable, on peut y appliquer append. Une écriture comme t[1] = [], qui affecterait directement un élément du tuple, lèverait une TypeError, mais ici on ne remplace pas un élément. Comme l'ajout se fait à l'intérieur de la liste, la longueur du tuple n'augmente pas, et il ne reste pas non plus totalement inchangé.

Affecter à un découpage remplace entièrement la plage indiquée par le contenu du membre droit. x[1:3] désigne les 2 éléments 2 et 3, qui sont remplacés par le seul élément 9, réduisant la longueur totale de 5 à 4. Croire qu'un seul élément est remplacé laisserait la longueur à 5, et croire que le membre droit est étiré pour correspondre à la largeur ferait apparaître 9 deux fois. Lire le début de la plage avec un décalage d'un cran laisserait 2 subsister. La caractéristique de l'affectation à un découpage est que la largeur du membre gauche et la longueur du membre droit peuvent différer.

y[1:1] désignant une plage de largeur 0, y affecter revient à insérer sans rien supprimer, ce qui donne [1, 7, 8, 2, 3]. Le del y[0] qui suit retire le 1 initial, laissant [7, 8, 2, 3]. Lire que l'insertion supprime aussi un élément d'origine donnerait 7 8 3, et croire que del supprime une autre position laisserait le 1 initial. Mal lire que le résultat s'ajoute à la fin ferait apparaître 2 et 3 en premier. Il est utile de retenir que del est une instruction sans valeur de retour, qui supprime sans extraire de valeur.

get ne lève pas d'exception lorsque la clé est absente : elle renvoie None si le second argument est omis, ou cette valeur si elle est fournie. Le premier résultat est donc None, le second 0. Croire que 0 est renvoyé même sans second argument ferait obtenir 0 dans les deux cas, et croire que le second argument est ignoré ferait obtenir None dans les deux cas. Écrire d["z"] avec des crochets lèverait une KeyError ; get est justement l'outil pour l'éviter.

setdefault, si la clé existe, se contente de renvoyer la valeur existante sans modifier le dictionnaire. Si la clé n'existe pas, elle insère le second argument comme valeur et le renvoie. Le premier appel renvoie donc la valeur existante 1 sans changer le dictionnaire, et le second insère 99 et le renvoie. Croire que même la valeur existante est écrasée donnerait 99 dans les deux cas, et croire qu'aucune insertion ne se produit laisserait le dictionnaire inchangé. En omettant le second argument, la valeur insérée serait None ; l'apparition de None correspond au cas où ce second argument n'a pas été écrit.

in appliqué à un dictionnaire n'examine que les clés. "x" étant une clé, le résultat est True ; 1 existe en tant que valeur mais pas en tant que clé, donc False. Pour examiner les valeurs, il faut cibler d.values(), qui donne alors True. Croire que in examine aussi les valeurs ferait obtenir True partout, et croire que values() n'examine pas non plus les valeurs ferait obtenir False au dernier résultat. Inverser les rôles de clé et de valeur ferait obtenir False au premier résultat. Vérifier la présence d'une clé avant d'y accéder avec des crochets est un usage classique.

Un littéral de dictionnaire crée les entrées dans l'ordre, de gauche à droite ; si une même clé apparaît deux fois, la valeur ultérieure écrase la précédente. Cela ne provoque ni erreur ni avertissement. Croire que la première valeur écrite subsiste ferait rester la valeur de a à 1. De plus, un dictionnaire conserve l'ordre d'insertion, et un écrasement ne déplace pas la position ; a reste donc en tête de l'ordre. L'ordre des clés ne change donc pas, et la valeur de b n'est pas non plus affectée par ricochet.

dict peut construire un dictionnaire aussi bien à partir d'arguments nommés qu'à partir d'une série de paires (clé, valeur). Les deux écritures produisant un dictionnaire de contenu identique, la comparaison donne True. Croire que des méthodes de construction différentes donnent des objets différents ferait obtenir False. Le nom d'un argument nommé devenant directement la chaîne de la clé, il n'y a pas d'inversion entre clé et valeur. Une fois passé par dict, l'objet est déjà un dictionnaire ; il ne reste donc pas sous forme de série de paires.

{1, 2} avec des éléments à l'intérieur devient un ensemble, mais si le contenu est vide, on ne peut trancher ni pour un dictionnaire ni pour un ensemble. Python traite ce cas comme un dictionnaire, donc {} est un dictionnaire vide. Pour obtenir un ensemble vide, on doit obligatoirement écrire set(). Croire que des accolades signifient toujours un ensemble ferait obtenir set dans les deux cas, et confondre les deux inverserait l'ordre. Croire que même set() devient un dictionnaire ferait obtenir dict dans les deux cas. Ensembles et dictionnaires utilisant tous deux des accolades, cette distinction prête facilement à confusion.

L'esperluette est l'intersection : elle conserve 3 et 4, présents dans les deux. Le circonflexe est la différence symétrique : elle rassemble les éléments présents dans un seul des deux, conservant donc 1 et 2, propres à s1, et 5, propre à s2, tandis que les éléments communs 3 et 4 disparaissent. Confondre la différence symétrique avec la différence simple ferait disparaître 5, et inverser les deux opérations inverserait l'ordre d'affichage. Confondre la différence symétrique avec l'union ferait inclure aussi 3 et 4. L'ordre d'affichage d'un ensemble n'étant pas défini, on vérifie ici en triant avec sorted.

En passant une liste à set, les doublons sont éliminés ; il ne reste que les 3 valeurs distinctes 1, 2, 3, donc la longueur est 3. En passant un ensemble à sorted, une nouvelle liste triée par ordre croissant est renvoyée. Croire que les doublons subsistent donnerait un compte de 6. sorted trie par ordre de valeur et non par ordre d'apparition d'origine, donc l'ordre ne suit pas non plus celui de la première apparition. L'ordre d'affichage d'un ensemble en lui-même n'ayant pas de sens, on passe par sorted pour l'aligner.

Les éléments d'un ensemble comme les clés d'un dictionnaire doivent être hachables. Un tuple, dont le contenu ne peut pas changer, est hachable et peut donc être ajouté ; une liste, dont le contenu peut changer par la suite, n'est pas hachable, ce qui provoque une TypeError avec un message du type unhashable type. Croire que les deux entrent ferait afficher 2, et croire qu'une conversion implicite en tuple a lieu ferait afficher 1. Le mélange de types n'étant pas en soi un problème, la justification par une ValueError est également erronée.

keys renvoie uniquement les clés, values uniquement les valeurs, et items renvoie successivement des tuples (clé, valeur). Pour parcourir un dictionnaire, la forme classique est for k, v in d.items() avec deux variables. Inverser les rôles de ces trois méthodes mènerait à des descriptions comme keys renvoyant les valeurs. Ce que renvoie items est la série des entrées, pas leur nombre ; une description disant qu'items renvoie le nombre d'entrées est donc erronée, et pour connaître ce nombre, on utilise len. Notons que passer directement le dictionnaire à un for extrait les clés.