Mise à jour de 'README.md'

Reviewed-on: #1

README.md

@@ -1,2 +1,73 @@
+ # Notation
+
++ Réalisation pratique du projet : 4/5
+    + Pas d'interpréteur valide mais un début
+
++ Bonnes pratiques de programmation : 4/5
+    + interpreteur.py : aucune fonction, tout est dans le programme principal...
+
++ Communication : 2/5
+    + pas de documentation ou presque.
+
++ Revue de projet : 4/5
+    + TB mais pas de jeux de tests permettant de valider la démarche
+
+
+
 # Premier_projet_Kylian_Louis
 
+## Mardi 13/09/2022 Louis 
+* prise en main 
+* groupe formes.py, réalisation de la fonction trace_rectangle() et de la fonction rectangle()
+* rajout de la documentation de rectangle et de trace_rectangle
+
+```python
+def trace_rectangle(feutre, cote) 
+def rectangle(cote, infos, coordonnees)
+```
+
+# Mardi 13/09/2022 Kylian
+* prise en main
+* groupe formes.py, réalisation de la fonction trace_triangle_isocele() et la fonction triangle_isocele()
+* rajout de la documentation de triangle_isocele et trace_triangle_isocele
+
+```python
+def trace_triangle_isocele(feutre, largeur, hauteur, x, y)
+def triangle_isocele(hauteur, largeur, infos, coordonnees)
+```
+
+# Mardi 13/09/2022 Kylian, Louis
+* 20 minutes de débug de programmes (espace en trop a la ligne 194 de formes.py)
+
+# Jeudi 15/09/2022 Kylian, Louis
+* correction de la fonction rectangle et trace_rectangle.
+
+```python
+def rectangle(largeur, hauteur, infos, coordonnees):
+def trace_rectangle(feutre, largeur, hauteur):
+```
+* creation de la façade de 4 immeubles avec leur hauteur générer aléatoirement.
+* Kylian: creation des toits
+
+# Dimanche 18/09/2022 Kylian
+
+* creation de la fonction dessiner_porte
+
+# Samedi 24/09/2022 Kylian
+
+* debut de creation des fenetres (premier etage)
+
+## Mardi 27/09/2022 Kylian/Louis
+
+* terminaison fonction creation des fenetres(tout les étages)
+* création variation de toit
+
+# Jeudi 06/10/2022 Louis
+
+* création de la fonction choisir_couleur qui permet de choisir une couleur aléatoirement
+
+## Jeudi 13/10/2022 Kylian/Louis
+
+* correction lignes de code en trop
+* documentation
+* debut interpreteur

fichier_enfant.txt

@@ -0,0 +1,4 @@
+red-6-3-1
+blue-4-1-1
+purple-2-3-2
+green-5-2-2

formes.py

@@ -1,177 +1,215 @@
-'''Ce fichier permet de dessiner deux formes à l'aide des deux fonctions suivantes
+'''Ce fichier permet de dessiner deux formes à l'aide des deux fonctions suivantes
- 
+ 
-+ triangle_equilateral(cote, infos, coordonnees)
++ triangle_equilateral(cote, infos, coordonnees)
-+ arc_de_cercle(rayon, angle, infos, coordonnees)
++ arc_de_cercle(rayon, angle, infos, coordonnees)
- 
+ 
-Exemples d'utilisation :
+Exemples d'utilisation :
->>> infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
+>>> infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
->>> triangle_equilateral(50, infos_generales, (50,100))
+>>> triangle_equilateral(50, infos_generales, (50,100))
->>> arc_de_cercle(75, 360, infos_generales, (200,-200))
+>>> arc_de_cercle(75, 360, infos_generales, (200,-200))
- 
+ 
-'''
+'''
- 
+ 
-# Importation
+# Importation
- 
+ 
-import turtle as trt
+import turtle as trt
-import random as rd
+import random as rd
- 
+ 
-# Pas de classes
+# Pas de classes
- 
+ 
-# Déclaration des fonctions privées
+# Déclaration des fonctions privées
- 
+ 
-def nouveau_stylo(ecriture, fond, largeur):
+def nouveau_stylo(ecriture, fond, largeur):
-    '''Renvoie la référence d'un stylo configuré
+    '''Renvoie la référence d'un stylo configuré
- 
+ 
-    :: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
+    :: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
-    :: param fond(str)      :: la couleur de fond pour ce stylo
+    :: param fond(str)      :: la couleur de fond pour ce stylo
-    :: param largeur(int)   :: la largeur du trait
+    :: param largeur(int)   :: la largeur du trait
-    :: return (Turtle)      :: renvoie un objet de la classe Turtle
+    :: return (Turtle)      :: renvoie un objet de la classe Turtle
- 
+ 
-    '''
+    '''
-    feutre = trt.Turtle()
+    feutre = trt.Turtle()
-    feutre.color(ecriture)
+    feutre.color(ecriture)
-    feutre.fillcolor(fond)
+    feutre.fillcolor(fond)
-    feutre.pensize(largeur)
+    feutre.pensize(largeur)
-    feutre.speed(5)
+    feutre.speed(5)
-    return feutre
+    return feutre
- 
+ 
-def deplacer(feutre, x, y):
+def deplacer(feutre, x, y):
-    '''Lève le feutre, déplace le feutre et abaisse le feutre
+    '''Lève le feutre, déplace le feutre et abaisse le feutre
- 
+ 
-    :: param feutre(Turtle) :: la référence de l'objet Turtle
+    :: param feutre(Turtle) :: la référence de l'objet Turtle
-    :: param x(int)         :: coordonnée horizontale (abscisse)
+    :: param x(int)         :: coordonnée horizontale (abscisse)
-    :: param y(int)         :: coordonnée verticale (ordonnée)
+    :: param y(int)         :: coordonnée verticale (ordonnée)
-    :: return (None)        :: c'est une fonction sans retour
+    :: return (None)        :: c'est une fonction sans retour
-    .. effet de bord        :: modifie l'état de feutre
+    .. effet de bord        :: modifie l'état de feutre
- 
+ 
-    '''
+    '''
-    feutre.penup()       # On lève la pointe
+    feutre.penup()       # On lève la pointe
-    feutre.goto(x, y)  # On déplace le crayon
+    feutre.goto(x, y)  # On déplace le crayon
-    feutre.pendown()     # On abaisse la pointe
+    feutre.pendown()     # On abaisse la pointe
- 
+ 
-def trace_triangle_equilateral(feutre, cote):
+def trace_triangle_equilateral(feutre, cote):
-    '''Trace un triangle (equilatéral) à l'aide du crayon feutre
+    '''Trace un triangle (equilatéral) à l'aide du crayon feutre
- 
+ 
-    :: param ftr(Turtle)    :: la référence de l'objet Turtle
+    :: param ftr(Turtle)    :: la référence de l'objet Turtle
-    :: param cote(int)      :: la valeur en pixel des côtés 
+    :: param cote(int)      :: la valeur en pixel des côtés 
-    :: return (None)        :: fonction sans retour
+    :: return (None)        :: fonction sans retour
-    .. effet de bord        :: modifie l'état de feutre
+    .. effet de bord        :: modifie l'état de feutre
- 
+ 
-    '''
+    '''
-    feutre.begin_fill()
+    feutre.begin_fill()
-    for x in range(3):
+    for x in range(3):
-        feutre.forward(cote)
+        feutre.forward(cote)
-        feutre.left(120)
+        feutre.left(120)
-    feutre.end_fill()
+    feutre.end_fill()
-    feutre.hideturtle()
+    feutre.hideturtle()
- 
+ 
-def trace_arc(feutre, rayon, angle):
+def trace_arc(feutre, rayon, angle):
-    '''Trace un arc de cercle à l'aide du crayon feutre
+    '''Trace un arc de cercle à l'aide du crayon feutre
- 
+ 
-    :: param ftr(Turtle)    :: la référence de l'objet Turtle
+    :: param ftr(Turtle)    :: la référence de l'objet Turtle
-    :: param rayon(int)     :: la valeur en pixel du rayon
+    :: param rayon(int)     :: la valeur en pixel du rayon
-    :: param angle(int)     :: l'angle à tracer (360 pour un cercle)
+    :: param angle(int)     :: l'angle à tracer (360 pour un cercle)
-    :: return (None)        :: fonction sans retour
+    :: return (None)        :: fonction sans retour
-    .. effet de bord        :: modifie l'état de feutre
+    .. effet de bord        :: modifie l'état de feutre
- 
+ 
-    '''
+    '''
-    feutre.begin_fill()
+    feutre.begin_fill()
-    feutre.circle(rayon, angle)
+    feutre.circle(rayon, angle)
-    feutre.end_fill()
+    feutre.end_fill()
-    feutre.hideturtle()
+    feutre.hideturtle()
- 
+ 
-def trace_rectangle(feutre, cote):
+def trace_rectangle(feutre, largeur, hauteur):
-    '''Trace un rectangle à l'aide du crayon feutre
+    '''Trace un rectangle à l'aide du crayon feutre
- 
+ 
-    :: param ftr(Turtle)    :: la référence de l'objet Turtle
+    :: param ftr(Turtle)    :: la référence de l'objet Turtle
-    :: param cote(int)      :: la valeur en pixel des côtés 
+    :: param largeur(int)   :: la valeur en pixel de la largeur
-    :: return (None)        :: fonction sans retour
+    :: param hauteur(int)   :: la valeur en pixel de la hauteur
-    .. effet de bord        :: modifie l'état de feutre
+    :: return (None)        :: fonction sans retour
-    
+    .. effet de bord        :: modifie l'état de feutre
-    '''
+    
-    feutre.begin_fill()
+    '''
-    for x in range(2):
+    feutre.begin_fill()
-        feutre.forward(cote)
+    for x in range(2):
-        feutre.left(90)
+        feutre.forward(largeur)
-        feutre.forward(cote*2)
+        feutre.left(90)
-        feutre.left(90)
+        feutre.forward(hauteur)
-    feutre.end_fill()
+        feutre.left(90)
-    feutre.hideturtle()
+    feutre.end_fill()
-    
+    feutre.hideturtle()
-
+
-# Déclarations des fonctions d'interface (aucun paramètre n'est lié au module Turtle)
+def trace_triangle_isocele(feutre, largeur, hauteur, x, y):
- 
+    '''Trace un triangle (isocele) à l'aide du crayon feutre
-def triangle_equilateral(cote, infos, coordonnees):
+ 
-    '''Trace un triangle (equilatéral) à partir des infos et aux bonnees coordonnées
+    :: param ftr(Turtle)    :: la référence de l'objet Turtle
- 
+    :: param largeur(int)      :: la valeur en pixel de la largeur
-    :: param cote(int)                     :: la valeur en pixel des côtés
+    :: param hauteur(int) :: la valeur en pixel de la hauteur
-    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+    :: param x(int) :: position de depart en x
-    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+    :: param y(int) :: position de depart en y
- 
+    :: return (None)        :: fonction sans retour
-    '''
+    .. effet de bord        :: modifie l'état de feutre
-    ecriture = infos['écriture']
+ 
-    fond = infos['fond']
+    '''
-    epaisseur = infos['épaisseur']
+    feutre.begin_fill()
-    x = coordonnees[0]                  # ou x,y = coordonnees
+    feutre.goto(x + largeur//2, hauteur + y)
-    y = coordonnees[1]
+    feutre.goto(x + largeur, y)
- 
+    feutre.goto(x, y)
-    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    feutre.end_fill()
-    deplacer(feutre, x, y)
+    feutre.hideturtle()
-    trace_triangle_equilateral(feutre, cote)
+    
- 
+# Déclarations des fonctions d'interface (aucun paramètre n'est lié au module Turtle)
-    return feutre
+ 
- 
+def triangle_equilateral(cote, infos, coordonnees):
-def arc_de_cercle(rayon, angle, infos, coordonnees):
+    '''Trace un triangle (equilatéral) à partir des infos et aux bonnees coordonnées
-    '''Trace un arc de cercle à partir des infos et aux bonnees coordonnées
+ 
- 
+    :: param cote(int)                     :: la valeur en pixel des côtés
-    :: param rayon(int)                    :: la valeur en pixel du rayon
+    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
-    :: param angle(int)                    :: la valeur en ° de l'angle
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
-    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+ 
-    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+    '''
- 
+    ecriture = infos['écriture']
-    '''
+    fond = infos['fond']
-    ecriture = infos['écriture']
+    epaisseur = infos['épaisseur']
-    fond = infos['fond']
+    x = coordonnees[0]                  # ou x,y = coordonnees
-    epaisseur = infos['épaisseur']
+    y = coordonnees[1]
-    x = coordonnees[0]                  # ou x,y = coordonnees
+ 
-    y = coordonnees[1]
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
- 
+    deplacer(feutre, x, y)
-    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    trace_triangle_equilateral(feutre, cote)
-    deplacer(feutre, x, y)
+ 
-    trace_arc(feutre, rayon, angle)
+    return feutre
- 
+
-    return feutre
+def triangle_isocele(hauteur, largeur, infos, coordonnees):
-
+    '''Trace un triangle (equilatéral) à partir des infos et aux bonnees coordonnées
-
+ 
-    
+    :: param hauteur(int) :: la valeur en pixel de la hauteur
-def rectangle(cote, infos, coordonnees):
+    :: param largeur(int) :: la valeur en pixel de la largeur
-     '''Trace un rectangle à partir des infos et aux bonnees coordonnées
+    :: param infos(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
- 
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
-    :: param cote(int)                     :: la valeur en pixel des côtés
+ 
-    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+    '''
-    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+    ecriture = infos['écriture']
-    
+    fond = infos['fond']
-    '''
+    epaisseur = infos['épaisseur']
-    ecriture = infos['écriture']
+    x = coordonnees[0]                  # ou x,y = coordonnees
-    fond = infos['fond']
+    y = coordonnees[1]
-    epaisseur = infos['épaisseur']
+ 
-    x = coordonnees[0]                  # ou x,y = coordonnees
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
-    y = coordonnees[1]
+    deplacer(feutre, x, y)
- 
+    trace_triangle_isocele(feutre, largeur, hauteur, x, y)
-    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+
-    deplacer(feutre, x, y)
+    return feutre
-    trace_rectangle(feutre, cote)
+ 
- 
+def arc_de_cercle(rayon, angle, infos, coordonnees):
-    return feutre
+    '''Trace un arc de cercle à partir des infos et aux bonnees coordonnées
-
+ 
-    
+    :: param rayon(int)                    :: la valeur en pixel du rayon
-    
+    :: param angle(int)                    :: la valeur en ° de l'angle
- 
+    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
-# Corps du programme principal
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
- 
+ 
-if __name__ == '__main__':
+    '''
- 
+    ecriture = infos['écriture']
-    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
+    fond = infos['fond']
-    triangle_equilateral(50, infos_generales, (50,100))
+    epaisseur = infos['épaisseur']
-    arc_de_cercle(75, 360, infos_generales, (200,-200))
+    x = coordonnees[0]                  # ou x,y = coordonnees
-    rectangle(100, infos_generales, (-200,50))
+    y = coordonnees[1]
+ 
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    deplacer(feutre, x, y)
+    trace_arc(feutre, rayon, angle)
+ 
+    return feutre
+
+
+    
+def rectangle(largeur, hauteur, infos, coordonnees):
+    '''Trace un rectangle à partir des infos et aux bonnees coordonnées
+ 
+    :: param largeur(int)                  :: la valeur en pixel de la largeur
+    :: param hauteur(int)                  :: la valeur en pixel de la hauteur
+    :: param infos(dict)                   :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
+    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
+    
+    '''
+    ecriture = infos['écriture']
+    fond = infos['fond']
+    epaisseur = infos['épaisseur']
+    x = coordonnees[0]                  # ou x,y = coordonnees
+    y = coordonnees[1]
+ 
+    feutre = nouveau_stylo(ecriture, fond, epaisseur)
+    deplacer(feutre, x, y)
+    trace_rectangle(feutre, largeur, hauteur)
+ 
+    return feutre
+
+# Corps du programme principal
+ 
+if __name__ == '__main__':
+ 
+    infos_generales = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
+    triangle_equilateral(50, infos_generales, (50,100))
+    arc_de_cercle(75, 360, infos_generales, (200,-200))
+    rectangle(100, 200, infos_generales, (0,0))

interpreteur.py

@@ -0,0 +1,20 @@
+import rue 
+
+# 1 - Création de l'objet-fichier : ouverture en mode r (read)
+obj_fichier = open('fichier_enfant.txt', 'r', encoding="utf-8")
+ 
+# 2 - Lecture progressive du fichier
+immeuble_1  = obj_fichier.readline().replace('\n', '')
+immeuble_2  = obj_fichier.readline().replace('\n', '')
+immeuble_3  = obj_fichier.readline().replace('\n', '')
+immeuble_4  = obj_fichier.readline().replace('\n', '')
+ 
+# 3 - Fermeture de l'objet-fichier
+obj_fichier.close()
+
+print(immeuble_1.split('-'))
+print(immeuble_2.split('-'))
+print(immeuble_3.split('-'))
+print(immeuble_4.split('-'))
+ensemble = [immeuble_1, immeuble_2, immeuble_3, immeuble_4]
+rue.dessiner_rue_enfant(ensemble)

rue.py

@@ -1,36 +1,115 @@
-# Importation
+# Importation
- 
+ 
-from formes import triangle_equilateral
+from formes import triangle_equilateral
- 
+from formes import triangle_isocele
-# Fonction gestion des données
+from formes import rectangle
- 
+import random
-def determiner_immeuble(numero:int) -> dict:
+ 
-    caracteristiques = {}
+# Fonction gestion des données
-    caracteristiques['couleur_facade'] = 'red'
+lesCouleurs = ['red', 'blue', 'green', 'violet', 'yellow', 'orange', 'magenta']
-    caracteristiques['numero'] = numero
+ 
-    return caracteristiques
+def determiner_immeuble(numero:int) -> dict:
- 
+    caracteristiques = {}
-# Fonctions d'interface graphique
+    caracteristiques['couleur_facade'] = choisir_couleur(lesCouleurs)
- 
+    caracteristiques['numero'] = numero
-def dessiner_facade(informations:dict):
+    caracteristiques['coordonnees'] = -350 + numero * 170
-    facade = {}  # pour faire la "traduction" entre les clés de ce module et les clés du module formes
+    caracteristiques['etage'] = random.randint(1,6)
-    facade['écriture'] = 'blue'
+    caracteristiques['porte'] = random.randint(1,3)
-    facade['fond'] = informations['couleur_facade']
+    caracteristiques['toit_variant'] = random.randint(1,2)
-    facade['épaisseur'] = 5 * informations['numero']
+    caracteristiques['fenetre'] = 1    
-    triangle_equilateral(50, facade, (0,0))
+        
- 
+    return caracteristiques
-def dessiner_porte(informations:dict):
+
-    pass
+def determiner_immeuble_enfant(numero:int, tab:list) -> dict:
- 
+    caracteristiques = {}
-def dessiner_immeuble(informations:dict):
+    caracteristiques['couleur_facade'] = tab[0]
-    dessiner_facade(informations)
+    caracteristiques['numero'] = numero
-    dessiner_porte(informations)
+    caracteristiques['coordonnees'] = -350 + numero * 170
-    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
+    caracteristiques['etage'] = tab=[1]
- 
+    caracteristiques['porte'] = tab=[2]
-# Programme principal
+    caracteristiques['toit_variant'] = tab=[3]
- 
+    caracteristiques['fenetre'] = 1    
-if __name__ == '__main__':
+        
- 
+    return caracteristiques
-    for x in range(4):
+# Fonctions d'interface graphique
-        infos_immeuble = determiner_immeuble(x)
+ 
-        dessiner_immeuble(infos_immeuble)
+def dessiner_facade(informations:dict):
+    facade = {}  # pour faire la "traduction" entre les clés de ce module et les clés du module formes
+    facade['écriture'] = 'blue'
+    facade['fond'] = informations['couleur_facade']
+    facade['épaisseur'] = 1
+    x0 = informations['coordonnees']
+    hauteur = informations['etage'] * 80
+    rectangle(140, hauteur, facade, (x0, -200))
+ 
+def dessiner_porte(informations:dict):
+    porte = {}
+    porte['écriture'] = 'brown'
+    porte['fond'] = 'brown'
+    porte['épaisseur'] = 1
+    x0 = informations['coordonnees']
+    position = informations['porte']
+    rectangle(30, 50, porte, (x0 + (position * 40) -25, -200))
+    
+def dessiner_fenetres(informations:dict):
+    fenetre = {} 
+    fenetre['écriture'] = 'black' 
+    fenetre['fond'] = 'cyan' 
+    fenetre['épaisseur'] = 1
+    x0 = informations['coordonnees'] 
+    position = informations['fenetre'] 
+    for etage in range(0,informations['etage']): 
+        rectangle(30, 30, fenetre, (x0 + (position * 40) -25, -180 + etage*80))
+        rectangle(30, 30, fenetre, (x0 + (position * 80) -25, -180 + etage*80))
+        rectangle(30, 30, fenetre, (x0 + (position * 120) -25, -180 + etage*80))
+        
+def dessiner_toit(informations:dict):
+    toit = {}
+    toit['écriture'] = 'black'
+    toit['fond'] = 'black'
+    toit['épaisseur'] = 1
+    x0 = informations['coordonnees']
+    hauteur = informations['etage'] * 80
+    variant = random.randint(1,2)
+    if informations['toit_variant'] == 1:
+        triangle_isocele(50, 140, toit,(x0,hauteur - 200))
+    else:
+        rectangle(180, 10, toit,(x0-20, hauteur - 200))
+        
+        
+        
+        
+def choisir_couleur(lesCouleurs:list)->int:
+    '''Choisi une couleur aléatoirement'''
+    i = random.randint(0,len(lesCouleurs)-1) #choisi unn couleur aléatoire dans le tableau lesCouleurs
+    return lesCouleurs[i]
+        
+    
+    
+    
+
+    
+    
+def dessiner_immeuble(informations:dict):
+    dessiner_facade(informations)
+    dessiner_toit(informations)
+    dessiner_fenetres(informations)
+    dessiner_porte(informations)
+    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
+    
+def dessiner_rue_enfant(ensemble:list):
+    for i in range(len(ensemble)):
+        infos_immeuble = determiner_immeuble_enfant(i, ensemble[i])
+        dessiner_immeuble(infos_immeuble)    
+ 
+# Programme principal
+ 
+if __name__ == '__main__':
+ 
+    for x in range(4):
+        infos_immeuble = determiner_immeuble(x)
+        dessiner_immeuble(infos_immeuble)
+
+
+    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
+