Code. Progresse. / Learn. Grow. »
🎓 Python Academy Global
FR/EN — Apprends / Learn Python facilement.
Leçons simples, exercices pratiques, projets réels.
Pour débutants et passionnés qui veulent progresser chaque jour.
« 🎯Apprends.
07/06/2026
💻 Informatique : fais ton choix 👇
Si tu devais choisir UNE seule voie aujourd’hui, ce serait laquelle ?
🛡️ Cybersécurité
👉 Protéger les systèmes, traquer les hackers, sécuriser les données
🌐 Développement Web
👉 Créer des sites, des applications, transformer des idées en réalité
Dis-nous ton choix en commentaire :
➡️ Cyber sécurité ou Développement web ?
👇👇👇
07/06/2026
💰 Tu sais combien gagne un développeur Python aujourd'hui ? 🤔
🇺🇸 États-Unis 95 000 $ / an
🇨🇦 Canada 80 000 $ / an
🇫🇷 France 45 000 € / an
🌍 Freelance 50 à 150 $ / heure
Impressionnant, n'est-ce pas ? 😲
Mais ce qui est encore plus surprenant, c'est que la plupart ont commencé avec une seule ligne de code :
print("Hello, World!")
Oui, juste ça. 👆
Pas de projet complexe.
Pas d'intelligence artificielle.
Pas d'application révolutionnaire.
Seulement une ligne qui marque le début de l'aventure.
Beaucoup de débutants pensent qu'il faut être un génie pour apprendre à programmer.
La réalité est différente.
⏱️ 30 minutes par jour
📅 Quelques mois de pratique régulière
🎯 Des projets concrets à réaliser
Chaque expert Python que tu admires aujourd'hui a été débutant un jour.
La vraie question n'est donc pas :
❌ « Est-ce que je suis capable d'apprendre Python ? »
Mais plutôt :
✅ « Quand vais-je commencer ? »
06/06/2026
⭐Défi Python : Transformer une calculatrice console en interface graphique avec Tkinter ✅
📌 Code de départ (version console)
# Calculatrice simple en console
while True:
expression = input("Entrez un calcul (ou 'q' pour quitter) : ")
if expression.lower() == "q":
print("Au revoir !")
break
try:
resultat = eval(expression)
print("Résultat :", resultat)
except:
print("Erreur dans l'expression")
🎯 Objectif du défi :
Jusqu’à présent, votre calculatrice fonctionne dans le terminal.
C’est une bonne base, mais une application moderne utilise généralement une interface graphique pour offrir une meilleure expérience utilisateur.
Votre mission est donc de transformer cette calculatrice console en une véritable application graphique avec Tkinter
👉 Fonctionnalités attendues :
Votre calculatrice graphique doit inclure :
✅ Une zone d’affichage pour saisir et afficher les calculs
✅ Des boutons numériques de 0 à 9
✅ Les opérateurs : +, -, *, /
✅ Un bouton = pour afficher le résultat
✅ Un bouton C pour effacer l’écran
💡 Consigne
Essayez de réaliser l’interface par vous-même avant de consulter la solution.
✅ Voici ma solution 👇:
import tkinter as tk # on importe tkinter pour créer la fenêtre
# ajouter un caractère dans l'écran
def ajouter(caractere):
ecran.insert(tk.END, caractere) # on ajoute ce que l'utilisateur clique
# faire le calcul
def calculer():
try:
resultat = eval(ecran.get()) # on récupère ce qui est écrit et on calcule
ecran.delete(0, tk.END) # on vide l'écran
ecran.insert(0, str(resultat)) # on affiche le résultat
except:
ecran.delete(0, tk.END)
ecran.insert(0, "Erreur") # si problème dans le calcul
# vider l'écran
def effacer():
ecran.delete(0, tk.END)
# fenêtre principale
fenetre = tk.Tk()
fenetre.title("Calculatrice")
# écran d'affichage
ecran = tk.Entry(fenetre, width=20, font=("Arial", 18))
ecran.grid(row=0, column=0, columnspan=4)
# boutons de la calculatrice
boutons = [
"7", "8", "9", "/",
"4", "5", "6", "*",
"1", "2", "3", "-",
"C", "0", "=", "+"
]
ligne = 1
colonne = 0
# création des boutons
for bouton in boutons:
if bouton == "=":
tk.Button(fenetre, text=bouton, width=5, command=calculer).grid(row=ligne, column=colonne)
elif bouton == "C":
tk.Button(fenetre, text=bouton, width=5, command=effacer).grid(row=ligne, column=colonne)
else:
tk.Button(
fenetre,
text=bouton,
width=5,
command=lambda b=bouton: ajouter(b)
).grid(row=ligne, column=colonne)
colonne += 1
if colonne > 3:
colonne = 0
ligne += 1
fenetre.mainloop()
🔥Qui a réussi a le faire sans regarder la résolution ?
06/06/2026
Formation Python #15 (partie 3) : Comment centrer une fenêtre Tkinter à l'écran ? ✅
Lorsque nous créons une fenêtre avec Tkinter, elle n'apparaît pas toujours au centre de l'écran.
Aujourd'hui, nous allons apprendre à centrer automatiquement une fenêtre, comme dans les logiciels professionnels.
📌 Voici un exemple du code complet :
import tkinter
mainapp = tkinter.Tk()
mainapp.title("Mon premier programme fenêtré")
window_x = 800
window_y = 600
# Force Tkinter à terminer ses calculs internes
mainapp.update_idletasks()
screen_x = mainapp.winfo_screenwidth()
screen_y = mainapp.winfo_screenheight()
posX = (screen_x // 2) - (window_x // 2)
posY = (screen_y // 2) - (window_y // 2)
geo = "{}x{}+{}+{}".format(window_x, window_y, posX, posY)
mainapp.geometry(geo)
mainapp.mainloop()
👉 Voici l'explication de ce code qui centre la fenêtre :
🧱 1. Importer Tkinter
import tkinter
Cette ligne permet d'utiliser la bibliothèque Tkinter.
👉 Sans elle, Python ne connaîtrait pas les fenêtres graphiques.
🧱 2. Créer la fenêtre
mainapp = tkinter.Tk()
Cette ligne crée la fenêtre principale.
C'est cette fenêtre qui va apparaître à l'écran.
🧱 3. Donner un titre à la fenêtre
mainapp.title("Mon premier programme fenêtré")
Cette ligne change le texte affiché dans la barre de titre.
Résultat :
Mon premier programme fenêtré
🧱 4. Définir la taille de la fenêtre
window_x = 800
window_y = 600
Ici , on a défini la taille :
800 = largeur
600 = hauteur
La fenêtre mesurera donc :
800 pixels de large
600 pixels de haut
🧱 5. Demander à Tkinter de terminer ses calculs
mainapp.update_idletasks()
Cette ligne force Tkinter à préparer correctement la fenêtre avant la suite du programme.
C'est une bonne habitude lorsqu'on travaille avec les dimensions d'une fenêtre.
🧱 6. Récupérer la largeur de l'écran
screen_x = mainapp.winfo_screenwidth()
Cette fonction récupère automatiquement la largeur de l'écran.
Donc on demande à Python de récupérer automatiquement la largeur de l'écran et de la stocker dans la variable screen_x.
Exemple :
1920 pixels
🧱 7. Récupérer la hauteur de l'écran
screen_y = mainapp.winfo_screenheight()
Cette fonction récupère la hauteur de l'écran.
Donc on demande à Python de récupérer automatiquement la hauteur de l'écran et de la stocker dans la variable screen_y.
Exemple :
1080 pixels
À ce stade :
screen_x = 1920
screen_y = 1080
🔢 8. Calculer le centre horizontal
posX = (screen_x // 2) - (window_x // 2)
Imaginons :
screen_x = 1920
window_x = 800
Python calcule :
1920 // 2 = 960
800 // 2 = 400
Puis :
960 - 400 = 560
Résultat :
posX = 560
👉 La fenêtre commencera à 560 pixels du bord gauche de l'écran.
🔢 9. Calculer le centre vertical
posY = (screen_y // 2) - (window_y // 2)
Imaginons :
screen_y = 1080
window_y = 600
Python calcule :
1080 // 2 = 540
600 // 2 = 300
Puis :
540 - 300 = 240
Résultat :
posY = 240
👉 La fenêtre commencera à 240 pixels du haut de l'écran.
🧱 10. Construire la géométrie
geo = "{}x{}+{}+{}".format(window_x, window_y, posX, posY)
Cette ligne fabrique automatiquement :
800x600+560+240
Ce texte signifie :
800 = largeur
600 = hauteur
560 = position horizontale
240 = position verticale
🧱 11. Appliquer la géométrie
mainapp.geometry(geo)
Cette ligne indique à Tkinter :
👉 Crée une fenêtre de 800x600 et place-la aux coordonnées calculées.
🔄 12. Garder la fenêtre ouverte
mainapp.mainloop()
Cette ligne lance la boucle principale de Tkinter.
Sans elle :
❌ La fenêtre apparaîtrait puis disparaîtrait immédiatement.
Avec elle :
✅ La fenêtre reste ouverte jusqu'à ce que l'utilisateur la ferme.
🎯 Résultat final
Lorsque le programme démarre :
✅ Une fenêtre de 800x600 est créée.
✅ Son titre est affiché.
✅ Elle est automatiquement centrée à l'écran.
✅ Elle reste ouverte jusqu'à sa fermeture.
💡 À retenir :
Pour centrer une fenêtre, il faut :
1️⃣ Connaître la taille de l'écran.
2️⃣ Connaître la taille de la fenêtre.
3️⃣ Calculer la moitié de chaque dimension.
4️⃣ Soustraire les deux valeurs pour obtenir la position idéale.
05/06/2026
🚫 Voici pourquoi tu ne finis pas tes projets.
Pendant longtemps, je pensais que le problème venait du manque de motivation.
Je me disais que j'avais juste besoin d'être plus inspiré, plus motivé, plus déterminé.
Mais avec le temps, j'ai compris quelque chose d'important :
La motivation ne dure jamais.
Certains jours, tu te sens capable de tout accomplir. Tu travailles avec enthousiasme. Tu as plein d'idées. Tu es convaincu que cette fois-ci, tu vas aller jusqu'au bout.
Puis quelques jours ou quelques semaines plus t**d, l'excitation disparaît.
Le projet devient plus difficile. Les résultats arrivent moins vite que prévu. Les problèmes s'accumulent.
Et c'est souvent à ce moment-là que beaucoup abandonnent.
Ce que j'ai appris, c'est que les personnes qui réussissent ne sont pas celles qui sont motivées en permanence.
Elles sont simplement disciplinées.
Elles avancent même quand elles n'en ont pas envie. Elles continuent même quand c'est difficile. Elles travaillent même quand personne ne les regarde.
La discipline n'est pas spectaculaire.
Ce n'est pas une vidéo motivante. Ce n'est pas un discours inspirant.
C'est faire ce qui doit être fait, encore et encore, même lorsque l'envie n'est plus là.
Aujourd'hui, je crois que la motivation aide à commencer, mais que seule la discipline permet d'aller jusqu'au bout.
Et toi, qu'en penses-tu ? 👇🔥
Créer ce jeu complet avec Claude code + la bibliothèque pygame en python 😱✅
message = "Salut et bonne journée à tous 👋"
print(f"Merci ma communauté, {message}")
04/06/2026
Python Formation #15 ( partie 2) : Les widgets dans Tkinter ✅
Quand on crée une interface graphique avec Tkinter, on utilise des widgets.
Un widget est simplement un élément visible ou interactif de la fenêtre.
Pense à une application comme une maison :
- La fenêtre est la maison.
- Les widgets sont les meubles et les objets à l'intérieur.
Par exemple :
- Un bouton est un widget.
- Une zone de texte est un widget.
- Une étiquette affichant du texte est un widget.
- Une case à cocher est un widget.
♦️ Les widgets les plus utilisés :
1. Label (Étiquette)
Permet d'afficher du texte.
Exemple :
import tkinter as tk
fenetre = tk.Tk()
label = tk.Label(fenetre, text="Bonjour !")
label.pack()
fenetre.mainloop()
Résultat :
Bonjour !
2. Button (Bouton)
Permet à l'utilisateur d'exécuter une action lorsqu'il clique dessus.
Exemple :
import tkinter as tk
fenetre = tk.Tk()
bouton = tk.Button(fenetre, text="Clique-moi")
bouton.pack()
fenetre.mainloop()
Résultat :
[ Clique-moi ]
3. Entry (Champ de saisie)
Permet à l'utilisateur d'écrire du texte.
import tkinter as tk
fenetre = tk.Tk()
champ = tk.Entry(fenetre)
champ.pack()
fenetre.mainloop()
Résultat :
[____________]
4. Text
Permet d'écrire plusieurs lignes de texte.
import tkinter as tk
fenetre = tk.Tk()
zone = tk.Text(fenetre, height=5, width=30)
zone.pack()
fenetre.mainloop()
5. Checkbutton (Case à cocher)
Permet de sélectionner ou non une option.
import tkinter as tk
fenetre = tk.Tk()
case = tk.Checkbutton(fenetre, text="J'accepte")
case.pack()
fenetre.mainloop()
Résultat :
☐ J'accepte
6. Radiobutton
Permet de choisir une seule option parmi plusieurs.
import tkinter as tk
fenetre = tk.Tk()
tk.Radiobutton(fenetre, text="Homme").pack()
tk.Radiobutton(fenetre, text="Femme").pack()
fenetre.mainloop()
7. Listbox
Affiche une liste d'éléments.
Python
import tkinter as tk
fenetre = tk.Tk()
liste = tk.Listbox(fenetre)
liste.insert(tk.END, "Python")
liste.insert(tk.END, "Java")
liste.insert(tk.END, "C++")
liste.pack()
fenetre.mainloop()
👉 Prochainement, nous allons voir comment centrer sa fenêtre ✅
04/06/2026
Projet : Crée un mini réseau social avec des dictionnaires.✅
Structure :
reseau = {
"Johnny": {
"amis": ["Sarah", "David"],
"publications": 12
},
"Sarah": {
"amis": ["Exau"],
"publications": 8
}
}
Le programme doit permettre :
- Ajouter un utilisateur.
- Ajouter un ami.
- Afficher le nombre total d'amis d'un utilisateur.
- Trouver l'utilisateur ayant le plus d'amis.
- Trouver l'utilisateur ayant publié le plus.
- Afficher les amis communs entre deux utilisateurs.
Ce dernier exercice combine :
- dictionnaires,
- listes,
- boucles,
- conditions,
- fonctions
✅ Résolution 👇 :
# Base de données du réseau social
reseau = {
"Johnny": {
"amis": ["Sarah", "David"],
"publications": 12
},
"Sarah": {
"amis": ["Johnny"],
"publications": 8
}
}
# Boucle principale du programme
while True:
# Menu principal
print("\n=== MINI RÉSEAU SOCIAL ===")
print("1. Ajouter un utilisateur")
print("2. Ajouter un ami")
print("3. Afficher le nombre d'amis")
print("4. Utilisateur avec le plus d'amis")
print("5. Utilisateur avec le plus de publications")
print("6. Afficher les amis communs")
print("7. Afficher tous les utilisateurs")
print("8. Quitter")
choix = input("\nVotre choix : ")
# Ajouter un nouvel utilisateur
if choix == "1":
nom = input("Nom du nouvel utilisateur : ")
if nom not in reseau:
reseau[nom] = {
"amis": [],
"publications": 0
}
print("Utilisateur ajouté.")
else:
print("Cet utilisateur existe déjà.")
# Créer une amitié entre deux utilisateurs
elif choix == "2":
utilisateur1 = input("Premier utilisateur : ")
utilisateur2 = input("Deuxième utilisateur : ")
if utilisateur1 in reseau and utilisateur2 in reseau:
# Ajouter chaque utilisateur dans la liste d'amis de l'autre
if utilisateur2 not in reseau[utilisateur1]["amis"]:
reseau[utilisateur1]["amis"].append(utilisateur2)
if utilisateur1 not in reseau[utilisateur2]["amis"]:
reseau[utilisateur2]["amis"].append(utilisateur1)
print("Amitié ajoutée.")
else:
print("Un ou plusieurs utilisateurs sont introuvables.")
# Afficher le nombre d'amis d'un utilisateur
elif choix == "3":
nom = input("Nom de l'utilisateur : ")
if nom in reseau:
nb_amis = len(reseau[nom]["amis"])
print(nom, "a", nb_amis, "ami(s).")
else:
print("Utilisateur introuvable.")
# Trouver l'utilisateur qui possède le plus d'amis
elif choix == "4":
plus_amis = max(
reseau,
key=lambda utilisateur: len(reseau[utilisateur]["amis"])
)
print(
"Utilisateur avec le plus d'amis :",
plus_amis
)
print(
"Nombre d'amis :",
len(reseau[plus_amis]["amis"])
)
# Trouver l'utilisateur le plus actif
elif choix == "5":
plus_publications = max(
reseau,
key=lambda utilisateur: reseau[utilisateur]["publications"]
)
print(
"Utilisateur le plus actif :",
plus_publications
)
print(
"Publications :",
reseau[plus_publications]["publications"]
)
# Rechercher les amis communs entre deux utilisateurs
elif choix == "6":
utilisateur1 = input("Premier utilisateur : ")
utilisateur2 = input("Deuxième utilisateur : ")
if utilisateur1 in reseau and utilisateur2 in reseau:
amis1 = set(reseau[utilisateur1]["amis"])
amis2 = set(reseau[utilisateur2]["amis"])
# Intersection des deux ensembles
communs = amis1 & amis2
if communs:
print("Amis communs :", list(communs))
else:
print("Aucun ami commun.")
else:
print("Un ou plusieurs utilisateurs sont introuvables.")
# Afficher tous les utilisateurs du réseau
elif choix == "7":
print("\nListe des utilisateurs :")
for utilisateur, infos in reseau.items():
print("\nNom :", utilisateur)
print("Amis :", infos["amis"])
print("Publications :", infos["publications"])
# Quitter le programme
elif choix == "8":
print("Au revoir !")
break
# Gestion des choix incorrects
else:
print("Choix invalide.")
04/06/2026
Exercice 3 sur les dictionnaires : Classement des joueurs 🎮
On te donne :
joueurs = {
"Alice": 250,
"Bob": 400,
"Charlie": 180,
"David": 520,
"Emma": 350
}
Sans modifier le dictionnaire original :
- Affiche les joueurs du meilleur au moins bon.
- Affiche le Top 3.
- Trouve le joueur ayant le score le plus proche de 300.
- Affiche l'écart entre le meilleur et le moins bon score.
👉 Voici la résolution ✅ :
joueurs = {
"Alice": 250,
"Bob": 400,
"Charlie": 180,
"David": 520,
"Emma": 350
}
# Tri des joueurs selon leurs scores
classement = sorted(
joueurs.items(),
key=lambda joueur: joueur[1],
reverse=True
)
print("Classement :")
for nom, score in classement:
print(nom, ":", score)
# Top 3
print("\nTop 3 :")
for nom, score in classement[:3]:
print(nom, ":", score)
# Score le plus proche de 300
proche = min(
joueurs,
key=lambda joueur: abs(joueurs[joueur] - 300)
)
print("\nPlus proche de 300 :", proche)
# Écart entre le meilleur et le moins bon score
ecart = max(joueurs.values()) - min(joueurs.values())
print("Écart :", ecart)