Université Sidi Mohamed Ben Abdellah

Faculté des Sciences Dhar El Mahraz Fès

Licence Professionnelle:
Systèmes d’Information et Génie Logiciel

Introduction à
Plan
• Caractéristique du langage
• Environnement de développement
• Le langage Python
– Variables
– Commentaires
– Opérateurs
– Affectations
– Type de données
– Manipulation de chaines de caractères
– Fonctions d’entrée/sortie
– Blocs d’instruction
– Structures de controles
– Les listes, tuples, Sets, Dictionnaires
• Gestion des exceptions

2
Caractéristiques du langage
• Python
– Simple et puissant
– Interprété
– Multi-paradigme
– Multiplateformes
– Typage dynamique fort
– Gestion automatique de la mémoire
– Système de gestion d'exceptions
– Distribué sous licence libre
– Très utilisé:
• Web: Python + le Framework Django
• Administration
• Prototypage
– Richesse en librairie: calcul, réseau, jeux vidéos (2d et 3D), ...
– Première version sortie le 1990 par « Guido van Rossum »
– Principalement inspiré du :
• Langage ABC pour l’indentation
• Modula-3 pour la gestion des exceptions
• C pour les outils UNIX
– En deux releases: Version 2 et Version 3
– Dernières versions: 2.7.11 (la plus stable) et 3.5.1

3
Multiplateforme et multi-environnement
• Multiplateforme: Windows, MacOS, Linux, ...
• Multi-Environnement: par le biais des
implémentations:
– Cpython: en C (plus utilisée  Windows, Mac, Linux)
– IronPython: en .Net en Mono
– Jython: en Java
– ...

4
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

5
Environnement de développement
• 2 modes d’utilisation
– Interactif: un invite de commande qui interprète
immédiatement les commande saisies et affiche le résultat 
calculateur
>>> print "salut"
salut
>>> 5 + 6
11
>>>
– Programmation (script): code écrit dans des fichiers *.py et
interprétés par l’interpréteur Python
• Editeurs Python:
– IDLE: installé par défaut
– Bluefish
– Eric3
– PyDev
Pour une liste d’IDEs python
– .... https://wiki.python.org/moin/IntegratedDevelopmentEnvironments
6
Interpréteur de commandes
• 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).
• L'objectif principal est de tester et comprendre les bases de
Python en testons directement des instructions
• la série de trois chevrons qui se trouve en bas à gauche des
informations signifient qu’il est prêt à recevoir des instructions
Python .
>>> tax = 12.5 / 100
>>> price = 100.50 «_» contient le
>>> price * tax résultat
12.5625 d’exécution. en
>>> price + _
lecture seule
113.0625
>>> round(_, 2)
113.06
Les variables
 Le nom de la variable ne peut être composé que des lettres,
majuscules ou minuscules, de chiffres et du symbole souligné.
 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.
>>> tva=50
>>> print(tva)
50
>>> print (Tva) # génére une erreur ”name 'Tva' is not defined”
 Les mots réservés ne sont pas utilisables comme identifiants
Les commentaires
• Commentaires mono-ligne :
 commence par le caractère # et s’étend jusqu’à la fin de la ligne.
>>> tva =5 #Ceci est un commentaire
• Commentaires multi-lignes :
 Utiliser trois quottes/double-quottes au début et à la fin de la partie
à commenté :
' ' ' ceci est un commentaire ' ' ‘ ou “”” ceci est un commentaire”””
Opérateurs
• Opérateurs logiques :
And - Or - Not
• Opérateurs de comparaison :
> , >= , == , < , <= , !=
• Opérateurs Mathématiques :
 3+2 #5
 3-2 #1
 3*2 #6
 3**2 #6(puissance)
 3/2 #1(division entière)
 3%2 #1(modulo)
 3.5//2 #1 (division entière forcée)
Opérations d’affectation
>>> a=2 #Affectation
>>> a+=2 #a=a+2 si a déjà référencé
>>> C=d=8 #cibles multiples (affection de droite à gauche )
>>> e,f=2,9 #affectation de tuple (par position)
>>> e,f=f,e #permutation entre e et f
>>> g,h=[‘G’,’H’] #affectation de liste (par position)
Type de données
• Pas de déclaration explicite du type d’une variable (langage non
typique).
• Tout est basé sur l’objet: objet avec identifiant, type et valeur
• Utiliser des primitives pour identifier les attributs d’un objet
– id(): identifiant d’un objet
– type(): le type
– dir(): liste l’ensemble des fonctionnalités de l’objet
>>> tva =5
>>> id(tva) # affiche l’identifiant (équivalent à une adresse)
19845880
>>> type(tva) # affiche le type
<type 'int'>
>>> dir(tva)
['__abs__', '__add__', '__and__', '__class__'
>>> tva="la TVA“ # on change de type sans problème
>>> type(tva) 12
<type 'str'>
Les types
- Les types entiers :
 Peuvent être d’une taille quelconque.
- Les types flottants(réels)
 Notés avec un point décimal (3.2)
- Les types booléens qui prennent deux valeurs
 True
 False
- Les nombres complexes:
 Les complexes sont écrits en notation cartésienne de la forme a+bj avec a et b
des flottants
 Exemples:
 1j #1j
 (4+1j)+(2+3j) #(6+4j)
 (5+7j).real #5.0
 (5+7j).imag #7.0
 Abs(3+4j) #5.0 ;module
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 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:
 S= " Je m’appelle Ahmed"
 S= ' le mot " Oni" signifie démon en japonais '
Les opérations sur les str
• Concatenation
>>> " Hello" + " World" # Hello World
>>> "Hello"*3 # HelloHelloHello

• 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 élément de S
 S[-i] retourne le ième élément de S en partant de la fin. (à la position n-i)
 La fonction len(S) retourne la taille de S
• 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
 Les opérations sur les str
• Exemples
S="J'apprends le langage Python"
print S[0], S[5] Jr
print S[-2] o
print "La longueur de " , S, " est ", len(S) La longueur de J'apprends le langage Python est 28
print S[2:5] app
print S[:6] J'appr
print S[8:] ds le langage Python

16
Les opérations sur les 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
Formater une chaine de caractères
 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
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
 Attention :
 Elle attend en réalité une instruction Python
 N’existe plus à partir de Python 3.x
 Lui préférer la fonction raw_input()
Entrées clavier :raw_input()
 Même chose que input(), sauf qu’elle lit une chaine de
caractères
 Pour lire une variable d’un autre type, il faut faire un
transtypage(cast)
>>> a=raw_input()
8
>>> type(a)
<type 'str'>
>>> b=int(raw_input())
5
>>> type(b)
<type 'int'>
Sortie écran (print)
 L’instruction print permet d’afficher la valeur d’une variable à l’écran
>>> print "salut"
salut
>>> print ("salut") # En version 3.X c’est une fonction
Salut
>>> a="Sabri"
>>> print (a)
Sabri
 Remarque:
 Elle fait un saut de ligne après l’affichage de la valeur
 Pour l’empêcher de sauter de ligne; rajouter une virgule à la fin (elle écrira
un espace au lieu d’un saut de ligne)
print ("salut"),
print ("Prof") # affiche Salut Prof
 Python 3.X: rajouter un paramètre end=" "
print ("salut " ,end=" ")
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 meme 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

22
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

23
Notion de bloc d’instruction
 Les blocs d’instruction sont identifiés par leur indentation (espace
entre le de marge bu bloc et les instructions)
 Il ne faut JAMAIS mélanger les tabulations et les espaces au
risque d’avoir l’erreur suivante:
IndentationError: unindentdoesnot match anyouterindentation level
 Utiliser dans les boucles, conditions, fonctions, exceptions ...
 La convention est d’utiliser 4 espaces par niveau au lieu d’une
tabulation
Notion de bloc d’instruction

print "Je suis dans le premier bloc"

print "Je suis toujours dans le premier bloc"
if (a == 12) : #L'instruction ''if'' initie un nouveau bloc
#Ce bloc est a quatre espace du bord
print "Je suis dans le second bloc"
if (b == 13 ) :
#Il est possible d'imbriquer des blocs dans des blocs
print "Je suis dans un troisième bloc"
print "Je suis revenue dans le premier bloc"
 Structures de contrôle
• if elif else
if condition:
BLOC d’instruction à exécuter si condition est vérifiée
2éme ligne du bloc. 4 espaces pour indentation
Fin du bloc if. Pas d’accolade mais indentation

if condition_1: if condition:
BLOC 1 BLOC d’instruction à exécuter si condition vérifiée
elif condition_2: #Equivalent à else if 2éme ligne du bloc. 4 espaces pour indentation
BLOC 2 else:
else: bloc de else
BLOC 3 Fin du bloc. Pas d’accolade mais indentation
Fin du bloc

26
Structures de contrôle
# -*- coding: UTF-8 -*-
a= input("saisir a: ")
b= input("saisir b: ")
if (a>b):
print "{} est > a {}".format(a,b)
else:
print "{} est > a {}".format(b,a)
print ("Fin")

# -*- coding: UTF-8 -*-

a= input("saisir a: ")
b= input("saisir b: ")
if (a>b):
print "{} est > a {}".format(a,b)
elif a==b:
print "{} est = a {}".format(b,a)
else:
print "{} est > a {}".format(b,a)
print ("Fin") 27
 Structures de contrôle
• Boucle while
while condition:
BLOC d’instruction à exécuter tant que la condition est vérifiée
2éme ligne du bloc. 4 espaces pour indentation

i=0
while i<5: 12345
i=i+1 Fin
print i,
print "\nFin"

i=0
while i<5: 5
i=i+1 Fin
print i,
print "\nFin" 28
 Structures de contrôle
• Boucle for:
for el in struc:
BLOC d’instruction à exécuter pour tous les « el » de struc

n=5
for i in range(n) :#Equivalent à for (i=0; i<n; i++ ) 01234
print i,
n=5
for i in range(2,n) :#Equivalent à for (i=2; i<n; i++ ) 234
print i,
n=5
for i in range(-1,n, 2) :#Equivalent à for (i=-1; i<n; j=j+2 ) -1 1 3
print i,
for cc in "Python":
Python
print (cc), 29
Les instructions break, continue
 L'instruction break permet d'arrêter une boucle avant sa fin.
i=1
while i<5:
1
if i%2==0:
Fin
break
print i,
i=i+1
print "\nFin"

 L'instruction continue n'interrompre pas la boucle, mais saute

à la prochaine itération de la boucle
i=0
while i<5:
135
i=i+1
Fin
if i%2==0:
continue
print i,
print "\nFin"
Exercices
Exercice 1:
 Demander à l’utilisateur de saisir un nom et un âge
en utilisant l’instruction input().
 Afficher comme: Lâge de « val_nom » est « val_âge »
Exercice 2:
– Demander à l’utilisateur de saisir un chiffre
– Si il est positif, afficher sa racine carrée: utiliser la
fonction sqrt(variable) de la bibliothèque math (from
math import sqrt) à écrire en haut du code
– Si il est négatif afficher un message d’erreur

31
Les listes
 Ce sont des tableaux hétérogènes de taille variable
 Accès par position
 Les objets de la liste peuvent être de types différents
 La taille de la liste change à chaque suppression ou
insertion
 Ils ne sont pas immuables contrairement aux str, on
peut faire :
l[0]=val
 On peut créer des matrices sous forme de liste de listes
 Exemple: M=[[1, 2, 3], [4, 5, 6]]
Les opérations sur les listes
 Créer une liste (vide) : l=[] ou bien l=list()
 l=[1 , -58, "SIGL", 'S', True]
 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)
 On peut créer des matrices sous forme de liste de listes
M=[[1, 2, 3], [4, 5, 6]]
 Les opérations sur les listes
• Exemple
l=list()
l=[1 , 1, -58, "SIGL", 'S', True]
print l[2]
l2=[0.25, "T"] -58
l3= l + l2 [1, 1, -58, 'SIGL', 'S', True, 0.25, 'T']
print l3 1 1 -58 SIGL S True 0.25 T
for lis in l3:
print lis, 1 1 -58 SIGL S True 0.25 T ajout a la fin
l3.append("ajout a la fin") 1
print("\n")
for lis in l3:
print lis,
print "\n", l3.count('T')

36
Les 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
 Les opérations sur les listes
• Exemple
l=[1, 1, -58, 18, 500, 0]
l.sort()
[-58, 0, 1, 1, 18, 500]
print l [500, 18, 1, 1, 0, -58]
l.reverse() [0, -58]
print l
print l[2:4]

38
Tuple
 Même déclaration que les listes, mais avec parenthèses
tpl=() # tuple vide
Tupl=tuple() # tuple vide
tple=(2, 3) # tuple avec deux éléments
 Même méthodes d’accès que les listes ( par index )
 Sont immuables !
 N’ont pas de méthodes
 Ils sont plus rapides que les listes.
 Peuvent servir comme clés des dictionnaires
 Sont utilisées pour formater les strings (lui préférer la méthode format):
n_ag=("Ahmed", 25)
S= "Nom: %s et age: %s" % n_ag
print S # affiche « Nom: Ahmed et age: 25 »
Liste <-> Tuple
 Passage d’un tuple à une liste:
 L=list(myTuple)
 Passage d’une liste à un tuple :
 myTuple=tuple(list)
Set
 Ensemble au sens mathématique: collection d’objets sans doublons
 Ne sont pas ordonnés et donc pas d’accès par index
 On peut itérer les éléments: for x in set
 Existe en version immuable frozenset
 Déclaration d’un set:
 set={} # vide
 Set={1,5}
 Quelque méthodes des Set :
 len(set) : retourne le cardinal du set
 set.isdisjoint(set2) retourne True si l’intersection de set et set2 est vide
 set.issubset( set2 ) (ou set <= set2) retourne True si set ⊂ set2
 set.union(set2) (ou set | set2) : retourne set ∪ set2
 set.intersection(set2) (ou set & set2) : retourne set ∩ set2
 set. difference(set2) ( ou set –set2)
Les dictionnaires
 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 new Key , newVal:
 Dict[newKey]=newVal
Les dictionnaires
 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
Exercice
• Ecrire un code python qui
– Déclare un tuple dont tous les éléments sont des entiers
– Décaler un dictionnaire vide
– Affiche la somme de ces éléments et l’insère dans le
dictionnaire avec la clés « Somme»
– Afficher la valeur maximale et l’insère dans le dictionnaire
avec la clés « Min»
– Afficher la valeur minimale et l’insère dans le dictionnaire
avec la clés « Min»

44
Gestion des exceptions
 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.
 Gestion des exceptions
• quelque sexceptions
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.
Gestion des exceptions
 Syntaxe:
try:
Bloc d’instructions
except ExceptionI:
Bloc d’instructions
except ExceptionII:
Bloc d’instructions
else:
Bloc d’instructions
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 ......................
Exception
• Exemples
try:
try:
print foo
print 5/0
except NameError, e:
except ZeroDivisionError, e:
print e #
print e
name 'foo' is not defined
try:
foo = [0,1,2]
print 5%0
try:
except ZeroDivisionError, e:
print foo[3]
print e
except IndexError, e:
print e list index out of range