Comparaison tuple

Hello,

J'ai une question par rapport à la comparaison de tuple avec Python, car je n'ai pas le même comportement avec l'interpréteur et avec un code exécuté. En effet, je souhaite mettre en avant l'utilisation des fonctions poly de turtle et pour ce faire, je veux comparer le premier point avec le dernier pour savoir si nous ne sommes pas revenus au point de départ. Or, il se trouve qu'à chaque fois la comparaison != retourne True, même si le point d'arrivée est identique au point de départ. J'ai essayé en changeant de position de départ ainsi que la forme de la figure, mais ça ne change pas et je ne comprends pas ce qui ne va pas :

Avec la console :

1
2
3
4

(-0.00, 0.00) == (0.00, 0.00)
>> True
(-0.00, 0.00) != (0.00, 0.00)
>> False

Avec le code (cf. notre_end_fill) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import turtle

def notre_begin_fill():
    turtle.begin_fill()
    turtle.begin_poly()

def notre_end_fill():
    turtle.end_poly()
    poly = turtle.get_poly()
    if poly[0] != poly[-1]:  #Devrait être False
        print(poly)  #Affiche ((0.00,0.00), (90.00,0.00), (90.00,90.00), (0.00,90.00), (-0.00,0.00))
        print(poly[0])  #Affiche (0.00,0.00)
        print(poly[-1])  #Affiche (-0.00,0.00)
        turtle.goto(poly[0])
    turtle.end_fill()

if __name__ == "__main__":
    turtle.color("red", "green")
    notre_begin_fill()
    for i in range(4):
        turtle.forward(90)
        turtle.left(90)
    notre_end_fill()

Merci de votre aide !

EDIT : La version de Python utilisée est la 3.4.3

Merci de ta réponse à la fois éclairante et troublante !

Sais-tu à quoi est dû ce -1.6532731788489267e-14 ? Une imprécision de turtle ?

@Nodraak

Merci pour l'explication et les propositions ! Après ta première réponse, j'avais songé au calcul de la différence, je vais voir avec tes autres propositions et tes autres liens.

@Vayel

Merci pour le lien

Même si c'est toi qui définit les valeurs ?

Tu as raison, je vais utiliser round et ça fera l'affaire ici

Yep,

Mais ça retourne un flottant arrondi à un nombre de chiffres après la virgule choisi :

1
2
3
4

>>> round(0.99432656, 0)
1.0
>>> round(0.4444, 0)
0.0

Tandis que int arrondit toujours à l'entier inférieur (enfin pour être exact : "For floating point numbers, this truncates towards zero.") :

1
2
3
4

>>> int(0.9999)
0
>>> int(0.4444)
0

Ce qui est donne moins de précision ici, c'est pourquoi je préfère utiliser round.

Ça restera des flottants. Les pixels de ton écran, c'est une valeur discrète, il n'y a aucune raison d'utiliser des flottants pour ça. Si ça te rassure d'utiliser round, utilise au moins int(round(...)).

Oui c'est vrai, mais ici turtle nous fournit des points flottants (get_poly). Effectivement, je peux toujours convertir en entier après avoir arrondi avant de comparer les deux points, mais au final est-ce que ça change quelque chose vu que j'arrondirai à 0 chiffre après la virgule ? Donc l'utilisation de int n'est pas forcément nécessaire, mais peut-être qu'elle fait plus sens comme tu le dis.

l'utilisation de int n'est pas forcément nécessaire

On vient de passer une page à t'expliquer que l'égalité stricte entre flottants n'était pas fiable…

Oui, oui, ça j'ai bien compris ce que je veux dire c'est que l'utilisation de int n'est pas nécessaire si j'arrondis comme je l'ai dit plus haut avec round(x, 0), à moins que je fasse erreur et que la comparaison de deux flottants de la forme x.x0 et x.x0 (comme 0.0 et 0.0) après avoir arrondi n'est pas fiable (d'où ma question à Kje un peu plus haut dans la page)

Eh bien, c'est surprenant merci pour vos réponses qui m'ont éclaircies sur le sujet !