- Introduction
- Le mode interactif
- Variables et affectations
- Programmation et fonctions
- Structure conditionnelle
- Boucles non bornées
- Les listes
- Boucles bornées
- Lire et écrire dans un fichier
- Application en SNT (en seconde)
Introduction au langage Python
Introduction
Suite au test re gravité réalisé avec pyxel : une autre activité sous capytal, reprennat ce thème avec le module P5.
Structures de données
- Une liste ordonnée :
- Première à droite
- Tout droit
- Tout droit
- Deuxième à droite
- Première à droite
- Une liste non ordonnée :
- A
- E
- I
- O
- U
- Y
- Un tableau :
DS1 DS2 DS3 12 11 13 - Un couple : $A(3;-1)$
- Un triplet : $B(5;-2;3)$
- ...
[], des accolades {} ou des parenthèses () et en séparant les valeurs par des virgules ,.
>>> chemin = ["1ère droite", "Tout droit", "Tout droit", "2ème droite", "1ère droite"]
>>> voyelle = {'A', 'E', 'I', 'O', 'U', 'Y'}
>>> notes = {'DS1' : 12, 'DS2' : 11, 'DS3' : 13}
>>> A = (3,-1)
>>> B = (5,-2,3)
Elles se différencient par leurs caractéristiques :
- Une structure est dite indexée si ses valeurs sont associées à un index ; faisant correspondre un numéro : un indice, ou un nom : une clé, spécifique à chaque valeur.
- Une structure est dite ordonnée si ses valeurs suivent un ordre spécifique.
- Une structure est dite mutable si ses valeurs sont modifiables.
Liste Une liste est une structure de données indexée par des indices entiers consécutifs commençant à 0, ordonnée par ces indices et mutable.
Elle est définie en python à l'aide de crochets : ma_liste = [2, 4, 6]
| indice | 0 | 1 | 2 |
| valeur | 2 | 4 | 6 |
Par comparaison,
- un ensemble
{2, 4, 6}n'est ni indexé ni ordonnée, - un dictionnaire
{'am':2, 'stram':4, 'gram':6}est indexé par clé mais pas ordonné, - un n-uplet (tuple)
(2, 4, 6)est indexé et ordonné, mais non mutable.
Il existe bien d'autres structures. Par exemple, un tableau est une structure de données mutable indexée et ordonnée comme une liste, mais dont on impose à chaque élément d'être de même type et dont on ne peut pas changer la taille.
Exercice Quelles sont les caractéristiques de la structure de donnée : chaine de caractères ?
Parties d'une liste
>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
C'est à dire :
| Indices | 0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 | ||||||||||
'a' |
'b' |
'c' |
'd' |
'e' |
'f' |
'g' |
'h' | |||||||||||
| Tranches | 0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
|||||||||
On peut lire une valeur d'une liste, ou en extraire une sous-liste, comme on le fait pour un caractère d'une chaine :
>>> liste[3]
'd'
>>> liste[2:5]
['c', 'd', 'e']
On peut se servir de la même notation pour modifier une partie de la liste :
| Indices | 0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 | ||||||||||
'a' |
'b' |
'c' |
'd' |
'e' |
'f' |
'g' |
'h' | |||||||||||
>>> liste[5] = 'z' # liste[5] se comporte comme une variable
>>> liste
['a', 'b', 'c', 'd', 'e', 'z', 'g', 'h']
'a' |
'b' |
'c' |
'd' |
'e' |
'z' |
'g' |
'h' | |||||||||||
| Tranches | 0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
|||||||||
>>> liste[0:5] = ['x', 'y'] # remplacer
>>> liste
['x', 'y', 'z', 'g', 'h']
'x' |
'y' |
'z' |
'g' |
'h' | ||||||||
| Tranches | 0 |
1 |
2 |
3 |
4 |
5 |
||||||
>>> liste[3:5] = [] # supprimer
>>> liste
['x', 'y', 'z']
'x' |
'y' |
'z' | ||||||
| Tranches | 0 |
1 |
2 |
3 |
||||
>>> liste[2:2] = ['et'] # insérer
>>> liste
['x', 'y', 'et', 'z']
Exercice Quelle(s) commande(s) permetent d'échanger la première et la dernière valeur d'un tableau ?
Par exemple :
>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> tmp = liste[0]
>>> liste[0] = liste[len(liste)-1]
>>> liste[len(liste)-1] = tmp
On peut simplifier, python acceptant des indices négatifs :
| Indices | 0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 | ||||||||||
| Indices | -8 |
-7 |
-6 |
-5 |
-4 |
-3 |
-2 |
-1 | ||||||||||
'a' |
'b' |
'c' |
'd' |
'e' |
'f' |
'g' |
'h' | |||||||||||
>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> tmp = liste[0]
>>> liste[0] = liste[-1]
>>> liste[-1] = tmp
Par affectation parallèle :
>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> liste[0], liste[-1] = liste[-1], liste[0]
Opérateurs
L'utilisation de fonctions et d'opérateurs se fait également comme avec les chaines de caractères :
>>> len(['a', 'b', 'c', 'b']) # Longueur
4
>>> 'b' in ['a', 'b', 'c', 'b'] # Appartenance
True
>>> ['a', 'c'] + ['y', 'z'] # Concaténation
['a', 'c', 'y', 'z']
>>> ['t', 'o'] * 2
['t', 'o', 't', 'o']
Exercice Réécrire la fonction suivante, sans utiliser in.
def appartient(valeur, liste):
""" Renvoie True ou False si valeur est un élément de liste ou non. """
return valeur in liste
En passant toutes les valeurs en revue :
def appartient(valeur, liste):
""" Renvoie True ou False si valeur est un élément de liste ou non. """
app = False
i = 0
while i<len(liste) :
app = app or liste[i]==valeur
i = i + 1
return app
Si on cherche à s'arrêter dès qu'on trouve la valeur :
def appartient(valeur, liste):
""" Renvoie True ou False si valeur est un élément de liste ou non. """
app = False
i = 0
while i<len(liste) and not app:
app = app or liste[i]==valeur
i = i + 1
return app
Que l'on peut encore réduire :
def appartient(valeur, liste):
""" Renvoie True ou False si valeur est un élément de liste ou non. """
i = 0
while i<len(liste) and liste[i]!=valeur:
i = i + 1
return i<len(liste)
Méthodes
L'utilisation de la notation liste[i:j] n'étant pas très explicite, on préfère utiliser les méthodes suivantes pour ajouter ou supprimer une valeur :
>>> liste=['a', 'b', 'c', 'd']
>>> liste.append('c') # ajoute en fin de liste
>>> liste
['a', 'b', 'c', 'd', 'c']
>>> liste.insert(1,'à') # insère à l'indice donné
>>> liste
['a', 'à', 'b', 'c', 'd', 'c']
>>> liste.remove('c') # supprime la première occurrence
>>> liste
['a', 'à', 'b', 'd', 'c']
>>> liste.pop(2) # extrait la valeur à l'indice donné
'b'
>>> liste
['a', 'à', 'd', 'c']
Utiliser la fonction help sur une liste permet d'avoir l'ensemble des méthodes disponibles.
Par exemple :
| sort(self, /, *, key=None, reverse=False)
| Sort the list in ascending order and return None.
|
| The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
| order of two equal elements is maintained).
|
| If a key function is given, apply it once to each list item and sort them,
| ascending or descending, according to their function values.
|
| The reverse flag can be set to sort in descending order.
>>> liste = ['b', 'c', 'b', 'a']
>>> liste.sort()
>>> liste
['a', 'b', 'b', 'c']
Exercice Écrire une fonction qui demande un mot à l'utilisateur, en boucle, jusqu'à ce que l'utilisateur entre le mot FIN, et qui renvoie la liste de tous les mots entrés (sauf le mot FIN).
def input_mots():
""" Demande et renvoie une liste de mots. """
mots = []
mot = input('Entrer un mot : ')
while mot != 'FIN':
mots.append(mot)
mot = input('Entrer un autre mot : ')
return mots
>>> input_mots()
Entrer un mot : moi
Entrer un autre mot : toi
Entrer un autre mot : elle
Entrer un autre mot : FIN
['moi', 'toi', 'elle']
Conversion listes / chaines de caractères
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
>>> 'Hello world'.split(' ')
['Hello', 'world']
>>> str(['1', '2', '3'])
"['1', '2', '3']"
>>> ' ; '.join(['1', '2', '3'])
'1 ; 2 ; 3'
Exercice Écrire la fonction qui prend une date au format
'dd/mm/aaaa' et qui renvoie 'dd mois aaaa', avec le
mois en toute lettre, sans le premier '0' éventuel du jour et
en appelant '1er' le premier jour '01'.
def jour(data):
""" data est 'dd/mm/aaaa', et la fonction renvoie 'dd mois aaaa' """
mois = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'aout', 'septembre', 'octobre', 'novembre', 'décembre']
liste = data.split('/') # liste est de la forme ['dd', 'mm', 'aaaa']
if liste[0][0] == '0': # si le premier 'd' de 'dd' est '0'
liste[0] = liste[0][1] # alors on ne garde que le second 'd'
if liste[0] == '1' :
liste[0] = '1er'
liste[1] = int(liste[1]) # On va se servir de int('mm') comme indice
liste[1] = mois[liste[1]-1] # Le n-ième mois est d'indice n-1
return ' '.join(liste)
>>> jour('01/01/2024')
'1er janvier 2024'
Pour s'entraîner
index , count et reverse puis écrire des fonctions avec les mêmes spécifications.