################################################
# Exo1 :
################
1.1 Identifiez les éléments suivants: 1) "parameters", 2) "class", 3) "attributes", 4) "methods" et 5) "state" dans le code ci-dessous (CODE Exo1). Par exemple, pour class, on attend la réponse Dog.

1.2. Modifiez le code afin que la race du chien devienne un attribut de type "string" fixé lors de l'instanciation de la classe. 

1.3. Modifiez le code afin que l'humeur du chien devienne un entier entre 0 (grincheux) et 10 (heureux). Lors de l'instanciation du chien la valeur est à 5. Créez une méthode "eat" qui incrémente l'humeur de 3 (l'humeur plafonne à 10) et une méthode "leash" (mettre la laisse) qui diminue l'humeur de 1.

########
CODE Exo1:

'''

class Dog:
    """
    This is a dog
    """

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

    def bark(self, intensity=3):
        if intensity==1:
            print('whouaf')
        elif intensity==2:
            print('Whouaf!')
        else:
            print('WHOUAF!')

fido = Dog('Fido')
buddy = Dog('Buddy')
fido.add_trick('roll over')
fido.add_trick('play dead')
buddy.bark(2)


########
SOLUTION Exo1:

1.1
parameters = {intensity}
class = {Dog}
instance = {fido, buddy}
attributes = {name, tricks}
methods = {add_trick, bark}
state:
{name:Fido, tricks:['roll over', 'play dead']}
{name:Buddy, tricks:[]}

1.2 & 1.3
class Dog:
    """
    This is a dog
    """
    mood_min = 0
    mood_max = 10

    def __init__(self, name, race):
        self.name = name
        self.race = race
        self.mood = 5
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

    def bark(self, intensity=3):
        if intensity==1:
            print('whouaf')
        elif intensity==2:
            print('Whouaf!')
        else:
            print('WHOUAF!')

    def eat(self):
        self.mood+=3
        # Make sure the mood is not more than Dog.mood_max
        self.mood = min(self.mood,Dog.mood_max)

    def leash(self):
        self.mood-=1
        # Make sure the mood is not more than Dog.mood_max
        self.mood = max(self.mood,Dog.mood_min)

fido = Dog('Fido', 'husky')
buddy = Dog('Buddy', 'husky')
fido.add_trick('roll over')
fido.add_trick('play dead')
print (fido.mood)
fido.eat()
print (fido.mood)
fido.eat()
print (fido.mood)
fido.eat()
print (fido.mood)

buddy.bark(2)


################################################
# Exo2 :
################
Soit le code ci-dessous "CODE Exo2":
2.1. En utilisant la classe "Dog", instanciez trois nouveaux chiens, chacun avec un âge différent.
2.2. Ecrivez une fonction appelée get_biggest_number(), qui prend un nombre quelconque d’âge (*args) et renvoie le plus ancien.
2.3. Indiquez ensuite l’âge du chien le plus âgé comme suit: Le chien le plus âgé a 7 ans.
2.4. définir une méthode d'instance 'description' qui renvoie le nom et l'âge du chien
2.5. définir une méthode d'instance 'speak' qui prend comme argument un son et renvoie le nom du chien et le son

########
CODE Exo2:
class Dog:
    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

########
SOLUTION Exo2:

class Dog:
    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # exo 2.4.
    def description(self):
        return "{} is {} years old".format(self.name, self.age)

    # exo 2.5.
    def speak(self, sound):
        return "{} says {}".format(self.name, sound)

# 2.1 Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)

# 2.2 Determine the oldest dog
def get_biggest_number(*args):
    return max(args)

# 2.3 
print("The oldest dog is {} years old.".format(get_biggest_number(jake.age, doug.age, william.age)))

# 2.4 & 2.5
# Instantiate the Dog object
mikey = Dog("Mikey", 6)
# call our instance methods
print(mikey.description())
print(mikey.speak("Gruff Gruff"))
'''



################################################
# Exo3 :
################
Soit le code ci-dessous "CODE Exo3":
3.1. Write a child class Teacher, which inherits from the SchoolMember class with an additional argument salary
3.2. Ecrivez une classe "Student" qui hérite de la classe SchoolMember avec un argument supplémentaire "note"
3.3. Pour "Teacher" et "Student", ajoutez une méthode 'tell' qui appelle la méthode tell de la classe parente et affiche le salaire pour un "Teacher" et la note pour un "Student".     

########
CODE Exo3:

class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('(Initialized SchoolMember: {})'.format(self.name))

    def tell(self):
        '''Tell my details.'''
        print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")


class Teacher(SchoolMember):
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print('(Initialized Teacher: {})'.format(self.name))

    def tell(self):
        SchoolMember.tell(self)
        print('Salary: "{:d}"'.format(self.salary))



########
SOLUTION Exo3:

class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('(Initialized SchoolMember: {})'.format(self.name))

    def tell(self):
        '''Tell my details.'''
        print('Name:"{}" Age:"{}"'.format(self.name, self.age), end=" ")


class Teacher(SchoolMember):
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print('(Initialized Teacher: {})'.format(self.name))

    def tell(self):
        SchoolMember.tell(self)
        print('Salary: "{:d}"'.format(self.salary))

class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, grade):
        SchoolMember.__init__(self, name, age)
        self.grade = grade
        print('(Initialized Student: {})'.format(self.name))

    def tell(self):
        SchoolMember.tell(self)
        print('Grade: "{:d}"'.format(self.grade))


t = Teacher('Bob', 40, 40000)
s = Student('Alice',20, 6)
t.tell()
s.tell()

===============











################################################
# Exo4 :
################
Build a class Student which define a new student by a name and a year and a list of grades.

1. Define a constructor which initiate a new student with a name and an age.
2. Write methods to get the name and the age of a student.
3. Write a methods to add a new grade.
4. Implement a method which compute the average grade.
5. Add a new method which make a student pass (i.e., the student goes to the next year and start with new grades) if the average grade is higher than a threshold.

Construisez une classe "Student" qui gère les informations suivantes pour un étudiant: nom, année académique et liste de notes.

1. Définissez un constructeur qui initie un nouvel étudiant avec un nom et l'année académique.
2. Écrivez une méthode pour obtenir le nom et l'année académique d'un étudiant.
3. Écrivez une méthode pour ajouter une nouvelle note.
4. Implémentez une méthode qui calcule la note moyenne.
5. Ajoutez une nouvelle méthode qui fait passer l'étudiant (c’est-à-dire que l'étudiant passe à l’année suivante et commence avec de nouvelles notes) si la note moyenne est supérieure à un seuil.


########
SOLUTION Exo4:
class  Student:
    def __init__(self, name:str, year:int):
        self.name = name
        self.year = year
        self.grades = []

    def get_name(self):
        return self.name

    def get_year(self):
        return self.year

    def add_new_grade(self, grade:int):
        self.grades.append(grade)

    def final_grade(self):
        if len(self.grades) > 0:
            return sum(self.grades)/len(self.grades)
        else:
            return 0

    def evaluate_year(self, limit_grade:int):
        if self.final_grade() >= limit_grade:
            self.year += 1
            self.grades = []

    def __str__(self):
        return self.name + " is in year " + str(self.year) + (" with an average grade of " + str(self.final_grade()) if len(self.grades) > 0 else '')


laura = Student("Laura", 17)
laura.add_new_grade(6)
laura.add_new_grade(4)
laura.add_new_grade(5)
laura.add_new_grade(4)
print(laura.final_grade())
print(laura)
laura.evaluate_year(4)
print(laura)



################################################
# Exo5 :
################

Définissez une classe "Classe" contenant des étudiants. Il est possible d’ajouter de nouveaux étudiants à une classe, d’obtenir la liste des noms d’étudiants, ainsi que de récupérer le nom et la note finale du meilleur étudiant.

1. Construisez le constructeur pour lancer une nouvelle classe sans élève.
2. Implémentez des méthodes pour ajouter un nouvel étudiant et obtenir la liste du nom des étudiants ajoutés.
3. Implémentez une méthode qui renvoie le nom et le grade du meilleur élève d’une classe.

########
SOLUTION Exo5:

class Classe:
    def __init__(self):
        self.list_students = []

    def get_name_students(self):
        return [student.get_name for student in self.list_students]

    def add_new_student(self, student):
        self.list_students.append(student)

    def get_best_student(self):
        student = max(self.list_students, key=lambda s: s.final_grade())
        return student.get_name(), student.final_grade()

bob = Student("Bob", 53)
bob.add_new_grade(1)
bob.add_new_grade(3)
print(bob.final_grade())

agent = Classe()
agent.add_new_student(laura)
agent.add_new_student(bob)
print(agent.get_name_students())
print(agent.get_best_student())