FABOL |1

PROGRAMMATION DESKTOP AVEC PYTHON

Introduction

Python est un langage de programmation polyvalent et populaire, connu pour sa

syntaxe claire et lisible. Il est largement utilisé dans divers domaines tels que le
développement web, l'analyse de données, l'intelligence artificielle, etc.

Voici les principaux types d'applications que l'on peut développer avec Python :

1. Applications de bureau : Python offre des bibliothèques comme Tkinter, PyQt,

et wxPython pour créer des applications de bureau interactives avec des interfaces
graphiques utilisateur (GUI). Ces applications peuvent être des outils de
productivité, des éditeurs de texte, des jeux, des applications de gestion, etc.

2. Applications Web : Python est largement utilisé pour le développement web

grâce à des frameworks populaires comme Django et Flask. Ces frameworks
offrent des fonctionnalités robustes pour la création de sites web, d'applications
web, de services web, et plus encore.

3. Applications scientifiques et analytiques : Python est largement utilisé dans le

domaine de la science des données, de l'analyse de données et du calcul
scientifique. Des bibliothèques telles que NumPy, Pandas, Matplotlib et SciPy
sont utilisées pour manipuler, analyser et visualiser des données, ainsi que pour
effectuer des calculs scientifiques complexes.

4. Applications d'intelligence artificielle et d'apprentissage automatique : Python

est le langage de choix pour le développement d'applications d'intelligence
artificielle (IA) et d'apprentissage automatique (ML). Des bibliothèques comme
TensorFlow, Keras, PyTorch et scikit-learn sont largement utilisées pour créer des
modèles d'IA et de ML pour diverses applications, telles que la reconnaissance
d'images, la traduction automatique, la prédiction, etc.

5. Applications de traitement du langage naturel (NLP) : Python est utilisé pour

le développement d'applications de traitement du langage naturel (NLP) grâce à
des bibliothèques comme NLTK, spaCy et gensim. Ces applications peuvent
inclure la création de chatbots, l'analyse de sentiments, la traduction automatique,
etc.

6. Applications de développement de jeux : Python peut être utilisé pour le

développement de jeux grâce à des bibliothèques comme Pygame. Bien que moins
courant que d'autres langages comme C++ ou Unity, Python est utilisé pour créer
 FABOL |2

des jeux simples, des prototypes de jeux, des outils de développement de jeux,
etc.

Python est un langage de programmation extrêmement polyvalent qui peut être

utilisé pour développer une large gamme d'applications dans divers domaines, des
applications de bureau aux applications web, en passant par les applications
scientifiques, l'IA, le ML, le NLP et même les jeux. Sa simplicité, sa polyvalence
et sa large communauté en font un choix populaire pour de nombreux
développeurs à travers le monde.

Voici ses principales caractéristiques :

1. Simplicité et lisibilité : La syntaxe de Python est intuitive et facile à lire, ce qui

en fait un excellent choix pour les débutants et les projets collaboratifs.

2. Polyvalence : Python est utilisé dans de nombreux domaines, tels que le

développement web, la science des données, l'intelligence artificielle,
l'automatisation système, etc.

3. Interprété : Python est un langage interprété, ce qui signifie que le code est
exécuté ligne par ligne par un interpréteur, ce qui facilite le développement itératif
et le débogage.

4. Typage dynamique : Python est dynamiquement typé, ce qui signifie que les
types des variables sont déterminés à l'exécution, offrant une grande flexibilité
mais nécessitant une attention particulière pour éviter les erreurs.

5. Gestion automatique de la mémoire : Python dispose d'un garbage collector

intégré qui gère automatiquement la mémoire, simplifiant ainsi la gestion des
ressources.

6. Large bibliothèque standard : Python offre une vaste bibliothèque standard qui
couvre une gamme étendue de fonctionnalités, permettant aux développeurs
d'accéder à des outils pour accomplir diverses tâches sans avoir à réinventer la
roue.

7. Communauté active : Python bénéficie d'une communauté mondiale active de

développeurs qui contribuent à son écosystème en créant des bibliothèques, des
frameworks et des outils.

En résumé, Python est un langage de programmation puissant et polyvalent, idéal

pour les débutants et les professionnels, offrant simplicité, lisibilité et une large
gamme de fonctionnalités pour répondre à divers besoins de développement.
 FABOL |3

Installation de Python

Pour commencer à programmer en Python, vous devez installer Python sur votre
ordinateur. Vous pouvez le télécharger depuis le site officiel de Python
(https://www.python.org/) et suivre les instructions d'installation pour votre
système d'exploitation.

L'installation de PyCharm

PyCharm, un environnement de développement intégré (IDE) populaire pour

Python, est généralement simple et directe. Voici un résumé des étapes typiques
pour installer PyCharm :

1. Téléchargement de l'installateur : Rendez-vous sur le site officiel de PyCharm

et téléchargez l'installateur correspondant à votre système d'exploitation
(Windows, macOS, Linux).

2. Exécution de l'installateur : Une fois le téléchargement terminé, lancez

l'installateur en double-cliquant sur le fichier téléchargé. Sur macOS, faites glisser
l'icône de PyCharm dans le dossier Applications pour l'installer.

3. Configuration initiale : Lors du premier démarrage de PyCharm, vous serez

invité à effectuer quelques configurations initiales, telles que la sélection de
l'édition (Community ou Professional), la configuration des paramètres de l'IDE
et l'installation des plugins facultatifs.

4. Création d'un projet : Après la configuration initiale, vous pouvez créer un

nouveau projet ou ouvrir un projet existant. PyCharm offre des modèles de projet
pour divers types d'applications Python, ce qui facilite la mise en place de votre
environnement de développement.

5. Configuration de l'environnement virtuel : Il est recommandé d'utiliser des

environnements virtuels pour isoler les dépendances de vos projets. PyCharm
offre des outils intégrés pour créer et gérer des environnements virtuels.

6. Installation des packages et des dépendances : Utilisez l'interface utilisateur de

PyCharm pour installer les packages Python nécessaires à votre projet. PyCharm
facilite la gestion des dépendances en intégrant des gestionnaires de packages
comme pip.

7. Développement et débogage : Une fois votre environnement configuré, vous

pouvez commencer à développer votre application Python dans PyCharm. L'IDE
 FABOL |4

offre des fonctionnalités avancées telles que l'achèvement automatique du code,

le débogage interactif, la navigation dans le code et bien plus encore.

L'installation de PyCharm pour le développement Python implique le

téléchargement de l'installateur, son exécution, la configuration initiale, la
création de projets, la gestion des environnements virtuels et des dépendances, et
enfin le développement et le débogage de votre code. PyCharm offre une
expérience de développement conviviale et puissante pour les programmeurs
Python de tous niveaux.

Les bases de Python

Syntaxe de base

Python utilise une syntaxe claire et lisible qui ressemble à du pseudocode. Voici
un exemple simple d'un programme Python :

# Ceci est un commentaire

print("Bonjour, monde !")

Les Identificateurs en Python

Les identificateurs sont des noms utilisés pour identifier des variables, des
fonctions, des classes, des modules ou d'autres objets. Les règles pour définir
des identificateurs en Python sont les suivantes :

1. Les lettres et les chiffres : Un identificateur doit commencer par une lettre (a-
z, A-Z) ou un underscore (_), suivi par des lettres, des chiffres ou des
underscores.
2. Pas de mots réservés : Les mots réservés (ou mots-clés) en Python ne peuvent
pas être utilisés comme identificateurs.
3. Sensibles à la casse : Python distingue les majuscules des minuscules, donc
`Variable` et `variable` sont différents.

Exemples d'identificateurs valides :

- `my_variable`
- `_private_var`
- `ClassName`
- `var123`

Exemples d'identificateurs invalides :

- `2variable` (commence par un chiffre)
- `my-variable` (contient un tiret)
 FABOL |5

- `class` (mot réservé)

Les Mots Réservés en Python

Les mots réservés sont des mots qui ont une signification particulière pour le
compilateur Python et ne peuvent pas être utilisés comme noms d'identificateurs.
Ils sont toujours en minuscules.

Exemples de mots réservés en Python :

`and` `elif` `import` `pass`
`as` `else` `in` `raise`
`assert` `except` `is` `return`
`break` `finally` `lambda` `try`
`class` `for` `None` `while`
`continue` `from` `nonlocal` `with`
`def` `global` `not` `yield
`del` `if` `or` `pass`

Entrées et Sorties en Python

En Python, l'entrée (input) et la sortie (output) sont réalisées principalement via

les fonctions `input()` et `print()`.

Entrée (Input)

La fonction `input()` est utilisée pour lire une ligne de texte depuis l'entrée
standard (habituellement le clavier). Elle renvoie la chaîne de caractères entrée
par l'utilisateur.

Exemple d'utilisation de `input()` :

name = input("Entrez votre nom : ")
print("Bonjour, " + name + "!")

Dans cet exemple, l'utilisateur est invité à entrer son nom, qui est ensuite affiché
avec un message de bienvenue.

Sortie (Output)

La fonction `print()` est utilisée pour afficher des messages ou des valeurs sur la
sortie standard (habituellement l'écran).

Exemple d'utilisation de `print()` :

print("Hello, world!")
 FABOL |6

a=5
b = 10
print("La somme de", a, "et", b, "est", a + b)

Cet exemple affiche un message simple et la somme de deux nombres.

Exemple Complet

Voici un exemple complet intégrant les notions d'identificateurs, de mots

réservés et d'entrées/sorties en Python :

# Exemple d'utilisation de variables (identificateurs)

nom_utilisateur = input("Entrez votre nom : ") # entrée utilisateur
age_utilisateur = int(input("Entrez votre âge : ")) # conversion de chaîne à
entier

# Utilisation de print() pour la sortie

print("Bienvenue,", nom_utilisateur)
print("Vous avez", age_utilisateur, "ans.")

# Utilisation d'une fonction (définie par un identificateur)

def afficher_message(nom, age):
if age >= 18:
print(nom, "est majeur.")
else:
print(nom, "est mineur.")

# Appel de la fonction
afficher_message(nom_utilisateur, age_utilisateur)

Dans cet exemple :

- `nom_utilisateur` et `age_utilisateur` sont des identificateurs.
- `input`, `int`, `print`, `def`, `if`, `else` sont des mots réservés.
- Les fonctions `input()` et `print()` sont utilisées pour l'entrée et la sortie.

Variables et types de données

En Python, les variables sont des conteneurs qui stockent des données. Vous
pouvez déclarer des variables et leur assigner des valeurs. Voici les principaux
types de données et des variables en Python, avec un exemple pour chaque cas :

1. Entiers (int) : Les entiers représentent des nombres entiers sans décimales.
 FABOL |7

Exemple :
age = 25

2. Nombres à virgule flottante (float) : Les nombres à virgule flottante

représentent des nombres réels avec une partie décimale.

Exemple :
prix = 19.99

3. Chaînes de caractères (str) : Les chaînes de caractères représentent du texte,

entouré de guillemets simples ou doubles.

Exemple :
nom = "Alice"

4. Booléens (bool) : Les booléens représentent les valeurs de vérité, soit True
(Vrai) soit False (Faux).

Exemple :
est_majeur = True

5. Listes (list) : Les listes sont des collections ordonnées et modifiables d'éléments
de différents types.

Exemple :
fruits = ["pomme", "banane", "orange"]

6. Tuples (tuple) : Les tuples sont des collections ordonnées et immuables

d'éléments de différents types.

Exemple :
coordonnees = (10, 20)

7. Dictionnaires (dict) : Les dictionnaires sont des collections non ordonnées de

paires clé-valeur.

Exemple :
etudiant = {"nom": "Alice", "age": 25, "classe": "Python"}

8. Ensembles (set) : Les ensembles sont des collections non ordonnées d'éléments
uniques.

Exemple :
 FABOL |8

voyelles = {'a', 'e', 'i', 'o', 'u'}

9. None : None est une valeur spéciale qui représente l'absence de valeur ou la
nullité.

Exemple :
adresse = None

Python offre une grande variété de types de données pour stocker et manipuler
différentes sortes d'informations. Chaque type de données a ses propres
caractéristiques et utilisation, ce qui permet une grande flexibilité dans le
développement d'applications Python.

Les opérateurs

Les opérateurs en Python sont des symboles spéciaux utilisés pour effectuer des
opérations sur des valeurs ou des variables. Voici les principaux types
d'opérateurs en Python, avec un exemple pour chaque cas :

1. Opérateurs arithmétiques : Ils sont utilisés pour effectuer des opérations

mathématiques telles que l'addition, la soustraction, la multiplication, la division,
etc.

Exemple :
a = 10
b=5

addition = a + b
soustraction = a - b
multiplication = a * b
division = a / b

L'opérateur modulo en Python, représenté par le symbole `%`, est utilisé pour
obtenir le reste de la division entière de deux nombres. Voici son fonctionnement
et un exemple d'utilisation :

1. Fonctionnement de l'opérateur modulo : L'opérateur modulo renvoie le reste de

la division entière de deux nombres. Par exemple, `a % b` renverra le reste de la
division de `a` par `b`.

Exemple :
resultat = 10 % 3
print(resultat) # Résultat : 1 (car 10 = 3 * 3 + 1)
 FABOL |9

2. Utilisation dans les tests de parité : L'opérateur modulo est souvent utilisé pour
déterminer si un nombre est pair ou impair. Un nombre pair divisé par 2 donnera
un reste de 0, tandis qu'un nombre impair donnera un reste de 1.

Exemple :
nombre = 7
if nombre % 2 == 0:
print("Le nombre est pair")
else:
print("Le nombre est impair")

3. Utilisation dans les boucles et les séquences : L'opérateur modulo peut être
utilisé pour créer des boucles ou des séquences répétitives avec une certaine
périodicité.

Exemple :
for i in range(10):
if i % 2 == 0:
print("Nombre pair :", i)
else:
print("Nombre impair :", i)

4. Utilisation pour calculer les indices cycliques : L'opérateur modulo est utile
pour parcourir cycliquement une liste ou un tableau en boucle.

Exemple :
jours = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi",
"Dimanche"]
indice = 8
jour = jours[indice % len(jours)]
print(jour) # Résultat : Mercredi (car 8 % 7 = 1)

L'opérateur modulo en Python est un outil puissant pour effectuer des opérations
basées sur les restes de divisions entières. Il est largement utilisé dans divers
contextes, notamment pour tester la parité, créer des boucles cycliques et calculer
des indices répétitifs.

2. Opérateurs d'affectation : Ils sont utilisés pour attribuer des valeurs à des
variables.

Exemple :
x = 10
 F A B O L | 10

y=5

3. Opérateurs de comparaison : Ils sont utilisés pour comparer deux valeurs et

renvoyer un résultat booléen (vrai ou faux).

Exemple :
a = 10
b=5

egal = a == b
superieur = a > b
inferieur_ou_egal = a <= b

4. Opérateurs logiques : Ils sont utilisés pour combiner des expressions

booléennes et renvoyer un résultat booléen.

Exemple :
x = True
y = False

et_logique = x and y
ou_logique = x or y
non_logique = not x

5. Opérateurs d'appartenance : Ils sont utilisés pour vérifier si une valeur est
présente dans une séquence.

Exemple :
liste = [1, 2, 3, 4, 5]

est_present = 3 in liste
n_est_pas_present = 6 not in liste

6. Opérateurs d'identité : Ils sont utilisés pour comparer l'identité d'objets (leur
emplacement mémoire).

Exemple :
x = [1, 2, 3]
y = [1, 2, 3]

sont_identiques = x is y
ne_sont_pas_identiques = x is not y
 F A B O L | 11

Les opérateurs en Python permettent d'effectuer une grande variété d'opérations,

allant des calculs mathématiques simples à la logique complexe. Comprendre et
maîtriser ces opérateurs est essentiel pour écrire un code Python efficace et
expressif.

Structures de contrôle

Les structures de contrôle en Python permettent de contrôler le flux d'exécution

d'un programme en fonction de certaines conditions. Voici les principales
structures de contrôle en Python avec un exemple pour chaque cas :

1. Instructions conditionnelles (if-elif-else) : Permet d'exécuter des blocs de code

en fonction de conditions.

Exemple :
note = 75
if note >= 90:
print("A")
elif note >= 80:
print("B")
elif note >= 70:
print("C")
else:
print("D")

2. Boucles while : Exécute un bloc de code tant qu'une condition donnée est vraie.

Exemple :
count = 0
while count < 5:
print(count)
count += 1

3. Boucles for : Parcourt un ensemble d'éléments, comme une liste ou une plage
de nombres.

Exemple :
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
print(fruit)

4. Instructions break et continue : Permettent de contrôler le flux à l'intérieur des

boucles. Break arrête la boucle et continue passe à l'itération suivante.
 F A B O L | 12

Exemple :
for i in range(10):
if i == 3:
continue
if i == 7:
break
print(i)

5. Instructions pass : Ne fait rien et est souvent utilisé comme espace réservé pour
une fonctionnalité future ou pour éviter une erreur de syntaxe.

Exemple :
if True:
pass

6. Instructions try-except : Permettent de gérer les erreurs et les exceptions.

Exemple :
try:
resultat = 10 / 0
except ZeroDivisionError:
print("Division par zéro!")

Les structures de contrôle en Python, telles que les instructions conditionnelles,

les boucles et les mécanismes de gestion des erreurs, offrent un moyen puissant
de contrôler le flux d'exécution d'un programme en fonction des conditions et des
situations rencontrées. Utilisées judicieusement, elles permettent de créer des
programmes flexibles et robustes.

Fonctions

Les fonctions en Python sont des blocs de code réutilisables qui effectuent une
tâche spécifique. Voici les aspects clés des fonctions, avec un exemple pour
chaque cas :

1. Définition de fonction : Pour définir une fonction, utilisez le mot-clé `def`, suivi
du nom de la fonction et des parenthèses contenant les paramètres, le cas échéant.

Exemple :
def saluer(nom):
print("Bonjour,", nom)
 F A B O L | 13

saluer("Alice")

2. Paramètres et arguments : Les paramètres sont des valeurs que vous passez à
une fonction lors de son appel. Les arguments sont les valeurs réelles passées à la
fonction.

Exemple :
def multiplier(x, y):
return x * y

resultat = multiplier(3, 5)

3. Valeurs de retour : Les fonctions peuvent renvoyer des valeurs à l'aide du mot-
clé `return`.

Exemple :
def multiplier(x, y):
return x * y

resultat = multiplier(3, 5)

4. Fonctions avec des valeurs par défaut : Vous pouvez attribuer des valeurs par
défaut aux paramètres d'une fonction.

Exemple :
def saluer(nom="Anonyme"):
print("Bonjour,", nom)

saluer()

5. Fonctions récursives : Les fonctions peuvent s'appeler elles-mêmes, ce qui est

utile pour résoudre des problèmes récursifs.

Exemple :
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(5))
 F A B O L | 14

6. Portée des variables : Les variables définies à l'intérieur d'une fonction sont
locales à cette fonction, sauf si elles sont explicitement déclarées comme globales.

Exemple :
def ma_fonction():
x = 10
print(x)

ma_fonction()

7. Fonctions lambda : Les fonctions lambda sont des fonctions anonymes et de

courte durée définies à l'aide du mot-clé `lambda`.

Exemple :
carre = lambda x: x ** 2
print(carre(5))

Les fonctions en Python offrent un moyen efficace de réutiliser du code, de le

rendre plus modulaire et de le rendre plus lisible. Elles permettent également
d'encapsuler la logique, de rendre le code plus facile à maintenir et de le rendre
plus facile à tester.

Les tableaux

En Python, les tableaux sont couramment représentés sous forme de listes, qui
sont des structures de données flexibles et polyvalentes. Voici un résumé des
principaux aspects des tableaux en Python, avec un exemple pour chaque cas :

1. Création de listes : Les listes peuvent être créées en énumérant leurs éléments
entre crochets `[ ]`.

Exemple :
liste = [1, 2, 3, 4, 5]

2. Accès aux éléments : Les éléments d'une liste peuvent être accédés par leur
indice, en utilisant l'opérateur d'indexation `[ ]`.

Exemple :
premier_element = liste[0]
deuxieme_element = liste[1]

3. Modification d'éléments : Les éléments d'une liste peuvent être modifiés en

affectant de nouvelles valeurs à leurs indices.
 F A B O L | 15

Exemple :
liste[2] = 10

4. Ajout d'éléments : De nouveaux éléments peuvent être ajoutés à une liste à

l'aide de méthodes telles que `append()` pour ajouter à la fin ou `insert()` pour
ajouter à une position spécifique.

Exemple :
liste.append(6)
liste.insert(2, 7)

5. Suppression d'éléments : Les éléments peuvent être supprimés d'une liste à

l'aide de la méthode `remove()` pour supprimer une valeur spécifique, ou de
l'instruction `del` pour supprimer par indice.

Exemple :
liste.remove(4)
del liste[1]

6. Longueur de la liste : La fonction `len()` peut être utilisée pour déterminer le

nombre d'éléments dans une liste.

Exemple :
longueur = len(liste)

7. Parcours de la liste : Les éléments d'une liste peuvent être parcourus à l'aide de
boucles `for` ou `while`.

Exemple :
for element in liste:
print(element)

8. Listes en compréhension : Les listes en compréhension offrent une syntaxe

concise pour la création de listes basées sur des expressions.

Exemple :
carres = [x**2 for x in range(1, 6)]

Les listes en Python sont des structures de données flexibles et puissantes,

largement utilisées pour stocker des collections d'éléments de différents types.
Leur polyvalence et leur syntaxe claire en font un choix populaire pour une variété
de tâches de programmation.
 F A B O L | 16

La programmation orientée objet (POO)

La programmation orientée objet (POO) est un paradigme de programmation qui

organise le code autour de classes et d'objets, plutôt que de fonctions et de
données. En Python, la POO est largement utilisée et comprend plusieurs concepts
clés :

1. Classe : Une classe est un modèle qui définit les attributs et les comportements
d'un objet. Elle sert de plan pour créer des instances d'objets.

Exemple :
class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age

def afficher_info(self):
print(f"Nom : {self.nom}, Age : {self.age}")

# Création d'une instance de la classe Personne

personne1 = Personne("Alice", 30)

2. Objet : Un objet est une instance d'une classe. Il possède des attributs (variables)
et des méthodes (fonctions) définis par la classe.

Exemple :
# Utilisation des attributs et des méthodes de l'objet personne1
print(personne1.nom) # Affiche : Alice
print(personne1.age) # Affiche : 30
personne1.afficher_info() # Affiche : Nom : Alice, Age : 30

3. Encapsulation : L'encapsulation consiste à regrouper les données et les

méthodes connexes dans une classe, en limitant l'accès aux données internes de la
classe depuis l'extérieur.

Exemple :
class CompteBancaire:
def __init__(self, solde):
self.__solde = solde # Attribut privé

def afficher_solde(self):
print(f"Solde : {self.__solde}")
 F A B O L | 17

compte1 = CompteBancaire(1000)
compte1.afficher_solde() # Affiche : Solde : 1000
# Erreur : AttributeError: 'CompteBancaire' object has no attribute 'solde'
print(compte1.__solde)

4. Héritage : L'héritage permet à une classe (appelée sous-classe ou classe dérivée)

de hériter des attributs et des méthodes d'une autre classe (appelée super-classe ou
classe de base).

Exemple :
class Etudiant(Personne):
def __init__(self, nom, age, matricule):
super().__init__(nom, age)
self.matricule = matricule

etudiant1 = Etudiant("Bob", 25, "123456")

etudiant1.afficher_info() # Affiche : Nom : Bob, Age : 25

5. Polymorphisme : Le polymorphisme permet à des objets de différentes classes

de répondre de manière uniforme à des messages similaires ou à des méthodes.

Exemple :
class Animal:
def faire_son(self):
pass

class Chien(Animal):
def faire_son(self):
print("Woof!")

class Chat(Animal):
def faire_son(self):
print("Meow!")

def faire_son_animal(animal):
animal.faire_son()

chien = Chien()
chat = Chat()

faire_son_animal(chien) # Affiche : Woof!

faire_son_animal(chat) # Affiche : Meow!
 F A B O L | 18

En résumé, la programmation orientée objet en Python repose sur les concepts de

classes, d'objets, d'encapsulation, d'héritage et de polymorphisme. Ces concepts
offrent une manière puissante et structurée de concevoir et d'organiser le code, en
le rendant plus modulaire, réutilisable et extensible.

Exemple

Voici un exemple d'application de gestion d'employés qui illustre les concepts

clés de la programmation orientée objet en Python :

class Employe:
def __init__(self, nom, age, salaire):
self.nom = nom
self.age = age
self.salaire = salaire

def afficher_info(self):
print(f"Nom: {self.nom}, Age: {self.age}, Salaire: {self.salaire}")

def augmenter_salaire(self, pourcentage):

self.salaire += self.salaire * pourcentage / 100

class GestionEmployes:
def __init__(self):
self.employes = []

def ajouter_employe(self, employe):

self.employes.append(employe)

def afficher_employes(self):
print("Liste des employés:")
for employe in self.employes:
employe.afficher_info()

# Création d'une instance de la classe GestionEmployes

gestionnaire = GestionEmployes()

# Création et ajout d'employés

employe1 = Employe("Alice", 30, 50000)
employe2 = Employe("Bob", 25, 45000)
 F A B O L | 19

gestionnaire.ajouter_employe(employe1)
gestionnaire.ajouter_employe(employe2)

# Affichage des employés

gestionnaire.afficher_employes()

# Augmentation du salaire de l'employé

employe1.augmenter_salaire(10)

# Affichage des employés mis à jour

gestionnaire.afficher_employes()

Dans cet exemple :

- Nous avons une classe `Employe` qui représente un employé avec des attributs
`nom`, `age` et `salaire`. La méthode `afficher_info` affiche les informations de
l'employé, et la méthode `augmenter_salaire` augmente le salaire de l'employé
d'un pourcentage donné.

- Nous avons également une classe `GestionEmployes` qui représente un

gestionnaire d'employés. Elle a une liste d'employés et des méthodes pour ajouter
des employés (`ajouter_employe`) et afficher tous les employés
(`afficher_employes`).

- Nous créons une instance de la classe `GestionEmployes`, ajoutons des

employés à l'aide de la méthode `ajouter_employe`, affichons tous les employés
à l'aide de la méthode `afficher_employes`, puis augmentons le salaire d'un des
employés avec la méthode `augmenter_salaire`.

Cet exemple illustre les concepts clés de la POO en Python, notamment la création
de classes, l'instanciation d'objets, l'accès aux attributs et méthodes, et
l'organisation du code en objets et en classes.

Interface graphique

En Python, il existe plusieurs bibliothèques pour créer des interfaces graphiques

(GUI), chacune avec ses propres caractéristiques et avantages. Voici un bref
aperçu de quelques-unes des bibliothèques les plus populaires :

1. Tkinter : Tkinter est la bibliothèque d'interface graphique standard de Python.

Elle est simple à utiliser, bien documentée et est idéale pour les projets simples
 F A B O L | 20

ou pour apprendre les bases des interfaces graphiques. Tkinter est basée sur le kit
d'outils graphiques Tk, qui est largement utilisé et bien établi.

2. PyQt et PySide : PyQt et PySide sont des liaisons Python pour la bibliothèque
Qt, une puissante bibliothèque d'interface utilisateur C++. Ils offrent une grande
variété de widgets, une bonne performance et une grande flexibilité. PyQt utilise
une licence commerciale, tandis que PySide est disponible sous licence LGPL.

3. wxPython : wxPython est une autre bibliothèque populaire pour créer des
interfaces graphiques en Python. Elle est basée sur le framework wxWidgets et
offre une grande variété de widgets. wxPython est connue pour sa stabilité, sa
maturité et sa documentation complète.

4. Kivy : Kivy est une bibliothèque open source multiplateforme destinée au

développement d'applications multitouch. Elle prend en charge les interfaces
utilisateur naturelles pour les plates-formes mobiles (iOS, Android), ainsi que les
ordinateurs de bureau (Windows, Linux, macOS). Kivy utilise Python comme
langage de programmation principal.

5. PyGTK : PyGTK est une liaison Python pour GTK+, une bibliothèque
d'interface graphique multiplateforme. Elle offre une grande variété de widgets et
est souvent utilisée pour le développement d'applications GNOME sous Linux.

Ces bibliothèques offrent différentes fonctionnalités, niveaux de complexité et

styles de programmation. Le choix de la bibliothèque dépend souvent des besoins
spécifiques du projet, des préférences personnelles et de la plate-forme cible.

Interface graphique avec Tkinter

Tkinter est une bibliothèque standard de Python utilisée pour créer des interfaces
graphiques (GUI). Les widgets les plus couramment utilisés dans Tkinter avec
leurs propriétés correspondantes :

1. Label :
- Propriétés principales : text, font, fg (couleur du texte), bg (couleur de fond),
padx, pady.
- Description : Affiche du texte ou une image non modifiable.

2. Button :
- Propriétés principales : text, command, padx, pady.
- Description : Un bouton cliquable qui déclenche une action lorsqu'il est pressé.

3. Entry :
 F A B O L | 21

- Propriétés principales : textvariable, width, show (pour les mots de passe),

state (activé ou désactivé).
- Description : Zone de saisie pour l'entrée de texte par l'utilisateur.

4. Text :
- Propriétés principales : height, width, wrap (WORD ou CHAR), state.
- Description : Zone de texte multiligne pour l'affichage et la saisie de texte.

5. Canvas :
- Propriétés principales : height, width, bg.
- Description : Zone de dessin pour créer des formes graphiques et des
illustrations.

6. Frame :
- Propriétés principales : relief (FLAT, RAISED, SUNKEN, GROOVE,
RIDGE), bd (épaisseur de la bordure), bg.
- Description : Conteneur invisible utilisé pour organiser et regrouper d'autres
widgets.

7. Checkbutton :
- Propriétés principales : text, variable, onvalue, offvalue.
- Description : Case à cocher qui permet à l'utilisateur de sélectionner une ou
plusieurs options.

8. Radiobutton :
- Propriétés principales : text, variable, value.
- Description : Bouton radio qui permet à l'utilisateur de sélectionner une seule
option parmi plusieurs.

9. Listbox :
- Propriétés principales : height, width, selectmode (SINGLE, BROWSE,
MULTIPLE, EXTENDED).
- Description : Liste déroulante permettant à l'utilisateur de sélectionner un ou
plusieurs éléments.

10. Scrollbar :
- Propriétés principales : orient (HORIZONTAL ou VERTICAL), command.
- Description : Barre de défilement pour faire défiler le contenu d'un widget,
comme une zone de texte ou une liste.

11. Menu :
- Propriétés principales : (pas de propriétés spécifiques, mais utilise des
méthodes pour ajouter des éléments de menu).
 F A B O L | 22

- Description : Barre de menus déroulante permettant d'accéder à différentes

commandes et options.

12. Toplevel :
- Propriétés principales : (comme Frame, mais représente une fenêtre de niveau
supérieur).
- Description : Fenêtre de niveau supérieur indépendante qui peut être utilisée
pour afficher des dialogues ou des fenêtres contextuelles.

Ces widgets offrent une gamme de fonctionnalités pour créer des interfaces
graphiques interactives avec Tkinter en Python, en permettant aux développeurs
de créer des applications conviviales et intuitives. Chaque widget a ses propres
propriétés spécifiques qui peuvent être configurées pour répondre aux besoins de
l'application.

Les principales fonctionnalités de Tkinter et un exemple pour chaque cas :

1. Création d'une fenêtre principale : Vous pouvez créer une fenêtre principale en
instanciant la classe `Tk`.

Exemple :
import tkinter as tk

racine = tk.Tk()
racine.mainloop()

2. Ajout de widgets : Tkinter offre une variété de widgets tels que des boutons,
des étiquettes, des champs de texte, etc., que vous pouvez ajouter à la fenêtre
principale.

Exemple :
import tkinter as tk

racine = tk.Tk()
etiquette = tk.Label(racine, text="Bonjour, monde!")
etiquette.pack()
racine.mainloop()

3. Disposition des widgets : Les widgets peuvent être disposés dans la fenêtre
principale en utilisant différentes méthodes de disposition comme `pack()`,
`grid()` ou `place()`.

Exemple :
 F A B O L | 23

import tkinter as tk

racine = tk.Tk()
bouton1 = tk.Button(racine, text="Bouton 1")
bouton2 = tk.Button(racine, text="Bouton 2")
bouton1.pack(side=tk.LEFT)
bouton2.pack(side=tk.RIGHT)
racine.mainloop()

4. Gestion des événements : Tkinter permet de lier des fonctions à des

événements, comme des clics de souris ou des presses de touche.

Exemple :
import tkinter as tk

def afficher_message():
print("Bouton cliqué!")

racine = tk.Tk()
bouton = tk.Button(racine, text="Cliquez ici", command=afficher_message)
bouton.pack()
racine.mainloop()

5. Création de fenêtres modales : Vous pouvez créer des fenêtres modales en

utilisant la méthode `Toplevel()`.

Exemple :
import tkinter as tk

def afficher_fenetre_modale():
fenetre_modale = tk.Toplevel()
etiquette = tk.Label(fenetre_modale, text="Ceci est une fenêtre modale")
etiquette.pack()

racine = tk.Tk()
bouton = tk.Button(racine, text="Ouvrir fenêtre modale",
command=afficher_fenetre_modale)
bouton.pack()
racine.mainloop()

En résumé, Tkinter est une bibliothèque simple et puissante pour créer des
interfaces graphiques en Python. Avec sa syntaxe intuitive et ses fonctionnalités
flexibles, elle permet de concevoir des applications interactives avec facilité.
 F A B O L | 24

Exercices

Pour créer une application de gestion des achats en Python avec une interface
graphique utilisant Tkinter, nous allons inclure les fonctionnalités suivantes :
1. Définition de la géométrie de la fenêtre.
2. Placement des widgets à l'aide de la méthode `place`.
3. Utilisation de labels (étiquettes) pour afficher du texte.

Étapes de l'application :

1. Création de la fenêtre principale.

2. Ajout de labels pour les champs "Nom du produit", "Quantité", "Prix".
3. Ajout de champs de saisie (Entry) pour les entrées utilisateur.
4. Boutons pour ajouter les achats et afficher la liste des achats.
5. Zone d'affichage pour la liste des achats.

Voici le code de l'application :

import tkinter as tk
from tkinter import messagebox

class GestionAchatsApp:
def __init__(self, root):
self.root = root
self.root.geometry("400x400")
self.root.title("Gestion des Achats")

# Label et Entry pour le nom du produit

self.label_nom = tk.Label(root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = tk.Entry(root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = tk.Label(root, text="Quantité")
self.label_quantite.place(x=20, y=60)
self.entry_quantite = tk.Entry(root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

self.label_prix = tk.Label(root, text="Prix")
self.label_prix.place(x=20, y=100)
 F A B O L | 25

self.entry_prix = tk.Entry(root)
self.entry_prix.place(x=150, y=100)

# Bouton pour ajouter l'achat

self.bouton_ajouter = tk.Button(root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=150, y=140)

# Bouton pour afficher les achats

self.bouton_afficher = tk.Button(root, text="Afficher les achats",
command=self.afficher_achats)
self.bouton_afficher.place(x=150, y=180)

# Zone d'affichage pour la liste des achats

self.liste_achats = tk.Text(root, width=50, height=10)
self.liste_achats.place(x=20, y=220)

# Liste des achats

self.achats = []

def ajouter_achat(self):
nom = self.entry_nom.get()
quantite = self.entry_quantite.get()
prix = self.entry_prix.get()

if nom and quantite and prix:

try:
quantite = int(quantite)
prix = float(prix)
achat = {"nom": nom, "quantite": quantite, "prix": prix}
self.achats.append(achat)
messagebox.showinfo("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, tk.END)
self.entry_quantite.delete(0, tk.END)
self.entry_prix.delete(0, tk.END)
except ValueError:
messagebox.showerror("Erreur", "Veuillez entrer des valeurs valides
pour la quantité et le prix.")
else:
messagebox.showerror("Erreur", "Tous les champs doivent être remplis.")

def afficher_achats(self):
self.liste_achats.delete(1.0, tk.END)
 F A B O L | 26

if not self.achats:
self.liste_achats.insert(tk.END, "Aucun achat enregistré.\n")
else:
for achat in self.achats:
self.liste_achats.insert(tk.END, f"Produit: {achat['nom']}, Quantité:
{achat['quantite']}, Prix: {achat['prix']}\n")

if __name__ == "__main__":
root = tk.Tk()
app = GestionAchatsApp(root)
root.mainloop()

Explications :

1. Création de la fenêtre principale :

- `self.root.geometry("400x400")` définit la taille de la fenêtre.
- `self.root.title("Gestion des Achats")` définit le titre de la fenêtre.

2. Ajout des labels et champs de saisie :

- Les labels et les champs de saisie sont placés à l'aide de la méthode `place`
pour un positionnement précis.

3. Ajout des boutons et de la zone d'affichage :

- Deux boutons sont ajoutés pour ajouter des achats et afficher la liste des achats.
- La zone d'affichage (Text widget) est utilisée pour afficher la liste des achats.

4. Fonctionnalité d'ajout et d'affichage des achats :

- `ajouter_achat` ajoute un achat à la liste après validation.
- `afficher_achats` affiche la liste des achats dans la zone d'affichage.

Cette application de base peut être étendue avec des fonctionnalités

supplémentaires comme la modification ou la suppression d'achats,
l'enregistrement des achats dans un fichier, etc.

Version améliorée

Pour améliorer l'application de gestion des achats en ajoutant les fonctionnalités

supplémentaires telles que le PTHT (Prix Total Hors Taxes), PTTC (Prix Total
Toutes Taxes Comprises) et le Net à payer avec une TVA de 16%, nous allons
faire les modifications suivantes :

1. Ajout de labels pour afficher PTHT, PTTC et Net à payer.

 F A B O L | 27

2. Calcul automatique des valeurs PTHT, PTTC et Net à payer lors de l'ajout d'un
achat.

Code amélioré :
import tkinter as tk
from tkinter import messagebox

class GestionAchatsApp:
def __init__(self, root):
self.root = root
self.root.geometry("500x500")
self.root.title("Gestion des Achats")

# Label et Entry pour le nom du produit

self.label_nom = tk.Label(root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = tk.Entry(root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = tk.Label(root, text="Quantité")
self.label_quantite.place(x=20, y=60)
self.entry_quantite = tk.Entry(root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

self.label_prix = tk.Label(root, text="Prix unitaire HT")
self.label_prix.place(x=20, y=100)
self.entry_prix = tk.Entry(root)
self.entry_prix.place(x=150, y=100)

# Bouton pour ajouter l'achat

self.bouton_ajouter = tk.Button(root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=150, y=140)

# Bouton pour afficher les achats

self.bouton_afficher = tk.Button(root, text="Afficher les achats",
command=self.afficher_achats)
self.bouton_afficher.place(x=150, y=180)

# Zone d'affichage pour la liste des achats

self.liste_achats = tk.Text(root, width=60, height=10)
 F A B O L | 28

self.liste_achats.place(x=20, y=220)

# Labels pour PTHT, PTTC et Net à payer

self.label_ptht = tk.Label(root, text="PTHT: 0.00")
self.label_ptht.place(x=20, y=400)

self.label_tva = tk.Label(root, text="TVA (16%): 0.00")

self.label_tva.place(x=20, y=430)

self.label_pttc = tk.Label(root, text="PTTC: 0.00")

self.label_pttc.place(x=20, y=460)

# Liste des achats

self.achats = []
self.ptht = 0.0

def ajouter_achat(self):
nom = self.entry_nom.get()
quantite = self.entry_quantite.get()
prix = self.entry_prix.get()

if nom and quantite and prix:

try:
quantite = int(quantite)
prix = float(prix)
total_ht = quantite * prix
self.ptht += total_ht
achat = {"nom": nom, "quantite": quantite, "prix": prix, "total_ht":
total_ht}
self.achats.append(achat)
messagebox.showinfo("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, tk.END)
self.entry_quantite.delete(0, tk.END)
self.entry_prix.delete(0, tk.END)
self.mettre_a_jour_totaux()
except ValueError:
messagebox.showerror("Erreur", "Veuillez entrer des valeurs valides
pour la quantité et le prix.")
else:
messagebox.showerror("Erreur", "Tous les champs doivent être remplis.")

def afficher_achats(self):
self.liste_achats.delete(1.0, tk.END)
 F A B O L | 29

if not self.achats:
self.liste_achats.insert(tk.END, "Aucun achat enregistré.\n")
else:
for achat in self.achats:
self.liste_achats.insert(tk.END, f"Produit: {achat['nom']}, Quantité:
{achat['quantite']}, Prix unitaire HT: {achat['prix']}, Total HT:
{achat['total_ht']:.2f}\n")

def mettre_a_jour_totaux(self):
tva = self.ptht * 0.16
pttc = self.ptht + tva

self.label_ptht.config(text=f"PTHT: {self.ptht:.2f}")
self.label_tva.config(text=f"TVA (16%): {tva:.2f}")
self.label_pttc.config(text=f"PTTC: {pttc:.2f}")

if __name__ == "__main__":
root = tk.Tk()
app = GestionAchatsApp(root)
root.mainloop()

Explications des modifications :

1. Géométrie de la fenêtre : La taille de la fenêtre a été augmentée à `500x500`

pour accommoder les nouveaux labels et la zone d'affichage.

2. Ajout de labels PTHT, TVA, PTTC :

- `self.label_ptht`, `self.label_tva`, et `self.label_pttc` ont été ajoutés pour
afficher les valeurs calculées.
- La méthode `mettre_a_jour_totaux` met à jour ces labels après chaque ajout
d'achat.

3. Calcul et affichage des totaux :

- `self.ptht` maintient le total des prix hors taxes.
- La méthode `ajouter_achat` calcule le total HT de chaque achat et met à jour
`self.ptht`.
- `mettre_a_jour_totaux` calcule la TVA et le PTTC, puis met à jour les labels
correspondants.

Ces améliorations permettent une gestion complète des achats avec calcul
automatique des totaux, incluant la TVA.
 F A B O L | 30

Voici un exemple d'interface graphique Tkinter qui permet d'ajouter des

employés, d'afficher la liste des employés et d'augmenter le salaire d'un employé
sélectionné :

import tkinter as tk
from tkinter import ttk

class Employe:
def __init__(self, nom, age, salaire):
self.nom = nom
self.age = age
self.salaire = salaire

def afficher_info(self):
return f"Nom: {self.nom}, Age: {self.age}, Salaire: {self.salaire}"

def augmenter_salaire(self, pourcentage):

self.salaire += self.salaire * pourcentage / 100

class GestionEmployes:
def __init__(self):
self.employes = []

def ajouter_employe(self, employe):

self.employes.append(employe)

def afficher_employes(self):
infos_employes = []
for employe in self.employes:
infos_employes.append(employe.afficher_info())
return infos_employes

def ajouter_employe():
nom = entry_nom.get()
age = int(entry_age.get())
salaire = float(entry_salaire.get())
employe = Employe(nom, age, salaire)
gestionnaire.ajouter_employe(employe)
update_liste_employes()
 F A B O L | 31

def augmenter_salaire():
index = liste_employes.curselection()[0]
pourcentage = int(entry_pourcentage.get())
gestionnaire.employes[index].augmenter_salaire(pourcentage)
update_liste_employes()

def update_liste_employes():
liste_employes.delete(0, tk.END)
for employe in gestionnaire.afficher_employes():
liste_employes.insert(tk.END, employe)

# Création de l'interface graphique

root = tk.Tk()
root.title("Gestion des employés")

frame_ajout = tk.Frame(root)
frame_ajout.pack(padx=10, pady=10)

label_nom = tk.Label(frame_ajout, text="Nom:")

label_nom.grid(row=0, column=0)
entry_nom = tk.Entry(frame_ajout)
entry_nom.grid(row=0, column=1)

label_age = tk.Label(frame_ajout, text="Âge:")

label_age.grid(row=1, column=0)
entry_age = tk.Entry(frame_ajout)
entry_age.grid(row=1, column=1)

label_salaire = tk.Label(frame_ajout, text="Salaire:")

label_salaire.grid(row=2, column=0)
entry_salaire = tk.Entry(frame_ajout)
entry_salaire.grid(row=2, column=1)

btn_ajouter = tk.Button(frame_ajout, text="Ajouter Employé",

command=ajouter_employe)
btn_ajouter.grid(row=3, columnspan=2, pady=10)

frame_modification = tk.Frame(root)
frame_modification.pack(padx=10, pady=10)

liste_employes = tk.Listbox(frame_modification, width=50, height=5)

 F A B O L | 32

liste_employes.grid(row=0, column=0, padx=10, pady=10)

label_pourcentage = tk.Label(frame_modification, text="Pourcentage

d'augmentation:")
label_pourcentage.grid(row=1, column=0)
entry_pourcentage = tk.Entry(frame_modification)
entry_pourcentage.grid(row=1, column=1)

btn_augmenter = tk.Button(frame_modification, text="Augmenter Salaire",

command=augmenter_salaire)
btn_augmenter.grid(row=2, column=0, columnspan=2, pady=10)

# Création de l'instance de la classe GestionEmployes

gestionnaire = GestionEmployes()

root.mainloop()

Cet exemple utilise Tkinter pour créer une interface graphique avec deux parties
:

1. La première partie permet d'ajouter un employé en saisissant son nom, son âge
et son salaire, puis en appuyant sur le bouton "Ajouter Employé".

2. La deuxième partie affiche la liste des employés ajoutés sous forme d'une liste
déroulante. Vous pouvez sélectionner un employé dans la liste et saisir un
pourcentage d'augmentation de salaire dans le champ prévu à cet effet. Ensuite,
en appuyant sur le bouton "Augmenter Salaire", le salaire de l'employé
sélectionné sera augmenté de ce pourcentage.

Ce code intègre les concepts de la programmation orientée objet avec Python, en

utilisant les classes `Employe` et `GestionEmployes` pour représenter les
employés et gérer leur manipulation. L'interface graphique Tkinter facilite
l'interaction avec l'utilisateur en lui permettant d'ajouter des employés et de
modifier leurs salaires de manière conviviale.

Intégration de bases de données

Qu'est-ce qu'une base de données ?

Une base de données est un ensemble organisé de données qui permet de stocker,
d'accéder et de gérer efficacement des informations.

SQLite avec Python

 F A B O L | 33

SQLite est une bibliothèque de gestion de base de données légère qui est intégrée
à Python par défaut. Voici comment utiliser SQLite pour créer une base de
données et interagir avec elle en Python :

import sqlite3

# Connexion à la base de données

connexion = sqlite3.connect('ma_base_de_donnees.db')

# Création d'une table

cursor = connexion.cursor()
cursor.execute('''CREATE TABLE utilisateurs (id INTEGER PRIMARY KEY,
nom TEXT, age INTEGER)''')

# Insertion de données
cursor.execute("INSERT INTO utilisateurs (nom, age) VALUES ('Alice', 30)")
cursor.execute("INSERT INTO utilisateurs (nom, age) VALUES ('Bob', 25)")

# Sélection de données
cursor.execute("SELECT * FROM utilisateurs")
for row in cursor.fetchall():
print(row)

# Fermeture de la connexion
connexion.close()

BD MySQL

MySQL est un système de gestion de base de données relationnelle populaire, et

Python propose plusieurs bibliothèques pour interagir avec MySQL, dont l'une
des plus couramment utilisées est MySQL Connector/Python. Voici un résumé
des principales fonctionnalités et un exemple pour chaque cas :

1. Connexion à la base de données : Utilisez la méthode `connect()` pour établir

une connexion à la base de données en spécifiant l'hôte, le nom d'utilisateur, le
mot de passe et la base de données.

Exemple :
import mysql.connector

connexion = mysql.connector.connect(
host="localhost",
 F A B O L | 34

user="utilisateur",
password="mot_de_passe",
database="ma_base_de_donnees"
)

2. Création d'une table : Utilisez la méthode `execute()` pour exécuter des

instructions SQL pour créer une table.

Exemple :
curseur = connexion.cursor()
curseur.execute("CREATE TABLE utilisateurs (id INT AUTO_INCREMENT
PRIMARY KEY, nom VARCHAR(255), age INT)")

3. Insertion de données : Utilisez la méthode `execute()` pour insérer des données

dans une table.

Exemple :
curseur.execute("INSERT INTO utilisateurs (nom, age) VALUES (%s, %s)",
("Alice", 30))

4. Sélection de données : Utilisez la méthode `execute()` pour exécuter des

instructions SQL de sélection et `fetchall()` pour récupérer les résultats.

Exemple :
curseur.execute("SELECT * FROM utilisateurs")
resultats = curseur.fetchall()
for resultat in resultats:
print(resultat)

5. Mise à jour de données : Utilisez la méthode `execute()` pour exécuter des

instructions SQL de mise à jour.

Exemple :
curseur.execute("UPDATE utilisateurs SET age = %s WHERE nom = %s", (25,
"Alice"))

6. Suppression de données : Utilisez la méthode `execute()` pour exécuter des

instructions SQL de suppression.

Exemple :
curseur.execute("DELETE FROM utilisateurs WHERE nom = %s", ("Alice",))
 F A B O L | 35

7. Commit et rollback : Utilisez la méthode `commit()` pour valider les

modifications dans la base de données et `rollback()` pour annuler les
modifications.

Exemple :
connexion.commit()

En résumé, MySQL Connector/Python offre une interface simple et puissante

pour interagir avec une base de données MySQL en Python. En utilisant ces
fonctionnalités, vous pouvez facilement créer, lire, mettre à jour et supprimer des
données dans une base de données MySQL à partir de vos applications Python.

Exercice

Voici un exemple complet d'un programme Python utilisant MySQL

Connector/Python pour la gestion des ventes de produits. Ce programme permet
d'ajouter, modifier, supprimer et afficher les produits dans une base de données
MySQL :

import mysql.connector

# Connexion à la base de données

connexion = mysql.connector.connect(
host="localhost",
user="utilisateur",
password="mot_de_passe",
database="gestion_ventes"
)

# Fonction pour ajouter un produit

def ajouter_produit(reference, nom, prix):
curseur = connexion.cursor()
curseur.execute("INSERT INTO produits (reference, nom, prix) VALUES
(%s, %s, %s)", (reference, nom, prix))
connexion.commit()
print("Produit ajouté avec succès !")

# Fonction pour modifier un produit

def modifier_produit(reference, nouveau_nom, nouveau_prix):
curseur = connexion.cursor()
curseur.execute("UPDATE produits SET nom = %s, prix = %s WHERE
reference = %s", (nouveau_nom, nouveau_prix, reference))
 F A B O L | 36

connexion.commit()
print("Produit modifié avec succès !")

# Fonction pour supprimer un produit

def supprimer_produit(reference):
curseur = connexion.cursor()
curseur.execute("DELETE FROM produits WHERE reference = %s",
(reference,))
connexion.commit()
print("Produit supprimé avec succès !")

# Fonction pour afficher tous les produits

def afficher_produits():
curseur = connexion.cursor()
curseur.execute("SELECT * FROM produits")
resultats = curseur.fetchall()
for resultat in resultats:
print(resultat)

# Exemple d'utilisation
ajouter_produit("P001", "Ordinateur portable", 999.99)
ajouter_produit("P002", "Smartphone", 599.99)
afficher_produits()
modifier_produit("P001", "Nouvel ordinateur portable", 1099.99)
supprimer_produit("P002")
afficher_produits()

# Fermeture de la connexion
connexion.close()

Ce programme crée une table `produits` dans la base de données `gestion_ventes`

avec des colonnes pour la référence, le nom et le prix des produits. Ensuite, il
utilise les fonctions définies pour ajouter, modifier, supprimer et afficher des
produits dans la base de données.

Exercice2

Voici un exemple complet d'un programme Python utilisant Tkinter pour créer
une interface graphique et MySQL Connector/Python pour la gestion des ventes
de produits. Ce programme permet d'ajouter, modifier, supprimer et afficher les
produits dans une base de données MySQL :

import mysql.connector
 F A B O L | 37

from tkinter import *

from tkinter import messagebox

# Connexion à la base de données

connexion = mysql.connector.connect(
host="localhost",
user="utilisateur",
password="mot_de_passe",
database="gestion_ventes"
)

# Fonction pour ajouter un produit

def ajouter_produit():
reference = entry_reference.get()
nom = entry_nom.get()
prix = entry_prix.get()
curseur = connexion.cursor()
curseur.execute("INSERT INTO produits (reference, nom, prix) VALUES
(%s, %s, %s)", (reference, nom, prix))
connexion.commit()
messagebox.showinfo("Succès", "Produit ajouté avec succès !")
afficher_produits()

# Fonction pour modifier un produit

def modifier_produit():
reference = entry_reference.get()
nouveau_nom = entry_nom.get()
nouveau_prix = entry_prix.get()
curseur = connexion.cursor()
curseur.execute("UPDATE produits SET nom = %s, prix = %s WHERE
reference = %s", (nouveau_nom, nouveau_prix, reference))
connexion.commit()
messagebox.showinfo("Succès", "Produit modifié avec succès !")
afficher_produits()

# Fonction pour supprimer un produit

def supprimer_produit():
reference = entry_reference.get()
curseur = connexion.cursor()
curseur.execute("DELETE FROM produits WHERE reference = %s",
(reference,))
connexion.commit()
messagebox.showinfo("Succès", "Produit supprimé avec succès !")
 F A B O L | 38

afficher_produits()

# Fonction pour afficher tous les produits

def afficher_produits():
curseur = connexion.cursor()
curseur.execute("SELECT * FROM produits")
resultats = curseur.fetchall()
for i in tree.get_children():
tree.delete(i)
for resultat in resultats:
tree.insert('', 'end', values=resultat)

# Création de l'interface graphique

root = Tk()
root.title("Gestion des ventes")

frame_formulaire = Frame(root)
frame_formulaire.pack(pady=10)

label_reference = Label(frame_formulaire, text="Référence:")

label_reference.grid(row=0, column=0)
entry_reference = Entry(frame_formulaire)
entry_reference.grid(row=0, column=1)

label_nom = Label(frame_formulaire, text="Nom:")

label_nom.grid(row=1, column=0)
entry_nom = Entry(frame_formulaire)
entry_nom.grid(row=1, column=1)

label_prix = Label(frame_formulaire, text="Prix:")

label_prix.grid(row=2, column=0)
entry_prix = Entry(frame_formulaire)
entry_prix.grid(row=2, column=1)

frame_boutons = Frame(root)
frame_boutons.pack(pady=10)

bouton_ajouter = Button(frame_boutons, text="Ajouter",

command=ajouter_produit)
bouton_ajouter.grid(row=0, column=0)

bouton_modifier = Button(frame_boutons, text="Modifier",

command=modifier_produit)
 F A B O L | 39

bouton_modifier.grid(row=0, column=1)

bouton_supprimer = Button(frame_boutons, text="Supprimer",

command=supprimer_produit)
bouton_supprimer.grid(row=0, column=2)

frame_resultats = Frame(root)
frame_resultats.pack(pady=10)

tree = ttk.Treeview(frame_resultats, columns=('Référence', 'Nom', 'Prix'),

show='headings')
tree.heading('Référence', text='Référence')
tree.heading('Nom', text='Nom')
tree.heading('Prix', text='Prix')
tree.pack()

afficher_produits()

root.mainloop()

# Fermeture de la connexion
connexion.close()

Ce programme crée une interface graphique avec Tkinter pour saisir les
informations des produits et des boutons pour ajouter, modifier et supprimer les
produits. Les produits sont affichés dans un tableau Tkinter. Lorsque vous ajoutez,
modifiez ou supprimez un produit, la base de données est mise à jour et les
résultats sont rafraîchis dans le tableau.

Exercice

Voici un exemple complet d'un programme Python utilisant Tkinter pour créer
une interface graphique permettant de gérer les ventes de produits à partir d'une
base de données MySQL. L'utilisateur peut sélectionner les produits dans un
ComboBox, indiquer la quantité, et le prix partiel s'affiche automatiquement. Les
événements pour ajouter, modifier, supprimer et afficher les ventes sont
également pris en charge :

import mysql.connector
from tkinter import *
from tkinter import ttk, messagebox

# Connexion à la base de données

 F A B O L | 40

connexion = mysql.connector.connect(
host="localhost",
user="utilisateur",
password="mot_de_passe",
database="gestion_ventes"
)

# Fonction pour ajouter une vente

def ajouter_vente():
produit = combo_produits.get()
quantite = entry_quantite.get()
prix_unitaire = prix_produit.get(produit)
prix_total = float(quantite) * prix_unitaire
curseur = connexion.cursor()
curseur.execute("INSERT INTO ventes (produit, quantite, prix_total)
VALUES (%s, %s, %s)", (produit, quantite, prix_total))
connexion.commit()
messagebox.showinfo("Succès", "Vente ajoutée avec succès !")
afficher_ventes()

# Fonction pour supprimer une vente

def supprimer_vente():
selection = tree.selection()
if selection:
id_vente = tree.item(selection[0], "values")[0]
curseur = connexion.cursor()
curseur.execute("DELETE FROM ventes WHERE id = %s", (id_vente,))
connexion.commit()
messagebox.showinfo("Succès", "Vente supprimée avec succès !")
afficher_ventes()
else:
messagebox.showwarning("Avertissement", "Veuillez sélectionner une
vente à supprimer.")

# Fonction pour afficher toutes les ventes

def afficher_ventes():
curseur = connexion.cursor()
curseur.execute("SELECT * FROM ventes")
resultats = curseur.fetchall()
for i in tree.get_children():
tree.delete(i)
for resultat in resultats:
tree.insert('', 'end', values=resultat)
 F A B O L | 41

# Fonction pour mettre à jour le prix partiel lors de la sélection d'un produit
def maj_prix_partiel(event):
produit = combo_produits.get()
quantite = entry_quantite.get()
prix_unitaire = prix_produit.get(produit)
prix_total = float(quantite) * prix_unitaire
label_prix_partiel.config(text=f"Prix partiel : {prix_total} €")

# Création de l'interface graphique

root = Tk()
root.title("Gestion des ventes")

frame_vente = Frame(root)
frame_vente.pack(pady=10)

label_produit = Label(frame_vente, text="Produit :")

label_produit.grid(row=0, column=0)
produits = ['Produit A', 'Produit B', 'Produit C'] # Exemple de produits
combo_produits = ttk.Combobox(frame_vente, values=produits,
state="readonly")
combo_produits.bind("<<ComboboxSelected>>", maj_prix_partiel)
combo_produits.grid(row=0, column=1)

label_quantite = Label(frame_vente, text="Quantité :")

label_quantite.grid(row=1, column=0)
entry_quantite = Entry(frame_vente)
entry_quantite.grid(row=1, column=1)

label_prix_partiel = Label(frame_vente, text="Prix partiel :")

label_prix_partiel.grid(row=2, column=0, columnspan=2)

bouton_ajouter = Button(frame_vente, text="Ajouter", command=ajouter_vente)

bouton_ajouter.grid(row=3, column=0, columnspan=2, pady=10)

frame_ventes = Frame(root)
frame_ventes.pack(pady=10)

tree = ttk.Treeview(frame_ventes, columns=('ID', 'Produit', 'Quantité', 'Prix total'),

show='headings')
tree.heading('ID', text='ID')
tree.heading('Produit', text='Produit')
tree.heading('Quantité', text='Quantité')
 F A B O L | 42

tree.heading('Prix total', text='Prix total')

tree.pack()

afficher_ventes()

bouton_supprimer = Button(root, text="Supprimer vente sélectionnée",

command=supprimer_vente)
bouton_supprimer.pack(pady=10)

root.mainloop()

# Fermeture de la connexion
connexion.close()

Ce programme crée une interface graphique avec Tkinter permettant à l'utilisateur

de sélectionner un produit dans un ComboBox, d'indiquer la quantité, et d'afficher
automatiquement le prix partiel. Les ventes ajoutées sont affichées dans un
tableau Tkinter. L'utilisateur peut également supprimer une vente sélectionnée.

MongoDB

Vous pouvez utiliser `pip`, le gestionnaire de paquets Python, pour installer

`pymongo`. Voici comment procéder :
1. Ouvrez votre terminal ou votre invite de commande.
2. Exécutez la commande suivante pour installer `pymongo` :
pip install pymongo

Voici un exemple d'application Python qui se connecte à une base de données

MongoDB et effectue des opérations CRUD (Create, Read, Update, Delete) sur
une collection d'employés :

import pymongo

# Connexion à la base de données MongoDB

client = pymongo.MongoClient("mongodb://localhost:27017/")
database = client["gestion_employes"]
collection = database["employes"]

# Fonction pour créer un nouvel employé

def creer_employe(nom, age, salaire):
employe = {"nom": nom, "age": age, "salaire": salaire}
 F A B O L | 43

collection.insert_one(employe)
print("Employé ajouté avec succès !")

# Fonction pour lire tous les employés

def lire_employes():
for employe in collection.find():
print(employe)

# Fonction pour mettre à jour les informations d'un employé

def mettre_a_jour_employe(nom, nouveau_salaire):
query = {"nom": nom}
new_values = {"$set": {"salaire": nouveau_salaire}}
collection.update_one(query, new_values)
print("Salaire de l'employé mis à jour avec succès !")

# Fonction pour supprimer un employé

def supprimer_employe(nom):
query = {"nom": nom}
collection.delete_one(query)
print("Employé supprimé avec succès !")

# Exemple d'utilisation
creer_employe("Alice", 30, 50000)
creer_employe("Bob", 25, 45000)

print("Liste des employés avant la mise à jour :")

lire_employes()

mettre_a_jour_employe("Alice", 55000)

print("Liste des employés après la mise à jour :")

lire_employes()

supprimer_employe("Bob")

print("Liste des employés après la suppression :")

lire_employes()

# Fermeture de la connexion MongoDB

client.close()

Dans cet exemple :

 F A B O L | 44

- Nous utilisons le module `pymongo` pour établir une connexion à une base de
données MongoDB.
- Nous créons une base de données appelée "gestion_employes" avec une
collection "employes".
- Nous définissons des fonctions pour créer, lire, mettre à jour et supprimer des
employés dans la collection.
- Nous appelons ces fonctions pour effectuer des opérations CRUD sur la
collection d'employés.
- Nous utilisons une base de données locale MongoDB, mais vous pouvez
remplacer l'URL de connexion par celle de votre base de données MongoDB
distante.

Cet exemple illustre comment utiliser Python avec MongoDB pour créer une
application simple de gestion d'employés.

Conclusion

Le cours de programmation Desktop avec Python offre une expérience complète

et enrichissante pour quiconque cherche à maîtriser le développement
d'applications de bureau. Voici les principaux points abordés :

1. Introduction à Python : Le cours commence par une solide introduction à

Python, mettant en avant sa syntaxe claire et concise, ainsi que sa polyvalence
pour diverses applications de développement.

2. Déclaration des variables et affectation : Les bases fondamentales telles que la

déclaration des variables et l'affectation sont clairement expliquées, fournissant
une base solide pour la suite du cours.

3. Types de données et structures de contrôle : Les étudiants apprennent à

manipuler efficacement les différents types de données et à utiliser les structures
de contrôle comme les boucles et les conditions pour contrôler le flux du
programme.

4. Fonctions et programmation orientée objet (POO) : Le cours explore en

profondeur les concepts de fonctions et de programmation orientée objet,
permettant aux étudiants de créer des programmes modulaires et réutilisables.

5. Tableaux : L'utilisation de tableaux pour stocker et manipuler des collections

de données est également couverte, offrant aux étudiants une compréhension
complète des structures de données couramment utilisées.
 F A B O L | 45

6. Interface graphique : L'accent est mis sur la création d'interfaces graphiques

attrayantes et fonctionnelles à l'aide de bibliothèques telles que Tkinter, offrant
aux étudiants les compétences nécessaires pour concevoir des applications de
bureau interactives.

7. Connexion avec SQLite, MySQL et MongoDB : Les étudiants apprennent à se

connecter à des bases de données relationnelles et non relationnelles, et à effectuer
des opérations CRUD (Create, Read, Update, Delete), élargissant ainsi leurs
compétences en matière de développement backend.

8. Exercices pratiques : Le cours offre une variété d'exercices pratiques qui

mettent en application les concepts enseignés, permettant aux étudiants de
renforcer leur compréhension et d'acquérir une expérience pratique précieuse.

En conclusion, le cours de programmation Desktop avec Python fournit une

formation complète et équilibrée, couvrant tous les aspects du développement
d'applications de bureau. Grâce à son approche pratique, les étudiants acquièrent
les compétences et la confiance nécessaires pour créer des applications de bureau
professionnelles et fonctionnelles dans un environnement Python.