Tutoriel python niveau intermédiaire LA NOTATION DE TRANCHE

Bienvenue dans le tutoriel python niveau intermédiaire numéro 1.

LISTES ET INDEX

Nous savons déjà que Python (comme tous les langages de programmation) permet d’agréger des données plus simples formant des types de données plus complexes qui sont génériquement appelés conteneurs ou collections (en Python nous avons des listes, des tuples, etc.) Un conteneur permet d’accéder à ses éléments au moyen des indices entre crochets (par exemple, si ls est une liste, ls [0] est son premier élément, ls [1] le second, et ainsi de suite).

Cependant, Python a énormément développé cette possibilité, donnant à l’utilisateur la possibilité de sélectionner non seulement des éléments individuels, mais des sous-séquences entières de la séquence principale, grâce à une série de règles syntaxiques qui ont été renommées notation de tranche (c’est-à-dire “notation de tranche”). Voyons dans cette leçon les possibilités qu’elle nous offre.

INDICES NÉGATIFS

On peut utiliser un nombre négatif comme indice : dans ce cas les indices partent de la fin de la liste : l’élément -1 est le dernier, l’élément -2 l’avant-dernier et ainsi de suite. Essayons ces commandes dans IDLE :

>>> city = ["Rome", "Milan", "Naples", "Florence", "Bologna"]
>>> city [-1]
'Bologna'
>>> city [-2]
'Florence'
>>> city [-10]
Traceback (most recent call last):
   File "<pyshell # 4>", line 1, in <module>
     city [-10]
IndexError: list index out of range
>>> name = "Maximilian"
>>> name [-1]
'or'
>>> name [-2]
'n'
>>> name [-len (name)]
'M'

Dans la troisième instruction, j’ai délibérément provoqué une IndexError, tandis que la dernière est une manière plus compliquée d’indiquer le premier élément.

SÉQUENCES SUIVANTES

On peut sélectionner une sous-séquence entière d’une liste en indiquant entre crochets deux indices séparés par un caractère “:” ; comme d’habitude, le premier index est le premier (inclus), tandis que le second est le dernier (exclu). Continue comme ça:

>>> city [1: 3]
['Milan', 'Naples']
>>> name [3: 9]
'similar'
>>> name [5: 5]
''
>>> name [5: 4]
''

tutoriel python

Notez les deux dernières déclarations : si le deuxième index est égal ou inférieur au premier, j’obtiens une séquence vide. Cela fonctionne également avec des indices négatifs, qui peuvent également être utilisés en conjonction avec des indices positifs.

>>> city [-3: -1] # elements from the third to last
['Naples', 'Florence']
>>> city [-1: -3] # the other way around (empty list)
[]
>>> name [3: -2] # the letters of 'Maximilian' from the third to the penultimate
'similar to'
>>> name [5: -2] # fifth to next to last
'milia'
>>> name [10: -2] # empty string

Je répète que si le deuxième élément (de quelque manière qu’il soit indiqué) occupe une position égale ou inférieure au premier, on obtient une sous-suite vide). C’est le cas du dernier exemple, où le premier indice (10) représente la neuvième lettre de “Maximilien” (c’est à dire le “a”) et le second (-2) le troisième dernier (le même “a”).

Pour inclure le dernier élément de la séquence dans la sélection, le deuxième index doit être omis, en laissant toutefois les deux-points ; de même, le premier index peut également être omis, indiquant le premier élément de la séquence.

>>> city [: 3]
['Rome', 'Milan', 'Naples']
>>> name [-5:]
'liano'

Et enfin, nous pouvons ajouter un troisième numéro, toujours séparé par “:”, qui indique le “pas” avec lequel nous devons sélectionner les éléments. Pour retenir ces règles il suffit de noter qu’elles sont identiques à celles utilisées pour les paramètres de la fonction range() (voir ici).

>>> nom [2 : 8 : 2] # de la troisième lettre à la septième toutes les deux lettres
'Yay'
>>> nom [:: 2] # toutes les chaînes toutes les deux lettres
'Msiiin'
>>> nom [:: - 3] # de la dernière lettre à la première toutes les trois lettres
'oims'

Bref, vous pouvez comprendre que les possibilités sont vraiment nombreuses et peut-être est-il aussi difficile de comprendre l’utilité de toutes les combinaisons possibles. Dans ce qui suit, je vais essayer de vous en montrer quelques-uns.

Tutoriel python / EXERCICE 1.1 : Écrire l’instruction dans IDLE :

>>> numbers = list (range (100))

ce qui nous donne la liste de tous les nombres de 0 à 99. Essayons maintenant d’entrer ces instructions en essayant, avant de donner enter pour chacune, de deviner leur résultat (que j’omets ici).

>>> numbers [5:20]
>>> numbers [: 50]
>>> numbers [-5: -1]
>>> numbers [50: -3]
>>> numbers [-99: 5]
>>> numbers [10: 30: 3]
>>> numbers [10 :: 4]

EXERCICE 1.2 : Faisons maintenant l’exercice inverse :

je vous propose quelques sous-séquences de la liste de nombres et vous devez écrire des instructions qui retournent les séquences données :

[25, 26, 27, 28, 29]
[30, 32, 34, 35]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 5', 55, 60, 65, 70, 75, 80, 85, 90, 95]
[0, 2, 4, 6, 8]
[99, 98, 97, 96, 95, 94, 93, 92, 91, 90]

MANIPULER LES SÉQUENCES

Rappelons que pour Python les chaînes et les tuples sont des objets immuables (c’est-à-dire qu’ils ne peuvent plus être modifiés une fois qu’on leur a attribué une valeur) : cela signifie qu’au moyen des index on ne peut que lire les données mais pas les modifier. Une technique largement utilisée pour contourner cette limitation consiste à effectuer des opérations sur l’objet, puis à se réaffecter le résultat à lui-même. Par exemple, essayons de supprimer certains caractères d’une chaîne :

>>> s = "Luigi"
>>> s = s [: - 1]
>>> s
'Luig'
>>> s = s [1:]
>>> s
'uig'

dans la première instruction nous avons réaffecté tous ses caractères à s du premier à l’avant-dernier, dans le second ses caractères à partir du second. Voyons maintenant comment changer une lettre dans une chaîne :

>>> s = "mastiff"
>>> s = s [: 2] + "t" + s [3:]
>>> s
'morning'

analyser l’exemple et essayer de comprendre comment j’ai obtenu le résultat. Enfin, nous voyons un petit programme qui supprime toutes les lettres a d’une chaîne une par une :

import random

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
random.seed ()
while len (alphabet)> 0:
     print ("The string", alphabet, "contains", len (alphabet), "characters")
     input ("Press ENTER to remove a letter")
     ind = random.randrange (len (alphabet))
     print ("I removed the", alphabet [ind])
     alphabet = alphabet [: ind] + alphabet [ind + 1:]
print ("Finish")

Vous devez vous rappeler que le module random importé dans # 1 contient certaines fonctions permettant de générer des nombres aléatoires. Notez que j’ai utilisé la syntaxe import random qui nous oblige à appeler ces fonctions en préfixant le nom du module (comme dans # 4 et # 8). C’est un peu plus lourd que l’instruction from random import * que j’ai utilisée dans le premier tutoriel, mais c’est une pratique courante dans les programmes “sérieux” et il vaut donc mieux s’y habituer (voir ici). Si vous ne vous souvenez pas à quoi servent les fonctions seed () et randrange (), vous pouvez les consulter ici. Les lignes qui nous intéressent sont # 8 qui génère un index aléatoire (correspondant à une lettre de la chaîne de l’alphabet) et # 10 qui supprime cette lettre de la chaîne.

Nous utilisons maintenant nos nouvelles connaissances pour implémenter un programme capable de conjuguer des verbes réguliers : nous voulons donc obtenir une I/O de ce type (j’ai écrit l’entrée utilisateur en bleu) :

tutoriel python

Enter a regular verb of the first conjugation in the infinitive: to love
I love
You love
He loves
We love
You love
They love

EXERCICE 1.3 PROGRAMMER PAS A PAS : Ecrire le programme à partir de ce schéma :

Copiez et collez d’abord ces deux tuples dans votre programme :

pronouns = ("I", "You", "He", "We", "You", "They")
endings = ("o", "i", "a", "iamo", "ate", "ano")

Le premier contient les pronoms des six personnes du verbe, tandis que le second contient les terminaisons correspondantes
Ajoutez maintenant une instruction input () qui demande à l’utilisateur d’écrire un verbe régulier de la première conjugaison, en affectant la chaîne typée à la variable du verbe ;
Il faut maintenant conjuguer le verbe aux six personnes : ajouter une boucle for avec le compteur i allant de 0 à 5 (il faut utiliser un range () …);
Pour chacune des six itérations, vous devez imprimer le pronom et le verbe conjugué ; la conjugaison s’obtient précisément en concaténant la racine du verbe (c’est-à-dire toutes les lettres de la variable verbale moins les trois dernières) avec la terminaison correspondante dans notre tuple. Il devrait être assez facile d’accomplir cela en utilisant la notation de tranche.

EXERCICE 1.4

Si vous avez réussi à écrire le programme, vous pouvez le modifier pour qu’il combine les trois conjugaisons italiennes. Vous devez apporter ces modifications :

Ajoutez un nouveau tuple avec les trois conjugaisons :

conjugations = ("are", "ere", "ire")

Modifiez également les terminaisons de tuple, de sorte que vous ayez les terminaisons pour les trois conjugaisons. ATTENTION! De cette façon, les terminaisons deviennent un tuple qui à son tour contient d’autres tuples, de sorte que les terminaisons simples seront appelées avec un double index …

endings = (("o", "i", "a", "iamo", "ate", "ano"), # first conjugation
               ("o", "i", "e", "iamo", "ete", "ono"), # second conjugation
               ("o", "i", "e", "iamo", "ite", "ono")) # third conjugation

Modifiez l’invite de l’entrée (), en supprimant la référence à la première conjugaison ;
Après avoir entré le verbe, nous devons déterminer à quelle conjugaison il appartient. Pour ce faire, nous devons chercher sa terminaison (les trois dernières lettres du verbe, encore une fois, vous devez utiliser la notation de tranche) à l’intérieur du tuple de conjugaison : utilisez la fonction index () (voir ici) qui renvoie l’index de la terminaison à l’intérieur du tuple, en l’affectant à la variable num_con (0 = premier, 1 = deuxième, 2 = troisième).
Enfin, nous devons modifier l’instruction à imprimer dans la boucle, en gardant à l’esprit que pour indiquer notre terminaison, nous devons utiliser les crochets deux fois : le premier pour indiquer la conjugaison et le second la terminaison du peron du verbe.

EXERCICE 1.5 (OPTIONNEL)

Si vous voulez remédier à cette situation, vous devez compliquer un peu le programme ; les verbes problématiques sont ceux qui se terminent par “care”, “gare” et “iare” (tous de la première conjugaison : dans les deux premiers cas le son du “c” ou du “g” dure (donc “tu joues” et pas “tu joues”), dans le troisième chez certaines personnes il y a un “i” de trop (“tu manges” et non “tu as mangé”).
Ajoutez deux “conjugaisons” supplémentaires aux terminaisons des tuples : la quatrième sera utilisée pour les verbes en “care” et “gare”, la cinquième pour les verbes en “iare” ;

terminaisons = (("o", "i", "a", "iamo", "ate", "ano"),
               ("o", "i", "e", "iamo", "ete", "ono"),
               ("o", "i", "e", "iamo", "ite", "ono"),
("o", "salut", "a", "hiamo", "mangé", "anus"),
("o", "", "a", "amo", "mange", "anus"))

Après l’énoncé qui détermine la conjugaison du verbe, on ajoute deux if pour vérifier si on est dans un des cas particuliers ;
Si la conjugaison est la première et la quatrième à la dernière lettre est “c” ou “g” (vous pouvez utiliser l’opérateur in pour vérifier la deuxième hypothèse) nous sommes dans le premier cas particulier et nous devons définir num_con = 3 pour utiliser notre “quatrième conjugaison” ;
Sinon, si la conjugaison est la première et l’avant-dernière lettre est “i”, définissez num_con = 4.
Ces changements devraient rendre le programme précis même avec ces verbes plus difficiles. Pensez maintenant à la difficulté de combiner tous les temps et toutes les manières verbales italiennes et de prendre en compte les verbes irréguliers…