Kylian.B-M
/
Premier_projet_Kylian_Louis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: Kylian.B-M:master
Branches Tags
Kylian.B-M:louis.l-patch-1
Kylian.B-M:master
..
compare: Kylian.B-M:louis.l-patch-1
Branches Tags
Kylian.B-M:louis.l-patch-1
Kylian.B-M:master

No commits in common. 'master' and 'louis.l-patch-1' have entirely different histories.
master ... louis.l-pa

5 changed files with 213 additions and 425 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats
  1. 71
      README.md
  2. 4
      fichier_enfant.txt
  3. 60
      formes.py
  4. 20
      interpreteur.py
  5. 87
      rue.py

71
README.md
Unescape View File

@ -1,73 +1,2 @@
# 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

4
fichier_enfant.txt
Unescape View File

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

60
formes.py
Unescape View File

@ -80,43 +80,24 @@ def trace_arc(feutre, rayon, angle):
feutre.end_fill()
feutre.hideturtle()
def trace_rectangle(feutre, largeur, hauteur):
def trace_rectangle(feutre, cote):
'''Trace un rectangle à l'aide du crayon feutre
:: param ftr(Turtle) :: la référence de l'objet Turtle
:: param largeur(int) :: la valeur en pixel de la largeur
:: param hauteur(int) :: la valeur en pixel de la hauteur
:: param cote(int) :: la valeur en pixel des côtés
:: return (None) :: fonction sans retour
.. effet de bord :: modifie l'état de feutre
'''
feutre.begin_fill()
for x in range(2):
feutre.forward(largeur)
feutre.forward(cote)
feutre.left(90)
feutre.forward(hauteur)
feutre.forward(cote*2)
feutre.left(90)
feutre.end_fill()
feutre.hideturtle()
def trace_triangle_isocele(feutre, largeur, hauteur, x, y):
'''Trace un triangle (isocele) à l'aide du crayon feutre
:: param ftr(Turtle) :: la référence de l'objet Turtle
:: param largeur(int) :: la valeur en pixel de la largeur
:: param hauteur(int) :: la valeur en pixel de la hauteur
:: param x(int) :: position de depart en x
:: param y(int) :: position de depart en y
:: return (None) :: fonction sans retour
.. effet de bord :: modifie l'état de feutre
'''
feutre.begin_fill()
feutre.goto(x + largeur//2, hauteur + y)
feutre.goto(x + largeur, y)
feutre.goto(x, y)
feutre.end_fill()
feutre.hideturtle()
# Déclarations des fonctions d'interface (aucun paramètre n'est lié au module Turtle)
@ -140,27 +121,6 @@ def triangle_equilateral(cote, infos, coordonnees):
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
:: param largeur(int) :: la valeur en pixel de la largeur
:: 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_triangle_isocele(feutre, largeur, hauteur, x, y)
return feutre
def arc_de_cercle(rayon, angle, infos, coordonnees):
'''Trace un arc de cercle à partir des infos et aux bonnees coordonnées
@ -184,11 +144,10 @@ def arc_de_cercle(rayon, angle, infos, coordonnees):
def rectangle(largeur, hauteur, infos, coordonnees):
def rectangle(cote, 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 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)
@ -201,10 +160,13 @@ def rectangle(largeur, hauteur, infos, coordonnees):
feutre = nouveau_stylo(ecriture, fond, epaisseur)
deplacer(feutre, x, y)
trace_rectangle(feutre, largeur, hauteur)
trace_rectangle(feutre, cote)
return feutre
# Corps du programme principal
if __name__ == '__main__':
@ -212,4 +174,4 @@ 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))
rectangle(100, infos_generales, (-200,50))

20
interpreteur.py
Unescape View File

@ -1,20 +0,0 @@
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)

87
rue.py
Unescape View File

@ -1,107 +1,32 @@
# Importation
from formes import triangle_equilateral
from formes import triangle_isocele
from formes import rectangle
import random
# Fonction gestion des données
lesCouleurs = ['red', 'blue', 'green', 'violet', 'yellow', 'orange', 'magenta']
def determiner_immeuble(numero:int) -> dict:
caracteristiques = {}
caracteristiques['couleur_facade'] = choisir_couleur(lesCouleurs)
caracteristiques['couleur_facade'] = 'red'
caracteristiques['numero'] = numero
caracteristiques['coordonnees'] = -350 + numero * 170
caracteristiques['etage'] = random.randint(1,6)
caracteristiques['porte'] = random.randint(1,3)
caracteristiques['toit_variant'] = random.randint(1,2)
caracteristiques['fenetre'] = 1
return caracteristiques
def determiner_immeuble_enfant(numero:int, tab:list) -> dict:
caracteristiques = {}
caracteristiques['couleur_facade'] = tab[0]
caracteristiques['numero'] = numero
caracteristiques['coordonnees'] = -350 + numero * 170
caracteristiques['etage'] = tab=[1]
caracteristiques['porte'] = tab=[2]
caracteristiques['toit_variant'] = tab=[3]
caracteristiques['fenetre'] = 1
return caracteristiques
# Fonctions d'interface graphique
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))
facade['épaisseur'] = 5 * informations['numero']
triangle_equilateral(50, facade, (0,0))
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]
pass
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__':
@ -109,7 +34,3 @@ 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...

Write Preview
Loading…
Cancel
Save