Simulation du fonctionnement d'une banque

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Personne():
    """
    Modélisation d'une personne.

    Attributs
    ---------
    - nom : str
        Renseigné à la création de l'objet
    - Prenom : str
        Renseigné à la création de l'objet
    - email : str
        Email. Initialisé à ""
    - telephone : str
        Numéro de téléphone. Initialisé à ""
    - date_naissance : str
        Chaîne de caractères au format jour/mois/année (4 chiffres). Initialisé à ""
    - jour_naissance : int
        Déterminé à partir de la date de naissance. Initialisée à -1
    - mois_naissance : int
        Déterminé à partir de la date de naissance. Initialisée à -1
    - annee_naissance : int
        Déterminé à partir de la date de naissance. Initialisée à -1
    """

1
2
3
4

def __init__(self, nom: str, prenom: str) -> None:
    """
    Initialisation des attributs.
    """

1
2
3
4

def modifier_nom(self, nom: str) -> None:
        """
        Permet de modifier le nom de la personne.
        """

1
2
3
4

def obtenir_nom(self) -> str:
        """
        Retourne le nom de la personne.
        """

1
2
3
4

def modifier_prenom(self, prenom: str) -> None:
        """
        Permet de modifier le prénom de la personne.
        """

1
2
3
4

def obtenir_prenom(self) -> str:
        """
        Retourne le prénom de la personne.
        """

1
2
3
4

def obtenir_email(self) -> str:
        """
        Retourne l'email de la personne.
        """

1
2
3
4

def renseigner_email(self, email: str) -> None:
        """
        Renseigne l'attribut email de la personne.
        """

1
2
3
4

def obtenir_telephone(self) -> str:
        """
        Retourne le numéro de téléphone de la personne.
        """

1
2
3
4

def renseigner_telephone(self, telephone: str) -> None:
        """
        Renseigne l'attribut telephone de la personne.
        """

1
2
3
4
5
6
7
8

def renseigner_date_naissance(self, date: str) -> None:
        """
        Récupère la date de naissance sous la forme jour/mois/année.
        Renseigne l'attribut date_naissance et, après un traitement, les attributs
        jour_naissance, mois_naissance, annee_naissance.
        
        Lève une exception de type ValueError si l'année ne possède pas le bon format.
        """

1
2
3
4

def obtenir_date_naissance(self) -> str:
        """
        Retourne la date de naissance.
        """

1
2
3
4
5
6

def obtenir_age(self, annee_en_cours: int) -> int:
        """
        Retourne l'age de la personne à partir de l'année en cours.

        Lève une exception de type Exception si la date de naissance n'a pas été renseignée au préalable.
        """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

def infos(self) -> str:
        """
        Retourne toutes les informations relatives à la personne.
        """

        chaine = """
        Prénom : {}
        Nom : {}
        Date de naissance : {}
        Email : {}
        Téléphone : {}
        """.format(self.obtenir_prenom(), self.obtenir_nom(),
                   self.obtenir_date_naissance(), self.obtenir_email(),
                   self.obtenir_telephone())

        return chaine

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Compte_bancaire():
    """
    Définition d'un compte bancaire.

    Attributs
    ---------
    - proprietaire : Personne
        Personne propriétaire du compte. Initialisé à la création de l'objet.
    - identifiant : int
        Identifiant unique du compte. Initialisé à la création de l'objet par un calcul réalisé par une méthode statique.
    - solde : float
        Solde du compte. Initialisé à la création de l'objet.

1
2
3
4

def __init__(self, proprietaire: Personne, montant_initial: float) -> None:
    """
    Initialisation des attributs.
    """

1
2
3
4
5
6
7
8

@staticmethod
def determine_id(proprietaire: Personne) -> int:
    """
    Détermine l'identifiant du compte aléatoirement à partir du
    nom et du prénom du propriétaire.

    Méthode statique
    """

1
2
3
4

def obtenir_solde(self) -> float:
    """
    Retourne le solde du compte.
    """

1
2
3
4

def depot(self, montant: float) -> None:
    """
    Ajoute montant au solde
    """

1
2
3
4
5

def retrait(self, montant: float) -> None:
    """
    Retire le montant montant du solde à la condition qu'il y ait suffisamment d'argent.
    Une exception de type ValueError est levée si le montant est trop important
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def infos(self) -> str:
    """
    Informations sur le compte.
    """
    chaine = """
    Compte numéro : {}
    Solde : {}
    """.format(self.identifiant, self.solde)

    chaine = chaine + self.proprietaire.infos()

    return chaine

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Banque():
    """
    Modélisation d'une banque.

    Attributs
    ---------
    - nom : str
        Nom de la banque. Initialisé lors de la création de l'objet.
    - comptes : Liste[Compte_bancaire]
        Liste des comptes bancaires au sein de la banque.
    """

1
2
3
4

def __init__(self, nom: str) -> None:
    """
    Initialisation de l'objet
    """

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

def creation_compte(self) -> None:
    """
    Prend en charge l'ouverture d'un compte au sein de la banque.
    """
    print("Procédure de création du compte :")
    print("---------------------------------")

    nom = input("Nom du propriétaire du compte : ")
    prenom = input("Prenom du propriétaire du compte : ")
    montant_initial = float(input("Montant du dépôt initial : "))

    p = Personne(nom, prenom)
    c = Compte_bancaire(p, montant_initial)

    self.comptes.append(c)

def infos(self) -> str:
    """
    Informations sur la banque
    """
    chaine = """
    -----------
    """

    for compte in self.comptes:
        chaine = chaine + compte.infos()
        chaine = """
        -----------
        
        """
    
    return chaine