Documentation de french-logo

Index et recherche

• Index

• Index du module

• Page de recherche

Documentation complémentaire

Classe Tortue

Constructeur

class logo.Tortue

__init__()

Consructeur

La classe Tortue retourne une émulation de logo, basée sur le module turtle et en français.

Les primitives distance(), position() et pos() sont identiques en français et en anglais et donc non reprises dans la classe. Elle peuvent être appelée directement de la classe turtle.Turtle

• position(), pos(): retourne la position courante (x, y) de la tortue

• distance(): retourne la distance de la tortue a (x, y) ou à une autre tortue. Paramètres:

  param x

  – un nombre, une paire de nombre ou une instance tortue

  param y

  – un nombre si x est un nombre, sinon None

la primitive distance() est particulièrement utile avec la primitive vers(). Exemple:

# la tortue t1 rejoint la tortue t2
t1.cap = t1.vers(t2)
t1.av(distance(t2))

Note

l’instruction “repete” n’accepte que des variables Tortue. D’où le besoin de disposer de telles variables pour obtenir des variations de paramètres. Historiquement, la tortue dispose de 3 variables attachées à son service v1 = 0, v2 = 0 et v3 = 0. Mais, c’est limitatif d’une part, et, d’autre part, il est très aisé d’ajouter à une classe des variables « à la volée ». Exemple : Tortue.var0 = 0 ou <objet_tortue>.var0 = 0;

Attributs et méthodes publiques

Orthographe de proximité

class logo.Tortue

classmethod au_revoir_ecran(message='', clic=False)

Ferme la fenêtre tortue, puis affiche “message” à la console. Si “clic”=True, attends qu’on clique sur l’écran pour le fermer. Défaut pour clic = False

av(pas)

Alias de avance

avance(pas)

tortue avance de “pas”

baissecrayon()

Baisse le crayon de la tortue

bc()

Alias de baissecrayon

cachet()

Laisse un cachet de forme tortue sur l’écran. Retourne un

“id_cachet” qui peut être utilisé pour supprimer le cachet avec tortue.efface_cachet(id_cachet)

Exemple:

t = Tortue()
cecachet = t.cachet()
t.fd(50)
t.efface_cachet(cecachet)

cachetortue()

Cache tortue

cap

Fixe, modifie ou retourne le cap de la tortue. Le cap est fonction du mode:

• « logo »: angles et orientation géographique (Défaut)

• « standard »: angles et orientation trigonométrique

clown()

Alias comique pour “double()”

classmethod configure_ecran(largeur, hauteur, posx, posy)

Fixe les dimensions et la position de l’écran, suivant les paramètres ci-dessous.

Paramètres

• largeur – largeur de l’écran en px (défaut = 50% de l’écran)

• hauteur – hauteur de l’écran en px (défaut = 75% de l’écran)

• posx – position écran en x; positif = à partir du bord gauche, négatif = à partir du bord droit

• posy – position écran en y; positif = à partir du bord haut, négatif = à partir du bord bas

coordx()

Retourne la position x de la tortue.

coordy()

Retourne la position y de la tortue.

couleur

Fixe, modifie ou retourne les couleurs du crayon et de remplissage. usage: <objet_tortue>.couleur = (couleur_crayon,[couleur_remplissage »])

Couleurs disponibles: “blanc”, “bleu”, “brun”, “gris”, “jaune”, “noir”, “orange”, “rose”, “rouge”, “vert”, “violet Chaque couleur est disponible en 3 tons: clair, normal, foncé

Exemples:

t = Tortue()
t.couleur = 'bleu foncé', 'rouge'
t.couleur = 'vert clair'
# il n'est plus nécessaire de <- NE PAS OUBLIER LA ',' Cependant, si
# elle est là, c'est rétro-compatible avec la version actuelle.

Avertissement

Il y a un problème avec « rouge clair » actuellement qui est redirigé automatiquement le « rouge » normal.

crayonbaisse

Retourne True/False, si le crayon est baissé ou pas.

ct()

Alias de cachetortue

cx()

Alias de coordx.

cy()

Alias de coordy.

debut_remplissage()

A appeler juste avant de dessiner une forme à remplir.

classmethod dit_mode_ecran()

Retourne le mode de l’écran

double()

Crée et retourne un double de la tortue, même position, même cap,

mêmes propriétés.

Exemple:

robert = Tortue()
anais = robert.double()

classmethod ecran_attends(millisecondes)

Le programme attend “millisecondes” millisecondes

ecris(message, bouge=False, aligne='left', fonte=('Arial', 8, 'normal'))

Ecris un texte à l’écran Paramètres

Paramètres

• message – Message à écrire sur l’écran.

• bouge – True/False. Si True, la tortue est déplacée vers le coin inférieur droit du texte.

• aligne – au choix: « left », « center » ou right »

• fonte – Un triplet description de la fonte (nom, taille, type)

efface()

Efface tous les dessins de la tortue. Laisse tous les autres états tels qu’ils sont

efface_cachet(id_cachet)

Supprime le cachet id_cachet. Voir la doc “cachet()”.

efface_cachets(n=None)

Si n > 0, supprime les n premiers cachets de tortue, sinon les n derniers. Si n=None, supprime tous les cachets de tortue. Voir la doc “cachet()”.

efface_tableau()

Efface le texte d’un tableau en cours, et replace sa tortue écrivaine à la position de départ.

fin_remplissage()

Remplit la forme dessinée après le dernier appel à debut_remplissage().

classmethod fixe_mode_ecran(mode)

Fixe le mode de l’écran

• « logo »: angles et orientation géographique (Défaut)

• « standard »: angles et orientation trigonométrique

classmethod fixe_titre_ecran(titre)

Fixe le titre de l’écran

forme

Fixe, modifie ou retourne la forme de la tortue.

Formes disponibles: “carré”, “cercle”, “classique”, “flèche”, “tortue”, “triangle”, “rien”

hasard(has)

Retourne un entier positif compris entre 0 et has-1

intervalle(*args)

• intervalle(stop)

• intervallle(depart, stop[, pas])

Si “pas” est omis, il est placé par défaut à 1. Si “départ” est omis, il est placé par défaut à 0. Si “stop” est omis, une exception “ValueError” est levée.

Avec un “pas” négatif, des valeurs négatives sont possibles. Exemple:

>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

largeurcrayon

Fixe, modifie ou retourne la taille du crayon de la tortue.

lc()

Alias de levecrayon

levecrayon()

Lève le crayon de la tortue

classmethod lis_couleurs()

retourne le dictionnaire des couleurs tortue disponibles

classmethod lis_formes()

retourne le dictionnaire des formes tortue disponibles

classmethod lis_nombre_ecran(titre, invite, defaut=None, minimum=None, maximum=None)

Fournit une fenêtre de dialogue et de saise d’un nombre. Renvoie le nombre. Paramètres obligatoires

Paramètres

• titre – titre

• invite – invite

Paramètres optionnels

Paramètres

• defaut – valeur par défaut

• minimum – valeur minimum d’entrée

• maximum – valeur maximum d’entrée

classmethod lis_texte_ecran(titre, invite)

Fournit une fenêtre de dialogue et de saise d’un texte. Renvoie le texte. Supporte un titre et une invite.

classmethod lis_vitesses()

retourne le dictionnaire des vitesses tortue disponibles

ln(texte, interligne=1.3, police='arial', taille=8, style='normal')

Ecris une ligne dans le tableau

Liste des styles disponibles : « normal », « gras », « italique », « souligné », « barré

maison()

Ramène la tortue à x, y = 0, 0 et cap = 0

monnom = ''

Attribut de classe. Nom à qui s’adressera le système.

Si vide, ce sera “Monsieur”, “Monseigneur”, “Madame”, “Messire”, “Sire”, “Majesté”, “Excellence”, ou “Emminence” au hasard.

montretortue()

Montre tortue

mt()

Alias de montretortue

pc(rayon, arc=None, cote=None)

Alias de polycercle

polycercle(rayon, arc=None, cote=None)

Dessine un polygone de rayon “rayon”, arc = “arc”, par défaut 360, et d’un nombre de cotés “cote ». A partir d’un nombre suffisant de cotés, le polygone apparait comme un cercle, c’est pourquoi nous l’appelons “polycercle” dans la suite

Paramètres

param rayon

un nombre rayon fixant le cantre du polycercle à gauche de la tortue. Si rayon est positif, le polycercle sera dessiné dans le sens contre-horlogique, sinon horlogique

param arc

un nombre, arc de polycercle (Défaut = None)

param cote

nombre de cotés du polycercle (Defaut = None) dans le cas d’un cercle, mieux vaut laisser la fonction décider de ce paramètre.

pour(iterable, liste)

L’nstruction “pour” est assez semblable à l’instruction “for” en python. Sa syntaxe est simple:

t=Tortue()
t.pour(iterable, liste_instruction)

• “itérable” = tout ce qui est itérable (superbe tautologie ! ;-)

• “liste_instruction”, comme pour repete. Et à ce propos, veuillez consulter les “Règles” proposée dans la doc string de “repete”

• pour est récursif, et peut se rappeler à l’intérieur d’elle-même

• vous disposez de l’iterateur nommé “iterateur” à l’intérieur des boucles. Voyez les exemples ci-dessous

• vous disposez de l’itérable “intervalle((stop|start, stop[, step]))” qui fonctionne comme son homologue “range()”

Exemples:

t1 = Tortue(); t1.va(100,0); t1.bc()

t1.pour(t1.intervalle(4), ["av(100)", "td(90)", "pour",
t1.intervalle(1), ["polycercle(30)", "td(60)", "polycercle(-30)",
"tg(60)"]])

t1.lc(); t1.va(-100, 0);
t1.pour(Tortue.lis_formes(), ["ecris(iterateur + ': ' +
Tortue.lis_formes()[iterateur])", "av(20)"])

Tortue.au_revoir_ecran("", True)

re(pas)

Alias de recule

recule(pas)

tortue recule de “pas”

reinit()

Alias de reinitialise

classmethod reinit_ecran()

Alias de reinitialise_ecran

reinitialise()

Efface tous les dessins de la tortue. Réinitialise toutes les variables de la tortue, comme x, y = 0, 0 et cap = 0, par exemple

classmethod reinitialise_ecran()

Efface tous les dessins des tortues de l’écran et réinitialise toutes les variables de la tortue, comme x, y = 0, 0 et cap = 0, par exemple

remplis

Retourne True/False, si la tortue est en mode remplissage ou pas.

repete(fois, liste)

Instruction absente de turtle, elle répete n fois une série de commandes. “repete” est récursive, et donc, supporte d’autres “repete” à l’intérieur d’elle-même.

Exemple d’usage:

t = Tortue()
t.repete(4, ["av(100", "td(90)"])
t.repete(4, ["repete", 4, ["av(90)", "td(90)"], "td(90)"])

Règles:

1. l’instruction “repete” n’accepte que des variables Tortue. D’où le besoin de disposer de telles variables pour obtenir des variations de paramètres. Historiquement, la tortue dispose de 3 variables attachées à son service v1 = 0, v2 = 0 et v3 = 0. Mais, c’est limitatif d’une part, et, d’autre part, il est très aisé d’ajouter à une classe des variables « à la volée ». Exemple : Tortue.var0 = 0 ou <objet_tortue>.var0 = 0; … C’est cette methode (dont nous aurons besoin) que nous choisirons pour la suite.

2. les instructions s’écrivent toutes entre guillemets, simples ou doubles, dans une liste et donc separées par des virgules.

3. si l’instruction Tortue débute, elle s’écrit telle quelle, sinon, elle doit être précédée de self. Exemple: [« td(90) », « av(self.var0) »]

4. l’instruction est récursive et peut se rapeller autant de fois qu’on veut à l’intérieur, sur le modèle suivant: t.repete(n, [« inst », « repete », n, [« inst », « etc. »], « inst », « etc. »])

Notes à propos de la récursivité:

• Le 1er appel à repete se construit comme “t.repete(n, [« … »])”, l’appel récursif comme “[ … « repete », n, [« … »]]”. Seul n, le nombre de répétion est un entier sans guillemet!

• La récursivité est consommatrice de ressources, suggestion donc de modérer le nombre d’appel récursif à 2 ou 3 (même si le nombre maximum d’appels récursifs est 996 !).

Astuce! comment introduire une fonction dans une boucle repete ?

t1 = Tortue()
def ballon(baton, rayon):
    t1.av(baton)
    t1.polycercle(rayon)
    t1.re(baton)

def ballons(baton, rayon):
    t1.var0 = ballon
    t1.var1 = baton
    t1.var2 = rayon
    # Suivons la règle: "si l'instruction Tortue débute, elle
    # s'écrit telle quelle, sinon, elle est précédée de self."
    t1.repete(8, ["var0(self.var1, self.var2)", "tg(360/8)"])

ballons(100, 50)

classmethod styles_de_polices()

retourne le dictionnaire des styles de polices tortue disponibles

tableau(x=None, y=None)

Ouvre un tableau tortue, dans lequel on écrira avec la primitive tortue.ln()

Paramètres:

Paramètres

• x – coord. x du coin gauche haut du tableau. Par défaut Tortue.xmin+20

• y – coord. y du coin gauche haut du tableau. Par défaut Tortue.ymax-20

taillecrayon(taille)

Fixe la largeur du crayon de la tortue

tc(taille)

Alias de taillecrayon

td(degres)

Alias de tournedroite

tg(degres)

Alias de tournegauche

tournedroite(degres)

tortue tourne à droite de “degrés”

tournegauche(degres)

tortue tourne à gauche de “degrés”

va(x, y)

tortue va en “x”, “y”

vers(x, y=None)

Retourne l’angle entre la ligne de la position tortue, et (x, y) ou d’une autre tortue. Paramètres:

Paramètres

• x – – un nombre, une paire de nombre ou une instance tortue

• y – – un nombre si x est un nombre, sinon None

static version()

Retourne la version de la classe.

Attention, le numero de version du setup.py est extrait d’ici.

visible

Retourne True/False, si la tortue est visible ou pas.

vitesse

Fixe, modifie ou retourne la vitesse de la tortue.

Vitesses disponibles: “très lente”, “lente”, “normale”, “rapide”, “en avant toute”