J'ai récemment remarqué que int()arrondit un flotteur vers 0, tandis que la division entière arrondit un flotteur vers son plancher.
par exemple:
-7 // 2 = -4
int(-7/2) = -3J'ai lu la documentation qui précise:
classe int (x, base = 10)
Retourne un objet entier construit à partir d'un nombre ou d'une chaîne x, ou retourne 0 si aucun argument n'est> donné. Si x est un nombre, retournez x. int (). Pour les nombres à virgule flottante, cela tronque vers zéro.
et:
division au sol
Division mathématique qui arrondit à l'entier le plus proche. L'opérateur de division de plancher est //. Par exemple, l'expression 11 // 4 est évaluée à 2 contrairement à 2,75 renvoyée par float true division. Notez que (-11) // 4 est -3 parce que c'est -2,75 arrondi vers le bas. Voir PEP 238.
Mais il me semble illogique que 2 opérations similaires (division flottante en entier) retournent des résultats différents.
Y a-t-il une motivation pour les différences entre les fonctions?
Je vous remercie.
la source
Réponses:
Cohérence.
Vous devrez suivre des explications très basiques et apparemment non pertinentes pour le comprendre.
À l'école, vous avez appris la division avec un reste. Et vous avez fait des calculs comme celui-ci:
Plus tard, vous avez appris les divisions pour les nombres réels:
Jusqu'à ce point, vous pourriez croire cela
x // 4etint(x/4)toujours donner le même résultat. C'est votre compréhension actuelle de la situation.Cependant, regardez ce qui se passe dans la division entière: le nombre derrière R passe de 3, 2, 1 à 0 puis redémarre: 3, 2, 1, 0. Le nombre devant le R décroît toutes les 4 étapes.
Alors, comment ça va se passer?
Dans le même temps, la division du nombre réel nous donne:
C'est pourquoi
-1 // 4donne -1 maisint(-1/4)donne 0.Eh bien, ils servent à des fins différentes:
//fait partie d'un calcul d'entier avec des restes etint()vous donne la partie en face.d'une opération de nombre réel.Vous décidez ce que vous voulez calculer, puis vous décidez quel opérateur utiliser en Python pour obtenir le résultat correct.
Bonne question. Continuez à apprendre.
la source
//opérateur en python 3 afin d'éviter de forcer l'utilisation de int (float). Si ce n'est pas le cas, quand devrais-je choisir d'implémenter usingint()et quand devrais-je implémenter using//Math.Floor(3.23) != -Math.Floor(-3.23)Pour la même raison, il-((-x)//y)n'est pas nécessaire qu'il soit égalx//y.Je dirais que votre observation selon laquelle ces 2 opérations devraient être intuitivement similaires est attendue car sur les nombres positifs, elles se comportent de manière identique. Mais si vous regardez leurs origines (l'une vient des mathématiques et l'autre de l'informatique), cela rend plus logique leur comportement différent.
Vous pouvez regarder derrière ces concepts:
=================================================== ================
I) Division du sol alias la fonction de sol appliquée à la division mathématique
La fonction de plancher est un concept très bien établi en mathématiques.
De mathworld.wolfram :
La division du sol n'est donc rien d'autre qu'une fonction de sol appliquée à la division mathématique. Le comportement est très clair, "mathématiquement précis".
II) Conversion de type / coulée de type
De wikipedia :
Dans la plupart des langages de programmation, le flottant de la forme de conversion en entier est appliqué par la règle d'arrondi (il existe donc une convention):
Règle d'arrondi selon IEEE 754 .
Donc, en d'autres termes, la raison de la différence entre la division entière et la conversion float en int en python est mathématique, voici quelques réflexions de Guido van Rossum (je suppose que je n'ai pas à le présenter: D) (du blog L'histoire de Python, article "Pourquoi les étages de division entiers de Python" )
la source