Cours de Python en Licence

•Ce cours est basé sur le MOOC de Charles Severance accessible sur la
plateforme Coursera : https://www.coursera.org/course/pythonlearn

•Pour compléter ce cours, nous vous conseillons de visionner les vidéos de

Charles Severance accessibles via l’Espace Numérique de Travail

•Il est également dans votre intérêt de refaire à la maison les exercices des
Travaux Dirigés, dans un but d’apprentissage et d’auto-évaluation
 Cours de Python en Licence

•Séquence 1 : Pourquoi programmer ? Notions d’architecture matérielle

•Séquence 2 : Constantes, variables, types, expressions, entrées-sorties
•Séquence 3 : Structures conditionnelles, gestion des exceptions
•Séquence 4 : Fonctions prédéfinies et définies par l’utilisateur
•Séquence 5 : Structures itératives, les types liste et chaîne
 Chapitre 1

Pourquoi programmer ?
Les ordinateurs « veulent »
nous être utiles... What
Next ?

•Les ordinateurs sont construits dans un seul

objectif : faire des choses pour nous…
•Mais nous avons besoin de « parler leur
langue » pour qu'ils puissent faire ce que nous
voulons…
•Mais notre tâche a été facilitée : des
What What What
spécialistes ont intégré beaucoup de Next ? Next ? Next ?
programmes différents dans l'ordinateur
•et les utilisateurs n’ont qu’à choisir les
What What What
programmes qu’ils veulent exécuter Next ? Next ? Next ?
 Les programmeurs
anticipent les besoins
•Exemple : les applications pour
smartphone est un marché :
•De 2008 à fin 2012, il y a eu 40 milliards
d'applications téléchargées sur la
boutique applicative AppStore ! Choisi Choisi Achète
•Des programmeurs quittent leur poste Moi ! Moi ! Moi !
pour devenir développeurs iPhone à plein
temps Choisi Choisi Choisi
Qu’est-ce qu’un programmeur ? Moi ! Moi ! Moi !
 Utilisateurs vs. Programmeurs
•Les utilisateurs voient les ordinateurs comme un ensemble d’outils : traitement
de texte, tableur, agenda, logiciels de communication, etc.
•Les programmeurs quant à eux :
•savent comment fonctionnent les ordinateurs
•apprennent les méthodes et les langages informatiques
•ont des outils qui leur permettent de construire de nouveaux outils
•certains sont destinés aux utilisateurs, d’autres aux programmeurs
•Pourquoi programmer ?
•pour nos propres besoins = programmeur & utilisateur à la fois
•pour produire un logiciel utilisable par d’autres = programmeur de métier
 Qu’est-ce que du code ? Un
logiciel ? Un programme?
•C’est une séquence d’instructions mémorisées dans l’ordinateur

•C’est une expression de notre intelligence que nous donnons aux autres :

•Nous comprenons quelque chose  nous le traduisons en langage

informatique  nous en faisons profiter d’autres personnes pour leur faire
gagner du temps et de l’énergie

•Si nous produisons une bonne « user experience » un programme peut aussi
être considéré comme un objet créatif, voire artistique
 Un programme
pour humains...
What
Next ?

http://www.youtube.com/watch?v=vlzwuFkn88U
Main gauche vers l’extérieur et en haut Un programme
Main droite vers l’extérieur et en haut
Retournez la main gauche
Retournez la main droite
pour humains...
Main gauche sur l'épaule droite What
Main droite sur l'épaule gauche Next ?
Main gauche derrière la tête
Nain droite derrière la tête
Main gauche sur la manche droite
Main droite sur la manche gauche
Main gauche sur fesse gauche
Main droite sur fesse droite
Se déhancher
Se déhancher
Sauter
http://www.youtube.com/watch?v=vlzwuFkn88U
Main gauche vers l’extérieur et en haut Un programme
Main droite vers l’extérieur et en haut
Retournez la main gauche
Retournez la main droite
pour humains...
Main gauche sur l'épaule droite BUGS ?
Main droite sur l'épaule gauche
Main gauche derrière la tête
Nain droite derrière la tête
Main gauche sur la manche droite
Main droite sur la manche gauche
Main gauche sur fesse gauche
Main droite sur fesse droite
Se déhancher
Se déhancher
Sauter
http://www.youtube.com/watch?v=vlzwuFkn88U
Main gauche vers l’extérieur et en haut Un programme
Main droite vers l’extérieur et en haut
Retournez la main gauche
Retournez la main droite
pour humains...
Main gauche sur l'épaule droite FIXED !
Main droite sur l'épaule gauche
Main gauche derrière la tête
Main droite derrière la tête
Main gauche sur la hanche droite
Main droite sur la hanche gauche
Main gauche sur fesse gauche
Main droite sur fesse droite
Se déhancher
Se déhancher
Sauter
http://www.youtube.com/watch?v=vlzwuFkn88U
Petit exercice :
Quel mot apparaît le plus souvent
dans le petit texte ci-dessous ?

le clown couru après la voiture et la voiture fonça sur

la tente et la tente tomba sur le clown et la voiture

Combien de temps vous a-t-il

fallu pour trouver une réponse ?
 Un programme pour ordinateurs
filename = input('Nom du fichier: ') Exemple d’exécution :
with open(filename, 'r') as file:
text = file.read() python words.py
words = text.split()
Nom du fichier: clown.txt
counts = dict() la 5
for word in words:
counts[word] = counts.get(word,0) + 1 Ce programme peut traiter
bigword,bigcount = None,None
d’autres programmes,
for word,count in counts.items(): y compris lui-même :
if bigcount == None or count > bigcount:
bigword,bigcount = word,count python words.py
print(bigword, bigcount)
Nom du fichier: words.py
=9
 Chapitre 1 (suite)

Architecture matérielle
« L’informatique n’est pas plus la science des ordinateurs
que l’astronomie n’est celle des télescopes »

Edsger Dijkstra (1930-2002)

 Un peu d’histoire…
•Le métier à tisser de Jacquard (1806) :

Les métiers à tisser de Joseph-Marie Jacquard sont des machines automatisées

programmées par cartes perforées qui décrivent le motif qui doit être tissé.

L’utilisation de cartes perforées fait que le métier Jacquard est parfois considéré
comme un ancêtre des ordinateurs.

•La machine analytique de Babbage (1834) :

La machine analytique de Charles Babbage est une calculatrice mécanique qui

repose sur l’utilisation de cartes perforées et qui fait la distinction entre unité de
calcul et unité de mémoire.

Babbage échoue dans la mise en œuvre de sa machine car les techniques

d’usinage de l’époque ne sont pas assez précises.
 Un peu d’histoire…
•Calculateurs électromécaniques (1930 ~ 45) :

Exemple du Z3 (1941) : les 2000 relais fonctionnaient

à une fréquence d’horloge de 5 à 10 Hz. Le code et les
données étaient stockées sur des rubans perforés en
celluloïd. Il pouvait effectuait 4 additions par seconde ou
une multiplication en 4 secondes.

•Calculateurs électroniques (1945 ~ 55) :

Exemple de l’ENIAC (1956) : 10.000 condensateurs, 17.000

tubes à vide, 70.000 résistances, 5 millions de soudures, 30 tonnes,
150 m2. Il pouvait effectuer 5000 additions par
seconde et seulement 357 multiplications ou 38 divisions
par seconde. Applications militaires (balistique, bombe A).
 Un peu d’histoire…
•Ordinateurs à transistors (1955 ~ 70) :

Exemple du PDP-1 (1959) : Doté d’un écran à tube cathodique,

c’est le premier ordinateur interactif, assez proche dans son
utilisation des micro-ordinateurs vendus 20 ans plus tard. Le
premier jeu vidéo (Space War) a été programmé sur cette
machine.

•Ordinateurs à microprocesseurs (1970 ~ ) :

Exemple du MICRAL-80 (1980) : Equipé d’un Zilog Z80

ou d’un Intel 8080 à 3Mhz, doté d’une mémoire de 64 à
256 Ko, de deux lecteurs de disquettes 5.25’’ et d’un
écran monochrome. Destiné à l'éducation nationale, il fut vendu à
un prix exorbitant (46.400 Francs).
 Un peu d’histoire…
•Un des premiers micro-ordinateurs (1975) :

L’Altair 8800 est un micro-ordinateur basé sur le µP Intel 8080 et

vendu en kit à quelque milliers d’exemplaires. Deux pionniers de la
micro-informatique, Bill Gates et Paul Allen, découvrent l’Altair
dans une revue et proposent à la société MITS de développer le
langage “Altair Basic”. Paul Allen et Bill Gates fondent alors
immédiatement une société au nom de Microsoft, et passent un
accord de commercialisation avec MITS pour toucher 35 dollars
(~100€ en 2012) par copie de leur logiciel vendu avec chaque
Altair… La suite vous la connaissez ?

Un micro-ordinateur est un ordinateur conçu autour d’un micro-processeur sur une base de circuit imprimé
comportant des circuits intégrés (puces de silicium) => optimisation + miniaturisation = faible coût
 Qu’est-ce qu’un ordinateur ?
•Les ordinateurs peuvent prendre de multiples apparences…
•Mais leur architecture interne et leur fonctionnement reste les mêmes
•Ces machines sont conçues selon l’architecture dite de Von Neumann
Certains ordinateurs ne tiennent pas sur une table :

SGI Altix / 4700 cores / 62 Teraflops = 62 x 1012 opérations / seconde

 Architecture de Von Neumann (1946)
•Un ordinateur est un système de traitement de l’information qui peut :
•Recevoir des informations et les encoder (périphériques d’entrée)
•Mémoriser temporairement des informations (mémoire vive)
•Sauvegarder et retrouver des informations (supports de stockage)
•Effectuer des traitements sur ces informations (microprocesseur)
•Produire des informations décodées (périphériques de sortie)
•Communiquer avec d’autres systèmes (périphériques d’entée/sortie)
 Architecture de Von Neumann (1946)
•Microprocesseur : exécute le programme pas à pas mais très rapidement
•Périphériques d’entrée : clavier, souris, trackpad, microphone, etc.
•Périphériques de sortie : écran, imprimante, haut-parleur, etc.
•Mémoire vive : mémoire très rapide mais volatile (mémoire RAM, DRAM)
•Mémoire de masse : mémoire lente mais permanente (disque, clé USB, etc.)
 Ou est le programme ?
•Le programme est chargé dans la mémoire RAM avec les données
•Le microprocesseur consulte une instruction du programme et l’exécute
•Cette opération est effectuée plusieurs millions de fois par seconde !
Surchauffe du processeur Un disque dur en action

http://www.youtube.com/watch?v=y39D4529FM4

http://www.youtube.com/watch?v=9eMWG3fwiEU
D’où vient le terme « ordinateur » ?

•En 1954, la compagnie IBM-France (International Business Machines) cherche

un néologisme pour désigner ce que l’on appelle alors un « calculateur »
•Jacques Perret (1906-1992), professeur de philologie latine à la Sorbonne,
propose un mot du vocabulaire théologique tombé en désuétude :
« ordinateur » (désigne Dieu qui met de l’ordre dans le monde)
•Protégé pendant quelques mois par IBM-France, le mot fut rapidement adopté
par les spécialistes et par l’administration, puis passa dans le domaine public

> Lettre de J. Perret

 Chapitre 1 (suite)

Le langage Python
 Python est un langage de
programmation
•Initialement développé par Guido van Rossum
•Nom donné en hommage aux Monty Python
•Multi-plateformes et multi-paradigmes :
•Programmation impérative, objet, fonctionnelle
•Bon compromis entre simplicité et puissance
•Outils de haut niveau + syntaxe relativement simple
•Typage dynamique fort + ramasse-miettes
•La gestion de la mémoire est automatisée
•Types de données structurés :
•Tuples, ensembles, listes, dictionnaires
•Système de gestion des exceptions
prompt$ python
Python 3.4.1 (v3.4.1:c0e311e010fc, May 18 2014, 00:54:21)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "copyright", "credits" or "license()" for more information.
>>> �
What
Next ?
prompt$ python
Python 3.4.1 (v3.4.1:c0e311e010fc, May 18 2014, 00:54:21)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "copyright", "credits" or "license()" for more information.
>>> x = 1
>>> print(x)
1 Il s’agit d’une utilisation en mode interactif :
>>> x = x + 1 vous tapez directement dans le terminal une ligne
>>> print(x) après l’autre et vous obtenez la réponse après
2
>>> exit() chaque « retour-chariot »

Ceci est un bon test afin de s’assurer que vous

avez correctement installé Python.

Remarquez qu’il est aussi possible de taper quit()

pour terminer la session interactive.
 Eléments de Python
•Vocabulaire / Mots : Variables et mots réservés (chapitre 2)
•Structure de phrase : Modèles de syntaxe valide (chapitres 3-5)
•Structure de l’histoire : Programmer dans un but particulier

Tout usage illégal d’un mot réservé ou toute formulation qui ne respecte
pas la syntaxe de Python provoque une SyntaxError :
 Mots réservés (vocabulaire)
•Vous ne pouvez pas utiliser ces mots réservés du langage en tant
que noms de variables / de fonctions (identificateurs) :

and del from None True as elif global

nonlocal try assert else if not while
n 3 . 3
P y t ho break except import or with class False
in pass yield continue finally is raise
def for lambda return
 Lignes de code (instructions)

x = 2 Instruction d’affectation
x = x + 2 Affectation d’une expression
print(x) Affichage (sur l’écran)

Variable Opérateur Constante Fonction

Scripts (programmes)

•Python en mode interactif peut être pratique pour tester des expressions
ou des programmes de 3-4 lignes mais…
•La plupart des programmes sont beaucoup plus longs, c’est pourquoi nous
les écrivons dans un fichier afin que python exécute les instructions à partir
de ce fichier
•D’une certaine manière nous « donnons un script à Python »
•Par convention, nous ajoutons le suffixe « .py » à la fin de ces fichiers pour
indiquer qu’ils contiennent des instructions Python
 Flux d’exécution

•Tout comme une recette ou une chorégraphie, un programme est une

séquence d’étapes à effectuer dans un certain ordre
•Certaines étapes sont conditionnelles = elles peuvent être « sautées »
•Parfois une étape (ou un groupe d’étapes) doivent être répétés
•Il est également possible d’identifier un groupe d’étapes susceptibles
d’être réutilisées à différents endroits du programme

> Chapitre 4
 Etapes Séquentielles
x=2
Programme : Affichage :
print(x)
x = 2
x=x+2 print(x) 2
x = x + 2
print(x) print(x) 4

Quand un programme s’exécute, il passe d’une étape à la

suivante. En tant que programmeurs, nous mettons en
place des « chemins » que le programme doit suivre. > Chapitre 2
 x=5 Etapes Conditionnelles
oui
X < 10 ? Programme : Affichage :
non print('Smaller') x = 5
if x < 10 :
oui print('Smaller') Smaller
X > 20 ? if x > 20 :
print('Bigger')
non print('Bigger')

print('OK') OK
print('OK')
> Chapitre 3
 n=5
Etapes Répétées
non oui Programme : Affichage :
n>0?

n = 5 5
print(n)
while n > 0 : 4
print(n) 3
n=n-1
n = n – 1 2
1
print('FEU') FEU

print('FEU')
> Chapitre 5
 Python 2 ou Python 3 ?
•Les langages informatiques évoluent (souvent dans le bon sens) :

•Parfois il y a une « compatibilité ascendante »

•Parfois il y a une « rupture de compatibilité »

•Les programmes écrits en Python 2 ne sont pas complètement

compatibles avec les interpréteurs Python 3 (et inversement)…

•Pour l’informatique en Licence, nous avons opté pour Python 3

Attention : beaucoup de tutoriels et de forums traitent de Python 2

 Remerciements / Contributions

Thes slides are Copyright 2010- Charles R. Severance () of the University of Michigan School of Information and and made available under a Creative
Commons Attribution 4.0 License. Please maintain this last slide in all copies of the document to comply with the attribution requirements of the license.
If you make a change, feel free to add your name and organization to the list of contributors on this page as you republish the materials.

Initial Development: Charles Severance, University of Michigan School Of Information

Translation : Frederic Foiry

Revision : Stephanie Kamidian
Adaptation : Jérôme Lehuen
 Chapitre 2

Constantes, Variables, Types,

Expressions, Entrées-sorties
 Constantes littérales
• Les valeurs fixes telles que les nombres, les lettres (caractères)
et les chaînes de caractères sont appelées constantes littérales
parce que leur valeur (donnée par le texte) ne peut pas changer
• Les valeurs numériques sont écrites naturellement
• Les chaînes de caractères utilisent des >>> print(123)
apostrophes simples ' ou doubles " 123
>>> print(98.6)
98.6
>>> print('Hello world')
Hello world
 Variables
• Une variable est un « emplacement nommé » dans la mémoire où
un programmeur peut stocker des données (une à la fois) et les
récupérer en utilisant le nom (identificateur) de la variable

• Il appartient aux programmeurs de choisir le nom des variables

• Le « contenu » (valeur) d’une variable change à chaque affectation

x = 12.2 x 12.2 100

y = 14
x = 100 y 14
 Règles de nommage
des variables Python
• Commencent obligatoirement par une lettre ou un underscore _

• Contiennent des lettres, des chiffres et des underscores

• Sont sensibles à la case (majuscule / minuscule)

• Bon : spam eggs spam23 _speed alert_on

• Mauvais : 23spam #sign var.12

• Différents : spam Spam SPAM

 Que fait ce programme ?
x1q3z9ocd = 35.0 a = 35.0 heures = 35.0
x1q3z9afd = 12.50 b = 12.50 taux = 12.50
x1q3p9afd = x1q3z9ocd * x1q3z9afd c = a * b paye = heures * taux
print(x1q3p9afd) print(c) print(paye)

Moralité : choisissez
intelligemment le nom
de vos variables !
 Des variables qui « parlent »
• Depuis qu’il est donné le choix, à nous programmeurs, de choisir le
nom des variables, il y a quelques “bonnes pratiques” à respecter
• Nous nommons les variables de telle sorte que nous puissions nous
rappeler ce qu’elles stockent (identificateurs mnémoniques)
• Ceci peut dérouter les étudiants débutants parce que des variables
bien nommées “sonnent” souvent si bien que celles-ci leur semblent
être des mots-clés…

http://en.wikipedia.org/wiki/Mnemonic
 Mots réservés (vocabulaire)
• Vous ne pouvez pas utiliser ces mots réservés du langage en
tant que noms de variables / de fonctions (identificateurs) :

and del from None True as elif global

nonlocal try assert else if not while
break except import or with class False
in pass yield continue finally is raise
def for lambda return
 Lignes de code (instructions)

x = 2 Instruction d’affectation
x = x + 2 Affectation d’une expression
print(x) Affichage (sur l’écran)

Variable Opérateur Constante Fonction

 Instruction d’affectation
• Nous attribuons une valeur à une variable avec l’instruction
d’affectation =

• Une affectation est composée d’une expression (à droite) et d’une

variable (à gauche) qui va stocker le résultat de l’évaluation

X = 3.9 * x * ( 1 - x )

• Tout ce qui renvoie quelque chose (possède une valeur) est

une expression (constante, variable, opération, appel de fonction)
Au début, la valeur de la
variable x est 0.6 x 0.6

0.6 0.6
x = 3.9 * x * ( 1 - x )

L’expression est à droite 0.4

L’expression est évaluée

0.93

Le résultat est placé dans x

Après l’affectation, la valeur de
la variable x est 0.93 x 0.6 0.93

l e u r 0 . 6
La v a
xi s te p l u s x = 3.9 * x * ( 1 - x )
n’ e

L’expression est à droite

L’expression est évaluée 0.93

Le résultat est placé dans x

 Expressions Numériques
Operateur Opération
• En raison du manque de symboles
mathématiques sur les claviers + Addition

d’ordinateur nous utilisons le « dialecte - Soustraction

de l’ordinateur » pour exprimer les * Multiplication
opérations mathématiques classiques
/ Division

• L’astérisque est la multiplication // Division entière

• L’exposant (élévation à la puissance) est ** Puissance

représenté par la double astérisque % Modulo

 Expressions Numériques
Operateur Opération
>>> a = 2 >>> e = c // 1000
>>> b = a + 2 >>> print(e) + Addition
>>> print(b) 5 - Soustraction
4 >>> f = c % 1000
>>> c = 440 * 12 >>> print(f) * Multiplication
>>> print(c) 280 / Division
5280
>>> d = c / 1000 // Division entière
>>> print(d) 5280 1000
5.28 ** Puissance

Modulo
280 5 Quotient % Modulo
(reste) entier
 Evaluation des expressions
• Quand nous utilisons plusieurs opérateurs ensemble, il faut
savoir dans quel ordre les opérateurs sont appliqués…

• Cet ordre est défini par des règles de priorité des opérateurs

• Dans quel ordre les opérateurs suivants sont-ils appliqués ?

x = 1 + 2 ** 3 // 4 * 5
 Règles de priorité
Priorité la plus haute à la plus basse :

>Les parenthèses sont toujours respectées

>L’exposant (élévation à la puissance) Parenthèses

Puissances
>Multiplication, division et modulo (reste) Multiplications & div
Additions & sous
>Addition et soustraction De gauche à droite

>De gauche à droite

 Règles de priorité
1 + 2 ** 3 // 4 * 5
>>> x = 1 + 2 ** 3 // 4 * 5
>>> print(x)
11 1 + 8 // 4 * 5
>>>
1+2*5
Parenthèses
Puissances
Multiplications & div 1 + 10
Additions & sous
De gauche à droite
11
 Parenthèses

Règles de priorité Puissances

Multiplications & div
Additions & sous
De gauche à droite

• Souvenez-vous des règles (du haut vers le bas)

• Quand vous écrivez du code => utilisez les parenthèses

• Quand vous écrivez du code => gardez les expressions

mathématiques assez simple pour être comprises

• Décomposez de longues séries d’opérations mathématiques

afin de les rendre plus lisibles
 Qu’est-ce qu’un type ?
>>> v1 = 1 + 4
• En Python, les constantes littérales >>> print(v1)
et les variables sont typées 5
>>> v2 = 'hello ' + 'there'
>>> print(v2)
• Python fait la différence entre un hello there
>>> v3 = 'abc' * 5
entier et une chaîne de caractères >>> print(v3)
abcabcabcabcabc
• C’est grâce à cette différence que…

+ signifie « addition » pour les nombres et « concaténation » pour les chaînes

* signifie « multiplication » pour les nombres et « concaténation multiple » pour les chaînes
 Qu’est-ce qu’un type ?
• Certaines opérations sont >>> v1 = 'hello ' + 'there'
interdites : >>> v2 = v1 + 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
• Par exemple, il n’est pas possible TypeError: cannot concatenate 'str' and
'int' objects
d’ajouter un nombre à une chaîne >>> type(v1)
<class 'str'> string (chaine)
• Nous pouvons demander à Python >>> type('hello')
<class 'str'>
le type de quelque chose en >>> type(1)
utilisant la fonction type() <class 'int'> integer (entier)
>>> type(1.0)
<class 'float'> virgule flottante
>>>
Conversions de type
• Quand nous utilisons des entiers et des >>> print(2 * 2.5)
5.0
nombres à virgule flottante dans une >>> n = 42
expression, les entiers sont implicitement >>> type(n)
<class 'int'>
convertis en float >>> f = float(n)
>>> print(f)
Le type float est « contaminant » 42.0
>>> type(f)
<class 'float'>
• On peut également forcer une conversion >>> i = int(f)
de type avec les fonctions int() et float() >>> print(i)
42
>>> type(i)
<class 'int'>
Type d’une division
• Exercices :
Type du Type de Type du Type du
>>> print(4 / 2) dividende la division diviseur quotient
2.0
>>> print(4 // 2) int int
2 int float
/ float
float int
>>> print(4.5 / 2) float float
2.25
>>> print(4.5 // 2) int // int int
2.0
>>> print(int(4.5) / 2) int float
2.0 float // int float
>>> print(int(4.5) // 2) float float
2
Le type float est « contaminant »
 Conversion >>> sval = '123'
>>> type(sval)

des chaînes
<class 'str'>
>>> print(sval + 1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
• On peut utiliser int() ou float() TypeError: Can't convert 'int' object to
str implicitly
pour effectuer la conversion
d’une chaîne vers un entier ou >>> ival = int(sval)
>>> type(ival)
vers un float : <class 'int'>
>>> print(ival + 1)
124
• On obtient une erreur si la
chaîne contient autre-choses >>> sval= 'hello bob'
>>> ival = int(sval)
que des chiffres : Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int()
with base 10: 'hello bob'
 Instructions d’E/S
name = input('Qui êtes-vous ?')
• La fonction input() bloque le print('Bienvenue', name)
déroulement du programme et
attend une saisie au clavier. Elle
retourne une chaîne de caractères

• La fonction print() permet d’afficher Qui êtes-vous ?

des données (constantes, variables, Chuck
expressions) séparées par des
Bienvenue Chuck
virgules (une virgule = un espace)
 Les sorties formatées
• Python possède une fonctionnalité de formatage des chaînes de
caractères à l’aide de l’opérateur %

chaîne à formater % variable, expression ou « tuple »

>>> prenom = 'Jérôme' >>> num = 41 tuple

>>> print('Bonjour %s' % prenom) >>> rue = 'rue des Fauvettes'
Bonjour Jérôme >>> pos = 72000
>>> vil = 'Le Mans'
>>> v1 = 745.8112
>>> v2 = 745.8183 >>> adr = '%i %s %i %s' % (num,rue,pos,vil)
>>> print('Résultat = %.2f' % v1) >>> print(adr)
Résultat = 745.81 41 rue des Fauvettes 72000 Le Mans
>>> print('Résultat = %.2f' % v2)
Résultat = 745.82
 Conversion des entrées
• Si nous voulons lire un an_cour = 2015
nombre de l’utilisateur, an_nais = input('Année de naissance :')
age = an_cour - int(an_nais)
nous devons le convertir print('Vous avez', age, 'ans')
de chaîne à nombre avec
la fonction int()

Plus tard nous verrons Année de naissance : 1968

comment traiter les Vous avez 47 ans
« mauvaises » entrées…
 Les commentaires en Python
• Tout ce qui suit # est ignoré par Python (enfin, presque…)

• A quoi servent les commentaires ?

>A expliquer ce qui se passe dans une portion de code

>A documenter qui a écrit le code ou d’autres informations

>A désactiver une ligne de code (peut-être temporairement)

# Get the name of the file and open it
filename = input('Nom du fichier: ')
with open(filename, 'r') as file:
text = file.read()
words = text.split()

# Count word frequency

counts = dict()
for word in words:
counts[word] = counts.get(word,0) + 1

# Find the most common word

bigword,bigcount = None,None
for word,count in counts.items():
if bigcount == None or count > bigcount:
bigword,bigcount = word,count

# Print the result

print(bigword, bigcount)
 Encodage du code source
• En informatique, les chaînes de caractères sont mémorisées selon
une norme de codage MAIS il y a plusieurs normes de codage :

Windows-1252 UTF-8 ISO-8859-1

ASCII
MacRoman
UTF-16
ISO-8859-6 UTF-32
• Pour éviter tout problème, vous sauvegarderez vos fichier en UTF-8
et vous préciserez l’encodage au tout début de vos programmes :

# -*- coding: utf-8 -*-

 Remerciements / Contributions

Thes slides are Copyright 2010- Charles R. Severance (www.dr-chuck.com) of the University of Michigan School of Information and open.umich.edu
and made available under a Creative Commons Attribution 4.0 License. Please maintain this last slide in all copies of the document to comply with the
attribution requirements of the license. If you make a change, feel free to add your name and organization to the list of contributors on this page as you
republish the materials.

Initial Development: Charles Severance, University of Michigan School Of Information

Translation : Frederic Foiry

Revision : Stephanie Kamidian
Adaptation : Jérôme Lehuen
 Chapitre 3

Structures Conditionnelles
Expressions Booléennes
Gestion des Exceptions
 x=5 Etapes Conditionnelles
oui
X < 10 ? Programme : Affichage :
non print('Smaller’) x = 5
if x < 10 :
oui print('Smaller') Smaller
X > 20 ? if x > 20 :
print('Bigger')
non print('Bigger’)

print('OK') OK
print('OK’)
 Opérateurs de Comparaison
Opérateur
• Les expressions Booléennes Signification
binaire
permettent de contrôler le < Inférieur à
déroulement du programme
<= Inférieur ou égal à
• Les expressions Booléennes == Egal à
utilisent les opérateurs de Supérieur ou égal
>=
comparaison et retournent les à
valeurs vrai / faux (oui / non) Ne >
confondezPlus
pas grand
= que
et
lorsqu’elles sont évaluées != Différent de
==
• Les opérateurs de comparaison Opérateur unaire Signification
contrôlent les variables mais not négation
ne les modifient pas !!!
http://en.wikipedia.org/wiki/George_Boole
 Opérateurs de Comparaison
x = 5 Affichage à l’écran :
if x == 5 :
print('Egal à 5') Egal à 5
if x > 4 :
print('Plus grand que 4') Plus grand que 4
if x >= 5 :
print('Plus grand ou égal à 5') Plus grand ou égal à 5
if x < 6 :
print('Inférieur à 6') Inférieur à 6
if x <= 5 :
print('Inférieur ou égal à 5') Inférieur ou égal à 5
if x != 6 :
print('Différent de 6') Différent de 6
 Décisions “tout ou print('Avant test
rien” 5')

x = 5 oui
print('Avant test 5') Avant test 5 x == 5
if x == 5 :
print('Egal à 5') Egal à 5 non print('Egal à 5')
print('Toujours 5') Toujours 5
print('Encore 5') Encore 5
print('Toujours
print('Après test 5') Après test 5 5')

print('Avant test 6') Avant test 6 print('Encore 5')

if x == 6 :
print('Egal à 6')
print('Toujours 6')
print('Encore 6')
print('Après test
print('Après test 6') Après test 6 5')
 Parlons d’indentation…
• Augmenter l’indentation après le mot-clé if pour définir le début du
bloc
• Maintenir l’indentation pour indiquer la portée du bloc
• Ramener l’indentation au niveau du mot-clé if pour définir la fin du
bloc
• Les lignes blanches (vides) sont ignorées : elles n’affectent pas
l’indentation

• ATTENTION : Ne mélangez pas tabulations et espaces !!!

• Vous aurez des « indentation errors » même si tout vous paraît
Décisions x>1
oui

imbriquées non
print('Plus que un')

x = 42 oui
if x > 1 : x < 100
print('Plus que un')
if x < 100 : non print('Moins que
print('Moins que 100')
100')
print('Terminé')

print('Terminé')
Décisions
à deux voies x=4
instruction

ou
x = 4 instruction non
x>2 i
if x > 2 :
print('Bigger')
print('Smaller') print('Bigger')
else :
print('Smaller')

print('All done')

print('All done')
 x = 4 x = 4
Décisions if x > 2 :
print('Bigger')
if x > 2 :
print('Bigger')
à deux voies else :
print('Smaller') print('Smaller')
print('All done') print('All done')

Po u rq u o i x=4 x=4

le « e l s e » non
x>2
ou
i
non
x>2
ou
i

est u t i l e ? print('Bigger') print('Bigger')

print('Smaller') print('Smaller')

print('All done') print('All done')

 x = 4 x = 4
Décisions if x > 2 :
print('Bigger')
if x > 2 :
print('Bigger')
à deux voies else :
print('Smaller')
if not(x > 2):
print('Smaller')
print('All done') print('All done')

x=4

Po u rq u o i x=4
ou
i

»
x>2

le « e l s e non
x>2
ou
i
non

est u t i l e ? print('Bigger')
print('Bigger')

print('Smaller') ou
not(x > i
2)

non
print('All done')
print('Smaller')

print('All done')
Décisions à
voies oui
multiples x<2 print('Small')
no
n
oui
if x < 2 : x < 10 print('Medium')
print('Small') no
elif x < 10 : n
print('Medium')
else : print('LARGE')
print('LARGE')
print('All done')

print('All done')
Décisions à x=0

voies oui
multiples x<2 print('Small')
no
n
X = 0 oui
if x < 2 : x < 10 print('Medium')
print('Small') no
elif x < 10 : n
print('Medium')
else : print('LARGE')
print('LARGE')
print('All done')

print('All done')
Décisions à x=5

voies oui
multiples x<2 print('Small')
no
n
X = 5 oui
if x < 2 : x < 10 print('Medium')
print('Small') no
elif x < 10 : n
print('Medium')
else : print('LARGE')
print('LARGE')
print('All done')

print('All done')
Décisions à x = 20

voies oui
multiples x<2 print('Small')
no
n
X = 20 oui
if x < 2 : x < 10 print('Medium')
print('Small') no
elif x < 10 : n
print('Medium')
else : print('LARGE')
print('LARGE')
print('All done')

print('All done')
Que pe n s er d e
ces
struc tu r e s ?
if x < 2 : if x < 2 :
print('Below 2') print('Below 2')
elif x >= 2 : elif x < 20 :
print('Two or more') print('Below 20')
else : elif x < 10 :
print('Something else') print('Below 10')
else :
print('Something else')
Que pe n s er d e
ces
struc tu r e s ?
if x < 2 : if x < 2 :
print('Below 2') print('Below 2')
elif x >= 2 : elif x < 20 :
print('Two or more') print('Below 20')
else : elif x < 10 :
print('Something else') print('Below 10')
else :
print('Something else')
Les lignes en rouge ne sont pas accessibles !
Pour vérifier une structure, construire son
« puzzle »
 Chapitre 3 (suite)

Expressions booléennes
 Les expressions booléennes
• Une expression booléenne est une expression dont les deux seules
valeurs possibles sont True et False
>>> print(3 > 4)
False
• Le type d’une expression booléenne est le type >>> print(3 < 4)
True
booléen noté <class 'bool'> en Python >>> type(3 < 4)
<class 'bool'>
>>> a = 3
• On peut mémoriser et manipuler les expressions >>> b = 4
booléennes à l’aide de variables >>> c = a > b
>>> print(c)
George Boole (1815-1864) est un logicien, mathématicien, philosophe False
britannique. Il est le créateur de la logique moderne, fondée sur une structure >>> type(c)
algébrique et sémantique, que l’on appelle aujourd’hui algèbre de Boole. <class 'bool'>
 Les opérateurs booléens
• Les opérateurs booléens permettent de combiner des expressions
booléennes afin de construire des expressions de + en +
complexes mais dont les valeurs sont toujours True ou False
• On représente souvent les opérateurs booléens par leur table de
vérité :
A not A A B A and B A B A or B
False True False False False False False False
True False False True False False True True
True False False True False True
True True True True True True
 Les opérateurs booléens
• Comme pour les expressions numériques, il est conseillé de
combiner opérateurs et parenthèses lorsque les expressions se
complexifient :
valide = ((a > b) and (b > c)) or (a == 0)

• Toute expression booléenne (simple ou complexe) peut être utilisée

comme condition dans une structure conditionnelle :
if not(valide):
...
...
 Chapitre 3 (suite)

Gestion des Exceptions

 Il y a des erreurs qu’on ne peut pas
éviter :
an_cour = 2015
an_nais = input('Année de naissance :')
age = an_cour - int(an_nais)
print('Vous avez %i ans' % age) … on les appelle
des exceptions

Année de naissance : 1968 Année de naissance : SALUT

Vous avez 47 ans Traceback (most recent call last):
File "/Users/lehuen/Desktop/test.py", line 4, in <modu
age = an_cour - int(an_nais)
ValueError: invalid literal for int() with base 10: 'SALUT
En revanche, on peut les anticiper et les
gérer :
• Pour les gérer on dispose de la structure try / except pour la quelle il
faut :
• Identifier la portion de code où l’exception peut survenir (être
levée)
• Ecrire le code à exécuter s’il n’y a pas d’exception (traitement
# -*-
normal) coding: utf-8 -*-
an_cour = 2015
• Ecrire le code
an_nais à exécuter en
= input('Année decas d’exception
naissance :') (traitement
try:
exceptionnel)
age = an_cour - int(an_nais)
print('Vous avez %i ans' % age)
except:
print("Erreur: vous n'avez pas saisi une année")
 La gestion des exceptions
an_nais = input('Année:')
Filet de
sécurité
# -*- coding: utf-8 -*- age = an_cour - int(an_nais)

an_cour = 2015
an_nais = input('Année:')
print('Vous avez %i ans' % age)
try:
age = an_cour - int(an_nais)
print('Vous avez %i ans' % age)
print('Erreur')
except:
print('Erreur: pas une année')

print('Terminé') print('Terminé')
 Remerciements / Contributions

Thes slides are Copyright 2010- Charles R. Severance (www.dr-chuck.com) of the University of Michigan School of Information and open.umich.edu
and made available under a Creative Commons Attribution 4.0 License. Please maintain this last slide in all copies of the document to comply with the
attribution requirements of the license. If you make a change, feel free to add your name and organization to the list of contributors on this page as you
republish the materials.

Initial Development: Charles Severance, University of Michigan School Of Information

Translation : Frederic Foiry

Revision : Stephanie Kamidian
Adaptation : Jérôme Lehuen
 Chapitre 4

Fonctions prédéfinies et
définies par l’utilisateur
Les fonctions en Informatique
sin(x) f(x) = x * sin(x)

• Comme en maths, on peut considérer deux familles de fonctions :

>Les fonctions prédéfinies qui sont fournies avec le langage

>Les fonctions définies par l’utilisateur (le programmeur en fait)

• Contrairement à une fonction mathématique, une fonction en

informatique ne renvoie pas forcément un résultat, elle peut juste
avoir des effets de bord (affichages, traitements en mémoire)
Les fonctions en Informatique
• On peut voir les fonctions comme des « boites noires » qui savent
effectuer des calculs ou des traitements particuliers :

Entrée typée Fonction Sortie typée

(arguments) (résultat)

Effets de bord
• Dans la boite, il y a du code informatique mais ce n’est pas
nécessaire de le connaître, il faut juste savoir comment l’utiliser
 Quelques fonctions Python
>>> print(float(3))
entier
ou flottant flottant 3.0
float()
ou chaîne >>> print(float('3'))
3.0
>>> print(sin(pi/2))
entier flottant
ou flottant
sin() 1.0
>>> print(random())
0.737897260521
>>> print(random())
random() flottant
0.972452891561
Fonctions avec effets de bord
>>> print('texte: ')
chaîne texte:
ou rien print()
>>> print()

>>> input('texte: ')

affichage
texte: bonjour
>>> n = input('texte: ')
chaîne chaîne texte: hello
ou rien input()
>>> n = input()
hello
affichage + saisie
Une fonction « polymorphe »
>>> print(max('hello world'))
chaîne max() caractère
w
>>> print(max('Hello World'))
r
nombre >>> print(max(5))
max() nombre
nombre TypeError: 'int' object
is not iterable
>>> print(max(5,6))
nombre
nombre nombre 6
max()
nombre >>> print(max(5,6,4))
6
Nombre et types des arguments
• Attention au nombre et aux types des arguments !!!
>Si les types des arguments changent, ce n’est pas forcément la
même fonction pour un même nom de fonction :
float(3) float(3.0) float('3')
max('abc') max(3)
>Si le nombre des arguments change, ce n’est pas forcément la
même fonction pour un même nom de fonction :
max(3) max(3,4)
Les fonctions prédéfinies

https://docs.python.org/3/library/functions.html
Les librairies de Python
• En Python, la plupart des fonctions sont « rangées » par familles :

• Les fonctions mathématiques sont dans la librairie math

• Les générateurs aléatoires sont dans la librairie random
• Les fonctions systèmes sont dans les librairies sys et os

• Pour utiliser ces fonctions, il faut importer leur librairie au début du

programme. Deux syntaxes différentes pour utiliser une librairie :

>>> import math >>> from math import *

>>> print(math.sin(math.pi/2)) >>> print(sin(pi/2))
1.0 1.0
 Chapitre 4 (suite)

Fonctions définies
par l’utilisateur
Définir vos propres fonctions ?
• Si une même portion de code est dupliquée à plusieurs endroits
• Si vous avez conçu et implémenté un algorithme réutilisable

• Alors vous avez intérêt à définir une nouvelle fonction :

def print_lyrics():
print("I'm a lumberjack, and I'm okay.")
print('I sleep all night and I work all day.')
 Définir une fonction
ne signifie pas l’exécuter :
print('Hello') Hello
def print_lyrics(): Yo
print("I'm a lumberjack, and I'm okay.")
print('I sleep all night and I work all day.')

print('Yo')

print('Hello') Hello
print_lyrics()
print('Yo') I'm a lumberjack, and…
I sleep all night and…
Yo
 Argument vs. paramètre
• Un argument est une valeur que nous transmettons à la fonction
comme entrée (donnée) au moment de l’appel de la fonction

• Un paramètre est une variable que nous utilisons dans la définition

de la fonction et qui prend la valeur d’un argument lors de l’appel

def greet(lang): >>> greet('en')

if lang == 'es': Hello
print('Hola') >>> greet('es')
elif lang == 'fr': Hola
print('Bonjour') >>> greet('fr')
else: Bonjour
print('Hello')
 Portée des paramètres
• La portée d’une variable correspond à la portion de code dans
laquelle la variable en question possède une valeur

• La portée des paramètres d’une fonction correspond à la définition

de la fonction => en dehors, les paramètres ne sont pas définis

def greet(lang): >>> greet('fr')

if lang == 'es': Bonjour
print('Hola') >>> print(lang)
elif lang == 'fr': Traceback (most recent call last):
print('Bonjour') File "Untitled.py", line 10, in <module>
else: print(lang)
print('Hello') NameError: name 'lang' is not defined
Retourner une valeur
• Les fonctions qui retournent (renvoient) un résultat dans l’expression
appelante doivent comporter le mot-clé return
def greet():
return "Hello"

>>> print(greet(), "Glenn")

Hello Glenn

>>> print(greet(), "Sally")

Hello Sally

• Le type d’une fonction correspond au type de la valeur retournée

Retourner une valeur
• Il peut y avoir plusieurs return dans une fonction :

> Exemple d’une fonction qui retourne le mois en toutes lettres à

partir du numéro du mois dans l’année :
def mois(n): def mois(n):
if n == 1: if n == 1:
return('janvier') return('janvier')
elif n == 2: if n == 2:
return('février') return('février')
elif n == 3: if n == 3:
return('mars') return('mars')
... ...

Dès qu’un return est exécuté, le flux d’exécution « sort de la fonction »

 Retourner plusieurs valeurs
• Les fonctions peuvent accepter plusieurs arguments en entrée...

> Est-il possible de retourner plusieurs valeurs en sortie ?

def foobar(a,b): >>> foobar(1,2)
nombre nombre x = a + b (3,-1)
foobar() y = a - b
nombre nombre
return(x,y)

> Comment récupérer les deux valeurs retournées ?

>>> (i,j) = foobar(1,2)
print(i, j) Un TUPLE est un groupe de valeurs
3 -1 réunies au sein d’un même « objet »
Lever des exceptions
• Certaines fonctions peuvent lever (générer) des exceptions :
>>> math.log(-1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: math domain error

> Comment une fonction définie par l’utilisateur peut-elle lever

des exceptions également définies par l’utilisateur ?

• Exemple : (dans la fonction qui retourne le mois) si le numéro du

mois est inférieur à 1 ou supérieur à 12 la fonction doit lever une
exception avec le message « month number out of range »
Lever des exceptions
• Le mot-clé raise génère une exception et stoppe le flux d’exécution
du programme si vous laissez Python la gérer :

def mois(n):
if (n < 1) or (n > 12):
raise Exception('month number out of range’)
if n == 1:
return('janvier')
if n == 2:
return('février')
...

• Mais il est également possible de la gérer avec un try…except

dans le code qui appelle cette fonction (cf. diaporama #3)
Fonctions récursives
• Une fonction récursive est une fonction qui s’utilise elle-même pour
produire un résultat (effet de bord ou valeur retournée) :
def facto(n):
return n * facto(n-1)

>>> print(facto(3))
Traceback (most recent call last):
File "/Users/lehuen/Desktop/test.py", line 4, in <module>
print(facto(3))
...
RuntimeError: maximum recursion depth exceeded

Quel est le problème ???

Fonctions récursives
• Une fonction récursive est une fonction qui s’utilise elle-même pour
produire un résultat (effet de bord ou valeur retournée) :
def facto(n):
if n == 0:
return 1
else:
return n * facto(n-1)

>>> print(facto(3))
6

• Toujours identifier un cas (ou plusieurs) sans appel récursif sinon on

obtient une récursion « infinie » qui génère une erreur ou un plantage
 Fonctions ou pas fonctions ?
• Organisez votre code sous forme de « paragraphes » en
capturant une pensée complète puis « nommez la »

• Si votre code fonctionne quelque part, ne le répétez pas =>

réutilisez le (transformez-le en fonction)

• Si votre code devient trop long ou trop complexe, séparez-le en

parties logiques et faites des fonctions avec ces morceaux

• Construisez une bibliothèque des opérations que vous répétez

continuellement, partagez-la avec vos ami(e)s...
 Remerciements / Contributions

Thes slides are Copyright 2010- Charles R. Severance (www.dr-chuck.com) of the University of Michigan School of Information and open.umich.edu
and made available under a Creative Commons Attribution 4.0 License. Please maintain this last slide in all copies of the document to comply with the
attribution requirements of the license. If you make a change, feel free to add your name and organization to the list of contributors on this page as you
republish the materials.

Initial Development: Charles Severance, University of Michigan School Of Information

Translation : Frederic Foiry

Revision : Stephanie Kamidian
Adaptation : Jérôme Lehuen
 Chapitre 5

Structures Itératives
Les types liste et chaîne
 n=5 Répétition d’opérations
non oui Programme : Affichage :
n>0?
n = 5
print(n) while n > 0 : 5
4
n=n-1 print(n) 3
n = n – 1 2
1
print('FEU') FEU
print('FEU')

Que fait ce programme ?

 n=5 Répétition d’opérations
non oui Programme :
n>0?
n = 5
print(n) Condition de
while n > 0 : la boucle (vraie / fausse)

n=n-1 print(n) Corps de

n = n – 1 la boucle (un bloc)

print('FEU')
print('FEU')
 n=5 Une boucle infinie
non oui
n>0?
n = 5
print('Laver') while n > 0 :
print('Laver')
print('Rincer') print('Rincer')
print('Sécher')

La condition de la boucle est toujours vraie

print('Sécher') => pas de sortie possible de la boucle

Quel est le problème de ce programme ?

 n=0 Une boucle inaccessible
non oui
n>0?
n = 0
print('Laver') while n > 0 :
print('Laver')
print('Rincer') print('Rincer')
print('Sécher')

La condition de la boucle est fausse dès le début

print('Sécher') => pas d’entrée possible dans la boucle

Quel est le problème de ce programme ?

 La boucle while
• Une boucle while permet de répéter un bloc d’instructions en
fonction de la valeur d’une expression booléenne (condition) :

> Si la condition est fausse dès le début, le bloc est « sauté »

> Sinon, le bloc est répété tant que la condition reste vraie

• Il n’est pas toujours facile d’être certain qu’une boucle while se

terminera mais il est facile de vérifier les points suivants :

> La condition de la boucle doit pouvoir changer de valeur

> La modification est effectuée dans le corps de la boucle
 n=5 Variable d’itération
non oui Programme : Affichage :
n>0?
n = 5 5
print(n) while n > 0 : 4
print(n) 3
n=n-1 n = n – 1 2
1
print('FEU') FEU

Les boucles while comportent souvent des variables dont la

print('FEU')
valeur change à chaque itération (passage dans la boucle).
Ces variables d’itération sont souvent numériques : leurs
valeurs successives définissent une séquence de nombres.
 Chapitre 5 (suite)

Le type liste
 Le type Liste
• La liste est un type structuré = une structure de données

• C’est une structure linéaire ordonnée composée de valeurs

quelconques (entiers, flottants, chaînes, etc.) éventuellement
hétérogène
>>> lst = [1,2,3,'hello',3.14]
print(lst)
• En Python, les éléments
[1,2,3,'hello',3.14]
d’une liste sont séparé par >>> type(lst)
des virgules, l’ensemble étant <class 'list'>
enfermé par des crochets : >>> print(len(lst))
5
 Accéder à un élément
• On accède directement à un élément d’une liste en utilisant
son index avec la syntaxe suivante :

L’index du >>> lst = [1,2,3,'hello',3.14]

>>> print(lst[0])
premier 1
élém e nt es t 0 >>> print(lst[3])
hello
>>> print(lst[5])
Impossible Traceback (most recent call last):
d ’ ac c éd e r e n File "<stdin>", line 1, in <module>
dehors d e l a l i s t e IndexError: list index out of range
 Modifier un élément
• Pour modifier un élément on utilise une instruction d’affectation
comme pour une variable :
>>> lst = [1,2,3,'hello',3.14]
>>> lst[3] = 'bonjour'
>>> print(lst)
[1,2,3,'bonjour',3.14]

Imp os s i bl e d e >>> lst[5] = 9999

Traceback (most recent call last):
modifier un File "<stdin>", line 1, in <module>
nt i n e x i s t a nt IndexError: list assignment index out
éléme of range
 Supprimer un élément
• Pour supprimer un élément on applique une instruction del sur cet
élément (attention : pas de parenthèses) :
>>> lst = [1,2,3,'hello',3.14]
>>> del lst[4]
>>> print(lst)
[1,2,3,'hello']
>>> del lst[4]
Im p os s i bl e d e Traceback (most recent call last):
sup p ri m e r u n File "<stdin>", line 1, in <module>
t i n e x i s t a nt IndexError: list assignment index out
élémen of range
 Ajouter un élément
• Pour ajouter un élément on invoque la méthode append sur cet
élément (attention à la syntaxe particulière) :

>>> lst = [1,2,3,'hello',3.14]

Attention à >>> lst.append(9999)
la syntaxe >>> print(lst)
[1,2,3,'hello',3.14,9999]

• Cette syntaxe correspond à l’utilisation d’une méthode en

programmation objet (les listes sont des objets à part entière)
 Les listes de listes
• Une liste pouvant contenir des valeurs de n’importe quel type,
elle peut également contenir des listes :
>>> lst = [[1,2,3],[4,5,6]]
>>> print(lst[0])
[1,2,3]
>>> print(lst[0][1])
2
>>> lst.append([7,8,9])
>>> print(lst)
[[1,2,3],[4,5,6],[7,8,9]]
• On dispose ainsi d’une structure de données à 2 entrées
 Chapitre 5 (suite)

Itérations sur les listes

 La boucle for
• Une boucle for permet de parcourir une liste et exécuter un bloc
d’instructions pour chacun des éléments de la liste :

liste = [1,2,3,'hello',3.14] bonjour 1

for element in liste: bonjour 2
print('bonjour', element) bonjour 3
bonjour hello
bonjour 3.14
> Si la liste est vide, le bloc est « sauté »
> Sinon, le bloc est répété autant de fois qu’il y a d’éléments

• Contrairement à la boucle while, la boucle for s’arrête à coup sûr !

 n=5
Variable d’itération d’une boucle while

non oui Programme : Affichage :

n>0?
n = 5 5
print(n) while n > 0 : 4
print(n) 3
n=n-1 n = n – 1 2
1
print('FEU') FEU

print('FEU')
 lst = [5,4,3,2,1]
Variable d’itération d’une boucle for

non oui Programme : Affichage :

encore ?
lst = [5,4,3,2,1] 5
n = valeur suivante for n in lst : 4
print(n) 3
print(n) 2
1
print('FEU') FEU

print('FEU')
 Pour i allant de 1 à 1000 ?
• La façon la plus naturelle pour réaliser une telle itération est
d’utiliser une boucle while avec une variable d’itération…

• Mais il est également possible d’utiliser une boucle for sur une
liste de 1000 entiers => comment initialiser cette liste ?

i = 1 for i in range(1,1001):
while i < 1001: print(i)
print(i)
i = i + 1 Borne Borne
inférieure supérieure
inclue exclue
 Boucle while ou boucle for ?
• Lorsque nous connaissons à l’avance le nombre d’éléments
sur lesquels on itère => boucle for

• Lorsque nous ne connaissons pas à l’avance le nombre

d’éléments sur lesquels on itère => boucle while

• Ce qu’on peut faire avec une boucle for, on peut le faire avec
une boucle while mais le résultat est un peu plus « verbeux »
 Chapitre 5 (suite)

Le type chaîne
 Qu’est-ce qu’une chaîne ?
• C’est un type de données non modifiables qui permet de
représenter des séquences de caractères Unicode

> Une donnée non modifiable ne peut plus être modifiée une fois créée
> Toute transformation d’une chaîne produit une nouvelle valeur distincte

• On peut voir une chaîne comme une liste de caractères

> On traiter un chaîne en utilisant des fonctions communes aux séquences

> On peut également utiliser des méthodes spécifiques aux chaînes

>>> len('Python 3.5') 10

>>> 'Python 3.5'.upper() 'PYTHON 3.5'
 Opérations sur les chaînes
• Pour indexer une chaîne, on utilise la notation [ ] où l’index
commence à zéro, comme avec les listes
• On peut également extraire des sous-chaînes (ou « tranches ») :

>>> ch = 'Python 3.5' >>> ch[:6]

>>> print(ch[0], ch[3], ch[5]) Python
P h n >>> ch[2:]
>>> ch[2:6] thon 3.5
thon

inclus exclus
 Opérations sur les chaînes
• Exemples de méthodes de test de l’état d’une chaîne :
>>> ch.isupper()
>>> ch.isalpha()
>>> ch.startwith('Py')
>>> ch.endswith('thon')

• Exemples de méthodes retournant une nouvelle chaîne :

>>> ch.lower()
>>> ch.upper()
>>> ch.capitalize()
>>> ch.strip()
 Opérations sur les chaînes
• Quelques autres méthodes en vrac :

>>> ch.find('thon')
>>> ch.replace('thon','tule')
>>> ch.split()
>>> '-'.join(['Python','3.5'])

• Et parce que les chaînes sont avant tout des séquences :

for c in ch:
print(c)
Fin du cours de Python
du premier semestre…