Programmation objet en Python

💻 Travail n° 1 Classe Cercle

🎯 Travail à faire :

  1. À partir de l’exemple donné dans Une 1ère classe, créer une classe Cercle :

    • qui possède 1 attribut d’instance nommé rayon

    • 2 méthodes calcCirconference() et calcSurface() qui retourne respectivement la circonférence et la surface d’un objet de type Cercle

  2. Instancier 2 objets c1 et c2 de type Cercle avec 2 rayons différents et calculer puis afficher leur circonférence et leur surface.

Exemple de résultat attendu pour 2 cercles de rayons respectifs 1 et 10
c1 <Cercle(1)> -> Circonférence : 6.28 / Aire : 3.14
c2 <Cercle(10)> -> Circonférence : 62.83 / Aire : 314.16

💻 Travail n° 2 Surcharge opérateur

🎯 Travail à faire :

Compléter le code de la classe Resistance donné dans le script Python ci-dessous pour qu’elle redéfinisse le comportement de l’opérateur // (→ division entière) pour que celui-ci permettent de calculer la valeur résultante de résistance montées en parallèle.

La méthode “magique” associée à cet opérateur est :
__floordiv__(self, other)

La formule générale permettant de calculer la résistance équivalente (Req) de résistances associées en parallèles est :

req parallele
Resistance.py
class Resistance :
    def __init__(self, r) :
        self.value = r

    def __floordiv__(self, other) :
        pass # Remplacer `pass` par votre code

if __name__ == "__main__":
    r1 = Resistance(470)
    r2 = Resistance(220)
    r3 = Resistance(820)

    r12 = r1 // r2
    r123 = r1 // r2 // r3

    print(f"r1 // r2 : {r12.value:.2f}Ω")
    print(f"r1 // r2 // r3 : {r123.value:.2f}Ω")
Résultat attendu
r1 // r2 : 149.86Ω
r1 // r2 // r3 : 126.70Ω

💻 Travail n° 3 Couleurs HTML

🎯 Travail à faire :

  1. Coder une classe CouleurHTML qui possède :

    • 3 attributs d’instance : red, green, blue qui codent — entre 0 et 255 — le niveau de rouge, vert, bleu d’une couleur HTML

    • 1 constructeur __init__(self, r, g, b) qui initialise les attributs d’instances avec la valeur des paramètres qui lui sont passés.

      Celui-ci doit “borner” les valeurs fournies en paramètre dans l’intervalle [0,255].

      Ex. : c = CouleurHTML(-10, 20, 300)
      …​doit être interprété comme :
      c = CouleurHTML(0, 20, 255)

    • 1 méthode getLuminance() qui retourne la valeur de la sensation visuelle de luminosité de la couleur. Cette luminance est donnée par la formule :

      luminance = 0.299 * rouge + 0.587 * vert + 0.114 * bleu

    • 1 méthode __eq__(self, other) (→ méthode “magique” qui correspond à l’opérateur ==) qui teste l’égalité entre 2 couleurs en vérifiant si leurs composantes RGB sont identiques

    • les méthodes :

      • __lt__(self, other) (→ opérateur <),

      • __gt__(self, other) (→ opérateur >),

      • __le__(self, other) (→ opérateur ⇐),

      • __ge__(self, other) (→ opérateur >=)

        …​qui comparent 2 couleurs en termes de luminance.

    • 1 méthode __add__(self, other) qui additionne 2 couleurs.

      Ici, on considère que l’addition consiste à calculer la moyenne des composantes RGB des 2 couleurs.

      Ex. : CouleurHTML(255,0,255) + CouleurHTML(255,0,0) → CouleurHTML(255, 0, 128)

    • 1 méthode __str__(self) qui retourne la représentation d’une couleur HTML sous la forme d’une chaîne #RRGGBB avec RR, GG et BB représentant les composantes RGB codées en hexadécimal. (Ex. : Rouge ⇒ #FF0000)

      __str__(self) renvoie une représentation lisible pour l’utilisateur, tandis que __repr__(self) renvoie une représentation plus précise et non ambiguë, plutôt destinée au débogage.

    • 1 méthode __repr__(self) qui retourne la représentation d’une couleur HTML sous la forme d’une chaîne Couleur(r,g,b) avec r, g et b représentant les composantes RGB codées en décimal. (Ex. : Rouge ⇒ Couleur(255,0, 0))

  2. Vérifier votre code avec le script suivant :

    class CouleurHTML :
    pass # Remplacer `pass` par votre code

if __name__ == "__main__" :

    c1 = CouleurHTML(300, 128, 64)
    c2 = CouleurHTML( 64, 255,  0)
    c1_plus_c2 = c1 + c2

    print(f"c1 = {c1} ({c1!r})") (1)
    print(f"c2 = {c2} ({c2!r})")
    print(f"c1_plus_c2 = {c1_plus_c2} (type : {c1_plus_c2!r})")

    # Détermination de la couleur de plus haute luminance
    c_max_lum = CouleurHTML(0,0,0) # Noir

    couleurs = [c1, c2, c1_plus_c2]
    for c in couleurs :
        if c >= c_max_lum :
            c_max_lum  = c

    print(f"La couleur de plus haute luminance est {c_max_lum}")
    1 {c1} fait appel à __str__(self) et {c1!r} à __repr__(self)
    Résultat attendu 
    c1 = #FF8040 (Couleur(255,128,64))
c2 = #40FF00 (Couleur(64,255,-10))
c1_plus_c2 = #A0C020 (type : Couleur(160,192,32))
La couleur de plus haute luminance est #40FF00

  3. Vérifier les résultats avec le site ColorDesigner link

    colordesigner

💻 Travail n° 4 Classe IP

🎯 Travail à faire 🔥 🔥 :

  1. Toujours à partir de l’exemple donné dans Une 1ère classe, créer une classe IP permettant de manipuler une adresse IP d’un hôte réseau.

    Celle-ci doit :

    • possèder 2 attributs d’instance :

      • ip → valeur de l’adresse IP

      • mask → masque

    • un constructeur __init__() qui prend en paramètre une adresse IP et une longueur de masque (Ex. : __init(`192.168.4.5', 22)

    • une méthode getNwkAddr() qui retourne l’adresse réseau

    • une méthode getMask() qui retourne, sous forme de chaîne de caractères, le masque réseau en notation décimale pointée

    • une méthode getBcastAddr() qui retourne, sous forme de chaîne de caractères et en notation décimale pointée, l’adresse de broadcast du réseau auquel appartient l’IP

    • une méthode getMaxHosts() qui retourne le nombre max. d’hôtes du réseau auquel appartient l’IP

    • une méthode getMinIp() qui retourne la 1ère adresse disponible du réseau auquel appartient l’IP

    • une méthode getMaxIp() qui retourne la dernière adresse disponible du réseau auquel appartient l’IP

    • la méthode spéciale __repr__() qui retourne l’adresse IP sous forme de chaîne de caractères au format CIDR (→ “192.168.4.5/22”)

Vous pouvez vous servir du code source qui a été vu en co-enseignement math dans la partie qui traite des opérateurs bit-à-bit

🞄  🞄  🞄