<jupyter_start><jupyter_text>TE Object-Oriented Programming (OOP) Traivail écrit sur Object-Oriented Programming (OOP)* Nom: Ducommun* Prénom: Hugo* Classe: OC informatique* Date: 14 mai 2019  Variables de classe, Variables d'instance Complétez la definition de la classe __Humain__ avec les méthodes:* __init()__* __str()__* __imc()__ (indice de masse corporelle)* __corpulence()__Dans votre calcul vous devez utiliser * les 3 __variables de classe__ (genres, interpretations, limites)  et * les 4 __variables d'instance__ (nom, poids, taille, genre)<jupyter_code>class Humain():
    '''Décrit un humain avec nom, taille, poids, et genre (m/f).'''
    
    genres = ('homme', 'femme')
    interpretations = ('anorexique', 'maigre', 'normal', 'obèse')
    limites = [16.5, 18.5, 25, 100]
    
    def __init__(self, nom, poids, taille, genre):
        """Definit une instance de la classe Humain."""
        self.nom = nom
        self.poids = poids
        self.taille = taille
        self.genre = Humain.genres[genre]
        
    def __str__(self):
        """Retourne une description de l'instance."""
        return self.nom + ' : ' + self.genre + ' de ' + str(self.poids) + ' kg et de taille ' + \
                str(self.taille) + ' m'
    
    def imc(self):
        """Calcule l'indice de masse corporelle (poids_kg/taille_m**2)"""
        self.imc = self.poids / self.taille**2
        return self.imc
        
    def corpulence(self):
        """Evalue la corpulence: anorexique <16.5, maigre <18.5, normale <25, obèse"""
        for i in range(4):
            limit = Humain.limites[i]
            label = Humain.interpretations[i]
            if self.imc < limit:
                return label
h = Humain('Massimo', poids=86, taille=1.87, genre=0)
print(vars(h))
print(h)
print(h.imc())
print(h.corpulence())<jupyter_output>{'nom': 'Massimo', 'poids': 86, 'taille': 1.87, 'genre': 'homme'}
Massimo : homme de 86 kg et de taille 1.87 m
24.59321112985787
normal<jupyter_text>Exemples<jupyter_code>steve = Humain('Steve', 150, 1.75, 0)
cindy = Humain('Cindy', 50, 1.80, 1)
billy = Humain('Billy', 75, 1.75, 1)

print(steve.nom, ":", steve)
print(cindy.nom, ":", cindy)
print(billy.nom, ":", billy)
print()
print(steve.nom, "imc =", steve.imc(), steve.corpulence())
print(cindy.nom, "imc =", cindy.imc(), cindy.corpulence())
print(billy.nom, "imc =", billy.imc(), billy.corpulence())<jupyter_output>Steve : Steve : homme de 150 kg et de taille 1.75 m
Cindy : Cindy : femme de 50 kg et de taille 1.8 m
Billy : Billy : femme de 75 kg et de taille 1.75 m

Steve imc = 48.97959183673469 obèse
Cindy imc = 15.432098765432098 anorexique
Billy imc = 24.489795918367346 normal<jupyter_text>Méthodes spéciales de comparaison Créez des définitions pour* une classe __Vec3__,* une méthode pour imprimer `__str__(self)`* une méthode __norm()__ pour calculer longeur* six méthodes speciales de comparaison (=, >)Qui permet d'obtenir les résultats ci-dessous<jupyter_code>import math

class Vec3():
    def __init__(self, x=0, y=0, z=0):
        """Initialise un vecteur avec les 3 composantes (x, y, z)."""
        self.x = x
        self.y = y
        self.z = z
        
    def __str__(self):
        """Retourne une represation sous forme 'Vec3(x, y, z)'"""
        return 'Vec3({}, {}, {})'.format(self.x, self.y, self.z)
    
    def norm(self):
        """Calcule la norme (la longueur) du vecteur."""
        return math.sqrt(self.x**2 + self.y **2 + self.z**2)
        
    def __lt__(self, other):
        return self.norm() < other.norm()

    def __le__(self, other):
        return self.norm() <= other.norm()

    def __eq__(self, other):
        return self.norm() == other.norm()

    def __ne__(self, other):
        return self.norm() != other.norm()

    def __ge__(self, other):
        return self.norm() >= other.norm()

    def __gt__(self, other):
        return self.norm() > other.norm()
v0 = Vec3()
print(v0)
v1 = Vec3(1, 2, 3)
print(vars(v1))
print(v1)
print(v1.norm())<jupyter_output>Vec3(0, 0, 0)
{'y': 2, 'x': 1, 'z': 3}
Vec3(1, 2, 3)
3.74165738677<jupyter_text>Exemple<jupyter_code>a = Vec3(1, 1 ,1)
b = Vec3(1, -1, 2)
print(a, b)
print(a.norm(), b.norm())
print(a<b, a<=b, a==b, a!=b, a>=b, a>b)
a = Vec3(1, 1 ,1)
b = Vec3(1, -1, 2)
print(a, b)
print(a.norm(), b.norm())
print(a<b, a<=b, a==b, a!=b, a>=b, a>b)<jupyter_output>(<__main__.Vec3 instance at 0x0000000004AD2808>, <__main__.Vec3 instance at 0x0000000004AD2E88>)
(1.7320508075688772, 2.449489742783178)
(True, True, False, True, False, False)<jupyter_text>Héritage Definissez* une class __Polygon__* une variable de classe __names__ avec la valeur ('triangle', 'rectangle', 'pentagon', 'hexagon')* une méthode `__init__(self, n, s)` qui initialise le polygone* une méthode __str()__ qui affiche le mot _triangle, rectangle, pentagon, hexagon_ si n<=6* une méthode __perimeter()__ qui calcule le périmètre (n * s)* une méthode __angle()__ qui calcule l'angle interne (180-360/n)* des sous-classes __Triangle__, __Square__, __Pentagon__, basées sur __Polygon__* qui utilisent la méthode `super().__init__(n, s)` pour accéder a une méthode de la classe parentQui affiche les valeurs ci-dessous<jupyter_code>class Polygon():
    names = ('triangle', 'rectangle', 'pentagon', 'hexagon')
    
    def __init__(self, n=3, s=1):
        '''Regular polygon with n sides of length s.'''
        self.n = n
        self.s = s

    def __str__(self):
        if self.n <= 6:
            return Polygon.names[self.n - 3]
        else:
            return 'polygon with ' + str(self.n) + 'sides'

    def perimeter(self):
        '''Return perimeter.'''
        return self.n * self.s

    def angle(self):
        '''Return interior angle.'''
        return 180-360/self.n

class Triangle(Polygon):
    def __init__(self, s=1):
        super(Triangle, self).__init__(3, s)

class Square(Polygon):
    def __init__(self, s=1):
        super(Square, self).__init__(4, s)

class Pentagon(Polygon):
    def __init__(self, s=1):
        super(Pentagon, self).__init__(5, s)
p = Polygon(n=3, s=10)
print(vars(p))
print(p, p.perimeter(), p.angle(), sep=' - ')

t = Triangle(10)
s = Square(10)
pent = Pentagon(10)
print(p, t, s, pent)<jupyter_output>{'n': 3, 's': 10}
triangle - 30 - 60.0
triangle triangle rectangle pentagon<jupyter_text>Exemples<jupyter_code>print('{:15}{:10}{:15}{}'.format('name', 'side', 'perimeter', 'angle'))
for p in (Triangle(3), Square(2), Pentagon(1)):
    print('{:15}{:<10}{:<15}{}'.format(str(p), p.s, p.perimeter(), p.angle()))
print('{:15}{:10}{:15}{}'.format('name', 'side', 'perimeter', 'angle'))
for p in (Triangle(3), Square(2), Pentagon(1)):
    print('{:15}{:<10}{:<15}{}'.format(str(p), p.s, p.perimeter(), p.angle()))<jupyter_output>name           side      perimeter      angle
triangle       3         9              60.0
rectangle      2         8              90.0
pentagon       1         5              108.0<jupyter_text>Code Morse Définissez les 2 méthodes:* toMorse(self)* fromMorse(self)<jupyter_code>class Morse(str):
    codes = {' ':'.......', 'a':'.-', 'b':'-...', 'c':'-.-.', 'd':'-..', 'e':'.', 'f':'..-.', 'g':'--.', 'h':'....', 
         'i':'..', 'j':'.---', 'k':'-.-', 'l':'.-..', 'm':'--', 'n':'-.', 'o':'---', 'p':'.--.', 'q':'--.-', 
         'r':'.-.', 's':'...', 't':'-', 'u':'..-', 'v':'...-', 'w':'.--', 'x':'-..-', 'y':'-.--', 'z':'--..'}
    
    inv_codes = {'....':'h', '.':'e', '.-..':'l', '---':'o'}
    #inv_codes = {m: c for c, m in Morse.codes.items()}
    
    def __init__(self, msg):
        self.msg = msg

    def toMorse(self):
        """Transforme une chaine de caractères en code Morse"""
        res = ''
        for c in self.msg:
            c = c.lower()
            m = Morse.codes[c]
            #print(c, m)
            res += m + ' '
        return res
    
    def fromMorse(self):
        """Transforme un code Morse en chaine de caractères"""
        res = ''
        mes = self.msg.split(' ')
        for c in mes:
            m = Morse.inv_codes[c]
            table = '{:8} {}'.format(c, m)
            print(table)
            res += m
        return res
Morse('OC info').toMorse()<jupyter_output><empty_output><jupyter_text>Exemples<jupyter_code>s = Morse('SOS')
print(s)
print(s.toMorse())
s = Morse('SOS')
print(s)
print(s.toMorse())
h = Morse('hello')
print(h)
print(h.toMorse())
h = Morse('hello')
h2 = Morse('.... . .-.. .-.. ---')
print(h)
print(h.toMorse())
print(h2.fromMorse())
print(Morse('.... . .-.. .-.. ---').fromMorse())
print(Morse('.... . .-.. .-.. ---').fromMorse())<jupyter_output>....     h
.        e
.-..     l
.-..     l
---      o
hello<jupyter_text>Extension d'un module Une classe peut étendre un module existant. Créez une nouvelle classe __FrenchDate__ basé sur _datetime.date_ qui redefinit la fonction `__str__(self)` pour imprimer une date avec le mois écrit en lettres en français.<jupyter_code>import datetime

class FrenchDate(datetime.date):
    months = ('janvier', 'février', 'mars', 'avril', 'mai', 'juin', 
              'juillet', 'aout', 'septembre', 'octobre', 'novembre', 'décembre')
    
    def __str__(self):
        return str(self.day) + ' ' + FrenchDate.months[self.month-1] + ' ' + str(self.year)
import datetime

d = datetime.date(2019, 5, 14)
fd = FrenchDate(2019, 5, 14)
print(d)
print(fd)<jupyter_output>2019-05-14
14 mai 2019<jupyter_text>Exemple<jupyter_code>fd = FrenchDate(1999, 5, 23)
print(fd)<jupyter_output>23 mai 1999<jupyter_text>Créez une nouvelle classe __JapaneseDate__ basé sur _datetime.date_ qui imprime une date sous deux formes:* avec des symboles japonaises : 2000年2月23日 (vous pouvez copier-coller ces caractères)* en phonétique (romaji) : 2000-nen-2-gatsu-23-nichi<jupyter_code>class JapaneseDate(datetime.date):
    def __str__(self):
        return '{}年{}月{}日'.format(self.year, self.month, self.day)
    
    def romaji(self):
        return '{}-nen-{}-gatsu-{}-nichi'.format(self.year, self.month, self.day)<jupyter_output><empty_output><jupyter_text>Exemple<jupyter_code>jd = JapaneseDate(2000, 2, 23)
print(jd)
print(jd.romaji())
jd = JapaneseDate(2000, 2, 23)
print(jd)
print(jd.romaji())<jupyter_output>2000年2月23日
2000-nen-2-gatsu-23-nichi
{'fraction_non_alphanumeric': 0.1843602825745683, 'fraction_numerical': 0.043661695447409735, 'mean_word_length': 3.130064829821718, 'pattern_counts': {'":': 3, '<': 57, '<?xml version=': 0, '>': 48, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 2, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '137322', 'license': 'MIT', 'n_tokens_mistral': 4194, 'n_tokens_neox': 3859, 'n_words': 957, 'path': 'usr/duc/Test/TE_OOP_Ducommun_Hugo.ipynb', 'repo_name': 'Bugnon/oc-2018', 'size': '10192'}