Université Alioune Diop de Bambey UFR SATIC
Licence de Physique Numérique
Cours de Programmation avancée : Python + POO
Enseignant : Dr. Mamadou Salif DIALLO
Email : [Link]@[Link]
Chapitre I Introduction à Python
1. Jupyter Notebook (Cellule Code , Markdown )
2. Introduction générale à Python
3. Variables
4. Types de base ( bult-in )
5. Opérateurs + Opérations sur les types
Evaluation
Presque chaque cours (un test d'environ 20mn )
Travail de groupe (par deux ou individuel)
devoirs
Evaluation globale à la fin du cours
Matériel du cours
Installer Python 3.8 et Jupyter-notebook :
Distribution Anaconda3 recommandée.
Installer un IDE :
Visual Studio
Visual Studio Code
PyCharm (recommendé)
Python au terminal (Unix) ou Ananconda Prompt (Windows):
$ python
$ ipython
IDLE de Python (pas nécessaire)
I) Introduction générale à Python
Python est un langage de programmation
puissant,
facile à apprendre et à utiliser (simplicité),
de typage dynamique,
orienté objet,
interprété,
de syntaxe élégante (code lisible),
gratuit
de haut niveau,
multiplateforme : Windows, Mac OS X, Linux, Android, iOS
a une communauté qui s'augmente rapidement,
crée par Guido van Rossum (en 1989 ), aux Pays-Bas. La Première version publique a été publiée en
1991
Site web de Python : [Link]
Utilisation de python
On peut utiliser Python pour diverses applications :
le développement web,
le développement mobile,
le développement d'interfaces graphiques,
la science des données,
les graphiques,
le calcul numérique,
l'intelligence artificielle,
le calcul distribué
....
Quelques organisations utilisant Python
Le Zen de Python par Tim Peters
In [ ]:
import this
II) Environment Jupyter-Notebook
Fichier notebook : extension .ipynb
Pour lancer le serveur Jupyter-Notebook , au terminal tapez : jupyter-notebook
Pour ouvrir un fichier spécifique (exemple [Link] ), au terminal,
tapez jupyter-notebook .... path/[Link]
Cellule Code python
Cellule Markdown :
le guide Markdown
le langage Markdown
Plusieurs commandes magiques : % command
Exemple :
% whos : liste tous les objets (variables, ...) utilisés dans le notebook.
% history : liste toutes les commandes Python lancées dans un notebook.
Voir la documentation pour plus de détails .
Remarque : Les environnements Linux ou Mac OS X , il est possible de lancer une commande Unix depuis
un notebook Jupyter. Il faut pour cela précéder la commande du symbole ! .
Exemples :
Exemples :
! pwd : pour
! ls : pour lister les
! cd path :
! echo "Command Unix"
! touch [Link]
In [ ]:
!
In [ ]:
pwd
III) Variables
Opérateur d'affectation en Python est "="
nom_variable = valeur_variable
Exemple
In [1]:
x = 5
y = 7 - x
z = 2*x-x*x
Il faut noter que "=" dans ce contexte n'exprime pas l'équivalence mathématique.
Type en Python : typage dynamique
Dans certains langages de programmation (comme C ), le type de chaque variable doit être donné
explicitement avant son utilisation (un processus appelé déclaration).
En Python , le type d'une variable est déterminée automatiquement lorsqu'une valeur est affectée à une
variable.
Pour connaitre le type d'une variable en Python, on peut utiliser type(...)
In [ ]:
x = 5
a = 8
In [ ]:
type(x)
In [ ]:
x = 1/a
type(x)
In [ ]:
decim = 7.2
decim
In [ ]:
type(decim)
Noms de variables
Il y a quelques règles pour les noms de variables à garder à l'esprit :
Ils sont composés (en général) de caractères alphanumériques ( a-z , A-Z , 0-9 ) et le caractère de
soulignement _ . Pour les dernières versions de Python (Python 3), les caractères accentués sont
acceptées.
Une variable ne peut pas commencer par un nombre, mais le nombre peut apparaître n'importe où ailleurs.
Caractères inutilisables : Caractères spéciaux tel que \, $, %, !,. etc ne peuvent pas être utilisés, ni les
virgules , , points . ou les tirets - , car ils ont tous d'autres significations particulières.
Le nom d'une variable ne peut pas être un mot clef réservé tel que "or", "and", "if", "def" ,
etc. Il ne devrait pas non plus être un mot avec signification spéciale ("int", "float", "complex", " type ", etc.)
parce que la fonctionnalité de ces significations originales devrait être maintenue.
Mots clefs
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
Les variables sont sensibles à la casse (en effet, tous les mots (clés ou non) en Python le sont). En d'autres
termes, Python fait la distinction entre majuscules et minuscules, de sorte que "message", "Message" et
"meSSage" sont trois variables différentes.
In [ ]:
is = 2
In [ ]:
pass = 7
Remarque : N'oubliez pas de donner des noms de variables significatifs.
Une variable pour designer le rayon d'un cercle qui est égal à 2 .
In [ ]:
r = 2
rayon = 2 # mieux
Une variable pour designer le nombre d'étudiants (total 16 ).
In [ ]:
n = 6
In [ ]:
nbre_etudiants = 16 # mieux
Déclaration multiples
In [ ]:
i, j = 2, 4
In [ ]:
i
In [ ]:
j
In [ ]:
a, b, c = 3, 4.3, 8
In [ ]:
a
Commentaires, Affichage et Aide
Les commentaires commence par # .
Pour afficher une variable, on peut utiliser la fonction print .
Pour l'aide sur func , on peut utiliser help(func) ou func? ou encore ?func .
Exemples
In [ ]:
print(1,2,3)
In [ ]:
help(print)
In [ ]:
# Aide pour la fonction ``print``
print?
In [ ]:
?print
In [ ]:
x2 = 9
x3 = " Hello"
In [ ]:
print(x2, x3, sep="; ")
In [ ]:
print(x2, x3, sep="; ", end="\n ")
print(x2, x3, sep="; ", end=" : ")
IV) Types de base ( built-in ) :
bool, int, float, str, tuple, list, set, dict
Remarque : Pour connaitre le type d'une variable nommée var_a , éxécuté type(var_a) .
Les entiers : int
In [ ]:
n = 4;n
In [ ]:
type(n)
Les nombres floatants : float
In [ ]:
rayon = 3.4
v = 2.
In [ ]:
v
In [ ]:
type(v)
In [ ]:
largeur = 3 + 5.1
In [ ]:
type(largeur)
In [ ]:
b = .5;
b
Les chaines de caractères (string en anglais : str )
Les chaines de caractères sont délimitées par
des guillements simples '....' ou
des guillements doubles "...." .
In [ ]:
salutation = "Bonjour tout le monde"; salutation
In [ ]:
type(salutation)
In [ ]:
lpn = 'Lycence Physique Numerique'
print(lpn)
Remarque : Si une chaine est délimitée par des guillements doubles "...." , vous pouvez utiliser à l'intérieur
de la chaine des guillements simples '....' .
In [ ]:
aibd = 'L\' Aéroport International Blaise Diagne'
print(aibd)
Les tuples : tuple
Les tuples sont des collections délimitées par des parenthèses (elt1, elt2, .... eltn) .
Remarque:
Il faut au moins une virgule dans les parenthèses pour un tuple non vide.
On peut même omettre les parenthèses i.e elt1, elt2, .... eltn .
Tuple vide : () ou tuple() .
L'ordre des élements compte.
In [ ]:
(a, b) = (2, 5)
In [ ]:
serie1 = (1, 2, 10, 2.3, "a", "c")
serie1
In [ ]:
serie2 = (3, 5, "a", (1, 5.1))
serie2
Exo: Un tupe qui contient que la chaine "MPI1"
In [ ]:
("MPI1",)
Remarque Notez que tout élément d'un tuple peut être de n'importe quel type ( "int", "float", "str",
"tuple", etc)
In [ ]:
# tuple vide
tuple_vide = tuple() # ()
tuple_vide
In [ ]:
coord = (2, )
coord
Les listes : list
Les listes sont des collections délimitées par des crochets [elt1, elt2, .... eltn] .
Remarque:
Liste vide : [] ou list() .
L'ordre des élements compte.
In [ ]:
liste_alphabet = ["A", "B", "C", "D", "E"]
liste_alphabet
Remarque : Comme les tuples, tout élément d'une liste peut être de n'importe quel type ( "int", "float",
"str", "tuple", "list" , etc)
In [ ]:
liste2 = [1, 2.3, 4., "A", "B", ["A", "B", "C", "D", "E"], (1,2,3)]
liste2
Les ensembles : set
Les ensembles sont des collections délimitées par des accolades
{elt1, elt2, .... eltn} .
Remarque :
Ensemble vide : set() .
L'ordre des élements ne compte pas .
In [ ]:
E1 = {1,2,3,4,5,6,7,7,8,9,9}
E1
In [ ]:
E2 = {6,7,7,8,9,1,2,3,4,5,2}
E2
In [ ]:
set()
Les dictionnaires : dict
Les dictionnaires ressemblent aux objets en Javascript , ils sont délimitées par des accolades, cependant
les élements sont sous la forme clé : valeur
Syntaxe
dico = {cle1: valeur1, cle2: valeur2, .... , cle_n: val_n}
Remarque :
dictionnaire vide : {} ou dict()
les valeurs peuvent être de n'importe quel type ("int", "float", "str", "tuple", "list", etc).
les clés aussi peuvent être (en général) de n'importe quel type ("int", "float", "str", "tuple") avec certaines
restrictions. Par exemple, les clés ne peuvent pas par contre être une liste ou un dictionnaire
Exemples
In [ ]:
dico1 = {"A" : 0, "B": 1, "C": 1}
dico1
In [ ]:
dico2 = {"D": 3, 2: "2", 9: [1,2,3], (1,2,3): 4, "dic": {1:1, "F": 6}}
dico2
In [ ]:
dico3 = {"D": 3, 2: "2", 9: [1,2,3], [1,2,3]: 4}
V) Opérateurs + Opérations sur les types
V-1. Conversion de types
Conversion en int : int(...)
In [ ]:
type(int)
In [ ]:
y=2.9
In [ ]:
int(y)
In [ ]:
a="67"
In [ ]:
type(a)
In [ ]:
int(a)
In [ ]:
int([1])
Conversion en float : float(...)
In [ ]:
v=7
In [ ]:
float(v)
In [ ]:
float("00")
Conversion en string : str(...)
remarque : input
In [ ]:
int(input("Monsieur: Donner un entier"))
In [ ]:
str(6)
In [ ]:
str((6,8))
Conversion en Tuple et Liste : tuple(...) et list(...)
In [ ]:
chaine="je vous aime"
In [ ]:
list(chaine)
In [ ]:
tuple(chaine)
In [ ]:
L = (1, 2 , 4, 6, 9)
In [ ]:
T = list(L); T
In [ ]:
list(T)
Conversion en dictionnaire : dict(...)
Une séquence de paire de valeurs
In [ ]:
L=((1, "un"), (5, "5"), ("Hello", "Bonjour"))
In [ ]:
dict(L)
In [ ]:
Conversion en Booléen : bool(...)
bool(var) : renvoie False si var est une variable de type
int nul
float nul
str vide
tuple vide
list vide
set vide
dict vide
etc
etc
bool(var) retoune True dans le cas contraire
In [ ]:
bool(0)
In [ ]:
bool(77654)
In [ ]:
bool({})
In [ ]:
bool?
V-2. opérations sur des variables de type int ou float
Opérateurs
+ - * ** / // %
In [ ]:
x = 2
y = 7.3
z = x + 2*y
xcarre = x**2
print("x=", x, "y=", y, "z=", z, "xcarre=",xcarre)
In [ ]:
x_demi = x / 2
print("x_demi = ", x_demi)
x_demi_prime = x // 2
print("x_demi_prime = ", x_demi_prime)
In [ ]:
# Reste d'une division: Calcul modulo (%)
N = 26
# soit à calculer ... mod N
mes = 66 % N
print("mes = ", mes)
In [ ]:
6667
In [ ]:
V-3. Indices et Slicing (str, tuple, list)
Supposons que var est une chaine de caractère, un tuple, ou une liste et i un entier:
var[i] : renvoie l'élément qui est à la position i + 1 s'il existe; dans le cas contraire une erreur de type
IndexError sera levée.
len(var) : renvoie le nombre d'éléments
Il faut noter qu'en Python, on commence la numérotation en 0
In [ ]:
chaine = "La transmission des données et la sécurité de l'information"
mon_tuple = ("A", "B", "C", 'D', 'E', 1, 3, 5.2, (3, 6), [1,2,3], 9)
ma_liste = ["Moussa", "Ba", "TSIU", "@", "crypto", (0, 2.2, 8), [3, "UADB"], "last"]
In [ ]:
print(len(chaine), len(mon_tuple), len(ma_liste))
In [ ]:
mon_tuple[-2]
In [ ]:
chaine[0]
In [ ]:
chaine[5]
In [ ]:
mon_tuple[0]
In [ ]:
mon_tuple[8]
In [ ]:
ma_liste[0]
In [ ]:
ma_liste[7]
In [ ]:
ma_liste[10]
Indices avec des entiers négatifs
var[-1] : renvoie le dernier élément (s'il existe)
var[-2] : renvoie l'avant dernier élément (s'il existe)
et ainsi de suite
In [ ]:
ma_liste[-1]
In [ ]:
chaine[-2]
In [ ]:
mon_tuple[-2]
Remarque:
Si var est une chaine de caractère
var[debut: fin: pas] : renvoie une sous chaine de var qui est la concaténation des caractères aux
positions allant de debut à fin - 1 avec pas pas
Si var est un tuple (ou une liste)
var[debut: fin: pas] : renvoie le tuple (ou la liste) des éléments de var aux positions allant de debut à
fin - 1 avec pas pas
NB:
Si debut n'est pas précisé, il est égal à 0
Si fin n'est pas précisé, il est égal au nombre d'éléments de var
Si pas (ou :pas ) n'est pas précisé, il est égal à 1
In [ ]:
ch = "TRANSMISSION DES DONNEES"
T = ("A", 3, 5.2, (3, 6), [1,2,3], 9)
L = ["Moussa", "@", "crypto", (0, 2.2, 8), [3, "UADB"], "last"]
In [ ]:
ch[0:5:1]
In [ ]:
ch[0::3]
In [ ]:
L[0: 5: 2]
In [ ]:
L[0:3]
In [ ]:
L = "DICDEEPT"
In [ ]:
L[-2 :]
In [ ]:
L[:]
Opérateurs in et not in
x in sequence : renvoie True si l'élément x est dans sequence et False dans le cas contraire
x not in sequence : renvoie True si l'élément x n'est pas dans sequence et False dans le cas contraire
In [ ]:
T1 = ("A", 3, 5.2, (3, 6), [1,2,3], 9)
L1 = ["Moussa", "@", "crypto", (0, 2.2, 8), [3, "UADB"], "last"]
In [ ]:
"A" in T1
In [ ]:
L1[4][1]
In [ ]:
"A" in L1[4][1]
In [ ]:
"B" in T1
In [ ]:
3 not in L1
In [ ]:
(0, 2.2, 8) in L1
In [ ]:
"M" in L1[0]
In [ ]:
"M" in T1[1]
Exercice
V-4. Opérations sur les chaines de caractères (str) et
fstring
On suppose chaine est de type str
[Link]() : mettre tous les caractères en minuscule
[Link]() : mettre tous les caractères en majuscule
[Link](ch1, ch2) : remplace ch1 par ch2
[Link](x) : renvoie True si chaine se termine par x et False dans le cas contraire
[Link](x) : renvoie True si chaine commence par x et False dans le cas contraire
chaine1 + chaine2 : la concaténation de chaine1 et de chaine
n * chaine avec n un entier : chaine + chaine + …
+ chaine
n fois
index
split
Exercice:
Demander à l'utilisateur de donner son adresse email patie1@partie et
Affciher les parties `patie1, partie
In [ ]:
In [ ]:
dir(str)
In [ ]:
chaine = "Bonjour Monsieur Ndiaye"
In [ ]:
[Link]()
In [ ]:
[Link]()
In [ ]:
[Link]("Sow", "DIALLO")
In [ ]:
ch1 = [Link]()
ch2 = [Link](" ", "")
ch2
# enlever les espaces
In [ ]:
chaine. #tabulation
Fstring
In [ ]:
x = 2
y = x**2
diff = abs(x - y)
# ch3 = "Pour x=2, y=4, et la différence de x et de y = 2"
ch3 = f"Pour x={x}, y={y}, et la différence de x et de y diff= {diff}"
ch3
In [ ]:
a=int(input("entrer la valeur"))
print("le carree de {} est {} ".format(a,a**2))
la méthode .format()
In [ ]:
x, y = 5, 9
In [ ]:
ch4 = "Pour x={} , y={} , et la différence de x et de y".format(x, y)
ch4
In [ ]:
ch4 = "Pour y={1}, x={0}, et la différence de x et de y".format(x, y)
ch4
In [ ]:
ch5 = "La valeur de x={0}, sa valeur absolue est {0} et son carré est {1}".format(x, y)
In [ ]:
chaine1 = "Bonjour"
chaine2 = "tout le monde !"
In [ ]:
chaine1 + chaine2
In [ ]:
chaine1 + " " + chaine2
Si L est une liste de chaine de caractères alors
[Link](L) : renvoie chaine de caractères qui est la concaténation des éléments de L separés deux à
deux par chaine
i.e L[0] + chaine + L[1] + chaine + L[2] + chaine + ...
In [ ]:
L = ["A", "B", "C", "D", "F"]
In [ ]:
"@".join(L)
In [ ]:
" --> ".join(L)
In [ ]:
"".join(L)
In [ ]:
x=str(input("entrer un chaine "))
print("-".join(list(x)))
In [ ]:
[Link]("Bon")
In [ ]:
[Link]('!')
Exercice :
Demander à l'utilisateur son email et dire si c'est
Gmail
Yahoo
EPT
Outlook
V-5-1. Opérations sur les tuples
T = ("DIALLO", "NDIAYE", "SARR", "SOW", "FAYE") T2 = ("D", "N", "S", "F")
In [ ]:
del T[0]
In [ ]:
dir(tuple)
In [ ]:
ch4
V-5-2. Opérations sur les listes
In [ ]:
dir(list)
Supposons que L, L1 et L2 sont de type list
del L[i] : supprime l'élément L[i] de la liste L
[Link](val) : ajoute val à la liste
[Link](L2) : rajoute L2 à L1
L1 + L2 : renvoie la concaténation des deux listes L1 et L2
[Link](val, i) : insert val à la position i
L[i] = val : remplace l'élément à la position i par val
In [ ]:
fruit = ["Pomme", "Orange", "Mangue", "Bannane", "Pastec", "Citron"]
In [ ]:
fruit + fruit
In [ ]:
[Link]("Clémentine")
In [ ]:
fruit
In [ ]:
fruit[1] = "Mandarine"
In [ ]:
fruit
In [ ]:
L = fruit[:]
print(L)
Remarque : Effet de bord
In [ ]:
L=[1,2]
M=L
[Link](5)
print(M)
In [ ]:
print(L)
Remarque : mutables et immuables
La valeur de certains objets peut changer. Les objets qu'on peut modifier ( ajouter, supprimer,
remplacer ) sont dits mutables ( mutable en anglais) et les objets dont la valeur est définitivement fixée à
leur création sont dits immuables ( immutable en anglais).
1. mutables : 'list', 'set', 'dict' ; on peut modifier, supprimer, ajouter des éléments etc.
2. immuables : 'int, float, str, tuple'
In [ ]:
T = (1, 2, [1, 2])
In [ ]:
id(T[2])
In [ ]:
T[2].append("SECK")
In [ ]:
In [ ]:
id(T[2])
V-6. Opérations sur les dictionaires
Supposons que dico est un dictionaire.
[Link]() : les clefs de dico ( list([Link]() retourne la liste des cles),
[Link]() : les valeurs de dico ( list([Link]() retourne la liste des valeurs),
[Link]() : les items de dico ( list([Link]() retourne la liste des items i.e [(key1,
valeur1), (key2, valeur2), ...., (keyn, valeurn)] ),
[Link]() : une shallow copie de dico ,
key in dico : renvoie True si key est une clé du ditionnaire dico et False dans le cas contraire,
dico[key] = valeur ajoute l'élément key: valeur au dictionaire,
del dico[key] supprime la clef key et sa valeur.
In [ ]:
dico = {"A": 0, "B": 1, "C": 2, "D": 3, "E": 4}
In [ ]:
"A" in dico
In [ ]:
[Link]()
In [ ]:
type([Link]())
In [ ]:
tuple([Link]())
In [ ]:
[Link]()
In [ ]:
del dico['A']
In [ ]:
dico
In [ ]:
dico1 = {"A": 0, "B": 1}
dico2 = {"D": 3, "E": 4}
In [ ]:
{**dico1, **dico2}
Exercic1: methodes de mis-a-jour d'un dic
7. Opérations sur les booleens
In [ ]:
True + True
In [ ]:
True - False
In [ ]:
True and True
In [ ]:
True or False
In [ ]:
ch = input("Saisir une phrase")
a = ch or "Bonjour"
print(a)
8. Remaques
variable operateur= valeur est équivalent à variable = variable operateur valeur
+= -= *= /= //= %= &= |= ^= **=
+= -= *= /= //= %= &= |= ^= **=
In [ ]:
x = 6
# x = x + 4
In [ ]:
x += 4
print(x)
In [ ]:
y = 20
y //= 5 # y = y // 5
print(y)