Chapitre 10. Fonctions 10.8.
Exercices
Les écarts sur les statistiques entre les différentes listes sont-ils importants ? Relancez votre script avec des listes de
1000 éléments, puis 10 000 éléments. Les écarts changent-ils quand le nombre d’éléments par liste augmente ?
10.8.8 Distance à l’origine (exercice +++)
En reprenant votre fonction de calcul de distance euclidienne en trois dimensions calc_distance_3D(), faites-en
une version pour deux dimensions que vous appellerez calc_distance_2D().
Créez une autre fonction calc_dist2ori(), à laquelle vous passez en argument deux listes de floats list_x et
list_y représentant les coordonnées d’une fonction mathématique (par exemple x et sin(x)). Cette fonction renverra
une liste de floats représentant la distance entre chaque point de la fonction et l’origine (de coordonnées (0, 0)).
La figure 10.2 montre un exemple sur quelques points de la fonction sin(x) (courbe en trait épais). Chaque trait
pointillé représente la distance que l’on cherche à calculer entre les points de la courbe et l’origine du repère de coordonnées
(0, 0).
Figure 10.2 – Illustration de la distance à l’origine.
Votre programme générera un fichier [Link] qui contiendra deux colonnes : la première représente les x, la
seconde la distance entre chaque point de la fonction sin(x) à l’origine.
Enfin, pour visualiser votre résultat, ajoutez le code suivant tout à la fin de votre script :
100 Cours de Python / Université Paris Cité / UFR Sciences du Vivant
10.8. Exercices Chapitre 10. Fonctions
1 # Création d'une image pour la visualisation du résultat.
2 import [Link] as plt
3
4 x = []
5 y = []
6 with open("[Link]", "r") as f_in:
7 for line in f_in:
8 coords = [Link]()
9 [Link](float(coords[0]))
10 [Link](float(coords[1]))
11 fig, ax = [Link](figsize=(6, 6))
12 [Link](x, y)
13 ax.set_xlabel("x")
14 ax.set_ylabel("Distance de sin(x) à l'origine")
15 [Link]("[Link]")
Ouvrez l’image [Link].
Remarque
Le module matplotlib sera expliqué en détail dans le chapitre 21 Module matplotlib.
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 101
CHAPITRE 11
Plus sur les chaînes de caractères
11.1 Préambule
Nous avons déjà abordé les chaînes de caractères dans les chapitres 2 Variables et 3 Affichage. Ici nous allons un peu
plus loin, notamment avec les méthodes associées aux chaînes de caractères 1 .
11.2 Chaînes de caractères et listes
Les chaînes de caractères peuvent être considérées comme des listes (de caractères) un peu particulières :
1 >>> animaux = "girafe tigre"
2 >>> animaux
3 'girafe tigre'
4 >>> len(animaux)
5 12
6 >>> animaux[3]
7 'a'
Nous pouvons donc utiliser certaines propriétés des listes comme les tranches :
1 >>> animaux = "girafe tigre"
2 >>> animaux[0:4]
3 'gira'
4 >>> animaux[9:]
5 'gre'
6 >>> animaux[:-2]
7 'girafe tig'
8 >>> animaux[1:-2:2]
9 'iaetg'
Mais a contrario des listes, les chaînes de caractères présentent toutefois une différence notable, ce sont des listes
non modifiables. Une fois une chaîne de caractères définie, vous ne pouvez plus modifier un de ses éléments. Le cas
échéant, Python renvoie un message d’erreur :
1. [Link]
102
11.3. Caractères spéciaux Chapitre 11. Plus sur les chaînes de caractères
1 >>> animaux = "girafe tigre"
2 >>> animaux[4]
3 'f'
4 >>> animaux[4] = "F"
5 Traceback (most recent call last):
6 File "<stdin>", line 1, in <module>
7 TypeError: 'str' object does not support item assignment
Par conséquent, si vous voulez modifier une chaîne de caractères, vous devez en construire une nouvelle. Pour cela,
n’oubliez pas que les opérateurs de concaténation (+) et de duplication (*) (introduits dans le chapitre 2 Variables)
peuvent vous aider. Vous pouvez également générer une liste, qui elle est modifiable, puis revenir à une chaîne de
caractères (voir plus bas).
11.3 Caractères spéciaux
Il existe certains caractères spéciaux comme \n que nous avons déjà vu (pour le retour à la ligne). Le caractère \t
produit une tabulation. Si vous voulez écrire des guillemets simples ou doubles et que ceux-ci ne soient pas confondus
avec les guillemets de déclaration de la chaîne de caractères, vous pouvez utiliser \' ou \" :
1 >>> print("Un backslash n\npuis un backslash t\t puis un guillemet\"")
2 Un backslash n
3 puis un backslash t puis un guillemet"
4 >>> print('J\'affiche un guillemet simple')
5 J'affiche un guillemet simple
Vous pouvez aussi utiliser astucieusement des guillemets doubles ou simples pour déclarer votre chaîne de caractères :
1 >>> print("Un brin d'ADN")
2 Un brin d'ADN
3 >>> print('Python est un "super" langage de programmation')
4 Python est un "super" langage de programmation
Quand on souhaite écrire un texte sur plusieurs lignes, il est très commode d’utiliser les guillemets triples qui conservent
le formatage (notamment les retours à la ligne) :
1 >>> x = """souris
2 ... chat
3 ... abeille"""
4 >>> x
5 'souris\nchat\nabeille'
6 >>> print(x)
7 souris
8 chat
9 abeille
Attention, les caractères spéciaux n’apparaissent intérprétés que lorsqu’ils sont utilisés avec la fonction print(). Par
exemple, le \n n’apparait comme un retour à la ligne que lorsqu’il est dans une chaîne de caractères passée à la fonction
print() :
1 >>> "bla\nbla"
2 'bla\nbla'
3 >>> print("bla\nbla")
4 bla
5 bla
11.4 Préfixe de chaîne de caractères
Nous avons vu au chapitre 3 Affichage la notion de f-string. Il s’agit d’un mécanisme pour formater du texte au sein
d’une chaîne de caractères. Par exemple :
1 >>> var = "f-string"
2 >>> f"voici une belle {var}"
3 'voici une belle f-string'
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 103
Chapitre 11. Plus sur les chaînes de caractères 11.4. Préfixe de chaîne de caractères
Que signifie le f que l’on accole aux guillemets de la chaîne de caractères ? Celui-ci est appelé « préfixe de chaîne de
caractères » ou stringprefix.
Remarque
Un stringprefix modifie la manière dont Python va interpréter ladite string. Celui-ci doit être systématiquement «
collé » à la chaîne de caractères, c’est-à-dire sans espace entre les deux.
Il existe différents stringprefixes en Python, nous vous montrons ici les deux qui nous apparaissent les plus importants.
• Le préfixe r mis pour raw string, qui force la non-interprétation des caractères spéciaux :
1 >>> s = "Voici un retour à la ligne\nEt là une autre ligne"
2 >>> s
3 'Voici un retour à la ligne\nEt là une autre ligne'
4 >>> print(s)
5 Voici un retour à la ligne
6 Et là une autre ligne
7 >>> s = r"Voici un retour à la ligne\nEt là une autre ligne"
8 >>> s
9 'Voici un retour à la ligne\\nEt là une autre ligne'
10 >>> print(s)
11 Voici un retour à la ligne\nEt là une autre ligne
L’ajout du r va forcer Python à ne pas interpréter le \n comme un retour à la ligne, mais comme un backslash littéral
suivi d’un n. Quand on demande à l’interpréteur d’afficher cette chaîne de caractères, celui-ci met deux backslashes
pour signifier qu’il s’agit d’un backslash littéral (le premier échappe le second). Finalement, l’utilisation de la syntaxe
r"Voici un retour à la ligne\nEt là une autre ligne" renvoie une chaîne de caractères normale, puisqu’on
voit ensuite que le r a disparu lorsqu’on demande à Python d’afficher le contenu de la variable s. Comme dans var = 2
+ 2, d’abord Python évalue 2 + 2. Puis ce résultat est affecté à la variable var. Enfin, on notera que seule l’utilisation
du print() mène à l’interprétation des caractères spéciaux comme \n, comme expliqué dans la rubrique précédente.
Les caractères spéciaux non interprétés dans les raw strings sont de manière générale tout ce dont le backslash modifie
la signification, par exemple un \n, un \t, etc.
• Le préfixe f mis pour formatted string, qui met en place l’écriture formatée comme vue au chapitre 3 Affichage :
1 >>> animal = "renard"
2 >>> animal2 = "poulain"
3 >>> s = f"Le {animal} est un animal gentil\nLe {animal2} aussi"
4 >>> s
5 'Le renard est un animal gentil\nLe poulain aussi'
6 >>> print(s)
7 Le renard est un animal gentil
8 Le poulain aussi
9 >>> s = "Le {animal} est un animal gentil\nLe {animal2} aussi"
10 >>> s
11 'Le {animal} est un animal gentil\nLe {animal2} aussi'
12 >>> print(s)
13 Le {animal} est un animal gentil
14 Le {animal2} aussi
La f-string remplace le contenu des variables situées entre les accolades et interprète le \n comme un retour à la
ligne. Pour rappel, consultez le chapitre 3 si vous souhaitez plus de détails sur le fonctionnement des f-strings.
Conseil
Il existe de nombreux autres détails concernant les préfixes qui vont au-delà de ce cours. Pour en savoir plus, vous
pouvez consulter la documentations officielle 2 .
2. [Link]
104 Cours de Python / Université Paris Cité / UFR Sciences du Vivant
11.5. Méthodes associées aux chaînes de caractères Chapitre 11. Plus sur les chaînes de caractères
11.5 Méthodes associées aux chaînes de caractères
Voici quelques méthodes 3 spécifiques aux objets de type str :
1 >>> x = "girafe"
2 >>> [Link]()
3 'GIRAFE'
4 >>> x
5 'girafe'
6 >>> 'TIGRE'.lower()
7 'tigre'
Les méthodes .lower() et .upper() renvoient un texte en minuscule et en majuscule respectivement. On remarque
que l’utilisation de ces méthodes n’altère pas la chaîne de caractères de départ, mais renvoie une chaîne de caractères
transformée.
Pour mettre en majuscule la première lettre seulement, vous pouvez faire :
1 >>> x[0].upper() + x[1:]
2 'Girafe'
ou plus simplement utiliser la méthode adéquate :
1 >>> [Link]()
2 'Girafe'
Il existe une méthode associée aux chaînes de caractères qui est particulièrement pratique, la méthode .split() :
1 >>> animaux = "girafe tigre singe souris"
2 >>> [Link]()
3 ['girafe', 'tigre', 'singe', 'souris']
4 >>> for animal in [Link]():
5 ... print(animal)
6 ...
7 girafe
8 tigre
9 singe
10 souris
La méthode .split() découpe une chaîne de caractères en plusieurs éléments appelés champs, en utilisant comme
séparateur n’importe quelle combinaison « d’espace(s) blanc(s) ».
Définition
Un espace blanc 4 (whitespace en anglais) correspond aux caractères qui sont invisibles à l’œil, mais qui occupent de
l’espace dans un texte. Les espaces blancs les plus classiques sont l’espace, la tabulation et le retour à la ligne.
Il est possible de modifier le séparateur de champs, par exemple :
1 >>> animaux = "girafe:tigre:singe::souris"
2 >>> [Link](":")
3 ['girafe', 'tigre', 'singe', '', 'souris']
Attention, dans cet exemple, le séparateur est un seul caractères « : » (et non pas une combinaison de un ou plusieurs
:) conduisant ainsi à une chaîne vide entre singe et souris.
Il est également intéressant d’indiquer à .split() le nombre de fois qu’on souhaite découper la chaîne de caractères
avec l’argument maxsplit :
1 >>> animaux = "girafe tigre singe souris"
2 >>> [Link](maxsplit=1)
3 ['girafe', 'tigre singe souris']
4 >>> [Link](maxsplit=2)
5 ['girafe', 'tigre', 'singe souris']
3. [Link]
4. [Link]
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 105
Chapitre 11. Plus sur les chaînes de caractères 11.5. Méthodes associées aux chaînes de caractères
La méthode .find(), quant à elle, recherche une chaîne de caractères passée en argument :
1 >>> animal = "girafe"
2 >>> [Link]("i")
3 1
4 >>> [Link]("afe")
5 3
6 >>> [Link]("z")
7 -1
8 >>> [Link]("tig")
9 -1
Si l’élément recherché est trouvé, alors l’indice du début de l’élément dans la chaîne de caractères est renvoyé. Si
l’élément n’est pas trouvé, alors la valeur -1 est renvoyée.
Si l’élément recherché est trouvé plusieurs fois, seul l’indice de la première occurrence est renvoyé :
1 >>> animaux = "girafe tigre"
2 >>> [Link]("i")
3 1
On trouve aussi la méthode .replace() qui substitue une chaîne de caractères par une autre :
1 >>> animaux = "girafe tigre"
2 >>> [Link]("tigre", "singe")
3 'girafe singe'
4 >>> [Link]("i", "o")
5 'gorafe togre'
La méthode .count() compte le nombre d’occurrences d’une chaîne de caractères passée en argument :
1 >>> animaux = "girafe tigre"
2 >>> [Link]("i")
3 2
4 >>> [Link]("z")
5 0
6 >>> [Link]("tigre")
7 1
La méthode .startswith() vérifie si une chaîne de caractères commence par une autre chaîne de caractères :
1 >>> chaine = "Bonjour monsieur le capitaine !"
2 >>> [Link]("Bonjour")
3 True
4 >>> [Link]("Au revoir")
5 False
Cette méthode est particulièrement utile lorsqu’on lit un fichier et que l’on veut récupérer certaines lignes commençant
par un mot-clé. Par exemple dans un fichier PDB, les lignes contenant les coordonnées des atomes commencent par le
mot-clé ATOM.
Enfin, la méthode .strip() permet de « nettoyer les bords » d’une chaîne de caractères :
1 >>> chaine = " Comment enlever les espaces au début et à la fin ? "
2 >>> [Link]()
3 'Comment enlever les espaces au début et à la fin ?'
La méthode .strip() enlève les espaces situés sur les bords de la chaîne de caractère mais pas ceux situés entre des
caractères visibles. En réalité, cette méthode enlève n’importe quel combinaison « d’espace(s) blanc(s) » sur les bords,
par exemple :
1 >>> chaine = " \tfonctionne avec les tabulations et les retours à la ligne\n"
2 >>> [Link]()
3 'fonctionne avec les tabulations et les retours à la ligne'
Cette méthode est utile pour se débarrasser des retours à la ligne quand on lit un fichier.
106 Cours de Python / Université Paris Cité / UFR Sciences du Vivant
11.6. Extraction de valeurs numériques d’une chaîne de caractères Chapitre 11. Plus sur les chaînes de caractères
11.6 Extraction de valeurs numériques d’une chaîne de caractères
Une tâche courante en Python est de lire une chaîne de caractères (provenant par exemple d’un fichier), d’en extraire
des valeurs pour ensuite les manipuler.
On considère par exemple la chaîne de caractères chaine1 :
1 >>> chaine1 = "3.4 17.2 atom"
On souhaite extraire les valeurs 3.4 et 17.2 pour ensuite les additionner.
D’abord, on découpe la chaîne de caractères avec la méthode .split() :
1 >>> liste1 = [Link]()
2 >>> liste1
3 ['3.4', '17.2', 'atom']
4 >>> nb1, nb2, nom = liste1
5 >>> nb1
6 '3.4'
7 >>> nb2
8 '17.2'
On obtient alors une liste de chaînes de caractères liste1. Avec l’affectation multiple, on récupère les nombres
souhaités dans nb1 et nb2, mais ils sont toujours sous forme de chaîne de caractères. Il faut ensuite les convertir en floats
pour pouvoir les additionner :
1 >>> float(nb1) + float(nb2)
2 20.599999999999998
Remarque
Retenez bien l’utilisation des instructions précédentes pour extraire des valeurs numériques d’une chaîne de caractères.
Elles sont régulièrement employées pour analyser des données extraites d’un fichier.
11.7 Fonction map()
Conseil
Si vous êtes débutant, vous pouvez sauter cette rubrique.
La fonction map() permet d’appliquer une fonction à plusieurs éléments d’un objet itérable. Par exemple, si on a une
chaîne de caractères avec trois entiers séparés par des espaces, on peut extraire et convertir les trois nombres en entier
en une seule ligne. La fonction map() produit un objet de type map qui est itérable et transformable en liste :
1 >>> ligne = "67 946 -45"
2 >>> [Link]()
3 ['67', '946', '-45']
4 >>> map(int, [Link]())
5 <map object at 0x7fa34e573b20>
6 >>> for entier in map(int, [Link]()):
7 ... print(entier)
8 ...
9 67
10 946
11 -45
12 >>> list(map(int, [Link]()))
13 [67, 946, -45]
Remarque
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 107
Chapitre 11. Plus sur les chaînes de caractères 11.8. Test d’appartenance
La fonction map() prend deux arguments. Le second est un objet itérable, souvent une liste comme dans notre
exemple. Le premier argument est le nom d’une fonction qu’on souhaite appliquer à chaque élément de la liste, mais sans
les parenthèses (ici int et non pas int()). Une fonction passée en argument d’une autre fonction est appelée fonction
de rappel 5 ou callback en anglais. Nous reverrons cette notion dans le chapitre 25 Fenêtres graphiques et Tkinter (en
ligne).
La fonction map() est particulièrement utile lorsqu’on lit un fichier de valeurs numériques. Par exemple, si on a un
fichier [Link] contenant trois colonnes de nombres, map() en conjonction avec .split() permet de séparer les trois
nombres puis de les convertir en float en une seule ligne de code :
1 with open("[Link]", "r") as filin:
2 for line in filin:
3 x, y, z = map(float, [Link]())
4 print(x + y + z)
Sans map(), il aurait fallu une ligne pour séparer les données x, y, z = [Link]() et une autre pour les
transformer en float x, y, z = float(x), float(y), float(z).
Enfin, on peut utiliser map() avec ses propres fonctions :
1 >>> def calc_cube(x):
2 ... return x**3
3 ...
4 >>> list(map(calc_cube, [1, 2, 3, 4]))
5 [1, 8, 27, 64]
11.8 Test d’appartenance
L’opérateur in teste si une chaîne de caractères fait partie d’une autre chaîne de caractères :
1 >>> chaine = "Néfertiti"
2 >>> "toto" in chaine
3 False
4 >>> "titi" in chaine
5 True
6 >>> "ti" in chaine
7 True
Notez que la chaîne testée peut-être présente à n’importe quelle position dans l’autre chaîne. Par ailleurs, le test est
vrai si elle est présente une ou plusieurs fois.
La variation avec l’opérateur booléen not permet de vérifier qu’une chaîne n’est pas présente dans une autre chaîne :
1 >>> not "toto" in chaine
2 True
3 >>> not "fer" in chaine
4 False
11.9 Conversion d’une liste de chaînes de caractères en une chaîne de ca-
ractères
On a vu dans le chapitre 2 Variables la conversion d’un type simple (entier, float et chaîne de caractères) en un
autre avec les fonctions int(), float() et str(). La conversion d’une liste de chaînes de caractères en une chaîne de
caractères est moins intuitive. Elle fait appelle à la méthode .join() :
5. [Link]
108 Cours de Python / Université Paris Cité / UFR Sciences du Vivant
11.10. Method chaining Chapitre 11. Plus sur les chaînes de caractères
1 >>> seq = ["A", "T", "G", "A", "T"]
2 >>> seq
3 ['A', 'T', 'G', 'A', 'T']
4 >>> "-".join(seq)
5 'A-T-G-A-T'
6 >>> " ".join(seq)
7 'A T G A T'
8 >>> "".join(seq)
9 'ATGAT'
Les éléments de la liste initiale sont concaténés les uns à la suite des autres et intercalés par un séparateur, qui peut
être n’importe quelle chaîne de caractères. Ici, on a utilisé un tiret, un espace et rien (une chaîne de caractères vide).
Attention, la méthode .join() ne s’applique qu’à une liste de chaînes de caractères :
1 >>> maliste = ["A", 5, "G"]
2 >>> " ".join(maliste)
3 Traceback (most recent call last):
4 File "<stdin>", line 1, in <module>
5 TypeError: sequence item 1: expected str instance, int found
On espère qu’après ce petit tour d’horizon vous serez convaincu de la richesse des méthodes associées aux chaînes de
caractères. Pour avoir une liste exhaustive de l’ensemble des méthodes associées à une variable particulière, vous pouvez
utiliser la fonction dir() :
1 >>> animaux = "girafe tigre"
2 >>> dir(animaux)
3 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__',
4 ...,
5 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
6 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip',
7 'swapcase', 'title', 'translate', 'upper', 'zfill']
Pour l’instant, vous pouvez ignorer les méthodes qui commencent et qui se terminent par deux tirets bas (underscores)
__. Nous n’avons pas mis l’ensemble de la sortie de cette commande dir() pour ne pas surcharger le texte, mais n’hésitez
pas à la tester dans l’interpréteur.
Vous pouvez également accéder à l’aide et à la documentation d’une méthode particulière avec help(), par exemple
pour la méthode .split() :
>>> help([Link])
Help on built-in function split:
split(...)
[Link]([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator.
(END)
Attention à ne pas mettre les parenthèses à la suite du nom de la méthode. L’instruction correcte est help(animaux
.split) et non pas help([Link]()).
11.10 Method chaining
Il existe de nombreuses méthodes pour traiter les chaînes de caractères. Ces méthodes renvoient la plupart du temps
une chaîne de caractères modifiée.
Par exemple, si on souhaite mettre une majuscule à tous les mots d’une chaîne de caractères, puis remplacer un mot
par un autre, puis transformer cette chaîne de caractères en une liste de chaînes de caractères, on peut écrire :
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 109
Chapitre 11. Plus sur les chaînes de caractères 11.11. Exercices
1 >>> message = "salut patrick salut pierre"
2 >>> message1 = [Link]()
3 >>> message1
4 'Salut Patrick Salut Pierre'
5 >>> message2 = [Link]("Salut", "Bonjour")
6 >>> message2
7 'Bonjour Patrick Bonjour Pierre'
8 >>> [Link]()
9 ['Bonjour', 'Patrick', 'Bonjour', 'Pierre']
On a créé deux variables intermédiaires message1 et message2 pour stocker les chaînes de caractères modifiées par
les méthodes .title() et .replace().
Il est possible de faire la même chose en une seule ligne, en utilisant le chaînage de méthodes ou method chaining :
1 >>> message = "salut patrick salut pierre"
2 >>> [Link]().replace("Salut", "Bonjour").split()
3 ['Bonjour', 'Patrick', 'Bonjour', 'Pierre']
On évite ainsi de créer des variables intermédiaires.
Le method chaining peut créer des lignes de code très longues. On peut couper une ligne de code en plusieurs lignes
en utilisant le caractère \ en fin de ligne :
1 >>> message = "salut patrick salut pierre"
2 >>> [Link]() \
3 ... .replace("Salut", "Bonjour") \
4 ... .title()
5 'Bonjour Patrick Bonjour Pierre'
On peut aussi utiliser des parenthèses pour couper une ligne de code en plusieurs lignes :
1 >>> message = "salut patrick salut pierre"
2 >>> (message
3 ... .title()
4 ... .replace("Salut", "Bonjour")
5 ... .split()
6 ... )
7 ['Bonjour', 'Patrick', 'Bonjour', 'Pierre']
L’utilisation de parenthèses permet aussi de couper une chaîne de caractères en plusieurs lignes :
1 >>> ma_chaine = (
2 ... "voici une chaine de caractères "
3 ... "très longue "
4 ... "sur plusieurs lignes")
5 >>> ma_chaine
6 'voici une chaine de caractères très longue sur plusieurs lignes'
Nous reverrons le method chaining dans le chapitre 22 Module Pandas.
11.11 Exercices
Conseil
Pour ces exercices, créez des scripts puis exécutez-les dans un shell.
11.11.1 Parcours d’une liste de chaînes de caractères
Soit la liste ['girafe', 'tigre', 'singe', 'souris']. Avec une boucle, affichez chaque élément ainsi que sa
taille (nombre de caractères).
110 Cours de Python / Université Paris Cité / UFR Sciences du Vivant