---
# System prepended metadata

title: GR 1 EQ 2

---

# GR 1 EQ 2
# TP1 - Introduction à la POO


# Exercice 1

# 1)
liste = [2, 5, 1, 9, 11]
list(liste) '''renvoie la liste'''
[2, 5, 1, 9, 11]
tuple(liste) '''creer un tuple'''
(2, 5, 1, 9, 11)
str(liste) '''liste en cdc'''
[2, 5, 1, 9, 11]
dict((x, 0) for x in liste) """ Création d'un dictionnaire de la forme {2 : 0, 5 : 0, 1 : 0, 9 : 0, 11 : 0} 
dict((x, i) for i, x in enumerate(liste)) """Création d'un dictionnaire de la forme {2 : 0, 5 : 1, 1 : 2, 9 : 3, 11 : 4} 
set(liste) '''{1, 2, 5, 9, 11}'''
set([100,] + liste) '''{1, 2, 5, 9, 11, 100}'''

# 2)
chaine = 'hello world'
list(chaine) ''' liste avec une lettre par case et une liste vide entre hello et world'''
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
tuple(chaine) """tuple avec une lettre par case et une liste vide entre hello et world"""
('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
str(chaine) '''Ne fait rien : affiche simplement la chaîne de caractères'''
hello world
dict((x, 0) for x in chaine) '''transforme en dictionnaire chaque lettre de la chaine'''
{'o': 0, 'd': 0, 'h': 0, 'l': 0, 'e': 0, 'r': 0, ' ': 0, 'w': 0}
dict((x, i) for i, x in enumerate(chaine))
{'o': 7, 'd': 10, 'h': 0, 'l': 9, 'e': 1, 'r': 8, ' ': 5, 'w': 6}
set(chaine)
{'o', 'l', 'e', 'w', 'd', 'h', 'r', ' '}
set([100,] + chaine) ''' erreur car pas possible de concaténer une chaine de caracteres en liste'''

# 3)

liste.append(x) """Méthode qui permet de rajouter un élément x à la fin de la liste liste"""
len(liste) """Retourner la longueur (nombre d'éléments) de la liste liste"""
liste.extend(L) """Méthode qui fait la concaténation entre la liste liste et la liste L"""
liste.insert(i, x) """Méthode qui permet d'insérer l'élément x à la ième place dans la liste liste"""
liste.remove(x) """Méthode qui permet de retirer de la liste liste le premier élément x présent dedans"""
liste.pop(i) """Méthode qui renvoit la valeur qui a pour index i"""
liste.index(x) """Méthode qui renvoit l'index de la valeur rentrée. Si la valeur n'est pas dans la liste, cela sort une erreur en disant que ce n'est pas dans la liste"""
liste.count(x) """Méthode qui permet de compter le nombre d'occurences de l'élément x dans la liste liste"""
liste.sort() """Méthode qui permet de trier les éléments de la liste liste dans l'ordre croissant"""
sorted(liste)"""Fonction qui permet d'afficher en sortie la liste liste triée par ordre croissant sans pour autant modifier la liste au départ"""
liste.reverse() """Méthode qui permet d'inverser le sens de la liste liste (1er élément devient le dernier etc..)"""

dict.values """Méthode qui renvoie la liste des valeurs présentes dans le dictionnaire dict"""
dict.keys """Méthode qui renvoie la liste des clés présentes dans le dictionnaire dict"""
dict.clear """Méthode qui permet d'effacer l'ensemble des éléments (valeurs et clés) présents dans le dictionnaire dict => renvoi None après exécution"
"""
str.partition """Méthode qui prend une chaine de caractères et la coupe selon un caractère défini."""
'bonjour'.partition('o') 
    >>>('b','o','njour')
str.find """Méthode qui trouve l'index d'une valeur si présente dans la chaine"""
'bonjour'.find('j')
    >>> 3



# Exercice 2

def afficherTitre(texte, largeur) : 
    """Fonction qui permet d'afficher sous forme de         titre un texte donné centré dans la largeur indiquée     au préalable et bordé d’astérisques.
    
     Parameters
     ----------
     texte : list
     Une liste de chaîne de caractères qui correspond au      texte que l'on veut afficher sous forme de titre        avec la fonction
     largeur : int
     Un entier pour lequel on veut définir la largeur du      texte retournée par la fonction
  
     Returns
     -------
     Affichage formaté avec des astérix où le texte est centré parfaitement
     
     Examples
     -------
     >>> afficherTitre(["L'ingénieux hidalgo", "Don Quichotte de la Manche", "Composé par Miguel de Cervantes", "Avec privilège royal", "à Madrid", "en l'an de grâce 1605"], 3)
    *********************************
    *      L'ingénieux hidalgo      *
    *   Don Quichotte de la Manche  *
    *Composé par Miguel de Cervantes*
    *      Avec privilège royal     *
    *            à Madrid           *
    *     en l'an de grâce 1605     *
    *********************************
    
   """
    
   print("*"*largeur)
   for j in range(0, len(texte)-1) :
       if len(texte[j]) < len(texte[j+1]) :
           m = len(texte[j+1])
       else :
           m = len(texte[j])
   if largeur < m :
       largeur = m
   for i in texte :
       l = len(i)
       l = int(l)
       blanc = largeur - l - 2
       blanc = int(blanc)
       if blanc%2 == 0 : 
           print("*" + " *(int((blanc/2))) + i + " "*(int((blanc/2))) + "*")
       else : 
           print("*" + " "*(int((blanc+1)/2)) + i + " "*(int(blanc-1)/2)) + "*")
   print("*"*largeur)


# Exercice 3 

def include(a,b):
    """
    """
    lettrea=list(a)
    lettreb=list(b)
    for i in lettrea :
        if i not in lettreb:
            return False
    return True

def verifierEntierValide(val, inf, sup):
    """
    """
    C=[i for i in range(inf,sup+1)]
    val=[val]
    return(include(val,C))


# Exercice 4

def moyennneMobile(seriedevaleurs1, tailleperiode) : 
    """
    """
    moyenneMobile=[]
    moyenneLocale = 0
    n = tailleperiode
    for i in range(0, len(seriedevaleurs1), n) : 
        for j in range(i, i+n) : 
            moyenneLocale = moyenneLocale + seriedevaleurs1[j]
        moyenneLocale = moyenneLocale / n
        moyenneMobile.append(moyenneLocale)
    return moyenneMobile




# TP2 - Fonctions et modules en Python

# Exercice 1

# 1)

def position(elt, list, depart) : 
    """
    Fonction qui renvoie l’indice i de la première occurrence de elt dans liste après la position depart (c.-à-d., i ≥ depart), ou -1 si une telle occurrence n’existe pas.
    
     Parameters
     ----------
     elt : int/str/list
     Un entier, une châine de caractères ou une liste qui se trouve ou non dans la liste list
     list : list
     Une liste de n'importe quelle taille, voire même vide
     depart : int
     Un entier qui définit à partir de quel élément de la liste list la fonction va démarrer la recherche d'une occurence de la variable elt
  
     Returns
     -------
        L'indice de la première occurence de la variable elt dans une liste donnée à partir de l'indice départ le cas échéant. Retourne -1 si elt n'est pas dans la liste à partir du départ.
     
     Examples
     -------
     >>> position(2,[1,2,3],1)
     1
     
     >>> position("j'aime me battre", ["j'aime me battre","et manger des fraises","avec Mac Mahon"], 1)
     -1
     
   """
    n = len(list)
    for i in range(depart,n) : 
        if elt == list[i] :
            return i
    return -1

# 2)

def sous_liste(petite_liste, grande_liste) : 
    """
    Fonction qui envoie la réponse à la question: « les éléments de petite_liste apparaissent-ils tous, et dans le même ordre, dans grande_liste? »
    
     Parameters
     ----------
     petite_liste : list
     Une liste de taille inférieure ou égale à la liste grande_liste
     grande_liste : list
     Une liste de taille supérieure ou égale à la liste grande_liste
  
     Returns
     -------
    Renvoi la réponse OUI ou NON à la question: « les éléments de petite_liste apparaissent-ils tous, et dans le même ordre, dans grande_liste? »
     
     Examples
     -------
     >>> sous_liste([2, 4, 10],[1, 2, 4, 5, 6, 8, 10, 12])
     OUI
     
     >>> sous_liste([0, 4, 10],[1, 2, 4, 5, 6, 8, 10, 12])
     NON
     
   """ 
   ~~n_petite_liste = len(petite_liste)
    n_grande_liste = len(grande_liste)
    for i in range(0, n_grande_liste) : # Test si les valeurs de la petite liste sont dans la grande liste
        for j in range(0, n_petite_liste) : 
            if any(petite_liste[j] == grande_liste[i]) == TRUE : 
                for h in range(0, n_petite_liste) : # Test si l'ordre est respecté'
                    valeurTestee = petite_liste[h]
                    x = position(valeurTestee, grande_liste, 0)
                    if x == -1 : 
                        return "NON"
            else : 
                return "NON"
    return "OUI"~~

#le meilleur code
    n_petite=len(petite_liste)
    depart=0
    for i in range (0,n_petite):
        x=position(petite_liste[i], grande_liste, depart)
        if x==-1:
            return "Non"
        else:
            depart=x
    return "Oui"



# 3)

Oui, les fonctions peuvent être toujours réutilisées avec des tuples et des dictionnaires sans avoir besoin de les modifier


# Exercice 2

# 1)

def transformer(fonction, liste) : 
    """
    Fonction qui renvoie la liste obtenue en appliquant la fonction donnée à chaque élément de la liste donnée
    
     Parameters
     ----------
     fonction : function
     Une fonction qui est appliquée à chaque élément de la liste appelée liste
     liste : list
     Une liste de taille quelconque
  
     Returns
     -------
     Une liste de même taille que la liste appelée liste dont les éléments proviennent de la liste de départ à laquelle on a appliqué une fonction
     
     Examples
     -------
     >>>transformer(fonction_carrée,[1,2,3])
     [1,4,9]
     # où la fontction fonction_carrée est une fonction définie au préalable qui prend une valeur et renvoie son carrée.
     
   """
    n = len(liste)
    listeSortie = []
    for i in range(0, n):
        a = fonction(liste[i])
        listeSortie.append(a)
    return listeSortie

# 2)

def fonctioncarree(x) : 
    """
    Fonction qui met au carrée l'élément x
    """
    x = x*x
    return x
    
l = [1, 2, 3, 4, 5]
transformer(fonctioncarree, l)

# 3)

def filter(fonction, liste) : 
    """
    Fonction qui renvoie la liste formée des éléments de liste pour lesquels fonction évalue à vrai
    
     Parameters
     ----------
     fonction : function
     Une fonction qui permet de renvoyer un booléen pour chaque élément de la liste appelée liste sur laquelle on effectue le test
     liste : list
     Une liste de taille quelconque
  
     Returns
     -------
     Retourne une liste composée uniquement des éléments pour lesquels le(s) test(s) de fonction ont été vérifié(s).
     
     Examples
     -------
     >>>filtrer(p, [1, 2, 3, 4, 5])
     [1, 3, 5]
     #lorsque p est la fonction p(x) =« x est impair » 
   """ 
    n = len(liste)
    listeFiltree = []
    for i in range(0, n):
        if fonction(liste[i]) == "TRUE" :
            a = liste[i]
            listeFiltree.append(a)
    return listeFiltree
       
    
def cumuler2(fonction, liste):
    """ 
    >>> cumuler2(lambda x, y: x * y, [1, 2, 3, 4, 5])
    120
    >>> cumuler2(lambda x, y: x * y, [2, 2, 3, 4, 5])
    240
    >>> cumuler2(lambda x, y: x + y, [2, 2, 3, 4, 5])
    16
    >>> cumuler2(lambda x, y: x + y, [2])
    2
    """
    # print(liste)
    if len(liste) < 2:
        return liste[0]
    liste.append(
        fonction(liste.pop(), liste.pop())
        )
    return cumuler2(fonction, liste)
    
    
  
def fonctionImpaire (x):
    """Fonction qui retourne "TRUE" si une valeur est impaire, et "FALSE" sinon """
   if x%2 == 0 :
        return "FALSE"
   else : 
       return "TRUE"

l = [1, 2, 3, 4, 5]
filter(fonctionImpaire, l)


# 4)

def cumuler(fonction, liste) : 
    """
    Fonction qui renvoie le cumul des éléments de la liste donnée pour l’opération binaire exprimée par la fonction donnée
    
     Parameters
     ----------
     fonction : function
     Une fonction qui permet de cumuler les éléments de la liste appelée liste en fonction d'une certaine opération
     liste : list
     Une liste de taille quelconque
  
     Returns
     -------
     Retourne une entier qui correspond au cumul des éléments de la liste selon une certaine opération définie par la fonction en entrée
     
     Examples
     -------
     >>>cumuler(g, [1, 2, 3, 4, 5])
     120
     #où g est la fonction telle que g(x,y)=x*y
   """ 
    n = len(liste)
    if n < 2 : 
        return "Erreur - la liste entrée est trop petite (la taille doit être supérieure ou égale à 2)"
    a = liste[0]
    for i in range(1, n):
        a = fonction(liste[i], a)
    return a

    
def produit(x,y) :
    "fonction qui retourne le produit des réels x et y"
    z = x*y
    return z

l=[1, 2, 3, 4, 5]
cumuler(produit, l)

# 5)

lambda x,y : x*y
l = [1, 2, 3, 4, 5]
cumuler((lambda x,y : x*y), l)


lambda x : x*x
l = [1, 2, 3, 4, 5]
transformer((lambda x : x*x), l)

lambda x : 
l = [1, 2, 3, 4, 5]
filtrer(lambda, l)


# Exercice 3

# 1)

def new_mat(nl, nc) : 
    """ Fonction qui crée et retourne une nouvelle matrice ayant nl lignes et nc colonnes composée uniquement de 0"""
    mat=[]
    for i in range (0,nl):
        u=[]
        for j in range (0,nc):
            u.append(0)
        mat.append(u)
    return mat
    
def set_mat(m, i, j, x) : 
    """ Fonction qui affecte la valeur x à la ième ligne et jème colonne de la matrice m, et ne retourne rien. """
    m[i-1][j-1] = x 

def get_mat(m, i, j) : 
    """ Fonction qui retourne la valeur à la ième ligne et jème colonne de la matrice m. Si cet élément n’a jamais été affectée par set_mat(), il est attendu que get_mat() retourne 0. """
    return m[i-1][j-1]

def test_matrice(nl, nc) : 
    """ Fonction qui exécute des instructions de tests ne faisant que des appels aux fonctionsnew_mat(), set_mat() et print(get_mat()). """
    mat = new_mat(nl, nc)
    for i in range(1, nl+1) : 
        for j in range(1, nc+1) :
            x = input("Entrer la valeur que vous souhaitez insérer dans la matrice : ")
            mat = set_mat(mat, i, j, x)
    return mat




# TP3 - Classes

# Exercice 1

class Voiture : 
    """Définition de ce qu'est une voiture en fonction de ses caractéristiques
    
    Attributes
    ----------
    couleur : str
        couleur de la voiture
    nom : str
        nom de la voiture
    vitesse : float
        vitesse de la voiture
    
    Parameters
    ----------
    nom : str
        nom de la voiture à construire
    couleur : str
        couleur de la voiture à construire
    
    Examples
    -------
    >>>a1=Voiture('titine', 'bleu')
    >>>a2=Voiture('quatrelle', 'verte')
    >>>a3=Voiture('bovelo', 'jaune')
    >>>a2.accelere(18)
    >>>a3.accelere(8)
    >>>print(a1)
    voiture titine de couleur bleue à l'arrêt
    >>>print(a2)
    voiture quatrelle de couleur verte roule à 10km/h.
    >>>print(a3)
    11 voiture bovelo de couleur jaune roule à 8km/h. 
    """
    
def __init__(self, couleur, nom) : 
    """Constructeur de la classe voiture
        
    Parameters
    ----------
    nom : str
        nom de la voiture
    couleur : str
        couleur de la voiture
    vitesse : float
        vitesse de la voiture                 
    """
self.couleur = couleur
self.nom = nom
self.vitesse = 0



def accelerate(self, increment) : 
    """Augmente la vitesse de la voiture de la valeur d'increment : Vitesse maximale = 130km/h, accélération maximale à chaque boucle = 10km/h

    Parameters
    ----------
    increment : float
        accélération de la voiture selon la vitesse donnée au départ
    """
if increment > 10 : 
    increment = 10
if self.vitesse > 130 : 
    print("Vitesse maximale atteinte !") 
else : 
    self.vitesse = self.vitesse + increment



def freine(decrement)  :
    """Diminue la valeur du decrement de la vitesse de la voiture. Une voiture ne peut pas rouler à une vitesse négative (elle est à l’arrêt lorsque sa vitesse est à zéro).

    Parameters
    ----------
    decrement : float
    """

self.vitesse=max(self.vitesse - decrement, 0)



def est_arretee (self):
    """Retourne si la voiture est arrêtée ou non.
    
    Return
    -------
    Booléen (TRUE/FALSE) : bool
        TRUE = "Voiture est à l'arrêt"
        FALSE = "Voiture est en marche"
    """

if self.vitesse == 0 : 
    print("voiture est à l'arrêt")
    return ("TRUE")
else : 
    print ("voiture est en marche")
    return ("FALSE")



def __str__(self) : 
    """Retourne les informations en chaîne de caractères sur l'état et les caractéristiques de la voiture (quel est son nom ? quelle est sa couleur ? est-elle en arrêt ? si non, quelle est sa vitesse ?).
    
    Return
    -------
    Chaîne de caractères : str
    """
if self.est_arretee () == "TRUE" : 
    v_voiture = "à l'arrêt"
else :
    v_voiture = "roule à " + str(self.vitesse) + " km/h"
    
return "voiture {} de couleur {} {}.".format(str(self.nom), str(self.couleur), v_voiture)


# Exercice 2

class Complexe : 
    """Représente un nombre complexe qui est caractérisé par sa partie réelle et sa partie imagi- naire
    
    Attributes
    ----------
    p_reelle : float
        Partie réelle du nombre complexe considéré
    p_imaginaire : float
        Partie imaginaire du nombre complexe considéré
    
    Parameters
    ----------
    p_reelle : float
        Partie réelle du nombre complexe considéré
    p_imaginaire : float
        Partie imaginaire du nombre complexe considéré

    
    """
def __init__(self, p_reelle, p_imaginaire) : 
    """Constructeur de la classe complexe
        
    Parameters
    ----------
    p_reelle : float
        Partie réelle du nombre complexe considéré
    p_imaginaire : float
        Partie imaginaire du nombre complexe considéré                 
    """
self.p_reelle = p_reelle
self.p_imaginaire = p_imaginaire



def __add__(self, nb_complexe) : 
    """Permet d’additionner deux nombres complexes en utilisant le symbole « + »
    
    Parameters
    ----------
    self : Complexe
    nb_complexe: Complexe
    """
    
p_reelle = self.p_reelle + nb_complexe.p_reelle
p_complexe = self.p_complexe + nb_complexe.p_complexe
return Complexe(p_reelle, p_complexe)



def __sub__(self, nb_complexe): 
    """Permet de soustraire deux nombres complexes en utilisant le symbole « - »

    Parameters
    ----------
    self : Complexe
    nb_complexe: Complexe
    """
p_reelle = self.p_reelle - nb_complexe.p_reelle
p_complexe = self.p_complexe - nb_complexe.p_complexe
return Complexe(p_reelle, p_complexe)
    


def __mul__(self, nb_complexe): 
    """Permet de multiplier deux nombres complexes en utilisant lesymbole « * »

    Parameters
    ----------
    self : Complexe
    nb_complexe: Complexe
    """
p_reelle = self.p_reelle * nb_complexe.p_reelle - self.p_imaginaire * nb_complexe.p_imaginaire
p_complexe = self.p_reelle *  nb_complexe.p_complexe + self.p_imaginaire *  nb_complexe.p_reelle
return Complexe(p_reelle, p_complexe)

    
    
def __str__(self): 
    """Affiche un nombre complexe en utilisant la fonction str (ou en utilisant print)
    
    Return
    -------
    Chaîne de caractères : str
    
    """
if self.imaginaire < 0:
    return ""{} - {}"i"".format(self.reel, -self.imaginaire)
else :
return "{} "+" {} "i"".format(str(self.p_reelle), str(self.p_imaginaire))
    

    
def __repr__(self):
    """Affiche un représentant du nombre complexe

    Return
    -------
    Chaîne de caractères : str
    
    Example
    -------
    >>>__repr__(1+i)
    "Complexe(1,1)"
    """

return "Complexe({}, {})".format(str(self.p_relle), str(self.p_imaginaire))



### Exercice 3
# Partie 1

# 1

class Domino : 
"""Permet d’instancier des objets simulant les pièces d’un jeu de dominos.
    
    Attributes
    ----------
    extr_A : int
        Valeur de l'extrémité A / gauche
    extr_B : int
        Valeur de l'extrémité / droite
    
    Parameters
    ----------
    extr_A : int
        Valeur de l'extrémité A / gauche
    extr_B : int
        Valeur de l'extrémité / droite
        
    Examples
    --------
    >>> d1 = Domino(2,6)
    >>> d2 = Domino(4,3)
    >>> print(d1)
    [2|6]
    >>> print(d2)
    [4|3]
    >>> print("total des points : ", d1.valeur() + d2.valeur())
    total des points : 15
    
    """

def __init__(self, extr_A = 0, extr_B = 0) : 
    """Constructeur de la classe domino

    Parameters
    ----------
    extr_A : int
        Valeur de l'extrémité A / gauche
    extr_B : int
        Valeur de l'extrémité / droite
    """
self.extr_A = extr_A
self.extr_B = extr_B



def __str__(self) : 
    """Affiche les points présents sur les deux extrémités

    Return
    ------
    '[extr_A|extr_B]'
    
    Examples
    --------
    >>> d1 = Domino(2, 6)
    >>> str(d1)
    '[2|6]'

    """
return "[{}|{}]".format(str(self.__extr_A), str(self.__extr_B))




def valeur(self) : 
    """Renvoie la somme des points présents sur les 2 extrémités.

    Return
    somme_points : int
    ------
    """
somme_points = self.extr_A + self.extr_B
return somme_points

def retourne(self) : 
    """Retourne le domino (son extrémité A devient son extrémité B et vice-versa)."""
intermediaire = self.extr_A
self.extr_A = self.extr_B
self.extr_B = intermediaire



def accepte_apres(self, autre_domino) : 
    """Vérifie si l’extrémité B du domino courant a la même valeur que l’ex- trémité A du domino autre_domino.

    Parameters
    ----------
    autre_domino : Domino
    
    Return
    ------
    Booléen ("True"/"False") : bool
    
    """

if self.extr_B == autre_domino.extr_A : 
    return "True"
else : 
    return "False"



# Partie 2

# 1
def affiche_dominos(liste) : 
    """Affiche une liste de dominos, chacun séparé d'un tiret " - " """ 
nb_dominos = len(liste)
dernier_domino = list(nb_dominos - 1)
for i in range(0:nb_dominos) :
    return "{0[i]} - \n {}".format(liste*(nb_dominos-1), dernier_domino))


# 2
def cree_jeu_dominos() : 
    """ Crée une liste de tous les dominos possibles avec des valeurs de points allant de 0 à 6. Attention : [1|0] et [0|1] sont les mêmes dominos. """
liste = []
for i in range(0:7):
    for j in range (i:7):
        append.liste(Domino(i,j))
return liste


# 3

def choisit_alea(liste):
    """Tire au hasard un domino dans une liste de dominos. Ce domino est supprimé de la liste et retourné par la fonction
    
    Parameters
    ----------
    liste : liste
    
    Returns
    ------
    domino_idx : Domino
    """
domino_idx = rnd.randint(0, len(self.__dominos_restant) - 1)    
return self.__dominos_restant.pop(domino_idx)    
    