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.
| chaineDeCaracteres= | M | o | n | t | a | g | n | e |
| ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | ↑ | |
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
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 ?
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
>>> texte = "Écrit par Antoine de Saint-Exupéry"
>>> texte.count("a") # Sensible à la casse
2
>>> texte.lower().count("a")
3
>>> texte = "Écrit par Antoine de Saint-Exupéry"
>>> print(texte.replace("Écrit", "Rédigé"))
Rédigé par Antoine de Saint-Exupéry
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.
>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"]
>>> fournitures.append("ciseaux")
>>> print(fournitures)
['cahier', 'crayon', 'stylo', 'trousse', 'gomme', 'ciseaux']
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 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']
Il existe deux méthodes pour supprimer un élément d'une liste : remove(element) et pop(indice).
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']
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
>>> fournitures = ["cahier", "crayon", "stylo", "trousse", "gomme"] >>> print(len(fournitures)) 5
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']
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
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']
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']
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]
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
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']
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]
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.
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
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)
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}
À 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
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']
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])
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}
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
É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 :
| Client | Solde |
|---|---|
| Paul | 154,74 |
| Marie | 418,45 |
| Jean | 96,20 |
| Pauline | 914,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.
É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.
É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.
É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
É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.
300g de farine • 75g de beurre • 75g de sucre roux • 1 œuf • 50 ml de lait • 1⁄2 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 1⁄2 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
É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.
É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