UFR / SFI

Base du langage Python

Dr Pascal FAYE
 Introduction
Principales caractéristiques
• Interprété, multi-paradigme et multiplateformes.
• Favorise la programmation impérative structurée, fonctionnelle et orientée objet.
• Typage dynamique fort, d'une gestion automatique de la mémoire par ramasse-miettes
et d'un système de gestion d'exceptions ; il est ainsi similaire à Perl, Ruby, Scheme,
Smalltalk et Tcl.

Portable
Python est portable entre les différentes variantes de Unix ainsi que sur les S.E
propriétaires comme Mac OS et les différentes versions de Windows.

Gratuit
•Python est placé sous Général Public License. Il est facilement à télécharger sur www.python.org
•Sa première version est du 20 février 1991, par Guido van Rossum.
•Extension de fichier: py, pyc, pyd, pyo, pyw et pyz.

2 Dr Pascal FAYE 14/02/2024

 Introduction
Extensible
Au-delà de la multitude de librairies et de modules déjà existent, il est possible d’en
développer pour ses propres besoins.

Modulable
Python permet de séparer les programmes en modules qui peuvent être réutilisés dans
d'autres programmes en Python

Orienté Objet
Python est orienté-objet. Il supporte l'héritage multiple et la surcharge des opérateurs.

Syntaxe aisée
La syntaxe de Python est très simple et, combinée à de nombreux types de données
évolués (comme les listes, dictionnaires, tuples...), ce qui conduit à des programmes à la
fois très compacts et très lisibles. De plus, Python ne nécessite aucune déclaration de
variable. Les variables sont créées lors de leur première assignation.
3 Dr Pascal FAYE 14/02/2024
Introduction

Peu d’erreurs…
Tout comme Java ou Ada, Python possède un système d’exception qui
facilite la gestion des erreurs.

Gestion des ressources

Python gère ses ressources (mémoire, descripteurs de fichiers...)
sans intervention du programmeur, par un mécanisme de comptage
de références

Sensible à la casse des lettres

Une instruction par ligne

4 Dr Pascal FAYE 14/02/2024

 Domaines d’application
• Scripts d’administration systemes
ex : Les programmes d'administration système spécifiques à la distribution Red Hat
Linux.
• Tous les dévelloppement lié à l’internet et en particulier au web (moteur de recherche,
navigateur…)
ex : moteurs de recherche yahoo et infoseek
• Accès aux bases de donnée (contextuelle)
• Réalisations d’interfaces graphiques utilisateurs.
• Utilisation pour la résolution de calculs scientifiques
•…
Visiter:
https://www.python.org/doc/
https://python.developpez.com/

5 Dr Pascal FAYE 14/02/2024

Prérequis
 La librairie numpy contient des fonctions essentielles
pour traiter les tableaux, les matrices et les opérations de
type algèbre linéaire avec Python.

 La librairie Matplotlib permet de générer directement

des graphiques à partir de Python. Matplotlib est
compatible avec beaucoup de plateformes, et capable de
générer des graphiques dans beaucoup de formats
différents.

6 Dr Pascal FAYE 14/02/2024

Prérequis
 Installations de numpy et matplotlib
1. pip install numpy
2. pip install matplotlib

7 Dr Pascal FAYE 14/02/2024

Autres prérequis

8 Dr Pascal FAYE 14/02/2024

Autres prérequis

9 Dr Pascal FAYE 14/02/2024

 Généralités et premiers pas avec Python

10 Dr Pascal FAYE 14/02/2024

Les principaux opérateurs pour les types
numériques
 Tableau (dans un ordre de priorité croissant):

11 Dr Pascal FAYE 14/02/2024

 Quelques remarques…

 Lors de mélange de types numériques lors d’une opération, la réponse sera du

type de l’opérande la plus complexe.
 En Python, vrai signifie n’importe quel nombre différent de zéro ou un objet
non vide; faux signifie zéro, none et un objet vide (un ex.: “a or b” retourne le
premier qui est vrai et si les 2 sont faux, retourne celui de droite (donc b))
 la dernière expression affichée est affectée à la variable. Si on affecte une
valeur à cette variable, on crée une variable locale qui masquera la globale.
 Si nous faisons c = d (où c et d sont 2 variables), c référencera le même objet
que d,
 Ainsi pour les listes, nous ferons une copie de cette manière c = d[:] et pour les
dictionnaires, nous utiliserons la méthode copy, c = d.copy().

12 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Les instructions :

Des commandes adressées à l’interpréteur impliquant l’emploi de mots-clés.

>>> print "Ceci est mon premier programme PYTHON"

Ceci est mon premier programme PYTHON
>>>

L’instruction print permet d’afficher la donnée fournie, en l’occurrence

une chaîne de caractères.

Les instructions peuvent ou non déboucher sur un résultat affiché.

Le symbole >>> et le curseur indiquent que l’interpréteur attend la prochaine

instruction Python.

13 Dr Pascal FAYE 14/02/2024

Généralités et premier pas avec Python

les expressions :

Il peut s’agir de simples équations, qu’on utilise avec des opérateurs arithmétiques,
ou de fonctions, qui sont appelées avec des parenthèses. Les fonctions peuvent ou
non accepter une entrée et retourner ou non une valeur.

>>> 3 - 5
-2
La fonction abs prend en entrée un nombre et
>>> abs(-7)
retourne sa valeur absolue.
7
>>> _ Le caractère souligné correspond à la dernière
7 expression évaluée.
>>>

La valeur de chaque expression est affichée à l’écran.

14 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Le signe dièse (#)

Les commentaires débutent toujours par un signe dièse (#).

Un commentaire peut débuter n’importe où sur une ligne.

Tous les caractères qui suivent le # sont ignorés par l’interpréteur,

jusqu’à la fin de la ligne.
Les commentaires servent, comme dans d’autres langages de
programmation, à documenter les programmes et améliorer leur lisibilité.

>>> # Place aux commentaires.

>>> print 1 / 3. # Division réelle.
0.333333333333
>>>

15 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Le caractère de fin de ligne (\n)

Il s’agit du retour à la ligne suivante

>>> print 10 + 5 \
La barre oblique inverse (\) (ou antislash). *4\
-7
Cela annonce que l’instruction n’est pas terminée et 23
qu’elle se poursuit à la ligne suivante. >>>

Il existe 2 cas particuliers où une instruction peut s’étaler sur plusieurs lignes
sans avoir besoin de barres obliques inverses :
Lorsqu’elle utilise des opérateurs comme les parenthèses, les crochets
ou les accolades.
Lorsque le caractère de retour à la ligne est inséré dans une chaîne
entourée de guillemets triples.
>>> print '''Place >>> print """Place
aux guillemets triples.''' aux guillemets triples."""
Place Place
aux guillemets triples. aux guillemets triples.
>>> >>>
16 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Le point-virgule (;) permet de regrouper 2 instructions sur la même ligne.

>>> -2 + 5; print 5 - 2
3
3
>>>

Python ne tient pas compte de la présentation :

• espaces
• et sauts de lignes.

Un programme pourrait s’écrire en quelques lignes même

si ce n’est pas conseillé pour des soucis de lisibilité et de maintenance
de code des programmes.

17 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Utilisation de l’interpréteur comme simple calculatrice

>>> -5 + 3
-2
>>> 8 + 4 * 6
32
>>> 22 // 3 Division entière
7
>>> 2 * (32 – 26)
12
Division réelle (l’entier 3 est converti en réel)
>>> 22. / 3
à cause de la présence du point décimal.
7.333333333333333
>>>

Avec la division: Si les opérandes sont tous deux des entiers, la partie entière du
résultat de la division sera retenue.
Autrement, il s’agira d’une véritable division réelle avec comme résultat une
valeur réelle.
18 Dr Pascal FAYE 14/02/2024
 Généralités et premiers pas avec Python

Utilisation de l’interpréteur comme simple calculatrice

// : Division entière. >>> 11 // 3
3
>>> 23 // 8
2
>>> -6 // 5
-2
>>> 12.8 // 1.1
11.0 Puisque les opérandes sont réelles,
>>> le résultat est réel.

% : Obtenir le reste de la division.

>>> 13 % 3
Si les opérandes sont entières, le
1
résultat l’est.
>>> 12.8 % 1.1
0.69999999999999973 Si les opérandes sont réelles, le
>>> -6 % 5 résultat l’est.
4
19 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Utilisation de l’interpréteur comme simple calculatrice

** l’opérateur d’exponentiation.
>>> 3.1 ** 2
9.6100000000000012
>>> 3.1 ** 2.0 >>> 3.1 * 3.1
9.6100000000000012 9.6100000000000012
>>> 3 ** -1
0.33333333333333331
>>> (-3)** 2
9
>>> 2 ** 0.5
1.4142135623730951 >>> 8 ** 2
>>> --5 64
5 >>> -8 ** 2
L’opérateur d’exponentiation a une règle de priorité particulière -64
lorsqu’on le combine avec d’autres opérateurs : il est exécuté >>> 8 ** -2
avant les opérateurs unaires placés à sa gauche, mais après les 0.015625
opérateurs unaires placés à sa droite. >>> (-8)**2
64
20 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Priorité des opérateurs :

+ et - *, /, //, % + et – unaires **
Bas de la hiérarchie Haut de la hiérarchie

>>> -3 + 5**2 -7 / 2 >>> -3 + 5**2 + -7 / 2

19 18

On peut utiliser les parenthèses pour clarifier la signification d’une expression

: (5 – 3) * 2 + 4.

21 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Qu’est-ce qu’une variable ?

Les programmes doivent mémoriser les données qu’ils utilisent.

Pour cela, les variables nous fournissent plusieurs représentations et méthodes

de stockage des informations.

Une variable est un emplacement en mémoire principale destiné à recevoir une

donnée. Cette zone reçoit une valeur qui peut ensuite être réutilisée.
La notion de variable est la même qu’en algorithme ou en langage C.
De même, en python, la taille d’une variable dépend de son type.
Types de données type associé en python Exemples
Entiers int 12, -999, 0, 900000, etc
réels float 4.5, 0.0003, -90.5, 3.0; etc
chaine de caractères str 'hello', "100", "$$$", ""; etc
22 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Identificateur de variable
L’identificateur doit indiquer le rôle joué par cette variable; il faut éviter d’utiliser
des noms qui n’évoquent rien. Ex. : Rayon au lieu de x.
Règles à respecter pour les noms de variables
Une séquence de lettres (a → z, A → Z) et de chiffres (0 à 9) qui doit toujours
commencer par une lettre. Le symbole _ est considéré comme une lettre.
Aucune lettre accentuée, cédille, espace, caractère spécial à l’exception
du caractère souligné _.
Les minuscules et les majuscules sont des lettres différentes.

Variable_entiere, entier1, mot, surface_r2 ➔ valides

Exemple :
1er_entier, nom.2, nom de variable, deuxième_entier, a-b ➔ Invalides.

Éviter d’utiliser le symbole _ comme premier caractère car il peut être utilisé pour
définir des entités spéciales pour Python (nous y reviendrons plus loin).
23 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Les 28 mots réservés ci-dessous ne peuvent être utilisés comme nom de

variable :

Attention : Python distingue les majuscules et les minuscules :

Rayon est différent de rayon.

Bien que la longueur des identificateurs ne soit plus un problème dans les
langages de programmation d’aujourd’hui, utilisez des noms de taille
raisonnable ayant une signification.
Il peut exister des limites qui peuvent changer d’un interpréteur à l’autre.
24 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Opérateur d’affectation ( = )
Syntaxe : identificateur_de_variable = expression

Exemple : >>> entier1 = 8

>>> entier2 = entier1 - 5
>>> entier1 = entier1 + 1
>>> print entier1, entier2
93
But : stocker la valeur d’une expression dans une variable.

Note : Les affectations ne sont pas des expressions; elles n’ont pas
de valeurs inhérentes mais, il est permis d’enchaîner
x plusieurs
affectations.
>>> x = 1
avant 1
>>> y = x = x + 1
>>> print x, y x y
22
>>> après 2 2

On ne peut pas écrire : y = (x = x + 1).

25 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Opérateur d’affectation ( = )

Dans le langage Python, ces instructions d’affectation réalisent les opérations

suivantes :
créer et mémoriser un nom de variable,
attribuer implicitement un type bien déterminé
▪ entier, réel, chaîne de caractères, …
associer une valeur particulière,

Établir un lien entre le nom de la variable et l’emplacement mémoire

renfermant la valeur associée.

Note : Pour définir le type des variables avant de pouvoir les utiliser, il suffit
d’assigner une valeur à un nom de variable pour que celle-ci soit
automatiquement créée avec le type qui correspond le mieux à la valeur
fournie. Python possède donc un typage dynamique et non un typage
statique (C++, JAVA).

26 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Affichage de la valeur d’une variable

>>> s = "Luc"
>>> entier = 3
>>> reel = 10.2
>>> s
Affichage de la chaîne de caractères s.
'Luc'
>>> entier, reel
(3, 10.199999999999999) Affichage des variables entier et reel.
>>> s = 1
>>> s Affectation d’une valeur à une variable s.
1 Cela signifie que l’ancienne variable s
>>> n’est plus accessible.
Ce mode d’affichage élémentaire est utilisé en mode interactif. Autrement, on opte pour print.
>>> chaine = "Yes! USSEIN"
>>> indice = 5
>>> print chaine, indice Les variables sont séparées par des virgules.
Yes! USSEIN 5
Notez les différences
>>> chaine, indice
entre les modes d’affichage.
(‘Yes! USSEIN’, 5)

27 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Affectations multiples et parallèles

>>> centre_x, centre_y, rayon = 1.0, 0.5, 12 Affectation parallèle
>>> print centre_x, centre_y, rayon
1.0 0.5 12
>>> centre_x = centre_y = 0 Affectation multiple
>>> print centre_x, centre_y, rayon
0 0 12
Une autre façon de réaliser l’affectation de plusieurs variables à la fois est de placer la
liste des variables à gauche de l’opérateur d’affectation et la liste des expressions à
droite de l’opérateur d’affectation.

>>> x = 5.0
>>> y = 10.0 >>> x, y = 10, 20
>>> x, y, z = x + y, x - y, 25 >>> print x, y
>>> print x, y, z 10 20
15.0 -5.0 25 >>> x, y = y, x
>>> u = v = 1. >>> print x, y
>>> u, v, w = u + w, v + w, 3.4 20 10
Traceback (most recent call last): >>>
File "<pyshell#6>", line 1, in <module> Permutation de variables sans
u, v, w = u + w, v + w, 3.4 utiliser de variable temporaire.
NameError: name 'w' is not defined
28 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Opérateurs et expressions

>>> x, y = 3, 13
>>> x, y = x ** 2, y % x l’opérateur ** d’exponentiation,
>>> print x, y l’opérateur modulo % .
91
>>> a = 10
>>> a = a + 1
>>> print a
11
Dans une affectation parallèle avec des expressions,
>>>
l’évaluation de celles-ci se fait avec la valeur des
variables avant l’exécution de l’instruction.

Priorité des opérateurs

Ordre de priorité : les parenthèses, **, * et /, + et -.

Si 2 opérateurs ont même priorité, l’évaluation est effectuée de gauche à droite.

>>> x = 5
>>> y = 3
>>> print x - 1 + y ** 2 * 3 / 6
8
>>>
29 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Opérateurs d’affectation +=, -=, *=, /=, %=, **=, //=

Syntaxe : identificateur_de_variable op expression

But : L’évaluation d’une expression et une affectation sont combinées.

Exemple : >>> x = 5
>>> x **= 2 # Équivaut à x = x ** 2.
>>> x
25
>>> x %= 3
>>> x
1
>>> x //= 2
>>> x
0
>>>
Note : Contrairement au C, Python ne renferme pas les opérateurs ++ et --.
30 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Saisie de données au clavier (input)

Elle provoque une interruption dans le programme courant où l’utilisateur est invité à
entrer des données au clavier et à terminer avec <Enter>. L’exécution du programme
se poursuit alors et la fonction fournit en retour les valeurs entrées par l’utilisateur.

Ces valeurs peuvent alors être stockées dans des variables dont le type correspond
à celui des données entrées.
>>> print "Entrez un entier positif :"
>>> n = input()
>>> print "Deux puissance ", n, " donne comme résultat : ", 2**n
Deux puissance 5 donne comme résultat : 32
La fonction input est soit, sans paramètre ou soit, avec un seul paramètre, une chaîne
de caractères, lequel est un message explicatif destiné à l’utilisateur.
>>> nom = input("Entrez votre nom (entre guillemets) :")
>>> print nom
La chaîne de caractères est entrée entre des apostrophes ou des guillemets.
31 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Saisie de données au clavier (input)

On peut saisir plusieurs données simultanément.
>>> t, u, v, w = input()
"oui", 34, "non", 59
>>> print t, u, v, w
oui 34 non 59
On doit fournir exactement le nombre de données voulues à la saisie.
Exemple : Programme qui saisit 2 entiers et affiche leur quotient.
>>> # Ce programme saisit deux valeurs entières au clavier,
>>> # calcule le quotient et
>>> # affiche le résultat.
>>>
>>> m, n = input("Entrez 2 valeurs entières au clavier :")
Entrez 2 valeurs entières au clavier :34, 6
>>> resultat = m / n
>>> print "Le quotient de ", m, " par ", n, " est : ", resultat
Le quotient de 34 par 6 est : 5
>>>
32 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

>>> Valeur = 3.14159 * rayon ** 2

Exemple : Traceback (most recent call last):

File "<pyshell#1>", line 1, in <module>
Valeur = 3.14159 * rayon ** 2
NameError: name 'rayon' is not defined
>>>
Erreurs à l’interprétation
Lorsque vous écrivez une commande ou une expression en Python avec une
erreur syntaxique, l’interpréteur affiche un message d’erreur et rien n’est
exécuté. Il faut recommencer.
Exemple :

>>> Montant_en_$ = 35.56

SyntaxError: invalid syntax
>>>
33 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Circonférence et aire d’un cercle

>>> # Ce programme saisit au clavier le rayon d'un cercle,

>>> # calcule la circonférence et l'aire du cercle et
>>> # affiche ces résultats.
>>>
>>> rayon = input("Entrez le rayon du cercle :")
Entrez le rayon du cercle :24.5
>>> print "Circonférence du cercle : ", 2.0 * 3.14159 * rayon
Circonférence du cercle : 153.93791
>>> print "Aire du cercle : ", 3.14159 * rayon **2
Aire du cercle : 1885.7393975
>>>

34 Dr Pascal FAYE 14/02/2024

 Généralités et premiers pas avec Python

Conversion de types numériques

Qu’arrive-t-il lorsque les opérandes sont de types différents ?

>>> 3 + 5.4
8.4
>>>
Il s’agit de convertir l’un des opérandes au type de l’autre opérande avant d’effectuer
l’opération.

Toutes les conversions ne sont pas possibles comme celle d’un réel en entier,
ou celle d’un nombre complexe en n’importe quel autre type non complexe.

Règles de conversion :

✓ Si l’un des arguments est un nombre complexe, l’autre est converti en complexe.

✓ Sinon, si l’un des arguments est un nombre réel, l’autre est converti en réel.

✓ Sinon, si l’un des arguments est un long, l’autre est converti en long.

✓ Sinon, tous deux doivent être des entiers ordinaires et aucune conversion n’est nécessaire.

35 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Fonctions de types numériques

abs() Retourne la valeur absolue de l’argument.

pow(m, n) ou pow(m, n, p)

Dans les 2 cas, mn est d’abord calculé; puis, si le troisième argument

est fourni, alors (m ** n) % p est retourné; sinon, m ** n est retourné.

round() Arrondit un nombre réel à l’entier le plus proche et retourne

le résultat comme une valeur réelle. Un 2ième paramètre
présent arrondit l’argument au nombre de décimales
indiqué.

36 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Gestion de la mémoire

En Python, il n’existe pas de déclaration explicite de variables lesquelles sont implicitement

déclarées lors de leur première utilisation.

Cependant, il n’est pas possible d’accéder à une variable avant qu’elle n’ait été créée et
initialisée :

>>> a

Traceback (most recent call last):

File "<pyshell#0>", line 1, in <module>
a
NameError: name 'a' is not defined
>>>

En Python, il n’y a pas non plus de spécification explicite de type. Cela se fait implicitement à
la première utilisation.

X = 3.4 X est alors une variable de type réel renfermant la valeur 3.4.

37 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Gestion de la mémoire
La libération de l’espace mémoire d’une variable est sous la responsabilité de
l’interpréteur. Lorsqu’il n’y a plus de références à un espace mémoire, le « ramasse-miettes »
se charge de libérer cet espace mémoire.
>>> x = 3.4
>>> x = "La variable réelle est perdue."
>>> print x
La variable réelle est perdue.
Si vous souhaitez supprimer une référence, utilisez l’instruction del.
Après quoi, on ne peut plus utiliser le nom de variable à moins de l’affecter à une nouvelle
valeur.
>>> s = 1
>>> print s
1
>>> del s
>>> print s
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
print s
NameError: name 's' is not defined
38 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Les chaînes

 Une chaîne : séquence de caractères non modifiable c’est à dire que si nous
avons une chaîne s=‘salut’,
 on ne peut pas faire s[0]=‘s’.
 on devra faire s=‘s’+s[1:] (une réassignation) qui donne s=‘salut’.

 Déclaration : Une chaîne peut être déclarée avec un simple guillemet ou un

double. On utilise le triple double quotes (“”” … “””) pour entrer une chaîne de
caractère sur plusieurs lignes.

 Remarque : le type “char” en C est donc représenté par une

chaîne de taille 1

 On ne déclare donc pas la taille de la chaîne et pour connaître sa longueur on

peut utiliser len( ).

39 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python
Tableau des opérations

OPERATION INTERPRETATION
_________________________________________ __________________________________________

S1=’’ Chaîne vide

S2 = “l’oeuf” Double guillemets
Bloc=”””….””” Bloc à triple guillemets
S1+S2, S2*S3 Concaténation, répétition
S2[i],S2[i:j],len(S2) Indice, extraction, longueur
“ Hello %s” % ‘World’ Formatage de chaîne
For x in S2, ‘o’ in S2 Itération, appartenance

40 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Chaînes: concaténation-répétition

 Exemple de concaténation
>>> mot = ‘help’ + ‘a’
>>>mot
’helpa’
# pour la répétition:
>>>mot*3
‘helpahelpahelpa’

 Autre manière de faire

>>> ‘help’ ‘a’
‘helpa’

 Remarque : on ne peut pas concaténer une chaîne et un nombre avec ‘+’;

on doit d’abord utiliser atoi( ) pour convertir ce nombre en string et ensuite
concaténer
41 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python
Chaînes: indexation et extraction

 Représentation d’une chaînes:

0 1 2 3 -3 -2 -1
J e s u i s e n t p
[: :]

 l’indexation est le fait de sélectionner un élément de la chaîne.

 Un indice positif indique que l’on commence à compter par la gauche et un
indice négatif est que l’on compte depuis la droite :
 s[3] donnera s
 s[-5] donnera e
 S[-1] donnera p

 l’extraction est le fait de sélectionner une partie de la chaîne ainsi, s[1:5] donnera
‘e su’ (le 5 n’est pas compris)
42 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python
Chaînes: indexation et extraction

 Une valeur laissée vierge prend la valeur 0 à gauche et la taille de la chaîne à droite
 s[:5] <=> s[0:5]

 s[3:] <=> s[3:len(s)]).

 Un index qui est trop grand est remplacé par la taille de la chaîne, un index de fin
inférieur à l’indice de début retourne une chaîne vide:
 s[1:100] donnera 'e suis en tp‘

 s[2:1] donnera ‘ ’

 s[-100] # erreur

43 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Remarques…

 Les opérateurs de comparaison in et not in vérifient si une valeur apparaît ou non

dans une séquence.
 Les opérateurs is et is not vérifient si deux objets sont réellement le même objet;
ceci se justifie seulement pour les objets modifiables comme les listes.
 Tous les opérateurs de comparaison ont la même priorité, qui est plus faible que
celle de tous les opérateurs numériques.
 Les objets de type séquence peuvent être comparés à d'autres objets appartenant
au même type de séquence.
 La comparaison utilise l'ordre lexicographique :
 les deux premiers éléments sont d'abord comparés, et s'ils diffèrent ceci détermine le résultat de
la comparaison,
 s'ils sont égaux, les deux éléments suivants sont comparés,
 et ainsi de suite, jusqu'à ce que l'une des deux séquences soit épuisée.

44 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Les listes

 Ont une même signification qu’en C: une collection d’objets.

Déclaration:
 une liste de valeurs (ou éléments) entre crochets séparés par des virgules. Les
éléments de la liste n’ont pas nécessairement le même type.
 Voici une liste de 4 éléments:
>>>a = [‘spam’, ‘eggs’,100,1234]
>>>a
[‘spam’, ‘eggs’,100,1234]

 Comme les indices des chaînes, les indices des listes commencent à 0, et les
listes peuvent étre découpées, concaténée.
 Les listes sont modifiables, on peut donc changer les éléments individuellement:
remplacement, destruction,... (c’est l’utilité d’une liste! Important lors des
passages de paramètres des fonctions )
45 Dr Pascal FAYE 14/02/2024
Généralités et premiers pas avec Python

Tableau des opérations

46 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Exemples
 >>> a = ['spam', 'eggs', 100, 1234]
 >>> a
 ['spam', 'eggs', 100, 1234]
 >>> a[0]
 'spam'
 >>> a[3]
 1234
 >>> a[-2]
 100
 >>> a[1:-1]
 ['eggs', 100]
 >>> a[:2] + ['bacon', 2*2]
 ['spam', 'eggs', 'bacon', 4]
 >>> 3*a[:3] + ['Boe!']
 ['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

47 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python
Listes imbriquées (généralisées)

 L = ['abc', [(1,2), ([3], 4)], 5];

 L[1] donnera [(1,2),([3],4)]
 L[1][1] donnera ([3],4)

48 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python
Les méthodes d’un objet liste

 insert(i, x)
 Insère un élément à une position donnée d’une liste L. Le premier argument est
l'indice de l'élément avant lequel il faut insérer, donc L.insert(0, x) insère au début de
la liste, et L.insert(len(a), x) est équivalent à L.append(x).

 append(x)
 Equivalent à L.insert(len(L), x).

 index(x)
 Retourne l'indice dans la liste du premier élément dont la valeur est x. Il y a erreur si
cet élément n'existe pas.

 remove(x)
 Enlève le premier élément de la liste dont la valeur est x. Il y a erreur si cet élément
n'existe pas.

49 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Les méthodes d’un objet liste

 sort()
 Trie les éléments à l'intérieur de la liste.

 reverse()
 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.

50 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Exemple pour les méthodes

 Un exemple qui utilise toutes les méthodes des listes:
 >>> a = [66.6, 333, 333, 1, 1234.5]
 >>> print a.count(333), a.count(66.6), a.count('x')
 210
 >>> a.insert(2, -1)
 >>> a.append(333)
 >>> a
 [66.6, 333, -1, 333, 1, 1234.5, 333]
 >>> a.index(333)
 1
 >>> a.remove(333)
 >>> a
 [66.6, -1, 333, 1, 1234.5, 333]
 >>> a.reverse()
 >>> a
 [333, 1234.5, 1, 333, -1, 66.6]
 >>> a.sort()
 >>> a
 [-1, 1, 66.6, 333, 333, 1234.5]

51 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Une fonction intégrée

 "filter(fonction, sequence)" renvoit une liste (du même type, si possible)

contenant les seul éléments de la séquence pour lesquels
fonction(element) est vraie. Par exemple, pour
calculer quelques nombres premiers:
 >>> def f(x): return x%2 != 0 and x%3 != 0
 ...
 >>> A=filter(f, range(2, 25))
 >>> list(A)
 [5, 7, 11, 13, 17, 19, 23]

52 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Les Tuples

 Définition: Comme une liste, un tuple est une collection ordonnée d’objets;
mais le tuple n’est pas modifiable .

 Déclaration: des valeurs (entre parenthèses) séparées par des virgules

>>>tuple=(0,1.4,’world’)

 Pourquoi les tuples alors que nous avons les listes??

La non-possibilité de modifier les tuples assure une certaine
intégrité car nous pouvons être sûr qu’un tuple ne sera pas modifié à travers
une référence ailleurs dans le programme.

53 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Tableau des opérations

54 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Tuple unpacking

 L'instruction t = 12345, 54321, 'salut!'

 est un exemple d' emballage en tuple (tuple packing).

 L'opération inverse est aussi possible, par ex.:

 x, y, z = t
 Ceci est appelé, fort judicieusement, déballage de tuple (tuple unpacking).
 Le déballage d'un tuple nécessite que la liste des variables à gauche ait un
nombre d'éléments égal à la longueur du tuple

 A l'occasion, l'opération correspondante sur les listes est utile:

list unpacking.
Ceci est possible en insérant la liste des variables entre des crochets carrés:
 a = ['spam', 'oeufs', 100, 1234]
 [a1, a2, a3, a4] = a

55 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Les dictionnaires

 Définition. Un dictionnaire est un ensemble non ordonnés de couples

clé:valeur avec comme contrainte que les clés soient uniques (dans un même
dictionnaire).

 Déclaration: des couples clé:valeur séparés par des virgules et entre accolades
>>> dico = {`japon' :'japan', `chine' :'china'}

 Un dictionnaire, à la différence des séquences qui sont indexées par un

intervalle numérique (cf.liste,chaîne,tuple),est indexé par une clé qui peut être
n’importe quel type non-modifiable (les chaînes,les nbrs et les tuples s’ils ne
contiennent que des éléments non modifiables)

56 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Tableau des opérations

57 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Un exemple

 >>> tel = {'jack': 4098, 'sape': 4139}

>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> tel.has_key('guido')
1

58 Dr Pascal FAYE 14/02/2024

Généralités et premiers pas avec Python

Les fichiers

 Tableau des opérations

59 Dr Pascal FAYE 14/02/2024

 Les structures de contrôles

60 Dr Pascal FAYE 14/02/2024

1. Le test if

L’instruction IF peut comporter plusieurs tests conditionnels ’elif’ et

se termine par un bloc optionnel ‘else’. Le bloc qui sera executé, sera le
premier ou la condition sera vrai sinon se sera le bloc else sans condition
qui sera executé.
Le if s’écrit de la forme suivante:

if <test1>:
<instructions>
elif <test2>:
<instructions>
.....
!!! ATTENTION à l’indentation !!!!
else:
<instructions>

61 Dr Pascal FAYE 14/02/2024

 2. La Boucle While

Comme dans beaucoup d’autres langages, la boucle while éxecute un bloc tant que la
condition d’arrêt est vérifiée. La particularité de ce while est qu’il peut y avoir un else
optionnel dont le bloc sera éxecuté lorsqu’on sort de la boucle

while <test> :
<instructions>

else :
<instructions>

62 Dr Pascal FAYE 14/02/2024

Un exemple…
X=0
While x<6:
print « Dans la boucle while x vaut : » , x
x=x+1
else:
print « Dans le else x vaut : »,x

63 Dr Pascal FAYE 14/02/2024

Utilisation du break, continue, pass

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

grand contôle de la boucle.
- Comme en C, l’instruction break permet de sortir de la boucle
instantannément et de passer à la suite. Elle annule le passage
dans la boucle else.
- L’istruction « continue » saute au début de la boucle la plus
imbriquée.
- « pass » ne fait rien du tout mais, comme on ne peut avoir une
expression qui n’est suivie de rien, « pass » peut être utilisé pour
combler ce vide.

64 Dr Pascal FAYE 14/02/2024

Exemple :

y=0
While y<6:
if y==4:
break
else:
print « Dans la boucle while, y vaut : », y
y=y+1
else:
print « dans le else y vaut : », y

65 Dr Pascal FAYE 14/02/2024

 3. La Boucle For

La boucle for fonctionne sur les chaînes, les listes, les tuples et d’autes objets issus
de classes.

Elle commence par une ligne d’en-tête qui spécifie une cible d’affectation, ainsi
qu’un objet qui sera itéré :

for <cible> in <objet>:

<instructions>
else :
<instructions>

Ici encore, le else est mis en fin de boucle pour la même raison que dans la boucle
while vue précédemment.

Le for de Python fonctionne différemment que celui du C, il affecte les objets de

l’élément séquence à la cible un par un.

66 Dr Pascal FAYE 14/02/2024

Exemple :

X={« ichi »: « un », « ni »: « deux », « san »: « trois », « chi »: « quatre »}

Print « Les clefs du dictionnaire sont : »,x.keys()
Print « Les Valeurs du dictionnaire sont : », x.values()
For i in x.keys():
print « La clef est : %s la valeur est :%s »%(i,x[i])

67 Dr Pascal FAYE 14/02/2024

Le Range
L’instruction range permet de créer une liste croissante d’entiers
successifs compris dans une certaine borne dépendant du nombre de
paramètres de l’instruction :
1 paramètre : entiers compris entre 0 et le paramètre
2 paramètres : entier compris entre param1 et param2
3 paramètres : entier compris entre parm1 et param2 et de pas param3

Ex : for i in range(10,20,2):
print i
Ce qui donne: 10
12
14
16
18

68 Dr Pascal FAYE 14/02/2024

Comparaisons
Algorithme Langage c Python
Si (conditions) alors If (condition) { If condition :
Instructions Instructions; Instructions
Fin si }

Si (conditions) alors If (condition) { If condition :

Instructions Instructions; Instructions
Sinon else else :
Instructions Instructions; Instructions
Fin si }

L’indentation
identifie les
blocs

69 Dr Pascal FAYE 14/02/2024

Comparaisons L’indentation
identifie les
blocs

Algorithme Langage c Python

Si (condition) alors if (condition) If condition :

Instructions {
Instructions ; Instructions
Sinon si (condition) alors else if ( condition)
Instructions { elif condition :
Instructions;
Sinon else instructions
Instructions Instructions;
} else :
Fin si }
Fin si instructions

70 Dr Pascal FAYE 14/02/2024

 Comparaisons
Algorithme Langage c Python
Instructions d’entrée Instructions d’entrée ; Instructions d’entrée
while(condition) { while condition :
Tant que (conditions) faire Instructions
Instructions Instructions ; Instructions de sortie
-------------- Instructions de sortie;
Instructions de sortie }
Fin tant que
Pour (variable) allant (début) à (fin) For (variable=valeur de debut; For in sequence :
Valeur de fin ;valeur de pas) Instructions
Instructions {
Instructions ;
Fin pour
}

L’indentation
identifie les
blocs

71 Dr Pascal FAYE 14/02/2024

 LES FONCTIONS

72 Dr Pascal FAYE 14/02/2024

 1. Définition
Outre les fonctions de bases de Python, il est possible d’en définir de nouvelles grâce à
l’instruction « def ». Il faudra bien sur à nouveau veiller à l’indentation car en python, il
n’y pas de délimiteur pour définir les scopes.
format :
def nom_fct (arg1,arg2,…,argn):
<instruction>
return <valeur>
Lorsqu’on quitte la fonction valeur va directement être assignée à la fonction appelante. Elle
peut être de tous type puisque il n’y a pas de déclaration de type sous python.
NB : nous pouvons aussi créer des fonctions mathématique grâce à l’instruction lambda,
par exemple :
f=lambda x: x**x
g(x,y)=2x+y f=lambda x, y:2*x+y
f(x)=sin(x) import math
f=lambda x: math.sin(x)
73 Dr Pascal FAYE 14/02/2024
2. Les arguments…

La forme générale pour passer des arguments est nom_fct(arg1,arg2,…,argn)

Il est possible de définir des paramètres par défaut pour un ou plusieurs arguments.
Ce qui crée une fonction qui pourra être appelée avec moins d’arguments que ce qui
a été défini.
Ex: def nom_fct (arg1=0, arg2=2,…,argn ="hello world ")
Les fonctions peuvent être appelées en utilisant des arguments mots-clés de la
forme « motclé=valeur »
Ex : def voiture (voltage, etat='c\'est du solide',action='voom'):
print(" -- Cette voiture ne feras pas ",action)
print(" -- si vous le mettez sous ",voltage," volts. ")
print(" -- Ca ",etat," ! ")
pourrait être appelé de l’une des façons suivantes :
voiture (1000)
voiture (action='vooooooom',voltage=1000000)

74 Dr Pascal FAYE 14/02/2024

Toujours Les arguments…

Une fonction peut être appelée avec un nombre d’arguments arbitraire.

Il est possible de les envoyer sous deux formes différentes :
Soit par dictionnaire :
Définition : Def nom_fct (**arg):
pass
Appel : nom_fct (arg1=1, arg2=2)
Soit par tuple :
Définition : def nom_fct (*arg):
pass
Appel : nom_fct (arg1,arg2)

75 Dr Pascal FAYE 14/02/2024

 LES MODULES

76 Dr Pascal FAYE 14/02/2024

1. Définition
 Un module est un fichier contenant des définitions et des instructions
Python. Le nom du fichier est le nom du module auquel est ajouté le
suffixe .py.

 Avantages: - permet de relancer un même programme sans tout

réécrire (en créant éventuellement un script).
- d’utiliser dans plusieurs programmes une même
fonction sans la réécrire dans chaque programme.

 Chaque module a sa propre table de symboles privée, qui est utilisée

comme table de symbole globale par toutes les fonctions définies dans
le module. Ainsi, l'auteur d'un module peut utiliser des variables
globales dans le module sans s'inquiéter des désaccords accidentels
avec les variables globales d'un utilisateur.

77 Dr Pascal FAYE 14/02/2024

 2. Les instructions

L'instruction "import <module>" importe tout le module <module>, en

exécutant le total du module.
Le module est exécuté en premier avant de pouvoir travailler sur les objets.Pour
utiliser ensuite le module, nous écrirons “<module>.nom”.

L'instruction "from" s'utilise avec "import" de la manière "from <module>

import <nom>".
Là seulement l'objet <nom> du module <module> sera importé, le code restant
du module sera aussi exécuté, mais les objets ne seront pas mémorisés et les
éventuelles variables ne seront pas affectées. Si <nom> est remplacé par *,
on obtient alors une copie de tous les noms définis a la racine du module.
Pour utiliser ensuite nom, nous écrirons juste “<nom>”.

78 Dr Pascal FAYE 14/02/2024

Remarques

 La grande différence entre "import <module>" et "from <module> import *"

est que les noms ne sont pas mémorisés sur le même niveau.
 Le premier sera mémorisé sous le nom du module, tandis qu'avec "from" la
valeur est directement visible dans la racine (car dans la table des symboles
globaux, (Voir exemple).

 La fonction "reload" est en fait un fonction se trouvant dans __builtin__

(comme print), cette fonction s'exécute par "reload(<nom>)" et a
pour but de recharger le module <nom>.
 Le code du module sera de nouveau exécuté depuis le début et les variables
qui auraient pu changer seront remises à leurs valeurs d'origine. Refaire un
“import” ne servirait à rien car le module est déjà chargé.
 La fonction intégrée dir() est employée pour découvrir les noms qu'un module
définit.
 Elle renvoie une liste triée de chaînes de caractères.

79 Dr Pascal FAYE 14/02/2024

Exemple

 Illustration de la remarque
#contenu du module mon_module
num=12
#fin du module mon_module (.py)
#on est dans l’invite interactive
>>>from mon_module import num
>>> print num
12
>>>num=24
>>>print num
24
>>>from mon_module import num #équivalent du reload
>>>print num
12 # ne fonctionne pas avec les types modifiables

80 Dr Pascal FAYE 14/02/2024

 LES EXCEPTIONS

81 Dr Pascal FAYE 14/02/2024

 1. Définition

Comme en Java, il existe un mécanisme de contrôle des erreurs d’exécution , les

exeptions.
Le traitement d’une exception permet de passer par dessus un bout de programme.

Dans Python , il existe deux types d’exception :

- celles présentent dans la table des exceptions de Python
- celles créées par l’utilisateur

82 Dr Pascal FAYE 14/02/2024

 2. Gestion des exceptions

Il est possible d’écrire des programmes qui prennent en charges des exceptions
spécifiques.
Ex : try:
print 1.0 / 0
except ZeroDivisionError:
print '*** n'a pas d'inverse ***
else : pass
Lorsque l’instruction « try » est rencontrée, on execute d’abord la « clause
d’essai ».
Si une exception se produit, le reste de la clause try est ignorée. Dans le
cas contraire, on ignore la clause d’exception.
Si une exception se produit qui ne correspond pas à l’exception dans la
clause except, elle est renvoyée aux instructions « try » extérieures. S’il n’y
a pas de prise en charge, Python affichera un message d’erreur.
83 Dr Pascal FAYE 14/02/2024
 2. Gestion des exceptions

L’instruction « else » est une clause par défaut qui doit suivre toutes les clauses
d’exeptions. Elle permet d’executer la suite du programme dans le cas où aucune
exception ne serait survenue.
Quand une exception survient, elle peut avoir une valeur associée, appelé argument de
l’exeption.
Ex : try :
spam()
except NameError, x:
print ‘nom’, x,’non défini’
ce qui affichera : nom spam non défini.

84 Dr Pascal FAYE 14/02/2024

 3. Comment déclencher une exception??

L’instruction « raise » permet à l’utilisateur de déclencher une exception.

Par exemple :
def myfunc() :
raise EOFError
try:
myfunc()
except EOFError :
print « erreur d’i/O !! »
Else :
print « Et voilà »

85 Dr Pascal FAYE 14/02/2024

 4. Créer ma propre exception

Il suffit d’affecter une chaîne de caractères à une variable…

Ex : MonErreur = « Une erreur »
def mafunc() :
raise MonErreur, « survenue »
try :
mafunc()
except MonErreur, value :
print « mon erreur est %s! »%value
else:
pass

86 Dr Pascal FAYE 14/02/2024

 5. Actions de nettoyage…

L’instruction « try » contient une autre clause exceptionnelle qui permet de

définir les actions de nettoyage qui doivent être éxecutées impérativement.
Ex : def divise(a,b):
return a/b
for x in range(1.0,5.0,1.0):
try:
result = divise(x,x-4)
print « Le résultat est %f »% result
finally :
print « cette ligne est exécutée quoi qu’il se passe » rem : La
clause de finalisation est éxecutée qu’une exception est executée ou non..

87 Dr Pascal FAYE 14/02/2024

 LES CLASSES

88 Dr Pascal FAYE 14/02/2024

 1. introduction

Python offre la possibilité de programmer en Orienté objet. Le mécanisme de

classe en Python est un mélange des mécanismes de classes de C++ et de Modula-3.
Ex : Comme en c++, tous les membres d’une classe sont publics, et toutes les fonctions
membres sont virtuelleS.Il n’y a pas de constructeur ni de destructeur particulier.
Comme en Modula-3, il n’y a pas de raccourcis pour faire référence aux membres
d’un objet à partir de ses méthodes.

89 Dr Pascal FAYE 14/02/2024

 2. La synthaxe…
La forme la plus simple de définition de classe ressemble à ceci :
class Nomclasse:
<instruction1>
…
<instructionN>
Dans la pratique, les instructions à l’intérieur de la définition de classe seront souvent
des définitions de fonctions, mais d’autres instructions sont acceptées.
L’objet classe permet deux types d’opération : La réferenciation des attributs et
l’instanciation.
La réference d’attributs : Nomclasse.i où i est un attribut de Nomclasse est une
réferences d’attribut valide.
L’instanciation(création d’une instance (objet) Nomclasse):
x=Nomclasse() affecte la nouvelle instance à la variable x

90 Dr Pascal FAYE 14/02/2024

3. A l’intérieur de la classe…

On trouve deux types d’attributs :

- données (idem que les données membre en C)
- Les méthodes (idem que fonction membre en C)
1) Les données
Les données n’ont pas besoin d’être déclarée; Comme les
variable locale, elles apparaissent lorsqu’on leur affecte une
valeur la première fois.
ex : class MaClasse :
def f(x):
print « hello World »
i=123456
x= MaClasse()
x.compteur = 1 #creation de l’attribut compteur
91 Dr Pascal FAYE 14/02/2024
2) Les méthodes
Une méthode est appelée comme en C++ :
x.f()
Vous avez surement remarqué que la fonction f définie dans MaClasse a
été appelée sans paramètre alors que la définition en contenait un. Ca devrait
normalement déclencher une exception. Mais il n’en est rien car la
particularité des méthodes est que l’objet est passé comme premier argument
de la fonction. Le plus souvent par convention appelé « self » pour amélioré
la lisibilité du programme .
L’appel x.f() est donc équivalent à MaClasse.f(x).
Il n’est pas nécessaire que la définition de la méthode soit
comprise dans la définition de la classe.
Ex : def f1 (self,x,y):
return min(x,x+y)
class C:
f=f1
92 Dr Pascal FAYE 14/02/2024
Méthodes prédefinies…

Python contient une liste de méthodes dites spéciales :

93 Dr Pascal FAYE 14/02/2024

En particulier, la méthode __init__(self)…

Lorsqu’une class définit la méthode spéciale __init__(), l’instantation de la

classe appelle automatiquement cette méthode.
Il s’agit en fait de ce qu’on appel en C/C++ un constructeur.
Bien sûr, la méthode __init__() peut prendre autant de paramètre qu’on le
vaut, pour une flexibilité accrue…
Ex : class Complexe:
def __init__(self, partiereelle, partieimaginaire):
self.r = partiereelle
self.i = partieimaginaire
x = Complexe(3.0,-4.5)
x.r, x.i donne: (3.0, -4.5)

94 Dr Pascal FAYE 14/02/2024

4. L’héritage
La syntaxe pour définir une classe dérive est la suivante :
Class Nomclassedérivée (NomClassedeBase):
<instruction1>
…
<instructionN>
Rem : A la place de d’un nom de classe de base, une expression est
acceptée. Ce qui est utile lorsque le définition de la classe de base se
trouve dans un autre module..
Ex : class NomClasseDerivee(nommod.NomClasseDeBase):
L’exécution d’une définition de classe dérivée se déroule
comme une classe de base. Quand l’objet classe est construit, la
classe de base est mémorisée.C’est ce qui permet de trouver
facilement un attribut. Lorsqu’un attributs est réferencé, il est
recherché dans la classe dérivée s’il ne s’y trouve pas on le
recherchera dans la classe de base.

95 Dr Pascal FAYE 14/02/2024

5. L’héritage multiple
Python supporte également l’héritage multiple.
Une définition de classe avec plusieurs classes de base ressemble à :
Class NomClasseDerivee (Base1,Base2,..,BaseN)
<instruction1>
…
<instructionN>
Lorsqu’on référence un attribut, la recherche s’effectue en
profondeur càd de gauche à droite? Donc si un attribut n’est pas
trouvé dans ClasseDerivee, on le cherchera d’abord dans base1, puis
dans base2, et ainsi de suite jusqu’à ce qu’on le trouve…
Rem : Il faut faire attention aux conflits accidentelles!!
Par exemple, si on crée une classe dérivée de deux autres
classes dérivées de la même classe de base…risque de problèmes!!!!

96 Dr Pascal FAYE 14/02/2024

 D’AUTRES OUTILS DE
PYTHON

97 Dr Pascal FAYE 14/02/2024

 Quelques librairies
SciPy est un ensemble d'outils numériques et scientifiques open-source. Il supporte
actuellement des fonctions spéciales, l'intégration, les résolveurs d'équations
SciPy
différentielles ordinaires, les algorithmes génétiques, ...
Prérequis: il faut installer d’abord NumPy
NumPy est la bibliothèque à utiliser pour le calcul scientifique. Elle est une refonte
NumPy
complète des bibliothèques numarray et Numeric. Il conviendra donc de préférer cette
bibliothèque une fois qu'elle sera dans un état stable.

Numarray permet une manipulation efficace des tableaux. Présence de tout un panel
numarray
de fonctions, de l'algèbre linéaire etc. Numarray est une réimplantation de Numeric.

matplotlib Matplotlib est une bibliothèque pour tracer des graphes 2D.
Prérequis: il faut installer d’abord NumPy
MySQLdb MySQLdb permet la manipulation des bases de données MySQL.
Cette bibliothèque permet de construire des scènes 3D de façon très simple avec des
VPython élements très simples: Cube, Cône, Pyramide, Sphère ... De nombreux exemples
permettent de se familiariser rapidement avec cette bibliothèque.

D’autres librairies très utiles sont disponibles et vous pouvez trouver plus d’informations au niveau des sites:
• https://docs.python.org/fr/3/library/index.html
• https://python.developpez.com/outils/BackupOutils/Librairies/

98 Dr Pascal FAYE 14/02/2024

TP : utilisation de GUI (Graphic User Interface)

99 Dr Pascal FAYE 14/02/2024

from tkinter import * menubar = Menu(fenetre)
menu1 = Menu(menubar, tearoff=0)
fenetre = Tk() menu1.add_command(label="Créer", command=alert)
label = Label(fenetre, text="Bonjour les Mathématiciens de Pr menu1.add_command(label="Editer", command=alert)
SENE")
menu1.add_separator()
label.pack()
menu1.add_command(label="Quitter",
command=fenetre.quit)
Canvas(fenetre, width=250, height=50, bg='ivory').pack(side=LEFT,
padx=5, pady=5) menubar.add_cascade(label="Fichier", menu=menu1)
Button(fenetre, text ='Bouton 1').pack(side=TOP, padx=5, pady=5)
Button(fenetre, text ='Bouton 2').pack(side=BOTTOM, padx=5, menu2 = Menu(menubar, tearoff=0)
pady=5)
menu2.add_command(label="Couper", command=alert)

def alert():
menu2.add_command(label="Copier", command=alert)
showinfo("alerte", "Bravo!") menu2.add_command(label="Coller", command=alert)
menubar.add_cascade(label="Editer", menu=menu2)

menu3 = Menu(menubar, tearoff=0)

menu3.add_command(label="A propos", command=alert)
menubar.add_cascade(label="Aide", menu=menu3)

fenetre.config(menu=menubar)
fenetre.mainloop()
100 Dr Pascal FAYE 14/02/2024
TPE :
1-conversion d’un nombre décimal en base 2

2-Personnaliser cette interface pour rendre actif les

boutons et les menus

101 Dr Pascal FAYE 14/02/2024

 FAQ

102 Dr Pascal FAYE 14/02/2024