Les séquences en Python sont des structures de données composées d'entités plus petites. Dans cette catégorie, on retrouve les chaînes de caractères, les listes et les dictionnaires. Ces types de données ont en commun des fonctions permettant d'avoir des informations sur elles ou de les modifier, ainsi qu'une boucle parcourant un à un les éléments de celles-ci. Nous allons étudier en détail ces structures, les fonctions, ainsi que la boucle "Pour" dans ce chapitre.

Les chaînes de caractères

Nous avons déjà abordé précédemment les chaînes de caractères mais sans entrer dans le détail. Il est tout d'abord primordial d'avoir à l'esprit que les chaînes de caractères sont composées de caractères accessibles par un indice. Le schéma suivant permet d'illustrer les caractères associés à leurs indices.
chaineDeCaracteres=Montagne
01234567

On peut donc accéder aux caractères un à un à partir de leurs indices et n'utiliser qu'une partie de la chaîne en demandant un fragment de celle-ci :

>>> chaineDeCaracteres = "Montagne"
>>> print(chaineDeCaracteres[0])
M		# Premier caractere
>>> print(chaineDeCaracteres[3])
t		# Quatrieme caractere
>>> print(chaineDeCaracteres[-1])
e 		# Dernier caractere
>>> print(chaineDeCaracteres[-2])
n		# Avant-dernier caractere
>>> print(chaineDeCaracteres[-3])
g		# Avant-avant-dernier caractère
>>> print(chaineDeCaracteres[2:5])
nta		# Tranche du troisième au cinquième caractère
>>> print(chaineDeCaracteres[:4])
Mont		# Tranche du premier au quatrième caractère
>>> print(chaineDeCaracteres[6:])
ne		# Tranche du septième au dernier caractère
>>> print(chaineDeCaracteres[7:2:-1])
engat		# Tranche du huitième au troisième caractère dans le sens inverse
>>> print(chaineDeCaracteres[::-1])
engatnoM	# La chaîne complète dans le sens inverse
>>> print(chaineDeCaracteres[::2])
Mnan		# Les lettres d'indice pair
>>> print(chaineDeCaracteres[1::2])
otge		# Les lettres d'indice impair

Comme nous l'avons vu dans l'exemple précédent, on peut accéder aux caractères d'une chaîne en entrant le nom de la variable suivi de l'indice entre crochets. Un indice négatif permet d'accéder aux caractères à partir de la fin.

La syntaxe générale est : variable[indiceDebut (par défaut 0):indiceFin (par défaut la fin de la chaîne):pas (par défaut 1)] avec indiceDebut inclus, indiceFin exclu et pas le pas.

Si une valeur n'est pas renseignée, sa valeur par défaut est appliquée. Si une seule valeur est entrée entre crochets, seulement le caractère à l'indice du début est retourné (exemple lignes 2 à 10).

Enfin, il est possible de concaténer des chaînes de caractères uniquement à l'aide du symbole + :

>>> prenom = "Arnaud"
>>> texte = "Bonjour " + prenom + ", comment vas-tu ?"
>>> print(texte)
Bonjour Arnaud, comment vas-tu ?

Modifier la casse d'une chaîne de caractères

La casse désigne le fait de distinguer les lettres majuscules des lettres minuscules. Python possède les méthodes lower(), upper(), title(), capitalize() et swapcase() permettant de modifier la casse d'une chaîne de caractères :

>>> texte = "Écrit par Antoine de Saint-Exupéry"
>>> print(texte.lower())		# Tout en minuscule
écrit par antoine de saint-exupéry
>>> print(texte.upper())		# Tout en majuscule
ÉCRIT PAR ANTOINE DE SAINT-EXUPÉRY
>>> print(texte.title())		# Majuscule à chaque mot
Écrit Par Antoine De Saint-Exupéry
>>> print(texte.capitalize())		# Majuscule en début de phrase
Écrit par antoine de saint-exupéry
>>> print(texte.swapcase())		# Inverse la casse
éCRIT PAR aNTOINE DE sAINT-eXUPÉRY

Compter les occurrences dans une chaîne ou une liste

La méthode count(sousChaine) permet de compter le nombre d'occurrences de la sous-chaîne dans la chaîne ou liste :
>>> texte = "Écrit par Antoine de Saint-Exupéry"
>>> texte.count("a")	# Sensible à la casse
2
>>> texte.lower().count("a")
3

Rechercher et remplacer les éléments d'une chaîne

La méthode relace(ancien, nouveau) permet de remplacer l'élément ancien par nouveau.
>>> texte = "Écrit par Antoine de Saint-Exupéry"
>>> print(texte.replace("Écrit", "Rédigé"))
Rédigé par Antoine de Saint-Exupéry

Les listes et les tuples

Une liste et un tuple Python sont un ensemble ordonné d'éléments de tous types. Elles peuvent contenir en leur sein des chaînes de caractères, des nombres, des autres listes, des objets … Elles peuvent contenir des éléments de plusieurs types à la fois.

La différence entre une liste et un tuple est qu'une liste est modifiable et un tuple, non. Chaque élément est séparé par une virgule. Voici ci-dessous la syntaxe pour déclarer une liste et un tuple :

exempleListe = [27, 24.8, "Bonjour"]
exempleTuple = (27, 24.8, "Bonjour")
listeDansUneListe = [[1,2,3], [4,5,6], [7,8,9]]

À l'instar des chaînes de caractères, on peut accéder aux éléments d'une liste ou d'un tuple par son indice entre crochets :

>>> exempleListe = [27, 24.8, "Bonjour"]
>>> listeDansUneListe = [[1,2,3], [4,5,6], [7,8,9]]
>>> exempleListe[0]
27
>>> exempleListe[1:]
[24.8, 'Bonjour']
>>> listeDansUneListe[0]
[1, 2, 3]
>>> listeDansUneListe[0][1]
2

Il est possible de modifier, d'ajouter ou de supprimer une valeur d'une liste et non d'un tuple. Nous allons aborder toutes ces opérations.

Ajouter un élément en fin de liste

Pour ajouter un élément en fin de liste, on utilise la méthode append(element) :
>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> fournitures.append("ciseaux")
>>> print(fournitures)
['cahier', 'crayon', 'stylo', 'trousse', 'gomme', 'ciseaux']

Modifier un élément

La modification d'un élément se fait en réaffectant la nouvelle valeur à la place de l'ancienne :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> fournitures[1] = "équerre"
>>> print(fournitures)
['cahier', 'équerre', 'stylo', 'trousse', 'gomme']
>>> fournitures[3] = ["trombones","calque"]
>>> print(fournitures)
['cahier', 'équerre', 'stylo', ['trombones', 'calque'], 'gomme']

Ajouter un élément au cœur de la liste

Ajouter un élément se fait en modifiant une tranche de la liste dont le début et la fin de la tranche sont identiques :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> fournitures[2:2] = ["cartable"]	# Doit être dans une liste ou un tuple.
>>> print(fournitures)
['cahier', 'crayon', 'cartable', 'stylo', 'trousse', 'gomme']
>>> fournitures[4:4] = ["règle","feuilles"]
>>> print(fournitures)
['cahier', 'crayon', 'cartable', 'stylo', 'règle', 'feuilles', 'trousse', 'gomme']

Supprimer un élément

Il existe deux méthodes pour supprimer un élément d'une liste : remove(element) et pop(indice).

La méthode remove

Cette méthode permet de supprimer la première occurrence de l'élément passé en argument :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme", "stylo"]
>>> fournitures.remove("stylo")
>>> print(fournitures)
['cahier', 'crayon', 'trousse', 'gomme', 'stylo']

La méthode pop

Cette méthode permet de supprimer un élément par son indice et retourne l'élément supprimé :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> element = fournitures.pop(3)
>>> print(fournitures)
['cahier', 'crayon', 'stylo', 'gomme']
>>> print(element)
trousse

Calculer la taille d'une séquence

La fonction len(sequence) permet de retourner le nombre d'éléments contenus dans une séquence :
>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> print(len(fournitures))
5

Diviser une chaîne en liste

On peut séparer une chaîne de caractères en liste en utilisant la méthode split(separateur). Cette méthode utilise en argument une chaîne délimitant chaque élément :

>>> listeFournitures = "cahier;crayon;stylo;trousse;gomme"
>>> fournitures = listeFournitures.split(";")
>>> print(fournitures)
['cahier', 'crayon', 'stylo', 'trousse', 'gomme']

Assembler une liste en chaîne

La méthode separateur.join(liste) permet de concaténer chaque élément de la liste séparé par un séparateur :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> listeFournitures = ";".join(fournitures)
>>> print(listeFournitures)
cahier;crayon;stylo;trousse;gomme

Trier une liste

La méthode sort() permet de trier dans l'ordre croissant une liste selon ses valeurs :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> fournitures.sort()
>>> print(fournitures)
['cahier', 'crayon', 'gomme', 'stylo', 'trousse']

Inverser l'ordre d'une liste

La méthode reverse() permet d'inverser l'ordre des valeurs d'une liste :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> fournitures.reverse()
>>> print(fournitures)
['gomme', 'trousse', 'stylo', 'crayon', 'cahier']

Mélanger une liste

La méthode shuffle() du module random permet de mélanger aléatoirement les valeurs d'une liste :

>>> from random import shuffle
>>> nombres = [1,2,3,4,5,6,7,8,9]
>>> shuffle(nombres)
>>> print(nombres)
[7, 9, 3, 1, 8, 4, 6, 5, 2]
>>> shuffle(nombres)
>>> print(nombres)
[2, 1, 9, 4, 6, 8, 5, 3, 7]

Trouver l'index d'un élément

La méthode index(element) retourne l'indice du premier élément passé en argument :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme", "stylo"]
>>> fournitures.index("stylo")
2

Copie de liste

Nous allons étudier la copie de liste. On peut instinctivement tenter cette opération avec la commande suivante mais sans succès :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> copieFournitures = fournitures
>>> fournitures.remove("crayon")
>>> print(fournitures)
['cahier', 'stylo', 'trousse', 'gomme']
>>> print(copieFournitures)
['cahier', 'stylo', 'trousse', 'gomme']

Lors de la ligne 2, Python crée un alias à la nouvelle liste et n'effectue pas de copie. Chaque opération apportée sur chaque variable affectera la liste qui est accessible par ses alias. Ainsi, pour effectuer une véritable copie d'une liste, il est nécessaire d'utiliser la fonction deepcopy du module copy :

>>> from copy import deepcopy
>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> copieFournitures = deepcopy(fournitures)
>>> fournitures.remove("crayon")
>>> print(fournitures)
['cahier', 'stylo', 'trousse', 'gomme']
>>> print(copieFournitures)
['cahier', 'crayon', 'stylo', 'trousse', 'gomme']

Création rapide d'une suite de nombre

Il peut être utile de générer une suite de nombres. Pour cela, il est recommandé d'utiliser la fonction range(debut (inclus, par défaut 0),fin (exclu),pas (par défaut 1)).

>>> liste = [i for i in range(0,20,2)]
>>> print(liste)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Cette syntaxe peut être utilisée pour initialiser une liste avec des valeurs identiques :

>>> liste = [None for i in range(10)]
>>> print(liste)
[None, None, None, None, None, None, None, None, None, None]

Boucles "Pour"

Une boucle "Pour" ("For" en anglais) permet d'exécuter une portion de code pour chaque élément d'une liste en les affectant à une variable. Une fois que la liste est terminée, l'exécution normale du programme se poursuit.

Voici un exemple de l'utilisation de cette structure :

fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
for element in fournitures:
	print(element)

L'exemple ci-dessus affichera les éléments de la liste à raison de un par ligne. Il est possible d'utiliser la fonction range directement :

for compteur in range(15):
	print(compteur)

L'exemple ci-dessus affichera les nombres de 0 à 14 inclus à raison de un par ligne.

Récupérer l'élément et son indice

La fonction enumerate(liste) retourne l'indice et l'élément un à un :

>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> for index,element in enumerate(fournitures):
...     print("Indice :  " + str(index) + " => " + element)
...
Indice :  0 => cahier
Indice :  1 => crayon
Indice :  2 => stylo
Indice :  3 => trousse
Indice :  4 => gomme

Parcourir deux listes en même temps

La fonction zip(listes) permet de parcourir plusieurs listes en même temps :

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [7,8,9]
>>> for i in zip(a,b,c):
...     print(i)
...
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)

Les dictionnaires

Un dictionnaire est un ensemble désordonné d'éléments de tous types. Chaque élément est identifié à l'aide d'une clé. Voici la syntaxe pour déclarer un dictionnaire. :

exempleDictionnaire = {"livre":74, 85:"tulipe", 74.1:"rose", "coquelicot":False, "agrumes":["citron","orange","pamplemousse"]}

Le dictionnaire étant un ensemble désordonné, l'ordre de déclaration des éléments qui le composent n'a pas d'importance. Chaque élément est accessible par sa clé :

>>> exempleDictionnaire = {"livre":74, 85:"tulipe", 74.1:"rose", "coquelicot":False, "agrumes":["citron","orange","pamplemousse"]}
>>> exempleDictionnaire[74.1]
'rose'
>>> exempleDictionnaire['coquelicot']
False
>>> exempleDictionnaire['coquelicot'] = 'Rouge'
>>> exempleDictionnaire['coquelicot']
'Rouge'
>>> exempleDictionnaire["agrumes"]
['citron', 'orange', 'pamplemousse']
>>> exempleDictionnaire["agrumes"][1]
'orange'
>>> exempleDictionnaire['livre'] += 1
>>> print(exempleDictionnaire['livre'])
75

On peut ajouter un élément dans un dictionnaire comme suit :

>>> quantiteFournitures = {"cahiers":134, "stylos":{"rouge":41,"bleu":74}, "gommes": 85}
>>> quantiteFournitures["agrafes"] = 49
>>> quantiteFournitures["stylos"]["noir"] = 16
>>> print(quantiteFournitures)
{'stylos': {'bleu': 74, 'noir': 16, 'rouge': 41}, 'cahiers': 134, 'gommes': 85, 'agrafes': 49}

Supprimer un élément

À l'instar des listes, on utilise la méthode pop(clé) pour supprimer un élément par sa clé et retourner l'élément supprimé :

>>> quantiteFournitures = {"cahiers":134, "stylos":{"rouge":41,"bleu":74}, "gommes": 85}
>>> element = quantiteFournitures.pop("gommes")
>>> print(quantiteFournitures)
{'stylos': {'bleu': 74, 'rouge': 41}, 'cahiers': 134}
>>> print(element)
85

Lister les clés d'un dictionnaire

La méthode keys() retourne la liste des clés du dictionnaire :

>>> quantiteFournitures = {"cahiers":134, "stylos":{"rouge":41,"bleu":74}, "gommes": 85}
>>> cles = quantiteFournitures.keys()
>>> for fourniture in cles:
...     print(fourniture,"Quantité :",quantiteFournitures[fourniture])
...
stylos Quantité : {'bleu': 74, 'rouge': 41}
cahiers Quantité : 134
gommes Quantité : 85
>>> print(list(cles))
['stylos', 'cahiers', 'gommes']

Lister les valeurs d'un dictionnaire

La méthode values() retourne la liste des valeurs du dictionnaire :

>>> quantiteFournitures = {"cahiers":134, "stylos":{"rouge":41,"bleu":74}, "gommes": 85}
>>> valeurs = quantiteFournitures.values()
>>> print(values)
dict_values([{'bleu': 74, 'rouge': 41}, 134, 85])

Copier un dictionnaire

La méthode copy permet de créer une copie indépendante d'un dictionnaire :

>>> quantiteFournitures = {"cahiers":134, "stylos":{"rouge":41,"bleu":74}, "gommes": 85}
>>> inventaire = quantiteFournitures.copy()
>>> quantiteFournitures.pop("cahiers")
134
>>> print(quantiteFournitures)
{'stylos': {'bleu': 74, 'rouge': 41}, 'gommes': 85}
>>> print(inventaire)
{'stylos': {'bleu': 74, 'rouge': 41}, 'gommes': 85, 'cahiers': 134}

Parcourir un dictionnaire

On peut parcourir un dictionnaire par ses clés ou ses clés et ses valeurs avec la méthode items() :

>>> quantiteFournitures = {"cahiers":134, "stylos":{"rouge":41,"bleu":74}, "gommes": 85}
>>> for cle in quantiteFournitures:
...     print(cle)
...
stylos
cahiers
gommes
>>> for cle,valeurs in quantiteFournitures.items():
...     print(cle,valeurs)
...
stylos {'bleu': 74, 'rouge': 41}
cahiers 134
gommes 85

Exercices

  1. Écrivez un programme simulant le fonctionnement d'une banque en stockant le solde des comptes dans un dictionnaire. Il devra permettre le dépôt et le retrait de sommes d'argent.

    Voici les clients de la banque :

    ClientSolde
    Paul154,74
    Marie418,45
    Jean96,20
    Pauline914,21

    Exemple :

      Banque
    
    Client  Solde
    ---------------
    Marie   418.45
    Pauline 914.21
    Jean    96.2
    Paul    154.74
    
    Choisissez une opération (D : Dépot - R : Retrait - Q : Quitter) : d
    Entrez le nom du client sur lequel effectuer le dépot : Jean
    Quel montant voulez-vous déposez ? 50
    Opération effectuée. 
      Banque
    
    Client  Solde
    ---------------
    Marie   418.45
    Pauline 914.21
    Jean    146.2
    Paul    154.74
    
    Choisissez une opération (D : Dépot - R : Retrait - Q : Quitter) : r
    Entrez le nom du client sur lequel effectuer le retrait : Paul
    Quel montant voulez-vous retirer ? 9000
    Opération impossible : votre solde est insuffisant. 
    

    Démarrer l'activité avec Python Studio

  2. Écrivez un programme de loterie en demandant à l'utilisateur de choisir 6 numéros entre 1 et 50 inclus et d'effectuer un tirage aléatoire sur les mêmes critères. Enfin, il devra vérifier le nombre de numéros gagnants.

    Exemple :

    Entrez le 1e numéro entre 1 et 50 inclus : 4
    Entrez le 2e numéro entre 1 et 50 inclus : 17
    Entrez le 3e numéro entre 1 et 50 inclus : 25
    Entrez le 4e numéro entre 1 et 50 inclus : 55
    Entrez le 4e numéro entre 1 et 50 inclus : 8
    Entrez le 5e numéro entre 1 et 50 inclus : 22
    Entrez le 6e numéro entre 1 et 50 inclus : 33
    Votre choix : 4 - 17 - 25 - 8 - 22 - 33
    Le tirage : 9 - 32 - 34 - 22 - 11 - 2
    Vous avez 1 nombres gagnants.
    

    Démarrer l'activité avec Python Studio

  3. Écrivez un programme permettant de vérifier si un mot ou une phrase saisis par l'utilisateur est un palindrome, à savoir un mot lisible à la fois à l'endroit ou à l'envers tel que Serres, radar, rotor ou "Ésope reste ici et se repose".

    Exemple :

    Entrez un mot ou une phrase : laval
    La phrase est un palindrome. 
    Entrez un mot ou une phrase : fenetre
    La phrase n'est pas un palindrome.
    

    Démarrer l'activité avec Python Studio

  4. Écrivez un programme permettant de générer le calendrier d'une année non-bissextile dont le premier janvier tombe un samedi (telle que 2011). Les jours et les mois seront stockés dans des tuples. L'affichage final sera du type :

    Samedi 1 janvier
    Dimanche 2 janvier
    …
    Samedi 31 décembre
    

    Démarrer l'activité avec Python Studio

  5. Écrivez un programme permettant de calculer la quantité d'ingrédients de la recette ci-dessous en fonction du nombre de biscuits fourni par l'utilisateur. La liste d'ingrédients doit être stockée dans un dictionnaire.

    Biscuits écossais (20 biscuits)

    300g de farine • 75g de beurre • 75g de sucre roux • 1 œuf • 50 ml de lait • 12 sachet de levure chimique • 1 sachet de sucre vanillé.

    Mélanger farine et levure, ajouter le beurre, le sucre et pétrir avec les doigts. Ajouter l'œuf battu et le lait. Bien mélanger. Fariner la boule de pâte, étaler la pâte sur 12 cm et découper des formes avec un emporte-pièce. Cuire 12 à 15 minutes à 190°C.

    Exemple :

    Entrez le nombre de biscuits à produire (par multiple de 20) : 80
      - Levure chimique : 2.0 sachet
      - Lait : 200.0ml
      - Oeuf : 4.0
      - Sucre vanillé : 4.0 sachet
      - Beurre : 300.0g
      - Farine : 1200g
      - Sucre roux : 300.0g
    
    Entrez le nombre de biscuits à produire (par multiple de 20) : 17
      - Levure chimique : 0.42500000000000004 sachet
      - Farine : 255g
      - Sucre roux : 63.75g
      - Lait : 42.5ml
      - Beurre : 63.75g
      - Oeuf : 0.8500000000000001
      - Sucre vanillé : 0.8500000000000001 sachet
    

    Démarrer l'activité avec Python Studio

  6. Écrivez un programme affichant le mot le plus long d'une phrase entrée par l'utilisateur.

    Exemple :

    Entrez une phrase : Les sanglots longs des violons de l'automne blessent mon coeur d'une langueur monotone
    Le mot le plus long est L'AUTOMNE avec 9 lettres.
    

    Démarrer l'activité avec Python Studio

  7. Écrivez un programme permettant de trier une liste de nombres sans utiliser la méthode sort(). Réécrivez une fonction de tri de liste avec l'algorithme de tri à bulles qui consiste à comparer deux valeurs consécutives d'une liste et de les permuter quand elles sont mal triées et de répéter cela jusqu'à ce que la liste soit triée. Vous utiliserez les nombres tirés aléatoirement.

    Exemple :

    La liste avant le tri : 29 - 50 - 43 - 24 - 20 - 4 - 7 - 27 - 26 - 17 - 22 - 32 - 18 - 35 - 1
    La liste après le tri : 1 - 4 - 7 - 17 - 18 - 20 - 22 - 24 - 26 - 27 - 29 - 32 - 35 - 43 - 50
    

    Démarrer l'activité avec Python Studio