Quelle est la différence entre '/' et '//' lorsqu'ils sont utilisés pour la division?
https://stackoverflow.com/questions/183853
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Y at-il un avantage à utiliser l’un sur l’autre? En Python 2, ils semblent tous deux retourner les mêmes résultats:
>>> 6/3
2
>>> 6//3
2
La solution
Dans Python 3.0, 5/2 renverra 2.5 et 5 // 2 renverra 2 . La première est la division en virgule flottante et la dernière est la division de plancher, parfois également appelée division entière.
Dans Python 2.2 ou version ultérieure de la ligne 2.x, il n'y a pas de différence pour les entiers sauf si vous effectuez un à partir de __future__ import division , ce qui oblige Python 2.x à adopter le comportement de 3.0
Quelle que soit l'importation future, 5.0 // 2 renverra 2.0 car il s'agit du résultat de la division d'étage de l'opération.
Vous trouverez une description détaillée sur https. : //docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator
Autres conseils
Il est utile de clarifier pour la ligne Python 2.x, / n'est ni une division de plancher ni une division vraie. La réponse acceptée actuellement n’est pas claire à ce sujet. / est la division d'étage lorsque les deux arguments sont entiers, mais est une division vraie lorsque l'un des arguments, ou les deux, sont flottants.
Ce qui précède dit beaucoup plus de vérité et est beaucoup plus clair que le deuxième paragraphe de la réponse acceptée.
// implémente la "division d'étage", quel que soit votre type. Alors
1.0 / 2.0 donnera 0.5 , mais les deux 1/2 , 1 // 2 et 1.0 //2.0 donnera 0 .
Voir https: //docs.python .org / whatsnew / 2.2.html # pep-238-change-the-division-operator pour plus de détails
/ - > Division en virgule flottante
// - > Division de plancher
Voyons quelques exemples à la fois dans Python 2.7 et dans Python 3.5.
Python 2.7.10 contre Python 3.5
print (2/3) ----> 0 Python 2.7
print (2/3) ----> 0.6666666666666666 Python 3.5
Python 2.7.10 contre Python 3.5
print (4/2) ----> 2 Python 2.7
print (4/2) ----> 2.0 Python 3.5
Maintenant, si vous voulez avoir (en python 2.7) la même sortie que dans python 3.5, vous pouvez procéder comme suit:
Python 2.7.10
from __future__ import division
print (2/3) ----> 0.6666666666666666 #Python 2.7
print (4/2) ----> 2.0 #Python 2.7
Là où il n'y a pas de différence entre la division de Floor dans Python 2.7 et dans Python 3.5
138.93//3 ---> 46.0 #Python 2.7
138.93//3 ---> 46.0 #Python 3.5
4//3 ---> 1 #Python 2.7
4//3 ---> 1 #Python 3.5
Comme tout le monde a déjà répondu, // est la division d'étage.
Pourquoi est-ce important, c'est que // constitue sans ambiguïté la division d'étage, dans toutes les versions de Python à partir de la version 2.2, y compris les versions de Python 3.x.
Le comportement de / peut changer en fonction de:
- Actif
__ future __à importer ou non (module-local) - Option de ligne de commande Python,
-Q ancienou-Q nouveau
>>> print 5.0 / 2
2.5
>>> print 5.0 // 2
2.0
Python 2.7 et une autre version à venir de python:
- Division (
/)
Divise l'opérande gauche par l'opérande droit
Exemple: 4/2 = 2
- Division d'étage (
//)
La division des opérandes dont le résultat est le quotient dans lequel les chiffres après la virgule sont supprimés. Mais si l’un des opérandes est négatif, le résultat est pondéré, c’est-à-dire qu’il est arrondi à zéro (vers l’infini négatif):
Exemples: 9 // 2 = 4 et 9.0 // 2.0 = 4.0 , -11 // 3 = -4 , < code> -11.0 // 3 = -4.0
Les divisions / et l'opérateur de division d'étage // fonctionnent de la même manière.
La double barre oblique, // , correspond à la division de l'étage:
>>> 7//3
2
Dans cette réponse, je vais non seulement dire la réponse, mais aussi les avantages de //.
La plupart d’entre vous qui utilisez Python doivent connaître l’opérateur de division d’étage (//) en Python. Pour ceux qui ne le savent pas, cet opérateur renvoie la valeur plancher après la division. Par exemple: 5/2 = 2,5, mais 5 // 2 = 2 (2 est la valeur plancher de 2,5)
Mais l'opérateur de division se comporte anormalement généralement pour les nombres supérieurs à 10 ^ 17.
x = 10000000000000000000006
if x / 2 == x // 2:
print("Hello")
else:
print("World")
Pour le code ci-dessus, Monde sera imprimé et non Bonjour. En effet, 10000000000000000000006/2 renverra 5e + 21, mais 10000000000000000000006 // 2 renverra la réponse correcte 5000000000000000000003. Même int (10000000000000000000006/2) renverra 5000000000000000000000, ce qui est incorrect.
Par conséquent, même si vous souhaitez diviser de grands nombres, utilisez l'opérateur //.
Par exemple: si vous voulez trouver la somme des premiers 1000000000000000000000000000010002, avec la formule suivante: n (n + 1) / 2, l'opérateur de division normal (/) vous donnera une réponse incorrecte, mais l'opérateur // vous donnera la bonne répondre.
// est la division de plancher, elle vous donnera toujours le plancher entier du résultat. L’autre est la division «régulière».
La réponse de l'équation est arrondie au nombre entier immédiatement inférieur ou à un nombre égal à 0, avec le séparateur décimal.
>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0
Les réponses ci-dessus sont bonnes. Je veux ajouter un autre point. Jusqu'à un certain nombre de valeurs, les deux résultent dans le même quotient. Après que cet opérateur de division d’étage ( // ) fonctionne correctement mais pas l’opérateur de division ( / ).
- > int(755349677599789174/2)
- > 377674838799894592 #wrong answer
- > 755349677599789174 //2
- > 377674838799894587 #correct answer
Les suivants sont la différence entre '/' et '//'; J'ai exécuté ces opérations arithmétiques dans Python 3.7.2
>>> print 11 / 3
3.6666666666666665
>>> print 11 // 3
3
>>> print 11.3 / 3
3.7666666666666667
>>> print 11.3 // 3
3.0
5.0 // 2 génère 2.0 et non 2 car le type de retour de la valeur renvoyée L'opérateur from // suit les règles de coercition (typage) de python.
Python favorise la conversion du type de données inférieur (entier) en type de données supérieur (float) afin d'éviter toute perte de données.
