3.5. Exercices Chapitre 3.

Affichage

3.5.2 Poly-A
Générez une chaîne de caractères représentant un brin d’ADN poly-A (c’est-à-dire qui ne contient que des bases A)
de 20 bases de longueur, sans taper littéralement toutes les bases.

3.5.3 Poly-A et poly-GC

Sur le modèle de l’exercice précédent, générez en une ligne de code un brin d’ADN poly-A (AAAA…) de 20 bases
suivi d’un poly-GC régulier (GCGCGC…) de 40 bases.

3.5.4 Écriture formatée

En utilisant l’écriture formatée, affichez en une seule ligne les variables a, b et c dont les valeurs sont respectivement
la chaîne de caractères "salut", le nombre entier 102 et le float 10.318. La variable c sera affichée avec deux décimales.

3.5.5 Écriture formatée 2

Dans un script percGC.py, calculez un pourcentage de GC avec l’instruction suivante :
perc_GC = ((4500 + 2575)/14800)*100
Ensuite, affichez le contenu de la variable perc_GC à l’écran avec 0, 1, 2 puis 3 décimales sous forme arrondie en
utilisant l’écriture formatée et les f-strings. On souhaite que le programme affiche la sortie suivante :
Le pourcentage de GC est 48 %
Le pourcentage de GC est 47.8 %
Le pourcentage de GC est 47.80 %
Le pourcentage de GC est 47.804 %

3.5.6 Décomposition de fractions

Utilisez l’opérateur modulo (%) et l’opérateur division entière (//) pour simplifier des fractions, connaissant leur
numérateur et leur dénominateur, et afficher le résultat avec des f-strings.
Par exemple pour la fraction 37 , le numérateur vaut 7 et le dénominateur vaut 3, et le résultat s’affichera sous la
forme :
7/3 = 2 + 1/3

Ici, 2 est le résultat de la division entière du numérateur par le dénominateur et 1 est le reste de la division entière du
numérateur par le dénominateur.
Faites de même pour les fractions suivantes :

9 23 21 7
, , et
4 5 8 2

Cours de Python / Université Paris Cité / UFR Sciences du Vivant 31

 CHAPITRE 4

Listes

4.1 Définition

Définition
Une liste est une structure de données qui contient une collection d’objets Python. Il s’agit d’un nouveau type par
rapport aux entiers, float, booléens et chaînes de caractères que nous avons vus jusqu’à maintenant. On parle aussi
d’objet séquentiel en ce sens qu’il contient une séquence d’autres objets.

Python autorise la construction de liste contenant des valeurs de types différents (par exemple entier et chaîne de
caractères), ce qui leur confère une grande flexibilité. Une liste est déclarée par une série de valeurs (n’oubliez pas les
guillemets, simples ou doubles, s’il s’agit de chaînes de caractères) séparées par des virgules, et le tout encadré par des
crochets. En voici quelques exemples :
1 >>> animaux = ["girafe", "tigre", "singe", "souris"]
2 >>> tailles = [5, 2.5, 1.75, 0.15]
3 >>> mixte = ["girafe", 5, "souris", 0.15]
4 >>> animaux
5 ['girafe', 'tigre', 'singe', 'souris']
6 >>> tailles
7 [5, 2.5, 1.75, 0.15]
8 >>> mixte
9 ['girafe', 5, 'souris', 0.15]

Lorsque l’on affiche une liste, Python la restitue telle qu’elle a été saisie.

4.2 Utilisation
Un des gros avantages d’une liste est que vous accédez à ses éléments par leur position. Ce numéro est appelé indice
(ou index) de la liste.
liste : ["girafe", "tigre", "singe", "souris"]
indice : 0 1 2 3

Soyez très attentif au fait que les indices d’une liste de n éléments commencent à 0 et se terminent à n − 1. Voyez
l’exemple suivant :

32
4.3. Opération sur les listes Chapitre 4. Listes

1 >>> animaux = ["girafe", "tigre", "singe", "souris"]

2 >>> animaux[0]
3 'girafe'
4 >>> animaux[1]
5 'tigre'
6 >>> animaux[3]
7 'souris'

Par conséquent, si on appelle l’élément d’indice 4 de notre liste, Python renverra un message d’erreur :
1 >>> animaux[4]
2 Traceback (innermost last):
3 File "<stdin>", line 1, in ?
4 IndexError: list index out of range

N’oubliez pas ceci ou vous risquez d’obtenir des bugs inattendus !

4.3 Opération sur les listes

Tout comme les chaînes de caractères, les listes supportent l’opérateur + de concaténation, ainsi que l’opérateur *
pour la duplication :
1 >>> ani1 = ["girafe", "tigre"]
2 >>> ani2 = ["singe", "souris"]
3 >>> ani1 + ani2
4 ['girafe', 'tigre', 'singe', 'souris']
5 >>> ani1 * 3
6 ['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']

L’opérateur + est très pratique pour concaténer deux listes.

Vous pouvez aussi utiliser la méthode .append() lorsque vous souhaitez ajouter un seul élément à la fin d’une liste.

Remarque
La notion de méthode est introduite dans la rubrique Note sur le vocabulaire et la syntaxe à la fin de ce chapitre.

Dans l’exemple suivant, nous allons créer une liste vide :

1 >>> liste1 = []
2 >>> liste1
3 []

puis lui ajouter deux éléments, l’un après l’autre, d’abord avec la concaténation :
1 >>> liste1 = liste1 + [15]
2 >>> liste1
3 [15]
4 >>> liste1 = liste1 + [-5]
5 >>> liste1
6 [15, -5]

puis avec la méthode .append() :

1 >>> liste1.append(13)
2 >>> liste1
3 [15, -5, 13]
4 >>> liste1.append(-3)
5 >>> liste1
6 [15, -5, 13, -3]

Dans cet exemple, nous ajoutons des éléments à une liste en utilisant l’opérateur de concaténation + ou la méthode
.append().

Conseil

Cours de Python / Université Paris Cité / UFR Sciences du Vivant 33

Chapitre 4. Listes 4.4. Indiçage négatif

Nous vous conseillons dans ce cas précis d’utiliser la méthode .append(), dont la syntaxe est plus élégante.

Nous reverrons en détail la méthode .append() dans le chapitre 12 Plus sur les listes.

4.4 Indiçage négatif

La liste peut également être indexée avec des nombres négatifs selon le modèle suivant :
liste : ["girafe", "tigre", "singe", "souris"]
indice positif : 0 1 2 3
indice négatif : -4 -3 -2 -1

ou encore :
liste : ["A", "B", "C", "D", "E", "F"]
indice positif : 0 1 2 3 4 5
indice négatif : -6 -5 -4 -3 -2 -1

Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage est que vous pouvez accéder au
dernier élément d’une liste à l’aide de l’indice -1 sans pour autant connaître la longueur de cette liste. L’avant-dernier
élément a lui l’indice -2, l’avant-avant dernier l’indice -3, etc. :
1 >>> animaux = ["girafe", "tigre", "singe", "souris"]
2 >>> animaux[-1]
3 'souris'
4 >>> animaux[-2]
5 'singe'

Pour accéder au premier élément de la liste avec un indice négatif, il faut par contre connaître le bon indice :
1 >>> animaux[-4]
2 'girafe'

Dans ce cas, on utilise plutôt animaux[0].

4.5 Tranches
Un autre avantage des listes est la possibilité de sélectionner une partie d’une liste en utilisant un indiçage construit
sur le modèle [m:n+1] pour récupérer tous les éléments, du émième au énième (de l’élément m inclu à l’élément n+1
exclu). On dit alors qu’on récupère une tranche de la liste, par exemple :
1 >>> animaux = ["girafe", "tigre", "singe", "souris"]
2 >>> animaux[0:2]
3 ['girafe', 'tigre']
4 >>> animaux[0:3]
5 ['girafe', 'tigre', 'singe']
6 >>> animaux[0:]
7 ['girafe', 'tigre', 'singe', 'souris']
8 >>> animaux[:]
9 ['girafe', 'tigre', 'singe', 'souris']
10 >>> animaux[1:]
11 ['tigre', 'singe', 'souris']
12 >>> animaux[1:-1]
13 ['tigre', 'singe']

Notez que lorsqu’aucun indice n’est indiqué à gauche ou à droite du symbole deux-points :, Python prend par défaut
tous les éléments depuis le début ou tous les éléments jusqu’à la fin respectivement.
On peut aussi préciser le pas en ajoutant un symbole deux-points supplémentaire et en indiquant le pas par un entier :

34 Cours de Python / Université Paris Cité / UFR Sciences du Vivant

4.6. Fonction len() Chapitre 4. Listes

1 >>> animaux = ["girafe", "tigre", "singe", "souris"]

2 >>> animaux[0:3:2]
3 ['girafe', 'singe']
4 >>> x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5 >>> x
6 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
7 >>> x[::1]
8 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
9 >>> x[::2]
10 [0, 2, 4, 6, 8]
11 >>> x[::3]
12 [0, 3, 6, 9]
13 >>> x[1:6:3]
14 [1, 4]

Finalement, on se rend compte que l’accès au contenu d’une liste fonctionne sur le modèle liste[début:fin:pas].

4.6 Fonction len()

L’instruction len() vous permet de connaître la longueur d’une liste, c’est-à-dire le nombre d’éléments que contient
la liste. Voici un exemple d’utilisation :
1 >>> animaux = ["girafe", "tigre", "singe", "souris"]
2 >>> len(animaux)
3 4
4 >>> len([1, 2, 3, 4, 5, 6, 7, 8])
5 8

4.7 Les fonctions range() et list()

L’instruction range() est une fonction spéciale en Python qui génère des nombres entiers compris dans un intervalle.
Lorsqu’elle est utilisée en combinaison avec la fonction list(), on obtient une liste d’entiers. Par exemple :
1 >>> list(range(10))
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La commande list(range(10)) a généré une liste contenant tous les nombres entiers de 0 inclus à 10 exclu. Nous
verrons l’utilisation de la fonction range() toute seule dans le chapitre 5 Boucles et comparaisons.
Dans l’exemple ci-dessus, la fonction range() a pris un argument, mais elle peut également prendre deux ou trois
arguments, voyez plutôt :
1 >>> list(range(0, 5))
2 [0, 1, 2, 3, 4]
3 >>> list(range(15, 20))
4 [15, 16, 17, 18, 19]
5 >>> list(range(0, 1000, 200))
6 [0, 200, 400, 600, 800]
7 >>> list(range(2, -2, -1))
8 [2, 1, 0, -1]

L’instruction range() fonctionne sur le modèle range([début,] fin[, pas]). Les arguments entre crochets sont
optionnels. Pour obtenir une liste de nombres entiers, il faut l’utiliser systématiquement avec la fonction list().
Enfin, prenez garde aux arguments optionnels par défaut (0 pour début et 1 pour pas) :
1 >>> list(range(10,0))
2 []

Ici la liste est vide car Python a pris la valeur du pas par défaut qui est de 1. Ainsi, si on commence à 10 et qu’on
avance par pas de 1, on ne pourra jamais atteindre 0. Python génère ainsi une liste vide. Pour éviter ça, il faudrait, par
exemple, préciser un pas de -1 pour obtenir une liste d’entiers décroissants :
1 >>> list(range(10,0,-1))
2 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Cours de Python / Université Paris Cité / UFR Sciences du Vivant 35

Chapitre 4. Listes 4.8. Listes de listes

4.8 Listes de listes

Pour finir, sachez qu’il est tout à fait possible de construire des listes de listes. Cette fonctionnalité peut parfois être
très pratique. Par exemple :
1 >>> prairie1 = ["girafe", 4]
2 >>> prairie2 = ["tigre", 2]
3 >>> prairie3 = ["singe", 5]
4 >>> savane = [prairie1, prairie2, prairie3]
5 >>> savane
6 [['girafe', 4], ['tigre', 2], ['singe', 5]]

Dans cet exemple, chaque sous-liste contient une catégorie d’animal et le nombre d’animaux pour chaque catégorie.
Pour accéder à un élément de la liste, on utilise l’indiçage habituel :
1 >>> savane[1]
2 ['tigre', 2]

Pour accéder à un élément de la sous-liste, on utilise un double indiçage :

1 >>> savane[1][0]
2 'tigre'
3 >>> savane[1][1]
4 2

On verra un peu plus loin qu’il existe en Python des dictionnaires qui sont également très pratiques pour stocker
de l’information structurée. On verra aussi qu’il existe un module nommé NumPy qui permet de créer des listes ou des
tableaux de nombres (vecteurs et matrices) et de les manipuler.

4.9 Minimum, maximum et somme d’une liste

Les fonctions min(), max() et sum() renvoient respectivement le minimum, le maximum et la somme d’une liste
passée en argument :
1 >>> liste1 = list(range(10))
2 >>> liste1
3 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4 >>> sum(liste1)
5 45
6 >>> min(liste1)
7 0
8 >>> max(liste1)
9 9

Même si en théorie ces fonctions peuvent prendre en argument une liste de strings, on les utilisera la plupart du temps
avec des types numériques (liste d’entiers et / ou de floats).
Nous avions déjà croisé min(), max() dans le chapitre 2 Variables. Ces deux fonctions pouvaient prendre plusieurs
arguments entiers et / ou floats, par exemple :
1 >>> min(3, 4)
2 3

Attention toutefois à ne pas mélanger entiers et floats d’une part avec une liste d’autre part, car cela renvoie une
erreur :
1 >>> min(liste1, 3, 4)
2 Traceback (most recent call last):
3 File "<stdin>", line 1, in <module>
4 TypeError: '<' not supported between instances of 'int' and 'list'

Soit on passe plusieurs entiers et / ou floats en argument, soit on passe une liste unique.

4.10 Problème avec les copies de listes

Nous attirons votre attention sur un comportement de Python qui peut paraitre étrange lorsqu’on copie une liste :

36 Cours de Python / Université Paris Cité / UFR Sciences du Vivant