IV. Structurer des programmes▲
IV-A. Données structurées fondamentales▲
Jusqu'ici, nous avons essentiellement travaillé avec des chiffres qui sont des types de données relativement simples. Nous sommes parfois passés par le texte, mais sans rentrer dans le détail de sa manipulation. Tout cela est un peu limitatif et il sera souvent nécessaire de pouvoir associer plusieurs données et de garder leur relation. Certains types de données permettent de décrire de réelles structures et d'associer ainsi les différents éléments qui les composent de façon permanente ou temporaire. Parmi celle-ci, notons les chaînes de caractères justement, mais aussi les listes et les tuples qui sont un cas particulier de liste, ou encore les dictionnaires qui en sont une complexification. Enfin, les classes seront une variante étendue de ce principe, mais nous ne les verrons pas encore.
Pour connaître le type d'une donnée, vous pouvez à tout moment utiliser type(). Ainsi si vous avez une variable i avec la valeur 12, vous pourrez savoir si elle est de type str ou int :
i =
12
type(
i)
Affiche : <type 'int'>,
alors que :
i =
"12"
type (
i)
Affiche : <type 'str'>.
Les chaînes de caractères sont des suites de lettres. Les mots sont le type de chaîne de caractères le plus naturel. On peut donc considérer qu'avec Python, les mots sont de simples suites de lettres analysées et rendues une à une. Le mot n'est que cet ensemble de lettres mises les unes à la suite des autres, comme les maillons d'une chaîne.
Voici un exemple de chaîne :
phrase =
"je suis une chaîne de caractères"
globalement, toute valeur affectée à une variable entre guillemets est comprise par Python comme une chaîne de caractères, même si ce sont des chiffres qui sont entre les guillemets.
Pour changer un type il faudra utiliser une déclaration associée, déjà mentionnée :
str() pour l'utiliser en chaîne et int() pour l'utiliser comme un entier.
Ainsi si :
i =
12
type(
i)
> <type 'int'>
en faisant
> <type 'int'>
On voit bien que i n'a pas changé de type, alors que :
> <type 'str'>
affecte le type à une nouvelle variable et évite alors toute confusion.
IV-B. Plus sur le type chaîne (str)▲
Nous nous attarderons un peu sur le type string. En effet, la manipulation de chiffres avec les langages de programmation ne pose en général pas d'autres difficultés que les compétences mathématiques de l'auteur. Le texte, en comparaison, peut sembler d'un fonctionnement un peu étrange.
Le terme chaîne déjà peut surprendre et pourtant il exprime bien la réalité des choses : il s'agit d'une suite de lettres comme des maillons sont les éléments d'une chaîne métallique. Cela induit plusieurs choses qui rendent le texte « informatique » un peu différent de celui du quotidien :
- lorsque nous parlons, notre expression est fluide et continue, nous ne parlons pas lettre par lettre ;
- lorsque nous parlons, nous utilisons des structures grammaticales (sujet, verbes, compléments…) dont aucun logiciel n'a nativement connaissance. Le mot lui-même est quelque chose de difficilement repérable.
Tout cela induit des difficultés qui ne sont pas insurmontables, mais qui demandent un peu de démonstration parce que le texte est souvent un élément très important d'un projet informatique.
Allons donc petit à petit dans les détails :
texte =
"Mon texte pour commencer"
print
texte
> Mon texte pour commencer
IV-B-1. Écrire avec des guillemets▲
Remarquez à nouveau qu'une chaîne se définit entre guillemets. Si vous omettez les guillemets voici ce qui se passe :
texte =
Mon texte pour commencer
File "<stdin>", line 1
texte = Mon texte pour commencer
SyntaxError: invalid syntax
Bref, cela ne marche pas. En revanche, si votre texte doit lui-même contenir des guillemets, un autre problème va se poser :
texte =
"L'ouvreuse m'a dit : "
Donnez-
moi votre ticket." Je le lui ai donné."
File "<stdin>", line 1
texte = "L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné."
^
SyntaxError: invalid syntax
Même erreur. Dans le premier cas, le guillemet manquait ici il est en trop. En fait, Python interprète le guillemet avant Donnez comme le guillemet de fermeture de la chaîne et ne comprend pas ce qui se passe par la suite. Il existe plusieurs solutions pour contourner cette difficulté :
IV-B-2. Utiliser des guillemets simples▲
La solution la plus simple consiste à utiliser des guillemets simples (apostrophe) en remplacement de guillemets doubles :
texte =
'Mon texte "essai" pour commencer'
>>> print texte
Mon texte "essai" pour commencer
Cela marche bien ici, mais posera un problème dans cet autre exemple :
texte =
'L'
ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné.'
File "<stdin>", line 1
texte = 'L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné.'
^
SyntaxError: invalid syntax
Comme des apostrophes sont présentes dans le texte, il y a ici un nouveau conflit. Dans des cas comme ceux-ci, un peu complexe, il faudra trouver une autre solution.
IV-B-3. Échapper les caractères avec \▲
L'échappement de caractère consiste à différencier au sein du texte les caractères a priori identiques mais qui doivent être traité de façon différente par Python. Il s'agit de dire : ceci est du code Python et ceci fait partie du texte à afficher.
Le principe est simple : il suffit d'ajouter un \ devant les guillemets ou caractères qui appartiennent au texte à afficher :
texte =
"L'ouvreuse m'a dit :
\"
Donnez-moi votre ticket.
\"
Je le lui ai donné."
>>> print texte
L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné.
Le problème est souvent de savoir ce qu'il faut échapper. Généralement, il s'agit de tout caractère syntaxique du langage Python qui peut entrer en conflit avec un caractère du texte. Par chance, Python a limité au maximum sa syntaxe pour remplacer l'utilisation de caractères par l'indentation, donc cela arrive ici moins souvent que dans d'autres langages.
Globalement, il s'agit de :
- " à remplacer par \" ;
- ' à remplacer par \' ;
- et de \ à remplacer par \\.
Le caractère d'échappement est aussi utilisé dans un contexte légèrement différent lorsqu'il s'agit d'utiliser des caractères invisibles.
IV-B-4. Les caractères spéciaux▲
Il s'agit toujours de quelque chose de spécial, ces caractères spéciaux ! Le tout est de avoir ce qui est spécial ou pas. Pour un Anglais, un é est un caractère spécial, pas pour nous. il pourra donc sembler étrange à certains.
- La méthode traditionnelle pour écrire des caractères est d'utiliser leur valeur dans la table des caractères ASCII avec chr() :
print
chr(
102
)
> f
le problème est d'avoir accès à de vrais caractères étranges :
print
chr(
255
)
> ?
print
chr(
196
)
> ?
Ici, ces caractères sont simplement introuvables d'où le résultat identique. Il faudra utiliser unichr() en remplacement :
print
unichr(
255
)
> ÿ
print
unichr(
196
)
> Ä
Reste donc à connaître la correspondance entre ces chiffres et le caractère recherché. Un petit tour sur http://fr.wikipedia.org/wiki/Table_des_caractères_Unicode_(0000-0FFF) peut aider.
Parmi les caractères spéciaux, on retrouve les caractères invisibles en texte, en général ceux qui permettent de faire des retours à la ligne ou des tabulations. Dans ces cas très fréquents, Python intègre des solutions standards utilisées dans de nombreux langages par des lettres de raccourci échappées \n pour une nouvelle ligne et \t pour une tabulation.
texte =
"L'ouvreuse m'a dit :
\n\t\"
Donnez-moi votre ticket.
\"
\n
Je le lui ai donné."
print
texte
>
L'ouvreuse m'a dit :
"Donnez-moi votre ticket."
Je le lui ai donné.
IV-B-5. Agir sur le texte▲
Modifier la casse
Passer le texte en majuscules ou en minuscules peut avoir plusieurs usages : en particulier, il permet de faciliter des recherches (voir ci-dessous) ou encore d'augmenter la lisibilité en différenciant les lettres dans le terminal sur lequel il n'est pas possible de faire de différenciation de style (gras, italique…).
Python possède deux fonctions de changement de casse : mettre en majuscule avec upper(), mettre en minuscule avec lower().
cherche =
texte.upper
(
)
print
cherche
> L'OUVREUSE M'A DIT : "DONNEZ-MOI VOTRE TICKET." JE LE LUI AI DONNé.
cherche =
texte.lower
(
)
print
cherche
> l'ouvreuse m'a dit : "donnez-moi votre ticket." je le lui ai donné.
Chercher une lettre ou un mot
Dans les processus d'automatisation, il n'est pas rare d'avoir à comparer des données. Dans un texte, nous aurons parfois besoin de savoir si une portion de texte est incluse dans une autre. Cette opération s'effectue à l'aide de la méthode find().
texte =
"L'ouvreuse m'a dit :
\"
Donnez-moi votre ticket.
\"
Je le lui ai donné."
texte.find
(
"ticket"
)
> 39
texte.find
(
"billet"
)
> -1
Le résultat, s'il est valide, renvoie la position de l'occurrence dans le texte. Ainsi si le résultat est inférieur à 0 c'est que le texte n'a pas été trouvé. Comme les lettres majuscules et minuscules représentent des caractères différents en ASCII ou unicode, il est compréhensible que Python n'y soit pas indifférent et les différencie lors de la recherche.
texte.find
(
"don"
)
> 61
texte.find
(
"Don"
)
> 22
Pour faire des recherches un ignorant la casse, il faudra soit modifier la casse du texte avant recherche soit utiliser des expressions régulières (qu 'il n'est pas encore temps de voir).
Attention, car find ne retourne que la première occurrence trouvée, même s'il y en a plusieurs.
Remplacer une partie du texte
Il en est de même du remplacement. Il suffira d'utiliser la fonction replace() pour remplacer toutes les occurrences d'un texte par autre.
print
texte.replace
(
"ticket"
,"billet"
)
L'ouvreuse m'a dit : "Donnez-moi votre billet." Je le lui ai donné.
texte =
"L'ouvreuse m'a dit :
\"
Donnez-moi votre ticket.
\"
Je le lui ai donné ce ticket."
print
texte.replace
(
"ticket"
,"billet"
)
> L'ouvreuse m'a dit : \"Donnez-moi votre billet.\" Je le lui ai donné ce billet.
Découper le texte
Enfin, il est parfois nécessaire d'avoir de portions du texte. Cela est particulièrement vrai dans différents formats textes comme le CSV ou autre. Imaginons simplement des données utilisateurs contenant ces informations :
M,Alphonse,1932
M pour le sexe, Alphonse pour le prénom et 1932 pour la date de naissance. En tant que chaîne, chacune des informations n'a pas de réalité en propre. En utilisant split(), Python aura connaissance que nous souhaitons les traiter différemment. Il suffira de placer dans les parenthèses le caractère présent dans le texte qui doit servir à faire le découpage :
texte =
"M,Alphonse,1932"
print
texte.split
(
","
)
> ['M', 'Alphonse', '1932']
Le texte obtenu n'est plus une chaîne, mais une liste qui, elle, se manipule différemment, c'est ce qu'il est temps de voir.
IV-C. Listes simples et tuples▲
Les listes et les tuples sont de simples suites d'éléments indexés. Dans les listes ou dans les tuples, les éléments qui se suivent ne sont pas nécessairement de même type. Alors que dans une chaîne de caractères, tout élément est compris comme une lettre, dans une liste, un élément chiffre (int) peut suivre un élément chaîne de caractères (str)…
Il existe deux façons de déclarer une liste :
- soit en créant une liste d'emblée, vide ou non :
liste1 =
[]
liste2 =
[1
,2
,3
]
type(
liste1)
> <type 'list'>
type(
liste2)
> <type 'list'>
- soit en typant la variable :
> <type 'list'>
Le tuple héritera des mêmes procédés :
> <type 'tuple'>
type(
tuple2)
> <type 'tuple'>
type(
tuple3)
> <type 'tuple'>
La seule différence visible entre un tuple et une liste consiste dans l'utilisation de crochets dans le cas de la liste et de la parenthèse dans le cas du tuple. Au niveau de l'usage, nous verrons bientôt que la liste est modifiable alors que le tuple est prévu comme un élément figé dont les valeurs ne peuvent être modifiées.
IV-D. Les dictionnaires▲
Enfin, parmi les structures de données fondamentales en Python, on notera les dictionnaires : ce sont des listes un peu plus complexes, en ce que chacun des éléments qui les compose est au moins composé de deux membres, l'un étant la clé, l'autre la valeur, le tout embrassé par des accolades { }. La clé est la valeur sont associées par un ":" et les membres se suivent, séparés par des virgules comme dans des listes. L'utilisation d'un dictionnaire est en particulier utile lorsque les clés sont des mots qui permettent ainsi d'avoir une approche sémantique des données :
dictionnaire1 =
{}
dictionnaire2 =
{'nom'
:'Descartes'
,'prenom'
:'René'
}
dictionnaire3 =
dict(
)
type(
dictionnaire1)
> <type 'dict'>
type(
dictionnaire2)
> <type 'dict'>
type(
dictionnaire3)
> <type 'dict'>
Ainsi, en imaginant deux variables différentes elles peuvent être représentées sous les formes :
- chaînes de caractères :
nom =
"Descartes"
prenom =
"René"
dans ce cas, rien n'associe informatiquement les deux variables, seul le développeur connaît la relation implicite que le nom entretien avec le prénom.
- liste ou tuples :
personne =
["Descartes"
,"René"
]
dans ce cas, les deux valeurs sont associées dans un ensemble qui peut être signifiant, mais la nature des éléments n'est pas mentionnée. Cela peut être trompeur dans des cas comme :
personne =
["David"
,"Vincent"
]
Comment savoir lequel est le nom et lequel le prénom :
personne1 =
{'nom'
:'Descartes'
,'prenom'
:'René'
}
qui enlève toute confusion possible quels que soient les noms et prénoms.
Les dictionnaires permettent de nombreuses autres applications grâce à des spécificités que nous traiterons ultérieurement, comme les classes, lorsque nous aurons avancé sur notre connaissance et compréhension des mécanismes de Python.
IV-E. Utilisation des types▲
IV-F. Sélectionner des éléments dans les structures▲
Connaître l'existence de ces structures ne suffit pas, il faut aussi pouvoir les manipuler. Alors que dans le cas des entiers (int) la manipulation se concentrait sur des opérations mathématiques, ces structures nouvelles étant une façon d'associer des éléments par ailleurs séparés ou compris comme tels, la plupart des procédés seront relatifs à la manipulation des éléments. L'ajout de données est le plus simple.
La sélection des éléments est évidemment fondamentale, soit pour extraire la donnée et l'exploiter dans un nouveau contexte, soit pour la modifier.
Elle peut se faire de deux façons : soit par la position des éléments plutôt utilisée pour les chaînes et listes, soit par la valeur.
IV-F-1. Sélection par position (index)▲
Les chaînes, la liste et le tuple
L'accès aux éléments se gère en général par un chiffre qui représente sa position dans l'ensemble. Ce chiffre, nommé indice, est en général exprimé entre crochet quel que soit le type de structure utilisée :
phrase =
"Je pense donc je suis."
print
phrase
> Je pense donc je suis.
print
phrase[1
]
Cette dernière ligne permet d'extraire la lettre placée en position 1 de la chaîne phrase dont la valeur est « Je pense donc je suis. » Le résultat attendu est donc ?
> e
Ici, Python renvoie « e ». Vous direz oui mais la première lettre est le « J ». Certes, mais en Python comme dans de nombreux cas en informatique, on pourra estimer que la numérotation commence à 0. Il nous faudra donc tout décaler en cherchant notre indice :
print
phrase[0
]
> J
En ce qui concerne la liste ce sera la même chose :
liste1 =
(
"René"
, "Descartes"
)
print
liste1[1
]
> Descartes
et le tuple
tuple1 =
["René"
,"Descartes"
]
print
tuple1[1
]
> Descartes
En cas de besoin, il est possible de retrouver l'index d'un élément par sa valeur :
liste1=(
"Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
)
liste1.index
(
'Voltaire'
)
> 6
Le dictionnaire
En ce qui concerne le dictionnaire, on accédera à la valeur en nommant la clé :
dictionnaire1=
{'nom'
:'Descartes'
,'prenom'
:'René'
}
print
dictionnaire1['nom'
]
> Descartes
Il est aussi possible d'utiliser :
dictionnaire1.get
(
'prenom'
)
on voit que dans ce cas, l'avantage du recours au tableau est qu'il évite le recours à la position de l'élément. Ainsi, si les éléments ont changé de place suite à une manipulation, l'appel restera correct grâce à la clé, inchangée.
Sélection par valeurs
Cette méthode est plutôt utilisée dans des tests qui permettent de vérifier la présence d'un élément dans la séquence :
nom =
"Descartes"
if
"cartes"
in
nom:
print
"Descartes est de la famille des cartomanciens"
else
:
print
"Descartes aurait dû s'appeler Descartes"
Nous aurons bien sûr le même comportement pour une liste véritable :
liste1=(
"Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
)
if
"Voltaire"
in
liste1:
print
"Voltaire est un philosophe"
> Voltaire est un philosophe
IV-G. Sélection multiple et longueur dans les structures▲
Dans le cas des chaînes surtout, mais quelquefois aussi des listes et tuples, il est parfois utile de sélectionner plusieurs éléments. Quand il s'agit de chaînes, cela est évident si on souhaite extraire plusieurs lettres faisant sens ensemble, comme un mot, par exemple. Dans le cas des listes et des tuples, cela se fera surtout sentir dans le cas de réaffectation, ou de suppression.
On pourra connaître la longueur de la structure en ayant recours à len().
phrase =
"Je pense donc je suis"
len(
phrase)
> 21
liste1
(
"René"
,"Descartes"
)
len(
liste1)
> 2
Cela fonctionne aussi, de la même façon avec les tuples et les dictionnaires.
Ensuite et dans tous les cas, la longueur d'une sélection sera définie par les indices de début et fin de la sélection, séparé par un ":". Ainsi :
phrase =
"Je pense donc je suis"
print
phrase[3
:8
]
Affiche : > pense
N'oubliez pas que les indices commencent à 0 !
Lorsque l'on veut sélectionner à partir du début on écrira simplement :
print
phrase[:8
]
> Je pense
Lorsque l'on souhaite sélectionner les derniers éléments, les choses se compliquent un peu puisqu'il faut connaître la quantité d'éléments. Ainsi on pourrait faire :
liste4=(
"René"
,"Descartes"
,"Méditations Métaphysiques"
)
longueur =
len(
liste4)
print
liste4[1
:longueur]
> ('Descartes', 'Méditations métaphysiques')
Remarquez ici deux choses. Premièrement la spécificité du traitement des accents, et ensuite que le résultat est rendu sous forme de liste.
On pourra abréger en notant :
liste4 =
(
"René"
,"Descartes"
,"Méditations métaphysiques"
)
print
liste4[1
:len(
liste4)]
IV-H. Parcourir une structure de données▲
L'objectif des structures de données est d'organiser le contenu pour y avoir ensuite accès de façon facilitée, et avec des outils qui permettent de les exploiter simplement selon des critères spécifiques. Il est en particulier régulièrement nécessaire de parcourir les éléments de la structure pour en extraire les valeurs ou faire une recherche.
Ici rien de bien nouveau, nous nous contenterons de montrer comment les boucles déjà vues s'adaptent à ces formes nouvelles.
IV-H-1. While▲
phrase =
"Je pense donc je suis"
i=
0
while
i <
len(
phrase):
print
(
phrase[i])
i+=
1
On utilise ici la valeur incrémentée de i comme indice pour extraire la valeur. On retrouvera le même principe dans :
liste4 =
(
"René"
,"Descartes"
,"Méditations métaphysiques"
)
i=
0
while
i <
len(
liste4):
print
(
liste4[i])
i+=
1
IV-H-2. For▲
Avec for nous pourrons éviter le recours à l'incrémentation d'un chiffre en parcourant la liste en elle-même :
for
element in
liste4:
print
(
element)
> René
> Descartes
> Méditations Métaphysiques
Ainsi s'il s'agit de parcourir toutes les données, ce procédé pourra se révéler plus astucieux. While permettra d'avoir un meilleur contrôle des limites mais aussi de faire des boucles non pas élément après élément, mais tous les 2, 3, 4… éléments :
i=
0
while
i <
len(
phrase):
print
(
phrase[i])
i+=
2
>
J
e
s
o
c
j
u
s
IV-H-3. range()▲
Si vous préférez for quoi qu'il arrive, vous pouvez le combiner à range pour obtenir des résultats du même type, voire parfois plus succincts et plus clairs :
liste1=(
"Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
)
for
n in
(
range(
3
,6
)):
print
liste1[n]
>
Montesquieu
Diderot
Rousseau
Range() accepte plusieurs paramètres qui sont interprétés de la façon suivante :
- 1 seul paramètre, range(3) : indique une quantité de 3 ou encore range(len(liste1)) indique le nombre d'éléments de liste1 parcourue comme une plage ;
- 2 paramètres, range(3,6) : indique une plage, ici du quatrième au sixième ;
- 3 paramètres, range(0,7,2) : indique une plage ainsi qu'un rythme de sélection, ici tous les deux éléments. Nous avons dans ce cas :
for
n in
range(
0
,7
,2
):
print
liste1[n]
>
Descartes
Montaigne
Diderot
Voltaire
IV-H-4. Parcours de dictionnaires▲
La spécificité du parcours d'un dictionnaire tient dans le fait qu'il est composé de deux informations pour chaque élément : la clé et la valeur. Le parcours du dictionnaire peut se faire avec une boucle for mais si rien n'est spécifié, seul la clé est récupérée. Pour tout récupérer on utilisera une boucle du type :
dictionnaire1=
{'nom'
:'Descartes'
,'prenom'
:'René'
,'ecrit'
:'Meditations Métaphysiques'
}
for
cle, valeur in
dictionnaire1.items
(
):
print
cle, " "
, valeur
>
ecrit Meditations Métaphysiques
nom Descartes
prenom René
Les informations sont bien écrites. Remarquez simplement qu'elles sont parcourues à partir de la fin du dictionnaire.
Pour ne récupérer que la clé, utilisez :
for
cle in
dictionnaire1.keys
(
)
Pour ne récupérer que la valeur, utilisez :
for
valeur in
dictionnaire1.values
(
)
IV-I. Ajout et concaténation d'éléments▲
Pour ajouter des éléments à un ensemble structuré, les procédés pourront varier. En ce qui concerne les tuples, rien ne sera possible puisqu'ils sont immuables.
Pour ajouter un élément dans une liste, la méthode employée sera dépendante de la position souhaitée. Pour positionner le nouvel élément en fin de liste, on utilisera la méthode append alors que pour insérer à un emplacement particulier, insert sera préféré.
liste1=
['Rene'
,'Descartes'
]
liste1.append
(
'Philosophe'
)
print
liste1
> ['Rene', 'Descartes', 'Philosophe']
liste1.insert
(
2
,'France'
)
print
liste1
['Rene', 'Descartes', 'France', 'Philosophe']
En ce qui concerne les dictionnaires, il suffira d'affecter une nouvelle clé et une nouvelle valeur en utilisant la clé comme indice :
dictionnaire1['pays'
]=
"France"
ou par la position :
dictionnaire1[2
]=
"France"
Ensuite, il arrive régulièrement qu'il y ait plusieurs éléments à ajouter et que ces éléments proviennent éventuellement d'une autre variable de même type ou non. Si les types sont différents, une boucle pourra permettre l'opération, mais dans le cas ou les types sont identiques, une simple concaténation va suffire : la concaténation sur une simple opération de mise à la suite de deux éléments. La concaténation a déjà été entrevue avec la fonction print et les chaînes de caractères :
citation1 =
"je pense"
citation2 =
"je suis"
print
citation1 +
", donc "
+
citation2
> je pense, donc je suis
Dans le cas des listes, il est possible d'utiliser la même opération :
liste1 =
['Rene'
, 'Descartes'
, 'France'
, 'Philosophe'
]
liste2 =
['Discours de la Méthode'
,'Principes de la philosophie'
]
liste1 +
liste2
> ['Rene', 'Descartes', 'France', 'Philosophe', 'Discours de la Methode', 'Principes de la philosophie']
Pour concaténer les deux sans passer par une opération, la méthode extend fera parfaitement l'affaire :
liste1 =
['Rene'
, 'Descartes'
, 'France'
, 'Philosophe'
]
liste2 =
['Discours de la Méthode'
,'Principes de la philosophie'
]
liste1.extend
(
liste2)
print
liste1
> ['Rene', 'Descartes', 'France', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']
IV-J. Suppression d'éléments▲
La suppression d'éléments n'est pas l'opération la plus courante, l'ajout et l'affectation de nouvelles valeurs seront bien plus utilisées. Il n'est cependant pas inutile de savoir comment faire pour limiter la recherche et, éventuellement, accélérer les manipulations, boucles…
En ce qui concerne les listes, la suppression se fera par la position de l'élément, son indice :
print
liste1
> ['Rene', 'Descartes', 'France', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']
del
liste1[2
]
print
liste1
> ['Rene', 'Descartes', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']
Il est possible de supprimer plusieurs éléments en une seule opération à l'aide d'une plage de sélection :
del
liste1[2
:4
]
soit par sa valeur avec la méthode remove à laquelle on passera la valeur à supprimer :
liste1.remove
(
'Descartes'
)
print
liste1
> ['Rene', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']
Dans le cas des dictionnaires, en plus de pouvoir réutiliser del comme pour les listes, on retrouve la sempiternelle attention aux clés et aux valeurs :
- clear() videra complètement le dictionnaire ;
- pop(cle) supprime la clé mentionnée ;
- popitem() supprimera la paire clé:valeur.
dictionnaire1=
{"nom"
:"Descartes"
,"Prenom"
:"René"
,"Pays"
:"France"
}
del
dictionnaire1['nom'
]
print
dictionnaire1
> {'Prenom': 'René', 'Pays': 'France'}
Ici l'ensemble clé:valeur est purement et simplement supprimé. Ce ne sera pas tout à fait le cas avec pop qui renverra la valeur associée à la clé au moment de la suppression.
dictionnaire1=
{"nom"
:"Descartes"
,"Prenom"
:"René"
,"Pays"
:"France"
}
dictionnaire1.pop
(
'nom'
)
> 'Descartes'
print
dictionnaire1
{'Prenom': 'René', 'Pays': 'France'}
Ces renvois pourront être utiles dans certains cas, associés à des fonctions que nous verrons prochainement.
Enfin popitem renvoie la paire clé:valeur sous forme de tuple au moment de la sélection. La paire supprimée est la première du dictionnaire. Cette forme de suppression, surtout utile dans les boucles, évitera les doublons, mais ouvrira le risque des pertes.
IV-K. Affectation et remplacement de valeur▲
L'affectation est une opération souvent effectuée en création. Les modes d'affectation par défaut ont été vus en début de section sur les types structurés. La plupart du temps, il suffira de donner l'indice et de mentionner la nouvelle valeur à lui donner :
liste1=
['René'
, 'Philosophe'
, 'Discours de la Méthode'
, 'Principes de la philosophie'
]
liste1[2
]=
"Discours de la méthode"
print
liste1
> ['René', 'Philosophe', 'Discours de la méthode', 'Principes de la philosophie']
Au sujet des dictionnaires, il suffit de sélectionner par la clé est de modifier la valeur :
dictionnaire1=
{"nom"
:"Descartes"
,"Prenom"
:"René"
,"Pays"
:"France"
}
dictionnaire1['Pays'
]=
'Suède'
print
dictionnaire1
> {'nom': 'Descartes', 'Prenom': 'René', 'Pays': 'Suède'}
Enfin, en ce qui concerne les chaînes, il faudra effectuer un remplacement d'une portion de la chaîne par une autre en la réaffectant ou en l'enregistrant dans une nouvelle chaîne :
chaine1 =
"Bonjour"
chaine1.replace
(
"jour"
, "soir"
)
print
chaine1
> Bonsoir
IV-L. Trier des listes▲
Il est parfois important de changer l'ordre des éléments. Cela peut être pratique pour des classements ou mettre en relation deux séquences. sort() va faire ce travail très simplement :
liste1 =
[5
,10
,3
,7
]
liste1.sort
(
)
print
liste1
> [3, 5, 7, 10]
Cela marche aussi avec les éléments textuels de la liste :
liste1 =
["Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
]
liste1.sort
(
)
print
liste1
> ['Descartes', 'Diderot', 'Erasme', 'Montaigne', 'Montesquieu', 'Rousseau', 'Voltaire']
En revanche, une fois encore mais de façon plus étonnante, cela ne pourra s'appliquer aux tuples, ni aux chaînes d'ailleurs :
nom =
"cedric"
nom.sort
(
)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'sort'
Si la liste contient des éléments de type int ou float et des éléments str, alors les éléments de type str sont placés à la fin alors que la suite est bien ordonnée en ce qui concerne les nombres quelque soit leur type.
liste1 =
["Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
]
liste2 =
[5
,10
,7
,3
]
liste1 =
liste1+
liste2
liste1.sort
(
)
print
liste1
> [3, 5, 7, 10, 'Descartes', 'Descartes', 'Diderot', 'Erasme', 'Montaigne', 'Montesquieu', 'Rousseau', 'Voltaire']
liste3 =
[1.5
, 3.5
, 6.2
, 10.5
]
liste1 =
liste1+
liste3
liste1.sort
(
)
print
liste1
> [1.5, 3, 3.5, 5, 6.2, 7, 10, 10.5, 'Descartes', 'Descartes', 'Diderot', 'Erasme', 'Montaigne', 'Montesquieu', 'Rousseau', 'Voltaire']
Avec les dictionnaires, les choses se gâtent un peu. Que trier ? Les clés, les valeurs ? En utilisant la fonction sorted, on obtient un premier résultat.
dictionnaire2 =
{'nom'
:'Descartes'
,'prenom'
:'René'
,'age'
:'?'
}
dictionnaire2
> {'nom': 'Descartes', 'age': '?', 'prenom': 'Ren\xc3\xa9'}
sorted
(
dictionnaire2)
> ['age', 'nom', 'prenom']
J'ai souvent vu des personnes effectuant un tri pour rapprocher les éléments similaires et éventuellement trouver des doublons, comme on le ferait en cliquant sur les colonnes dans un navigateur de fichiers. Pour trouver des éléments similaires, il y a bien plus simple, rapide et fiable, count().
nom =
"cedric"
nom.count
(
'c'
)
> 2
ou sur des listes :
liste1=
["Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
]
liste1.count
(
'Descartes'
)
> 1
liste1.append
(
'Descartes'
)
liste1.count
(
'Descartes'
)
> 2
On trie aussi souvent pour connaître la plus petite et la plus grande valeur. Il est alors possible d'utiliser les fonctions de bases min() et max() :
liste2 =
[5
,10
,7
,3
]
min(
liste2)
> 3
max(
liste2)
> 10
et même d'en effectuer la somme avec sum() ce qui évite parfois d'avoir recours à des procédés plus longs et complexes :
liste2 =
[5
,10
,7
,3
]
sum(
liste2)
> 25
min() et max() fonctionnent aussi sur les chaînes et les éléments textuels :
nom =
"cedric"
min(
nom)
> 'c'
max(
nom)
> 'r'
liste1=
["Descartes"
,"Erasme"
,"Montaigne"
,"Montesquieu"
,"Diderot"
,"Rousseau"
,"Voltaire"
]
max(
liste1)
> 'Voltaire'