Académique Documents
Professionnel Documents
Culture Documents
Said NOUH
2022-2023
1
Chapitre 1:Généralités, Rappels
Et Instructions de base de Python
2
Question clé du module informatique:
On dispose du matériel informatique (microprocesseur,
mémoire vive, périphériques d’entrée, périphériques de
sortie, et périphériques de stockage). Comment exploiter
ce matériel et le programmer pour résoudre des
problèmes ?
Deux situations:
1) utilisation des programmes faits par d’autres
personnes.
2) Création de nouveaux programmes
3
ALGORITHME
◆ Algorithme du surnom latin Algorismi du mathématicien Arabe
Al Khwarizmi.
◆ Définition: Un algorithme est une suite d’actions précises
qui doivent être exécutées dans un ordre déterminé en vue
de la résolution d’un problème.
◆ Objectifs:
Un algorithme sert à transmettre un savoir faire.
Il décrit les étapes à suivre pour réaliser un travail.
Il permet d'expliciter clairement les idées de solution d’un
problème indépendamment d'un langage de programmation.
L'utilisateur d'un algorithme n'aura qu'à suivre les instructions,
dans l'ordre pour arriver au résultat que doit donner l'algorithme.
«Ce que l’on conçoit bien s’énonce clairement et les
mots pour le dire arrivent aisément» [N. Boileau]
4 4
QU'EST-CE QU'UN BON ALGORITHME / PROGRAMME?
5
•Exemple
L'algorithme suivant décrit l'usage d'un appareil téléphonique à pièces de monnaie
pour effectuer une communication:
Début
Décrocher l'appareil;
Insérer les pièces nécessaires;
Composer le numéro désiré;
L’interlocuteur décroche l’appareil
Parler;
Raccrocher;
Fin
Remarque :
On a une représentation de la solution du problème sous la forme d’un algorithme. Mais
certains cas n’ont pas été prévus (numéro occupé par exemple), d’où insuffisance de la
solution proposée. Il est nécessaire de détailler au maximum les ordres élémentaires
connus par la machine et prévoir tous les cas possibles. La machine ne peut pas intervenir
dans les cas non prévus (elle ne peut pas réfléchir, elle exécute vos ordre uniquement).
6
Les variables et les constantes
8
• Les opérateurs: +, -, *, / Avec en plus pour les entiers div et mod,
qui permettent respectivement de calculer une division entière et le
reste de cette division.
par exemple :11 div 2 vaut 5, 11 mod 2 vaut 1
En Python: 11//2 vaut 5 et 11%3 vaut 2
• L’opérateur d’égalité :
pour les types simples il permet de savoir si les deux opérandes
sont égales ou non.
Il est représenté par le caractère = (en algo) et par (= =) en python
Le résultat d'une expression contenant cet opérateur est un booléen
• On a aussi l’opérateur d’inégalité : ≠ (en python !=)
• Et pour les types possédant un ordre les opérateurs de comparaison
<, ≤, >, ≥
9
Priorités des opérateurs arithmétiques
• Tout comme en arithmétique les opérateurs ont des
priorités Par exemple * et / sont prioritaires sur + et -
Pour les booléens, la priorité des opérateurs est : non,
et, ouExclusif et ou
• Pour supprimer toutes ambiguïtés on peut utiliser des
parenthèses
10
Les opérateurs logiques
Les operateurs logiques sont : ET ( and en python), OU (or en
python) et NON (not en python).
13
Manipulation de variables
• Par exemple l’expression c ← a + b :
On prend la valeur contenue dans la variable a et
celle contenue dans la variable b. On additionne ces
deux valeurs et on met ce résultat dans la variable c
• Si c avait auparavant une valeur, cette dernière est
perdue !
• Un algorithme peut avoir des interactions avec
l’utilisateur. il peut afficher un résultat (du texte ou le
contenu d’une variable) ou demander à l’utilisateur de
saisir une information afin de la stocker dans une
variable
• En tant qu’informaticien on raisonne en se mettant
“à la place de la machine” 14
Les entrées / sorties
• Instruction d'écriture:
L'instruction de restitution de résultats sur le
périphérique de sortie (en général l'écran) est :
écrire(liste d'expressions)
En Python: print(" X= ",X, " Y= ", Y, ……)
Cette instruction réalise simplement l'affichage des
valeurs des expressions décrites dans la liste.
Ces instructions peuvent être simplement des
variables ayant des valeurs ou même des nombres ou
des commentaires écrits sous forme de chaînes de
caractères.
– Exemple d'utilisation : écrire(x, y+2, "bonjour")
15
Les entrées / sorties
• Instructions de lecture:
L'instruction de prise de données sur le périphérique
d'entrée (en général le clavier) est :
variable ← lire() ou lire(variable)
En Python:
variable = (int, float, …) (input(« votre message"))
L'exécution de cette instruction consiste à affecter
une valeur à la variable en prenant cette valeur sur le
périphérique d'entrée.
Avant l'exécution de cette instruction, la variable
avait ou n'avait pas de valeur. Après, elle a la valeur
prise sur le périphérique d'entrée.
16
Structure séquentielle
a- Définition
On dit qu'un algorithme a une structure séquentielle lorsque les instructions
s'exécutent d'une manière linéaire une après une du début jusqu'à la fin.
b- exemple
Soit l'algorithme suivant:
Algorithme moyenne;
Variables NT1, NT2, NT3, MOY : Réel;
Début
LIRE (NT1);
LIRE (NT2);
LIRE (NT3);
MOY← (NT1+ NT2+ NT3)/3;
ECRIRE (MOY);
Fin
17
Exercice 1 : Exercice 2: Écrire un algorithme qui permet
Quels sont les messages affichés à de saisir le prix "Hors taxe" d'une
l’cran après l’exécution des marchandise et d’afficher ensuite le prix
instructions suivantes ? "TTC" sachant que cet article a une T.V.A
1. A<---2 (constante) de 20%. Traduire en Python
2. A<---A+2
3. B<---A*2+A Exercice 3: Écrire un algorithme saisissant
4. C<---4 deux variables entières et qui calcule et
5. C<---B-C affiche leur moyenne. Traduire en Python
6. C<--- C+A-B
7. A<--- B-C*A Exercice 4: Écrire un algorithme saisissant
8. A<--- (B-A)*C un temps en secondes que l’on transcrira en
9. B<--- (A+C)*B jours, heures, minutes et secondes. Traduire
en Python.
10. Ecrire(‘la valeur de A est :’ , A)
11. Ecrire(‘la valeur de B est :’ , B)
Exercice 5: Écrire un algorithme saisissant
12. Ecrire(‘la valeur de C est :’ , C)
la valeur d’une variable X, puis il calcule la
valeur de X16 (rapidement). Traduire en
Traduire cet algorithme au langage
Python.
Python
18
Structure conditionnelle ou alternative
• L’instruction si alors sinon permet de conditionner l’exécution
d’un algorithme à la valeur d’une expression booléenne.
Syntaxe :
si expression booléenne alors
suite d’instructions exécutées si l’expression est vrai
sinon
suite d’instructions exécutées si l’expression est
fausse
finsi
Remarque: cette structure est appelée structure alternative ou
sélective simple. S’il n’y a pas le sinon, elle est appelée
structure sélective réduite.
19
Exemple en algorithmique:
Algorithme equationDeuxiemeDegre
Variable a,b,c,delta,x1,x2: réels
Début
Ecrire(« donner a, b et c: »)
Lire(a,b,c)
deltab*b-4*a*c
Si(delta<0) alors ecrire(« pas de solutions »)
sinon si (delta=0) alors ecrire(« une solution:»,-b/(2*a))
sinon x1 (-b-racine(delta))/(2*a)
x2 (-b+racine(delta))/(2*a)
Ecrire(« 2 solutions: »,x1,x2)
Finsi
Finsi
Fin 20
Exemple en python:
from math import *
print("donner a, b et c: ")
a=float(input("")); b=float(input("")); c=float(input(""));
delta=b*b-4*a*c
if(delta<0) :
print("pas de solutions ")
elif(delta==0) :
print("une solution:",-b/(2*a))
else:
x1 =(-b-sqrt(delta))/(2*a)
x2 =(-b+sqrt (delta))/(2*a)
print("2 solutions:" ,x1,x2)
21
Définition
Dans un algorithme ayant une structure alternative les instructions s'exécutent selon la réalisation
d'une condition ou non.
•La condition est une expression logique de type X Relation Y
Avec Relation est l'un des opérateurs de comparaison Suivants:
22
Instruction conditionnelle En Python:
if (conditions 1): ATTENTION à l’indentation en Python !!!!
……………….
elif (conditions 2):
……………….
elif (conditions 3):
…………….
else :
……………….
25
Instruction conditionnelle
Exercice 6:
Ecrire l’exemple précédent en langage Python:
Réponse:
print("entrer un nombre");
valeur=float(input()); # (float pour l'ensemble IR et int pour
# l'ensemble Z)
if valeur>=0:
valabsolue=valeur
else:
valabsolue=-1.0*valeur
print("la valeur absolue est: ", valabsolue)
26
La boucle déterministe
• Il est fréquent que le nombre de répétitions soit connu à
l'avance, et que l'on ait besoin d'utiliser le numéro de l'itération
afin d'effectuer des calculs ou des tests. Le mécanisme
permettant cela est la boucle Pour.
• Forme de la boucle Pour :
Pour variable de valeur initiale à valeur finale faire
liste d'instructions
fin pour
-------------------------------------------------------------------------
En Python:
for <cible> in <objet>:
<instructions>
else :
<instructions>
27
• La boucle for fonctionne sur les chaînes, les listes, les tuples et
d’autres objets.
• La partie else: … est optionnelle.
• L’instruction range (a,b,pas) permet de créer une liste L
croissante ou décroissante d’entiers successifs . aL, a+pas L,
a+2*pas L, a+3*pas L, ….. Et x L: x<b
• Exemple:
for i in range(10,20,3):
print (i);
else:
print("Sortie de la boucle avec i=",i);
input();
Donne à l’exécution: 10
13
16
19
Sortie de la boucle avec i= 19
28
Représentation graphique (organigramme) de la boucle pour :
i ←a
Vrai
i <b instructions i ← i + pas
faux
29
boucle indéterministe
• L'utilisation d'une "boucle pour" nécessite de connaître
à l'avance le nombre d'itérations désiré, c'est-à-dire la
valeur finale du compteur. Dans beaucoup de cas, on
souhaite répéter une instruction tant qu'une certaine
condition est remplie, alors qu'il est à priori impossible
de savoir à l'avance au bout de combien d'itérations
cette condition cessera d'être satisfaite. Dans ce cas, on
a deux possibilités :
la boucle Tant que et la boucle Répéter jusqu'à
• Syntaxe de la boucle Tant que :
tant que condition faire
liste d'instructions
ftant
30
Les répétitions conditionnelles
• Etant donné que la condition est évaluée avant
l'exécution des instructions à répéter, il est possible
que celles-ci ne soient jamais exécutées.
• Il faut que la liste des instructions ait une incidence
sur la condition afin qu'elle puisse être évaluée à
faux et que la boucle se termine.
• Il faut toujours s'assurer que la condition devient
fausse au bout d'un temps fini.
• Exemple : Un utilisateur peut construire des
rectangles de taille quelconque, à condition que les
largeurs qu'il saisit soient supérieures à 1 pixel.
31
En Python:
La boucle while exécute un bloc tant que la condition de continuité est
vérifiée. La particularité de ce while est qu’il peut y avoir un else optionnel
dont le bloc sera exécuté lorsqu’on sort de la boucle.
while <test> :
<instructions>
else :
<instructions>
33
Définir une fonction
Il arrivera souvent qu'une même séquence d'instructions doive être utilisée à plusieurs
reprises dans un programme, et on souhaitera bien évidemment ne pas avoir à la
reproduire systématiquement.
34
Fonction simple sans paramètres
Pour utiliser la fonction que nous venons de définir, il suffit de l'appeler par son
nom. Ainsi :
>>> table7()
Provoque l'affichage de :
7 14 21 28 35 42 49 56 63 70
35
Pourquoi définir une fonction ?
1. Créer une nouvelle fonction vous offre l'opportunité de donner un nom à tout un
ensemble d'instructions. De cette manière, vous pouvez simplifier le corps
principal d'un programme, en dissimulant un algorithme secondaire complexe
sous une commande unique, à laquelle vous pouvez donner un nom très
explicite, en français si vous voulez.
3. Une fonction est donc en quelque sorte une nouvelle instruction personnalisée,
que vous ajoutez vous-même librement à votre langage de programmation.
36
Fonction avec paramètres
La fonction table() telle que définie ci-dessous utilise le paramètre base pour
calculer les dix premiers termes de la table de multiplication de base.
37
Fonction avec plusieurs paramètres
La fonction table() est certainement intéressante, mais elle n'affiche toujours que les dix
premiers termes de la table de multiplication, alors que nous pourrions souhaiter qu'elle en
affiche d'autres. Nous allons l'améliorer en lui ajoutant des paramètres supplémentaires,
dans une nouvelle version que nous appellerons cette fois tableMulti() :
38
Utilisation des fonctions dans une autre fonction
Les fonctions peuvent aussi s'utiliser dans des scripts. Veuillez essayer vous-
même le petit programme ci-dessous, lequel calcule le volume d'une sphère à
l'aide de la formule : V= 4/3* pi*r^3
def cube(n):
return n**3
def volumeSphere(r):
return 4 * 3.1416 * cube(r) / 3
39
Fonction anonyme (lambda function)
Le mot-clé lambda en Python permet la création de fonctions anonymes
(i.e. sans nom et donc non définie par def)
Exemple:
>>> f = lambda x : x * x
>>> f ( 3 )
9
On peut également préciser plusieurs arguments:
>>> g = lambda x , y : x * y
>>> g(5, 7)
35
On peut également préciser des valeurs par défaut :
40
Fonctions comme valeurs de première classe
En Python, une fonction est une valeur comme une autre, c’est-à-dire qu’elle peut
être passée en argument, renvoyée comme résultat ou encore stockée dans une
variable. On dit que les fonctions sont des valeurs de première classe.
Une application directe est la définition d’un opérateur mathématique par une
fonction.
n
i =1
f (i )
Par exemple, la somme : , pour une fonction f quelconque, peut être
ainsi définie :
def somme_fonction( f , n ):
s = 0
for i in range(n+1):
s = s + f ( i )
return s
41
Exemple d’application:
def carre ( x ) :
return x*x
42
Fonctions récursives
Une fonction est dite récursive si elle s’appelle elle-même : on parle alors d’appel
récursif de la fonction.
(n! =
k
)
k =1 est simplement définie par la relation de récurrence suivante:
0! = 1
n ! = n.(n − 1)! n *
43
Exemple d’exécution de la fonction récursive fact:
fact(1)=1*fact(0) fact(1)=1
Procédure et fonction
Les "fonctions": assez proches de la notion mathématique correspondante.
Notamment, une fonction dispose d'arguments (en python, une fonction peut ne
pas comporter des arguments) qui correspondent à des informations qui lui sont
transmises et elle fournit un résultat qui peut être d’un type reconnu en python
(nombre, liste, tuple, …..
L’appel d’une fonction peut apparaître dans une expression.
2. Variable globale
Les variables déclarées à l'extérieur de toutes les fonctions sont disponibles
à toutes les fonctions du programme par l’utilisation du mot clé global. Ce
sont alors des variables globales.
Conseils :
▪ Les variables globales sont à utiliser avec précaution.
▪ Il faut faire attention à ne pas cacher involontairement des variables
globales par des variables locales portant le même nom.
▪ Il est conseillé d'écrire des programmes aussi localement que possible.
46 46
Chapitre 3
Les chaines de caractères
47
Les chaines de caractères
Le type des chaînes de caractères, string en anglais et dans Python, est celui
permettant de représenter des textes. On considère dans un premier temps des
textes élémentaires, ceux composés d’une unique lettre ; on les appelle les
caractères.
En Python, les caractères peuvent être n’importe quelle lettre de l’alphabet, mais
aussi des symboles, comme les signes de ponctuation. Une chaîne de
caractères est une suite finie de caractères consécutifs, qu’on note entre
apostrophes ou guillemets :
'Ceci est une chaine'
La chaîne vide se note '' ou " "
Accès à un caractère:
On peut stocker une chaîne dans une variable :
s = 'Bonjour'
et accéder à chacun des caractères à l’aide de la construction s[i] :
>>>s[2]
'n’
Comparaison:
>>> ‘bonjour’ == ‘bonne journée’
False
48
Les chaines de caractères
>>> n=x.count('S')
➔n=2
>>> x.endswith("dir")
➔True
>>> x.startswith("Idris")
➔True
>>>y =x.lower()
➔y= ‘idrissi, bouhajeb, belkouch, soulane, sadir‘
>>> y=x.upper()
➔'IDRISSI, BOUHAJEB, BELKOUCH, SOULANE, SADIR‘
>>>x.find('Bel')
➔19
>>> x.index('Bel')
➔19 51
>>> x="Bonjour mes chers étudiant alyassamine SUP 2018"
>>> x.islower()
>>> chaine = 'Aujourd'hui'
False >>> chaine = 'Aujourd\'hui'
>>> x.isupper() >>> print chaine
False >>> chaine = "Aujourd'hui"
>>> x.isdigit() >>> print chaine
False >>> chaine = 'Première ligne\nDeuxième ligne'
>>> x.isalpha() >>> print chaine
False >>> chaine = """Première ligne
>>> x.isalnum() Deuxième ligne"""
>>> print chaine
False
>>> X="Pa"
>>> y=x.replace(' ','') >>> Y=X*2
➔"PaPa"
>>> y
'BonjourmeschersétudiantalyassamineSUP2018'
>>> y.isalnum()
True
>>> '6'.isdigit() >>> X="Bon"
True >>> Y=X*2
➔"BonBon"
>>> x[43:].isnumeric()
True 52
>>> " ".isspace()
➔True
>>> "Soulane Slimane".isspace()
➔False
>>> " ".isspace()
➔True
>>> "\t".isspace()
➔True
>>> "Titre".istitle()
➔True
>>> "TitrE".istitle()
➔False
>>> "Titre de mon site".istitle()
➔False
>>> "Titre De Mon Site".istitle()
➔True
>>> "***".join(["Idrissi", "alaoui" , "Said"])
➔'Idrissi***alaoui***Said‘
>>> "Soulane".replace("ou", "a")
➔'Salane'
>>> ("Soulane".replace("ou", "a")).replace("la","loua")
➔'Salouane'
53
>>>"olivier\nengel\ndéveloppeur".splitlines()
➔['olivier', 'engel', 'développeur']
>>> x="bonjour sup mpsi. soyez les bienvenue"
>>> x.capitalize()
➔'Bonjour sup mpsi. soyez les bienvenue'
>>> e="\n"
>>> e.isprintable()
➔False
>>> x='bon'
>>> x.isprintable()
➔True
>>> x='bon'
>>> x.isprintable()
➔True
>>> y="c'estunevariable100%"
>>> y.isidentifier()
➔False
>>> x="Bonjour Chers Etudiants"
>>> x.swapcase()
➔'bONJOUR cHERS eTUDIANTS‘
>>> x="ceCi n'eSt pas BOn"
>>> x.title()
➔"Ceci N'Est Pas Bon" 54
Définition d'une liste
Les listes
C’est une collection ordonnée et modifiable d’éléments éventuellement hétérogènes.
>>> nombres = [5, 38, 10, 25]
>>> mots = ["fromage", "confiture", "chocolat"]
>>> L= [5000, "Big Data", 3.1416, ["Bon", "Jour", 1947]]
Dans le dernier exemple ci-dessus, nous avons rassemblé un entier, une chaîne,
un réel et même une liste, pour vous rappeler que l'on peut combiner dans une liste
des données de n'importe quel type, y compris des listes.
56
>>> nombres.index(17) # retrouver l'index d'un élément
4
>>> nombres.remove(38) # enlever (effacer) un élément
>>> nombres
[12, 72, 25, 17, 10]
En plus de ces méthodes, vous disposez encore de l'instruction intégrée del, qui vous
permet d'effacer un ou plusieurs éléments à partir de leur(s) index :
>>> del(nombres[2])
>>> nombre
s[12, 72, 17, 10]
>>> del(nombres[1:3])
>>> nombres
[12, 10]
58
Parcours d'une liste à l'aide de for, range() et len()
L'instruction for est l'instruction idéale pour parcourir une liste :
>>> prov = ['La','raison','du','plus','fort','est','toujours','la','meilleure']
>>> for mot in prov:
... print(mot, end =' ')
La raison du plus fort est toujours la meilleure
10 100 1000
13 169 2197
16 256 4096
Supposons par exemple que vous voulez créer une liste B qui contient le même
nombre d'éléments qu'une autre liste A. Vous pouvez obtenir ce résultat de différentes
manières, l'une des plus simples consiste à effectuer : B = [0]*len(A).
>>>'orange‘ in fruits
True
>>>len(fruits)
2
60
index(L,x,a,b) retourne la position de la première occurrence de x
dans la liste L entre les deux positions a et b. si b n’est pas donné la
recherche s’éffectue de la position a à la fin.
>>> L=["Bon","Jour","Monsieur"]
>>> C="***".join(L)
>>> C
'Bon***Jour***Monsieur’
64
Dictionnaires
Les types composites (chaînes de caractères, listes et tuples) considérés jusqu’à
maintenant étaient tous des séquences, i.e. des suites ordonnées d’éléments.
Un dictionnaire ressemble à une liste et est modifiable mais n’est pas une
séquence car les éléments enregistrés ne sont pas disposés dans un ordre
immuable.
On peut accéder à un élément d’un dictionnaire à partir d’une clé. Cette clé
peut être une chaîne, un nombre ou même d’un type composite sous certaines
conditions. On ne peut pas modifier les clés d’un dictionnaire.
Nous pouvons utiliser en guise de clés n’importe quel type de donnée non
modifiable : des entiers, des réels, des chaînes de caractères et même des tuples.
>>> sudoku = {}
>>> sudoku[(0, 1)] = 9
>>> sudoku[(0, 4)] = 5
>>> sudoku[(0, 7)] = 3
>>> print(sudoku)
{(0, 1): 9, (0, 7): 3, (0, 4): 5} Chaque clé dans un
>>> print(sudoku[(0,4)]) dictionnaire est unique.
5
>>> print(sudoku[(2,2)])
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
print sudoku[(2,2)]
KeyError: (2, 2)
Les dictionnaires permettent tous les opérateurs de type standard mais n’autorisent
pas d’opérations telles que la concaténation, la répétition ou l’extraction d’un groupe
d’éléments contigus car les dictionnaires ne sont pas des séquences, c’est-à-dire
les éléments ne sont pas disposés dans un ordre particulier. 67
Les dictionnaires
Contrairement à une liste, nous ne faisons pas appel à une méthode particulière
telle que append() pour ajouter un nouvel élément à un dictionnaire. Il suffit de
créer une nouvelle paire clé-valeur.
>>> print(traduction)
{'mouse': 'souris', 'keyboard': 'clavier'}
>>> traduction["computer"] = "ordinateur"
>>> print(traduction)
{'computer': 'ordinateur', 'mouse': 'souris', 'keyboard': 'clavier'}
dict() : renvoie un dictionnaire issu par exemple d’une séquence où ses éléments
doivent être associés deux à deux. Le premier élément constituera une
nouvelle clé et le second sa valeur associée.
68
L=[["Zineb",17],["Salma",16.75],["Amine",15]]
def trouverNote(M,nom):
for i in range(len(M)):
if M[i][0]==nom:
return M[i][1]
return -1
Exercice:
On dispose d’un dictionnaire associant à des noms de commerciaux
d’une société le nombre de ventes qu’ils ont réalisées.
Par exemple :
ventes= {"Amine":14, "Rachid":19, "Hamza":15, "Taha":21, "Aya":17}
70
Supprimer des éléments d’un dictionnaire ou des dictionnaires entiers
71
Accès aux valeurs d’un dictionnaire
bleu---blue
vert---green
rouge---red
bleu---blue
vert---green
rouge---red
72
On doit vérifier si un dictionnaire possède une clé avant de tenter d’accéder à
sa valeur.
Vous pouvez mettre à jour un dictionnaire en lui ajoutant une nouvelle entrée ou
en modifiant une entrée existante.
>>> dictionnaire = {'rouge': 'red', 'vert': 'green', 'bleu': 'blue'}
>>> dictionnaire['noir'] = 'black'
>>> dictionnaire['bleu'] = 'BLUE'
>>> print(dictionnaire)
{'bleu': 'BLUE', 'noir': 'black', 'vert': 'green', 'rouge': 'red'}
Lorsqu’on affecte une valeur à une clé qui n’existe pas encore, la clé est créée
dans le dictionnaire et la valeur est ajoutée. Mais si la clé existe déjà, alors la
valeur existante est remplacée par la nouvelle.
>>> dictionnaire = {1: "vert", 1:"VERT"}
>>> print(dictionnaire)
{1: 'VERT'} 73
Fonctions et méthodes permettant de manipuler des dictionnaires.
>>> print(traduction.keys())
['computer', 'keyboard']
>>> print(traduction.values())
['ordinateur', 'clavier']
>>> print(traduction.has_key("mouse"))
False
>>> print(traduction.items())
[('computer', 'ordinateur'), ('keyboard', 'clavier')]
D.copy() : effectue une vraie copie d’un dictionnaire D au lieu d’un alias.
>>> conversion = traduction.copy()
>>> conversion["mouse"] = "souris"
>>> print traduction
{'computer': 'ordinateur', 'keyboard': 'clavier'}
>>> print conversion
{'computer': 'ordinateur', 'mouse': 'souris', 'keyboard': 'clavier'}
74
Les tuples
Vous savez qu’il n’est pas possible de changer les caractères au sein d’une chaîne
existante, alors que vous pouvez modifier les éléments d’une liste.
Un tuple est une collection d’éléments à l’intérieur de parenthèses séparés par des
virgules semblable à une liste mais il n’est pas modifiable.
Un tuple peut représenter une clé de dictionnaire ce qu’une liste ne peut faire.
Les tuples sont préférables aux listes partout où l’on veut être certain que les
données transmises ne soient pas modifiées par erreur.
>>> saisons = ("printemps", "été", "automne", "hiver")
>>> print(saisons)
('printemps', 'été', 'automne', 'hiver')
>>> print(saisons[2:3])
('automne',) Il faut toujours au moins
>>> print (("printemps",) + saisons[1:4]) une virgule pour définir
('printemps', 'été', 'automne', 'hiver') un tuple.
>>> saisons[2] = "Automne"
Pour accéder aux valeurs d’un tuple, on utilise les crochets de la même façon
qu’avec les listes.
76
Modification d’un tuple
On peut modifier certains éléments d’un tuple si ces éléments sont modifiables.
>>> T = (5, [0, 1, 2])
>>> print (T)
(5, [0, 1, 2])
>>> T[0] = 6
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
T[0] = 6
TypeError: 'tuple' object does not support item assignment
>>> T[1][0] = -1
>>> print (T)
(5, [-1, 1, 2]) 77
Suppression d’un tuple ou des éléments d’un tuple
Il est impossible de supprimer individuellement les éléments d’un tuple.
On peut assembler un nouveau tuple en omettant les éléments indésirables.
Pour supprimer explicitement un tuple entier, on utilise del :
del (teinte)
Les opérateurs *, +, in, [], <, >, ==, <=, >= et les fonctions intégrées len, max, min
se comportent exactement de la même façon avec les tuples qu’avec les listes.
>>> T = (2, 3)
Les fonctions intégrées list() et tuple() permettent >>> T = list(T)
de convertir une liste en tuple ou vice versa. >>> print (T)
[2, 3] 78
Les interfaces graphiques sous python 3
• Les boutons permettent de proposer une action à l'utilisateur. Dans l'exemple
ci-dessous, on lui propose de fermer la fenêtre.
• from tkinter import *
• fenetre=Tk()
• fenetre.geometry('400x200')
• fenetre.title('PI-2 ESTEM Window')
• # définition des dimensions de la fenêtre (400x300)
• label = Label(fenetre, text="Bonjour PI-2 ESTEM, Bienvenue!",fg="red",bg='yellow')
• label.pack() # affichage du label
• bouton=Button(fenetre, text="Fermer", command=fenetre.destroy)
• bouton.pack() # affichage du bouton
• fenetre.mainloop()
• #fenetre.mainloop()# est très importante, parce que c'est elle qui provoque le
• #démarrage du réceptionnaire d'événements associé à la fenêtre. Cette instruction
• # est nécessaire pour que votre application soit « à l'affût » des clics de souris, des
pressions exercées sur les touches du clavier, etc. C'est donc cette instruction qui « la
met en marche », en quelque sorte T1 79
#Checkbutton : affiche des cases à cocher.
from tkinter import *
fenetre = Tk()
CheckVar1 = StringVar()
CheckVar2 = StringVar()
CheckVar3 = StringVar()
bouton = Checkbutton(fenetre, text="Etudiant",variable = CheckVar1,onvalue ="oui", offvalue = "non")
bouton.pack()
bouton2 = Checkbutton(fenetre, text="Prépas Integrés", variable = CheckVar2,onvalue ="oui", offvalue = "non")
bouton2.pack()
bouton3 = Checkbutton(fenetre, text="Bac Scientifique", variable = CheckVar3,onvalue ="oui", offvalue = "non")
bouton3.pack()
labelX=Label(fenetre, text="vous êtes: ")
labelX.pack()
def fonction1():
ch=""
if(CheckVar1.get()=="oui"):
ch+="Etudiant"
if(CheckVar2.get()=="oui"):
ch+=" Prépas Integrés "
if(CheckVar3.get()=="oui"):
ch+=" Bac Scientifique "
labelX.configure(text="vous êtes: "+ch)
bouton4=Button(fenetre, text="Afficher", command=fonction1)
bouton4.pack()
T2
fenetre.mainloop()
80
Les boutons radio sont des cases à cocher qui sont dans un groupe
et dans ce groupe seul un élément peut être sélectionné.
• fenetre = Tk()
• value = StringVar()
• bouton1 = Radiobutton(fenetre, text="Oui", variable=value, value=1)
• bouton2 = Radiobutton(fenetre, text="Non", variable=value, value=2)
• bouton3 = Radiobutton(fenetre, text="Peu être", variable=value,
value=3)
• bouton1.pack()
• bouton2.pack()
• bouton3.pack()
• fenetre.mainloop()
T3
81
• Les frames (cadres) sont des conteneurs qui permettent de
séparer des éléments.
• from tkinter import *
• fenetre = Tk()
• fenetre['bg']='white'
• # frame 1
• Frame1 = Frame(fenetre, borderwidth=2, relief=GROOVE)
• Frame1.pack(side=LEFT, padx=30, pady=30)
• # frame 2
• Frame2 = Frame(fenetre, borderwidth=2, relief=GROOVE)
• Frame2.pack(side=LEFT, padx=10, pady=10)
• # frame 3 dans frame 2
• Frame3 = Frame(Frame2, bg="white", borderwidth=2, relief=GROOVE)
• Frame3.pack(side=RIGHT, padx=5, pady=5)
• # Ajout de labels
• Label(Frame1, text="Frame 1").pack(padx=10, pady=10)
• Label(Frame2, text="Frame 2").pack(padx=10, pady=10)
• Label(Frame3, text="Frame 3",bg="white").pack(padx=10, pady=10)
• fenetre.mainloop()
T4 82
from tkinter import *
root = Tk()
root.title('Frames')
for r in [RAISED, SUNKEN, FLAT, RIDGE, GROOVE, SOLID]:
f = Frame(root, borderwidth=2, relief=r)
Label(f, text=r, width=10).pack(side=LEFT)
f.pack(side=LEFT, padx=5, pady=5)
root.mainloop()
T5 83
Le widgets Entry:
T6
84
• Les listes permettent de récupérer une valeur sélectionnée par
l'utilisateur.
T9
86
T9-V-2
87
• Le widget scale permet de récupérer une valeur numérique via
un scroll
T10
88
T10-V-2
89
• La spinbox propose à l'utilisateur de choisir un nombre
T11 90
Le labelframe est un cadre avec un label
• from tkinter import *
• fenetre = Tk()
• l = LabelFrame(fenetre, text="Titre de la frame", padx=20,
T11 pady=20)
• l.pack(fill="both", expand="yes")
• Label(l, text="A l'intérieure de la frame").pack()
• fenetre.mainloop()
T12
91
Pour pouvoir utiliser les alertes de votre os, vous pouvez importer le
module tkMessageBox
from tkinter import *
from tkinter.messagebox import *
def callback():
if askyesno('Titre 1', 'Êtes-vous sûr de vouloir faire ça?'):
showwarning('Titre 2', 'Tant pis...')
else:
showinfo('Titre 3', "Vous n'êtes pas sûr!")
showerror("Titre 4", "Au revoir...")
B=Button(text='Action', command=callback)
B.pack()
fenetre.mainloop()
T13
92
Pour pouvoir utiliser les alertes de votre os: module tkMessageBox
T14 93
• Il est possible de créer une barre de menu comme-ceci:
• from tkinter import *
• def alert():
showinfo("alerte", "Bravo!")
• fenetre = Tk()
• menubar = Menu(fenetre)
• menu1 = Menu(menubar)
• menu1.add_command(label="Créer", command=alert)
• menu1.add_command(label="Editer", command=alert)
• menu1.add_separator()
• menu1.add_command(label="Quitter", command=fenetre.quit)
• menubar.add_cascade(label="Fichier", menu=menu1)
• menu2 = Menu(menubar)
• menu2.add_command(label="Couper", command=alert)
• menu2.add_command(label="Copier", command=alert)
• menu2.add_command(label="Coller", command=alert)
• menubar.add_cascade(label="Editer", menu=menu2)
• menu3 = Menu(menubar)
• menu3.add_command(label="A propos", command=alert)
• menubar.add_cascade(label="Aide", menu=menu3)
• fenetre.config(menu=menubar)
• T15
fenetre.mainloop() 94
Animations (voir T16.py)
Canevas = Canvas(Mafenetre,height=HAUTEUR,width=LARGEUR,bg='white')
Canevas.coords(Balle,X-RAYON,Y-RAYON,X+RAYON,Y+RAYON)
Mafenetre.after(50,deplacement)
Balle = Canevas.create_oval(X-RAYON,Y-
RAYON,X+RAYON,Y+RAYON,width=1,fill='green')
95
• Vous pouvez récupérer les actions utilisateurs à travers
les events (évènements).
• Pour chaque widget, vous pouvez binder (lier) un évènement, par exemple
dire lorsque l'utilisateur appuie sur telle touche, faire cela.
• Voici un exemple qui récupère les touches appuyées par l'utilisateur:
98
import sqlite3 Connexion des bases de données avec Python
fichierDonnees = "C:/______________python 20-21/DB1.sqlite"
conn=sqlite3.connect(fichierDonnees)
cur=conn.cursor()
cur.execute("INSERT INTO fournisseur
(numero_fr,nom_fr,ville_fr)VALUES(6401,'Ahmadi','meknes'),
(909,'A','B')")
cur.execute("SELECT * FROM fournisseur")
TableFournisseurs=cur.fetchall() # ou bien: list(cur)
cur.execute("delete FROM fournisseur where numero_fr=61")
conn.commit()
cur.close()
conn.close()
99
Base de données Sqlite sous python 3
def ListeDesProduit(numFour):
import sqlite3
fichierDonnees ="C:/DB1.sqlite"
conn=sqlite3.connect(fichierDonnees)
cur=conn.cursor()
requete="SELECT * FROM produit where numero_fr="+str(numFour)
cur.execute(requete)
resultat=cur.fetchall()
for r in resultat:
print(r)
cur.close()
conn.close() 104
Base de données Sqlite sous python
def InformationsProduit(REF):
import sqlite3
fichierDonnees = "C:/DB1.sqlite"
conn=sqlite3.connect(fichierDonnees)
cur=conn.cursor()
requete="SELECT * FROM produit where ref_produit="+str(REF)
print(requete)
cur.execute(requete)
resultat=cur.fetchone()
print(resultat)
cur.close()
conn.close() 105
Base de données Sqlite sous python
def InformationsProduit(DESIGN):
import sqlite3
fichierDonnees = "C:/DB1.sqlite"
conn=sqlite3.connect(fichierDonnees)
cur=conn.cursor()
requete="SELECT * FROM produit where désignation="+'"'+DESIGN+'"'
print(requete)
cur.execute(requete)
resultat=cur.fetchone()
print(resultat) ; cur.close() ; conn.close()
106
Base de données Sqlite sous python
four=(2999,'Louhmadi','Mohammedia'); f3=(112611,'Akrami','Casablanca')
def InsererFournisseur(f):
import sqlite3
fichierDonnees = "C:/DB1.sqlite"
conn=sqlite3.connect(fichierDonnees)
cur=conn.cursor()
requete="insert into fournisseur values"+str(f)
cur.execute(requete)
choix=input("Pour valider cette insertion taper O, sinon N:")
if choix=='O':
conn.commit()
else:
conn.rollback()
cur.close()
conn.close()
107