Programmation Orienté Objet python

Signaler
-
 JASON -
Bonjour,

Je viens par la présente vous demandez de l'aide concernant cet exercice que j'ai bien commencé mais à la fin je bug complètement. C'est un exercice ou il faut compléter les commentaires(apres #).
Voici l'exercice en question:
Dans ce travail, vous devez implémenter les classes: Personne, Etudiant, Employe et Gestion. Le programme principal est déjà implémenté dans le fichier. Vous devez donc compléter toutes les classes.

Classe Personne La classe Personne comprendra les attributs suivants : - nom est une chaine de caractères. - prénom est une chaine de caractères. - identifiant est un nombre entier.

Cette classe dispose les méthodes suivantes : - La méthode __init__() doit initialiser le nom d’un objet de type classe Personne, son prénom et son identifiant. Cette fonction prend en entrée un nom, un prénom de type chaine de caractères et un identifiant de type entier. - La méthode _repr_() doit retourner une chaine de caractères qui contient tous les informations d’une personne. - La méthode _eq_() doit vérifier si deux personnes sont identiques (le même nom, le même prénom et le même identifiant). Cette fonction elle prend en entrée un objet de type Personne et retourne True si les deux personnes sont identiques et False sinon.



Classe Employe La classe Employe dérive de la classe Personne. Cette classe comprendra les attributs suivants : - tauxHoraire est un nombre réel. Cette classe dispose les méthodes suivantes : - La méthode __init__() doit initialiser un objet de type Employe. Cette fonction prend en entrée un nom, un prénom de type chaine de caractères, un identifiant de type entier et un taux de type réel. - La méthode _repr_() doit retourner une chaine de caractères qui contient tous les informations d’un employé. - La méthode calculerSalaire()doit retourner le salaire d’un employé. Elle prend en paramètre le nombre des heures (un nombre entier). Le salaire égale le nombre des heures multiplié par le taux horaire.

Classe Etudiant La classe Etudiant dérive de la classe Personne. Cette classe comprendra les attributs suivants : - solde est un nombre réel (présente le solde à payer pour les frais de scolarité). - cours est une liste de cours (une liste de chaine de caractères). Cette classe dispose les méthodes suivantes : - La méthode __init__() doit initialiser un objet de type Etudiant. Cette fonction prend en entrée un nom, un prénom de type chaine de caractères, un identifiant de type entier, un solde de type réel et une liste de cours. La liste de cours doit être initialisée à une liste de chaine de caractères vide. - La méthode _repr_() doit retourner une chaine de caractères qui contient toutes les informations d’un étudiant. Pour la liste de cours, ajouter seulement le nombre de cours dans la chaine de caractères. - La méthode ajouterCours()doit ajouter un cours dans la liste de cours. Elle prend en paramètre le nom de cours (une chaine de caractères). Un étudiant peut ajouter un cours seulement si il n’a aucun solde à payer (la valeur de solde est égale à zéro). Cette fonction retourne True si le cours a été ajouté dans la liste de cours et False sinon.

Classe Gestion La classe Gestion permet de gérer la liste des étudiants et des employés. Cette classe comprendra deux atributs (statiques) : - Une liste des étudiants listEtudiant. - Une liste des employés listEmploye.

Cette classe ne comprend pas aucuns attributs. Cette classe dispose les méthodes suivantes : - La méthode ajouterEtudiant(). Cette fonction ne prend aucun paramètre en entrée. Elle permet de demander à l’utilisateur les informations pour l’étudiant à ajouter. Par la suite, elle doit demander à l’utilisateur d’entrer un choix : si l’utilisateur veut ajouter un cours (le choix de l’utilisateur doit être oui ou non, sinon afficher un message approprié). Avant d’ajouter l’étudiant, il faut vérifier qu’il n’existe pas dans la liste. Cette fonction elle doit retourner True si l’étudiant a été ajouté et False sinon. - La méthode ajouterEmploye(). Cette fonction ne prend aucun paramètre en entrée. Elle permet de demander à l’utilisateur les informations pour l’employé à ajouter. Avant d’ajouter
l’employé, il faut vérifier qu’il n’existe pas dans la liste. Cette fonction elle doit retourner True si l’employé a été ajouté et False sinon. - La méthode soldeNonPaye(). Cette fonction ne prend aucun paramètre en entrée. Elle permet de calculer et retourner le nombre des étudiants qui ont un solde non payé. - La méthode salaireEmploye(). Cette fonction prend en entrée un employé et le nombre des heures travaillées. Elle permet de calculer et retourner le salaire d’un employé. Si l’employé n’existe pas dans la liste, le salaire est égal à zéro.


voici le code que j'ai fais mais j'ai pas pu terminer:
class Personne:
    '''represente une classe Personne'''
    def __init__(self, nom, prenom, identifiant):
        '''(str,str, int)->None
        initialise les attributs de la classe Personne'''
        self.nom = nom
        self.prenom = prenom
        self.identifiant = identifiant

    def __repr__(self):
        '''(Personne)->str
        retourne une representation de l'objet'''
         return "nom: " + str(self.x) + "prenom: " + str(self.prenom) + "identifiant: " + int(self.identifiant)

    def __eq__(self, autre):
        '''(Personne, Personne)->bool
        self == autre si le nom et le prenom sont les memes'''
        return self.nom == autre.nom and self.prenom == autre.prenom and self.identifiant == autre.identifiant

class Etudiant(Personne):
    '''represente une classe Etudiant'''
     def __init__(self ,nom ,prenom ,identifiant, tauxHoraire):
        Personne.__init__(nom, prenom, identifiant)
        self.tauxHoraire = tauxHoraire

    def __repr__(self):
        '''(Employe)->str
        retourne les informations d'un employé'''
        return "nom: " + str(self.nom) + "prenom: " + str(self.prenom) + "identifiant: " + int(self.identifiant) + "tauxHoraire: " + float(self.tauxHoraire)

    def calculerSalaire(self,nbre):
        '''(int,float)->float
        retourne le salaire d'un employé
        '''
        return "Salaire: " + int(self.nbre)*float(self.tauxHoraire)
    

class Employe(Personne):
    '''represente un employe'''
    # tauxHoraire est un attribut de la classe Employe
    
    # methodes

    # A completer


class Gestion:
 listEtudiant = []
 listEmploye = []
 def ajouterEtudiant(self):
    ''' none -> bool
    ajouter des etudiants dans une liste d'etudiant'''
    # Completer

 def ajouterEmploye(self):
    ''' none -> bool
    ajouter des etudiants dans une liste d'etudiant'''
    # Completer
 def SoldeNonPaye(self):
    ''' none -> int
    retourner le nombre des etudiants qui ont un solde non paye'''
    # Completer

 def salaireInd(self, employe, heures):
    '''(str) -> float
    retourne le salaire d'un employe'''
    # Completer


#program principal
g = Gestion()
print("Ajoutez des etudiants.")
# Ajouter des etudiants
g.ajouterEtudiant()
g.ajouterEtudiant()

# Ajouter des employes
print("Ajouter des employes.")
g.ajouterEmploye()
g.ajouterEmploye()
#g.ajouterEmployes()

# Afficher le nombre des employes et des etudiants
print("il y a: ", len(Gestion.listEtudiant), " etudiants.")
print("il y a: ", len(Gestion.listEmploye), " employes.")
# Afficher le nombre des etudiants qui ont un solde a payer
print("il y a ", g.SoldeNonPaye(), "etudiants qui n'ont pas paye leur solde.")
# Afficher les salaires de tous les employes
for e in Gestion.listEmploye:
    heure = int(input("Entrez le nombre des heures pour employe " + e.prenom + " " + e.nom + " "))
    print('Le salaire de:', e.nom, e.prenom, 'est:', g.salaireInd(e, heure), '$.')

#Afficher toute la Gestion
print("Toute la gestion: ")
print(Gestion.listEtudiant)
print(Gestion.listEmploye)







Configuration: Windows / Edge 18.17763

12 réponses

Bonjour,

Dans Personne.__repr__
- Il est inutile de convertir chaque valeur par leur propre type, ça ne sert à rien du tout.
- self.x n'existe pas.
- Plutôt que d'une concaténation de chaînes, sers-toi de format
return 'nom: {}, prenom: {}, identifiant: {}'.format(self.nom, self.prenom, self.identifiant)


Tu t'es bien mélangé les pinceaux entre Etudiant et Employe, vu que le 5ème argument de l'__init__de Etudiant dans ton code est celui que tu dois définir dans la classe Employe et qu'il y a une méthode calculerSalaire, alors le nom de cette classe doit être Employe et pas Etudiant.

Dans Etudiant.__repr__, self.nbre n'existe pas, c'est nbre (argument de la méthode).

Dans les méthodes ajouterEmploye, ajouterEtudiant de Gestion, tu dois simplement utiliser des input pour demander les valeurs nécessaires à l'instanciation des classes Etudiant et Employe.
Donc pour ajouter un employe, tu dois demander la saisie de 4 valeurs pour pouvoir définir un employé.

Personnellement je trouve la classe Gestion complètement stupide, je ne vois pas pourquoi on devrait gérer étudiants et employés dans cette même classe et y ajouter des méthodes spécifiques à chacune de ces types d'objets.
Pareil pour les identifiants, cela devrait être créé automatiquement par les classes Etudiant et Employé en utilisant une variable de classe, car on peut très bien avoir 2 employés portant même nom et prénom, la seule chose qui les distinguera est donc leur identifiant ce qui fait que Employe.__eq__ n'a pas vraiment de sens.
Bonjour trifou,

j'ai pris le temps de temps d'essayer de comprendre ta méthode mais jusque là je m'égare toujours.

1. Pourquoi la méthode _eq_ne sert à rien?
2.Dans la classe eTUDIANT comment je suis sensé procéder pour AJOUTER la méthode ajoutercours() ?
3. En ce qui concerne la classe gestion c'est encore pire.je suis perdu

Je sais que je t'en demande trop mais Le problème est que je dois soumettre cet exercice au plus tard demain.

Vu qu'il me manque de temps Je te serais vraiment reconnaissant si tu me donnes la solution et après je vais essayer de comprendre ou j'ai raté.
Bonjour,

J'ai un probleme a executé mon code. Quelqu'un peut il m'aider à irremedier.

Merci
class Personne:
    '''represente une classe Personne'''
    def __init__(self, nom, prenom, identifiant):
        '''(str,str, int)->None
        initialise les attributs de la classe Personne'''
        self.nom = nom
        self.prenom = prenom
        self.identifiant = identifiant

    def __repr__(self):
        '''(Personne)->str
        retourne une representation de l'objet'''
        s = 'nom: {}, prénom: {}, identifiant: {}'
        return s.format(self.nom, self.prenom, self.identifiant)
    
    def __eq__(self, autre):
        '''(Personne, Personne)->bool
        self == autre si le nom et le prenom sont les memes'''
        return self.nom == autre.nom and self.prenom == autre.prenom and self.identifiant == autre.identifiant


class Etudiant(Personne):
    '''represente une classe Etudiant'''
    __id = 0
    def __init__(self, nom, prenom,Etudiant._id, solde, cours):
        Etudiant.__id += 1
        super().__init__(nom, prenom, Etudiant.__id)
        self.solde = solde
        self.cours = cours

    def __repr__(self):
        s = '{}, solde: {}, cours: {}'
        return s.format(super().__repr__(), self.solde, self.cours)

    def ajouterCours(self,nom_cours):
        if (solde != 0):
            nom_cours.append(cours)
            return True
        return False

class Employe(Personne):
    '''represente un employe'''
    def __init__(self ,nom ,prenom ,identifiant, tauxHoraire):
        Personne.__init__(nom, prenom, identifiant)
        self.tauxHoraire = tauxHoraire

    def __repr__(self):
        '''(Employe)->str
        retourne les informations d'un employé'''
        return "nom: " + str(self.nom) + "prenom: " + str(self.prenom) + "identifiant: " + int(self.identifiant) + "tauxHoraire: " + float(self.tauxHoraire)

    def calculerSalaire(self,nbre):
        '''(int,float)->float
        retourne le salaire d'un employé
        '''
        return "Salaire: " + int(self.nbre)*float(self.tauxHoraire)



class Gestion:
    listEtudiant = []
    listEmploye = []
    def ajouterEtudiant(self):
        ''' none -> bool
        ajouter des etudiants dans une liste d'etudiant'''
        nom = input("Nom de l'étudiant : ")
        prenom = input("Prénom de l'étudiant : ")
        solde = input("Solde de l'étudiant : ")
        cours = input("Cours de l'étudiant : ")
        etudiant = Etudiant(nom, prenom, solde, cours)
        self.listEtudiant.append(etudiant)


    def ajouterEmploye(self):
        ''' none -> bool
        ajouter des etudiants dans une liste d'employés'''
        nom = input("Nom de l'employé : ")
        prenom = input("Prénom de l'employé : ")
        tauxHoraire = input("TauxHoraire de l'employé : ")
        employe = Employe(nom, prenom, tauxHoraire)
        self.listEmploye.append(employe)
        


    def SoldeNonPaye(self):
        ''' none -> int
        retourner le nombre des etudiants qui ont un solde non paye'''
        return sum(1 for etu in self.listEtudiant if etu.solde != 0)


    def salaireInd(self, employe, heures):
        '''(str) -> float
        retourne le salaire d'un employe'''
        salaire = heures * tauxHoraire
        if employe != listEmploye:
            salaire = 0
        else:
            return salaire
        
        


#program principal
gestion = Gestion()
print("Ajoutez des etudiants.")
# Ajouter des etudiants
gestion.ajouterEtudiant()
gestion.ajouterEtudiant()

# Ajouter des employes
# print("Ajouter des employes.")
# g.ajouterEmploye()
# g.ajouterEmploye()
# g.ajouterEmployes()

# Afficher le nombre des employes et des etudiants
print("il y a: ", len(gestion.listEtudiant), " etudiants.")
print("il y a: ", len(gestion.listEmploye), " employes.")
# Afficher le nombre des etudiants qui ont un solde a payer
print("il y a ", gestion.SoldeNonPaye(), "etudiants qui n'ont pas paye leur solde.")
# Afficher les salaires de tous les employes
"""
for e in Gestion.listEmploye:
    heure = int(input("Entrez le nombre des heures pour employe " + e.prenom + " " + e.nom + " "))
    print('Le salaire de:', e.nom, e.prenom, 'est:', g.salaireInd(e, heure), '$.')
"""
#Afficher toute la Gestion
print("Toute la gestion: ")
print("Etudiants :")
for etudiant in gestion.listEtudiant:
    print(etudiant)

# print(Gestion.listEmploye)

Voici un exemple de output:

Ajoutez des etudiants.
Entrez le nom M.
Entrez le prenom Jean
Entrez votre identifiant 100
Entrez le solde 0
Entrez une liste de cours separe par des virgules c1,c2
Veux-tu ajouter un autre cours? oui
Entrez le cours a ajouter c3
Le cours a ete ajoute.
Etudiant ajoute avec succes.
Entrez le nom SSS
Entrez le prenom Marie
Entrez votre identifiant 101
Entrez le solde 200
Entrez une liste de cours separe par des virgules c2,c3
Veux-tu ajouter un autre cours? oui
Entrez le cours a ajouter c4
Vous devez payer votre solde avant d'ajouter un cours.
Etudiant ajoute avec succes.
Ajouter des employes.
Entrez le nom AAA
Entrez le prenom Luc
Entrez votre identifiant 102
Entrez le taux horaire 30
Employe ajoute avec succes.
Entrez le nom BBB
Entrez le prenom Ana
Entrez votre identifiant 105
Entrez le taux horaire 40
Employe ajoute avec succes.
il y a: 2 etudiants.
il y a: 2 employes.
il y a 1 etudiants qui n'ont pas paye leur solde.
Entrez le nombre des heures pour employe Luc AAA 40
Le salaire de: AAA Luc est: 1200.0 $.
Entrez le nombre des heures pour employe Ana BBB 100
Le salaire de: BBB Ana est: 4000.0 $.
[Nom:M., Prenom:Jean, Identifiant:100, Solde a payer: 0, Liste de cours: c1 c2 c3, Nom:SSS, Prenom:Marie, Identifiant:101, Solde a payer: 200, Liste de cours: c2 c3]
[Nom:AAA, Prenom:Luc, Identifiant:102, taux Horaire: 30.0, Nom:BBB, Prenom:Ana, Identifiant:105, taux Horaire: 40.0]
Bonsoir,

__eq__ ne sert à rien car on a juste besoin de comparer les identifiants, on se fiche de savoir si les noms, prénoms sont identiques ou différents.

La programmation, c'est de la logique, je t'ai donné une base d'exemple, faudrait quand même un peu réfléchir, typer les variables correctement, si solde doit être un entier, alors avant de passer cette variable au constructeur, il faut la convertir en entier, si les cours doivent être enregistrés dans une liste, alors il faut séparer chaque cours donnés par la virgule, ça, tu as dû le voir en cours.

Ceci

def salaireInd(self, employe, heures):
        '''(str) -> float
        retourne le salaire d'un employe'''
        salaire = heures * tauxHoraire
        if employe != listEmploye:
            salaire = 0
        else:
            return salaire


Tu trouves que employe != listEmploye à un sens quelconque ? Tu compares une bille avec un sac de billes, et d'ailleurs pourquoi faire ce test ? L'employé est donné en paramètre de la méthode, donc tu as juste à renvoyer le résultat du calcul sans te préoccuper d'autre chose.

De toute façon, je ne comprends même pas à quoi sert cette méthode, dans ton 1er post on a :

Dans Employe, la méthode

def calculerSalaire(self,nbre):
        '''(int,float)->float
        retourne le salaire d'un employé
        '''


Dans Gestion, la méthode :

 def salaireInd(self, employe, heures):
    '''(str) -> float
    retourne le salaire d'un employe'''
    # Completer


A quoi sert donc cette méthode Gestion.salaireInd ?

L'objet employé on le connaît donc pas besoin de cette méthode puisqu'on peut directement appeler employe.calculerSalaire

Alors je ne sais pas si le modèle des classes a été fourni par ton prof, mais si c'est le cas, c'est pas jojo.
Dans la classe gestion j'éssaye de séparer les cours mais ca donne pas:
def ajouterEtudiant(self):
        ''' none -> bool
        ajouter des etudiants dans une liste d'etudiant'''
        nom = input("Entrer le nom : ")
        prenom = input("Entrer le prénom : ")
        identifiant = int(input("Entrer votre identifiant:" ))
        solde = float(input("Entrer le solde : "))
        l1 = input("Entrer une liste de cours separées par des virgules : ")
        cours = list(eval(l1))
        print(cours)
        etudiant = Etudiant(nom, prenom, solde, cours)
        self.listEtudiant.append(etudiant)


    def ajouterEmploye(self):
        ''' none -> bool
        ajouter des etudiants dans une liste d'employés'''
        nom = input("Nom de l'employé : ")
        prenom = input("Prénom de l'employé : ")
        tauxHoraire = input("TauxHoraire de l'employé : ")
        employe = Employe(nom, prenom, tauxHoraire)
        self.listEmploye.append(employe)