Test 1 #1

There is no content yet.

"""Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes

triangle_equilateral(cote, info_feutre, coordonnees)
arc_de_cercle(rayon, angle, info_feutre, coordonnees)

Exemples d'utilisation :

informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
triangle_equilateral(50, informations_feutre, (50,100))
arc_de_cercle(75, 360, informations_feutre, (200,-200))
"""

Importation

import turtle as trt
import random as rd

Déclaration des fonctions privées

def nouveau_stylo(ecriture, fond, largeur):
"""Renvoie la référence d'un stylo configuré

:: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
:: param fond(str)      :: la couleur de fond pour ce stylo
:: param largeur(int)   :: la largeur du trait
:: return (Turtle)      :: renvoie un objet de la classe Turtle

"""
feutre = trt.Turtle()
feutre.color(ecriture)
feutre.fillcolor(fond)
feutre.pensize(largeur)
feutre.speed(5)
return feutre

def deplacer(feutre, x, y):
"""Lève le feutre, déplace le feutre et abaisse le feutre

:: param feutre(Turtle) :: la référence de l'objet Turtle
:: param x(int)         :: coordonnée horizontale (abscisse)
:: param y(int)         :: coordonnée verticale (ordonnée)
:: return (None)        :: c'est une fonction sans retour
.. effet de bord        :: modifie l'état de feutre

"""
feutre.penup()       # On lève la pointe
feutre.goto(x, y)  # On déplace le crayon
feutre.pendown()     # On abaisse la pointe

def trace_triangle_equilateral(feutre, cote):
"""Trace un triangle (equilatéral) à l'aide du crayon feutre

:: param feutre(Turtle) :: la référence de l'objet Turtle
:: 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(3):
    feutre.forward(cote)
    feutre.left(120)
feutre.end_fill()
feutre.hideturtle()

def trace_arc(feutre, rayon, angle):
"""Trace un arc de cercle à l'aide du crayon feutre

:: param feutre(Turtle) :: la référence de l'objet Turtle
:: param rayon(int)     :: la valeur en pixel du rayon
:: param angle(int)     :: l'angle à tracer (360 pour un cercle)
:: return (None)        :: fonction sans retour
.. effet de bord        :: modifie l'état de feutre

"""
feutre.begin_fill()
feutre.circle(rayon, angle)
feutre.end_fill()
feutre.hideturtle()

Déclarations des fonctions publiques

def triangle_equilateral(cote, info_feutre, coordonnees):
"""Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées

:: param cote(int)                     :: la valeur en pixel des côtés
:: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
:: param coordonnees(tuple (int,int) ) :: un tuple (x,y)

"""
ecriture = info_feutre['écriture']
fond = info_feutre['fond']
epaisseur = info_feutre['épaisseur']
x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
y = coordonnees[1]

feutre = nouveau_stylo(ecriture, fond, epaisseur)
deplacer(feutre, x, y)
trace_triangle_equilateral(feutre, cote)

return feutre

def arc_de_cercle(rayon, angle, info_feutre, coordonnees):
"""Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées

:: param rayon(int)                    :: la valeur en pixel du rayon
:: param angle(int)                    :: la valeur en ° de l'angle
:: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
:: param coordonnees(tuple (int,int) ) :: un tuple (x,y)

"""
ecriture = info_feutre['écriture']
fond = info_feutre['fond']
epaisseur = info_feutre['épaisseur']
x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
y = coordonnees[1]

feutre = nouveau_stylo(ecriture, fond, epaisseur)
deplacer(feutre, x, y)
trace_arc(feutre, rayon, angle)

return feutre

Instructions du programme principal

if name == 'main':

informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5}
triangle_equilateral(50, informations_feutre, (50,100))
arc_de_cercle(75, 360, informations_feutre, (200,-200))

"""Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes + triangle_equilateral(cote, info_feutre, coordonnees) + arc_de_cercle(rayon, angle, info_feutre, coordonnees) Exemples d'utilisation : >>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5} >>> triangle_equilateral(50, informations_feutre, (50,100)) >>> arc_de_cercle(75, 360, informations_feutre, (200,-200)) """ # Importation import turtle as trt import random as rd # Déclaration des fonctions privées def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré :: param ecriture(str) :: la couleur d'écriture ('red', '#FF0000') :: param fond(str) :: la couleur de fond pour ce stylo :: param largeur(int) :: la largeur du trait :: return (Turtle) :: renvoie un objet de la classe Turtle """ feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre def deplacer(feutre, x, y): """Lève le feutre, déplace le feutre et abaisse le feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param x(int) :: coordonnée horizontale (abscisse) :: param y(int) :: coordonnée verticale (ordonnée) :: return (None) :: c'est une fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe def trace_triangle_equilateral(feutre, cote): """Trace un triangle (equilatéral) à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: 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(3): feutre.forward(cote) feutre.left(120) feutre.end_fill() feutre.hideturtle() def trace_arc(feutre, rayon, angle): """Trace un arc de cercle à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param rayon(int) :: la valeur en pixel du rayon :: param angle(int) :: l'angle à tracer (360 pour un cercle) :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.begin_fill() feutre.circle(rayon, angle) feutre.end_fill() feutre.hideturtle() # Déclarations des fonctions publiques def triangle_equilateral(cote, info_feutre, coordonnees): """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées :: param cote(int) :: la valeur en pixel des côtés :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_triangle_equilateral(feutre, cote) return feutre def arc_de_cercle(rayon, angle, info_feutre, coordonnees): """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées :: param rayon(int) :: la valeur en pixel du rayon :: param angle(int) :: la valeur en ° de l'angle :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_arc(feutre, rayon, angle) return feutre # Instructions du programme principal if __name__ == '__main__': informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5} triangle_equilateral(50, informations_feutre, (50,100)) arc_de_cercle(75, 360, informations_feutre, (200,-200))

c le squelette

def trace_rectangle(feutre,cote1,cote2) :
    """Trace un rectangle à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param cote1(int)     :: la valeur en pixel d'un côté
    :: param cote2(int)     :: la valeur en pixel de l'autre côté
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    for c in range(2) :
        feutre.forward(cote1)
        feutre.left(90)
        feutre.forward(cote2)
        feutre.left(90)
        
trace_rectangle(nouveau_stylo("blue",'#FF88FF',5),140,80)

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

"""Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes
 
+ triangle_equilateral(cote, info_feutre, coordonnees)
+ arc_de_cercle(rayon, angle, info_feutre, coordonnees)
 
 
Exemples d'utilisation :
>>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
>>> triangle_equilateral(50, informations_feutre, (50,100))
>>> arc_de_cercle(75, 360, informations_feutre, (200,-200))
"""
 
 
# Importation
 
import turtle as trt
import random as rd
 
# Déclaration des fonctions privées
 
def nouveau_stylo(ecriture, fond, largeur):
    """Renvoie la référence d'un stylo configuré
 
    :: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
    :: param fond(str)      :: la couleur de fond pour ce stylo
    :: param largeur(int)   :: la largeur du trait
    :: return (Turtle)      :: renvoie un objet de la classe Turtle
 
    """
    feutre = trt.Turtle()
    feutre.color(ecriture)
    feutre.fillcolor(fond)
    feutre.pensize(largeur)
    feutre.speed(5)
    return feutre
 
def deplacer(feutre, x, y):
    """Lève le feutre, déplace le feutre et abaisse le feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param x(int)         :: coordonnée horizontale (abscisse)
    :: param y(int)         :: coordonnée verticale (ordonnée)
    :: return (None)        :: c'est une fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    feutre.penup()       # On lève la pointe
    feutre.goto(x, y)  # On déplace le crayon
    feutre.pendown()     # On abaisse la pointe

def trace_rectangle(feutre,cote1,cote2) :
    """Trace un rectangle à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param cote1(int)     :: la valeur en pixel d'un côté
    :: param cote2(int)     :: la valeur en pixel de l'autre côté
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    for c in range(2) :
        feutre.forward(cote1)
        feutre.left(90)
        feutre.forward(cote2)
        feutre.left(90)
    feutre.hideturtle()
    
def trace_triangle_equilateral(feutre, cote):
    """Trace un triangle (equilatéral) à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: 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(3):
        feutre.forward(cote)
        feutre.left(120)
    feutre.end_fill()
    feutre.hideturtle()
 
def trace_arc(feutre, rayon, angle):
    """Trace un arc de cercle à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param rayon(int)     :: la valeur en pixel du rayon
    :: param angle(int)     :: l'angle à tracer (360 pour un cercle)
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    feutre.begin_fill()
    feutre.circle(rayon, angle)
    feutre.end_fill()
    feutre.hideturtle()
 
 
# Déclarations des fonctions publiques

def rectangle(cote, info_feutre, coordonnees):
    """Trace un rectangle à partir des info_feutre et aux bonnees coordonnées
 
    :: param cote(tuple[int])              :: la valeur en pixel des côtés
    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    """
    ecriture = info_feutre['écriture']
    fond = info_feutre['fond']
    epaisseur = info_feutre['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
    y = coordonnees[1]
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_rectangle(feutre, cote[0],cote[1])
    
def triangle_equilateral(cote, info_feutre, coordonnees):
    """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées
 
    :: param cote(int)                     :: la valeur en pixel des côtés
    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    """
    ecriture = info_feutre['écriture']
    fond = info_feutre['fond']
    epaisseur = info_feutre['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_triangle_equilateral(feutre, cote)
 
    return feutre

def arc_de_cercle(rayon, angle, info_feutre, coordonnees):
    """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées
 
    :: param rayon(int)                    :: la valeur en pixel du rayon
    :: param angle(int)                    :: la valeur en ° de l'angle
    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    """
    ecriture = info_feutre['écriture']
    fond = info_feutre['fond']
    epaisseur = info_feutre['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_arc(feutre, rayon, angle)
 
    return feutre
 
 
# Instructions du programme principal
 
if __name__ == '__main__':
    informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5}
    rectangle((140,80),informations_feutre,(-400,0))
    rectangle((140,80),informations_feutre,(-200,0))
    rectangle((140,80),informations_feutre,(0,0))
    rectangle((140,80),informations_feutre,(200,0))

```py """Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes + triangle_equilateral(cote, info_feutre, coordonnees) + arc_de_cercle(rayon, angle, info_feutre, coordonnees) Exemples d'utilisation : >>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5} >>> triangle_equilateral(50, informations_feutre, (50,100)) >>> arc_de_cercle(75, 360, informations_feutre, (200,-200)) """ # Importation import turtle as trt import random as rd # Déclaration des fonctions privées def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré :: param ecriture(str) :: la couleur d'écriture ('red', '#FF0000') :: param fond(str) :: la couleur de fond pour ce stylo :: param largeur(int) :: la largeur du trait :: return (Turtle) :: renvoie un objet de la classe Turtle """ feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre def deplacer(feutre, x, y): """Lève le feutre, déplace le feutre et abaisse le feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param x(int) :: coordonnée horizontale (abscisse) :: param y(int) :: coordonnée verticale (ordonnée) :: return (None) :: c'est une fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe def trace_rectangle(feutre,cote1,cote2) : """Trace un rectangle à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param cote1(int) :: la valeur en pixel d'un côté :: param cote2(int) :: la valeur en pixel de l'autre côté :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de feutre """ for c in range(2) : feutre.forward(cote1) feutre.left(90) feutre.forward(cote2) feutre.left(90) feutre.hideturtle() def trace_triangle_equilateral(feutre, cote): """Trace un triangle (equilatéral) à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: 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(3): feutre.forward(cote) feutre.left(120) feutre.end_fill() feutre.hideturtle() def trace_arc(feutre, rayon, angle): """Trace un arc de cercle à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param rayon(int) :: la valeur en pixel du rayon :: param angle(int) :: l'angle à tracer (360 pour un cercle) :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.begin_fill() feutre.circle(rayon, angle) feutre.end_fill() feutre.hideturtle() # Déclarations des fonctions publiques def rectangle(cote, info_feutre, coordonnees): """Trace un rectangle à partir des info_feutre et aux bonnees coordonnées :: param cote(tuple[int]) :: la valeur en pixel des côtés :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_rectangle(feutre, cote[0],cote[1]) def triangle_equilateral(cote, info_feutre, coordonnees): """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées :: param cote(int) :: la valeur en pixel des côtés :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_triangle_equilateral(feutre, cote) return feutre def arc_de_cercle(rayon, angle, info_feutre, coordonnees): """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées :: param rayon(int) :: la valeur en pixel du rayon :: param angle(int) :: la valeur en ° de l'angle :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_arc(feutre, rayon, angle) return feutre # Instructions du programme principal if __name__ == '__main__': informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5} rectangle((140,80),informations_feutre,(-400,0)) rectangle((140,80),informations_feutre,(-200,0)) rectangle((140,80),informations_feutre,(0,0)) rectangle((140,80),informations_feutre,(200,0)) ```

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "blue"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x,y = coordonnees_facade(immeuble)
    rectangle((IMMEUBLE),crayon,(x,y))

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = (140,80)
COTE_FENETRE = 30
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    return informations
def porte_aleatoire()

def couleur_aleatoire() -> str:
    couleur = ("red","blue","yellow","magenta","green","purple")
    return couleur[rd.randint(0,5)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    cote = LARGEUR_IMMEUBLE
    # Demande d'affichage
    rectangle((IMMEUBLE),crayon,(x,y))
    triangle_equilateral(cote, crayon, (x,y))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "blue"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x,y = coordonnees_facade(immeuble)
    rectangle((IMMEUBLE),crayon,(x,y))
    
def dessiner_fenetre(immeuble:dict) -> None:
    pass
    
def dessiner_toit(immeuble:dict) -> None:
    pass

def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_porte(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = (140,80) COTE_FENETRE = 30 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) return informations def porte_aleatoire() def couleur_aleatoire() -> str: couleur = ("red","blue","yellow","magenta","green","purple") return couleur[rd.randint(0,5)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple cote = LARGEUR_IMMEUBLE # Demande d'affichage rectangle((IMMEUBLE),crayon,(x,y)) triangle_equilateral(cote, crayon, (x,y)) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "blue" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x,y = coordonnees_facade(immeuble) rectangle((IMMEUBLE),crayon,(x,y)) def dessiner_fenetre(immeuble:dict) -> None: pass def dessiner_toit(immeuble:dict) -> None: pass def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_porte(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = (140,80)
COTE_FENETRE = 30
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire()
    #info fenetre
    informations['type_fenetre'] = rd.randint(0,2) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("red","blue","yellow","magenta","green","purple")
    return couleur[rd.randint(0,5)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    for i in range(immeuble['nb_etage']) :
        rectangle(IMMEUBLE,crayon,(x,y+(i*IMMEUBLE[1])))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "blue"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x,y = coordonnees_facade(immeuble)
    rectangle((IMMEUBLE),crayon,(x,y))
    
def dessiner_fenetre(immeuble:dict) -> None:
    pass
    
def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += immeuble['nb_etage'] * IMMEUBLE[1]
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE[0]), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE[0])
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = (140,80) COTE_FENETRE = 30 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire() #info fenetre informations['type_fenetre'] = rd.randint(0,2) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("red","blue","yellow","magenta","green","purple") return couleur[rd.randint(0,5)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage for i in range(immeuble['nb_etage']) : rectangle(IMMEUBLE,crayon,(x,y+(i*IMMEUBLE[1]))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "blue" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x,y = coordonnees_facade(immeuble) rectangle((IMMEUBLE),crayon,(x,y)) def dessiner_fenetre(immeuble:dict) -> None: pass def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += immeuble['nb_etage'] * IMMEUBLE[1] if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE[0]), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE[0]) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

Philippe Adrien parle d'une «antichambre de la mort où l'humour parvient à peine à conjurer l'horreur»

def trace_rectangle(feutre,cote1,cote2) :
    """Trace un rectangle à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param cote1(int)     :: la valeur en pixel d'un côté
    :: param cote2(int)     :: la valeur en pixel de l'autre côté
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    feutre.begin_fill()
    for c in range(2) :
        feutre.forward(cote1)
        feutre.left(90)
        feutre.forward(cote2)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()


def couleur_aleatoire() -> str:
    couleur = ("white","cyan","black","silver","pink","brown","red","blue","yellow","magenta","green","purple")
    return couleur[rd.randint(0,12)]
    ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire()
    #info fenetre
    informations['type_fenetre'] = rd.randint(0,2) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("red","blue","yellow","magenta","green","purple")
    return couleur[rd.randint(0,5)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    rectangle((IMMEUBLE,(immeuble['nb_etage']+ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x,y = coordonnees_facade(immeuble)
    
def dessiner_fenetre(immeuble:dict) -> None:
    pass
    
def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += immeuble['nb_etage'] * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire() #info fenetre informations['type_fenetre'] = rd.randint(0,2) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("red","blue","yellow","magenta","green","purple") return couleur[rd.randint(0,5)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage rectangle((IMMEUBLE,(immeuble['nb_etage']+ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x,y = coordonnees_facade(immeuble) def dessiner_fenetre(immeuble:dict) -> None: pass def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += immeuble['nb_etage'] * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range((nb_etage*3)-1) :
        informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("red","blue","yellow","magenta","green","purple")
    return couleur[rd.randint(0,5)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x,y = coordonnees_facade(immeuble)
    
def dessiner_fenetre(immeuble:dict) -> None:
    for i in range(
    
def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire() #info fenetre informations['type_fenetre'] = [] for _ in range((nb_etage*3)-1) : informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("red","blue","yellow","magenta","green","purple") return couleur[rd.randint(0,5)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x,y = coordonnees_facade(immeuble) def dessiner_fenetre(immeuble:dict) -> None: for i in range( def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += (immeuble['nb_etage']+1) * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range((informations['nb_etage']*3)-1) :
        informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("red","blue","yellow","magenta","green","purple")
    return couleur[rd.randint(0,5)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x,y = coordonnees_facade(immeuble)
    
def dessiner_fenetre(immeuble:dict) -> None:
    pass
   
def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire() #info fenetre informations['type_fenetre'] = [] for _ in range((informations['nb_etage']*3)-1) : informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("red","blue","yellow","magenta","green","purple") return couleur[rd.randint(0,5)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "black" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x,y = coordonnees_facade(immeuble) def dessiner_fenetre(immeuble:dict) -> None: pass def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += (immeuble['nb_etage']+1) * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes
 
+ triangle_equilateral(cote, info_feutre, coordonnees)
+ arc_de_cercle(rayon, angle, info_feutre, coordonnees)
 
 
Exemples d'utilisation :
>>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5}
>>> triangle_equilateral(50, informations_feutre, (50,100))
>>> arc_de_cercle(75, 360, informations_feutre, (200,-200))
"""
 
 
# Importation
 
import turtle as trt
import random as rd
 
# Déclaration des fonctions privées
 
def nouveau_stylo(ecriture, fond, largeur):
    """Renvoie la référence d'un stylo configuré
 
    :: param ecriture(str)  :: la couleur d'écriture ('red', '#FF0000')
    :: param fond(str)      :: la couleur de fond pour ce stylo
    :: param largeur(int)   :: la largeur du trait
    :: return (Turtle)      :: renvoie un objet de la classe Turtle
 
    """
    feutre = trt.Turtle()
    feutre.color(ecriture)
    feutre.fillcolor(fond)
    feutre.pensize(largeur)
    feutre.speed(5)
    return feutre
 
def deplacer(feutre, x, y):
    """Lève le feutre, déplace le feutre et abaisse le feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param x(int)         :: coordonnée horizontale (abscisse)
    :: param y(int)         :: coordonnée verticale (ordonnée)
    :: return (None)        :: c'est une fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    feutre.penup()       # On lève la pointe
    feutre.goto(x, y)  # On déplace le crayon
    feutre.pendown()     # On abaisse la pointe

def trace_rectangle(feutre,cote1,cote2) :
    """Trace un rectangle à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param cote1(int)     :: la valeur en pixel d'un côté
    :: param cote2(int)     :: la valeur en pixel de l'autre côté
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    feutre.begin_fill()
    for c in range(2) :
        feutre.forward(cote1)
        feutre.left(90)
        feutre.forward(cote2)
        feutre.left(90)
    feutre.end_fill()
    feutre.hideturtle()
    
def trace_triangle_equilateral(feutre, cote):
    """Trace un triangle (equilatéral) à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: 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(3):
        feutre.forward(cote)
        feutre.left(120)
    feutre.end_fill()
    feutre.hideturtle()
 
def trace_arc(feutre, rayon, angle):
    """Trace un arc de cercle à l'aide du crayon feutre
 
    :: param feutre(Turtle) :: la référence de l'objet Turtle
    :: param rayon(int)     :: la valeur en pixel du rayon
    :: param angle(int)     :: l'angle à tracer (360 pour un cercle)
    :: return (None)        :: fonction sans retour
    .. effet de bord        :: modifie l'état de feutre
 
    """
    feutre.begin_fill()
    feutre.circle(rayon, angle)
    feutre.end_fill()
    feutre.hideturtle()
 
 
# Déclarations des fonctions publiques

def rectangle(cote, info_feutre, coordonnees):
    """Trace un rectangle à partir des info_feutre et aux bonnees coordonnées
 
    :: param cote(tuple[int])              :: la valeur en pixel des côtés
    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    """
    ecriture = info_feutre['écriture']
    fond = info_feutre['fond']
    epaisseur = info_feutre['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
    y = coordonnees[1]
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_rectangle(feutre, cote[0], cote[1])
    
def triangle_equilateral(cote, info_feutre, coordonnees):
    """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées
 
    :: param cote(int)                     :: la valeur en pixel des côtés
    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    """
    ecriture = info_feutre['écriture']
    fond = info_feutre['fond']
    epaisseur = info_feutre['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_triangle_equilateral(feutre, cote)
 
    return feutre

def arc_de_cercle(rayon, angle, info_feutre, coordonnees):
    """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées
 
    :: param rayon(int)                    :: la valeur en pixel du rayon
    :: param angle(int)                    :: la valeur en ° de l'angle
    :: param info_feutre(dict)             :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int}    
    :: param coordonnees(tuple (int,int) ) :: un tuple (x,y)
 
    """
    ecriture = info_feutre['écriture']
    fond = info_feutre['fond']
    epaisseur = info_feutre['épaisseur']
    x = coordonnees[0]                  # ou x,y = coordonnees (par désempaquetage)
    y = coordonnees[1]
 
    feutre = nouveau_stylo(ecriture, fond, epaisseur)
    deplacer(feutre, x, y)
    trace_arc(feutre, rayon, angle)
 
    return feutre
 
 
# Instructions du programme principal
 
if __name__ == '__main__':
    informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5}
    rectangle((140,80),informations_feutre,(-400,0))
    rectangle((140,80),informations_feutre,(-200,0))
    rectangle((140,80),informations_feutre,(0,0))
    rectangle((140,80),informations_feutre,(200,0))

```py """Ce fichier permet de dessiner des formes à l'aide des fonctions suivantes + triangle_equilateral(cote, info_feutre, coordonnees) + arc_de_cercle(rayon, angle, info_feutre, coordonnees) Exemples d'utilisation : >>> informations_feutre = {'écriture':'blue', 'fond':'#FF88FF', 'épaisseur':5} >>> triangle_equilateral(50, informations_feutre, (50,100)) >>> arc_de_cercle(75, 360, informations_feutre, (200,-200)) """ # Importation import turtle as trt import random as rd # Déclaration des fonctions privées def nouveau_stylo(ecriture, fond, largeur): """Renvoie la référence d'un stylo configuré :: param ecriture(str) :: la couleur d'écriture ('red', '#FF0000') :: param fond(str) :: la couleur de fond pour ce stylo :: param largeur(int) :: la largeur du trait :: return (Turtle) :: renvoie un objet de la classe Turtle """ feutre = trt.Turtle() feutre.color(ecriture) feutre.fillcolor(fond) feutre.pensize(largeur) feutre.speed(5) return feutre def deplacer(feutre, x, y): """Lève le feutre, déplace le feutre et abaisse le feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param x(int) :: coordonnée horizontale (abscisse) :: param y(int) :: coordonnée verticale (ordonnée) :: return (None) :: c'est une fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.penup() # On lève la pointe feutre.goto(x, y) # On déplace le crayon feutre.pendown() # On abaisse la pointe def trace_rectangle(feutre,cote1,cote2) : """Trace un rectangle à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param cote1(int) :: la valeur en pixel d'un côté :: param cote2(int) :: la valeur en pixel de l'autre côté :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.begin_fill() for c in range(2) : feutre.forward(cote1) feutre.left(90) feutre.forward(cote2) feutre.left(90) feutre.end_fill() feutre.hideturtle() def trace_triangle_equilateral(feutre, cote): """Trace un triangle (equilatéral) à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: 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(3): feutre.forward(cote) feutre.left(120) feutre.end_fill() feutre.hideturtle() def trace_arc(feutre, rayon, angle): """Trace un arc de cercle à l'aide du crayon feutre :: param feutre(Turtle) :: la référence de l'objet Turtle :: param rayon(int) :: la valeur en pixel du rayon :: param angle(int) :: l'angle à tracer (360 pour un cercle) :: return (None) :: fonction sans retour .. effet de bord :: modifie l'état de feutre """ feutre.begin_fill() feutre.circle(rayon, angle) feutre.end_fill() feutre.hideturtle() # Déclarations des fonctions publiques def rectangle(cote, info_feutre, coordonnees): """Trace un rectangle à partir des info_feutre et aux bonnees coordonnées :: param cote(tuple[int]) :: la valeur en pixel des côtés :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_rectangle(feutre, cote[0], cote[1]) def triangle_equilateral(cote, info_feutre, coordonnees): """Trace un triangle (equilatéral) à partir des info_feutre et aux bonnees coordonnées :: param cote(int) :: la valeur en pixel des côtés :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_triangle_equilateral(feutre, cote) return feutre def arc_de_cercle(rayon, angle, info_feutre, coordonnees): """Trace un arc de cercle à partir des info_feutre et aux bonnees coordonnées :: param rayon(int) :: la valeur en pixel du rayon :: param angle(int) :: la valeur en ° de l'angle :: param info_feutre(dict) :: un dictionnaire {"écriture":str, "fond":str, "épaisseur":int} :: param coordonnees(tuple (int,int) ) :: un tuple (x,y) """ ecriture = info_feutre['écriture'] fond = info_feutre['fond'] epaisseur = info_feutre['épaisseur'] x = coordonnees[0] # ou x,y = coordonnees (par désempaquetage) y = coordonnees[1] feutre = nouveau_stylo(ecriture, fond, epaisseur) deplacer(feutre, x, y) trace_arc(feutre, rayon, angle) return feutre # Instructions du programme principal if __name__ == '__main__': informations_feutre = {'écriture':"blue", 'fond':'#FF88FF', 'épaisseur':5} rectangle((140,80),informations_feutre,(-400,0)) rectangle((140,80),informations_feutre,(-200,0)) rectangle((140,80),informations_feutre,(0,0)) rectangle((140,80),informations_feutre,(200,0)) ```

def dessiner_fenetre(immeuble:dict) -> None:
	crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 3
    x, y = coordonnees_facade(immeuble)
    x += 20
    y += 20
    for fenetre in range(3*immeuble['nb_etage']) :
    	if immeuble['type_fenetre'] == 2: 
        	rectangle((COTE_FENETRE,COTE_FENETRE+20), crayon, (x,y-20))
        elif immeuble == 1:
        	for i in range(2) :
            	for j in range(2) :
					rectangle((COTE_FENETRE//2,COTE_FENETRE//2), crayon, (x+(i*COTE_FENETRE//2),y+(i*COTE_FENETRE//2)))


def couleur_aleatoire_fonce() -> str :
    couleur = ("purple","red","blue","black")
    return couleur[rd.randint(0,3)]
    
def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_porte']
    crayon['épaisseur'] = 3
    x,y = coordonnees_facade(immeuble)
    y += ETAGE + 4
    x += 20 + (immeuble['pos_porte']) * 40
    rectangle((30,50),crayon, (x,y))
    ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
HAUTEUR_PORTE = 50
LARGEUR_PORTE = 30
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire_fonce()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range(informations['nb_etage']*3) :
        informations['type_fenetre'] + [rd.randint(0,2)] # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("yellow","magenta","green","cyan")
    return couleur[rd.randint(0,3)]

def couleur_aleatoire_fonce() -> str :
    couleur = ("purple","red","blue","black")
    return couleur[rd.randint(0,3)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_porte']
    crayon['épaisseur'] = 3
    x,y = coordonnees_facade(immeuble)
    y += ETAGE + 4
    x += 20 + (immeuble['pos_porte']) * 40
    rectangle((30,50),crayon, (x,y))
    
    
def dessiner_fenetre(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = "#7F7FDD"
    crayon['épaisseur'] = 3
    x, y = coordonnees_facade(immeuble)
    x += 20
    y += ETAGE + 20
    for fenetre in range(1, 3*immeuble['nb_etage']+1) :
        if immeuble['type_fenetre'] == 2: 
            rectangle((COTE_FENETRE,COTE_FENETRE+20), crayon, (x+(fenetre%3 * 40),(y-20)))
        elif immeuble['type_fenetre'] == 1:
            for i in range(2) :
                for j in range(2) :
                    rectangle((COTE_FENETRE//2,COTE_FENETRE//2), crayon, (x+(i*COTE_FENETRE//2),y+(i*COTE_FENETRE//2)))
        else :
            rectangle((COTE_FENETRE,COTE_FENETRE), crayon, (x+(fenetre%3 * 40),y))
        if fenetre%3 == 0 :
            y += ETAGE

def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_fenetre(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
        
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    for i in range(2) :
        for j in range(2) :
            rectangle((COTE_FENETRE//2,COTE_FENETRE//2), crayon, (x+(i*COTE_FENETRE//2),y+(i*COTE_FENETRE//2)))
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 HAUTEUR_PORTE = 50 LARGEUR_PORTE = 30 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire_fonce() #info fenetre informations['type_fenetre'] = [] for _ in range(informations['nb_etage']*3) : informations['type_fenetre'] + [rd.randint(0,2)] # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("yellow","magenta","green","cyan") return couleur[rd.randint(0,3)] def couleur_aleatoire_fonce() -> str : couleur = ("purple","red","blue","black") return couleur[rd.randint(0,3)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_porte'] crayon['épaisseur'] = 3 x,y = coordonnees_facade(immeuble) y += ETAGE + 4 x += 20 + (immeuble['pos_porte']) * 40 rectangle((30,50),crayon, (x,y)) def dessiner_fenetre(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "gray" crayon['fond'] = "#7F7FDD" crayon['épaisseur'] = 3 x, y = coordonnees_facade(immeuble) x += 20 y += ETAGE + 20 for fenetre in range(1, 3*immeuble['nb_etage']+1) : if immeuble['type_fenetre'] == 2: rectangle((COTE_FENETRE,COTE_FENETRE+20), crayon, (x+(fenetre%3 * 40),(y-20))) elif immeuble['type_fenetre'] == 1: for i in range(2) : for j in range(2) : rectangle((COTE_FENETRE//2,COTE_FENETRE//2), crayon, (x+(i*COTE_FENETRE//2),y+(i*COTE_FENETRE//2))) else : rectangle((COTE_FENETRE,COTE_FENETRE), crayon, (x+(fenetre%3 * 40),y)) if fenetre%3 == 0 : y += ETAGE def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += (immeuble['nb_etage']+1) * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_fenetre(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': for i in range(2) : for j in range(2) : rectangle((COTE_FENETRE//2,COTE_FENETRE//2), crayon, (x+(i*COTE_FENETRE//2),y+(i*COTE_FENETRE//2))) dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
COTE_CARREAUX = COTE_FENETRE//2
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire_fonce()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range(informations['nb_etage']*3) :
        informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("yellow","magenta","green","cyan")
    return couleur[rd.randint(0,3)]

def couleur_aleatoire_fonce() -> str :
    couleur = ("purple","red","blue","black")
    return couleur[rd.randint(0,3)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_porte']
    crayon['épaisseur'] = 3
    x,y = coordonnees_facade(immeuble)
    y += ETAGE + 4
    x += 20 + (immeuble['pos_porte']) * 40
    rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y))
    
    
def dessiner_fenetre(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = "cyan"
    crayon['épaisseur'] = 3
    x, y = coordonnees_facade(immeuble)
    x += 20
    y += 20
    for nfenetre in range(len(immeuble['type_fenetre'])) :
        if immeuble['type_fenetre'][nfenetre] == 0 :
            rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x,y))
        elif immeuble['type_fenetre'][nfenetre] == 1 :
            rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x,y))
            rectangle((0,COTE_FENETRE), crayon,(x+COTE_CARREAUX,y))
            rectangle((COTE_FENETRE,0), crayon,(x,y+COTE_CARREAUX))
        else :
            rectangle((COTE_FENETRE,HAUTEUR_PORTE), crayon, (x,y-20))
            for i in range(5) :
                rectangle((0,COTE_FENETRE), crayon,(x+i*7,y-COTE_CARREAUX))
            rectangle((COTE_FENETRE,0), crayon, (x,y+COTE_CARREAUX))
                

def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_porte(immeuble)
    dessiner_fenetre(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

``` """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 COTE_CARREAUX = COTE_FENETRE//2 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire_fonce() #info fenetre informations['type_fenetre'] = [] for _ in range(informations['nb_etage']*3) : informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("yellow","magenta","green","cyan") return couleur[rd.randint(0,3)] def couleur_aleatoire_fonce() -> str : couleur = ("purple","red","blue","black") return couleur[rd.randint(0,3)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_porte'] crayon['épaisseur'] = 3 x,y = coordonnees_facade(immeuble) y += ETAGE + 4 x += 20 + (immeuble['pos_porte']) * 40 rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y)) def dessiner_fenetre(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "gray" crayon['fond'] = "cyan" crayon['épaisseur'] = 3 x, y = coordonnees_facade(immeuble) x += 20 y += 20 for nfenetre in range(len(immeuble['type_fenetre'])) : if immeuble['type_fenetre'][nfenetre] == 0 : rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x,y)) elif immeuble['type_fenetre'][nfenetre] == 1 : rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x,y)) rectangle((0,COTE_FENETRE), crayon,(x+COTE_CARREAUX,y)) rectangle((COTE_FENETRE,0), crayon,(x,y+COTE_CARREAUX)) else : rectangle((COTE_FENETRE,HAUTEUR_PORTE), crayon, (x,y-20)) for i in range(5) : rectangle((0,COTE_FENETRE), crayon,(x+i*7,y-COTE_CARREAUX)) rectangle((COTE_FENETRE,0), crayon, (x,y+COTE_CARREAUX)) def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += (immeuble['nb_etage']+1) * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_porte(immeuble) dessiner_fenetre(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
 
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
COTE_CARREAUX = COTE_FENETRE//2
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire_fonce()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range(informations['nb_etage']*3) :
        informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    couleur = ("yellow","magenta","green","cyan")
    return couleur[rd.randint(0,3)]

def couleur_aleatoire_fonce() -> str :
    couleur = ("purple","red","blue","black")
    return couleur[rd.randint(0,3)]

def coordonnees_facade(immeuble:dict) -> tuple:
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    # Demande d'affichage
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    # Traduction des données de rue vers dessiner
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_porte']
    crayon['épaisseur'] = 3
    x,y = coordonnees_facade(immeuble)
    y += ETAGE + 4
    x += 20 + (immeuble['pos_porte']) * 40
    rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y))
    
    
def dessiner_fenetre(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = "cyan"
    crayon['épaisseur'] = 3
    x, y = coordonnees_facade(immeuble)
    x += 20
    y += 20
    for nfenetre in range(len(immeuble['type_fenetre'])) :
        if immeuble['type_fenetre'][nfenetre] == 0 :
            rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x+ (nfenetre%3)*40,y))
        elif immeuble['type_fenetre'][nfenetre] == 1 :
            rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x+ (nfenetre%3)*40,y))
            rectangle((0,COTE_FENETRE), crayon,(x+COTE_CARREAUX+ (nfenetre%3)*40,y))
            rectangle((COTE_FENETRE,0), crayon,(x+ (nfenetre%3)*40,y+COTE_CARREAUX))
        else :
            rectangle((COTE_FENETRE,HAUTEUR_PORTE), crayon, (x+ (nfenetre%3)*40,y-20))
            for i in range(5) :
                rectangle((0,COTE_FENETRE+3), crayon,(x+ (nfenetre%3)*40+i*7,y-COTE_CARREAUX-3))
            rectangle((COTE_FENETRE,0), crayon, (x+ (nfenetre%3)*40,y+COTE_CARREAUX))
                

def dessiner_toit(immeuble:dict) -> None:
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  # désempaquatage du couple
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    dessiner_facade(immeuble)
    dessiner_fenetre(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
    # à compléter avec d'autres fonctions pour le reste : toit, fenêtres...
    pass
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
    pass
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 COTE_CARREAUX = COTE_FENETRE//2 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire_fonce() #info fenetre informations['type_fenetre'] = [] for _ in range(informations['nb_etage']*3) : informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: couleur = ("yellow","magenta","green","cyan") return couleur[rd.randint(0,3)] def couleur_aleatoire_fonce() -> str : couleur = ("purple","red","blue","black") return couleur[rd.randint(0,3)] def coordonnees_facade(immeuble:dict) -> tuple: x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple # Demande d'affichage rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: # Traduction des données de rue vers dessiner crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_porte'] crayon['épaisseur'] = 3 x,y = coordonnees_facade(immeuble) y += ETAGE + 4 x += 20 + (immeuble['pos_porte']) * 40 rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y)) def dessiner_fenetre(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "gray" crayon['fond'] = "cyan" crayon['épaisseur'] = 3 x, y = coordonnees_facade(immeuble) x += 20 y += 20 for nfenetre in range(len(immeuble['type_fenetre'])) : if immeuble['type_fenetre'][nfenetre] == 0 : rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x+ (nfenetre%3)*40,y)) elif immeuble['type_fenetre'][nfenetre] == 1 : rectangle((COTE_FENETRE,COTE_FENETRE), crayon,(x+ (nfenetre%3)*40,y)) rectangle((0,COTE_FENETRE), crayon,(x+COTE_CARREAUX+ (nfenetre%3)*40,y)) rectangle((COTE_FENETRE,0), crayon,(x+ (nfenetre%3)*40,y+COTE_CARREAUX)) else : rectangle((COTE_FENETRE,HAUTEUR_PORTE), crayon, (x+ (nfenetre%3)*40,y-20)) for i in range(5) : rectangle((0,COTE_FENETRE+3), crayon,(x+ (nfenetre%3)*40+i*7,y-COTE_CARREAUX-3)) rectangle((COTE_FENETRE,0), crayon, (x+ (nfenetre%3)*40,y+COTE_CARREAUX)) def dessiner_toit(immeuble:dict) -> None: crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) # désempaquatage du couple x -= 10 y += (immeuble['nb_etage']+1) * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: dessiner_facade(immeuble) dessiner_fenetre(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # à compléter avec d'autres fonctions pour le reste : toit, fenêtres... pass # Fonction publiques def dessiner_rue_aleatoire() -> None: for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) pass def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd
 
# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
COTE_CARREAUX = COTE_FENETRE//2
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    """Génère des informations aléatoires pour un immeuble

    :: param numero (int) :: le numéro identifiant l'immeuble
    
    Renvoi un dictionnaire contenant les informations de l'immeuble avec les clés suivantes :
        - 'couleur_facade': Couleur de la façade de l'immeuble.
        - 'numero': Numéro de l'immeuble.
        - 'nb_etage': Nombre d'étages de l'immeuble (entre 1 et 5).
        - 'pos_porte': Position de la porte (0, 1 ou 2).
        - 'couleur_porte': Couleur de la porte (une couleur foncée aléatoire).
        - 'type_fenetre': Liste des types de fenêtres pour chaque étage (0, 1 ou 2).
        - 'type_toit': Type de toit (booléen, où False indique un toit rectangulaire et True un toit triangulaire).
        
    Fait par Iyad
    """
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire_fonce()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range(informations['nb_etage']*3) :
        informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    """Permet de fournir une couleur aléatoire non foncée

    Renvoi un str qui contient une couleur non foncée parmis :
                "yellow","magenta","green","cyan"
                
    Fait par Iyad
    """
    couleur = ("yellow","magenta","green","cyan")
    return couleur[rd.randint(0,3)]

def couleur_aleatoire_fonce() -> str :
    """Permet de fournir une couleur aléatoire foncée

    Renvoi un str qui contient une couleur foncée parmis :
                "purple","red","blue","black"

    Fait par Louay
    """
    couleur = ("purple","red","blue","black")
    return couleur[rd.randint(0,3)]

def coordonnees_facade(immeuble:dict) -> tuple:
    """Calcule les coordonnées de la façade d'un immeuble

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - numero : le numéro de l'immeuble
        
    Renvoi un tuple contenant les coordonnées (x_gauche, y_bas) de la façade de l'immeuble
    
    Fait par Louay
    """
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    """Permet de dessiner la façade de l'immeuble

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - couleur_facade : la couleur de la façade de l'immeuble
        - nb_etage : le n'ombre d'étages de l'immeuble
        
    Fait par Iyad
    """
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    """Permet de dessiner la porte d'un immeuble

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - couleur_porte : la couleur de la porte
        - pos_porte : la position de la porte définie aléatoirement
        - nb_etages : le nombre d'étages de l'immeuble
        
    Fait par Louay
    """
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_porte']
    crayon['épaisseur'] = 3
    x,y = coordonnees_facade(immeuble)
    y += ETAGE + 4
    x += 20 + (immeuble['pos_porte']) * 40
    rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y))
    
    

def dessiner_fenetre(immeuble: dict) -> None:
    """Permet de tracer 3 types de fenêtres. Tel que une fenêtre simple mais aussi à carreaux ou avec un balcon.

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - nb_etages : le nombre d'étages de l'immeuble
        - pos_porte : la position de la porte définie aléatoirement 
        - type_fenetre : une liste des types de fenêtres
        
    Fait par Louay et Iyad
    """
        
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = "cyan"
    crayon['épaisseur'] = 3
    nb_etages = immeuble['nb_etage']
    x_base, y_base = coordonnees_facade(immeuble)
    y_base += ETAGE + 20
    
    
    for etage in range(nb_etages):
        y = y_base + etage * ETAGE

        for colonne in range(3):
            x = x_base + 20 + colonne * 40
            type_fenetre = immeuble['type_fenetre']
            if etage == 0 and colonne == immeuble['pos_porte']:
               continue

            if immeuble['type_fenetre'][etage * 3 + colonne] == 0:
                rectangle((COTE_FENETRE, COTE_FENETRE), crayon, (x, y))
                
            elif immeuble['type_fenetre'][etage * 3 + colonne] == 1:
                rectangle((COTE_FENETRE, COTE_FENETRE), crayon, (x, y))
                rectangle((0, COTE_FENETRE), crayon, (x + COTE_CARREAUX, y))
                rectangle((COTE_FENETRE, 0), crayon, (x, y + COTE_CARREAUX))
                
            elif immeuble['type_fenetre'][etage * 3 + colonne] == 2:
                rectangle((COTE_FENETRE, HAUTEUR_PORTE), crayon, (x, y - 20))
                for i in range(5):
                    rectangle((0, COTE_FENETRE + 3), crayon, (x + i * 7, y - COTE_CARREAUX - 3))
                rectangle((COTE_FENETRE, 0), crayon, (x, y + COTE_CARREAUX))
                
def dessiner_toit(immeuble:dict) -> None:
    """Permet de dessiner 2 types de toits tel que pointu ou plat

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - type_toit : indique le type de toit définie par un booléen
        - nb_etage : nombre d'étages de l'immeuble
        
    Fait par Iyad
    """
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    """Permet de dessiner un immeuble complet

    :: param immeuble (dict) :: un dictionnaire contenant toutes les informations de l'immeuble
    
    Fait par Iyad
    """
    dessiner_facade(immeuble)
    dessiner_fenetre(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    """Permet de dessiner une rue contenant 4 immeubles aux caractéristiques définies aléatoirement
    """
    for n in range(4):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
        
def dessiner_rue_decrite(rue:'?') -> None:
    pass

# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()

```py """Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes : + dessiner_rue_aleatoire() + dessiner_rue_decrite(rue:dict) """ # Importation from dessiner import triangle_equilateral,rectangle import random as rd # Constantes IMMEUBLE = 140 ETAGE = 80 COTE_FENETRE = 30 COTE_CARREAUX = COTE_FENETRE//2 HAUTEUR_PORTE = 50 # Fonction privées def immeuble_aleatoire(numero:int) -> dict: """Génère des informations aléatoires pour un immeuble :: param numero (int) :: le numéro identifiant l'immeuble Renvoi un dictionnaire contenant les informations de l'immeuble avec les clés suivantes : - 'couleur_facade': Couleur de la façade de l'immeuble. - 'numero': Numéro de l'immeuble. - 'nb_etage': Nombre d'étages de l'immeuble (entre 1 et 5). - 'pos_porte': Position de la porte (0, 1 ou 2). - 'couleur_porte': Couleur de la porte (une couleur foncée aléatoire). - 'type_fenetre': Liste des types de fenêtres pour chaque étage (0, 1 ou 2). - 'type_toit': Type de toit (booléen, où False indique un toit rectangulaire et True un toit triangulaire). Fait par Iyad """ informations = {} #info immeuble informations['couleur_facade'] = couleur_aleatoire() informations['numero'] = numero informations['nb_etage'] = rd.randint(1,5) #info porte informations['pos_porte'] = rd.randint(0,2) informations['couleur_porte'] = couleur_aleatoire_fonce() #info fenetre informations['type_fenetre'] = [] for _ in range(informations['nb_etage']*3) : informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux #info toit informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle return informations def couleur_aleatoire() -> str: """Permet de fournir une couleur aléatoire non foncée Renvoi un str qui contient une couleur non foncée parmis : "yellow","magenta","green","cyan" Fait par Iyad """ couleur = ("yellow","magenta","green","cyan") return couleur[rd.randint(0,3)] def couleur_aleatoire_fonce() -> str : """Permet de fournir une couleur aléatoire foncée Renvoi un str qui contient une couleur foncée parmis : "purple","red","blue","black" Fait par Louay """ couleur = ("purple","red","blue","black") return couleur[rd.randint(0,3)] def coordonnees_facade(immeuble:dict) -> tuple: """Calcule les coordonnées de la façade d'un immeuble :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que : - numero : le numéro de l'immeuble Renvoi un tuple contenant les coordonnées (x_gauche, y_bas) de la façade de l'immeuble Fait par Louay """ x_gauche = -400 + 200 * immeuble['numero'] y_bas = 0 return (x_gauche, y_bas) def dessiner_facade(immeuble:dict) -> None: """Permet de dessiner la façade de l'immeuble :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que : - couleur_facade : la couleur de la façade de l'immeuble - nb_etage : le n'ombre d'étages de l'immeuble Fait par Iyad """ crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_facade'] crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE))) def dessiner_porte(immeuble:dict) -> None: """Permet de dessiner la porte d'un immeuble :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que : - couleur_porte : la couleur de la porte - pos_porte : la position de la porte définie aléatoirement - nb_etages : le nombre d'étages de l'immeuble Fait par Louay """ crayon = {} crayon['écriture'] = "gray" crayon['fond'] = immeuble['couleur_porte'] crayon['épaisseur'] = 3 x,y = coordonnees_facade(immeuble) y += ETAGE + 4 x += 20 + (immeuble['pos_porte']) * 40 rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y)) def dessiner_fenetre(immeuble: dict) -> None: """Permet de tracer 3 types de fenêtres. Tel que une fenêtre simple mais aussi à carreaux ou avec un balcon. :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que : - nb_etages : le nombre d'étages de l'immeuble - pos_porte : la position de la porte définie aléatoirement - type_fenetre : une liste des types de fenêtres Fait par Louay et Iyad """ crayon = {} crayon['écriture'] = "gray" crayon['fond'] = "cyan" crayon['épaisseur'] = 3 nb_etages = immeuble['nb_etage'] x_base, y_base = coordonnees_facade(immeuble) y_base += ETAGE + 20 for etage in range(nb_etages): y = y_base + etage * ETAGE for colonne in range(3): x = x_base + 20 + colonne * 40 type_fenetre = immeuble['type_fenetre'] if etage == 0 and colonne == immeuble['pos_porte']: continue if immeuble['type_fenetre'][etage * 3 + colonne] == 0: rectangle((COTE_FENETRE, COTE_FENETRE), crayon, (x, y)) elif immeuble['type_fenetre'][etage * 3 + colonne] == 1: rectangle((COTE_FENETRE, COTE_FENETRE), crayon, (x, y)) rectangle((0, COTE_FENETRE), crayon, (x + COTE_CARREAUX, y)) rectangle((COTE_FENETRE, 0), crayon, (x, y + COTE_CARREAUX)) elif immeuble['type_fenetre'][etage * 3 + colonne] == 2: rectangle((COTE_FENETRE, HAUTEUR_PORTE), crayon, (x, y - 20)) for i in range(5): rectangle((0, COTE_FENETRE + 3), crayon, (x + i * 7, y - COTE_CARREAUX - 3)) rectangle((COTE_FENETRE, 0), crayon, (x, y + COTE_CARREAUX)) def dessiner_toit(immeuble:dict) -> None: """Permet de dessiner 2 types de toits tel que pointu ou plat :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que : - type_toit : indique le type de toit définie par un booléen - nb_etage : nombre d'étages de l'immeuble Fait par Iyad """ crayon = {} crayon['écriture'] = "black" crayon['fond'] = "black" crayon['épaisseur'] = 5 x, y = coordonnees_facade(immeuble) x -= 10 y += (immeuble['nb_etage']+1) * ETAGE if immeuble['type_toit'] == False : dim = (20 + IMMEUBLE), 20 rectangle(dim, crayon, (x,y)) else : dim = (20 + IMMEUBLE) triangle_equilateral(dim, crayon, (x,y)) def dessiner_immeuble(immeuble:dict) -> None: """Permet de dessiner un immeuble complet :: param immeuble (dict) :: un dictionnaire contenant toutes les informations de l'immeuble Fait par Iyad """ dessiner_facade(immeuble) dessiner_fenetre(immeuble) dessiner_porte(immeuble) dessiner_toit(immeuble) # Fonction publiques def dessiner_rue_aleatoire() -> None: """Permet de dessiner une rue contenant 4 immeubles aux caractéristiques définies aléatoirement """ for n in range(4): informations_immeuble = immeuble_aleatoire(n) dessiner_immeuble(informations_immeuble) def dessiner_rue_decrite(rue:'?') -> None: pass # Programme principal if __name__ == '__main__': dessiner_rue_aleatoire() ```

Prototype interpréteur

rue = 'ma_rue.txt'
obj_rue = open(rue, 'r', encoding="utf-8")
ligne = obj_rue.readline

for ligne in obj_rue:
    print(ligne, end="")

obj_rue.close()

README.txt

Veillez à proposer votre rue dans cette ordre :

Le nombre d'immeubles voulu
couleur de la façade en anglais - le nombre d'étages - la position de la porte - le type de toit - le type de fenêtre

Exemple :

3 immeubles
yellow - 4 - gauche - lisse - carreaux

couleur de façade disponible : yellow, magenta, green, cyan
nombre d'étages disponible : minimum à 1 et maximum à 5
position de porte disponible : gauche, milieu et droite
type de toit disponible : lisse et pointu
type de fenêtre disponible : carreaux, balcon, simple et aléatoire