Python, de zéro

Les types tuple et list disposent de méthodes spécifiques. Voici une liste non exhaustive des méthodes couramment utilisées :

• tuple.count(x)/ list.count(x) : renvoie le nombre d’éléments ayant la valeur x dans le tuple/liste ;

• tuple.index(x)/ list.index(x) : renvoie la position du premier élément du tuple/liste ayant la valeur x. Cette valeur doit être présente dans le tuple/liste sinon ça remonte une exception ValueError.

Le type list dispose de méthodes spécifiques supplémentaires dédiées à la modification. Voici une liste non exhaustive des méthodes couramment utilisées :

• list.append(x) : ajoute l'élément x à la fin de la liste ;

• list.clear() : vide totalement la liste (n'existe pas sous Python 2) ;

• list.copy() : renvoie une copie de la liste. Cette copie ne duplique réellement que les éléments de premier niveau de la liste (ne fonctionnera pas par exemple pour une liste de listes). N'existe pas sous Python 2 ;

• list.extend(itérable) : étend la liste en y ajoutant tous les éléments de l’itérable.

• list.insert(i, x) : insère l'élément x à la position i. Si la position dépasse le nombre d'éléments, l'insertion se fait alors à la fin de la liste. Ainsi, list.insert(0, x) insère l’élément en tête de la liste ; et list.insert(len(list), x) est équivalent à list.append(x) ;

• list.pop(i=‑1) : renvoie l’élément situé à la position i (par défaut la dernière de la liste) tout en le supprimant de la liste. Si la liste est vide, ça remonte une exception IndexError ;

• list.remove(x) : supprime de la liste le premier élément dont la valeur est x. Cette valeur doit être présente dans la liste sinon ça remonte une exception ValueError ;

• list.reverse() : inverse sur place l’ordre des éléments de la liste ;

• list.sort(key=None, reverse=False) : trie sur place les éléments de la liste. La façon de trier est paramétrée par les éléments key et reverse. À noter la présence sous Python 2 d'un argument supplémentaire cmp qui permet d'y placer une fonction de comparaison d'éléments. Cet argument a disparu dans Python 3, mais son comportement peut toutefois être reproduit au travers d'un objet transformant la fonction en clef et passé ensuite à l'argument key (sera vu ultérieurement).

Le type set dispose de méthodes spécifiques. Voici une liste non exhaustive des méthodes couramment utilisées :

• set.add(x) : ajoute l'élément x à l’ensemble à condition qu’il n’y soit pas déjà (sinon pas d’effet) ;

• set.clear() : vide totalement l'ensemble ;

• set.copy() : renvoie une copie de l'ensemble. Cette copie ne duplique réellement que les éléments de premier niveau de l'ensemble (ne fonctionnera pas par exemple pour un ensemble d'ensembles) ;

• set.discard(x) : supprime de l’ensemble l’élément de valeur x si celui‑ci est présent (sinon pas d’effet) ;

• set.pop() : renvoie un élément pris au hasard dans l’ensemble tout en le supprimant de l’ensemble. Si l'ensemble est vide, ça remonte une exception KeyError ;

• set.remove(x) : supprime de l’ensemble l’élément de valeur x. Cette valeur doit être présente dans l'ensemble sinon ça remonte une exception KeyError ;

• set.update(itérable) : étend l’ensemble en y ajoutant tous les éléments de l’itérable qui n’y sont pas déjà.

XVI-3-a. Pour les deux versions de Python▲

XVI-3-b. Spécificités Python 2▲

Le type str dispose de méthodes spécifiques. Voici une liste non exhaustive des méthodes couramment utilisées :

• str.capitalize() : renvoie une copie de la chaîne avec son premier caractère mis en majuscule ;

• str.casefold() : renvoie une copie de la chaîne convertie en minuscules permettant une comparaison sans prendre en compte sa casse ;

• str.center(w, c=' ') : renvoie une copie de la chaîne centrée sur w positions remplies avec le caractère c ;

• str.count(x) : retourne le nombre d’éléments ayant la valeur x dans la chaîne ;

• str.encode(c) : renvoie une copie de la chaîne encodée dans le codec c ;

• str.endswith(x) : retourne un booléen indiquant si la chaîne se termine par x ;

• str.expandtabs(w) : renvoie une copie de la chaîne dans laquelle chaque tabulation est remplacée par w espaces ;

• str.find(x) : renvoie la position du x présent dans la chaîne (ou renvoie ‑1 s’il x n’y est pas) ;

• str.format(**d) : renvoie une copie de la chaîne en y incluant des variables ou expressions placées dans le dictionnaire d ;

• str.format_map(**d) : identique à str.format(**d) excepté que dans la précédente méthode, la variable d est copiée dans le format (création d’une nouvelle instance) tandis que dans ce cas elle est directement utilisée ;

• str.index(x) : identique à str.find(x) excepté que si le x n’y est pas, ça remonte une exception ValueError ;

• str.isalnum() : retourne un booléen indiquant si la chaîne ne contient que des caractères alphanumériques ;

• str.isalpha() : retourne un booléen indiquant si la chaîne ne contient que des caractères alphabétiques ;

• str.isascii() : retourne un booléen indiquant si la chaîne ne contient que des caractères ASCII ;

• str.isdecimal() : retourne un booléen indiquant si la chaîne ne contient que des caractères permettant de former des nombres décimaux.

• str.isdigit() : retourne un booléen indiquant si la chaîne ne contient que des caractères permettant de créer des nombres en plus des nombres décimaux (ex nombres de Kharosthi) ;

• str.isidentifier() : retourne un booléen indiquant si la chaîne est un identificateur ou un mot‑clef Python ;

• str.islower() : retourne un booléen indiquant si la chaîne ne contient que des caractères minuscules ;

• str.isnumeric() : retourne un booléen indiquant si la chaîne ne contient que des caractères numériques ;

• str.isprintable() : retourne un booléen indiquant si la chaîne ne contient que des caractères affichables sur un écran ;

• str.isspace() : retourne un booléen indiquant si la chaîne ne contient que des caractères de type « espace » (espace, tabulation, etc.) ;

• str.istitle() : retourne un booléen indiquant si la chaîne est assimilable à un titre (premier caractère de chaque mot en majuscule) ;

• str.isupper() : retourne un booléen indiquant si la chaîne ne contient que des caractères majuscules ;

• str.join(iter) : renvoie une nouvelle chaîne contenant la chaîne appelante placée entre chaque élément de l’itérable iter ;

• str.ljust(w, c=' ') : renvoie une copie de la chaîne justifiée à gauche sur w positions remplies avec le caractère c ;

• str.lower() : renvoie une copie de la chaîne convertie en minuscules ;

• str.lstrip() : renvoie une copie de la chaîne dont les espaces et autres caractères inutiles de gauche ont été supprimés ;

• str.maketrans(x) : renvoie une table de translation (un dictionnaire) basée sur x qui servira ensuite à str.translate() ;

• str.partition(c) : renvoie un tuple de 3 éléments contenant la partie de chaîne placée avant le premier c, l’élément c et la partie de chaîne placée après ce c ;

• str.replace(x, y) : renvoie une copie de la chaîne dans laquelle tout caractère x a été remplacé par y ;

• str.rfind(x) : identique à str.find() sauf que la recherche se fait à partir de la fin et en remontant vers le début ;

• str.rindex(x) : identique à str.index() sauf que la recherche se fait à partir de la fin et en remontant vers le début ;

• str.rjust(w, c=' ') : renvoie une copie de la chaîne justifiée à droite sur w positions remplies avec le caractère c ;

• str.rpartition(x) : identique à str.partition() sauf que la recherche du c se fait à partir de la fin et en remontant vers le début ;

• str.rstrip() : renvoie une copie de la chaîne dont les espaces et autres caractères inutiles de droite ont été supprimés ;

• str.split(c=' ') : renvoie une liste contenant la chaîne découpée sur chaque élément c ;

• str.splitlines(keepends=False) : renvoie une liste contenant la chaîne découpée sur chaque fin de ligne (\n), la fin de ligne sera incluse si le paramètre keepends est mis à True ;

• str.startswith(x) : retourne un booléen indiquant si la chaîne commence par x ;

• str.strip() : combine les effets de str.lstrip() et str.rstrip() ;

• str.swapcase() : renvoie une copie de la chaîne dans laquelle chaque minuscule est devenue une majuscule et inversement ;

• str.title() : renvoie une copie de la chaîne dans laquelle chaque mot a son premier caractère mis en majuscule ;

• str.translate(d) : renvoie une copie de la chaîne dans laquelle chaque clef du dictionnaire d a été remplacée par sa valeur associée. Le dictionnaire peut être créé manuellement ou bien provenir de str.maketrans() ;

• str.upper() : renvoie une copie de la chaîne convertie en majuscules.

Python possède aussi des fonctions spécifiques dédiées à la manipulation de chaînes, tuples, listes, ensembles et dictionnaires (pour ces derniers, les manipulations s’appliquent aux clefs) :

• all(iterable) : retourne True si tous les éléments de iterable sont considérés comme « vrai ». Cette instruction fonctionne à l’économie (elle s’arrête dès qu’une certitude est acquise donc au premier élément qui n’est plus « vrai ») ;

• any(iterable) : retourne True si un des éléments de iterable est considéré comme « vrai ». Cette instruction fonctionne à l’économie (elle s’arrête dès qu’une certitude est acquise donc au premier élément qui est « vrai ») ;

• filter(fonction, iterable) : renvoie une nouvelle liste contenant seulement les éléments de iterable pour lesquels la fonction fonction renvoie True ou toute expression considérée comme « vraie ». La fonction fonction doit être prévue pour n’accepter qu’un seul argument, mais peut être mise à None. Dans ce dernier cas, la nouvelle liste contiendra alors les éléments de l’itérable considérés nativement comme True ;

• map(fonction, iterable, …) : retourne un générateur contenant chaque élément de iterable après l’avoir fait traiter par la fonction fonction. Il peut traiter plusieurs itérables en parallèle ; la fonction fonction devant alors être prévue pour accepter autant de paramètres qu’il y a d’itérables demandés. Les éléments des itérables sont ensuite récupérés parallèlement les uns avec les autres (ou None pour les itérables n’ayant pas assez d’éléments par rapport aux autres) ;

• min(iterable, default=objet, key=None) / max(iterable, default=objet, key=None) : renvoie le plus petit/plus grand élément de iterable selon l’action de la clef demandée dans key (action qui doit être une fonction n’acceptant qu’un paramètre présumé être un élément de la liste), fonction associée à chaque élément de l’itérable si ce paramètre est demandé ou selon la valeur numérique de chaque élément sinon. Si l’itérable est vide, retourne alors l’objet mis dans default ou une exception ValueError si ce paramètre n’a pas été invoqué ;

• reduce(fonction, iterable, initializer=None) : applique la fonction fonction à chacun des éléments de iterable pris comme second argument en utilisant le résultat de l’élément précédent (ou par défaut initializer pour le premier élément qui, lui, ne bénéficie pas de résultat précédent) comme premier argument. Renvoie le résultat du traitement du dernier élément de l’itérable. La fonction fonction doit être prévue pour n’accepter que deux arguments. Cette méthode était naturellement présente dans Python 2. Elle doit être maintenant importée du module functools pour être disponible dans Python 3 ;

• sorted(iterable, key=None, reverse=False) : renvoie une liste croissante ou décroissante selon la valeur de reverse et contenant iterable trié selon l’action de la clef demandée dans key (action qui doit être une fonction n’acceptant qu’un paramètre présumé être un élément de la liste), fonction associée à chaque élément de l’itérable si ce paramètre est demandé ou selon la valeur numérique de chaque élément sinon ;

• sum(iterable, start=0) : retourne la somme des éléments de iterable (ces éléments étant tous censés pouvoir s’additionner) en initialisant cette somme à la valeur start ;

• zip(iterable, …) : retourne un objet zip (objet assimilable à une liste) contenant tous les éléments de chaque iterable récupérés en parallèle et accolés. Si les divers itérables n’ont pas le même nombre d’éléments, l’ensemble s’adapte à l’itérable le plus petit.

Quand on itère sur une séquence modifiable (liste, ensemble), il est très dangereux de modifier ladite séquence dans le corps de la boucle qui l’itère parce que Python réévalue la séquence à chaque itération. Exemple :

>>> tab=[1,]
>>> for x in tab:
...    print(x)
...    tab.append(x+1)
...
1
2
3
…(à l’infini)…

Dans le cas d’un ajout, si l’utilisateur a besoin d’ajouter des éléments sur la séquence durant l’exécution de la boucle qui l'itère, il doit alors utiliser une copie de la séquence lors de son évaluation par la boucle. Différentes syntaxes peuvent être utilisées comme une copie à chaud…

>>tab=[1, 2, 3, 4, 5]
>>> for x in tuple(tab):            # La boucle itèrera sur un tuple mémoire créé depuis tab
...    print(x)
...    tab.append(x+1)
...
1
2
3
4
5
>>> print(tab)
[1, 2, 3, 4, 5, 2, 3, 4, 5, 6]

… ou un slice qui lui aussi renvoie une copie de l’élément originel.

>>tab=[1, 2, 3, 4, 5]
>>> for x in tab[:]:                # La boucle itèrera sur un slice mémoire créé depuis tab
...    print(x)
...    tab.append(x+1)
...
1
2
3
4
5
>>> print(tab)
[1, 2, 3, 4, 5, 2, 3, 4, 5, 6]

Dans le cas d’une suppression, c’est encore plus subtil, car la suppression de l’élément i décale alors immédiatement la position de tous les éléments qui suivent (la suppression de l’élément [3] décale alors l’élément [4] qui devient [3] etc). Et la combinaison de l’itération qui passe à l’élément suivant à chaque tour pendant que l’élément suivant est décalé vers le précédent à chaque suppression provoque alors la perte d’un élément sur deux.

Exemple de ce qui se passe si on tente de supprimer naïvement les éléments pairs d’un tableau contenant les 10 premiers entiers…

>>> tab=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> for i in range(len(tab)):
...    print("i=%d, tab=%d" % (i, tab[i]))             # Pour montrer l’élément en cours
...    if (tab[i] % 2) == 0: del tab[i]                # Ça semble correspondre à la demande
...
i=0, tab=1
i=1, tab=2
i=2, tab=4
i=3, tab=6
i=4, tab=8
i=5, tab=10
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
IndexError: list index out of range
>>>

Comme on le voit, la suppression de l’élément pair décale vers la gauche l’élément impair qui le suit (et tout le reste du tableau par ricochet). Mais comme l’indice se décale lui vers la droite en même temps, non seulement on ne traite pas les éléments impairs (sinon on les verrait lors du print()), mais en plus l’indice finit par dépasser la taille du tableau qui décroit et par provoquer une exception.

Une première solution pourra être basée sur un indice qui évolue ou pas selon le cas…

>>> tab=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> i=0
>>> while i<len(tab):
...    if (tab[i]%2) == 0: del tab[i]
...    else: i+=1
...
>>> print(tab)
[1, 3, 5, 7, 9]

Une seconde solution plus simple sera de traiter la liste à l’envers (l’indice remontant vers 0 plus vite que ce que le tableau diminue)…

>>> tab=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> for i in range(len(tab)-1, -1, -1):
...    if (tab[i]%2) == 0: del tab[i]
...
>>> print(tab)
[1, 3, 5, 7, 9]

Sinon, on pourra se tourner en troisième recours vers une création à chaud de la liste attendue à partir d’une liste en intension basée sur la liste initiale…

>>> tab=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> tab=[x for x in tab if (x%2) != 0]
>>> print(tab)
[1, 3, 5, 7, 9]