Historique et raisons du choix

ENVIRONNEMENT DE du langage
2 Atef Boujelben

DÉVELOPPEMENT Python est un langage de programmation développé depuis 1989 par

PYTHON 3 le néerlandais Guido Van Rossum et de nombreux collaborateurs. Il

est apparu officiellement en 1991

ENSEIGNANT (FSS) : ATEF BOUJELBEN

Caractéristiques de base de
Langage Python PYTHON(1)
3 Atef Boujelben 4 Atef Boujelben

Python:
Python 1.0 – Janvier 1994
Python 2.0 – Octobre 2000 est portable sur différentes plateformes tels que Unix et
Windows.
Python 2.5 – Septembre 2006
Python 2.6 - Octobre 2008, est libre (free): utilisation sans restriction dans les projets
commerciaux
Python 2.7 – Juillet 2010
Révolution du langage python et apparition de la version 3 :
est dynamiquement typé: tout objet manipulable par le
Python 3.0 - Décembre, 2008
programmeur possède un type bien définit à l'exécution, qui n'a pas
Python 3.4 – Mars, 2014
besoin d'être déclaré à l'avance. Python gère lui-même l’espace
Python 3.6.3- Octobre, 2017
mémoire disponible.
Python 3.6.6-Mars 2018
Caractéristiques de base de Caractéristiques de base de
PYTHON (2)
5
PYTHON (3)
6
Atef Boujelben Atef Boujelben

est un langage Open Source (ouvert). Il peut de ce fait être

offre des possibilités pour la programmation orientée objets librement utilisé et distribué.
est un langage extensible : il possède tout un ensemble de librairies
est un langage inter-opérable (avec C Cython, Java Jython, C++, d’outils; domaines d’accès aux bases de données, des interfaces
etc)
graphiques, de développement pour le WEB, etc.
est un langage intégré : on peut utiliser Python sur une plate-
est Multi paradigme puisqu’il supporte les principaux styles de
forme JAVA et Python peut contenir du code C ou C++ par exemple.
programmation: impératif, procédural, orienté objet...

est robuste: permet au programmeur d’identifier les causes d’erreur

est Universel : non orienté vers un domaine d’applications
et de fournir une routine de traitement lorsque ces erreurs se
particulières comme en FORTRAN ou en COBOL.
produisent.

Caractéristiques de base de Caractéristiques de base de

PYTHON (4)
7
PYTHON (5)
8
Atef Boujelben Atef Boujelben

est langage de haut niveau :

niveau La syntaxe du langage est simple.

I Code machine

Il existe des interpréteurs en Python.

II Langage d’assemblage

III Fortran, C, Pascal Il existe des compilateurs en Python qui produisent un code

IV C++, JAVA intermédiaire, appelé bytecode lequel est transmis à un interpréteur

pour l’exécution finale.

V Python
 Quel Environnement de développement
Domaines d’applications intégré IDE choisir ? (1)
9 Atef Boujelben 10 Atef Boujelben

Python, est un langage de programmation de plus en plus populaire Plusieurs IDE sont disponibles
utilisé entre autres: IDLE: IDLE est un environnement de développement intégré pour
le langage Python (bon choix pour débutant).
WEB: google (pure Python et Django), youtube, mozilla, yahoo, ebay
(Plone), Nokia (Plone) IDLE propose un certain nombre d'outils :
Scientiphique : la NASA (pure Python et Plone), la CIA (Plone), CBS un éditeur de texte (pour l’écriture de script) avec une coloration
(Zope), etc. syntaxique et une indentation automatique.
L’enseignement principalement dans plusieurs pays un interpréteur (pour exécuter le programme)

Quel Environnement de Téléchargement et

Développement Intégré IDE choisir ?(2) installation de Python
11 Atef Boujelben 12 Atef Boujelben

Un débogueur (pour tester le programme) Les différentes versions de Python (pour Windows, Linux, etc.),
son tutoriel original, son manuel de référence, la documentation
Il existe d'autres IDE pour Python : Eclipse/Pydev, NetBeans, des bibliothèques de fonctions, etc. sont disponibles gratuitement,
Spyder, Eric... à partir du site officiel: [Link] .

On peut alors télécharger et installer Python à partir de cet

Pour les non débutants d’autres IDE complet: winPython ,
emplacement en tenant compte de la plate-forme utilisée.
anaconda V3, Python(x,y),etc

Une fois installé, on peut lancer en allant dans:

démarrer Tous les programmes IDLE( Python GUI)

 Environnement de
mode interactif(1)
programmation Python
13 Atef Boujelben 14 Atef Boujelben

En mode interactif, on choisit comme environnement de travail IDLE

On peut écrire nos programmes :
sous Windows. La fenêtre ressemblera à ceci :
en mode interactif en dialoguant directement depuis le clavier.

en mode script à l’aide d’un éditeur et les ranger dans des

fichiers sur disque.

Prêt à exécuter une commande.

Mode script(1) Mode script (2)

15 Atef Boujelben 16 Atef Boujelben
Pour ouvrir une nouvelle fenêtre, on choisit la commande New
Pour l’éxécution, il faut choisir la commande Run Module du menu
Window du menu File Run

Une nouvelle fenêtre s’ouvre

On obtient :
On écrit le code Python

On enregistre le fichier avec une extension .py

 Utilisation de l’aide Navigateur: Anaconda /jupyter(1)
17 Atef Boujelben 18 Atef Boujelben

L’utilisation de l’aide en ligne se fait par la commande

help(identificateur)

Exemple :

Navigateur: Anaconda /jupyter(2) Navigateur: Anaconda /jupyter(3)

19 Atef Boujelben 20 Atef Boujelben

Extension du fichier: [Link]

Navigateur: Anaconda /jupyter(4) Navigateur: Anaconda /jupyter(5)
21 Atef Boujelben 22 Atef Boujelben

Exécution: chift+entrée

Installation d’un module de l’internet

Commentaire mots réservés

23 Atef Boujelben 24 Atef Boujelben

En Python, une ligne d'instructions qui contient le

symbole # (dièse) signifie un commentaire. and assert break class continue
def del elif else except
exec finally for from global
Exemple :
if import in is lambda
help(int) # aider à savoir la signification de int not or pass print raise
return try while yield
 Les types sous Python(1) Les types sous Python(2)
25 Atef Boujelben 26 Atef Boujelben

Python est un Langage Orienté Objet

Tout est objet : données, fonctions, modules...
Un objet B possède:
Une identité id (adresse mémoire), id(B)
Un type type(B): (intrinsèque : int, float, str, bool ... ou définit par
l’utilisateur à l’aide d’une classe)
Des données.
Remarque:
L’opérateur is compare l’identité de 2 objets (adresses)
L’opérateur == compare le contenu de deux objets Array

Les types élémentaires(1) Les types élémentaires(2)

27 Atef Boujelben 28 Atef Boujelben

Un objet ne peut changer ni d’identité ni de type Les types élémentaires intrinsèques (built- in)
Le NONETYPE: seule valeur possible None (c’est la valeur
Un même objet peut être référencé sous
retournée par une fonction qui ne retourne rien)
plusieurs noms
Le type BOOL : deux valeurs possibles True et False (1/0)
>>> x=3
Les types numériques int, float, complex
>>> y=3
>>> x,id(x),type(x) Le type chaine de caractère : la classe str
(3, 505626136, <class 'int'>)
x
>>> y,id(y),type(y) 3
(3, 505626136, <class 'int'>) y 505626136 Le type d’un objet détermine :
>>> x is y
les valeurs : domaine de définition
True
>>> x==y les opérations
True
 Les types élémentaires(3) Les types élémentaires(4)
29 Atef Boujelben 30 Atef Boujelben

Le type de données entiers: le type int n’est limité en taille que par la Le type entier : <classe int> Les opérations arithmétiques +,
,*,**,/,//, %, divmod
mémoire de la machine >>> x=3
Exemple: >>> y=6 >>> z=x+y
9
>>> type(x),type(y) >>> z
(<class 'int'>, <class 'int'>) 9
>>> x-y
-3
>>> x*y
18
>>> x**y
729
Une instruction se termine par un retour à la ligne.

Les types élémentaires(5) Les types élémentaires(6)

31 Atef Boujelben 32 Atef Boujelben

>>> pow(x,y) #729

Le type de données flottants (le type float): un float est noté avec
>>> x/y # division réelle 0.5
un point décimal (jamais avec une virgule) ou en notation
>>> x//y #quotient de la division entiére 0
exponentielle avec un « e » symbolisant le « 10 puissance » suivi
>>> x%y #reste de la division entière 3
des chiffres de l’ exposant.
>>>divmod(13,4) #(3,1)
Les opérateurs de comparaison <, <=, !=, ==, >, >=
>>>x==y # False
>>>x>=y # False
>>>x<=y # True
>>>x!=y # True Les flottants ont un précision finie limitée
 Les types élémentaires(7) Les types élémentaires(8)
33 Atef Boujelben 34 Atef Boujelben

Le type réel: Class float >>> x-y # -2.2857142857142856

>>> x=12/7; y=4. >>> x*y # 6.857142857142857

>>> x;y >>> x/y #0.42857142857142855

1.7142857142857142 >>> x**y# 8.636401499375259

4.0 >>> x//y# 0.0

>>> type(x); type(y) >>> y//x # 2.0

<class 'float'> >>> x%y # 1.7142857142857142

>>> x=12/5
<class 'float'>
>>> x #2.4
Les opérations arithmétiques >>> int(x)# Passage de réel en entier l’objet retourné est un nouvel objet 2
>>> x+y #5.714285714285714 Les opérateurs de comparaison <, <=, >,>=,==, !=

Les types élémentaires(9) Les types élémentaires(10)

35 Atef Boujelben 36 Atef Boujelben

Le type booléen : class Bool Les opérations logiques and, or, not…
La classe Bool hérite de la classe int >>> B and E
>> x=3 ; y=4 False
>>> B=x==y >>> B or E
>>> B True
False >>>int(True)
>>> E=x<y 1
>>> E >>>int(False)
True 0
 Les types élémentaires(11) Import de modules(1)
37 Atef Boujelben 38 Atef Boujelben

Le type complex Python dispose plusieurs bibliothèques(modules) classées par thème.

Pour utiliser un module, on peut avoir recourt à l’une d’une manières
>>> [Link] suivantes:
>>> z=5+1j*3 5 1ere manière
>>> z >>> [Link]
(5+3j) 3 Syntaxe:
>>> z=5+3j >>> [Link]() >>>import nom_module
>>> z (5-3j)
(5+3j) >>> abs(z) >>>dir(nom_module)# permet de lister toutes les commandes du module
5.8309518948453
Exemple:
>>>import math
>>>dir(math)

Import de modules(2) Import de modules(3)

39 Atef Boujelben 40 Atef Boujelben

>>> [Link](5.7889) #partie entière supérieur 2eme manière : Utilisation d’un alias
6 Syntaxe:
>>> [Link](7.8989) #partie entière inférieur >>>import nom_module as alias
7 Exemple:

>>> [Link](2)
1.4142135623730951
 Import de modules(4) Import de modules(5)
41 Atef Boujelben 42 Atef Boujelben

3eme Manière : Importation de toutes les fonctions d’un module La troisième manière représente l’avantage d’accéder directement

Syntaxe: aux fonctions mais représente également l’inconvénient

>>>from nom_module import * d’encombrement de l’espace de noms réservés et la possibilité de

conflit entre deux fonctions ayant le même identificateur provenant
Exemple: de deux modules différents !!!
Exemple:
>>>from numpy import *
>>> from math import *
Les fonctions du module sont directement accessibles
Les deux contiennent la fonction sqrt , l’une définie pour les réels
>>> sqrt(2)
l’autre sur les tableaux! Laquelle sera utilisée ?
1.4142135623730951

Instructions Elémentaires: Instructions Elémentaires:

Affectation(1) Affectation(2)
43 Atef Boujelben 44 Atef Boujelben

L’opérateur est = Affecter plusieurs valeurs à plusieurs variables

Syntaxe Syntaxe
nom = valeur ou expression
nom1, nom2, nom3, … = v1ou exp1, v2 ou exp2, v3 ou exp3,…

Identificateur Objet Il faut respecter le nombre

- Identité
- Type Exemple:
- Données >>> a, b = 4, 8.33
>>> a
- L’identité et le type d’un objet sont inchangeables.
- Une fois l’objet n’est plus référencé, il est détruit automatiquement. 4
- Les identificateurs au format __nom__ sont réservés à l’interpréteur >>> b
Python 8.33
 Instructions Elémentaires: Instructions Elémentaires:
Affectation(3) Affectation(4)
45 Atef Boujelben 46 Atef Boujelben

Affecter une valeur à plusieurs variables

Syntaxe
nom1 = nom2 = nom3 = … = valeur ou expression

Exemple :
>>> x = y = 7
>>> x
7
>>> y
7

Instructions Elémentaires: Affectation: exemple

Affectation composée
47 Atef Boujelben 48 Atef Boujelben

Syntaxe
>>> n = 7 # donner à n la valeur 7
nom Opérateur= valeur ou expression 48

>>> msg = "Quoi de neuf ? " # affecter la valeur "Quoi de neuf ?" à msg
Exemple : >>> k = 3.6 # assigner sa valeur à la variable k

Mémoire
@
n 7 en binaire
@
msg « quoi de neuf » en binaire…

@
k 3,6 en binaire
.
.
.
Afficher la valeur d'une variable(1) Afficher la valeur d'une variable(2)
49 Atef Boujelben 50 Atef Boujelben

Pour afficher la valeur à l'écran, il existe deux possibilités:

2ème Méthode: utiliser print :
1ère méthode: entrer au clavier le nom de la variable puis <Enter>.
Exemple:
Exemple:
>>> print (msg)
>>> n
Quoi de neuf ? #pas de guillemets.
7
>>> msg
"Quoi de neuf ? " #affiche les guillemets, donc le type.
>>> k
Remarque: A partir de la version python 3, print devient une fonction
3.6

Print : Syntaxe PRINT : Exemple

51 Atef Boujelben 52 Atef Boujelben

Paramètres Optionnels
Le descripteur vers lequel
print envoie ces données print('Ceci est une chaine')
(par défaut : l’écran)
print( "Ceci est une chaine")
print(value,
< ..., sep=' ', end='\n', file=[Link]) print( """Ceci est une chaine""") ou print('''Ceci est une chaine''')

Toutes les combinaisons possibles de : Chaine ajoutée à la fin du

chaines, variables et expression message imprimé Quelle est la différence?
(par défaut : retour à la
Séparateur ligne)
(par défaut :
espace)
 PRINT : Exemple PRINT : Exemple
53 Atef Boujelben 54 Atef Boujelben

Pourquoi les """ ?

Les séquences d’échappement INPUT

55 Atef Boujelben 56 Atef Boujelben
ENTRÉE / SORTIE

À l’intérieur d’une chaîne, le caractère antislash (\) permet de donner

une signification spéciale à certaines séquences de caractères : Nom_var = input( value )

Chaine : "saisir..." ou 'saisir...' ou """

Nom de la saisir..."""
variable Nom d’une variable
 INPUT Entrée / sortie: INPUT
57 Atef Boujelben 58 Atef Boujelben

Ecrire l’instruction qui permet de saisir un entier x. On procéde de la même manière pour la saisie de valeurs de
Diviser x par 2. Qu’est ce que vous remarquez? types booléen (bool) ou réel (float).

x est considéré comme

chaine de caractère.

Il faut la transformer en entier

En utilisant : int

Types composés(1) Types composés: Définitions

59 Atef Boujelben 60 Atef Boujelben

Conteneur : est un objet destiné à contenir d’autres objets.

Itérable: objet qui supporte l’itération. On utilise tour à tour
chaque élément.
Mutable : la modification est autorisée.
Non mutable (Immutable ): la modification n’est pas autorisée.
Ordonnés : les éléments sont indexés.
Non ordonnés : les éléments ne sont pas indexés.
Types composés: les types mutables (listes, dictionnaires,
ensembles et array) et non mutables (tuples et chaînes).

Array
 séquence(1) séquence(2)
61 Atef Boujelben 62 Atef Boujelben

Une séquence est un conteneur ordonné d’éléments indexés par

S[a:b] sous séquence d’éléments allant de l’indice a inclu
des entiers indiquant leurs positions dans le conteneur.
jusqu’à l’élément d’indice b exclu
Les indices commencent par 0
S[Link] sous séquence d’ éléments de l’indice a inclu jusqu’à
Si S est une séquence:
indice b exclu par pas égal à c
S[i] retourne i+1 ème élément de S
3 Types de séquences :
S[ :a] sous séquence d’éléments de début jusqu’à l’élément
Les listes
d’indice a exclu
Les chaînes
S[a: ] sous séquence d’éléments de l’indice a inclus jusqu’à la fin
Les tuples
S[ : ] toute la séquence

séquence: les listes les listes: Indexation et Slicing

63 Atef Boujelben 64 Atef Boujelben
Création et accès Slicing
>>> L=[1,2, 3,6,1.5, 'bonjour',"bonsoir"] >>> L[3:]
Une liste est une collection ordonnée et modifiable d’objets >>> len(L)
7 [6, 1.5, 'bonjour', 'bonsoir']
éventuellement hétérogènes séparés par des virgules et définis >>> L[:5]
>>> 1.5 in L
entre crochets [ ]. True [1, 2, 3, 6, 1.5]
>>> 1.5 not in L >>> L[2:5]
len(L) nombre d’éléments . False
[3, 6, 1.5]
>>> L[0]
L[i] élément de rang i. 1 >>> L[Link]
>>> L[len(L)-1] [2, 6, 'bonjour']
Un indice négatif permet d'accéder aux éléments à partir de la 'bonsoir' >>> L[1::2]
>>> L[-1] [2, 6, 'bonjour']
fin (dernier L[-1] et son premier -len[L]) 'bonsoir'
>>> L[:] >>> L[::-1]
list(): permet de donner la liste des éléments. ['bonsoir', 'bonjour', 1.5, 6, 3,
[1, 2, 3, 6, 1.5, 'bonjour', 'bonsoir']
>>> L[7] 2, 1]
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
L[7] IndexError: list index out of range
 les listes: indexation et Slicing méthodes des objets listes(1)
65 Atef Boujelben 66 Atef Boujelben
>>>L_vide=[]
insert(i, x)
>>>L=[1, 3, 5, 2]
Insère un élément à une position donnée. Le premier argument
>>>L+[0,3,1] # l’opérateur + concatène les listes et donne une est l'indice de l'élément avant lequel il faut insérer, donc
nouvelle liste [1,3,5,2,0,3,1] [Link](0, x) insère au début de la liste, et [Link](len(a), x)
>>> L # L reste inchangée !!!! insère à la fin de la liste
[1, 3, 5, 2] append(x)
>>>L*2 # L’opération list*n ou n*list concatène n copies de la liste Equivalent à [Link](len(a),x)
[1, 3, 5, 2, 1, 3, 5, 2] remove(x)
>>>L=L*2 Enlève le premier élément de la liste dont la valeur est x. Il y a
>>>L #[1, 3, 5, 2, 1, 3, 5, 2] erreur si cet élément n'existe pas.
extend(L)
>>>L=list(range(5))
La méthode extend() permet d'ajouter les éléments d'une liste 'L'
>>> L à la liste à laquelle la méthode est appliquée.
[0, 1, 2, 3, 4]
>>> L+[1]*4
[0, 1, 2, 3, 4, 1, 1, 1, 1]
>>> max(L)# min (L)

méthodes des objets listes(2) méthodes des objets listes(3)

67 Atef Boujelben 68 Atef Boujelben

index(x) >>> [Link](5)

Retourne l'indice dans la liste du premier élément dont la valeur >>> L
est x. Il y a erreur si cet élément n'existe pas. >>> L is L1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 5]
True
sort() >>> L1=L
>>> L is L2
Trie les éléments à l'intérieur de la liste. >>> L1
False
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 5]
reverse()
>>> L2=L [:]
Renverse l'ordre des éléments à l'intérieur de la liste.
count(x)
Renvoie le nombre de fois que x apparaît dans la liste.
pop(i)
Cette méthode vous permet de retirer l'élément figurant à l'index
'i' d'une liste et de le retourner. S’il n’y pas d’argument, elle
retire le dernier élément.
 méthodes des objets listes(4) Copie d’une liste(1)
69 Atef Boujelben 70 Atef Boujelben
>>> nbr=[17,38,10,25,72] >>> nbr[1:3]=[14,17,2]
>>> [Link]() >>> nbr >>> L=list(range(10))
>>> nbr [11, 14, 17, 2, 17, 10] >>> L
[10, 17, 25, 38, 72] >>> [Link]() [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [Link](12) 10
>>> nbr
>>> L1=L # Attention les deux listes référencient le même objet en
>>> [Link]() mémoire
[10, 17, 25, 38, 72, 12] 17
>>> [Link]() >>> [Link](5) # ajoute 5 en fin de liste
>>> nbr
>>> nbr
[11, 14, 17, 2]
>>> L1
[12, 72, 38, 25, 17, 10] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
>>> [Link]([17,3,6])
>>> [Link](38) >>> id(L), id(L1)
>>> nbr >>> nbr
[12, 72, 25, 17, 10] [11, 14, 17, 2, 17, 3, 6] (46713952, 46713952)
>>> [Link](17) >>> [Link](17)
3 2
>>> nbr[0]=11 >>> [Link](0,7)
>>> nbr >>> nbr
[11, 72, 25, 17, 10] [7, 11, 14, 17, 2, 17, 3, 6]

Copie d’une liste(2) Les méthodes sur les listes

71 Atef Boujelben 72 Atef Boujelben

Pour recevoir une copie de liste indépendante, plusieurs manières [Link](x) ajouter un élément à une liste
existent:
>>> L2=L[:] [Link](L) ajouter des éléments à une liste
>>> id(L),id(L1),id(L2) [Link](i,x) insérer un élément à une place précise
(46713952, 46713952, 37856880)
[Link](x) supprimer la première occurrence d’un élément
Ou encore
>>>from copy import * [Link](i) retirer un élément en position donnée et le retourner
>>> L3=copy(L) [Link](x) avoir la position de la première occurrence d’un élément
>>> id(L), id(L1),id(L2), id(L3),
[Link](x) avoir le nombre d’occurrences d’un élément
(46713952, 46713952, 37856880, 46752632)
Ou encore [Link]() trier les éléments d’une liste
>>>L4=deepcopy(L) [Link](reverse=True) trier les éléments d’une liste dans l’ordre inverse
>>> id(L),id(L4)
(46713952, 48780672) [Link]() inverser l’ordre dans la liste
L3=copy(list) Copier le liste
 Les chaînes de caractères(1) Les chaînes de caractères(2)
73 Atef Boujelben 74 Atef Boujelben

Une chaine de caractères est une séquence de caractères unicode. >>> ch="bonjour"
>>> len(ch)
la classe str, >>> ch_vide=""
7
Syntaxe: C’est une séquence de caractères entre simple, double ou >>> ch_n_vide=" "
>>> ch[:3]
triple côtes . >>> ch_vide==ch_n_vide
'bon‘
Exemple: False
>>> ch1=‘Bonjour' >>> ch[3:]
>>> ch[0]
>>> type(ch1) 'jour'
<class 'str'> 'b'
>>> ch_vide=" >>> ch[2:5]
>>> ch[-1]
>>>ch_vide1= "" 'njo'
>>> ch=''' ''' 'r‘
>>>ch_vide==ch_vide1 >>> ch[::-1]
True 'ruojnob'

Les chaînes de caractères(3) Méthodes pour les chaînes(1)

75 Atef Boujelben 76 Atef Boujelben
>>>ch=’’TototiTi’’
Opérateurs + et * isupper() et islower()
>>> ch='bon' retournent True si la chaîne ne contient respectivement que des
majuscules/ minuscules :
>>> ch1='jour' >>> [Link]()
>>> ch +ch1 False
istitle()
'bonjour‘ retourne True si seule la première lettre de chaque mot de la chaîne
>>> ch2=ch +ch1 est en majuscule :
>>> [Link]()
>>> ch2*3 'bonjourbonjourbonjour' False
isalnum(), isalpha(), isdigit() et isspace() :
retournent True si la chaîne ne contient respectivement que des
caractères alphanumériques, alphabétiques, numériques ou des
espaces : >>> [Link]()
True
Méthodes pour les chaînes(2) Méthodes pour les chaînes(3)
77 Atef Boujelben 78 Atef Boujelben

strip(chars='\t\n\r\x0b\x0c')
upper() : retourne une chaîne de caractères dans laquelle ont été supprimés
permet de convertir la chaine en majuscule tous les caractères spécifiés par l’argument chars, en début et fin
>>> [Link]() # le résultat est une nouvelle chaîne de chaîne. Par défaut, chars contient tous les espaces
'TOTOTITI‘ >>> ch='bonjour tout le monde \n'
>>> ch >>> [Link]()
'TotoTiTi‘ 'bonjour tout le monde‘
split () La méthode split transforme une chaine de caractères en
lower(): liste.
permet de convertir la chaine en minuscule >>> [Link]()
>>> [Link]() ['bonjour', 'tout', 'le', 'monde']
'tototiti' eval(): sert à évaluer une chaine de caractère comme une
>>> ch=[Link]() expression python
>>> ch a=3
'TOTOTITI’ >>> print (eval("a == 2"))#False
>>> print (eval("2 + 4"))# 6

Méthode/fonction Signification
Méthodes pour les chaînes(4) isupper() , islower() retournent True si la chaîne ne contient respectivement que des majuscules/
minuscules
istitle() retourne True si seule la première lettre de chaque mot de la chaîne est en
79 Atef Boujelben 80 Atef Boujelben
majuscule
isalnum(), isalpha(), retournent True si la chaîne ne contient respectivement que des caractères
Les méthodes (split, join): split permet de découper une chaîne en isdigit() et isspace() alphanumériques, alphabétiques, numériques ou des espaces
une liste de sous-chaînes. La méthode join est l’inverse de la upper() , lower() permet de convertir la chaine en majuscule et en minuscule
méthode split. strip() retourne une chaîne dans laquelle ont été supprimés tous les caractères
>>> t = "être ou ne pas être, là est la question" spécifiés par l’argument chars, en début et fin de chaîne
split () La méthode split transforme une chaine de caractères en liste.
join La méthode join est l’inverse de la méthode split.
[Link](suffix) Renvoie True si la chaine str se termine par la chaine suffix
[Link](prefix) Renvoie True si la chaine str commence par la chaine prefix

# joint: joindre les chaînes de la liste, avec un séparateur vide [Link](old,new[,n]) Renvoie une chaine obtenue en remplaçant old par new, au plus n fois
[Link](sub) Indice de la première occurrence de sub(-1 si non trouvé)
[Link](sub) Comme find , mais erreur ValueError si non trouvé

# joint: joindre les chaînes de la liste en séparant par * [Link](sub) Comme index, mais de la dernière occurrence
[Link](sub) Indice de la dernière occurrence de sub (et -1 si non trouvé)
eval() sert à évaluer une chaine de caractère comme une expression python
 Les séquences : Les tuples Les séquences : Les tuples (2)
81 Atef Boujelben 82 Atef Boujelben

Un tuple (appelé également n-uplet) est une collection ordonnée et

non modifiable d’éléments éventuellement hétérogènes. Un problème particulier (tuple 0 ou 1 élément):
Les tuples vides construits avec des parenthèses vides;
Syntaxe
Éléments séparés par des virgules. Un tuple avec un élément est construit en faisant suivre une
>>> t = 1245,21, 'bonjour!'
valeur d’une virgule
>>> t
(1245, 21, 'bonjour!') Les éléments du tuple sont affichés séparés par Par exemple :
>>> t[0] des virgules et entourés par des parenthèses
>>> empty = ()
1245
>>> t[-1] >>> singleton = 'salut', # notez la virgule en fin de ligne
'bonjour!'
Les Tuples peuvent être imbriquués: >>> len(empty) , len(singleton), singleton
>>> u = t, (1, 2, 3, 4, 5) (0, 1, ('salut',))
>>> u
((1245, 21, 'bonjour!'), (1, 2, 3, 4, 5))

Tuple par comprehension Remarque

83 Atef Boujelben 84 Atef Boujelben

# un tuple défini en compréhension Les chaînes et les Tuples n’étant pas modifiable, mais il est possible
>>> t = tuple(x*x for x in range(1,9)); t ; id(t) de migrer vers des listes au moyen de l’instruction suivante list:
(1, 4, 9, 16, 25, 36, 49, 64)
>>> t=(1,2,3)
53220816 >>> t=list(t)
>>> type(t)
# concaténation de deux tuples <class 'list'>
(1,2,3)+(4,5) >>> [Link](5)
(1, 2, 3, 4, 5) >>> t
[1, 2, 3, 5]
Remarque: Les méthodes appliquées à un tuple T sont : >>> ch=‘’Bonjour ‘’
len (T), a in T, [Link](a), [Link](a) >>>list (ch)
['b', 'o', 'n', 'j', 'o', 'u', 'r']
 ARRAY(1) ARRAY(2)
85 Atef Boujelben 86 Atef Boujelben
Syntaxe
array(object, dtype=None, copy=True, order=None, subok=False,
ndmin=0) order : (optionnel) (C (par défaut), F ou A) concerne l’ordre de
parcours du tableau dans la mémoire.
object : le tableau

dtype : (optionnel) le type des données du tableau. Si ce champ

subok : (optionnel) (True (par défaut) ou False) si vrai, les sous-
n’est pas définit alors Python affecte le type minimal nécessaire
pour la plus grande valeur du tableau. classes seront refacturés, sinon le tableau retourné sera obligé d'être
un tableau de classe de base (par défaut).
copy : (optionnel) (True (par défaut) ou False) lié à la gestion de la
mémoire. Si vrai (par défaut), l'objet est copié. Sinon, une copie ne
sera faite que si __array__ renvoie une copie, si obj est une ndmin : (optionnel) pour fixer la dimension du tableau.
séquence imbriquée, ou si une copie est nécessaire pour satisfaire
à une des autres exigences (dtype, order, etc.).

ARRAY: exemple(1) ARRAY:exemple(2)

87 Atef Boujelben 88 Atef Boujelben

>>> import numpy as n

>>>[Link]([Link]('1 2; 3 4'))
>>> [Link]([1, 2, 3])
array([[1, 2],
array([1, 2, 3])
[3, 4]])
>>> [Link]([1, 2, 3.0])
array([ 1., 2., 3.])
>>> [Link]([[1, 2], [3, 4]])# 2D
Création d'un tableau de sous-classes:
array([[1, 2],
>>>[Link]([Link]('1 2; 3 4'))
[3, 4]])
array([[1, 2],
[3, 4]])
>>> [Link]([1, 2, 3], ndmin=2)#Minimum 2 dimensions
>>> [Link]([Link]('1 2; 3 4'), subok=True)
array([[1, 2, 3]])
matrix([[1, 2],
[3, 4]])
>>>[Link]([1, 2, 3], dtype=complex)#Type bien définit

array([ 1.+0.j, 2.+0.j, 3.+0.j])

 Un dictionnaire(1) Un dictionnaire(2)
89 Atef Boujelben 90 Atef Boujelben

>>> d={1:'janvier', 2:'février',3:'mars'}

Un dictionnaire (tableau associatif) est un type de données >>> d
{1: 'janvier', 2: 'février', 3: 'mars'}
permettant de stocker des couples cle:valeur, avec un accès très
>>> type(d)
rapide à la valeur à partir de la clé, la clé ne pouvant être présente <class 'dict'>
qu’une seule fois dans le tableau. Ces caractéristiques sont:
>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__doc__',
L’opérateur d’appartenance d’une clé (in) ; '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
La fonction taille (len()) donnant le nombre de couples stockés ; '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
Permet de retrouver un objet par sa clef '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
Il est itérable (on peut le parcourir) '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',
Non ordonné 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault',
Mutable. 'update', 'values']
Python propose la class dict.

Un dictionnaire(3) Un dictionnaire(4)
91 Atef Boujelben 92 Atef Boujelben

>>> d
>>> help([Link])
{1: 'janvier', 2: 'février', 3: 'mars'}
Help on method_descriptor:
>>> len(d)
keys(...)
3
[Link]() -> a set-like object providing a view on D's keys
>>> [Link]()
>>> d.__setitem__(4,'avril')
dict_items([(1, 'janvier'), (2, 'février'), (3, 'mars')])
>>> d
>>> [Link]()
{1: 'janvier', 2: 'février', 3: 'mars', 4: 'avril'}
dict_keys([1, 2, 3])
>>> [Link](6)
Traceback (most recent call last): >>> from copy import *
File "<pyshell#58>", line 1, in <module> >>> d2=copy(d)
[Link](6) >>> d2
KeyError: 6 {1: 'janvier', 2: 'février', 3: 'mars'}
>>> [Link](4)
'avril'
 len(dic) Renvoie la longueur du dictionnaire

Un dictionnaire(5) dic[cle] Renvoie la valeur associée à la clé (KeyError si la clé est absente)
dic[cle]=val Crée (ou modifie) une paire clé/valeur
93 Atef Boujelben del
94 dic[cle] Efface une paire clé/valeur Atef Boujelben

cle in dic Renvoie True si la clé est présente dans le dictionnaire, False sinon
Un dictionnaire en “compréhension”, cle not in dic Renvoie True si la clé est absente du dictionnaire, False sinon
[Link]() Efface le contenue du dictionnaire
[Link]() Renvoie une copy du dictionnaire
>>> D = {x:x*2 for x in range(10)}
[Link](cle) Renvoie la valeur associée à la clé, et renvoie None si la cle est absente
>>> D
[Link](cle,def) Renvoie la valeur associée à la clé, et renvoie def si la cle est absente
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
[Link]() Renvoie un itérable pour décrire les couples (clé,valeur) dans une boucle for
[Link]() Renvoie un itérable pour décrire les clés du dictionnaire dans une boucle for

[Link](cle) Renvoie la valeur et supprime la paire clé/valeur( KeyError si la clé est

absente)
[Link](dic2) Fusionne le dictionnaire dic2 avec dic( ici dic2 peut être une liste de
liste[cle,valeur] )
[Link]() Renvoie un itérable pour décrire les valeurs du dictionnaire dans une boucle for

tri d’un dictionnaire (1) tri d’un dictionnaire (2)

95 Atef Boujelben 96 Atef Boujelben

En python, l'objet dict ne conserve pas l'ordre dans lequel les

Tri des clés de l'objet dict
éléments sont ajoutés et ne possède pas de
fonction sort permettant de trier les données suivants les clés ou >>> sorted(d1)
les valeurs. ['a', 'a1', 'b', 'b1', 'c', 'c1', 'd', 'd1']
Pour trier un objet dict, il suffit d'utiliser la fonction sorted.
Cette fonction retourne une liste contenant les valeurs triées. Tri de l'objet dict en fonction des clés
Dans le cas d'un objet dict, les données (clés + valeurs) sont >>> sorted([Link]())
converties en tuple. [('a', 1), ('a1', 5), ('b', 2), ('b1', 10), ('c', 3), ('c1', 8), ('d', 4), ('d1', 6)]
Exemple:
>>> d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'a1': 5, 'b1': 10, 'c1': 8, 'd1': 6} Tri de l'objet dict dans l’ordre inverse en fonction des clés
>>> print(d1) >>> sorted([Link](),reverse=True)
{'d1': 6, 'c': 3, 'd': 4, 'b': 2, 'a1': 5, 'c1': 8, 'b1': 10, 'a': 1}
[('d1', 6), ('d', 4), ('c1', 8), ('c', 3), ('b1', 10), ('b', 2), ('a1', 5), ('a', 1)]
On voit que l'ordre d'insertion n'a pas été conservé.
tri d’un dictionnaire (2) ensemble
97 Atef Boujelben 98 Atef Boujelben

On peut utiliser la fonction sorted en prenannt en paramètre la

liste des données (clé + valeurs) de l'objet dict (la Un ensemble est une collection non ordonnée et mutable d’objets
fonction items() de l'objet dict) et en clé de tri, une uniques. Les ensembles sont des structures non indexées !
fonction lambda indiquant l'indice à utiliser pour le tri.
Syntaxe: Ensemble d’objets séparés par des virgules entre { }
L'indice '0' (zéro) indique la clé de l'objet dict. >>> S={1,1,3,3,'a','b','ccc',2,2,1,'a','a','bb'}
L'indice ‘1‘ indique les valeurs de l'objet dict. >>> S
{'a', 1, 2, 'b', 'bb', 3, 'ccc'}
>>> sorted([Link](), key=lambda t: t[0]) >>> [Link](8)
[('a', 1), ('a1', 5), ('b', 2), ('b1', 10), ('c', 3), ('c1', 8), ('d', 4), ('d1', 6)] >>> S
{'a', 1, 2, 'b', 'bb', 3, 'ccc', 8}
>>> sorted([Link](), key=lambda t: t[1])
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('a1', 5), ('d1', 6), ('c1', 8), ('b1', 10)]

Les ensembles: opérations Les ensembles: les fonctions

prédéfinis (1)
99 Atef Boujelben 100 Atef Boujelben
>>> e={1,2,3,'E','E','R','A',3,3,2,6}
>>> e Méthodes/Fonction Signification
{'A', 1, 2, 3, 'E', 6, 'R'} len(ens) Renvoie le cardinal (le nombre d’éléments ) de l’ensemble
>>> e2=set([1,2,3,'k','j',2,2,'L','A',3,3,2,6]) [Link](ens2) Renvoie True si Ens est inclus dans ens2
>>> e2 [Link](elt) Ajoute un élément à l’ensemble
{'A', 1, 2, 3, 6, 'k', 'j', 'L'} [Link](elt) Retire un élément à un ensemble(KeyError si élément
>>> type(e),type(e2) absent)
(<class 'set'>, <class 'set'>) [Link](elt) Retire un élément à un ensemble s’il y est effectivement
>>> e|e2 #opération d'union elt in ens Renvoie True si élément est présent dans l’ensemble, False
{'A', 1, 2, 3, 'E', 6, 'k', 'j', 'L', 'R'} sinon
>>> e&e2 # opération d’intersection elt not in ens Renvoie True si élément absent dans l’ensemble
{'A', 1, 2, 3, 6} [Link]() Efface le contenu de l’ensemble
>>> e-e2 # opération de différence [Link]() Renvoie une copie de l’ensemble, indépendante de
{'R', 'E'} l’origine
>>> e^e2# la différence symétrique [Link]() Renvoie et supprime un elélement arbitraire de
{'E', 'k', 'j', 'L', 'R'} l’ensemble(KeyError si ensemble vide)
 Les ensembles: les fonctions
Structures de contrôle
prédéfinis (2)
101 Atef Boujelben 102 Atef Boujelben

Méthodes/Fonction Méthodes/Fonction
Les structures de contrôle sont les groupes d'instructions qui
[Link](ens2) Renvoie True si ens1 et ens2 sont disjoints
ens1<=ens2 Renvoie True si ens1 est inclus dans ens2
déterminent l'ordre dans lequel les actions sont effectuées dans
ens1<ens2 Renvoie True si ens1 est inclus strictement dans ens2 le programme.

ens1>=ens2 Renvoie True si ens1 contient ens2

En programmation moderne, il en existe seulement trois : la
ens1>ens2 Renvoie True si ens1 contient strictement ens2
séquence, la sélection que nous allons décrire dans ce qui suit, et
ens1|ens2|ens3|.. Renvoie l’union des ensembles la répétition.
ens1& ens2&ens3&.. Renvoie l’intersection des ensembles
ens1-ens2 Renvoie la différence ensemblistes ens1\ens2
ens1^ens2 Renvoie la différence symétrique ens1 delsta ens2

Structures conditionnelles L’instruction if

103 Atef Boujelben 104 Atef Boujelben

vrai
if condition :
L’instruction if faux
instructions_si_vrai
L’instruction if ..else
if conditions :
L’instruction if .. elif and / or / not
instructions_si_vrai

if conditions : instructions_si_vrai
Le bloc if est comporte une seule
instruction : une seule ligne
 L’instruction else L’instruction elif
105 Atef Boujelben 106 Atef Boujelben
vrai
if conditions : C’est l’instruction else : if

instruction(s)_si _vrai faux

else :
instruction(s)_si_faux

if conditions : instruction
else : instruction

Attention à l’Indentation

L’instruction elif Opérateurs de comparaison(1)

107 Atef Boujelben 108 Atef Boujelben

C’est l’instruction else : if La condition évaluée après l'instruction «if» peut contenir les
opérateurs de comparaison suivants :

x == y # x est égal à y (deux signes « égale » et non d'un seul)

x != y # x est différent de y
x>y # x est plus grand que y
x<y # x est plus petit que y
x >= y # x est plus grand que, ou égal à y
x <= y # x est plus petit que, ou égal à y
 Instructions composées :
Opérateurs de comparaison(2) Blocs d'instructions
109 Atef Boujelben 110 Atef Boujelben

Sous Python, toutes les instructions composées ont toujours la

Exemple :
même structure : une ligne d'en-tête terminée par un double point,
>>> a = 7
suivie d'une ou de plusieurs instructions indentées sous cette ligne
>>> if (a % 2 == 0):
d'en-tête.
print("a est pair")
print ("parce que le reste de sa division par 2 est nul") Exemple :
Ligne d'en-tête:
else:
première instruction du bloc
print ("a est impair") ... ...
... ...
dernière instruction du bloc

Quelques règles de syntaxe

Python L’indentation: exemple(1)
111 Atef Boujelben 112 Atef Boujelben
La solution proposée par un étudiant pour l’exemple précédant
est la suivante :

Les blocs d'instructions sont toujours Pas de begin et end

associés à une ligne d'en-tête contenant Pas {…}

une instruction bien spécifique (if, elif, Pas de FINSI
else, while, def, ...) se terminant par un
En Python c’est l’indentation :
double point
C’est l'ajout de tabulations à
une ligne (le retrait de la ligne
par rapport à la norme).
 Structures itératives :
L’indentation: exemple(2) l'instruction while(1)
113 Atef Boujelben 114 Atef Boujelben

La solution doit être : Une des méthodes pour programmer les tâches répétitives est
l'instruction while.

Syntaxe:

while (condition(s)):
Instruction(s)

Structures itératives : Structures itératives :

l'instruction while(2) l'instruction while(3)
115 Atef Boujelben 116 Atef Boujelben

Exemple:
Commentaires
1. Entrer les commandes ci-dessous
1. Dans notre exemple, si la condition a < 7 est encore vraie, le
>>> a = 0
>>> while (a < 7): # (n'oubliez pas le double point !) corps de la boucle est exécuté une nouvelle fois et le bouclage
... a = a + 1 # (n'oubliez pas l'indentation !) se poursuit.
... a
2. La variable évaluée dans la condition doit exister au préalable (Il
2. Frappez sur <Enter>
faut qu'on lui ait déjà affecté au moins une valeur)
3. Que se passe-t-il ?
4. Changez la valeur a par 8
 Structures itératives : Structures itératives :
l'instruction while(4) La Boucle For(1)
117 Atef Boujelben 118 Atef Boujelben

3. Si la condition est fausse au départ, le corps de la boucle n'est La boucle for fonctionne sur les chaînes, les listes, les tuples et

jamais exécuté d’autres objets issus de classes.

4. Si la condition reste toujours vraie, alors le corps de la boucle est

répété indéfiniment. Elle commence par une ligne d’entête qui spécifie une cible
d’affectation, ainsi qu’un objet qui sera itéré .
Exemple de boucle infinie:
Le for de Python affecte les objets de l’élément séquence à la
>>> n = 3 cible un par un.
>>> while n < 5:
... "hello !"

Structures itératives : Structures itératives :

La Boucle For(2) La Boucle For(3)
119 Atef Boujelben 120 Atef Boujelben

Syntaxe:
Exemple:
for <cible> in <objet>:
>>> for caractere in "bonjour":
<instructions>
print(caractere)

Si séquence possède n éléments, le bloc sera exécuté n fois, et la

b
variable référencera l’élément sequence[n-1] qui sera accessible o
n
dans le bloc.
j
o
u
r
Utilisation du break, continue,
pass Le Range(1)
121 Atef Boujelben 122 Atef Boujelben

Ces trois instructions permettent à l’utilisateur d’avoir un plus grand

contrôle de la boucle. L’instruction range permet de créer une liste croissante d’entiers

L’instruction break permet de sortir de la boucle instantanément et successifs compris dans une certaine borne dépendant du nombre

de passer à la suite. de paramètres de l’instruction :

L’instruction « continue » saute au début de la boucle la plus 1 paramètre : entiers compris entre 0 et le paramètre

imbriquée. Syntaxe:

« pass » ne fait rien du tout mais, comme on ne peut avoir une for i in range(a):

expression qui n’est suivie de rien, « pass » peut être utilisé pour instructions

combler ce vide.

Le Range(2) Le Range(3)
123 Atef Boujelben 124 Atef Boujelben

2 paramètres : entier compris entre param1 et param2

Exemple1 :
Syntaxe:
for i in range(a,b):
range(5) désigne les entiers 0,1,2,3,4 (la borne prend par défaut 0)
instructions
range(1, 10) désigne les entiers 1, 2, 3, 4, 5, 6, 7, 8, 9
3 paramètres : entier compris entre parm1 et param2 et de pas
range(1, 11, 2) désigne les entiers 1, 3, 5, 7, 9
param3
range(10, 0, -1) désigne les entiers 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
Syntaxe:
for i in range(a,b,c):
instructions
 Le Range(4) Le Range(5)
125 Atef Boujelben 126 Atef Boujelben

Exemple3 :
Exemple2 : >>>L=list(range(5))
>>>L
for i in range(10,20,2): [0,1,2,3,4]
print( i) >>>L1=[]
>>>for k in L:
[Link](k**2)
Ce qui donne: 10 >>> L1
12 [0, 1, 4, 9, 16]
14 >>>ch= ‘azerty’
16 >>>ch1=‘’
18 >>>for c in ch:
ch1=ch1+c*2
>>>ch1
aazzeerrttyy

Le Range(6)
127 Atef Boujelben

Exemple4 : Construction de listes par compréhension

>>> L= [i for i in range(1,21,2)]
>>>L
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>>L=[(i,j) for i in range (1,5) for j in range (1,5)]
>>>L
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3),
(3, 4), (4, 1), (4, 2), (4, 3), (4, 4)]
>>>L=[(i,j) for i in range (1,5) for j in range (1,5) if (i+j) %2 ==0]
>>>L
[(1, 1), (1, 3), (2, 2), (2, 4), (3, 1), (3, 3), (4, 2), (4, 4)]