Quelle est la différence entre '/' et '//' lorsqu'ils sont utilisés pour la division?
Y a-t-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
Dans Python 3.0, 5 / 2 renverra 2.5 et 5 // 2 renverra 2. La première est une division en virgule flottante et la dernière est une 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 from __future__ import division, ce qui oblige Python 2.x à adopter le comportement de 3.0
Indépendamment de l'importation future, 5.0 // 2 renverra 2.0 puisqu'il s'agit du résultat de la division d'étage de l'opération.
Vous pouvez trouver une description détaillée sur https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator
Il est utile de clarifier pour la ligne Python 2.x, / n’est ni une division d’étage ni une véritable division. La réponse acceptée actuellement n’est pas claire à ce sujet. / est une division de plancher lorsque les deux arguments sont entiers, mais une division vraie lorsque l'un des arguments, ou les deux, sont flottants.
Ce qui précède révèle 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 du sol", quel que soit votre type. Donc 1.0/2.0 donnera 0.5, mais 1/2, 1//2 et 1.0//2.0 donneront 0.
Voir https://docs.python.org/whatsnew/2.2.html#pep-238-changing-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 vs. Python 3.5
print (2/3) ----> 0 Python 2.7
print (2/3) ----> 0.6666666666666666 Python 3.5
Python 2.7.10 vs. 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’ya 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 du sol.
Pourquoi est-ce important? // représente sans ambiguïté la division d'étage dans toutes les versions de Python à partir de 2.2, y compris les versions de Python 3.x.
Le comportement de / peut changer selon:
- Active
__future__importer ou non (module-local) - Option de ligne de commande Python, soit
-Q oldou-Q new
>>> 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 Ex :: 4/2 = 2
Division d'étage (//) - Division d'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 arrondi à zéro (vers l'infini négatif): Exemples: 9 // 2 = 4 et 9.0 // 2.0 = 4.0, -11 // 3 = -4, -11,0 // 3 = -4,0
Les opérateurs/Division et // de la division d’étage fonctionnent de la même manière
La double barre oblique, //, correspond à la division du sol:
>>> 7//3
2
Dans cette réponse, je ne dirai pas seulement la réponse, mais aussi les avantages de //.
La plupart d’entre vous qui utilisez Python doivent connaître l’opérateur de division de plancher (//) 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 des 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 // opérateur.
Par exemple: Si vous voulez trouver la somme des premiers 1000000000000000000000000000010002 nombres avec la formule: n (n + 1)/2, l'opérateur de division normal (/) vous donnera une réponse incorrecte, mais l'opérateur // vous donnera une réponse correcte.
// est la division de plancher, il 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 à l'entier inférieur le plus proche ou à la virgule flottante, avec un point décimal égal à .0.
>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0
5.0//2 se traduit par 2.0 et non pas 2 car l'opérateur return type de la valeur renvoyée par l'opérateur // suit les règles de coercition python (conversion de type).
Python favorise la conversion du type de données inférieur (entier) en type de données supérieur (float) pour éviter la perte de données.
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 cet opérateur de division d'étage (//) fonctionne correctement mais pas d'opérateur de division (/).
- > int(755349677599789174/2)
- > 377674838799894592 #wrong answer
- > 755349677599789174 //2
- > 377674838799894587 #correct answer
Les suivis 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