08 JUILLET 2025

METHODE APPLIQUEE DE PROGRAMMATION SUR PYTHON

INFORMATIQUE

MARC OMALOSOMBE
Business Academy
 Python 1

« Python est un langage de programmation puissant, simple et flexible, conçu

pour maximiser la productivité des développeurs. Il favorise un style de
programmation lisible et maintenable, ce qui le rend idéal pour les projets de
toutes tailles. »
> — Mark Lutz, Learning Python, O’Reilly Media, 5e édition, 2013
Python est un langage interprété à haut niveau, connu pour sa syntaxe claire et
sa structure modulaire. Il permet un développement rapide d'applications grâce
à une vaste bibliothèque standard et une communauté active. Il est utilisé dans
de nombreux domaines comme le web, les scripts système, l’intelligence
artificielle, la science des données et plus encore.
 Python 2

TABLE DES MATIERES

0. INTRODUCTION ......................................................................................................................... 4
0.1. HISTOIRE DE PYTHON .......................................................................................................... 4
0.2. INSTALLATION ................................................................................................................... 4
0.2.1. PYTHON 3 ..................................................................................................................... 4
0.2.1. PYCHARM ..................................................................................................................... 5
CHAPITRE 01. SYNTAXE DE BASE ............................................................................................... 7
1.1. VARIABLES, TYPES (INT, FLOAT, STR, BOOL) .................................................... 7
1.1.1. DEFINITION ................................................................................................................. 7
1.1.2. TYPES DE DONNEES DE BASE EN PYTHON ................................................. 7
1.1.3. CONNAITRE LE TYPE D’UNE VARIABLE ............................................................... 8
1.1.4. Conversion de types (casting) .................................................................................... 9
CHAPITRE 02. STRUCTURES DE CONTROLE ........................................................................ 12
2.1. LES STRUCTURES CONDITIONNELLES ....................................................................... 12
2.2. LES STRUCTURES DE BOUCLE ....................................................................................... 12
2.3. LES INSTRUCTIONS DE CONTROLE DE BOUCLE ................................................... 13
CHAPITRE 03. STRUCTURES DE DONNEES ........................................................................... 17
3.1. PRINCIPALES STRUCTURES DE DONNEES ............................................................... 17
3.2. METHODES DE MANIPULATION ..................................................................................... 20
CHAPITRE 04. LES FONCTIONS ................................................................................................... 26
PROJET DE CREATION D’UN CONVERTISSEUR DE TEMPERATURE.......................... 30
PROJET DE CREATION D’UNE CALCULATRICE SIMPLE .................................................. 31
CHAPITRE 05. INTRODUCTION SUR TKINTER ..................................................................... 33
1. DEFINITION : ............................................................................................................................... 33
2. PRINCIPAUX COMPOSANTS : ............................................................................................... 33
3. POSITIONNEMENT DES ELEMENTS : ............................................................................... 33
4. BOUCLE PRINCIPALE : ............................................................................................................ 33
5. ÉVENEMENTS ET COMMANDES :....................................................................................... 33
6. AVANTAGES :............................................................................................................................... 34
PROJET DE CREATION DE CALCULATRICE SUR TKINTER ............................................ 36
Python 3
 Python 4

0. INTRODUCTION

Python est l’un des langages les plus polyvalents et utilisés au monde. Ses
domaines d'application incluent :
 Développement web : avec Django, Flask
 Data science & analyse de données : avec Pandas, Numpy, Matplotlib,
Seaborn
 Intelligence artificielle & Machine Learning : avec Scikit-learn, TensorFlow,
PyTorch
 Automatisation & scripts : tâches répétitives, traitement de fichiers, bots
 Applications de bureau : avec Tkinter, PyQt
 Jeux vidéo : avec Pygame
Cyber sécurité : outils de scan, d’analyse, scripts pour pentesting.
0.1. HISTOIRE DE PYTHON

 Créateur : Guido van Rossum

 Date de création : Fin des années 1980, première version publique en 1991
 Origine du nom : Inspiré par le groupe comique britannique "Monty
Python", et non par le serpent.
 Objectif initial : Créer un langage simple, lisible et puissant, capable de
remplacer ABC tout en étant extensible.
Évolutions majeures :
 Python 2.x (1991-2010) : large adoption, mais quelques limites (ex.
gestion des chaînes, Unicode).
 Python 3.x (depuis 2008) : version actuelle, incompatible avec Python
2, mais plus moderne.
0.2. INSTALLATION

0.2.1. PYTHON 3

 Téléchargement

Va sur le site officiel : [https://www.python.org](https://www.python.org)

 Clique sur Downloads > sélectionne ta version selon ton système :
 Windows : Python 3.x.x Windows installer
 MacOS : Python 3.x.x macOS installer
 Linux : généralement préinstallé, sinon utiliser le terminal
 Python 5

 Installation sur Windows

 Ouvre le fichier téléchargé.
 Coche la case “Add Python 3.x to PATH”.
 Clique sur Install Now.
 À la fin, clique sur Close.
 Vérification
 Ouvre l’invite de commande (cmd).
 Tape :
python --version
ou
python3 --version

Tu verras la version installée s'afficher.

0.2.1. PYCHARM

PyCharm est un environnement de développement intégré (IDE) spécialement

conçu pour le langage Python, développé par JetBrains. Il est largement utilisé
par les développeurs, chercheurs, data scientists et étudiants pour écrire, tester,
déboguer et exécuter du code Python plus efficacement.
Caractéristiques principales :
 Complétion automatique du code
 Débogueur puissant intégré
 Gestion de projets Python
 Support des frameworks web (Django, Flask, etc.)
 Intégration avec Git, Docker, bases de données, etc.
 Interface intuitive et personnalisable

 Téléchargement : Va sur le site officiel de

JetBrains:[https://www.jetbrains.com/pycharm](https://www.jetbrains.
com/pycharm)/ Choisis Community Edition (gratuite) ou Professional
Edition (payante)/ Clique sur Download
 Installation :
 Ouvre le fichier téléchargé (.exe)
 Python 6

 Clique sur "Next"

 Choisis le dossier d’installation ou garde le chemin par défaut
 Clique "Next"
 Configuration (optionnelle) :
Coche :
 Créer un raccourci sur le bureau
 Ajouter à la variable PATH
 Associer .py à PyCharm (utile si tu veux ouvrir les fichiers Python
directement avec PyCharm)
- Clique "Next" puis "Install"
 Lancement :
 Une fois installé, clique sur "Run PyCharm"
 Accepte les conditions d'utilisation
 Choisis de ne pas importer les paramètres si c’est ta première
installation

 Premier projet :
 Clique sur "New Project"
 Choisis ou crée un environnement virtuel Python (PyCharm détecte
automatiquement les versions installées)
 Python 7

CHAPITRE 01. SYNTAXE DE BASE

1.1. VARIABLES, TYPES (INT, FLOAT, STR, BOOL)

La syntaxe de base en Python désigne l’ensemble des règles et conventions que

tout programmeur doit suivre pour écrire un code correct et compréhensible par
l’interpréteur Python. Elle inclut la structure des instructions, l’utilisation des
indentations, les mots-clés réservés, la manière de déclarer des variables,
d’écrire des conditions, des boucles, des fonctions, etc.

Exemples de règles de syntaxe de base :

 Indentation obligatoire (généralement 4 espaces) pour définir les
blocs de code.
 Pas besoin de point-virgule (;) à la fin d’une ligne.
 Variables dynamiques (pas besoin de préciser le type).
 Utilisation de # pour les commentaires.

1.1.1.DEFINITION

Une variable est un nom qui stocke une valeur. Elle permet de réutiliser cette
valeur plus tard dans le programme.
python
nom = "Marc"
age = 25

1.1.2.TYPES DE DONNEES DE BASE EN PYTHON

 int → Nombre entier

Exemples : 10, -3, 0

python
x = 10 # int
 Python 8

 float → Nombre à virgule flottante (décimal)

Exemples : 3.14, -0.5, 100.0

python
pi = 3.14 # float

 str → Chaîne de caractères (texte)

Exemples : "Bonjour", 'Python'

python
nom = "Jean" # str

 bool → Booléen (valeur logique)

Valeurs possibles : True ou False

python
actif = True # bool

1.1.3. CONNAITRE LE TYPE D’UNE VARIABLE

python
type(x) # Renvoie <class 'int'>
 Python 9

1.1.4. CONVERSION DE TYPES (CASTING)

python
int("5") # Donne 5 (int)
float("3.5") # Donne 3.5 (float)
str(100) # Donne "100" (str)
bool(0) # Donne False

Exemple complet :

python
nom = "Alice"
age = 30
taille = 1.70
est_etudiant = False

print("Nom :", nom)

print("Âge :", age)
print("Taille :", taille)
print("Étudiant :", est_etudiant)
 Python 10

EXERCICE : MANIPULATION DE VARIABLES EN PYTHON

Objectif : Déclarer des variables, identifier leur type, et les utiliser dans des
expressions.
Énoncé :
Déclare les variables suivantes :
1. Un entier nommé age contenant la valeur 21
2. Un flottant nommé taille contenant la valeur 1.75
3. Une chaîne de caractères nommée nom contenant ton prénom
4. Un booléen nommé est_etudiant indiquant si tu es étudiant ou pas
(True/False)
Ensuite :

 Affiche chaque variable avec son type (type())

 Crée une nouvelle variable presentation contenant une phrase comme :
"Je m'appelle Marc, j'ai 21 ans, je mesure 1.75 m et je suis étudiant : True"
 Affiche la variable presentation.
Corrigé :
```python
Déclaration des variables
age = 21 # int
taille = 1.75 # float
nom = "Marc" # str
est_etudiant = True # bool

Affichage des types

print(type(age)) # <class 'int'>
print(type(taille)) # <class 'float'>
print(type(nom)) # <class 'str'>
print(type(est_etudiant)) # <class 'bool'>
 Python 11

Phrase de présentation
presentation = f"Je m'appelle {nom}, j'ai {age} ans, je mesure {taille} m et je suis
étudiant : {est_etudiant}"
Affichage final
print(presentation)
 Python 12

CHAPITRE 02. STRUCTURES DE CONTROLE

Les structures de contrôle en Python sont des instructions qui permettent de

contrôler le déroulement du programme, c’est-à-dire décider quelle partie du
code sera exécutée, répétée ou ignorée, selon certaines conditions ou boucles.

2.1. LES STRUCTURES CONDITIONNELLES

a. if, elif, else

python
x = 10
if x > 0:
print("x est positif")
elif x == 0:
print("x est nul")
else:
print("x est négatif")

2.2. LES STRUCTURES DE BOUCLE

a. while
Utilisée tant qu’une condition est vraie.
python
i=0
while i < 5:
print(i)
i += 1
 Python 13

b. for
Utilisée pour parcourir une séquence (liste, chaîne, range…).
python
for i in range(5):
print(i)

2.3. LES INSTRUCTIONS DE CONTROLE DE BOUCLE

 break : interrompt la boucle.

 continue : passe à l’itération suivante.

python
for i in range(5):
if i == 3:
break
print(i)

python
for i in range(5):
if i == 2:
continue
print(i)
 Python 14

Exercice 1 : Condition simple

Demande à l'utilisateur son âge, puis affiche :
- "Mineur" si l’âge est < 18
- "Majeur" sinon

Exercice 2 : Nombre pair ou impair

Demande à l'utilisateur d'entrer un nombre entier.
Affiche s’il est pair ou impair.

Exercice 3 : Boucle for

Affiche tous les nombres de 1 à 10 et leur carré.

Exercice 4 : Boucle while

Demande un mot à l’utilisateur jusqu’à ce qu’il écrive "fin".

Exercice 5 : Somme des entiers

Écris un programme qui demande 5 nombres à l’utilisateur et affiche leur somme
à la fin.

RESOLUTIONS
Exercice 1 : Condition simple
python
age = int(input("Quel est ton âge ? "))
if age < 18:
print("Mineur")
else:
print("Majeur")
 Python 15

Exercice 2 : Pair ou impair

python
nombre = int(input("Entrez un nombre entier : "))
if nombre % 2 == 0:
print("Pair")
else:
print("Impair")

Exercice 3 : Boucle for

python
for i in range(1, 11):
print(f"{i} au carré = {i**2}")

Exercice 4 : Boucle while

python
mot = ""
while mot.lower() != "fin":
mot = input("Écris un mot (ou 'fin' pour arrêter) : ")

Exercice 5 : Somme de 5 nombres

python
somme = 0
for i in range(5):
 Python 16

nb = float(input(f"Entrez le nombre {i+1} : "))

somme += nb
print(f"La somme des 5 nombres est : {somme}")
 Python 17

CHAPITRE 03. STRUCTURES DE DONNEES

Les structures de données permettent de stocker, organiser et manipuler les

données efficacement.
3.1. PRINCIPALES STRUCTURES DE DONNEES

1. Listes (list)
- Ordonnées, modifiables, acceptent les doublons.
- Exemple : fruits = ["pomme", "banane", "mangue"]

2. Tuples (tuple)
- Ordonnés, non modifiables (immuables).
- Exemple : jours = ("lundi", "mardi", "mercredi")

3. Dictionnaires (dict)
- Clés/valeurs, non ordonnés (jusqu’à Python 3.6), modifiables.
- Exemple : notes = {"Marc": 15, "Anna": 17}

4. Ensembles (set)
- Non ordonnés, pas de doublons, utiles pour les opérations ensemblistes.
- Exemple : ensemble1 = {"pomme", "banane", "kiwi"}

Utilité :
- Stocker des collections de données.
- Accéder, modifier, trier ou comparer des éléments.
- Effectuer des opérations sur des groupes d’éléments.
 Python 18

Exercice 1 : Liste
Énoncé :
Crée une liste contenant les nombres de 1 à 5. Remplace le 3 par 33 et ajoute 6
à la fin.

Correction :
python
nombres = [1, 2, 3, 4, 5]
nombres[2] = 33 # Remplace 3 par 33
nombres.append(6) # Ajoute 6 à la fin
print(nombres) # [1, 2, 33, 4, 5, 6]

Exercice 2 : Tuple
Énoncé :
Crée un tuple avec les noms : "Marc", "Jean", "Claire". Affiche le deuxième nom.

Correction :
python
noms = ("Marc", "Jean", "Claire")
print(noms[1]) # Jean

Exercice 3 : Set
Énoncé :
Crée un set avec les éléments suivants : [1, 2, 2, 3, 4, 4, 5]. Affiche le set.
 Python 19

Correction :
python
mon_set = set([1, 2, 2, 3, 4, 4, 5])
print(mon_set) # {1, 2, 3, 4, 5}

Exercice 4 : Dictionnaire
Énoncé :
Crée un dictionnaire pour stocker les âges de "Alice": 25, "Bob": 30. Ajoute
"Claire": 22, puis affiche l’âge de Bob.

Correction :
python
ages = {"Alice": 25, "Bob": 30}
ages["Claire"] = 22
print(ages["Bob"]) # 30
 Python 20

3.2. METHODES DE MANIPULATION

1. Listes (list)
- append(x) : Ajoute un élément à la fin
liste.append(10)
- remove(x) : Supprime la première occurrence de x
liste.remove(10)
- pop(i) : Supprime l'élément à l’index i (ou le dernier si i non spécifié)
liste.pop() ou liste.pop(2)
- insert(i, x) : Insère x à l’index i
liste.insert(1, 20)
- sort() : Trie la liste
liste.sort()
- reverse() : Inverse l’ordre
liste.reverse()

2. Dictionnaires (dict)
- keys() : Retourne les clés
mon_dict.keys()
- values() : Retourne les valeurs
mon_dict.values()
- items() : Retourne couples (clé, valeur)
mon_dict.items()
- get(k, default) : Retourne la valeur de la clé ou une valeur par défaut
mon_dict.get("nom", "inconnu")
- update() : Met à jour avec un autre dict
mon_dict.update({"age": 30})
- pop(k) : Supprime une clé
 Python 21

mon_dict.pop("nom")

3. Ensembles (set)
- add(x) : Ajoute un élément
mon_set.add(7)
- remove(x) : Supprime x (erreur si absent)
mon_set.remove(7)
- discard(x) : Supprime x (sans erreur)
mon_set.discard(7)
- union() : Union de deux ensembles
set1.union(set2)
- intersection() : Éléments communs
set1.intersection(set2)
- difference() : Éléments de set1 non dans set2
set1.difference(set2)

Exercice : Gestion d’un petit stock de boutique

Objectif :
Créer une mini-application qui :
1. Ajoute des produits en stock (liste)
2. Supprime un produit
3. Affiche les produits triés
4. Gère les prix des produits (dictionnaire)
5. Identifie les catégories de produits (ensemble)

Instructions
 Python 22

python
Étape 1 : Crée une liste vide nommée 'stock'
stock = []

Étape 2 : Ajoute les produits suivants : "pain", "lait", "riz"

stock.append("pain")
stock.append("lait")
stock.append("riz")

Étape 3 : Supprime le produit "lait"

stock.remove("lait")

Étape 4 : Trie le stock

stock.sort()

Étape 5 : Crée un dictionnaire des prix des produits restants

prix = {
"pain": 500,
"riz": 1200
}

Étape 6 : Affiche les clés et les valeurs du dictionnaire

print("Produits :", prix.keys())
print("Prix :", prix.values())

Étape 7 : Crée un ensemble des catégories : "alimentaire", "ménager"

categories = {"alimentaire", "ménager"}
 Python 23

Étape 8 : Ajoute une catégorie "boulangerie"

categories.add("boulangerie")

Étape 9 : Affiche les catégories disponibles

print("Catégories :", categories)

Questions
1. Que contient la liste stock après suppression et tri ?
2. Quelle est la différence entre remove() et discard() (utilise un set pour tester) ?
3. Quelle méthode permet de récupérer les paires (clé, valeur) dans un
dictionnaire ?
Résultat attendu étape par étape :

*Liste stock*
python
stock = []

stock.append("pain") # ["pain"]
stock.append("lait") # ["pain", "lait"]
stock.append("riz") # ["pain", "lait", "riz"]

stock.remove("lait") # ["pain", "riz"]

stock.sort() # ["pain", "riz"]

Résultat final de stock :* ["pain", "riz"]

 Python 24

Dictionnaire prix*
python
prix = {
"pain": 500,
"riz": 1200
}

Affichage :
print("Produits :", prix.keys()) # dict_keys(['pain', 'riz'])
print("Prix :", prix.values()) # dict_values([500, 1200])

*Ensemble categories*
python
categories = {"alimentaire", "ménager"}
categories.add("boulangerie")

Affichage :
print("Catégories :", categories)
Exemple de sortie (l’ordre peut varier) : {'alimentaire', 'ménager', 'boulangerie'}

Réponses aux questions :

1. Que contient la liste stock ?*

→ ["pain", "riz"] (après suppression de "lait" et tri alphabétique)

2. Différence entre remove() et discard() (dans un set) :

- remove(x) : supprime x, mais lève une erreur si x n'existe pas.
 Python 25

- discard(x) : supprime x sans erreur, même si x n’est pas présent.

Exemple :
```python
s = {1, 2, 3}
s.remove(2) # OK
s.remove(5) # Erreur ! (KeyError)

s.discard(5) # Pas d’erreur

```
3. Méthode pour obtenir les paires clé-valeur d’un dictionnaire :
→ dictionnaire.items()
 Python 26

CHAPITRE 04. LES FONCTIONS

Une fonction en Python est un bloc de code réutilisable qui s'exécute uniquement
lorsqu'elle est appelée. Elle permet d'organiser et de structurer un programme,
d’éviter les répétitions et de rendre le code plus clair.

1. Déclaration d’une fonction

On utilise le mot-clé def :
python
def saluer():
print("Bonjour !")

2. Appel d’une fonction

python
saluer()

3. Fonction avec paramètres

python
def ajouter(a, b):
return a + b

Appel :
python
resultat = ajouter(3, 5)

4. Valeur de retour
Utilise return pour renvoyer un résultat.

5. Fonctions avec paramètres par défaut

 Python 27

python
def saluer(nom="ami"):
print(f"Bonjour {nom} !")

6. Fonctions anonymes (lambda)

python
carre = lambda x: x * x
print(carre(4)) # Affiche 16

7. Portée des variables

Les variables définies dans une fonction sont locales à cette fonction.

 Utilité des fonctions :

- Réutilisation de code
- Lisibilité
- Organisation

Exercice 1 : Fonction de salutation

Écris une fonction saluer(nom) qui affiche « Bonjour [nom] ! »
Exemple :
python
saluer("Marc") # Bonjour Marc !
Exercice 2 : Calcul de la somme
Écris une fonction somme (a, b) qui retourne la somme de deux nombres.
Exercice 3 : Calcul de la factorielle
Écris une fonction factorielle(n) qui calcule la factorielle d’un nombre n.

Indice :
 Python 28

- factorielle(5) = 5×4×3×2×1 = 120

Exercice 4 : Tester si un nombre est pair

Écris une fonction est_pair(n) qui retourne True si n est pair, sinon False.
Exercice 5 : Trouver le plus grand de deux nombres
Écris une fonction maximum(a, b) qui retourne le plus grand des deux.

RESOLUTIONS
Exercice 1 : Fonction de salutation
python
def saluer(nom):
print(f"Bonjour {nom} !")

Exercice 2 : Calcul de la somme

python
def somme(a, b):
return a + b

Exercice 3 : Calcul de la factorielle

python
def factorielle(n):
result = 1
for i in range(1, n + 1):
result *= i
return result
 Python 29

Exercice 4 : Tester si un nombre est pair

python
def est_pair(n):
return n % 2 == 0

Exercice 5 : Trouver le plus grand de deux nombres

python
def maximum(a, b):
if a > b:
return a
else:
return b
 Python 30

PROJET DE CREATION D’UN CONVERTISSEUR DE

TEMPERATURE

Convertisseur Celsius ⇄ Fahrenheit :

python
def celsius_to_fahrenheit(celsius):
return (celsius * 9/5) + 32

def fahrenheit_to_celsius(fahrenheit):
return (fahrenheit - 32) * 5/9

print("Convertisseur de température")
choix = input("Tapez 1 pour Celsius → Fahrenheit ou 2 pour Fahrenheit →
Celsius : ")

if choix == "1":
c = float(input("Entrez la température en Celsius : "))
f = celsius_to_fahrenheit(c)
print(f"{c}°C = {f:.2f}°F")
elif choix == "2":
f = float(input("Entrez la température en Fahrenheit : "))
c = fahrenheit_to_celsius(f)
print(f"{f}°F = {c:.2f}°C")
else:
print("Choix invalide")
 Python 31

PROJET DE CREATION D’UNE CALCULATRICE SIMPLE

python
def addition(a, b):
return a + b

def soustraction(a, b):

return a - b

def multiplication(a, b):

return a * b

def division(a, b):

if b == 0:
return "Erreur : division par zéro"
return a / b

print("Calculatrice simple")
print("1. Addition")
print("2. Soustraction")
print("3. Multiplication")
print("4. Division")

choix = input("Choisissez une opération (1/2/3/4) : ")

a = float(input("Entrez le premier nombre : "))

b = float(input("Entrez le deuxième nombre : "))
 Python 32

if choix == "1":
print("Résultat :", addition(a, b))
elif choix == "2":
print("Résultat :", soustraction(a, b))
elif choix == "3":
print("Résultat :", multiplication(a, b))
elif choix == "4":
print("Résultat :", division(a, b))
else:
print("Choix invalide")
 Python 33

CHAPITRE 05. INTRODUCTION SUR TKINTER

1. DEFINITION :
Tkinter est la bibliothèque standard de Python pour créer des interfaces
graphiques (GUI). Elle permet de développer des applications de bureau
interactives.

2. PRINCIPAUX COMPOSANTS :
- Tk() : Crée la fenêtre principale.
- Label : Affiche du texte.
- Button : Bouton cliquable.
- Entry : Champ de saisie.
- Text : Zone de texte multilignes.
- Frame : Conteneur pour regrouper des widgets.
- Checkbutton, Radiobutton : Boutons à cocher ou options.
- Listbox, Combobox : Listes déroulantes.

3. POSITIONNEMENT DES ELEMENTS :

- pack() : Empile les widgets (haut, bas, gauche…).
- grid() : Organisation en grille (ligne, colonne).
- place() : Placement libre (x, y).

4. BOUCLE PRINCIPALE :
- fenetre.mainloop() : Démarre l’interface et la rend interactive.

5. ÉVENEMENTS ET COMMANDES :
- On peut associer des fonctions aux boutons ou autres widgets avec command=.
 Python 34

6. AVANTAGES :
- Facile à utiliser.
- Livré avec Python.
- Suffisant pour les petits projets.

Objectif : Créer une interface qui demande le nom de l’utilisateur et

l’affiche après clic.

Énoncé :
Crée une fenêtre avec :
1. Un champ de saisie (Entry) pour le nom.
2. Un bouton "Afficher".
3. Une étiquette (Label) où s’affichera "Bonjour [Nom]".

Corrigé (code Python) :

python
import tkinter as tk

def afficher_nom():
nom = entree.get()
label_resultat.config(text=f"Bonjour {nom} !")

Fenêtre principale
fenetre = tk.Tk()
fenetre.title("Bienvenue")

Widgets
label = tk.Label(fenetre, text="Entrez votre nom :")
 Python 35

label.pack()

entree = tk.Entry(fenetre)
entree.pack()

bouton = tk.Button(fenetre, text="Afficher", command=afficher_nom)

bouton.pack()

label_resultat = tk.Label(fenetre, text="")

label_resultat.pack()

fenetre.mainloop()
 Python 36

PROJET DE CREATION DE CALCULATRICE SUR

TKINTER

python
import tkinter as tk

def click(event):
text = event.widget.cget("text")
if text == "=":
try:
result = str(eval(entry.get()))
entry.delete(0, tk.END)
entry.insert(tk.END, result)
except:
entry.delete(0, tk.END)
entry.insert(tk.END, "Erreur")
elif text == "C":
entry.delete(0, tk.END)
else:
entry.insert(tk.END, text)

root = tk.Tk()
root.title("Calculatrice")

entry = tk.Entry(root, font="Arial 20")

entry.pack(fill=tk.BOTH, ipadx=8, pady=10, padx=10)

boutons = [
 Python 37

["7", "8", "9", "/"],

["4", "5", "6", "*"],
["1", "2", "3", "-"],
["C", "0", "=", "+"]
]

for ligne in boutons:

frame = tk.Frame(root)
frame.pack()
for btn in ligne:
b = tk.Button(frame, text=btn, font="Arial 18", width=4, height=2)
b.pack(side=tk.LEFT, padx=5, pady=5)
b.bind("<Button-1>", click)

root.mainloop()
 Python 38

A propos de l’auteur :
Marc OMALOSOMBE ELENGA est étudiant et chercheur en sciences
commerciales, administratives, informatique de gestion et gestion
des entreprises à l’Institut Supérieur Pédagogique de la Gombe.
Titulaire d’un Bac+1 en gestion des entreprises, il se distingue par sa
passion pour l’enseignement pragmatique.
Convaincu que l’apprentissage doit être accessible et efficace, Marc
s’engage à développer des méthodes innovantes favorisant une
acquisition rapide et concrète des compétences, notamment dans les
domaines de la gestion et de l’informatique appliquée.