Faculté des Sciences – Tétouan

Introduction Python

Département Informatique- FS Tétouan

Pr. ADIL BEN-HDECH
 Sommaire
 Introduction
 Identificateurs et mots clés
 Variables
 Operateurs
 Operations sur les variables
 Type de données simple
 Fonctions d’entrée/sortie
 Notion de bloc d’instruction
 Les instructions de contrôle

A.BEN-HDECH 2
 Introduction

Choix d’un langage de programmation

 Il existe un très grand nombre de langages de programmation, chacun avec ses

avantages et ses inconvénients. Il faut bien en choisir un.
 Le langage dominant parmi les langages open-source est sans conteste C/C++. Ce
langage s’impose comme une référence absolue, et tout informaticien doit s’y frotter tôt
ou tard.
Il est malheureusement très compliqué, trop proche de la machine.

 Sa syntaxe est peu lisible et fort contraignante.

 Python est un langage portable, dynamique, extensible, gratuit, qui permet (sans
l’imposer) une approche modulaire et orientée objet de la programmation.

A.BEN-HDECH 3
 Introduction

Historique

 1991: Guido van Rossum travaille aux Pays-Bas sur le projet AMOEBA, un système
d’exploitation distribué. Il conçoit Python à partir du langage ABC et publie la version
0.9.0 sur un forum Usenet
 1996 : sortie de Numerical Python, ancêtre de numpy
 2001: naissance de la PSF (Python Software Fundation)
 Les versions se succèdent… Un grand choix de modules est disponible, des colloques
annuels sont organisés, Python est enseigné dans plusieurs universités et est utilisé en
entreprise…
 2006 : première sortie de IPython
 Fin 2008: sorties simultanées de Python 2.6 et de Python 2.3
 Dernières versions: 2.7.17 (la plus stable) et 3.8.1

A.BEN-HDECH 4
 Introduction

Caractéristiques du langage Python

 Langage Open Source

Licence Open Source CNRI, compatible GPL, mais sans la restriction copyleft. Donc Python est libre
et gratuit même pour les usages commerciaux

 GvR (Guido van Rossum) est le « BDFL » (dictateur bénévole à vie !)

Importante communauté de développeurs
Nombreux outils standard disponibles : Batteries included
 Travail interactif
 Nombreux interpréteurs interactifs disponibles (notamment IPython)
Importantes documentations en ligne
Développement rapide et incrémentiel
Tests et débogage outillés
Analyse interactive de données

A.BEN-HDECH 5
 Introduction

Caractéristiques du langage Python

 Langage interprété rapide

Interprétation du bytecode compilé
De nombreux modules sont disponibles à partir de bibliothèques optimisées (souvent écrites en C ou
C++)

 Simplicité du langage :
Syntaxe claire et cohérente
Indentation significative
Gestion automatique de la mémoire (garbage collector)
Typage dynamique fort : pas de déclaration

A.BEN-HDECH 6
 Introduction

Caractéristiques du langage Python

 Orientation objet
 Modèle objet puissant mais pas obligatoire

 Structuration multifichier aisée des applications : facilite les modifications et les extensions

 Les classes, les fonctions et les méthodes sont des objets dits de première classe. Ces objets sont

traités comme tous les autres (on peut les affecter, les passer en paramètre)

 Ouverture au monde
 Interfaçable avec C/C++/FORTRAN
 Langage de script de plusieurs applications importantes

 Excellente portabilité

 Disponibilité de bibliothèques
 Plusieurs milliers de packages sont disponibles dans tous les domaines

A.BEN-HDECH 7
 Introduction

Environnement de développement

 Linux:
 Souvent préinstallé. Pour le vérifier taper la commande «python» dans un terminal
 Sinon, installer le package de la distribution
 Windows:
 Utiliser un assistant d’installation à télécharger à partir du site officiel « www.python.org »
 Mac OS:
 Préinstallé mais en version incomplète; télécharger et installer la version complète à partir du site
www.python.org

A.BEN-HDECH 8
 Introduction

Environnement de développement

 Linux:
 Souvent préinstallé. Pour le vérifier taper la commande «python» dans un terminal
 Sinon, installer le package de la distribution
 Windows:
 Utiliser un assistant d’installation à télécharger à partir du site officiel « www.python.org »
 Mac OS:
 Préinstallé mais en version incomplète; télécharger et installer la version complète à partir du site
www.python.org
 Editeurs Python:
 IDLE: installé par défaut
 Spyder
 pyCharm
 Eric3
 PyDev

A.BEN-HDECH 9
 Introduction

Les modes d’exécution

 Les deux modes d’exécution d’un code Python

Soit on enregistre un ensemble d’instructions Python dans un fichier grâce à un
éditeur (on parle alors d’un script Python) que l’on exécute par une commande ou
par une touche du menu de l’éditeur ;
soit on utilise l’interpréteur l’interpréteur de commandes python. Pour lancer
l’interpréteur de commandes python (Windows) :
Démarrer > Tous les programmes > Python > Python (Commande Line).
(Démarrer + R) > Taper Python > Python (Commande Line).

>>> 5 + 3 Affichage d’une invite. L’utilisateur tape une expression.
8 Évaluation et affichage du résultat.
>>> Réaffichage de l’invite.

A.BEN-HDECH 10
 Identificateurs et mots clés

Identificateurs

 Définition :
Un identificateur Python est une suite non vide de caractères, de longueur quelconque,
formée d’un caractère de début et de zéro ou plusieurs caractères de continuation.
 Sachant que :
le caractère de début peut être n’importe quelle lettre Unicode , y compris le caractère souligné (_) ;
 un caractère de continuation est un caractère de début ou un chiffre.
 Remarques :
Les identificateurs sont sensibles à la casse et ne doivent pas être un mot réservé de
Python 3

A.BEN-HDECH 11
 Identificateurs et mots clés

Les mots réservés de Python

and del from None

as elif global nonlocal True
assert else if not try
break except import or while
class False in pass with
continue finally is raise yield
def for lambda return

A.BEN-HDECH 12
 Variables

Définition

 Une variable est une zone de la mémoire de l’ordinateur dans laquelle une valeur est
stockée. Cette variable est définie par un identifictauer, alors que pour l’ordinateur, il
s’agit en fait d’une adresse, c’est-à-dire d’une zone particulière de la mémoire.
 Le nom de la variable ne peut pas commencer par un chiffre.
 Affectation: avec «=»
 Le langage Python est sensible à la casse, ce qui signifie que des lettres majuscules et
minuscules ne constituent pas la même variable.
 la déclaration d’une variable et son initialisation (c’est-à-dire la première valeur que l’on
va stocker dedans) se font en même temps.

A.BEN-HDECH 13
 Variables

Déclaration et initialisation des variables

 La déclaration d'une variable ne suffit pas à la créer. Après avoir choisi son nom, il est
nécessaire de lui affecter une valeur initiale.
 Exemple

monChiffre=7
petitePhrase= " Bonjour les étudiants de IWA"
pi=3 .14159

A.BEN-HDECH 14
 Operateurs

Affectation

 On affecte une variable par une valeur en utilisant le signe = . Dans une affectation, le
membre de gauche reçoit le membre de droite ce qui nécessite d’évaluer la valeur
correspondant au membre de droite avant de l’affecter au membre de gauche

>>> v = 4 # affectation simple

>>> v += 2 # affectation augmentée. Idem à v = v + 2 si v est déjà référencé
>>> v
6
>>> c = d = 8 # d reçoit 8 puis c reçoit d (c et d sont des alias)
>>> c, d
(8, 8)
>>> e, f = 2.7, 5.1 # affectation parallèle d’un tuple
>>> (e, f)
(2.7, 5.1)
>>> g, h = [’G’, ’H’] # affectation parallèle d’une liste
>>> [g, h]
[’G’, ’H’]
>>> a = 3
>>> a, b = a + 2, a * 2 # toutes les expressions sont évaluées avant la première
affectation
>>> a, b
(5, 6)

A.BEN-HDECH 15
 Operateurs

Opérateurs de comparaison

 Les opérateurs de comparaison renvoient une valeur booléenne True ou False.

Operateur Description Exemple

< Strictement inferieur x<y

> Strictement supérieur x>y

<= inferieur ou égal x <= y

>= Supérieur ou égal x >= y

== égal x==y

!= différent x !=y

X is Y X et Y représente le même objet

X is not Y X et Y ne représente pas le même objet

A.BEN-HDECH 16
 Operateurs

Opérateurs arithmétiques

 Les opérateurs arithmétiques sont utilisés avec des valeurs numériques pour effectuer
des opérations mathématiques courantes:
Operateur Description Exemple

+ Addition x+y

- Soustraction x-y

* Multiplication x*y

/ Division x/y

% Modulo x%y

** Puissance x**y

// Division entière x // y

A.BEN-HDECH 17
 Operateurs

Opérateurs logiques

 Les opérateurs logiques sont utilisés pour combiner des instructions conditionnelles:

Operateur Description Exemple

and Renvoie True si les deux déclarations x > 5 and x<10

sont vraies
or Renvoie True si l'une des déclarations x >5 or x>4
est vraie
not Inverse le résultat not(x > 5 and x<10)

A.BEN-HDECH 18
 Operations sur les variables

Modification et transtypage des variables

 L'instruction d'affectation réalise donc la création et la mémorisation de la variable, l'attribution d'un type
à la variable, la création et la mémorisation d'une valeur et finalement l'établissement d'un lien entre le

nom de la variable et l'emplacement mémoire.

 Exemple
maVariable = 5
maVariable = 2. 567

 Notons au passage que le type de maVariable a changé : il est passé de int à float. Cette spécificité est une
facilité essentielle de plus permise par le langage Python. À la différence d'autres langages de

programmation plus contraignants, Python est dit typé dynamiquement et non statiquement.

A.BEN-HDECH 19
 Operations sur les variables

Copie de variables

 Nous pouvons également prendre le contenu de maVariable et le copier dans taVariable par la simple
instruction :

 Syntaxe

taVariable=maVariable

 Exemple

>>> maVariable=7
>>> taVariable=maVariable
>>> taVariable
7

A.BEN-HDECH 20
 Operations sur les variables

Copie de variables

 Nous pouvons également prendre le contenu de maVariable et le copier dans taVariable par la simple
instruction :

 Syntaxe

taVariable=maVariable

 Exemple

>>> maVariable=7
>>> taVariable=maVariable
>>> taVariable
7

A.BEN-HDECH 21
 Operations sur les variables

Renseignement sur une variable

 Le langage nous offre toute une bibliothèque d'utilitaires. Citons d'ores et

déjà deux fonctions prédéfinies :
 type (maVariable) qui affiche le type de la variable mise entre parenthèses et s'avère
très utile pour vérifier ce qui y a été installé jusqu'ici;
 print(maVariable) qui affiche à l'écran la valeur stockée à l'adresse désignée par la
variable maVariable.
 id(maVariable): identifiant d’un objet
 dir(): liste l’ensemble des fonctionnalités de l’objet

A.BEN-HDECH 22
 Type de données simple

Type de données simple

 On peut identifier plusieurs types d'information (nombres, chaînes de caractères.. .)

peuvent être placés dans une variable et il est capital de connaître comment la valeur qui
s'y trouve a été codée.
 Pas de déclaration explicite du type d’une variable (langage non typé).
 Tout est basé sur l’objet: objet avec identifiant, type et valeur
 Cette distinction correspond à la notion de type:
 Une variable recevant une valeur numérique entière est du type int.

 Une variable recevant un réel sera du type float.

 Une variable recevant au moins un caractère sera du type string.

 type bool a deux valeurs possibles : False, True.

A.BEN-HDECH 23
 Type de données simple

Quelques opérations sur les types simples: type int

 Le code suivant illustre des opérations réalisées dans la console interactive de Python,
sur des variables de type entier (int).

>>> maVariable = 3
>>> print maVariable
3
>>> type(maVariable)
<type 'int ' >
»> taVariable=4
>>> maVariable=taVariable
>>> print maVariable
4
>>> maVariable = saVariable
#Une erreur apparaît car saVariable n'existe pas
Traceback (most recent call last):
File "<input>", line 1, in <module>
maVari able = saVariable
NameError : name 'saVariable' is not defined

A.BEN-HDECH 24
 Type de données simple

Quelques opérations sur les types simples: type int

>>> maVariable = maVariable + 3

>>> maVariable #Dans la console interactive de Python, le seul appel
de
#la variable suffit à donner sa valeur sans qu'il soit nécessaire
#d'utiliser print explicitement.e
7
>>> maVariable = maVariable/2 C>
»> maVariable
3
#Python ne conserve que la valeur entière au vu du type de maVariable
>>> maVariable + 3 = 5 0
SyntaxError : can't assign to operator
#On ne peut pas écrire n'importe quoi et il faut respecter un minimum
de
#syntaxe python.
>>> maVari able+=3 f)#Raccourci d'écriture ! ! !
>» maVariable
6
>>>

A.BEN-HDECH 25
 Type de données simple

Quelques opérations sur les types simples: type float

 Le code suivant illustre des opérations élémentaires sur des réels.

>>> taVariable=3.0
>>> maVariable=taVariable/2 f)
»> maVariable
1. 5
>>> type(maVariable)
<type 'fl oat '>
>>> print (maVariable)
1. 5
>>> print (mavariable)
Traceback (most recent call last) :
File "<input>", line 1, in <module>
print mavariable
NameError : name 'mavariable' is not defined

 Python est sensible à la casse, c'est-à-dire différencie majuscules et minuscules :

maVariab1e et mavariab1e sont deux références différentes.

A.BEN-HDECH 26
 Type de données simple

Les chaines de caractères (str)

 Similaire aux chaines de caractères des autres langages (tableau de caractères)

 Accès aux caractères par index, ie: pour une chaine s, s[i] retourne le ième-1 caractère
 Sont immuables (on ne peut changer leurs valeurs), il est donc interdit d’écrire par
exemple s[0]='a'
 Les constantes sont écrites entre "", ou entre ' '
 On peut écrire des " " dans les chaines délimitées par ' ' et des ' dans les chaines
délimitées par " "
 Exemple:
 en japS= " Je m’appelle Ahmed"

 S= ' le mot " Oni" signifie démon onais '

A.BEN-HDECH 27
 Type de données simple

Les chaines de caractères (str)

 le code suivant illustre des exemples concernant des variables de type string (des
chaînes de caractères).

>>> taVariable=3.0
>>> phrasel="le framework"
>>> phrase2=" Django"
>>> phrasel+=phrase2
»> phrasel
'le framework Django'
>>> phrase2*=3
»> phrase2
' Django Django Django'
>>> print phrase2[1] #On saute le caractère blanc du début de ligne
D
>>> phrase2 += 5
Traceback (most recent call last) :
File "<pyshel1#49>", li ne 1, in <module>
phrase2 += 5
TypeError : cannot concatenate 'str' and 'int' objects
»> phrase2="phrasel" 0
»> phrase2
'phrasel

A.BEN-HDECH 28
 Type de données simple

Les chaines de caractères (str)

 Accès aux éléments: chaine de caractères S de taille n

 Le premier caractère est S[0] et le dernier S[n-1]

 S[i] retourne le ième -1 élément de S

 S[-i] retourne le ième élément de S en partant de la fin. (à la position n-i)

 Sous chaines
 S[i:j] donne la sous-chaine composée des caractères aux positions i, i+1, …, j-1

 S[:j] donne la sous-chaine composée des caractères aux positions 0, 1, …, j-1

 S[j:] donne la sous-chaine composée des caractères aux positions j, j+1, …, n-1

A.BEN-HDECH 29
 Type de données simple

Les chaines de caractères (str)

 Opérations
— Longueur :
>>> s = ”abcde”
>>> len(s)
5

— Concaténation :
>>> s1 = ”abc”
>>> s2 = ”defg”
>>> s3 = s1 + s2
>>> s3
’abcdefg’

— Répétition :
>>> s4 = ”Fi! ”
>>> s5 = s4 * 3
>>> s5
’Fi! Fi! Fi!

A.BEN-HDECH 30
 Type de données simple

Les chaines de caractères (str)

 s.isalnum() # retourne vrai si tous les caractères sont alphanumériques

 s.isalpha() #retourne vrai si tous les caractères sont alphabétiques
 s.isdigit() # retourne vrai si tous les caractères sont des chiffres
 s.replace(old, new)"""retourne une chaine où toutes les occurrences de
old dans s sont remplacées par new """
 s.index(c) #retourne la position de c dans s, -1 s’il n’y existe pas

A.BEN-HDECH 31
 Type de données simple

Les chaines de caractères (str)

 Pour formater une chaine de caractères on utilise sa fonction format

 La chaine en question doit contenir des {}
 Exemple:

a=8.58
b=2
print "{:.2f} + {} = {:.1f} " .format(a, b, a+b) # 8.58 + 2 = 10.6

A.BEN-HDECH 32
 Type de données simple

Conversion de types

 On est souvent amené à convertir les types, c’est-à-dire passer d’un type numérique à
une chaîne de caractères ou vice-versa. Cette conversion est plus simple avec les
fonctions int(), float() et str():
>>> i = 3
>>> str (i)
'3'
>>> i = '456 '
>>> int (i)
456
>>> float (i)
456.0
>>> i = '3.1416 '
>>> float (i)
3.1416

 N.B Contrairement à d'autres langages, Python ne fait pas de différence entre les
apostrophes simples et les doubles

A.BEN-HDECH 33
 Fonctions d’entrée/sortie

Entrées clavier :input()

 L’instruction input() permet de saisir une entrée au clavier

 Elle effectue un typage dynamique (détecté le type de la valeur entrée)
 Accepter une syntaxe input(message) exemple:
>>>n=input("Entrez un entier") # la valeur tapée sera affectée à n
8
>>> type(a)
<type 'str'>

 Pour lire une variable d’un autre type, il faut faire un transtypage(cast)

>>> b=int(raw_input())
5
>>> type(b)
<type 'int'>

A.BEN-HDECH 34
 Fonctions d’entrée/sortie

Sortie écran: print( )

 L’instruction print() permet d’afficher la valeur d’une variable à l’écran

>>> print ("salut") # En version 3.X c’est une fonction
Salut
>>> a="Adil"
>>> print (a)
Adil

 Remarque:
 Elle fait un saut de ligne après l’affichage de la valeur
 Python 3.X: rajouter un paramètre end=" "

>>> print("Hello world!")

Hello world!
>>> print("Hello world!", end="")
Hello world!>>>

A.BEN-HDECH 35
 Fonctions d’entrée/sortie

Les littéraux

 des constantes définissant une valeur:

 Alphanumériques: chaines de caractères entourées par des guillemets simples ou doubles, ou dans
une série de trois guillemets (triple-quoted) simples ou doubles

>>> print ("salut") # affiche salut de même que print ('salut')

>>> print ('salut j'en suis') #affiche erreur de même que print ("salut
j"en suis")
>>> print ("salut j'en suis") #affiche salut j'en suis
>>> print ("""salut j"en suis""") #affiche salut j"en suis
>>> print ('''salut j'en suis''') #affiche salut j’en suis

A.BEN-HDECH 36
 Fonctions d’entrée/sortie

Les littéraux

 Alphanumériques: Préfixer une chaine

 r ou R pour indiquer que le contenu est du texte brut, ainsi le caractère
antislash (\) n’a plus le même usage

>>> print ('c:\nombre')

c:
ombre
>>> print (r'c:\nombre')
c:\nombre

 u ou U pour le texte en caractères Unicode

 b ou B pour le texte en bytes

A.BEN-HDECH 37
 Notion de bloc d’instruction

Définition et structuration

 Ce type d'instruction permet au code de suivre différents chemins suivant les

circonstances. Il s'agit, en quelque sorte, d'un aiguillage dans le programme.
 Une instruction composée se compose :
— d’une ligne d’en-tête terminée par deux-points ;

— d’un bloc d’instructions indenté par rapport à la ligne d’en-tête. On utilise habituellement

quatre espaces par indentation et on ne mélange pas les tabulations et les espaces.

 Toutes les instructions au même niveau d’indentation appartiennent au même bloc

en−tete:
bloc ...........................
................................
d’instructions .................

A.BEN-HDECH 38
 Notion de bloc d’instruction

Définitions et structuration

 Il est possible d’imbriquer des blocs d’instructions les uns dans les autres :
en−tete:
bloc ...........................
................................
en−tete 2:
bloc .......................
............................
d’instructions .............
d’instructions..................
................................

 Remarque
 Il ne faut JAMAIS mélanger les tabulations et les espaces au risque d’avoir l’erreur suivante:
 IndentationError: unindentdoesnot match anyouterindentation level

 Utilisé dans les boucles, conditions, fonctions, exceptions ...

A.BEN-HDECH 39
 Les instructions de contrôle

Définition

 Les structures de contrôle permettent de faire varier l’exécution du programme.

 Une instruction de contrôle englobe généralement un bloc d'instructions.
 Il existe deux types d’instructions de contrôle :
 Les instructions conditionnelles permettent de n'exécuter une partie du programme que si une

condition donnée est satisfaite.

 Les instructions répétitives permettent de répéter un certain nombre de fois une portion de code.

A.BEN-HDECH 40
 Les instructions de contrôle

instructions conditionnelles : if(...) else

 L’instruction conditionnelle if ...: e1se teste une condition et, en fonction du résultat,
décide du chemin à suivre dans le programme. La syntaxe est la suivante :
 Syntaxe

if expression booleenne:
bloc..............
d instructions 1..
else:
bloc..............
d instructions 2.

 Si l’expression booléenne est vraie, le premier bloc d’instructions est réalisé, dans le cas
contraire c’est le second.

A.BEN-HDECH 41
 Les instructions de contrôle

instructions conditionnelles : if... else

Exemple

>>> a=l0
>>> if a<l0:
print ("a inferieur a 10")
else:
print ("a superieur ou egal a 10")
a superieur ou egal a 10

>>> a=10
if a<l0:
print ("c 'est vrai ")
if a>l0 :
a=6
print ("c'est faux" )
c'est vrai
c'est faux

A.BEN-HDECH 42
 Les instructions de contrôle

instructions conditionnelles : if(...) else

 Le mot-clé else avec le bloc 'false' peut être omis dans le cas où rien ne devrait être fait
si la condition est fausse.
 Par exemple, nous pouvons remplacer la variable x par sa valeur absolue comme ceci:

>>>x = 5
>>>if x < 0:
x = -x
print(x)

 Dans cet exemple, la variable x est affectée à -x seulement si x < 0 . En revanche,

l'instruction print(x) est exécutée à chaque fois, car elle n'est pas indentée, elle
n'appartient donc pas au bloc "true".

A.BEN-HDECH 43
 Les instructions de contrôle

instructions conditionnelles : if(...) elif … else

 Les instructions Il est possible d’imbriquer plusieurs tests à l’aide du mot-clé elif
 Syntaxe
if expression booleenne1:
bloc..............
d instructions 1..
elif expression booleenne2:
bloc..............
d instructions 2.
else expression booleenne2:
bloc..............
d instructions 2.

 Si l’expression 1 est vraie, le bloc d’instructions 1 est réalisé ;

 Si l’expression 1 est fausse et l’expression 2 vraie, le bloc d’instructions 2 est réalisé ;
 Si les deux expressions sont fausses, le bloc d’instructions 3 est réalisé.
 Plusieurs elif à la suite peuvent être utilisés pour multiplier les cas possibles.
 e1if est une concaténation de e1se et if et pourrait se traduire par« sinon si ».
A.BEN-HDECH 44
 Les instructions de contrôle

instructions conditionnelles : if(...) elif … else

Exemple

>>> x = 5
>>> if x < 0:
print(”x est négatif”)
elif x % 2 != 0:
print(”x est positif et impair”)
print (”ce qui est bien aussi !”)
else:
print(”x n’est pas négatif et est pair”)

x est positif et impair

ce qui est bien aussi !

A.BEN-HDECH 45
 Les instructions de contrôle

instructions répétitives
 Ce type d'instruction permet au programme de répéter, de compter ou
d'accumuler, avec une économie d'écriture considérable.
 On appelle boucle un système d’instructions qui permet de répéter un
certain nombre de fois toute une série d’opérations.
 Python propose deux instructions particulières pour construire des
boucles :
 l’instruction for … in … , très puissante;
 l’instruction while… .

A.BEN-HDECH 46
 Les instructions de contrôle

instructions répétitives: while

 Une boucle conditionnelle exécute une suite d’instructions tant qu’une certaine
condition est réalisée.

 Syntaxe
while condition:
bloc ...........................
D’instructions .................
à réaliser .....................

 Tant que la condition est vraie (True) le bloc d'instructions est exécuté. Le cycle continu jusqu'à
ce que la condition soit fausse (False) : on passe alors à la suite du programme.

A.BEN-HDECH 47
 Les instructions de contrôle

instructions répétitives: while

 Exemple: La table de multiplication par 8 avec la boucle while

print("Table de multiplication par 8")

compteur = 1 # initialisation de la variable de comptage
while compteur <10 :
# ce bloc est exécuté tant que la condition (compteur<10) est vraie
print(compteur,"* 8 =",compteur*8)
compteur += 1 # incrémentation du compteur : compteur = compteur + 1
# on sort de la boucle
print("Eh voilà !")
>>>
Table de multiplication par 8
1 * 8 = 8
2 * 8 = 16
3 * 8 = 24
4 * 8 = 32
5 * 8 = 40
6 * 8 = 48
7 * 8 = 56
8 * 8 = 64
9 * 8 = 72
Eh voilà !

A.BEN-HDECH 48
 Les instructions de contrôle

instructions répétitives: while

 Exemple: affichage de l’heure courante avec la boucle while

import time # importation du module time

quitter = 'n' # initialisation de la réponse
while quitter != 'o' :
# ce bloc est exécuté tant que la condition (quitter != 'o') est
vraie
print("Heure courante",time.strftime('%H:%M:%S'))
quitter = input("Voulez-vous quitter le programme (o/n) ?")
# on sort de la boucle
print("A bientôt")
>>>
Heure courante 13:56:25
Heure courante 13:56:30
Heure courante 13:56:33
A bientôt

A.BEN-HDECH 49
 Les instructions de contrôle

instructions répétitives: for…in

 L'instruction for (... ) in est une autre forme de boucle, qui permet cette fois d'itérer sur
une collection de données, telle une liste ou un dictionnaire.
 Syntaxe
for élément in séquence
bloc ...........................
................................
d instructions .................

 La séquence est parcourue élément par élément. L’élément peut être de tout type :
entier, caractère, élément d’une liste…
 Il est possible d'itérer sur les indices d'une séquence (et non pas sur les éléments eux-
mêmes) grâce à la fonction range() qui produit une séquence contenant les entiers de 0 à
n-1.

A.BEN-HDECH 50
 Les instructions de contrôle

instructions répétitives: for…in

 La fonction range
 La fonction range peut prendre entre 1 et 3 arguments entiers :
- range(b) énumère les entiers 0,1,2, · · · ,b-1 ;
- range(a,b) énumère les entiers a,a+1,· · · , b-1 ;
- range(a,b) énumère les entiers a, a+c, a+2c, · · · , a+nc où n est le plus grand entier vérifiant a +nc < b
si c est positif (ie n est la partie entière de (b-a)/c) et a +nc > b si c est négatif (ie que n est la partie
entière de (b-1)/c+1).

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(5, 15))
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> list(range(1, 20, 3))
[1, 4, 7, 10, 13, 16, 19]

- L’énumération range(b) comporte b éléments ; - l’énumération range(a,b) comporte b-a éléments.

A.BEN-HDECH 51
 Les instructions de contrôle

instructions répétitives: for…in

 La fonction range
 La fonction range peut prendre entre 1 et 3 arguments entiers :
- range(b) énumère les entiers 0,1,2, · · · ,b-1 ;
- range(a,b) énumère les entiers a,a+1,· · · , b-1 ;
- range(a,b) énumère les entiers a, a+c, a+2c, · · · , a+nc où n est le plus grand entier vérifiant a +nc < b
si c est positif (ie n est la partie entière de (b-a)/c) et a +nc > b si c est négatif (ie que n est la partie
entière de (b-1)/c+1).

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(5, 15))
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> list(range(1, 20, 3))
[1, 4, 7, 10, 13, 16, 19]

- L’énumération range(b) comporte b éléments ; - l’énumération range(a,b) comporte b-a éléments.

A.BEN-HDECH 52
 Les instructions de contrôle

instructions répétitives: for…in

 Exemple

>>> for x in range(2, 10, 3):

print(x, x∗∗2)
2 4
5 25
8 64

 Il est possible d’imbriquer des boucles à l’intérieur d’autres boucles :

>>> for x in range(1, 6):

for y in range(1, 6):
print(x ∗ y, end=’ ’)
print(’/’)
1 2 3 4 5 /
2 4 6 8 10 /
3 6 9 12 15 /
4 8 12 16 20 /
5 10 15 20 25 /

A.BEN-HDECH 53
 Les instructions de contrôle

instructions répétitives: for…in

 Exemple

>>> liste=["Bob", "Jean", "Pierre", "Alain", "Yves"]

>>> for x in liste :
print (x)
Bob
Jean
Pierre
Alain
Yves

>>> noms = ['Arthur', 'Julien', 'Aurélie']

>>> for i in range(len(noms)):

>>> print ('Prénom numéro %d : %s' % (i, noms[i]))

Prénom numéro 0 : Arthur

Prénom numéro 1 : Julien
Prénom numéro 2 : Aurélie

A.BEN-HDECH 54
 Les instructions de contrôle

instructions répétitives: for…in

 Exemple: Dans le cas des dictionnaires, on souhaite souvent connaître à la fois la clée et
la valeur :

>>> ages = {'arthur': 25, 'julien': 32, 'aurélie': 21}

>>> for nom, age in ages.iteritems():

print (nom.capitalize() + ' a ' + str(age) + ' ans.‘)

Arthur a 25 ans.
Aurélie a 21 ans.
Julien a 32 ans.

A.BEN-HDECH 55
 Les instructions de contrôle

Les instructions break, continue

 L'instruction break permet d'arrêter une boucle avant sa fin.
>>>i=1
>>>while i<5:
if i%2==0:
break
print (i)
i=i+1
print ("Fin“)
1
Fin

 L'instruction continue n'interrompre pas la boucle, mais saute à la prochaine itération de la boucle

>>>i=1
>>>while i<5:
i=i+1
if i%2==0:
continue
print (i)
print ("Fin“)
1
3
5
Fin

A.BEN-HDECH 56
 Les instructions de contrôle

La clause else dans une boucle

 La clause else dans un boucle permet de définir un bloc d’instructions qui sera exécuté à la fin
seulement si la boucle s’est déroulée complétement sans être interrompue par un break.

 Le bloc de la clause else est exécuté lorsque la boucle ;

 se termine par épuisement de la liste (avec for) ou

 quand la condition devient fausse (avec while),

 mais pas quand la boucle est interrompue par un break.

A.BEN-HDECH 57
 Les instructions de contrôle

La clause else dans une boucle

 Ceci est illustré dans la boucle suivante, qui recherche des nombres premiers :

n=2
for n in range(2, 8):
for x in range(2, n):
if n % x == 0:
print(n, "egale", x, "*", n/x)
break
else:
print(n, "est un nombre premier")
2 est un nombre premier
3 est un nombre premier
4 egale 2 * 2.0
5 est un nombre premier
6 egale 2 * 3.0
7 est un nombre premier

A.BEN-HDECH 58
 Les instructions de contrôle

Exercice
 On souhaite calculer un définie par u0 = 0, u1 = 1 et uk+2 = uk + 1 + uk

>>> n=int(input("entre n:"))

>>> x, y = 0, 1 # i n i t i a l i s a t i o n
>>> for k in range(n):
x, y = x + y, x # conservation
print(x)

A.BEN-HDECH 59
 Les types composites

Listes
 Les listes sont les principales structures de données en PYTHON. C’est une structure
hybride, qui cherche à tirer avantage de deux structures de données fondamentales en
informatique : les tableaux et les listes chaînées.

 Les objets de la liste peuvent être de types différents

 La taille de la liste change à chaque suppression ou insertion
 Une liste est déclarée par une série de valeurs séparées par des virgules, et le tout
encadré par des crochets. En voici quelques exemples :

>>> animaux = ["girafe", "tigre", "singe", "souris"]

>>> tailles = [5, 2.5, 1.75, 0.15]
>>> mixte = ["girafe", 5, "souris", 0.15]
>>> animaux
['girafe', 'tigre', 'singe', 'souris']
>>> tailles
[5, 2.5, 1.75, 0.15]
>>> mixte
['girafe', 5, 'souris', 0.15]

A.BEN-HDECH 60
 Les types composites

Listes : opérations sur les listes

 Créer une liste (vide) : l=[] ou bien l=list()
 l[0] retourne le premier élément
 L3= l1+ l2 #Concaténer deux listes
 l.append(v) : Insère un élément v à la fin de l
 l.insert(i, v): Insère un élément v à la position i de l
 l.pop() retourne la valeur du dernier élément et le supprime de la liste (on le dépile)
 l.pop(i) retourne la valeur du ième élément et le supprime de la liste
 l.remove(v): supprime la première occurrence de v dans l
 l.count(v): retourne le nombre d’occurrence de v dans l
 l.expend(l2): insère tous les éléments de l2 à la fin de l1 (concaténation)

A.BEN-HDECH 61
 Les types composites

Listes : opérations sur les listes

 l.sort(): Trie une liste (si les objets ne sont pas des types standards il faut rajouter une
fonction qu’on verra plus tard)
 l.reverse(): retourne une liste dont les éléments sont ceux de l mais d’ordre inversé
 len(l): retourne la taille de l.
 l[i:j] donne la sous-liste composée des valeurs aux positions i, i+1, …, j-1
 l[:j] donne la sous-liste composée des valeurs aux positions 0, 1, …, j-1
 l[j:] donne la sous-liste composée des valeurs aux positions j, j+1, …, n-1
 On peut créer des matrices sous forme de liste de listes
 M=[[1, 2, 3], [4, 5, 6]]

A.BEN-HDECH 62
 Les types composites

Listes : opérations sur les listes

 Exemple : Opérations sur des listes

>>> liste=["journal",9,2 . 7134,"pi"]

>>> liste[0]
'journal'
>>> print (liste[3])
pi
>>> type(liste[l])
<type 'int'>
>>> liste[4]
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: list index out of range
#Erreur car on a dépassé la capacité de la liste ! ! !
>>> liste .append("bazar") e
»> liste
['journal', 9, 2. 7134, 'pi', 'bazar']
>>>liste. insert(4, "truc")
>>> liste
['journal', 9, 2.7134, 'pi', 'truc', 'bazar']
>>> len(liste) e #donne la longueur de la liste
6

A.BEN-HDECH 63
 Les types composites

Listes : opérations sur les listes

 Exemple: Opérations sur des listes

>>> ani1 = ["girafe", "tigre"]

>>> ani2 = ["singe", "souris"]
>>> ani1 + ani2 #Concaténer deux listes
['girafe', 'tigre', 'singe', 'souris']
>>> ani1 * 3 #duplication de liste
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
>>> ani3[1:3]
['tigre', 'singe']
>>> ani3[:3]
['girafe', 'tigre', 'singe']
>>> ani3[2:]
['singe', 'souris']

A.BEN-HDECH 64
 Les types composites

Listes : opérations sur les listes

 Exemple: Opérations sur des listes

>>> ani1 = ["girafe", "tigre"]

>>> ani2 = ["singe", "souris"]
>>> ani1 + ani2 #Concaténer deux listes
['girafe', 'tigre', 'singe', 'souris']
>>> ani1 * 3 #duplication de liste
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
>>> ani3[1:3]
['tigre', 'singe']
>>> ani3[:3]
['girafe', 'tigre', 'singe']
>>> ani3[2:]
['singe', 'souris']

A.BEN-HDECH 65
 Les types composites

Les tuple
 Un tuple est une collection ordonnée et non modifiable d’éléments éventuellement
hétérogènes.
 Syntaxe : Éléments séparés par des virgules, et entourés de parenthèses.
monTuple=(el1,el2,…)

— L’indexage des tuples s’utilisent comme celui des listes ;

— le parcours des tuples est plus rapide que celui des listes ;

— ils sont utiles pour définir des constantes.

 N.B: Comme les chaînes de caractères, les tuples ne sont pas modifiables !
 N’ont pas de méthodes
 Ils sont plus rapides que les listes.
 Peuvent servir comme clés des dictionnaires

A.BEN-HDECH 66
 Les types composites

Les tuple : Exemple

monTuple=() # tuple vide

monTuple =tuple() # tuple vide
monTuple =(mohamed ’, 30) # tuple avec deux éléments

 Sont utilisées pour formater les strings (lui préférer la méthode format):
>>> monTuple =(mohamed ’, 30) # tuple avec deux éléments
>>>S= "Nom: %s et age: %s" % n_ag
>>>print(S)
Nom: lohamed et age: 30

>>> mon_tuple.append(4) # attention ne pas modifier un tuple !

Traceback (most recent call last) :
File ”<stdin>”, line 1, in <module>
AttributeError : ’tuple’ object has no attribute ’append

A.BEN-HDECH 67
 Les types composites

Liste <-> Tuple

 Passage d’un tuple à une liste:

monTuple =(mohamed ’, 30)

maListe=list(monTuple)

 Passage d’une liste à un tuple :

maListe=[’mohamed ’, 30]
monTuple =tuple(maListe)

A.BEN-HDECH 68
 Les types composites

Ensembles (set)
 Les ensemble ou sets forment un autre type de données composites Python. Un
ensemble est une collection d’éléments non ordonnée, sans index et qui ne peut pas
posséder l’élément dupliqué.
 Donc un set est la transposition informatique de la notion d’ensemble mathématique.
 Une des utilisation les plus courantes des ensembles est de les utiliser pour supprimer
des valeurs doublons à partir d’un autre type de données.
 Pour créer un ensemble, on utilise une paire d’accolades { } en placer les différents
éléments de notre ensemble entre ces accolades en les séparant avec une virgule.

set1={"ahmed",27,"tarik"}
set1
{'ahmed', 27, 'tarik'}
set2={"ahmed",30,"tarik","karima","ahmed"}
set2
{'karima', 'ahmed', 'tarik', 30}

A.BEN-HDECH 69
 Les types composites

Ensembles (set)
 Quelque méthodes des Set :
 len(set1) : retourne le cardinal du set1
 set1.isdisjoint(set2) retourne True si l’intersection de set1 et set2 est vide
 set1.issubset( set2 ) (ou set <= set2) retourne True si set1 ⊂ set2
 set1.union(set2) (ou set | set2) : retourne set1 ∪ set2
 set1.intersection(set2) (ou set1 & set2) : retourne set1 ∩ set2
 set1. difference(set2) ( ou set1 –set2)
 N.B Notez que pour créer un ensemble vide il faudra utiliser la fonction set() car la
syntaxe { } va créer un dictionnaire vide et non pas un ensemble vide.

A.BEN-HDECH 70
 Les types composites

Ensembles (set): exemple

>>> X = {’s’, ’p’, ’m’, ’a’}

>>> Y = {’s’, ’p’, ’a’}
>>> X
>>> ’p’ in X
True
>>> ’m’ in Y
False
>>> X - Y # ensemble des éléments de X qui ne sont pas dans Y
{’m’}
>>> Y - X # ensemble des éléments de Y qui ne sont pas dans X
set()
>>> X ^ Y # ensemble des éléments qui sont soit dans X soit dans Y
{’m’}
>>> X | Y # union
{’s’, ’p’, ’m’, ’a’}
>>> X & Y # intersection
{’s’, ’p’, ’a’}

A.BEN-HDECH 71
 Les types composites

Dictionnaires (dict)
 Tableaux associatifs: l’accès se fait par clés
 Ensemble de couples (key, value)
 La clé doit être de type immuable (str, tuple, frozenset)
 Création d’un dictionnaire vide:
 Dict={}
 Déclaration d’un dictionnaire initialisé:
 Dict={key1: value1, key2: value2 ….}
 Accès à la valeur value associée à la clé key; Dict[key]
 Ajout d’un élément newKey , newVal:
 Dict[newKey]=newVal

A.BEN-HDECH 72
 Les types composites

Dictionnaires (dict)

 del(dict[key]): Suppression d’un élément de clé key:

 dict.values(): retourne la liste des valeurs du dictionnaire
 dict.keys(): retourne la liste des clés du dictionnaire
 dict.clear(): supprime tous les éléments du dictionnaire.
 dict.items(): retourne les éléments du dictionnaire (tuples(clé, valeur))
 dict.has_key(key): retourne True si la clé key appartient au dict
 len(dict): retourne le nombre d’éléments du dictionnaire

A.BEN-HDECH 73
 Les types composites

Dictionnaires (dict)

 del(dict[key]): Suppression d’un élément de clé key:

 dict.values(): retourne la liste des valeurs du dictionnaire
 dict.keys(): retourne la liste des clés du dictionnaire
 dict.clear(): supprime tous les éléments du dictionnaire.
 dict.items(): retourne les éléments du dictionnaire (tuples(clé, valeur))
 dict.has_key(key): retourne True si la clé key appartient au dict
 len(dict): retourne le nombre d’éléments du dictionnaire

A.BEN-HDECH 74
 Les types composites

Dictionnaires (dict): exemple

>>> dico={"computer" :"ordinateur"}

>>> dico["mouse"]="souris"
>>> dico["mouse"]
'souris'
>>> dico[2]="two"
>>> dico
{2 : 'two', 'computer ': 'ordinateur', 'mouse': 'souris'}
»> dico.keys()
[2, 'computer', 'mouse'
>>> del dico[2]
>>> dico
{'computer' : 'ordinateur', 'mouse': 'souris '}

A.BEN-HDECH 75
 Les fonctions

Définition d’une fonction

 Traditionnellement on distingue deux types de routines :
—les procédures ne retournent pas de résultat et se contentent d’agir sur l’environnement,
—les fonctions retournent un résultat.
—En PYTHON la distinction n’existe pas réellement : les procédures sont des fonctions qui retournent
la valeur None.
 On définit une fonction à l’aide du mot clé def :
def nomdFonction (liste parametres ):
bloc ...........................
d instructions .................
a realiser .....................

 Appel

Mafonction()
# ou bien; cible d’affectation
Ret=mafonction()

A.BEN-HDECH 76
 Fonctions

Arguments d’une fonction

 Une fonction peut posséder un ou plusieurs arguments séparés par une virgule.
 Exemple: Pour définir la fonction

from numpy import sqrt

def norme(x, y):
return sqrt(x∗∗2 + y∗∗2)

 Une fois définie, une fonction utilise à l’instar de toute autre fonction prédéfinie :
In [1]: norme (3, 4)
Out [1]: 5.0

 En effet

A.BEN-HDECH 77
 Fonctions

Arguments d’une fonction

 Une fonction peut posséder un ou plusieurs arguments séparés par une virgule.
 Exemple: Pour définir la fonction

from numpy import sqrt

def norme(x, y):
return sqrt(x∗∗2 + y∗∗2)

 Une fois définie, une fonction utilise à l’instar de toute autre fonction prédéfinie :
>>> norme (3, 4)
5.0

 En effet

A.BEN-HDECH 78
 Fonctions

Arguments d’une fonction

 Une fonction peut posséder un ou plusieurs arguments séparés par une virgule. Pour
 définir la fonction :

def norme(x, y,k):

return (x∗∗k + y∗∗k)∗∗(1/k)

 Avec cette nouvelle définition, on a :

>>> norme(3, 4, 2)
5.0
>>> norme(3, 4, 3)
4.497941445275415
>>>norme(3, 4)
TypeError: norme() takes
exactly 3 arguments (2 given)

 Une erreur est déclenchée dès lors que le nombre d’arguments donnés est incorrect

A.BEN-HDECH 79
 Fonctions

Arguments d’une fonction :Arguments optionnels

 Il est possible de préciser les valeurs par défaut que doivent prendre certains arguments.

def norme(x, y, k=2):

return (x∗∗k + y∗∗k)∗∗(1/k)

 Si on omet de préciser le troisième paramètre, ce dernier sera égal à 2 :

>>> norme(3, 4, 3)
4.497941445275415
>>> norme(3, 4)
5.0

 Il est préférable de nommer les arguments optionnels pour éviter toute ambiguïté :

>>> norme(3, 4,k=3)

4.497941445275415

A.BEN-HDECH 80
 Fonctions

Arguments d’une fonction :Arguments optionnels

 C’est le cas de la fonction print qui possède deux paramètres optionnels sep (valeur par
défaut : ’ ’) qui est inséré entre chacun des arguments de la fonction et end (valeur par
défaut : ’\n’) qui est ajouté à la fin du dernier des arguments :

>>> print(1, 2, 3, sep=’+’, end=’=6\n’)

1+2+3=6

A.BEN-HDECH 81
 Fonctions

Portée des variables

 Les variables définies dans une fonction ne sont accessibles que dans la fonction elle-
même. De telles variables sont qualifiées de locales, par opposition aux variables
globales.
 Si on souhaite modifier le contenu d’une variable globale à l’intérieur du bloc
d’instructions d’une fonction, il faut utiliser l’instruction global pour déclarer celles des
variables qui doivent être traitées globalement.

>>> def h():

global a # declaration d une variable globale
a = 2
return a
>>> h()
2
>>> a # la variable definie ligne a bien ete modifiee
2

 En règle générale, il est conseillé de peu faire usage de variables globales

A.BEN-HDECH 82
 Fonctions

Portée des variables- Exercice

 Les variables définies dans une fonction ne sont accessibles que dans la fonction elle-
même. De telles variables sont qualifiées de locales, par opposition aux variables
globales.

>>> def h():

global a # declaration d une variable globale
a = 2
return a
>>> h()
>>> 2
>>> a # la variable definie l i g n e 9
#a bien ete modifiee
>>> 2

A.BEN-HDECH 83
 Gestion des exceptions

Definition
 Une exception est un événement qui se produit pendant l'exécution d'un programme qui
interrompt le déroulement normal des instructions du programme.
 En général, quand un script Python rencontre une situation qui ne peut pas faire face,
elle soulève une exception.
 Une exception est un objet Python qui représente une erreur.
 Si vous avez un « suspect code » qui peut soulever une exception, vous pouvez défendre
votre programme en plaçant le code suspect dans un try: bloc. Après l'essai: bloc,
inclure une except: déclaration, suivie par un bloc de code qui gère le problème le plus
élégamment possible.

A.BEN-HDECH 84
 Gestion des exceptions

Syntaxe

try:
Bloc ......................
d’instructions.............
except ExceptionI:
Bloc ......................
d’instructions.............
except ExceptionII:
Bloc ......................
d’instructions.............
else:
Bloc ......................
d’instructions.............

A.BEN-HDECH 85
 Gestion des exceptions

Try-finally
 Vous pouvez utiliser un finally: bloc le long d'un try: bloc.
 Le bloc finally est un endroit pour mettre tout code qui doit exécuter, si le bloc try
a soulevé une exception ou non. La syntaxe de l'instruction try-finally est la suivant:

try:
bloc d’instructions ......................
finally:
bloc d’instructions ......................

A.BEN-HDECH 86
 Gestion des exceptions

Exemples

try:
print (5/0)
except ZeroDivisionError, e:
print (e)

try:
print (5%0)
except ZeroDivisionError, e:
print (e)

try:
print (foo)
except NameError, e:
print (e)
#name 'foo' is not defined

foo = [0,1,2]
try:
print (foo[3])
except IndexError, e:
print (e)
#list index out of range

A.BEN-HDECH 87
 Gestion des exceptions

Quelques exceptions

Nom d’exception Description

Exception Classe de base pour toutes les exceptions

StopIteration Déclenchée quand la méthode () à côté d'un itérateur ne pointe pas vers un objet
quelconque.
indexError Déclenchée quand un index ne se trouve pas dans une séquence.
ZeroDivisonError Déclenchée quand division ou modulo par zéro a lieu pour tous les types
numériques.
FloatingPointError Déclenchée quand un calcul en virgule flottante échoue.

ImportError Déclenchée quand une déclaration d'importation échoue.

EOFError Déclenchée quand il n'y a pas d'entrée soit de la raw_input () ou (fonction d'entrée)
et la fin du fichier est atteinte.
NameError Déclenchée quand un identifiant ne se trouve pas dans l'espace local ou global.

A.BEN-HDECH 88