Projet Python :
Réalisés par : Encadré par :
Mlle : Afaf Mabkhouti Mr :Ben_Loghfyry
Mlle : Ikram Eljazouli
10 Décembre 2024
Présentation du 1er Programme : Chat entre Deux Amis
Introduction
Ce document présente un programme permettant `a deux utilisateurs, appelés
Ami 1 et Ami 2, de discuter en temps réel via un réseau local ou sur le même
ordinateur. Ce programme utilise les sockets pour ´établir une communication
entre le client (Ami 1) et le serveur (Ami 2).
Objectif
L’objectif principal est de permettre une conversation simple entre deux
utilisateurs en suivant ces ´étapes :
• Connexion : Un utilisateur (Ami 1) se connecte `à un serveur (Ami 2).
1
• Echange de messages´ : Les utilisateurs peuvent envoyer et recevoir des
messages en temps réel.
• Fin de la communication : La conversation peut ˆêtre terminée
proprement `a tout moment en utilisant le mot-clé exit.
Technologies utilisées
• Python : Langage de programmation utilisé pour ´écrire le programme.
• Bibliothèque socket : Permet de gérer la communication réseau entre
deux machines.
Description des programmes
Le programme est divis´e en deux parties :
1. Programme pour Ami 1 (Client)
• Rˆole : Se connecter `a Ami 2 et initier la communication.
• Fonctionnement :
– Saisir un nom d’utilisateur (exemple : Alice).
– Envoyer des messages `a Ami 2 et recevoir ses r´eponses.
– Quitter la conversation en tapant exit.
2. Programme pour Ami 2 (Serveur)
• Rôle : Accepter la connexion d’Ami 1 et répondre aux messages.
• Fonctionnement :
– Saisir un nom d’utilisateur (exemple : Bob).
– Attendre qu’Ami 1 se connecte.
– Recevoir les messages d’Ami 1 et y répondre.
– Terminer la conversation proprement si exit est reçu.
2
Simulation des échanges
Code :
Code du "Ami 1" :
import socket # Importer le module socket pour la communication réseau
# Définition de la classe Ami2
class Ami2:
def __init__(self, host, port, server_name):
"""
Initialise un serveur qui accepte une connexion d'un client.
Args:
host (str): L'adresse de l'hôte (par exemple 'localhost').
port (int): Le port sur lequel le serveur écoute.
server_name (str): Le nom de l'utilisateur ou du serveur pour afficher
dans les messages.
"""
# Création d'un socket TCP pour le serveur
self.server_socket = [Link](socket.AF_INET, socket.SOCK_STREAM)
3
# Lier le socket à l'adresse et au port spécifiés
self.server_socket.bind((host, port))
# Mettre le serveur en mode écoute pour accepter les connexions (ici, un
seul client à la fois)
self.server_socket.listen(1)
# Stocker le nom du serveur pour l'affichage dans les messages
self.server_name = server_name
def start(self):
"""
Démarre le serveur et accepte les connexions entrantes d'un client.
Une fois la connexion établie, il attend des messages du client et y
répond.
"""
# Attendre qu'un client se connecte
print(f"Ami 2 ({self.server_name}) en attente de connexion...")
# Accepter une connexion entrante. Cette méthode bloque jusqu'à ce qu'un
client se connecte
client_socket, client_address = self.server_socket.accept()
# Afficher l'adresse du client une fois la connexion établie
print(f"Connexion établie avec {client_address}")
# Boucle pour gérer l'échange de messages
while True:
# Recevoir le message du client, maximum de 1024 octets
message = client_socket.recv(1024).decode()
# Si le message reçu est "exit", la conversation se termine
if [Link]() == "exit":
print("Ami 1 a quitté la conversation.") # Afficher un message
indiquant que le client a quitté
client_socket.close() # Fermer la connexion avec le client
4
break # Sortir de la boucle
# Afficher le message reçu du client
print(f"Ami 1: {message}")
# Demander à l'utilisateur de saisir une réponse
response = input(f"{self.server_name}: ")
# Envoyer la réponse au client après l'avoir encodée en bytes
client_socket.send([Link]())
# Démarrage de l'application Ami2
if __name__ == "__main__":
# Demander le nom du serveur (Ami 2) à l'utilisateur
server_name = input("Entrez votre nom (Ami 2): ")
# Créer une instance de la classe Ami2 avec l'adresse 'localhost', le port
12345 et le nom du serveur
ami2 = Ami2('localhost', 12345, server_name)
# Démarrer le serveur pour accepter les connexions et gérer les messages
[Link]()
Code du "Ami 2" :
import socket # Importation du module socket pour la communication réseau
# Définition de la classe Ami1
class Ami1:
def __init__(self, host, port, username):
"""
Initialise une connexion client pour se connecter à un serveur.
5
Args:
host (str): Adresse IP ou nom d'hôte du serveur.
port (int): Port utilisé pour la connexion.
username (str): Nom d'utilisateur du client pour identifier les
messages envoyés.
"""
# Création d'un socket TCP
self.client_socket = [Link](socket.AF_INET, socket.SOCK_STREAM)
# Établir une connexion au serveur spécifié par 'host' et 'port'
self.client_socket.connect((host, port))
# Stocker le nom d'utilisateur
[Link] = username
def start(self):
"""
Lance la boucle principale pour envoyer et recevoir des messages.
L'utilisateur peut entrer "exit" pour terminer la conversation.
"""
while True:
# Demander à l'utilisateur de saisir un message
message = input(f"{[Link]}: ")
# Envoyer le message au serveur après l'avoir encodé en bytes
self.client_socket.send([Link]())
# Vérifier si l'utilisateur a tapé "exit" pour quitter
if [Link]() == "exit":
print(f"{[Link]} a quitté la conversation.") # Message
d'information
self.client_socket.close() # Fermer proprement la connexion
break # Sortir de la boucle principale
# Recevoir la réponse du serveur
response = self.client_socket.recv(1024).decode() # Lire les données
reçues et les décoder
# Afficher la réponse du serveur ou d'un autre utilisateur connecté
print(f"Ami 2: {response}")
6
# Démarrage de l'application Ami1
if __name__ == "__main__":
# Demander le nom d'utilisateur pour identifier le client
username = input("Entrez votre nom (Ami 1): ")
# Créer une instance de la classe Ami1 avec l'adresse du serveur, le port et
le nom d'utilisateur
ami1 = Ami1('localhost', 12345, username)
# Démarrer la communication
[Link]()
exemple d’exécution :
7
Conclusion
Ce programme est une introduction efficace `a la communication r´eseau avec
Python. Il peut servir de base pour d´evelopper des applications de messagerie
plus complexes.
Présentation du 2éme Programme : Gestion de boutique
Introduction :
Le code Python de gestion de boutique permet de simuler les principales
opérations d'une boutique en ligne, telles que la gestion des produits, la gestion
des clients et le suivi des commandes. Il utilise des classes pour modéliser les
entités principales : Produit, Boutique, Client, et Commande. La boutique peut
ajouter des produits, afficher les produits disponibles et mettre à jour le stock.
Les clients peuvent ajouter des produits à leur panier, afficher le contenu de leur
panier, et passer des commandes. Le système calcule automatiquement le total
des commandes et permet de vider le panier après validation. Ce programme
utilise une structure logique avec des boucles et des menus interactifs, rendant la
gestion de la boutique intuitive et fonctionnelle.
Le code :
class Produit:
def __init__(self,nom,prix,stock):#c'est un constructeur en python qui
initialise les attributs d'un objet avec des valeurs spécifiques lors de sa
création
[Link]=nom
[Link]=prix
[Link]=stock
def __str__(self):#c'est de fournir une représentation lisible et
compréhensible d'un objet sous forme de chaîne de caractères
return f"les informations de produit sont :
{[Link]},{[Link]}DH,{[Link]}"
class Boutique:
def __init__(self):
[Link]=[]
def ajouter_produit(self,produit):
8
[Link](produit)#Ajouter un element a la fin de la liste
[Link]
print(f"produit '{[Link]}' est ajouté avec succés")
def afficher_produit(self):
if not [Link]:
print("Aucun produit n'est disponible dans la boutique")
else:
print("Produits disponibles :")
for produit in [Link]:
print(f"{produit}")
def trouver_produit(self,nom):
for produit in [Link] :
if [Link]()==[Link]():#c'est pour Vérifier si deux
chaînes de caractères sont identiques, en ignorant les différences entre
majuscules et minuscules.
return produit
return None
def mettre_a_jour_stock(self,nom,quantité):
produit=self.trouver_produit(nom)
if produit:
[Link]=[Link]+quantité
print(f"Le stock du produit {nom} est mis a jour a {[Link]}")
else:
print("produit introuvable")
class Client:
def __init__(self,nom):
[Link]=nom
[Link]=[]
def ajouter_au_panier(self,produit,quantité):
if [Link]>=quantité:
[Link]((produit,quantité))
[Link]=[Link]-quantité
print(f"{quantité} {[Link]} ajoutés au panier")
else:
print(f"stock épuisé pour {[Link]}")
def afficher_panier(self):
if not [Link]:
9
print("le panier est vide")
else:
print(f"le panier de {[Link]}:")
total=0
for produit,quantité in [Link]:
sous_total=[Link]*quantité
total=total+sous_total
print(f"-{quantité} {[Link]}")
print(f"{[Link]}DH/unité")
print(f"{sous_total}DH")
print(f"le totale du panier est :{total}DH")
def vider_le_panier(self):
[Link]()#c'est pour réinitialiser une liste à son état vide.
print(f"le panier de {[Link]} a été vidé")
class Commande:
def __init__(self,client):
[Link]=client
[Link]=[Link][:]#c'est pour Copier les articles du panier
d'un client dans une nouvelle liste appelée [Link]
[Link]=sum([Link]*quantité for produit,quantité in
[Link])#c'est pour calculer le total d'une commande en multipliant le prix
de chaque produit par sa quantité, puis en additionnant les résultats pour tous
les article
def afficher_commande(self):
print(f"Commande de {[Link]} :")
for produit, quantite in [Link]:
print(f"{quantite} {[Link]} ({[Link]}Dh/unité) ")
print(f"le total de la commande est : {[Link]} Dh")
def gestion_boutique():
boutique=Boutique()
print(" Gestion de la boutique ")
while True:
#1 pour ajouter un produit
#2 pour afficher les produit
#3 pour gerer un client
10
#4 pour quitter le site
choix=input("Veuiller saisir votre choix:")
if choix=="1":
nom=input("veuiller ajouter le nom du produit")
prix=float(input("Prix du produit en DH :"))
stock=int(input("le stock du produit est"))
produit=Produit(nom,prix,stock)
boutique.ajouter_produit(produit)
elif choix=="2":
boutique.afficher_produit()
elif choix=="3":
nom_client=input("le nom du client est :")
client=Client(nom_client)
while True :
#1 pour ajouter un produit au panier
#2 pour afficher le panier
#3 pour passer une commande
#4 pour retourner au menu principale
choix_client=input("veuiller saisir votre choix")
if choix_client=="1":
nom_produit=input("saisir le nom du produit que vous
souhaitez")
produit=boutique.trouver_produit(nom_produit)
if produit:
quantité=int(input("saisir la quantité que vous
souhaitez"))
client.ajouter_au_panier(produit,quantité)
else :
print("Produit introuvable")
elif choix_client=="2":
client.afficher_panier()
elif choix_client=="3":
commande=Commande(client)
commande.afficher_commande()
client.vider_le_panier()
elif choix_client=="4":
break
11
else:
print("choix invalide")
elif choix_client=="4":
break
else:
print("choix invalide")
gestion_boutique()
Exemple d’exécution :
12
Présentation du 3éme Programme : Gestion de contacts :
Introduction au Projet de Gestion de Contacts en Python
Le projet de gestion de contacts en Python vise à créer une application simple qui permet à
l'utilisateur d'ajouter, de consulter, de modifier et de supprimer des contacts. Cette application peut
être utilisée sur un téléphone Android ou un ordinateur, et elle utilise des fonctions de base de
Python pour manipuler des données sous forme de listes et de dictionnaires.
Objectif :
L'objectif principal de ce projet est de permettre à un utilisateur de gérer facilement une liste de
contacts. Chaque contact est associé à un nom, un numéro de téléphone, et un email facultatif.
L'utilisateur peut interagir avec le programme à travers un menu simple et intuitif, où il peut choisir
différentes options comme ajouter un nouveau contact, afficher la liste des contacts, ou supprimer
un contact existant.
Le code :
# Classe Contact pour stocker les informations d'un contact
class Contact:
def __init__(self, nom, numero, email=None):
[Link] = nom
[Link] = numero
[Link] = email
def __str__(self):
return f"Nom: {[Link]}, Numéro: {[Link]}, Email: {[Link] if
[Link] else 'No email'}"
# Classe GestionContacts pour gérer les contacts
class GestionContacts:
def __init__(self):
[Link] = [] # Liste pour stocker les contacts
13
# Fonction pour ajouter un contact
def ajouter_contact(self):
nom = input("Entrez le nom du contact : ")
numero = input("Entrez le numéro de téléphone : ")
email = input("Entrez l'email (facultatif, appuyez sur Entrée pour
ignorer) : ")
if not email:
email = None
# Créer une instance de Contact et l'ajouter à la liste
contact = Contact(nom, numero, email)
[Link](contact)
print(f"Contact ajouté : {[Link]}")
# Fonction pour afficher tous les contacts
def afficher_contacts(self):
if [Link]:
for contact in [Link]:
print(contact) # Afficher l'objet Contact, ce qui appelle la
méthode _str_
else:
print("Aucun contact trouvé.")
# Fonction pour supprimer un contact par nom
def supprimer_contact(self):
nom = input("Entrez le nom du contact à supprimer : ")
# Filtrer la liste des contacts pour supprimer celui dont le nom
correspond
[Link] = [contact for contact in [Link] if
[Link]() != [Link]()]
print(f"Contact '{nom}' supprimé s'il existait.")
# Fonction pour afficher le menu et gérer les actions
def menu():
gestion_contacts = GestionContacts() # Créer une instance de GestionContacts
while True:
# Afficher les options du menu
14
print("\n--- Gestion des contacts ---")
print("1. Ajouter un contact")
print("2. Afficher les contacts")
print("3. Supprimer un contact")
print("4. Quitter")
# Demander à l'utilisateur de choisir une option
choix = input("Choisissez une option (1-4) : ")
# Lancer les actions en fonction du choix de l'utilisateur
if choix == "1":
gestion_contacts.ajouter_contact()
elif choix == "2":
gestion_contacts.afficher_contacts()
elif choix == "3":
gestion_contacts.supprimer_contact()
elif choix == "4":
print("Au revoir !")
break # Quitter la boucle et terminer le programme
else:
print("Choix invalide, essayez à nouveau.")
# Lancer le programme en appelant la fonction du menu
menu()
Exemple d’exécution :
15
Présentation du 4éme Programme : Zoo :
Le concept du code du zoo repose sur l'utilisation de la programmation orientée
objet (POO) pour modéliser différents types d'animaux dans un zoo. Une classe
parente Animal définit des attributs communs à tous les animaux, tels que le nom
et l'âge, ainsi qu'une méthode pour afficher les informations de base et une
méthode abstraite pour produire un cri. Des sous-classes spécifiques comme
Lion, Eléphant et Zébra héritent de la classe Animal et redéfinissent la méthode
du cri pour chaque type d'animal, tout en ajoutant des attributs uniques, comme
la couleur de la crinière pour le lion ou la taille des oreilles pour l'éléphant. Le
programme permet ainsi de gérer une collection d'animaux dans un zoo, en
offrant des fonctionnalités comme l'affichage des informations sur chaque animal
et la simulation des bruits qu'ils font. Cela montre l'utilisation de l'héritage et du
polymorphisme pour créer un système flexible et extensible
16
Le code :
class Animal:
def __init__(self,nom,age):
[Link]=nom
[Link]=age
def afficher_info(self):
print(f"les information de cet animal sont : {[Link]};{[Link]} ans")
def faire_crier(self):# Cette méthode sera redéfinie dans les sous-classes
pass
class Lion(Animal):
def __init__(self, nom, age,couleur_name):
super().__init__(nom, age)
self.couleur_name=couleur_name
def afficher_info(self):
super().afficher_info()
print(f"couleur de la criniére :{self.couleur_name}")
def faire_crier(self):
print(f"{[Link]} rugit : ROAAR")
class Elephant(Animal):
def __init__(self, nom, age,taille_oreille):
super().__init__(nom, age)
self.taille_oreille=taille_oreille
def afficher_info(self):
super().afficher_info()
print(f"la taille des oreilles est : {self.taille_oreille} ")
def faire_crier(self):
print(f"{[Link]} barrit : PAAHH")
class Zebre(Animal):
def __init__(self, nom, age,nbr_raye):
super().__init__(nom, age)
self.nbr_raye=nbr_raye
def afficher_info(self):
super().afficher_info()
print(f"le nombre des raye est : {self.nbr_raye}")
def faire_crier(self):
print(f"{[Link]} hennit :Iiiihhhaa")
def afficher_animaux(zoo):
17
for animal in zoo:
animal.afficher_info()
animal.faire_crier()
lion=Lion("Simba",5,"Doré")
elephant=Elephant("dumbo",10,150)
zebre=Zebre("Zorro",3,42)
zoo=[lion,elephant,zebre]
afficher_animaux(zoo)
Exemple d’exécution :
Présentation du 4éme Programme :jeux devinette :
Le code :
import random
class Jeu:
def __init__(self,joueur):
[Link]=joueur
class Joueur:
def __init__(self,nom):
[Link]=nom
class JeuDevinette(Jeu):
def __init__(self, joueur,valeur_min,valeur_max):
18
super().__init__(joueur)#on utilise supper pour accéder aux méthodes ou
attributs définis dans la classe parente. Ici, elle appelle __init__ de la classe
Jeu
#super().__init__(joueur), transmet l'argument joueur au constructeur de
la classe parente pour initialiser l'attribut [Link].
self.valeur_min=valeur_min
self.valeur_max=valeur_max
self.nombre_a_deviner=[Link](self.valeur_min,self.valeur_max)
def jouer(self):
print(f"Bienvenue {[Link]} dans notre jeu ")
print(f"Veuiller deviner un nombre entre {self.valeur_min} et
{self.valeur_max}")
n=0
while True:
try:
nbr_proposé=int(input("Veuiller saisir votre proposition"))
n=n+1
if nbr_proposé<self.nombre_a_deviner:
print("Trop bas essayez encore")
elif nbr_proposé>self.nombre_a_deviner:
print("trop haut essayez encore")
else:
print(f"Bravo {[Link]} vous avez devinez le nombre
{self.nombre_a_deviner} en {n} essaies")
break
except ValueError:#c'est pour gérer les erreurs potentielles qui
peuvent survenir lorsque l'utilisateur saisit une valeur non valide
print("Veuiller saisir une syntaxe validé")
#lancement du jeu
if __name__=="__main__":#c'est pour indiquer que le script est exécuté en tant que
programme principal, et non importé comme module dans un autre script.
print("Bienvenu au jeu devinnete")
nom_joueur=input("veuiller saisir votre nom")
joueur=Joueur(nom_joueur)
jeu=JeuDevinette(joueur,1,1000)
[Link]()
19
Exemple d’exécution :
20
