Types et chaînes en Python

Le manuel principal de l'examen de base est 『Pythonチュートリアル』(le Tutoriel Python) d'O'Reilly Japan ; la page officielle indique qu'à compter du 1er septembre 2021, l'examen correspond à la 4e édition. Le champ d'examen étant lui aussi publié avec les numéros et titres de chapitre de ce livre, la préparation consiste à maîtriser son contenu selon le poids attribué à chaque chapitre. 『Python実践レシピ』(Recettes pratiques Python) de Gijutsu-Hyoronsha est le manuel de l'examen pratique, 『Pythonによるあたらしいデータ分析の教科書』(Le nouveau manuel d'analyse de données par Python) de Shoeisha celui de l'examen d'analyse de données, et 『Pythonデータ分析 実践ハンドブック』(Manuel pratique d'analyse de données Python) d'Impress celui de l'examen pratique d'analyse de données ; ce sont tous des manuels d'autres examens organisés par la même association. Se tromper de manuel conduit à étudier indéfiniment hors du champ d'examen ; il convient donc de le vérifier en premier lieu.

Le plus fourni est le chapitre 4, « Outils de contrôle du flux », avec 9 questions sur 40. Viennent ensuite le chapitre 5, « Structures de données », avec 7 questions, puis le chapitre 3, « Une introduction en douceur », avec 6 questions, et le chapitre 8, « Erreurs et exceptions », avec 4 questions. Les seuls chapitres 3, 4 et 5 totalisent 22 questions, soit plus de la moitié de l'ensemble. Il est donc rationnel de répartir aussi le temps d'étude en priorité sur ces trois chapitres, et négliger en particulier le chapitre 4, qui traite de la boucle for et de la définition de fonctions, serait irrattrapable.

Le chapitre 4, « Outils de contrôle du flux », représente 9 questions sur 40, soit une proportion de 22,5 %. C'est le chapitre le plus important, suivi par le chapitre 5, « Structures de données », avec 7 questions, soit 17,5 %. 15,0 % correspond aux 6 questions du chapitre 3, « Une introduction en douceur », et 10,0 % correspond aux 4 questions de chacun des chapitres 8, « Erreurs et exceptions », et 10, « Brève excursion dans la bibliothèque standard ». Cette répartition n'est pas un chiffre opérationnel, mais est publiée en tant que champ d'examen lui-même, si bien qu'elle peut servir de base au plan d'étude.

Le chapitre 13, « Et maintenant ? », compte 0 question ; c'est le seul chapitre du champ d'examen qui n'est jamais interrogé. Son contenu guidant vers les prochaines étapes de l'apprentissage, il est exclu du champ d'un examen portant sur la syntaxe. 1 question est attribuée aux chapitres 1, 2, 7, 11, 12 et 14, 2 questions aux chapitres 6 et 9, et 4 questions aux chapitres 8, « Erreurs et exceptions », et 10, « Brève excursion dans la bibliothèque standard ». Tous les chapitres sauf le 13 comptent au moins 1 question ; même les chapitres peu représentés méritent donc au moins un survol du vocabulaire.

print() joint les arguments reçus au moyen de l'argument nommé sep. La valeur par défaut de sep est un unique espace ; sans précision, on obtiendrait Python 3 exam, mais ici sep='/' est spécifié, si bien que les éléments sont reliés par des barres obliques pour donner Python/3/exam. Python3exam correspond à sep réglé sur une chaîne vide. Choisir Python/3/exam/, avec un séparateur en fin également, reviendrait à penser que sep est ajouté après chaque élément, alors qu'en réalité il n'apparaît qu'entre les arguments. Ce qui s'ajoute à la fin, c'est end.

print() ajoute l'argument nommé end à la fin de la sortie. Sa valeur par défaut est un caractère de saut de ligne, donc sans précision, chaque appel à print() saute une ligne. Ici, les deux premiers appels ont end='', ce qui supprime le saut de ligne, si bien que A et B s'affichent à la suite ; le dernier print() ajoute le saut de ligne par défaut, si bien que ABC s'affiche sur une seule ligne. A B C avec des espaces correspondrait à un seul appel print() recevant trois arguments, 3 lignes correspondrait à l'absence totale de spécification de end, et 2 lignes correspondrait au cas où un seul des end='' aurait été omis.

Avec un astérisque, print(*nums) transmet chaque élément de la liste comme un argument séparé à print(). Les trois arguments sont donc joints par sep, qui vaut ', ', ce qui donne 10, 20, 30. Sans astérisque, print(nums) transmet la liste comme un seul argument, et l'affichage se fait avec crochets, [10, 20, 30], tel quel. Sans spécifier sep, on obtient l'espace par défaut, 10 20 30, et avec sep='', l'affichage est collé, 102030.

Les commentaires en Python s'écrivent avec le symbole dièse, et tout ce qui suit jusqu'à la fin de la ligne est ignoré. Placé en début de ligne, toute la ligne est concernée ; placé au milieu, seule la suite l'est. Il n'existe pas de syntaxe dédiée pour regrouper plusieurs lignes ; il faut donc placer un dièse à chaque ligne. On utilise parfois une chaîne entourée de guillemets triples en guise de commentaire de bloc, mais il s'agit syntaxiquement d'un littéral de chaîne, qui, placé en tête d'une fonction ou d'une classe, est conservé à l'exécution comme docstring. Le double slash est en Python l'opérateur de division entière, et le couple slash-astérisque ou le double tiret sont des notations de commentaire d'autres langages.

Python exprime les blocs par la profondeur de l'indentation, si bien que les instructions appartenant au même bloc doivent avoir la même largeur de retrait. Seule la 3e ligne est plus profonde, et la ligne précédente n'est de plus pas une ligne introduisant un nouveau bloc (une ligne se terminant par deux-points) ; il en résulte une IndentationError: unexpected indent. Cette erreur étant détectée lors de l'analyse syntaxique avant l'exécution, même le print de la 2e ligne ne s'exécute pas, et même one ne s'affiche pas. Si l'indentation manque là où elle est nécessaire, le message est expected an indented block, et si la largeur ne correspond plus en cours de route, c'est unindent does not match any outer indentation level ; mais dans les deux cas, il s'agit d'une IndentationError.

Un fichier source Python 3 est lu par défaut en UTF-8, si bien qu'on peut écrire du japonais directement aussi bien dans les commentaires que dans les littéraux de chaîne. Sous Python 2, l'encodage par défaut était ASCII, et pour inclure du japonais, il fallait écrire une déclaration coding sur la première ou la deuxième ligne du fichier ; sous Python 3, cette déclaration n'est plus nécessaire. On n'écrit une telle déclaration que si l'on souhaite faire lire un fichier enregistré dans un autre encodage qu'UTF-8. Notons qu'il est également possible d'utiliser du japonais dans les identifiants (noms de variables ou de fonctions), bien que cela ne soit pas recommandé du point de vue de la lisibilité.

L'opérateur / à barre unique est la division vraie, dont le résultat est toujours un float. Même lorsque la division tombe juste, cela ne fait pas exception : 9 / 3 vaut donc 3.0 et non 3, avec le type float. Penser qu'un calcul entre entiers donne un int mène à choisir 3 et int par erreur ; pour obtenir un int, il faut utiliser la division entière et écrire 9 // 3, qui donne alors 3 et int. Les combinaisons où l'apparence de la valeur et le type ne correspondent pas, comme 3 et float, ou 3.0 et int, ne résultent pas de cette expression.

L'opérateur // à double barre est la division entière, qui arrondit le quotient vers le bas, c'est-à-dire vers la plus petite valeur sur l'axe numérique. 9 / 4 valant 2,25, 9 // 4 vaut 2 ; -9 / 4 valant -2,25, -9 // 4 vaut non pas -2 mais -3. L'essentiel est que l'arrondi ne se fait pas vers 0 ; choisir -2 reviendrait à penser, comme en langage C, que l'arrondi se fait vers 0. 2,25 et -2,25 sont les valeurs obtenues avec / plutôt que //, et 2,0 et -3,0 correspondent au cas où l'on mélange un float dans les opérandes en écrivant 9.0 // 4 ; si les deux côtés sont des int, le résultat est aussi un int.

divmod(a, b) renvoie le tuple (a // b, a % b). L'opérateur // de Python arrondissant vers le bas, -11 // 3 vaut -4, et le signe du reste étant aligné sur celui du diviseur, -11 % 3 vaut 1. Le résultat est donc (-4, 1). En raisonnant selon un arrondi vers 0, on obtiendrait un quotient de -3 et un reste de -2, menant à choisir par erreur (-3, -2), mais Python n'adopte pas cette convention. Le quotient et le reste conservent toujours la relation selon laquelle diviseur fois quotient plus reste redonne la valeur d'origine ; on peut donc vérifier : 3 fois -4 plus 1 donne -11. En vérifiant avec cette relation, ni (-3, 2) ni (-4, -2) ne redonnent -11.

La fonction native int() supprime la partie décimale en arrondissant vers 0, si bien que int(-2.7) vaut non pas -3 mais -2. En revanche, // arrondit vers le bas, si bien que -2.7 // 1 va du côté de -3, et comme les opérandes contiennent un float, le résultat est aussi un float, -3.0. Pour les nombres positifs, int(2.7) et 2.7 // 1 vont tous deux du côté de 2, la différence ne se voit donc pas ; c'est avec les nombres négatifs que la direction diverge. Aucun des deux n'est un arrondi classique ; pour arrondir -2.7 à -3, il faut utiliser round(-2.7).

float conserve les nombres décimaux en base 2, si bien que des valeurs simples en base 10 comme 0.1 ou 0.7 ne peuvent pas être représentées exactement. En affichant réellement 0.1 + 0.7, on obtient 0.7999999999999999, légèrement différent de 0.8, donc la ligne 1 vaut False. La ligne 2 compare après avoir arrondi avec round() à 2 décimales, si bien que les deux côtés valent 0.8 et le résultat est True. Ce n'est pas un défaut propre à Python mais une propriété de la virgule flottante binaire de la norme IEEE 754 ; c'est pour la même raison que 0.1 + 0.2 donne 0.30000000000000004, ou que 1.1 + 2.2 donne 3.3000000000000003. Il faut éviter les comparaisons d'égalité entre float, et plutôt arrondir au nombre de décimales nécessaire avant de comparer, ou comparer la valeur absolue de la différence à une tolérance, ou encore, pour des cas exigeant une exactitude stricte comme des montants d'argent, utiliser le module decimal.

La fonction round() de Python arrondit au nombre pair le plus proche, ce qu'on appelle l'arrondi bancaire. Ce n'est que pour une valeur exactement à mi-chemin qu'elle se dirige vers le nombre pair le plus proche : 1.5 devient donc 2, 2.5 reste 2, et 3.5 devient 4, ce qui donne 2 2 4 en sortie. L'arrondi classique enseigné à l'école donnerait 2 3 4, mais Python n'adopte pas cette convention. 1 2 3 correspond à une simple troncature de la partie décimale, et 1 3 3 correspond à un arrondi systématique vers le nombre impair ; ni l'un ni l'autre ne correspond au comportement réel. Notons que round() sans second argument renvoie un int, tandis qu'en précisant le nombre de décimales, comme round(2.5, 0), un float, 2.0, est renvoyé.

bool étant un type héritant de int, True peut être utilisé directement dans un calcul numérique comme l'entier 1, et False comme l'entier 0. True + True donne 1 plus 1, soit 2, et isinstance(True, int) renvoie True. Penser que la ligne 1 vaut True reviendrait à confondre + avec le OU logique, alors que le OU logique de Python est or, et True or True donnerait True. issubclass(bool, int) vaut également True, et sum([True, False, True]) vaut 2 pour la même raison. Cette propriété est souvent utilisée pour compter le nombre d'éléments satisfaisant une condition.

Le type int de Python 3 est de précision arbitraire, sans limite de nombre de chiffres. 3 ** 40 se calcule exactement comme 12157665459056928801, ce qui dépasse la plage d'un entier signé sur 64 bits, mais le type reste int. Des valeurs comme 2 ** 1000 sont également traitées, et en comptant le nombre de chiffres avec len(str(2 ** 1000)), on obtient 302 chiffres. N'étant pas un entier de longueur fixe comme en langage C, il ne déborde jamais vers une valeur négative, ni ne bascule automatiquement vers float. Une OverflowError survient par exemple lorsqu'une valeur dépasse la plage représentable par un float, mais ne survient pas simplement parce que le nombre de chiffres d'un int augmente. Cependant, le temps de calcul et la mémoire augmentent à mesure que le nombre de chiffres croît.

Accéder à bytes avec un indice entier renvoie la valeur de l'octet à cette position sous forme d'int. Le premier octet de b'abc', l'encodage UTF-8 de 'abc', est le point de code de 'a', soit 97. En revanche, extraire par découpage (slice) renvoie un bytes de longueur 1, donc b[0:1] vaut b'a'. Avec str, s[0] comme s[0:1] donnent le même str 'a', ce qui contraste avec le comportement de bytes. L'affichage sous forme de b'a' plutôt que a s'explique par le fait que print() affiche bytes sous sa forme repr ; pour revenir à une chaîne, on utilise b.decode().

Le second argument de int() étant la base, int('1010', 2) lit la chaîne comme un nombre binaire et renvoie 10. Penser que le résultat reste 1010 correspondrait à avoir négligé cette base. bin() renvoie une chaîne préfixée par 0b, soit '0b1010', et hex() renvoie une chaîne en minuscules préfixée par 0x, soit '0xff'. Le résultat n'est jamais en majuscules 0xFF ; pour obtenir une notation en majuscules, on utilise format(255, 'X'). ord() renvoie le point de code d'un caractère, et pour la majuscule A, il vaut 65. 97 est le point de code de la minuscule a ; la conversion inverse s'écrit chr(65) et redonne 'A'.

s[2:5] extrait à partir de la position d'indice 2 jusqu'à juste avant l'indice 5. L'indice 2 de 'Pythonic' étant t, on obtient les 3 caractères t, h, o, soit tho. La position de fin n'étant pas incluse, on n'obtient pas thon. En comptant les indices à partir de 1 et en lisant « à partir du 2e caractère », on choisirait par erreur yth, qui correspond à s[1:4]. s[-3:] utilise un indice négatif, donc compte depuis la fin, et renvoie à partir du 3e caractère depuis la fin, n, jusqu'à la fin, soit nic. En lisant à tort -3 comme « jusqu'au 3e caractère depuis la fin », on choisirait ic, qui correspond à s[-2:]. Retenir que l'indexation commence à 0 et qu'un indice négatif compte la fin comme -1 évite toute confusion.

Un découpage (slice) ne lève pas d'exception même si la plage dépasse la longueur de la chaîne ; il ne renvoie que la partie qui se recouvre. 'Python' ne comptant que 6 caractères, s[100:200] vaut donc une chaîne vide, et la comparaison avec une chaîne vide donne True. Un indice unique s[100], en revanche, lèverait une IndexError ; c'est là le contraste. À la ligne 2, l'opérateur in vérifie la présence d'une sous-chaîne, mais en respectant la casse, si bien que la minuscule 'py' n'est pas contenue dans 'Python' et donne False. Avec 'Py' ou 'th', le résultat serait True.

str étant immuable, c'est-à-dire que son contenu ne peut pas être modifié après création, il n'est pas possible de réécrire un seul caractère par indexation. s[0] = 'z' provoque une TypeError: 'str' object does not support item assignment, ce qui arrête l'exécution ; le print ne s'exécute donc pas non plus. IndexError survient lorsque l'indice est hors de la plage, ce qui n'est pas le cas ici puisque 0 est un indice valide ; c'est donc un autre sujet. Pour modifier le contenu, il faut créer une nouvelle chaîne et la réassembler, par exemple s = 'z' + s[1:]. Une liste étant mutable, on peut en revanche réécrire un élément avec la même syntaxe.

Les méthodes de chaîne ne modifient pas la chaîne d'origine ; elles créent et renvoient une nouvelle chaîne. À la ligne 2, s.upper() crée 'EXAM', mais comme la valeur n'est affectée nulle part, elle est simplement perdue, et s reste 'exam'. print(s) affiche donc exam. La ligne 4 affiche directement la valeur de retour de s.replace('e', 'E'), donnant Exam, mais cela non plus ne modifie pas s lui-même. Pour conserver le résultat, il faut réaffecter, comme dans s = s.upper(). Cela contraste avec des méthodes comme sort() sur une liste, qui trient sur place et renvoient None.

La spécification de format :.2f d'une f-string arrondit à 2 décimales pour l'affichage, si bien que 2.71828 devient 2.72. Il ne s'agit pas d'une troncature, donc on n'obtient pas 2.71 ; 2.718 correspondrait à l'écriture :.3f. Le !r de la ligne 2 est une spécification de conversion, affichant la valeur sous la forme de repr(). Appliqué à une chaîne, il ajoute des guillemets, donnant 'ok' ; sans !r, on obtiendrait simplement ok. La syntaxe de formatage étant commune avec str.format(), écrire '{n:.2f}'.format(n=2.71828) donne le même résultat, 2.72.

En appelant split() sans argument, les espaces consécutifs sont traités comme un seul séparateur, sans créer d'élément vide. 'a b c'.split() donne donc les 3 éléments ['a', 'b', 'c']. En précisant explicitement le séparateur avec 'a b c'.split(' '), la coupe se fait à chaque espace un par un, laissant une chaîne vide et donnant les 4 éléments ['a', 'b', '', 'c']. Le second argument, maxsplit, limite le nombre de coupes ; en passant 1, une seule coupe est faite au premier séparateur, donnant ['a', 'b,c'], le reste restant regroupé sans être coupé. En omettant cet argument, tout est coupé, donnant ['a', 'b', 'c'].

L'argument de strip() est « l'ensemble des caractères à retirer » : depuis les deux extrémités, on continue de retirer tant que le caractère appartient à cet ensemble. Ce n'est pas la suppression d'une seule occurrence de la sous-chaîne 'x' ; 'xxabxx'.strip('x') retire donc tous les x des deux côtés, donnant ab. Penser qu'un seul caractère est retiré à chaque extrémité conduirait à choisir xabx par erreur. lstrip() ne traite que le côté gauche, donnant abxx, et rstrip() ne traite que le côté droit, donnant xxab. Sans argument, ce sont les espaces qui sont retirés. Étant traité comme un ensemble, écrire 'xxabxx'.strip('xa') retire aussi le xx à gauche et le a suivant, ne laissant que b.

join() relie chaque élément de l'itérable transmis en utilisant la chaîne appelante comme séparateur. Une chaîne étant elle-même un itérable dont on peut extraire les caractères un par un, '-'.join('abc') relie 'a', 'b' et 'c' par des tirets, donnant a-b-c. Le séparateur ne s'insérant qu'entre les éléments, il n'apparaît ni au début ni à la fin, donc pas de -a-b-c-. On obtiendrait abc sans séparateur en écrivant ''.join('abc'). L'opérateur * répète une chaîne un nombre de fois donné, donc 'ab' * 3 donne ababab, sans espace entre les répétitions. Pour obtenir ab ab ab, il faudrait écrire ' '.join(['ab'] * 3).

find() renvoie -1 lorsque la sous-chaîne n'est pas trouvée, sans lever d'exception. 'banana' ne contenant pas 'z', le résultat est -1. 0 correspond au cas où l'élément est trouvé au tout début ; il ne faut pas le confondre avec le cas où il n'est pas trouvé. index() renvoie, comme find(), la position trouvée : la première apparition de 'n' dans 'banana' se situe à l'indice 2, donc le résultat est 2. 3 correspondrait à compter les indices à partir de 1 en lisant « le 3e caractère », et 4 est la dernière position d'apparition, qu'on obtiendrait avec rfind() ou rindex(). La seule différence entre les deux méthodes concerne le cas où rien n'est trouvé : index() lève alors une ValueError: substring not found et arrête le traitement.

Dans une chaîne brute (raw), préfixée par r, une barre oblique inverse n'est pas interprétée comme le début d'une séquence d'échappement. r'a\nb' compte donc les 4 caractères a, barre oblique inverse, n, b, si bien que len vaut 4. En revanche, dans la chaîne normale 'a\nb', \n est remplacé par un unique caractère de saut de ligne, donnant les 3 caractères a, saut de ligne, b, avec len valant 3. Compter les deux comme des séquences d'échappement donnerait 3 3, et les compter tous les deux comme des caractères bruts donnerait 4 4, mais le point essentiel est que le traitement change selon la présence ou non du r. Même avec r, le type reste un str ordinaire, et ne devient pas un type spécial. Notons que len('\\') vaut 1, les deux barres obliques inverses étant doublées pour en écrire une seule.