# 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)