Pour définir la nouvelle classe Compte, on utilise l'instruction class.

Une classe possède des fonctions que l'on appelle méthodes et des données que l'on appelle attributs.

Une méthode se définit de la même manière qu'une fonction (on commence par l'instruction def).

Une méthode possède au moins un paramètre qui s'appelle self.

Le paramètre self désigne toutes les instances qui seront créées par cette classe.

7 méthodes sont ainsi définies.

Un seul attribut d'instance est utilisé dans cette classe : solde (à ne pas confondre avec la méthode Solde()).

La méthode constructeur (méthode spéciale __init__()) est exécutée automatiquement lorsque l'on instancie (crée) un nouvel objet de la classe.

Deux autres méthodes spéciales sont utilisées : __add__() et __sub__().

L'écriture cb1+253.2 est équivalente à cb1.__add__(253.2)

L'opérateur + représente ici une addition sur le solde.

L'écriture cb1-1000 est équivalente à cb1.__sub__(1000)

L'opérateur - représente ici une soustraction sur le solde.

>>> cb1.NouveauSolde(500)
>>> print( cb1.Solde())
500.0
>>> cb1.__add__(1000)
Nouveau solde : +1500.00 euros
>>> cb1+2000	# cette écriture est très pratique !
Nouveau solde : +3500.00 euros
>>>

Ici, le module est exécuté en tant que programme principal : les instructions qui suivent sont donc exécutées.

Dans le cas où ce module est importé dans un autre programme, cette partie du code est sans effet.

Documentation

La fonction help() est très utile.

On comprend ici l'intérêt de bien documenter ses programmes avec les """docstrings""" :

>>> help(cb1)
Help on instance of Compte in module __main__:

class Compte
 |  Un exemple de classe :
 |  gestion d'un compte bancaire
 |
 |  Methods defined here:
 |
 |  Credit(self, somme)
 |      Crédite le compte de la valeur somme. Retourne le solde.
 |
 |  Debit(self, somme)
 |      Débite le compte de la valeur somme. Retourne le solde.
 |
 |  NouveauSolde(self, somme)
 |      Nouveau solde de compte avec la valeur somme.
 |
 |  Solde(self)
 |      Retourne le solde.
 |
 |  __add__(self, somme)
 |      x.__add__(somme) <=> x+somme
 |      Crédite le compte de la valeur somme.
 |      Affiche 'Nouveau solde : somme'
 |
 |  __init__(self, soldeInitial)
 |      Initialisation du compte avec la valeur soldeInitial.
 |
 |  __sub__(self, somme)
 |      x.__sub_(somme) <=> x-somme
 |      Débite le compte de la valeur somme.
 |      Affiche 'Nouveau solde : somme'
>>>

La fonction dir() retourne la liste des méthodes et attributs :

>>> dir(cb1)
['Credit', 'Debit', 'NouveauSolde', 'Solde', '__add__',
'__doc__', '__init__', '__module__', '__sub__', 'solde']

On peut instancier plusieurs objets d'une même classe :

>>> cb2 = Compte(10000)
>>> print( cb2.Credit(500))
10500.0
>>> cb3 = Compte(6000)	# et encore un !
>>> cb3-500
Nouveau solde : +5500.00 euros
>>>

Même si cela n'est pas recommandable, vous pouvez accéder directement aux attributs d'instance :

>>> print( cb2.solde)
10500.0
>>> cb2.solde = 5000.0	# assignation de l'attribut d'instance solde
>>> print( cb2.solde)
5000.0
>>> print( cb2.Solde())
5000.0
>>>

Notez que des méthodes spéciales sont prévues pour personnaliser le mode d'accès aux attributs : __setattr__(), __getattr__()...

L'importation de notre module personnel CompteBancaire se fait de la même façon que pour les modules de base (math, random, time...).

Redémarrer l'interpréteur interactif (Python Shell) :
Shell → Restart Shell

>>> import CompteBancaire
>>> cb = CompteBancaire.Compte(1500)
>>> print( cb.Debit(200))
1300.0
>>> print( cb.solde)
1300.0
>>> cb+2000
Nouveau solde : +3300.00 euros
>>>

Le module CompteBancaire est importé par le programme principal (ici l'interpréteur interactif).
La partie du code qui suit l'instruction if __name__ == '__main__': est ignorée (il n'y a donc pas d'affichage après l'instruction import CompteBancaire).

Définir une nouvelle méthode Decouvert() de la classe Compte, qui affiche selon le cas Solde positif ou Solde négatif :

A la suite du programme principal, ajouter les lignes suivantes :

    CompteJerome = Compte(2000)
    CompteJerome-3000
    CompteJerome.Decouvert()
    CompteJerome+10000
    CompteJerome.Decouvert()

Le résultat devra être le suivant :

Nouveau solde : -1000.00 euros
Solde négatif
Nouveau solde : +9000.00 euros
Solde positif

Définir une nouvelle méthode Suivi() qui affiche l'historique du solde.
On pourra définir un nouvel attribut de type list :

A la suite du programme principal, ajouter les lignes suivantes :

    CompteJerome.Debit(5000)
    CompteJerome.Credit(1000)
    CompteJerome.Suivi()

Le résultat devra être le suivant :

[2000.0, 3000.0, 10000.0, 5000.0, 1000.0]

Le duel de Pokemons

Nous commençons par créer une classe Pokemon. Un Pokemon se définit par (entre autres) :

• Un attribut nom, correspondant au nom du pokemon.
• Un attribut pv correspondant à ses points de vie
• Un attribut pvmax correspondant à ses points de vie maximale égal à pv lors de l'initialisation
• Un attribut pc correspondant à sa puissance de combat
• Un type (EAU, FEU, PLANTE, ELECTRIK...)
• Une méthode EstVivant() qui retourne True si un Pokemon est toujours en vie (pv >0) sinon on retourne False.
• Une méthode BoitPotion(gain) permettant d'ajouter le gain , devra appeler la fonction spéciale __add__(gain)
  
• Une méthode Attaque(pokemon) permettant au Pokémon courant d'attaquer le Pokemon passé en paramètre. Cette méthode inflige des dégâts aux points de vie des Pokemons. Le calcul des dégâts infligés est expliquée plus tard. Au début de la méthode afficher "nom du pokemon1 attaque nom du pokemon2" et à la fin de la méthode afficher "nom du pokemon1" afflige xx dégâts à "nom du pokemon2" puis retranchez au pokemon les dégâts , par l'appel de la fonction spéciale __sub__
• Une méthode spéciale __add__(gain) qui permet d'additionner un gain à l'attrubut pv sans dépasser l'attribut pvmax. Elle affiche un message "nom pokemon a xx PV"
  
• Une méthode spéciale __sub__(degats) qui permet de soustraire des dégâts à l'attribut pv sans atteindre une valeur négative. Elle affiche un message "nom pokemon est KO" si pv=0 et dans tous les cas affiche "il reste xx PV à nom pokemon"

Les Pokemons décrits à travers la classe Pokemon servent de base à la modélisation de ces petites créatures.

N'oubliez pas les docstrings et les commentaires

Dans cet exercice, on étudie une méthode de chiffrement de chaînes de caractères alphabétiques. Pour des raisons historiques, cette méthode de chiffrement est appelée "code de César". On considère que les messages ne contiennent que les lettres capitales de l’alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ" et la méthode de chiffrement utilise un nombre entier fixé appelé la clé de chiffrement.

1. Soit la classe CodeCesar définie ci-dessous :

class CodeCesar: def __init__(self, cle): self.cle = cle self.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" def decale(self, lettre): num1 = self.alphabet.find(lettre) num2 = num1+self.cle if num2 >= 26: num2 = num2-26 if num2 < 0: num2 = num2+26 nouvelle_lettre = self.alphabet[num2] return nouvelle_lettre

On rappelle que la méthode str.find(lettre) renvoie l'indice (index) de la lettre dans la chaîne de caractères str

Représenter le résultat d’exécution du code Python suivant :

code1 = CodeCesar(3)
print(code1.decale('A'))
print(code1.decale('X'))


2. La méthode de chiffrement du « code César » consiste à décaler les lettres du message dans l’alphabet d'un nombre de rangs fixé par la clé. Par exemple, avec la clé 3, toutes les lettres sont décalées de 3 rangs vers la droite : le A devient le D, le B devient le E, etc.

Ajouter une méthode cryptage(self, texte) dans la classe CodeCesar définie à la question précédente, qui reçoit en paramètre une chaîne de caractères (le message à crypter) et qui retourne une chaîne de caractères (le message crypté).

Cette méthode cryptage(self, texte) doit crypter la chaîne texte avec la clé de l'objet de la classe CodeCesar qui a été instancié.

Exemple :

>>> code1 = CodeCesar(3)
>>> code1.cryptage("NSI")
'QVL'

class CodeCesar: def __init__(self, cle): self.cle = cle self.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" def decale(self, lettre): num1 = self.alphabet.find(lettre) num2 = num1+self.cle if num2 >= 26: num2 = num2-26 if num2 < 0: num2 = num2+26 nouvelle_lettre = self.alphabet[num2] return nouvelle_lettre

3. Ecrire un programme qui :

• demande de saisir la clé de chiffrement
• crée un objet de classe CodeCesar
• demande de saisir le texte à chiffrer
• affiche le texte chiffré en appelant la méthode cryptage

4. On ajoute la méthode transforme(texte) à la classe CodeCesar :

def transforme(self, texte): self.cle = -self.cle message = self.cryptage(texte) self.cle = -self.cle return message

On exécute la ligne suivante : print(CodeCesar(10).transforme("PSX"))

Que va-t-il s’afficher ? Expliquer votre réponse.

Créer une classe Eleve dont les attributs sont : nom (str), prenom (str) et matieres (un dictionnaire dont les clés sont les matières dont les valeurs une liste de notes)

Créer la méthode constructeur qui prend en paramètres lui-même, le nom de l'élève, le prénom de l'élève et une liste de matières (on se limitera à 3 matières)

Pour chaque matières de la liste matieres passée en paramètres par exemple ['Maths','NSI','Philo'], il faut créer l'attribut matières pour que le dictionnaire self.matieres={'Maths':[],'NSI':[],'Philo":[]}

Créer l'objet, votre login réseau dont les attributs seront vos nom et prenom et vos matières

Créer la méthode Ajoute_note prenant en paramètre la matière et la note, qui ajoutera une note dans le dictionnaire matieres de la matière passée en paramètre

Créer une méthode Moyenne qui prend en paramètre la matière qui reverra la moyenne de cette matière

Exécuter