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é
 FABOL |2

pour créer 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
 FABOL |3

large gamme de fonctionnalités pour répondre à divers besoins de

développement.

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
([Link] 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.
 FABOL |4

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

pouvez commencer à développer votre application Python dans PyCharm. L'IDE
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 :

 FABOL |5

- `2variable` (commence par un chiffre)

- `my-variable` (contient un tiret)
- `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).
 FABOL |6

Exemple d'utilisation de `print()` :

print("Hello, world!")
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 :
 FABOL |7

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

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.
 FABOL |8

Exemple :
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 :
 FABOL |9

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

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.
 F A B O L | 10

Exemple :
x = 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
 F A B O L | 11

ne_sont_pas_identiques = x is not y

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)
 F A B O L | 12

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.

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.
 F A B O L | 13

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

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)
 F A B O L | 14

print(fibonacci(5))

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]
 F A B O L | 15

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.

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 :
[Link](6)
[Link](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 :
[Link](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)]
 F A B O L | 16

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.

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):
[Link] = nom
[Link] = age

def afficher_info(self):
print(f"Nom : {[Link]}, Age : {[Link]}")

# 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([Link]) # Affiche : Alice
print([Link]) # 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):
 F A B O L | 17

self.__solde = solde # Attribut privé

def afficher_solde(self):
print(f"Solde : {self.__solde}")

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)
[Link] = 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()
 F A B O L | 18

chat = Chat()

faire_son_animal(chien) # Affiche : Woof!

faire_son_animal(chat) # Affiche : Meow!

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):
[Link] = nom
[Link] = age
[Link] = salaire

def afficher_info(self):
print(f"Nom: {[Link]}, Age: {[Link]}, Salaire: {[Link]}")

def augmenter_salaire(self, pourcentage):

[Link] += [Link] * pourcentage / 100

class GestionEmployes:
def __init__(self):
[Link] = []

def ajouter_employe(self, employe):

[Link](employe)

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

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

gestionnaire = GestionEmployes()
 F A B O L | 19

# Création et ajout d'employés

employe1 = Employe("Alice", 30, 50000)
employe2 = Employe("Bob", 25, 45000)

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 :
 F A B O L | 20

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
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.
 F A B O L | 21

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 :
- 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.
 F A B O L | 22

- 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).
- 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 = [Link]()
[Link]()

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 = [Link]()
etiquette = [Link](racine, text="Bonjour, monde!")
[Link]()
[Link]()
 F A B O L | 23

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 :
import tkinter as tk

racine = [Link]()
bouton1 = [Link](racine, text="Bouton 1")
bouton2 = [Link](racine, text="Bouton 2")
[Link](side=[Link])
[Link](side=[Link])
[Link]()

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 = [Link]()
bouton = [Link](racine, text="Cliquez ici", command=afficher_message)
[Link]()
[Link]()

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 = [Link]()
etiquette = [Link](fenetre_modale, text="Ceci est une fenêtre modale")
[Link]()

racine = [Link]()
bouton = [Link](racine, text="Ouvrir fenêtre modale",
command=afficher_fenetre_modale)
 F A B O L | 24

[Link]()
[Link]()

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é.

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):
[Link] = root
[Link]("400x400")
[Link]("Gestion des Achats")

# Label et Entry pour le nom du produit

self.label_nom = [Link](root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = [Link](root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = [Link](root, text="Quantité")
self.label_quantite.place(x=20, y=60)
 F A B O L | 25

self.entry_quantite = [Link](root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

self.label_prix = [Link](root, text="Prix")
self.label_prix.place(x=20, y=100)
self.entry_prix = [Link](root)
self.entry_prix.place(x=150, y=100)

# Bouton pour ajouter l'achat

self.bouton_ajouter = [Link](root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=150, y=140)

# Bouton pour afficher les achats

self.bouton_afficher = [Link](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 = [Link](root, width=50, height=10)
self.liste_achats.place(x=20, y=220)

# Liste des achats

[Link] = []

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}
[Link](achat)
[Link]("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, [Link])
self.entry_quantite.delete(0, [Link])
self.entry_prix.delete(0, [Link])
except ValueError:
 F A B O L | 26

[Link]("Erreur", "Veuillez entrer des valeurs valides

pour la quantité et le prix.")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

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

if __name__ == "__main__":
root = [Link]()
app = GestionAchatsApp(root)
[Link]()

Explications :

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

- `[Link]("400x400")` définit la taille de la fenêtre.
- `[Link]("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.
 F A B O L | 27

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.

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):
[Link] = root
[Link]("500x500")
[Link]("Gestion des Achats")

# Label et Entry pour le nom du produit

self.label_nom = [Link](root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = [Link](root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = [Link](root, text="Quantité")
self.label_quantite.place(x=20, y=60)
self.entry_quantite = [Link](root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

self.label_prix = [Link](root, text="Prix unitaire HT")
self.label_prix.place(x=20, y=100)
self.entry_prix = [Link](root)
self.entry_prix.place(x=150, y=100)

# Bouton pour ajouter l'achat

self.bouton_ajouter = [Link](root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=150, y=140)
 F A B O L | 28

# Bouton pour afficher les achats

self.bouton_afficher = [Link](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 = [Link](root, width=60, height=10)
self.liste_achats.place(x=20, y=220)

# Labels pour PTHT, PTTC et Net à payer

self.label_ptht = [Link](root, text="PTHT: 0.00")
self.label_ptht.place(x=20, y=400)

self.label_tva = [Link](root, text="TVA (16%): 0.00")

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

self.label_pttc = [Link](root, text="PTTC: 0.00")

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

# Liste des achats

[Link] = []
[Link] = 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
[Link] += total_ht
achat = {"nom": nom, "quantite": quantite, "prix": prix, "total_ht":
total_ht}
[Link](achat)
[Link]("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, [Link])
self.entry_quantite.delete(0, [Link])
self.entry_prix.delete(0, [Link])
self.mettre_a_jour_totaux()
 F A B O L | 29

except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs valides
pour la quantité et le prix.")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

def afficher_achats(self):
self.liste_achats.delete(1.0, [Link])
if not [Link]:
self.liste_achats.insert([Link], "Aucun achat enregistré.\n")
else:
for achat in [Link]:
self.liste_achats.insert([Link], 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 = [Link] * 0.16
pttc = [Link] + tva

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

if __name__ == "__main__":
root = [Link]()
app = GestionAchatsApp(root)
[Link]()

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 :

- `[Link]` maintient le total des prix hors taxes.
 F A B O L | 30

- La méthode `ajouter_achat` calcule le total HT de chaque achat et met à jour

`[Link]`.
- `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.

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):
[Link] = nom
[Link] = age
[Link] = salaire

def afficher_info(self):
return f"Nom: {[Link]}, Age: {[Link]}, Salaire: {[Link]}"

def augmenter_salaire(self, pourcentage):

[Link] += [Link] * pourcentage / 100

class GestionEmployes:
def __init__(self):
[Link] = []

def ajouter_employe(self, employe):

[Link](employe)

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

def ajouter_employe():
 F A B O L | 31

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()

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

def update_liste_employes():
liste_employes.delete(0, [Link])
for employe in gestionnaire.afficher_employes():
liste_employes.insert([Link], employe)

# Création de l'interface graphique

root = [Link]()
[Link]("Gestion des employés")

frame_ajout = [Link](root)
frame_ajout.pack(padx=10, pady=10)

label_nom = [Link](frame_ajout, text="Nom:")

label_nom.grid(row=0, column=0)
entry_nom = [Link](frame_ajout)
entry_nom.grid(row=0, column=1)

label_age = [Link](frame_ajout, text="Âge:")

label_age.grid(row=1, column=0)
entry_age = [Link](frame_ajout)
entry_age.grid(row=1, column=1)

label_salaire = [Link](frame_ajout, text="Salaire:")

label_salaire.grid(row=2, column=0)
entry_salaire = [Link](frame_ajout)
entry_salaire.grid(row=2, column=1)
 F A B O L | 32

btn_ajouter = [Link](frame_ajout, text="Ajouter Employé",

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

frame_modification = [Link](root)
frame_modification.pack(padx=10, pady=10)

liste_employes = [Link](frame_modification, width=50, height=5)

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

label_pourcentage = [Link](frame_modification, text="Pourcentage

d'augmentation:")
label_pourcentage.grid(row=1, column=0)
entry_pourcentage = [Link](frame_modification)
entry_pourcentage.grid(row=1, column=1)

btn_augmenter = [Link](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()

[Link]()

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.
 F A B O L | 33

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

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 = [Link]('ma_base_de_donnees.db')

# Création d'une table

cursor = [Link]()
[Link]('''CREATE TABLE utilisateurs (id INTEGER PRIMARY KEY,
nom TEXT, age INTEGER)''')

# Insertion de données
[Link]("INSERT INTO utilisateurs (nom, age) VALUES ('Alice', 30)")
[Link]("INSERT INTO utilisateurs (nom, age) VALUES ('Bob', 25)")

# Sélection de données
[Link]("SELECT * FROM utilisateurs")
for row in [Link]():
print(row)

# Fermeture de la connexion
[Link]()

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 :
 F A B O L | 34

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 [Link]

connexion = [Link](
host="localhost",
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 = [Link]()
[Link]("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 :
[Link]("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 :
[Link]("SELECT * FROM utilisateurs")
resultats = [Link]()
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 :
 F A B O L | 35

[Link]("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 :
[Link]("DELETE FROM utilisateurs WHERE nom = %s",
("Alice",))

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 :
[Link]()

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 [Link]

# Connexion à la base de données

connexion = [Link](
host="localhost",
user="utilisateur",
password="mot_de_passe",
database="gestion_ventes"
)

# Fonction pour ajouter un produit

def ajouter_produit(reference, nom, prix):
 F A B O L | 36

curseur = [Link]()
[Link]("INSERT INTO produits (reference, nom, prix) VALUES
(%s, %s, %s)", (reference, nom, prix))
[Link]()
print("Produit ajouté avec succès !")

# Fonction pour modifier un produit

def modifier_produit(reference, nouveau_nom, nouveau_prix):
curseur = [Link]()
[Link]("UPDATE produits SET nom = %s, prix = %s WHERE
reference = %s", (nouveau_nom, nouveau_prix, reference))
[Link]()
print("Produit modifié avec succès !")

# Fonction pour supprimer un produit

def supprimer_produit(reference):
curseur = [Link]()
[Link]("DELETE FROM produits WHERE reference = %s",
(reference,))
[Link]()
print("Produit supprimé avec succès !")

# Fonction pour afficher tous les produits

def afficher_produits():
curseur = [Link]()
[Link]("SELECT * FROM produits")
resultats = [Link]()
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
[Link]()

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
 F A B O L | 37

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 [Link]
from tkinter import *
from tkinter import messagebox

# Connexion à la base de données

connexion = [Link](
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 = [Link]()
[Link]("INSERT INTO produits (reference, nom, prix) VALUES
(%s, %s, %s)", (reference, nom, prix))
[Link]()
[Link]("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 = [Link]()
[Link]("UPDATE produits SET nom = %s, prix = %s WHERE
reference = %s", (nouveau_nom, nouveau_prix, reference))
[Link]()
 F A B O L | 38

[Link]("Succès", "Produit modifié avec succès !")

afficher_produits()

# Fonction pour supprimer un produit

def supprimer_produit():
reference = entry_reference.get()
curseur = [Link]()
[Link]("DELETE FROM produits WHERE reference = %s",
(reference,))
[Link]()
[Link]("Succès", "Produit supprimé avec succès !")
afficher_produits()

# Fonction pour afficher tous les produits

def afficher_produits():
curseur = [Link]()
[Link]("SELECT * FROM produits")
resultats = [Link]()
for i in tree.get_children():
[Link](i)
for resultat in resultats:
[Link]('', 'end', values=resultat)

# Création de l'interface graphique

root = Tk()
[Link]("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)
 F A B O L | 39

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)
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 = [Link](frame_resultats, columns=('Référence', 'Nom', 'Prix'),

show='headings')
[Link]('Référence', text='Référence')
[Link]('Nom', text='Nom')
[Link]('Prix', text='Prix')
[Link]()

afficher_produits()

[Link]()

# Fermeture de la connexion
[Link]()

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
 F A B O L | 40

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 [Link]
from tkinter import *
from tkinter import ttk, messagebox

# Connexion à la base de données

connexion = [Link](
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 = [Link]()
[Link]("INSERT INTO ventes (produit, quantite, prix_total)
VALUES (%s, %s, %s)", (produit, quantite, prix_total))
[Link]()
[Link]("Succès", "Vente ajoutée avec succès !")
afficher_ventes()

# Fonction pour supprimer une vente

def supprimer_vente():
selection = [Link]()
if selection:
id_vente = [Link](selection[0], "values")[0]
curseur = [Link]()
[Link]("DELETE FROM ventes WHERE id = %s", (id_vente,))
[Link]()
[Link]("Succès", "Vente supprimée avec succès !")
afficher_ventes()
else:
 F A B O L | 41

[Link]("Avertissement", "Veuillez sélectionner une

vente à supprimer.")

# Fonction pour afficher toutes les ventes

def afficher_ventes():
curseur = [Link]()
[Link]("SELECT * FROM ventes")
resultats = [Link]()
for i in tree.get_children():
[Link](i)
for resultat in resultats:
[Link]('', 'end', values=resultat)

# 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()
[Link]("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 = [Link](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)
 F A B O L | 42

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 = [Link](frame_ventes, columns=('ID', 'Produit', 'Quantité', 'Prix

total'), show='headings')
[Link]('ID', text='ID')
[Link]('Produit', text='Produit')
[Link]('Quantité', text='Quantité')
[Link]('Prix total', text='Prix total')
[Link]()

afficher_ventes()

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

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

[Link]()

# Fermeture de la connexion
[Link]()

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
 F A B O L | 43

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 = [Link]("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}
collection.insert_one(employe)
print("Employé ajouté avec succès !")

# Fonction pour lire tous les employés

def lire_employes():
for employe in [Link]():
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)
 F A B O L | 44

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

[Link]()

Dans cet exemple :

- 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.

EXERCICES SUR LES BASES DE DONNEES

1. Pour créer une application Python avec une interface graphique utilisant
Tkinter et intégrant une base de données SQLite, nous devons suivre plusieurs
étapes pour inclure les fonctionnalités d'enregistrement, modification,
suppression, affichage et recherche d'informations.

Voici un exemple complet d'une telle application :

import sqlite3
import tkinter as tk
from tkinter import messagebox, simpledialog
from tkinter import ttk # Ajout de cette ligne pour importer ttk
 F A B O L | 45

# Fonction pour créer une connexion à la base de données et initialiser la table

def init_db():
connexion = [Link]('ma_base_de_donnees.db')
cursor = [Link]()
[Link]('''CREATE TABLE IF NOT EXISTS utilisateurs (id
INTEGER PRIMARY KEY, nom TEXT, age INTEGER)''')
[Link]()
[Link]()

# Fonction pour insérer un utilisateur dans la base de données

def ajouter_utilisateur(nom, age):
connexion = [Link]('ma_base_de_donnees.db')
cursor = [Link]()
[Link]("INSERT INTO utilisateurs (nom, age) VALUES (?, ?)",
(nom, age))
[Link]()
[Link]()
afficher_utilisateurs()

# Fonction pour mettre à jour un utilisateur dans la base de données

def modifier_utilisateur(id, nom, age):
connexion = [Link]('ma_base_de_donnees.db')
cursor = [Link]()
[Link]("UPDATE utilisateurs SET nom = ?, age = ? WHERE id = ?",
(nom, age, id))
[Link]()
[Link]()
afficher_utilisateurs()

# Fonction pour supprimer un utilisateur de la base de données

def supprimer_utilisateur(id):
connexion = [Link]('ma_base_de_donnees.db')
cursor = [Link]()
[Link]("DELETE FROM utilisateurs WHERE id = ?", (id,))
[Link]()
[Link]()
afficher_utilisateurs()

# Fonction pour afficher les utilisateurs dans la liste

def afficher_utilisateurs():
for item in listbox.get_children():
[Link](item)
connexion = [Link]('ma_base_de_donnees.db')
 F A B O L | 46

cursor = [Link]()
[Link]("SELECT * FROM utilisateurs")
for row in [Link]():
[Link]('', 'end', values=row)
[Link]()

# Fonction pour rechercher un utilisateur par nom

def rechercher_utilisateur(nom):
for item in listbox.get_children():
[Link](item)
connexion = [Link]('ma_base_de_donnees.db')
cursor = [Link]()
[Link]("SELECT * FROM utilisateurs WHERE nom LIKE ?", ('%' +
nom + '%',))
for row in [Link]():
[Link]('', 'end', values=row)
[Link]()

# Initialisation de la base de données

init_db()

# Création de l'interface graphique

root = [Link]()
[Link]("Gestion des Utilisateurs")

# Création des widgets

frame = [Link](root)
[Link](pady=20)

label_nom = [Link](frame, text="Nom:")

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

entry_nom = [Link](frame)
entry_nom.grid(row=0, column=1, padx=10, pady=5)

label_age = [Link](frame, text="Âge:")

label_age.grid(row=1, column=0, padx=10, pady=5)

entry_age = [Link](frame)
entry_age.grid(row=1, column=1, padx=10, pady=5)

button_ajouter = [Link](frame, text="Ajouter", command=lambda:

ajouter_utilisateur(entry_nom.get(), entry_age.get()))
 F A B O L | 47

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

button_modifier = [Link](frame, text="Modifier", command=lambda:

modifier_utilisateur([Link]("ID", "Entrer l'ID:"),
entry_nom.get(), entry_age.get()))
button_modifier.grid(row=3, column=0, columnspan=2, pady=10)

button_supprimer = [Link](frame, text="Supprimer", command=lambda:

supprimer_utilisateur([Link]("ID", "Entrer l'ID:")))
button_supprimer.grid(row=4, column=0, columnspan=2, pady=10)

button_rechercher = [Link](frame, text="Rechercher", command=lambda:

rechercher_utilisateur(entry_nom.get()))
button_rechercher.grid(row=5, column=0, columnspan=2, pady=10)

button_afficher = [Link](frame, text="Afficher Tous",

command=afficher_utilisateurs)
button_afficher.grid(row=6, column=0, columnspan=2, pady=10)

# Création de la liste pour afficher les utilisateurs

listbox = [Link](root, columns=("ID", "Nom", "Âge"), show="headings")
[Link]("ID", text="ID")
[Link]("Nom", text="Nom")
[Link]("Âge", text="Âge")
[Link](pady=20)

# Affichage initial des utilisateurs

afficher_utilisateurs()

# Lancement de l'application
[Link]()

Vous devriez maintenant pouvoir exécuter votre application Tkinter sans

problème.

2. Pour créer une application de gestion des achats avec une interface graphique
sous Tkinter et une base de données SQLite qui permet d'enregistrer, modifier,
supprimer, afficher et rechercher des informations, nous pouvons étendre le code
existant. Voici comment le faire :

1. Initialiser la base de données SQLite.

2. Ajouter des fonctionnalités pour insérer, modifier, supprimer et afficher les
achats.
 F A B O L | 48

3. Mettre à jour l'interface pour intégrer ces fonctionnalités.

Voici le code complet :

import sqlite3
import tkinter as tk
from tkinter import messagebox, simpledialog
from tkinter import ttk

class GestionAchatsApp:
def __init__(self, root):
[Link] = root
[Link]("1000x600")
[Link]("Gestion des Achats")

self.init_db()

# Label et Entry pour le nom du produit

self.label_nom = [Link](root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = [Link](root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = [Link](root, text="Quantité")
self.label_quantite.place(x=20, y=60)
self.entry_quantite = [Link](root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

self.label_prix = [Link](root, text="Prix unitaire HT")
self.label_prix.place(x=20, y=100)
self.entry_prix = [Link](root)
self.entry_prix.place(x=150, y=100)

# Boutons pour les actions

self.bouton_ajouter = [Link](root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=20, y=140)

self.bouton_modifier = [Link](root, text="Modifier",

command=self.modifier_achat)
 F A B O L | 49

self.bouton_modifier.place(x=100, y=140)

self.bouton_supprimer = [Link](root, text="Supprimer",

command=self.supprimer_achat)
self.bouton_supprimer.place(x=180, y=140)

self.bouton_afficher = [Link](root, text="Afficher",

command=self.afficher_achats)
self.bouton_afficher.place(x=260, y=140)

self.bouton_rechercher = [Link](root, text="Rechercher",

command=self.rechercher_achat)
self.bouton_rechercher.place(x=340, y=140)

# Zone d'affichage pour la liste des achats

self.liste_achats = [Link](root, columns=("ID", "Nom", "Quantité",
"Prix", "Total HT"), show="headings")
self.liste_achats.heading("ID", text="ID")
self.liste_achats.heading("Nom", text="Nom")
self.liste_achats.heading("Quantité", text="Quantité")
self.liste_achats.heading("Prix", text="Prix unitaire HT")
self.liste_achats.heading("Total HT", text="Total HT")
self.liste_achats.place(x=20, y=180, width=950, height=300)

# Labels pour PTHT, TVA et PTTC

self.label_ptht = [Link](root, text="PTHT: 0.00")
self.label_ptht.place(x=20, y=500)

self.label_tva = [Link](root, text="TVA (16%): 0.00")

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

self.label_pttc = [Link](root, text="PTTC: 0.00")

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

# Totals
[Link] = 0.0

def init_db(self):
[Link] = [Link]('[Link]')
[Link] = [Link]()
[Link]('''
CREATE TABLE IF NOT EXISTS achats (
id INTEGER PRIMARY KEY AUTOINCREMENT,
 F A B O L | 50

nom TEXT NOT NULL,

quantite INTEGER NOT NULL,
prix REAL NOT NULL
)
''')
[Link]()

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)
[Link]("INSERT INTO achats (nom, quantite, prix)
VALUES (?, ?, ?)", (nom, quantite, prix))
[Link]()
[Link]("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, [Link])
self.entry_quantite.delete(0, [Link])
self.entry_prix.delete(0, [Link])
self.afficher_achats()
except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs valides
pour la quantité et le prix.")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

def modifier_achat(self):
id_achat = [Link]("ID", "Entrer l'ID de l'achat à
modifier:")
if id_achat:
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)
[Link]("UPDATE achats SET nom = ?, quantite = ?,
 F A B O L | 51

prix = ? WHERE id = ?",

(nom, quantite, prix, id_achat))
[Link]()
[Link]("Succès", "Achat modifié avec succès!")
self.afficher_achats()
except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs
valides pour la quantité et le prix.")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

def supprimer_achat(self):
id_achat = [Link]("ID", "Entrer l'ID de l'achat à
supprimer:")
if id_achat:
[Link]("DELETE FROM achats WHERE id = ?",
(id_achat,))
[Link]()
[Link]("Succès", "Achat supprimé avec succès!")
self.afficher_achats()

def afficher_achats(self):
for item in self.liste_achats.get_children():
self.liste_achats.delete(item)
[Link]("SELECT * FROM achats")
for row in [Link]():
total_ht = row[2] * row[3]
self.liste_achats.insert('', 'end', values=(row[0], row[1], row[2], row[3],
total_ht))
self.mettre_a_jour_totaux()

def rechercher_achat(self):
nom = [Link]("Rechercher", "Entrer le nom du produit à
rechercher:")
if nom:
for item in self.liste_achats.get_children():
self.liste_achats.delete(item)
[Link]("SELECT * FROM achats WHERE nom LIKE ?",
('%' + nom + '%',))
for row in [Link]():
total_ht = row[2] * row[3]
self.liste_achats.insert('', 'end', values=(row[0], row[1], row[2],
 F A B O L | 52

row[3], total_ht))
self.mettre_a_jour_totaux()

def mettre_a_jour_totaux(self):
[Link]("SELECT SUM(quantite * prix) FROM achats")
[Link] = [Link]()[0] or 0.0
tva = [Link] * 0.16
pttc = [Link] + tva

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

def on_closing(self):
[Link]()
[Link]()

if __name__ == "__main__":
root = [Link]()
app = GestionAchatsApp(root)
[Link]("WM_DELETE_WINDOW", app.on_closing)
[Link]()

Ce script ajoute les fonctionnalités suivantes :

1. Connexion à la base de données SQLite : Lors de l'initialisation, il crée la

base de données et la table des achats si elles n'existent pas déjà.
2. Ajout d'achats : Un bouton permet d'ajouter un nouvel achat.
3. Modification d'achats : Un bouton permet de modifier un achat existant en
fournissant l'ID de l'achat à modifier.
4. Suppression d'achats : Un bouton permet de supprimer un achat existant en
fournissant l'ID de l'achat à supprimer.
5. Affichage des achats : Un bouton permet d'afficher tous les achats dans une
zone de texte.
6. Recherche d'achats : Un bouton permet de rechercher des achats par nom de
produit.
7. Mise à jour des totaux : Le script met à jour les totaux (PTHT, TVA, PTTC)
après chaque modification de la liste des achats.

Tous les boutons sont sur une seule ligne pour faciliter l'accès.

MySQL :
 F A B O L | 53

Pour adapter l'application de gestion des achats à utiliser une base de données
MySQL au lieu de SQLite, nous devons modifier la partie du code qui initialise
et interagit avec la base de données. Voici comment procéder :

1. Installer le package `mysql-connector-python` pour interagir avec MySQL :

pip install mysql-connector-python

2. Adapter le code pour se connecter à une base de données MySQL, créer une
table si elle n'existe pas, et effectuer les opérations CRUD.

Voici le code mis à jour :

import [Link]
import tkinter as tk
from tkinter import messagebox, simpledialog
from tkinter import ttk

class GestionAchatsApp:
def __init__(self, root):
[Link] = root
[Link]("1000x600")
[Link]("Gestion des Achats")

self.init_db()

# Label et Entry pour le nom du produit

self.label_nom = [Link](root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = [Link](root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = [Link](root, text="Quantité")
self.label_quantite.place(x=20, y=60)
self.entry_quantite = [Link](root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

self.label_prix = [Link](root, text="Prix unitaire HT")
self.label_prix.place(x=20, y=100)
self.entry_prix = [Link](root)
 F A B O L | 54

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

# Boutons pour les actions

self.bouton_ajouter = [Link](root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=20, y=140)

self.bouton_modifier = [Link](root, text="Modifier",

command=self.modifier_achat)
self.bouton_modifier.place(x=100, y=140)

self.bouton_supprimer = [Link](root, text="Supprimer",

command=self.supprimer_achat)
self.bouton_supprimer.place(x=180, y=140)

self.bouton_afficher = [Link](root, text="Afficher",

command=self.afficher_achats)
self.bouton_afficher.place(x=260, y=140)

self.bouton_rechercher = [Link](root, text="Rechercher",

command=self.rechercher_achat)
self.bouton_rechercher.place(x=340, y=140)

# Zone d'affichage pour la liste des achats

self.liste_achats = [Link](root, columns=("ID", "Nom", "Quantité",
"Prix", "Total HT"), show="headings")
self.liste_achats.heading("ID", text="ID")
self.liste_achats.heading("Nom", text="Nom")
self.liste_achats.heading("Quantité", text="Quantité")
self.liste_achats.heading("Prix", text="Prix unitaire HT")
self.liste_achats.heading("Total HT", text="Total HT")
self.liste_achats.place(x=20, y=180, width=950, height=300)

# Labels pour PTHT, TVA et PTTC

self.label_ptht = [Link](root, text="PTHT: 0.00")
self.label_ptht.place(x=20, y=500)

self.label_tva = [Link](root, text="TVA (16%): 0.00")

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

self.label_pttc = [Link](root, text="PTTC: 0.00")

self.label_pttc.place(x=20, y=560)
 F A B O L | 55

# Totals
[Link] = 0.0

def init_db(self):
[Link] = [Link](
host="localhost",
user="root", # Remplacez par votre nom d'utilisateur MySQL
password="", # Remplacez par votre mot de passe MySQL
database="gestion_achats" # Remplacez par le nom de votre base de
données
)
[Link] = [Link]()
[Link]('''
CREATE TABLE IF NOT EXISTS achats (
id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(255) NOT NULL,
quantite INT NOT NULL,
prix FLOAT NOT NULL
)
''')
[Link]()

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)
[Link]("INSERT INTO achats (nom, quantite, prix)
VALUES (%s, %s, %s)", (nom, quantite, prix))
[Link]()
[Link]("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, [Link])
self.entry_quantite.delete(0, [Link])
self.entry_prix.delete(0, [Link])
self.afficher_achats()
except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs valides
pour la quantité et le prix.")
else:
 F A B O L | 56

[Link]("Erreur", "Tous les champs doivent être

remplis.")

def modifier_achat(self):
id_achat = [Link]("ID", "Entrer l'ID de l'achat à
modifier:")
if id_achat:
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)
[Link]("UPDATE achats SET nom = %s, quantite =
%s, prix = %s WHERE id = %s",
(nom, quantite, prix, id_achat))
[Link]()
[Link]("Succès", "Achat modifié avec succès!")
self.afficher_achats()
except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs
valides pour la quantité et le prix.")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

def supprimer_achat(self):
id_achat = [Link]("ID", "Entrer l'ID de l'achat à
supprimer:")
if id_achat:
[Link]("DELETE FROM achats WHERE id = %s",
(id_achat,))
[Link]()
[Link]("Succès", "Achat supprimé avec succès!")
self.afficher_achats()

def afficher_achats(self):
for item in self.liste_achats.get_children():
self.liste_achats.delete(item)
[Link]("SELECT * FROM achats")
for row in [Link]():
total_ht = row[2] * row[3]
 F A B O L | 57

self.liste_achats.insert('', 'end', values=(row[0], row[1], row[2], row[3],

total_ht))
self.mettre_a_jour_totaux()

def rechercher_achat(self):
nom = [Link]("Rechercher", "Entrer le nom du produit à
rechercher:")
if nom:
for item in self.liste_achats.get_children():
self.liste_achats.delete(item)
[Link]("SELECT * FROM achats WHERE nom LIKE %s",
('%' + nom + '%',))
for row in [Link]():
total_ht = row[2] * row[3]
self.liste_achats.insert('', 'end', values=(row[0], row[1], row[2],
row[3], total_ht))
self.mettre_a_jour_totaux()

def mettre_a_jour_totaux(self):
[Link]("SELECT SUM(quantite * prix) FROM achats")
[Link] = [Link]()[0] or 0.0
tva = [Link] * 0.16
pttc = [Link] + tva

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

def on_closing(self):
[Link]()
[Link]()

if __name__ == "__main__":
root = [Link]()
app = GestionAchatsApp(root)
[Link]("WM_DELETE_WINDOW", app.on_closing)
[Link]()

Points clés de la modification :

1. Connexion MySQL :
- Utilisation de `[Link]` pour se connecter à la base de
données MySQL.
 F A B O L | 58

- Mise à jour des méthodes de requêtes pour utiliser les placeholders `%s` au
lieu de `?`.

2. Structure de la base de données :

- Adaptation des types de données pour MySQL (`VARCHAR` pour les
chaînes de caractères, `FLOAT` pour les décimales, etc.).

3. Gestion des exceptions et des messages d'erreur :

- Utilisation de `try-except` pour gérer les conversions de types et les erreurs
de requêtes.

4. Méthode `on_closing` :
- Fermeture propre de la connexion à la base de données lors de la fermeture
de l'application.

Assurez-vous de remplacer les informations de connexion (utilisateur, mot de

passe, et nom de la base de données) avec les vôtres. Vous pouvez aussi créer la
base de données `gestion_achats` dans MySQL si elle n'existe pas déjà.

Les erreurs

L'erreur `getaddrinfo failed` indique que le client `pip` n'a pas réussi à résoudre
le nom de domaine pour accéder au dépôt de paquets Python. Cela peut être dû à
plusieurs raisons, comme des problèmes de réseau, des paramètres de proxy
incorrects ou des restrictions de pare-feu. Voici quelques solutions pour
résoudre ce problème :

1. Vérifier la connexion Internet

Assurez-vous que vous avez une connexion Internet active et que vous pouvez
accéder à d'autres sites Web. Essayez de visiter le site
[[Link]]([Link] dans votre navigateur pour vérifier si le site est
accessible.

2. Configurer le proxy (si nécessaire)

Si vous êtes derrière un proxy, vous devez configurer `pip` pour utiliser le
proxy. Vous pouvez le faire en définissant les variables d'environnement
`HTTP_PROXY` et `HTTPS_PROXY`, ou en utilisant les options de ligne de
commande `--proxy`.

Par exemple :

pip install --proxy [Link] mysql-

connector-python
 F A B O L | 59

3. Utiliser un miroir alternatif

Parfois, le problème peut être résolu en utilisant un miroir alternatif pour `pip`.

pip install --index-url=[Link] mysql-connector-python

4. Mettre à jour `pip`

Il se peut que votre version de `pip` soit obsolète et cause des problèmes de
compatibilité. Mettez à jour `pip` à la dernière version.

python -m pip install --upgrade pip

5. Utiliser `pip` via HTTP au lieu de HTTPS

Cela peut parfois contourner les problèmes de résolution de DNS.

pip install mysql-connector-python --trusted-host [Link] --trusted-host

[Link]

6. Résoudre les problèmes DNS

Parfois, le problème est lié aux paramètres DNS de votre système. Vous pouvez
essayer de configurer des serveurs DNS alternatifs comme ceux de Google
([Link] et [Link]) ou de Cloudflare ([Link]).

7. Utiliser une version spécifique de `mysql-connector-python`

Parfois, spécifier une version spécifique peut aider à résoudre le problème.

pip install mysql-connector-python==8.0.23

8. Vérifier les paramètres de pare-feu

Assurez-vous que votre pare-feu ou logiciel de sécurité ne bloque pas `pip`
d'accéder à Internet. Vous pouvez essayer de désactiver temporairement votre
pare-feu pour voir si cela résout le problème.

Exemple de commande combinée

python -m pip install --upgrade pip

pip install --index-url=[Link] --trusted-host [Link] --
trusted-host [Link] mysql-connector-python

Essayez ces étapes et voyez si l'une d'elles résout le problème. Si aucune de ces
solutions ne fonctionne, il pourrait être utile de vérifier vos paramètres réseau ou
de contacter votre administrateur réseau pour obtenir de l'aide.
 F A B O L | 60

MongoDB

Pour adapter l'application de gestion des achats pour qu'elle utilise MongoDB au
lieu de SQLite, nous allons utiliser la bibliothèque `pymongo`. Voici comment
vous pouvez adapter le code existant :

Étapes à suivre :

1. Installer la bibliothèque `pymongo` :

pip install pymongo

2. Mettre à jour l'application pour utiliser MongoDB.

Code mis à jour :

import tkinter as tk
from tkinter import messagebox, simpledialog
from tkinter import ttk
from pymongo import MongoClient
from [Link] import ObjectId

class GestionAchatsApp:
def __init__(self, root):
[Link] = root
[Link]("1000x600")
[Link]("Gestion des Achats")

self.init_db()

# Label et Entry pour le nom du produit

self.label_nom = [Link](root, text="Nom du produit")
self.label_nom.place(x=20, y=20)
self.entry_nom = [Link](root)
self.entry_nom.place(x=150, y=20)

# Label et Entry pour la quantité

self.label_quantite = [Link](root, text="Quantité")
self.label_quantite.place(x=20, y=60)
self.entry_quantite = [Link](root)
self.entry_quantite.place(x=150, y=60)

# Label et Entry pour le prix

 F A B O L | 61

self.label_prix = [Link](root, text="Prix unitaire HT")

self.label_prix.place(x=20, y=100)
self.entry_prix = [Link](root)
self.entry_prix.place(x=150, y=100)

# Boutons pour les actions

self.bouton_ajouter = [Link](root, text="Ajouter",
command=self.ajouter_achat)
self.bouton_ajouter.place(x=20, y=140)

self.bouton_modifier = [Link](root, text="Modifier",

command=self.modifier_achat)
self.bouton_modifier.place(x=100, y=140)

self.bouton_supprimer = [Link](root, text="Supprimer",

command=self.supprimer_achat)
self.bouton_supprimer.place(x=180, y=140)

self.bouton_afficher = [Link](root, text="Afficher",

command=self.afficher_achats)
self.bouton_afficher.place(x=260, y=140)

self.bouton_rechercher = [Link](root, text="Rechercher",

command=self.rechercher_achat)
self.bouton_rechercher.place(x=340, y=140)

# Zone d'affichage pour la liste des achats

self.liste_achats = [Link](root, columns=("ID", "Nom", "Quantité",
"Prix", "Total HT"), show="headings")
self.liste_achats.heading("ID", text="ID")
self.liste_achats.heading("Nom", text="Nom")
self.liste_achats.heading("Quantité", text="Quantité")
self.liste_achats.heading("Prix", text="Prix unitaire HT")
self.liste_achats.heading("Total HT", text="Total HT")
self.liste_achats.place(x=20, y=180, width=950, height=300)

# Labels pour PTHT, TVA et PTTC

self.label_ptht = [Link](root, text="PTHT: 0.00")
self.label_ptht.place(x=20, y=500)

self.label_tva = [Link](root, text="TVA (16%): 0.00")

self.label_tva.place(x=20, y=530)
 F A B O L | 62

self.label_pttc = [Link](root, text="PTTC: 0.00")

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

# Totals
[Link] = 0.0

def init_db(self):
[Link] = MongoClient('mongodb://localhost:27017/')
[Link] = [Link]['gestion_achats']
[Link] = [Link]['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)
[Link].insert_one({"nom": nom, "quantite": quantite, "prix":
prix})
[Link]("Succès", "Achat ajouté avec succès!")
self.entry_nom.delete(0, [Link])
self.entry_quantite.delete(0, [Link])
self.entry_prix.delete(0, [Link])
self.afficher_achats()
except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs valides
pour la quantité et le prix.")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

def modifier_achat(self):
id_achat = [Link]("ID", "Entrer l'ID de l'achat à modifier:")
if id_achat:
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)
 F A B O L | 63

prix = float(prix)
[Link].update_one({"_id": ObjectId(id_achat)}, {"$set":
{"nom": nom, "quantite": quantite, "prix": prix}})
[Link]("Succès", "Achat modifié avec succès!")
self.afficher_achats()
except ValueError:
[Link]("Erreur", "Veuillez entrer des valeurs
valides pour la quantité et le prix.")
except Exception as e:
[Link]("Erreur", f"Erreur lors de la modification:
{str(e)}")
else:
[Link]("Erreur", "Tous les champs doivent être
remplis.")

def supprimer_achat(self):
id_achat = [Link]("ID", "Entrer l'ID de l'achat à
supprimer:")
if id_achat:
try:
[Link].delete_one({"_id": ObjectId(id_achat)})
[Link]("Succès", "Achat supprimé avec succès!")
self.afficher_achats()
except Exception as e:
[Link]("Erreur", f"Erreur lors de la suppression:
{str(e)}")

def afficher_achats(self):
for item in self.liste_achats.get_children():
self.liste_achats.delete(item)
achats = [Link]()
for achat in achats:
total_ht = achat['quantite'] * achat['prix']
self.liste_achats.insert('', 'end', values=(achat['_id'], achat['nom'],
achat['quantite'], achat['prix'], total_ht))
self.mettre_a_jour_totaux()

def rechercher_achat(self):
nom = [Link]("Rechercher", "Entrer le nom du produit à
rechercher:")
if nom:
for item in self.liste_achats.get_children():
self.liste_achats.delete(item)
 F A B O L | 64

achats = [Link]({"nom": {"$regex": nom, "$options": "i"}})

for achat in achats:
total_ht = achat['quantite'] * achat['prix']
self.liste_achats.insert('', 'end', values=(achat['_id'], achat['nom'],
achat['quantite'], achat['prix'], total_ht))
self.mettre_a_jour_totaux()

def mettre_a_jour_totaux(self):
ptht = sum(achat['quantite'] * achat['prix'] for achat in [Link]())
[Link] = ptht or 0.0
tva = [Link] * 0.16
pttc = [Link] + tva

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

def on_closing(self):
[Link]()
[Link]()

if __name__ == "__main__":
root = [Link]()
app = GestionAchatsApp(root)
[Link]("WM_DELETE_WINDOW", app.on_closing)
[Link]()

Explications :
1. Connexion à MongoDB :
- `MongoClient` se connecte à MongoDB.
- `db` et `collection` sont définis pour accéder à la base de données et à la
collection spécifiques.

2. Ajout d'un achat :

- Utilisation de `insert_one` pour ajouter un document.

3. Modification d'un achat :

- Utilisation de `update_one` pour mettre à jour un document par son ID.

4. Suppression d'un achat :

- Utilisation de `delete_one` pour supprimer un document par son ID.

5. Affichage des achats :

 F A B O L | 65

- Utilisation de `find` pour récupérer tous les documents et les afficher dans la
`Treeview`.

6. Recherche d'un achat :

- Utilisation de l'opérateur `$regex` pour rechercher des documents dont le
nom correspond à la chaîne de recherche.

7. Calcul des totaux :

- Somme des prix pour les totaux HT, TVA et TTC.

Avec ces modifications, votre application utilisera MongoDB pour gérer les
achats. Assurez-vous d'avoir un serveur MongoDB en cours d'exécution et
accessible pour que l'application puisse se connecter correctement.

Erreurs

L'erreur `ModuleNotFoundError: No module named 'pymongo'` signifie que la

bibliothèque `pymongo` n'est pas installée dans l'environnement virtuel que vous
utilisez pour votre projet. Pour résoudre cette erreur, vous devez installer
`pymongo` dans votre environnement virtuel.

Voici les étapes à suivre :

Étape 1 : Activer l'environnement virtuel

Assurez-vous que l'environnement virtuel est activé. Vous pouvez l'activer avec
la commande suivante dans votre terminal ou votre invite de commande :

Pour Windows :

venv\Scripts\activate

Pour macOS et Linux :

source venv/bin/activate

Étape 2 : Installer pymongo

Une fois l'environnement virtuel activé, installez `pymongo` avec pip :

pip install pymongo

Étape 3 : Vérifier l'installation

 F A B O L | 66

Pour vérifier que `pymongo` est bien installé, vous pouvez lister les packages
installés dans l'environnement virtuel :

pip list

Vous devriez voir `pymongo` dans la liste des packages installés.

Étape 4 : Exécuter votre script

Après avoir installé `pymongo`, essayez de nouveau d'exécuter votre script

Python :

python C:/Users/Fabol/PycharmProjects/GestionAchatsApp/[Link]

Exemple complet dans le terminal

Voici un exemple complet de la procédure à suivre dans votre terminal ou invite

de commande :

cd C:/Users/Fabol/PycharmProjects/GestionAchatsApp
venv\Scripts\activate
pip install pymongo
python [Link]

Assurer que pymongo est installé dans l'environnement virtuel

Si vous avez plusieurs environnements virtuels ou si vous avez installé

`pymongo` dans le système global par erreur, assurez-vous que vous travaillez
bien dans le bon environnement virtuel. Vous pouvez réinstaller `pymongo`
dans l'environnement global puis dans le virtuel pour être sûr :

pip uninstall pymongo

venv\Scripts\activate
pip install pymongo

Vérification dans PyCharm

Si vous utilisez PyCharm, assurez-vous que l'environnement virtuel est bien

configuré pour votre projet :

1. Ouvrez les paramètres du projet dans PyCharm : `File > Settings` (ou
`Ctrl+Alt+S`).
 F A B O L | 67

2. Allez à `Project: GestionAchatsApp > Python Interpreter`.

3. Assurez-vous que l'interpréteur Python de votre environnement virtuel est
sélectionné.
4. Si nécessaire, utilisez le bouton `+` pour ajouter `pymongo` directement
depuis PyCharm.

Avec ces étapes, vous devriez être capable de résoudre l'erreur

`ModuleNotFoundError` et d'exécuter votre script avec MongoDB.

Creation db

Pour créer une base de données MongoDB et une collection pour votre
application de gestion des achats, vous pouvez utiliser le shell MongoDB avec
les commandes suivantes. Ces commandes vont créer une base de données
nommée `gestion_achats` et une collection nommée `achats`.

Étape 1 : Démarrer MongoDB

Assurez-vous que le serveur MongoDB est en cours d'exécution. Vous pouvez

démarrer le serveur MongoDB à partir de la ligne de commande (ou terminal)
avec la commande suivante (selon votre installation) :

mongod

Étape 2 : Accéder au shell MongoDB

Ouvrez un nouveau terminal ou invite de commande et démarrez le shell

MongoDB avec la commande suivante :

mongo

Étape 3 : Créer la base de données et la collection

Une fois dans le shell MongoDB, exécutez les commandes suivantes pour créer
la base de données et la collection :

use gestion_achats // Basculer vers (ou créer) la base de données gestion_achats

[Link]("achats") // Créer la collection achats

Étape 4 : (Optionnel) Ajouter des documents de test

 F A B O L | 68

Vous pouvez ajouter quelques documents de test dans la collection `achats` pour
vérifier que tout fonctionne correctement :

[Link]([
{ nom: "Produit A", quantite: 10, prix: 15.0 },
{ nom: "Produit B", quantite: 5, prix: 20.0 },
{ nom: "Produit C", quantite: 8, prix: 7.5 }
])

Résumé des commandes MongoDB

Voici un récapitulatif des commandes que vous devez exécuter dans le shell
MongoDB :

use gestion_achats

[Link]("achats")

[Link]([
{ nom: "Produit A", quantite: 10, prix: 15.0 },
{ nom: "Produit B", quantite: 5, prix: 20.0 },
{ nom: "Produit C", quantite: 8, prix: 7.5 }
])

Vérification

Pour vérifier que la base de données et la collection ont été créées correctement,
vous pouvez exécuter les commandes suivantes :

show dbs // Afficher toutes les bases de données

use gestion_achats // Basculer vers la base de données gestion_achats
show collections // Afficher toutes les collections dans la base de données
gestion_achats

[Link]() // Afficher tous les documents dans la collection achats

En suivant ces étapes, vous aurez créé la base de données et la collection

nécessaires pour votre application. Vous pourrez ensuite exécuter votre script
Python pour interagir avec MongoDB en utilisant `pymongo`.

Conclusion
 F A B O L | 69

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.

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
 F A B O L | 70

les compétences et la confiance nécessaires pour créer des applications de

bureau professionnelles et fonctionnelles dans un environnement Python.