Définition d’une liste
Note
Sous Python, on peut définir une liste comme une collection d’éléments séparés par des virgules, l’ensemble étant enfermé dans des crochets Les éléments individuels qui constituent une liste peuvent être de type varié. Les objets placés dans une liste sont rendus accessibles par l’intermédiaire d’un “index” (un nombre qui indique l’emplacement de l’objet dans la séquence. Il est possible de changer les éléments individuels d’une liste. La fonction “len” s’applique aux listes. est possible de supprimer d’une liste un élément à partir de son index à l’aide de la fonction del() . Il est possible d’ajouter un élément à une liste à l’aide de append().
On délimite une liste à l’aide de crochets on lui donne un nom :
index
Commande |
Effet |
|---|---|
lst=[a,[t,v…],..]
|
Création d’une liste avec des éléments choisis par le programmeur. |
lst=[]
|
Création d’une liste vide |
lst=5*[0]
|
Création d’une liste qui peut contenir 5 entiers. |
lst=n*[0]
|
Création d’une liste qui peut contenir n entiers. |
lst=n*[""]
|
Création d’une liste qui peut contenir n chaînes de caractères |
len append insert
index |
0 |
1 |
2 |
3 |
4 |
|---|---|---|---|---|---|
mots
|
"droite"
|
"vert"
|
"gauche"
|
"haut"
|
"bas"
|
lst = ["droite","vert", "gauche", "haut", "bas"]
len(lst) #est égal à 5 , et l’index de la listemots va de 0 à 4.
Commande |
Effet |
|---|---|
mots=[index]
|
Si index=1 alors mots[index] renvoie le deuxième élément de la liste : « gauche » |
lst=[]
|
Création d’une liste vide |
lst=mots
|
lst=["droite","gauche","haut","bas"]
|
lst.append("vert")
|
Insère « vert » à la fin de la liste. lst =['droite','vert','gauche','haut','bas','vert']
|
lst+bref
lst.extend(bref)
|
Insère la liste bref à la fin de la liste lst |
lst.insert(1, "vert")
|
Insère « vert » au niveau de l’index 1 de la liste. lst.append(1,"vert")
lst= ['droite','vert','gauche','haut','bas','vert']
|
"vert" in lst
|
Renvoie True si « vert » appartient à lst ou False s’il n’appartient pas. Le mot vert est dans la liste |
lst.remove("vert")
|
Supprime la première position du terme « vert » lst.remove(« vert »)
|
del lst[0]
del lst[i :j]
|
Supprime le premier élément de la liste Supprime de la liste l’élément i jusqu’à l’élément j-1 |
remove del
Commandes
remove()
|
: recherche une valeur (si plusieurs éléments de la liste possèdent la même valeur, seul le premier est effacé). |
del()
|
: travaille avec un index ou une tranche d’index, |
programme |
Résultat |
|---|---|
lst.append(1,"vert")
lst= ['droite', 'vert', 'gauche', 'haut', 'bas', 'vert']
Le mot vert est dans la liste |
lst = [17, 38, 10, 25, 72]
del lst[2]
print(lst)
.. code-block:: python
[17, 38, 25, 72]
del lst [1:3]
print(lst)
[17, 72]
|
reverse index sort
Ce sont des fonctions qui prennent des listes en paramètres :
lst=[0,5,4,78,45,26,30,21,,47]
ch="Alice et Bob"
Méthode |
Effet |
|---|---|
premiers.sort()
|
Trier la liste premiers=[11,13,23,31,43]
|
premiers.reverse()
|
inverser l’ordre des éléments. premiers=[43,31,23,13,11]
|
premiers.index(23)
|
Retrouver l’index d’un élément 2 |
split list index
programme |
Résultat |
|---|---|
#0310 fonctions listes.py
from random import*
lst=[0,5,4,78,45,26,30,21,47]
lstchar=["al","de","sir","at"]
ch="Alice et Bob"
print("lst=",lst)
print("min(lst) : ", min(lst))
print("mnax(lst) : ", max(lst))
print("choice(lst) : ", choice(lst))
print("ch= ",ch)
chr=ch.split(" ")
print('sep=" " : ')
print('ch.split(" ") : ',ch.split(" "))
sep="*-*"
print('sep= ',sep)
print("sep.join(lstchar) :",sep.join(lstchar))
print("lstchar= ",lstchar)
liste=list(ch)
print("list(ch) : ", liste)
|
lst= [0, 5, 4, 78, 45, 26, 30, 21, 47]
min(lst) : 0
mnax(lst) : 78
choice(lst) : 4
ch= Alice et Bob
sep=" " :
ch.split(" ") : ['Alice', 'et', 'Bob']
sep= *-*
sep.join(lstchar) : al*-*de*-*sir*-*at
lstchar= ['al', 'de', 'sir', 'at']
list(ch) : ['A', 'l', 'i', 'c', 'e', ' ', 'e', 't', ' ', 'B', 'o', 'b']
|
#0312 enumerate liste.py
ch="Alice et Bob"
liste=list(ch)
for index in enumerate(liste):
print(index)
|
(0, 'A')
(1, 'l')
(2, 'i')
(3, 'c')
(4, 'e')
(5, ' ')
(6, 'e')
(7, 't')
(8, ' ')
(9, 'B')
(10, 'o')
(11, 'b')
|
enumerate() # prend en paramètre une liste et renvoie deux valeurs par éléments : l’indice et l’élément.
|
(0, 'A') ; (1, 'l') ; (2, 'i') ; (3, 'c') ; (4, 'e') ; (5, ' ')
|
(7, 't') ; `(8, ' ') ; (9, 'B') ; (10, 'o') ; (11, 'b') ; (6, 'e')
|
if elif else
En langage naturel une instruction conditionnelle se formule par : |
|---|
Si condition alors :
bloc d’instruction
Sinon :
bloc d’instruction
|
La construction utilisée avec l’instruction if est un premier exemple d’instruction composée. Sous Python, les instructions composées ont toujours la même structure : une ligne d’en-tête terminée par un double point, suivie d’une ou de plusieurs instructions indentées sous cette ligne d’en-tête. |
Commande |
Effet. |
|---|---|
if condition :
{indentation} BLOC
|
Effectue tout le BLOC d’instructions dès lors que la condition est vérifiée. Il faut respecter une indentation pour tout le BLOC. |
if condition :
{indentation}BLOC1
else :
{indentation}BLOC2
|
Effectue tout le BLOC1 d’instructions dès lors que la condition est vérifiée, dans le cas contraire, c’est le BLOC2 qui est exécuté. Il faut respecter une indentation pour le BLOC1 et le BLOC2. |
if condition1 :
{indentation} BLOC1
elif condition2 :
{indentation} BLOC2
elif condition3:
{indentation} BLOC3
|
|
| Exemple : |
|---|
|
# 0301 instruction conditionnelle.py
# if ;elif; else
# la commande \n effectue un retour à la ligne
print(" programme qui détermine:\n si un nombre est positif ou négatif ")
nbre1=input(" Donner un nombre :")
# float() effectue la conversion de ma variable en nombre décimal
nbre=float(nbre1)
if nbre<0:# si condition
print("Le nombre ",nbre," est négatif")
elif nbre==0:#elif suit obligatoirement une instruction if
print(" Le nombre est ègal à zéro ")
else:# sinon
print(" Le nombre ",nbre," est positif ")
|
On peut déterminer si un élément fait partie d’une liste ou d’une chaîne de caractères à l’aide de l’instruction in.
| Appartenance |
|---|
|
# 0302 test d'appartenance.py
# if ; else , in
print(" Instructions imbriquées :")
va="a"
vb="b"
print(" le programme détecte si le mot comporte les lettres a ou b ")
print(" Donner un mot :")
mot=input()
if vb in mot:
if va in mot:
print(" Il y les lettres a et b dans ",mot)
else:
print("Il y a la lettre b et pas de lettre a dans ",mot )
else:
if va in mot:
print(" Il y a la lettre a et pas la lettre b dans ",mot )
else:
print("Il n'y a pas de lettre a ni de lettre b dans ",mot)
|
Les limites des instructions et des blocs sont définies par la mise en page.
Dans de nombreux langages de programmation, il faut terminer chaque ligne d’instructions par un caractère spécial (souvent le point-virgule). Sous Python, c’est le caractère de fin de ligne qui joue ce rôle.
Les instructions peuvent s’étendre sur plusieurs lignes si elles se trouvent dans une paire syntaxique, par exemple une paire de crochets.
Une instruction peut aussi s’étendre sur plusieurs lignes si elle finit par un .
On peut également terminer une ligne d’instructions par un commentaire.
Un commentaire Python commence toujours par le caractère spécial #.
Tout ce qui est inclus entre ce caractère et le saut à la ligne suivant est complètement ignoré par le compilateur.
Avec Python, vous devez utiliser les sauts à la ligne et l’indentation, mais en contrepartie vous n’avez pas à vous préoccuper d’autres symboles délimiteurs de blocs. En définitive, Python vous force donc à écrire du code lisible, et à prendre de bonnes habitudes que vous conserverez lorsque vous utiliserez d’autres langages.
Instruction composée : en-tête, double point, bloc d’instructions indenté. Les blocs d’instructions sont toujours associés à une ligne d’en-tête contenant une instruction bien spécifique (if, elif, else, while, def, etc.) se terminant par un double point.
Les blocs sont délimités par l’indentation : toutes les lignes d’un même bloc doivent être indentées exactement de la même manière (c’est-à-dire décalées vers la droite d’un même nombre d’espaces).
Le nombre d’espaces à utiliser pour l’indentation est quelconque, mais la plupart des programmeurs utilisent des multiples de 4.
Notez que le code du bloc le plus externe (bloc 1) ne peut pas lui-même être écarté de la marge de gauche (il n’est imbriqué dans rien)
INSTRUCTIONS :
Il est parfaitement possible d’imbriquer les unes dans les autres plusieurs instructions composées, de manière à réaliser des structures de décisions complexes.
Le schéma en résume le principe.
BLOC 1 Ligne (if elif while for ): #indentation BLOC 2 Ligne (if elif while for ): #indentation BLOC 3 BLOC 1 Suite et fin:
while
in
Un bloc d’instructions est répété tant que la condition reste vérifiée.
Commande |
Effet |
|---|---|
while condition :
{indentation} BLOC
|
Répète le BLOC d’instructions tant que la condition est vérifiée. Il faut respecter une indentation pour tout le BLOC. |
Le mot while signifie tant que en anglais. Cette instruction utilisée indique à Python qu’il lui faut répéter continuellement le bloc d’instructions qui suit, tant que le contenu de la variable Continue est égal à True. Comme l’instruction if, l’instruction while amorce une instruction composée. Le double point à la fin de la ligne introduit le bloc d’instructions à répéter, lequel doit obligatoirement se trouver en retrait. Toutes les instructions d’un même bloc doivent être indentées exactement au même niveau (c’est-à-dire décalées à droite d’un même nombre d’espaces). (de la ligne 6 à la ligne 11)
| Continuer à exécuter |
|---|
|
# 0303 tant que ca continue.py
# Tant que condition
# Continue est un booléen , faux: False , vrai : True
Continue=True
while Continue==True:
print("***********ESSAI************")
reponse=input("voulez vous continuer : oui / non ")
if reponse=="oui":
Continue=True
else:
Continue=False
|
Avec l’instruction while, Python commence par évaluer la validité de la condition fournie entre parenthèses (celles-ci sont optionnelles) |
Si la condition se révèle fausse, alors tout le bloc qui suit est ignoré et l’exécution du programme se termine. (ligne 18) |
Si la condition est vraie, alors Python exécute tout le bloc d’instructions constituant le corps de la boucle, c’est-à-dire : |
L’instruction i=i+ 1 (ligne 11) qui incrémente d’une unité le contenu de la variable i (ce qui signifie que l’on affecte à la variable i une nouvelle valeur, qui est égale à la valeur précédente augmentée d’une unité). |
L’appel de la fonction print(i) pour afficher la valeur de la variable i. |
Lorsque ces deux instructions ont été exécutées, nous avons assisté à une première itération, et le programme boucle, c’est-à-dire que l’exécution reprend à la ligne contenant l’instruction while. (ligne 10) |
La condition qui s’y trouve est à nouveau évaluée, et ainsi de suite. |
La variable évaluée dans la condition doit exister au préalable (il faut qu’on lui ait déjà affecté au moins une valeur).(ligne 9) |
Si la condition est fausse au départ, le corps de la boucle n’est jamais exécuté. |
Si la condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment. Il faut donc veiller à ce que le corps de la boucle contienne au moins une instruction qui change la valeur d’une variable intervenant dans la condition évaluée par while, de manière à ce que cette condition puisse devenir fausse et la boucle se terminer. |
for i in range()
Une boucle permet de répéter plusieurs fois de suite un même traitement.
| Les instructions peuvent s’étendre sur plusieurs lignes si elles se trouvent dans une paire syntaxique, par exemple une paire de crochets. |
| Lorsque le nombre de répétitions (ou itérations) noté « n »est connu à l’avance, on utilise un compteur initialisé à 1 et qui s’incrémente automatiquement de 1 à chaque itération jusqu’à n. On parle de boucle itérative |
| On peut également terminer une ligne d’instructions par un commentaire. |
| Un bloc d’instructions est répété à l’aide de l’instruction for, c’est une variable qui parcourt les éléments d’une séquence. |
Commande |
Effet |
|---|---|
for i in range(N):
#indentation
{BLOC}
|
Répète N fois le BLOC d’instructions. La variable i prend successivement les valeurs de 0 à N −1 . N est un entier, i est un entier, il y a plusieurs syntaxes possibles. Il faut respecter une indentation pour tout le BLOC. |
| Calcul d'une racine carré |
|---|
|
# 0304 calcul d'une racine carrée.py
#for , in, print , range
def racine_carre(var):
var1=var
for i in range(1,20):
u=0.5*(var1+var/var1)
var1=u
return u
print("Calcul de la solution positive de x²-N = 0 ")
print("N est un nombre positif et")
print("on calcule U qui est la racine carrée de N")
nbre=input("Donner la valeur de N :")
var=float(nbre)
u=racine_carre(var)
print("U = ", u)
print("U² = ",u*u)
|
programme |
Résultat |
|---|---|
#0310 fonctions listes.py
from random import*
lst=[0,5,4,78,45,26,30,21,47]
lstchar=["al","de","sir","at"]
ch="Alice et Bob"
print("lst=",lst)
print("min(lst) : ", min(lst))
print("mnax(lst) : ", max(lst))
print("choice(lst) : ", choice(lst))
print("ch= ",ch)
chr=ch.split(" ")
print('sep=" " : ')
print('ch.split(" ") : ',ch.split(" "))
sep="*-*"
print('sep= ',sep)
print("sep.join(lstchar) :",sep.join(lstchar))
print("lstchar= ",lstchar)
liste=list(ch)
print("list(ch) : ", liste)
|
lst= [0, 5, 4, 78, 45, 26, 30, 21, 47]
min(lst) : 0
mnax(lst) : 78
choice(lst) : 4
ch= Alice et Bob
sep=" " :
ch.split(" ") : ['Alice', 'et', 'Bob']
sep= *-*
sep.join(lstchar) : al*-*de*-*sir*-*at
lstchar= ['al', 'de', 'sir', 'at']
list(ch) : ['A', 'l', 'i', 'c', 'e', ' ', 'e', 't', ' ', 'B', 'o', 'b']
|
#0312 enumerate liste.py
ch="Alice et Bob"
liste=list(ch)
for index in enumerate(liste):
print(index)
|
(0, 'A')
(1, 'l')
(2, 'i')
(3, 'c')
(4, 'e')
(5, ' ')
(6, 'e')
(7, 't')
(8, ' ')
(9, 'B')
(10, 'o')
(11, 'b')
|
enumerate() # prend en paramètre une liste et renvoie deux valeurs par éléments : l’indice et l’élément.
|
(0, 'A') ; (1, 'l') ; (2, 'i') ; (3, 'c') ; (4, 'e') ; (5, ' ')
|
(7, 't') ; `(8, ' ') ; (9, 'B') ; (10, 'o') ; (11, 'b') ; (6, 'e')
|
L’habitude a été prise de nommer les entiers utilisés par for i, j, ou k.
programme |
Résultat |
|---|---|
# 0312 liste de mots.py
# listes
#for, in, print, sequence
#sequence est une liste
sequence= [ " lundi "," mardi "," mercredi "," jeudi ", \
" vendredi "," samedi "," dimanche"]
print(" liste sequence :")
print(sequence)
for lettre in sequence:
print(lettre)
print("-*-*-*-*-*")
|
liste sequence :
[' lundi ', ' mardi ', ' mercredi ', ' jeudi ', ' vendredi ', ' samedi ', ' dimanche']
lundi
-*-*-*-*-*
mardi
-*-*-*-*-*
mercredi
-*-*-*-*-*
jeudi
-*-*-*-*-*
vendredi
-*-*-*-*-*
samedi
-*-*-*-*-*
dimanche
-*-*-*-*-*
|
programme |
Résultat |
|---|---|
#0320méthodes listes
entiers=list(range(-5,6))
print("entiers")
print(entiers)
reels=[]
for i in range(len(entiers)):
reels.append(entiers[i])
socle=sorted(reels,reverse=False)
print("Dans le même sens")
print(socle)
print("Sens inversé")
socle1=sorted(reels,reverse=True)
print(socle1)
|
entiers
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
Dans le même sens
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
Sens inversé
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5]
|
programme |
Résultat |
|---|---|
#reverse liste
a=[1,2,3,4,5]
b=['a','b','c']
c=[]
c.append(a[4])
b[0]= a
a.reverse()
print('b',b)
print('a',a)
print('c',c)
|
b [[5, 4, 3, 2, 1], 'b', 'c']
a [5, 4, 3, 2, 1]
c [5]
|
and is or not
Si on doit tester plusieurs conditions pour rentrer dans une boucle il existe plusieurs solutions :
Bloc d’instructions
orsignifie ou en anglais.
Bloc d’instructions
signifie n’est pas en anglais.
Permettent de comparer des nombres. Le résultat d’une opération de comparaison est un booléen :(True ou False, Vrai ou Faux)
Symbole |
Signification |
Exemple |
Résultat |
|---|---|---|---|
==
|
est égal à |
\[1 == 2\]
|
False |
v!=
|
n’est pas égal à |
\[1 != 2\]
|
True |
<
|
est inférieur à |
\[1 < 2\]
|
True |
>
|
est supérieur à |
\[1 > 2\]
|
False |
v>=
|
est supérieur ou égal à |
\[1 >= 2\]
|
False |
<=
|
est inférieur ou égal à |
\[1 <= 2\]
|
True |
Opération |
Exemple |
Résultat |
Notes |
|---|---|---|---|
Transtypage |
ch = str(34)
|
\[34\]
|
ch est une chaîne de caractères; |
nb=int("34")
|
\[34\]
|
nb est un nombre entier |
|
db=float("3.4")
|
\[3.4\]
|
db est un nombre décimal |