View
3
Download
0
Category
Preview:
Citation preview
Cédric Escoute 0/27
BBBaaassseeesss dddeee
PPPrrrooogggrrraaammmmmmaaatttiiiooonnn
Python 3.5
Page 1 : Python, c’est quoi ?
Page 2 : Quelques règles de syntaxe Python
Page 3 : Les variables
Page 4 : Les opérateurs
Page 5 : Initiation à la programmation
Page 9 : Concevoir ses premiers programmes
Page 13 : Les chaines de caractères
Page 17 : Les listes
Page 22 : Correction des exercices
Page 27 : Vadémécum
Source : Apprendre à programmer avec Python 3.5 de Gérard Swinnen
Cédric Escoute 1/27
Python, c’est quoi ?
Crée en 1989 par le hollandais Guido van Rossum, Python est un logiciel de programmation gratuit et portable (pc, unix, mac).
Il est simple (lisible, il gère ses ressources et dynamiquement typé) orienté objet et extensible (utilisation de bibliothèque C)
Comment utiliser Python ?
Dans un interpréteur : Les instructions sont exécutées au fur et à mesure de la frappe
Après avoir tapé dans un IDLE (environnement de développement intégré) qui comporte :
- Un éditeur de texte (pour écrire le programme)
- Un interpréteur (pour exécuter le programme)
- Un débogueur (pour tester le programme)
Installation et lancement
Le logiciel est disponible en téléchargement à l’adresse : http://www.python.org/getit/ (choisir la version 3.5 compatible).
Vous pouvez le lancer en allant dans le Menu démarrer > Tous les programmes > Python 3 > IDLE (Python GUI).
Démarrer avec Python ?
Pour démarrer avec Python il existe un très bon livre : « Apprendre à programmer avec Python 3 » de Gérard Swinnen qui
peut être téléchargé gratuitement au format pdf : http://inforef.be/swi/download/apprendre_python3_5.pdf
L’interpréteur Python :
Lancez IDLE. Vous voyez apparaître une fenêtre « Shell ».
Les trois caractères « >>> » constituent le signal d’invite, qui vous indique que Python est prêt à exécuter une commande.
L’éditeur de texte :
Depuis l’IDLE, appuyer sur CTL+N pour ouvrir une nouvelle fenêtre pour écrire un script. C’est l’éditeur de texte qui
permet d’écrire les programmes.
Cédric Escoute 2/27
Quelques règles de syntaxe Python Limites des instructions et des blocs
Dans la plupart des autres langages, un bloc d’instructions doit être délimité par des symboles spécifiques
(parfois même par des instructions, telles que begin et end). En C++ et en Java, par exemple, un bloc
d’instructions doit être délimité par des accolades. Cela permet d’écrire les blocs d’instructions les uns à la suite
des autres, sans se préoccuper ni d’indentation ni de sauts à la ligne, mais cela peut conduire à l’écriture de
programmes confus, difficiles à relire pour les pauvres humains que nous sommes. On conseille donc à tous les
programmeurs qui utilisent ces langages de se servir aussi des sauts à la ligne et de l’indentation pour bien
délimiter visuellement les blocs.
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.
Les limites des instructions et des blocs sont définies par la mise en page
Instruction composée : en-tête, double point, bloc d’instructions indenté
Le schéma ci-contre en résume le principe.
• 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).
Vous pouvez aussi indenter à l’aide de tabulations, mais alors vous devrez faire très attention à ne pas
utiliser tantôt des espaces, tantôt des tabulations pour indenter les lignes d’un même bloc. En effet, même si
le résultat paraît identique à l’écran, espaces et tabulations sont des codes binaires distincts : Python
considérera donc que ces lignes indentées différemment font partie de blocs différents. Il peut en résulter des
erreurs difficiles à déboguer.
Les espaces et les commentaires : À part ceux qui servent à l’indentation, en début de ligne, les espaces placés à l’intérieur des instructions et
des expressions sont presque toujours ignorés (sauf s’ils font partie d’une chaîne de caractères).
Un commentaire Python commence toujours par le caractère dièse ( #). Tout ce qui est inclus entre ce
caractère et le saut à la ligne suivant est complètement ignoré par le compilateur.
Cédric Escoute 3/27
Les variables
Les variables associent un nom (à une valeur ou un objet, elles font partie des identificateurs de l'algorithmique.
L’affectation :
Le signe = sert à affecter une valeur à une
variable.
Python est un langage dont le typage est
automatique. Cela signifie que bien que
gérant différents types, lorsqu'une variable
est affectée, l'interpréteur trouvera
automatiquement son type
Exemples :
a=2 ;
b=3 ;
c= "Bonjour"
d= " au revoir."
Les noms de variables sont des noms que vous choisissez. Efforcez vous cependant de bien les choisir , de
préférence assez courts, mais aussi explicites que possible, de manière à exprimer clairement ce que la variable est
censée contenir.
Des noms de variables tels que altitude, altit ou alt conviennent mieux que x pour exprimer une altitude.
Un bon programmeur doit veiller à ce que ses lignes d'instructions soient faciles à lire.
Un nom de variable est une séquence de lettres (a → z , A → Z) et de chiffres (0 → 9), qui doit toujours
commencer par une lettre.
Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces, les caractères
spéciaux tels que $, #, @, etc. sont interdits, à l'exception du caractère _ (souligné).
La casse est significative (les caractères majuscules et minuscules sont distingués).
Joseph, joseph, JOSEPH sont donc des variables différentes. Soyez attentifs !
Prenez l'habitude d'écrire l'essentiel des noms de variables en caractères minuscules (y compris la
première lettre).
En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser comme noms de variables les 29 « mots
réservés » ci-dessous (ils sont utilisés par le langage lui-même) :
and assert break class continue def del elif else except exec finally
for from global if import in is not or pass print lambda
raise return try while yield
Les noms commençant par une majuscule ne sont pas interdits, mais l'usage veut qu'on le réserve plutôt
aux variables qui désignent des classes.
Syntaxe Type de variable
int Nombre entier optimisé
float Nombre à virgule flottante
complex Nombre complexe
str Chaîne de caractère
unicode Chaîne de caractère Unicode
tuple Liste de longueur fixe
list Liste de longueur variable
dict dictionnaire
file Fichier
booléen Booléen
NoneType Absence de type
Cédric Escoute 4/27
Les opérateurs
Les opérateurs de base
Les opérateurs logiques
Les expressions avec un opérateur logique sont évaluées à True ou False (booléens)
X or Y : OU logique, si X évalué à True, alors l'expression est True et Y n'est pas évalué. Sinon,
l'expression est évaluée à la valeur booléenne de Y.
X and Y : ET logique, si X est évalué à False, alors l'expression est False et Y n'est pas évalué. Sinon,
l'expression est évaluée à la valeur booléenne de Y.
not X : évalué à la valeur booléenne opposée de X.
Les opérateurs de comparaisons
Les opérateurs de comparaisons s'appliquent sur tous les types de base.
X is Y : X et Y représentent le même objet.
X is not Y : X et Y ne représentent pas le même objet
Il est possible d'enchaîner les opérateurs : X < Y < Z, dans ce cas, c'est Y qui est pris en compte pour la comparaison avec Z et non pas l'évaluation de (X < Y) comme on pourrait s'y attendre dans d'autres langages.
Symbole Effet
+ addition
- soustraction
* multiplication
/ division
** élévation à la puissance
// division Euclidienne
% reste de la division Euclidienne
Symbole Signification
< Strictement inférieur
> strictement supérieur
<= inférieur ou égal
>= supérieur ou égal
== égal
!= ou <> différent
Cédric Escoute 5/27
IIInnniiitttiiiaaatttiiiooonnn ààà lllaaa
PPPrrrooogggrrraaammmmmmaaatttiiiooonnn
Cédric Escoute 6/27
L’interpréteur Python
Ouvrez un terminal et lancez la commande python dans cette fenêtre. Le logiciel Python lance un interpréteur qui se comporte comme une super-calculatrice.
Pour chaque question, exécutez les commandes et écrivez leur résultat.. 1. Utilisation de variables.
>>> 3+2
>>> s=12
>>> m=24
>>> s=s+m
>>> 3*s
>>> s=5
>>> s**2
>>> n=13
>>> n/2
>>> n//2
>>> n%2
>>> k = float(input("Entrez un nombre : "))
>>> k
2. Fonction d’affichage : print()
>>> print("Salut !")
>>> s=12
>>> print(s)
>>> n=5
>>> print("Le carre de ", n, " est ", n**2)
3. Utilisation de modules
>>> pi
>>> from math import *
>>> pi
>>> sqrt(2)
Laissez cette fenêtre ouverte : elle pourra vous servir à tester des commandes avant des les inclure dans un programme.
Cédric Escoute 7/27
Premiers programmes (Niveau 1)
Instruction conditionnelle
La syntaxe complète est :
1
2
3
4
5
6
7
if (condition1):
instruction1
elif (condition2):
instruction2
else:
instruction3
# retour à la ligne pour la suite du programme
Si la condition 1 est vérifiée, l'instruction 1 va être effectuée,
sinon, si la condition 2 est vérifiée, l'instruction 2 va être effectuée.
Enfin, si aucune des conditions 1 ou 2 n'est vérifiée, c'est l'instruction 3 qui est réalisée.
Elif peut être répété à plusieurs reprises
Lancer Python (IDLE) puis avec CTL+N ouvrir une nouvelle fenêtre pour écrire un script.
1. Écrivez le programme suivant et enregistrez le sous le nom « pair.py ».
n = int(input("Entrez un nombre : ")) if (n%2 == 0):
print("Votre nombre est pair") else:
print("Votre nombre est impair")
Exécutez-le (touche F5). Observez et commentez.
………………………………………………………………………………………………………………………………
2. Écrivez le programme suivant :
n = int(input("Entrez un nombre : ")) i=0 while (i <= n):
print(i) i = i+1
Exécutez-le (touche F5). Observez et commentez.
………………………………………………………………………………………………………………………………
3. Modifiez le programme de façon à obtenir le programme suivant :
n = int(input("Entrez un nombre : ")) i=0 while (i<=n):
if (i%2 == 0): print (i)
i = i+1
Selon vous, que doit réaliser ce programme ? Exécutez-le pour le vérifier.
………………………………………………………………………………………………………………………………
4. Modifiez le programme de façon à obtenir le programme suivant :
n = int(input("Entrez un nombre : ")) i=0 while (i <= n):
if (i%2 == 0): print(i)
else: i = i+1
Que se passe-t-il ? ………………………………………………………………………………………..…………..
Augmentez l’indentation de la ligne i=i+1 et exécutez ce nouveau programme. Que se passe-t-il ?......................
Cédric Escoute 8/27
Premiers programmes (Niveau 2)
Exercice n°1 : Conditionnelle…
1. Ecrire le script suivant dans l’éditeur de texte et l’enregistrer sous le nom « Exercice_1.py ».
n = int(input("Entrez un nombre : ")) if (n%2 == 0):
print("Votre nombre est pair") else:
print("Votre nombre est impair")
2. Exécuter le script
3. Que fait ce programme ?
Exercice n°2 : Compléter un programme…
Le script suivant calcule la moyenne de 3 notes. Il doit informer l’utilisateur si la moyenne est au dessus ou au
dessous de 10.
1. Compléter le script suivant :
n1 = float(input("Entrez la première note : ")) n2 = float(input("Entrez la deuxième note : ")) n3 = float(input("Entrez la troisième note : ")) m = (n1 + n2 + n3)/3
if (m …………………………………………………………):
………………………………………………………………………………………
else: ………………………………………………………………………………………
2. Taper puis exécuter ce script
Exercice n°3 : - Chercher l’erreur…
1. Quelles erreurs ont été commises dans le script suivant ?
a = int("Entrer un nombre entier A : ")) b = int("Entrer un nombre entier B : ")) q = a//b r = a%b Print("le quotient de la division de a par b est :", q) Print("le reste de la division de a par b est :",r)
……………………………………………………………………………………………………………………………………………...
……………………………………………………………………………………………………………………………………………...
2. Quelles erreurs ont été commises dans le script suivant ?
nbre=float("que vaut 5 puissance 2 ?") if nbre=25 print("tu as gagné") else print("dommage !")
……………………………………………………………………………………………………………………………………………...
……………………………………………………………………………………………………………………………………………...
Cédric Escoute 9/27
CCCooonnnccceeevvvoooiiirrr ssseeesss ppprrreeemmmiiieeerrrsss
ppprrrooogggrrraaammmmmmeeesss
Cédric Escoute 10/27
Concevoir un programme
Exercice n°1 : Mes premiers programmes….
1. Écrire un programme qui demande un nombre entier n et affiche sa table de multiplications (de n à 10n).
2. Écrire un programme qui affiche les tables de multiplication, de la table de 2 à la table de 9.
3. Écrire un programme Python qui, étant donnés 3 nombres entiers compris entre 0 et 20 représentant les
notes obtenues par un candidat à un examen comportant 3 épreuves, calcule dans m la moyenne obtenue
par ce candidat (toutes les épreuves ont le même coefficient) et dans mention la mention obtenue (0≤m<10
: "ajourné", 10≤m<12 : "satisfecit", 12≤m<14 : "assez bien", 14≤m<16 : "bien" et 16≤m : "très bien").
Exercice n°2 : Équations du second degré
On considère une équation du second degré, donnée par les trois coefficients réels a, b et c :
2 0 (1)ax bx c
Écrivez un programme qui demande à l'utilisateur de saisir trois coefficients réels a, b et c et affiche l'ensemble des
solutions réelles de l'équation du second degré (1) associée.
Exercice n°3 : Convertisseur décimal-binaire
Écrivez un programme qui demande à l'utilisateur un nombre entier N en écriture décimale et qui le converti en
binaire.
Cédric Escoute 11/27
Utilisation de fonction
Notion de fonction
La programmation ne se réduit pas à l’algorithmique : il est essentiel de pouvoir faire référence à des morceaux de
programmes déjà écrits, sans devoir les recopier !
C’est le rôle des procédures (des suites d’instructions auxquelles ont donne un nom) et des fonctions (la même chose, mais
qui renvoie un résultat).
En Python, on les introduit au moyen de la construction def :
On définit une nouvelle fonction qui, partant des valeurs initiales de x1, x2, ... effectue les instructions requises, et
renvoie la valeur de l’expression resultat.
Si on n’utilise pas l’instruction return finale, ça fonctionne aussi sauf que rien n’est renvoyé (cas d’une procédure).
Exercice n°4 : Ma première fonction
On considère la fonction f : ℕ → ℕ définie par : 3 1 si est impair
( )/ 2 si est pair
i if i
i i
Enregistrez le programme suivant sous le nom « Exercice_fonction.py » :
# Definition de la fonction F
# Entrée : i un nombre entier # Sortie : R un nmonbre entier
def F(i): if (i%2 == 1):
R = 3*i+1 else:
R = i/2 return R
# Corps principal du programme
i = int(input("Entrez un nombre : ")) résultat = F(i) print("La valeur de la fonction f en ", i, " est ", résultat)
Exécutez ce programme, et observez comment la fonction est définie en Python. (Utilisation du mot-clé def, des
deux-points, et du mot-clé return pour renvoyer la valeur).
Exercice n°5 : Maximum entre deux nombres
Écrire un nouveau programme qui demande à l’utilisateur deux nombres entiers a et b puis les compares et
affiche le maximum des deux
On utilisera une fonction intitulée monmaximum qui, étant donnés deux entiers naturels n et m, renvoie le
maximum des deux.
L’en-tête de cette fonction sera donc : def monmaximum(n,m)
Exercice n°6 : Équations du second degré
Reprendre le sujet de l’exercice n°2 et réécrire le programme de telle manière qu’il utilise une fonction nommée
discriminant qui permet de calculer le discriminent ∆ de l’équation.
Cédric Escoute 14/27
Jusqu’à présent nous n’avons manipulé que des nombres. Mais un programme d’ordinateur peut également
traiter des caractères alphabétiques, des mots, des phrases, ou des suites de symboles quelconques. Dans la plupart
des langages de programmation, il existe pour cet usage des structures de données particulières que l’on appelle
« chaînes de caractères ».
Le type string
Une donnée de type string peut se définir en première approximation comme une suite quelconque de
caractères. Dans un script python, on peut délimiter une telle suite de caractères, soit par des apostrophes (simple
quotes), soit par des guillemets (double quotes).
Exemples :
>>> phrase1 = 'les oeufs durs.' >>> phrase2 = '"Oui", répondit-il,' >>> phrase3 = "j'aime bien" >>> print(phrase2, phrase3, phrase1) "Oui", répondit-il, j'aime bien les oeufs durs.
Les 3 variables phrase1, phrase2, phrase3 sont donc des variables de type string.
Remarquez l’utilisation des guillemets pour délimiter une chaîne dans laquelle il y a des apostrophes, ou
l’utilisation des apostrophes pour délimiter une chaîne qui contient des guillemets.
Remarquez aussi encore une fois que la fonction print( ) insère un espace entre les éléments affichés.
Le caractère spécial « \ » (antislash) :
Il permet quelques subtilités complémentaires :
La séquence \n dans une chaîne provoque un saut à la ligne.
La séquence \' permet d’insérer une apostrophe dans une chaîne délimitée par des apostrophes. De la
même manière, la séquence \" permet d’insérer des guillemets dans une chaîne délimitée elle-même par
des guillemets.
Exemples :
>>> txt3 = '"N\'est-ce pas ?" répondit-elle.' >>> print(txt3) "N'est-ce pas ?" répondit-elle.
>>> Salut = "Ceci est une chaîne plutôt longue\n contenant plusieurs lignes de texte " >>> print(Salut)
Ceci est une chaîne plutôt longue contenant plusieurs lignes de texte
Triple quotes
Pour insérer plus aisément des caractères spéciaux ou « exotiques » dans une chaîne, sans faire usage de
l’antislash, ou pour faire accepter l’antislash lui-même dans la chaîne, on peut encore délimiter la chaîne à l’aide
de triples guillemets ou de triples apostrophes :
>>> a1 = """ Exemple de texte préformaté, c'est-à-dire dont les indentations et les caractères ... spéciaux \ ' " sont conservés sans autre forme de procès.""" >>> print(a1)
Exemple de texte préformaté, c'est-à-dire dont les indentations et les caractères spéciaux \ ' " sont conservés sans autre forme de procès.
Cédric Escoute 15/27
Accès aux caractères individuels d’une chaîne
Les caractères d’une chaîne sont toujours disposés dans un certain ordre. Par conséquent, chaque caractère
de la chaîne peut être désigné par sa place dans la séquence, à l’aide d’un index.
Pour accéder à un caractère bien déterminé, on utilise le nom de la variable qui contient la chaîne et on lui
accole, entre deux crochets, l’index numérique qui correspond à la position du caractère dans la chaîne.
Les caractères d’une chaine sont numérotées à partir de zéro (et non à partir de un).
Exemple :
>>> ch = "Christine" >>> print(ch[0], ch[3], ch[5])
C i t
Opérations élémentaires sur les chaînes
Python intègre de nombreuses fonctions qui permettent d’effectuer divers traitements sur les chaînes de
caractères (conversions majuscules/minuscules, découpage en chaînes plus petites, recherche de mots, etc...).
Assembler plusieurs petites chaînes pour en construire de plus grandes à l’aide de l’opérateur +.
Cette opération s’appelle la concaténation.
Exemple :
>>>a='Petit poisson' >>>b = ' deviendra grand' >>>c = a + b >>>print(c)
petit poisson deviendra grand
Déterminer la longueur (c’est-à-dire le nombre de caractères) d’une chaîne, en faisant appel à la fonction
intégrée len( ) :
>>> ch ='Georges' >>> print(len(ch))
7
Convertir en nombre véritable une chaîne de caractères qui représente un nombre.
Exemple :
>>> ch = '8647' >>> print(ch + 45)
→ *** erreur *** : on ne peut pas additionner une chaîne et un nombre
>>> n = int(ch) >>> print(n + 65)
8712 # OK : on peut additionner 2 nombres
Dans cet exemple, la fonction intégrée int( ) convertit la chaîne en nombre entier. Il serait également
possible de convertir une chaîne de caractères en nombre réel, à l’aide de la fonction intégrée float( ).
Cédric Escoute 16/27
Parcours d’une séquence : l’instruction for…in…
Il arrive très souvent que l’on doive traiter l’intégralité d’une chaîne caractère par caractère, du premier
jusqu’au dernier, pour effectuer à partir de chacun d’eux une opération quelconque. Nous appellerons cette
opération un parcours.
En nous limitant aux outils Python que nous connaissons déjà, nous pouvons envisager d’encoder un tel
parcours à l’aide d’une boucle, articulée autour de l’instruction while : >>> nom ="Joséphine" >>> index =0 >>> while index < len(nom): ... print(nom[index] + ' *', end =' ') ... index = index +1 ... J * o * s * é * p * h * i * n * e *
Cette boucle parcourt donc la chaîne nom pour en extraire un à un tous les caractères, lesquels sont ensuite
imprimés avec interposition d’astérisques.
Notez bien que la condition utilisée avec l’instruction while est index < len(nom), ce qui signifie que le
bouclage doit s’effectuer jusqu’à ce que l’on soit arrivé à l’indice numéro 9 (la chaîne compte en effet 10
caractères indicés de 0 à 9).
Pour en faciliter l’écriture, Python vous propose une structure de boucle plus appropriée que la boucle while, basée
sur le couple d’instructions for ... in ... :
Avec ces instructions, le programme ci-dessus devient :
>>> nom ="Cléopâtre" >>> for car in nom: ... print(car + ' *', end =' ') ... C * l * é * o * p * â * t * r * e *
Comme vous pouvez le constater, cette structure de boucle est plus compacte. Elle vous évite d’avoir à définir et à
incrémenter une variable spécifique (un « compteur ») pour gérer l’indice du caractère que vous voulez traiter à
chaque itération
L’instruction for permet donc d’écrire des boucles, dans lesquelles l’itération traite successivement tous
les éléments d’une séquence donnée.
Exercices
1. Écrivez un script qui détermine si une chaîne contient ou non le caractère « e ».
2. Écrivez un script qui compte le nombre d’occurrences du caractère « e » dans une chaîne.
3. Écrivez un script qui recopie une chaîne (dans une nouvelle variable) en l’inversant.
Ainsi par exemple, « zorglub » deviendra « bulgroz ».
Cédric Escoute 18/27
La liste est une structure qui peut être très utile. Elle peut contenir des données de types différents.
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.
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi'] >>> print(jour)
['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
Comme les chaînes de caractères, on peut accéder individuellement à chacun des éléments d’une liste si l’on
connaît son index dans la liste.
La numérotation de ces index commence à partir de zéro.
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi'] >>> print(jour[2])
mercredi
>>> print(jour[4])
20.357
Opérations élémentaires sur les listes
Transformer une chaine de caractère en liste : fonction split (séparateur )
>>> "lundi : mardi : mercredi : 1800 : 20.357 : jeudi : vendredi".split(":")
['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
Changer les éléments individuels d’une liste :
À la différence de ce qui se passe pour les chaînes, qui constituent un type de données non-modifiables.
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi'] >>> jour[3] = jour[3] +47 >>> print(jour)
['lundi', 'mardi', 'mercredi', 1847, 20.357, 'jeudi', 'vendredi']
Remplacer certains éléments d’une liste par d’autres.
>>> jour[3] = 'Juillet' >>> print(jour)
['lundi', 'mardi', 'mercredi', 'Juillet', 20.357, 'jeudi', 'vendredi']
Supprimer un élément (à partir de son index) d’une liste : fonction del( )
>>> del(jour[4]) >>> print(jour) ['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi']
Ajouter un élément à la liste : fonction append ( )
>>> jour.append('samedi') >>> print(jour)
['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi', 'samedi']
Connaitre le nombre d’éléments présents dans la liste : fonction len( )
>>> print(len(jour))
7
Inverser l’ordre d’une liste : fonction reverse( )
>>> a = [1,4,7] >>> a.reverse() >>> a
[7, 4, 1]
Cédric Escoute 19/27
Opérations sur les listes
On peut appliquer aux listes les opérateurs + (concaténation) et * (multiplication) :
>>> fruits = ['orange','citron'] >>> legumes = ['poireau','oignon','tomate'] >>> fruits + legumes
['orange', 'citron', 'poireau', 'oignon', 'tomate'] >>> fruits * 3
['orange', 'citron', 'orange', 'citron', 'orange', 'citron']
L’opérateur * est particulièrement utile pour créer une liste de n éléments identiques :
>>> sept_zeros = [0]*7 >>> sept_zeros
[0, 0, 0, 0, 0, 0, 0]
Supposons par exemple que vous voulez créer une liste B qui contienne le même nombre d’éléments qu’une autre
liste A. Vous pouvez obtenir ce résultat de différentes manières, mais l’une des plus simples consistera à effectuer : B = [0]*len(A).
Test d’apparence
Vous pouvez aisément déterminer si un élément fait partie d’une liste à l’aide de l’instruction in (cette
instruction puissante peut être utilisée avec toutes les listes) :
>>> v = ['tomate', 2 ,'choux'] >>> if 'choux' in v: print('OK') OK
Opérations sur les listes de nombres
Ordonner une liste de nombres dans l’ordre croissant : fonction sort ( )
>>> list = [9,7,6,9] >>> list.sort() >>> print(list)
[6, 7, 9, 9,]
Additionner les nombres contenus dans une liste : fonction sum ( )
>>> list = [9,7,6,9] >>> sum(list]
31
Retrouver la valeur la plus élevée ou la plus basse d’une liste de nombre : fonction max ( ) ou min ( )
>>> list = [9,7,6,9] >>> max(list)
9
Cédric Escoute 20/27
2Crée une liste de nombres à l’aide de la fonction range( )
Si vous devez manipuler des listes de nombres, vous pouvez les créer très aisément à l’aide de cette fonction
intégrée. Elle renvoie une séquence d’entiers que vous pouvez utiliser directement, ou convertir en une liste avec la
fonction list() : >>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 3
La fonction range() génère par défaut une séquence de nombres entiers de valeurs croissantes.
Avec un seul argument, la liste contiendra un nombre de valeurs égal à l’argument fourni, mais en
commençant à partir de zéro (c’est-à-dire que range(n) génère les nombres de 0 à n1).
On peut aussi utiliser range() avec deux, ou même trois arguments séparés par des virgules, afin de générer des
séquences de nombres plus spécifiques : >>> list(range(5,13))
[5, 6, 7, 8, 9, 10, 11, 12]
>>> list(range(3,16,3))
[3, 6, 9, 12, 15] 4
FROM est la première valeur à générer.
TO est la dernière (𝑢𝑛−1).
STEP le « pas » à sauter pour passer d’une valeur à la suivante.
Les arguments négatifs sont autorisés :
>>> list(range(10, -10, -3))
[10, 7, 4, 1, -2, -5, -8]
Parcours d’une liste à l’aide de for, range( ) et len( )
L’instruction for est l’instruction idéale pour parcourir une liste :
>>> prov = ['La','raison','du','plus','fort','est','toujours','la','meilleure'] >>> for mot in prov: print(mot, end =' ')
La raison du plus fort est toujours la meilleure
Si vous voulez parcourir une gamme d’entiers, la fonction range() s’impose : >>> for n in range(10, 18, 3): print(n, n**2, n**3)
10 100 1000 13 169 2197 16 256 4096
Il est très pratique de combiner les fonctions range() et len() pour obtenir automatiquement tous les
indices d’une séquence (liste ou chaîne).
>>> prov = ['La','raison','du','plus','fort','est','toujours','la','meilleure'] >>> for index in range(len(prov)): print(index, prov[index])
0 La 1 raison 2 du 3 plus 4 fort ...
range (FROM , TO)
range (FROM , TO , STEP)
Cédric Escoute 21/27
Exercices
1. Écrivez un programme qui recherche le plus grand élément présent dans une liste donnée. Par exemple, si on
l’appliquait à la liste [32, 5, 12, 8, 3, 75, 2, 15], ce programme devrait afficher :
Le plus grand élément de cette liste a la valeur 75.
2. Soit le petit script ci-dessous : jour = ['dimanche','lundi','mardi','mercredi','jeudi','vendredi','samedi']
a, b = 0, 0
while a<25:
a = a + 1
b = a % 7
print(a, jour[b])
La 5e ligne fait usage de l’opérateur « modulo » déjà rencontré précédemment. On le représente par % dans de
nombreux langages (dont Python).
a. Quelle est l’opération effectuée par cet opérateur ?
b. Comprendre le fonctionnement du script en complétant le tableau suivant :
c. Que fait ce script ?
3. Soient les listes suivantes :
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin','Juillet', 'Août', 'Septembre',
'Octobre', 'Novembre', 'Décembre']
Écrivez un petit programme qui crée une nouvelle liste t3. Celle-ci devra contenir tous les éléments des deux listes
en les alternant, de telle manière que chaque nom de mois soit suivi du nombre de jours correspondant :
['Janvier',31,'Février',28,'Mars',31, etc...].
Variable a Variable b
initialisation 0 0
1er passage
2ème
passage
…. … …
7ème
passage
8ème
passage
…. … …
25ème
passage
Cédric Escoute 23/27
CORRECTION
Concevoir ses premiers programmes
Exercice n°1 : Mes premiers programmes
1. n = int(input("Entrez un nombre : ")) i=0
while (i <= 10):
print(i," x ",n," = ",i*n)
i = i+1
2. k=2
while (k<=9):
print("Table de ",k)
i = 0
while (i <= 10):
print(i," x ",k," = ",i*k)
i = i+1
k = k+1
3. a = int(input("Entrer une note")) b = int(input("Entrer une note"))
c = int(input("Entrer une note"))
m=(a+b+c)/3
if (0<=m<10):
mention = "ajourné"
elif (10<=m<12):
mention = "satisfecit"
elif (12<=m<14):
mention = "assez bien"
elif (14<=m<16):
mention = "bien"
elif (16<=m):
mention = "très bien"
print(m," mention : ",mention)
Exercice n°2 : Equations du second degré
from math import *
a=float(input("Entrer la valeur de a : "))
b=float(input("Entrer la valeur de b : "))
c=float(input("Entrer la valeur de c : "))
delta = b**2-4*a*c
if (delta < 0):
print("Pas de solution réelle.")
elif (delta == 0):
print("Une seule solution : x0 = ",-b/(2*a))
else:
x1 = (-b-sqrt(delta))/(2*a)
x2 = (-b+sqrt(delta))/(2*a)
print("Deux solutions réelles : x1=",x1," et x2=",x2)
Possibilité d’utiliser
la boucle for
Cédric Escoute 24/27
Exercice n°3 : Convertisseur décimal/binaire
n = int(input("Entrez un nombre entier en décimal : "))
while (n>1):
i=n%2
n=n//2
print(i)
Utilisation de fonctions
Exercice n°5 : Maximum entre deux nombres
2. def monmaximum(n,m):
if (n<m):
maxi = m
else:
maxi = n
return maxi
a= int(input("Entrer un nombre"))
b= int(input("Entrer un nombre"))
print("Max = ",monmaximum(a,b))
Exercice n°6 : Equations du second degré
from math import*
def discriminant(a,b,c):
return b * b - a * c
a = float(input("Entrer la valeur de a : "))
b = float(input("Entrer la valeur de b : "))
c = float(input("Entrer la valeur de c : "))
delta = discriminant(a,b,c)
if delta > 0:
n = 2
x = (-b - sqrt(delta)) / (2*a)
y = (-b + sqrt(delta)) / (2*a)
print("Nombre racines réelles : ",n,"x1=",x,"x2=",y)
elif delta == 0:
n = 1
x = -b/(2*a)
print("Nombre racines réelles : ",n,"x0=",x)
else:
n = 0
print("Nombre racines réelles : ",n)
Cédric Escoute 25/27
CORRECTION
Les chaînes de caractère
1. Écrivez un script qui détermine si une chaîne contient ou non le caractère « e ».
Boucle « while » ch=input("ecrire un nom")
i=0
test=False
#Le booléen Test Prend la valeur vrai
#si le caractère est trouvé
while (test==False and i<len(ch)):
if (ch[i]=="e"):
reponse = "caractère présent"
test=True
else :
reponse = "caractère absent"
i=i+1
print(reponse)
Boucle « for » ch=str(input("ecrire un nom"))
test = False
for car in ch :
if (car =="e" and test==False ):
reponse = "caractère présent"
test=True
elif test == False :
reponse = "caractère absent"
print(reponse)
2. Écrivez un script qui compte le nombre d’occurrences du caractère « e » dans une chaîne.
Boucle « while »
ch=input("ecrire un nom")
i=0
n=0 # compteur du nombre de e dans
# la chaine.
while (i<len(ch)):
if (ch[i]=="e"):
n = n+1
i=i+1
print("il y a",n,"lettre e")
Boucle « for »
ch=input("ecrire un nom")
n=0
for car in ch :
if (car =="e"):
n = n+1
print("il y a",n,"lettre e")
3. Écrivez un script qui recopie une chaîne (dans une nouvelle variable) en l’inversant.
Ainsi par exemple, « zorglub » deviendra « bulgroz ».
Boucle « while »
ch=input("ecrire un nom")
inverse="" # chaine inversée, vide au
# départ
i=0
while (i<len(ch)):
inverse=ch[i]+inverse
i=i+1
print(inverse)
Boucle « for »
ch=input("ecrire un nom")
inverse=""
for car in ch:
inverse = car+inverse
print(inverse)
Dans While, l’indice i représente la position du caractère ( i est un entier)
Dans For, l’indice car représente un caractère ( car est une variable de type string)
Cédric Escoute 0/27
Exercice 1 – Programmes de base
1. L=[32,5,12,8,3,75,2,15]
print("le plus gran élément de cette liste est la valeur :",max(L))
2. a. l’opérateur modulo (%) permet de trouver le reste de la division Euclidiènne (par 7 dans cet exemple) b.
3.
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin','Juillet', 'Août',
'Septembre', 'Octobre', 'Novembre', 'Décembre']
t3=[]
for i in range(len(t2)) :
t3.append(t2[i]) # Ajoute un élément de la liste t2
t3.append(t1[i]) # Ajoute un élément de la liste t1
print (t3,end='')
Ou
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin','Juillet', 'Août',
'Septembre', 'Octobre', 'Novembre', 'Décembre']
t=[]
t3=[]
for i in range(len(t2)) :
t=t2[i],t1[i] # Complète la liste t des deux éléments de t1 et t2
t3.append(t) # Ajoute les nouveaux éléments de t dans t3
print (t3,end='')
CORRECTION
Les listes
Variable a Variable b
initialisation 0 0
1er passage 1 1
2ème
passage 2 2
…. … …
7ème
passage 7 0
8ème
passage 8 1
…. … …
25ème
passage 25 4
Recommended