Code python

Code Python

Animaux

class Animal:
    def __init__(self, tete, corps, membres, habitat=None):

        # Composition
        if not isinstance(tete, Tete):
            raise ValueError("tete doit être une instance de la classe Tete")
        self.tete = tete

        # Composition
        if not isinstance(corps, Corps):
            raise ValueError("corps doit être une instance de la classe Corps")
        self.corps = corps

        # Composition
        if not isinstance(membres, list) or not all(isinstance(membre, Membres) for membre in membres):
            raise ValueError("membres doit être une liste d'instances de la classe Membres")
        self.membres = membres

        # Association
        if habitat is not None and not isinstance(habitat, Habitat):
            raise ValueError("habitat doit être une instance de la classe Habitat ou None")
        self.habitat = habitat

    def __str__(self):
        membres_str = ", ".join(str(membre) for membre in self.membres)
        return (f"{self.__class__.__name__} (Habitat: {self.habitat}, "
                f"Tête: {self.tete}, Corps: {self.corps}, Membres: [{membres_str}])")


class Herbivore(Animal):
    def __init__(self, tete, corps, membres, habitat=None, alimentation="herbivore"):
        super().__init__(tete, corps, membres, habitat)
        self.alimentation = alimentation

    def __str__(self):
        return f"{super().__str__()} - Alimentation: {self.alimentation}"


class Carnivore(Animal):
    def __init__(self, tete, corps, membres, habitat=None, alimentation="carnivore"):
        super().__init__(tete, corps, membres, habitat)
        self.alimentation = alimentation

    def __str__(self):
        return f"{super().__str__()} - Alimentation: {self.alimentation}"

class Tete:
    def __init__(self, forme, taille):
        self.forme = forme
        self.taille = taille

    def __str__(self):
        return f"Tête (Forme: {self.forme}, Taille: {self.taille})"


class Corps:
    def __init__(self, type, couleur):
        self.type = type
        self.couleur = couleur

    def __str__(self):
        return f"Corps (Type: {self.type}, Couleur: {self.couleur})"


class Membres:
    def __init__(self, nombre, fonction):
        self.nombre = nombre
        self.fonction = fonction

    def __str__(self):
        return f"Membres (Nombre: {self.nombre}, Fonction: {self.fonction})"


class Habitat:
    def __init__(self, type, localisation):
        self.type = type
        self.localisation = localisation

    def __str__(self):
        return f"Habitat (Type: {self.type}, Localisation: {self.localisation})"

Classe

from typing import List

class Dossier:
    def __init__(self, nom: str, prenom: str, date_naissance: str, adresse: str, telephone: str, email: str):
        self.nom = nom
        self.prenom = prenom
        self.date_naissance = date_naissance
        self.adresse = adresse
        self.telephone = telephone
        self.email = email

    def __str__(self):
        return (f"{self.prenom} {self.nom}, Né(e) le {self.date_naissance}\n"
                f"Adresse: {self.adresse}, Téléphone: {self.telephone}, Email: {self.email}")


class Personne:
    def __init__(self, dossier: Dossier):
        self.dossier = dossier  # Association : la Personne a un Dossier, mais n'en est pas responsable.

    def __str__(self):
        return str(self.dossier)


class Professeur(Personne):
    def __init__(self, dossier: Dossier, matiere: str):
        super().__init__(dossier)  # Héritage de Personne
        self.matiere = matiere

    def __str__(self):
        return f"Professeur de {self.matiere} : {super().__str__()}"


class Eleve(Personne):
    def __init__(self, dossier: Dossier, niveau: str):
        super().__init__(dossier)  # Héritage de Personne
        self.niveau = niveau

    def __str__(self):
        return f"Élève (Niveau: {self.niveau}) : {super().__str__()}"


class Classe:
    def __init__(self, professeur: Professeur, nom_classe: str):
        self.professeur = professeur  # Agrégation
        self.nom_classe = nom_classe
        self.eleves: List[Eleve] = []  # Agrégation

    def ajouter_eleve(self, eleve: Eleve):
        """Ajoute un élève à la classe si elle n'est pas pleine."""
        if len(self.eleves) < 30:
            self.eleves.append(eleve)
        else:
            print("La classe est déjà pleine, impossible d'ajouter cet élève.")

    def afficher_classe(self):
        """Affiche les informations de la classe, du professeur, et des élèves."""
        print(f"Classe : {self.nom_classe}")
        print(f"Professeur : {self.professeur}")
        print("Élèves :")
        for eleve in self.eleves:
            print(eleve)

Email

from typing import List


class AdresseEmail:
    def __init__(self, adresse: str):
        self.adresse = adresse
        if not self.est_valide():
            raise ValueError(f"Adresse email invalide : {adresse}")

    def est_valide(self) -> bool:
        # Validation simple du format de l'adresse email
        return re.match(r"[^@]+@[^@]+\.[^@]+", self.adresse) is not None


class TexteEmail:
    def __init__(self, titre: str, corps: str):
        # Maintenant, titre et corps sont obligatoires
        self.titre = titre
        self.corps = corps


class FichierJoint:
    def __init__(self, nom: str, contenu: bytes):
        self.nom = nom
        self.contenu = contenu

    def __str__(self):
        return f"Fichier Joint: {self.nom}"


class Email:
    def __init__(
            self,
            expediteur: str,
            destinataire: str,
            titre: str,
            corps: str,
            fichiers: List[FichierJoint] = None  # Fichiers joints sont optionnels
    ):
        # Composition
        self.expediteur = AdresseEmail(expediteur)
        self.destinataire = AdresseEmail(destinataire)

        # Composition
        self.texte = TexteEmail(titre, corps)

        # Composition (Les fichiers sont optionnels)
        self.fichiers = fichiers if fichiers is not None else []

    def envoyer(self):
        print(f"Envoi de l'email de {self.expediteur.adresse} à {self.destinataire.adresse}")
        print(f"Titre: {self.texte.titre}")
        print(f"Corps: {self.texte.corps}")
        if self.fichiers:
            print(f"Fichiers joints: {[f.nom for f in self.fichiers]}")