Je teste la structure du tuple, et j'ai trouvé cela étrange lorsque j'utilise le ==
opérateur comme:
>>> (1,) == 1,
Out: (False,)
Lorsque j'assigne ces deux expressions à une variable, le résultat est vrai:
>>> a = (1,)
>>> b = 1,
>>> a==b
Out: True
Cette question est différente de règle de syntaxe de virgule de fin de tuple Python à mon avis. Je demande au groupe d'expressions entre ==
_ opérateur.
D'autres réponses vous ont déjà montré que le comportement est dû à la priorité des opérateurs, comme documenté ici .
Je vais vous montrer comment trouver la réponse vous-même la prochaine fois que vous aurez une question semblable à celle-ci. Vous pouvez déconstruire le mode d'analyse de l'expression à l'aide du module ast
:
>>> import ast
>>> source_code = '(1,) == 1,'
>>> print(ast.dump(ast.parse(source_code), annotate_fields=False))
Module([Expr(Tuple([Compare(Tuple([Num(1)], Load()), [Eq()], [Num(1)])], Load()))])
On peut voir à partir de cela que le code est analysé comme l'explique Tim Peters :
Module([Expr(
Tuple([
Compare(
Tuple([Num(1)], Load()),
[Eq()],
[Num(1)]
)
], Load())
)])
Ceci est juste la priorité des opérateurs. Ta première
(1,) == 1,
des groupes comme ceux-ci:
((1,) == 1),
construit donc un Tuple avec un seul élément à partir du résultat de la comparaison du Tuple à un élément 1,
au nombre entier 1
pour l'égalité Ils ne sont pas égaux, vous obtenez donc le 1-tuple False,
pour un résultat.
Quand tu fais
>>> (1,) == 1,
il construit un tuple avec le résultat de la comparaison du tuple(1,)
avec un entier et retournant ainsi False
.
Au lieu de cela, lorsque vous affectez des variables, les deux tuples égaux sont comparés l'un à l'autre.
Tu peux essayer:
>>> x = 1,
>>> x
(1,)