Quelle est la différence entre '/' et '//' lorsqu'il est utilisé pour la division?

Y a-t-il un avantage à utiliser l'un sur l'autre? En Python 2, ils semblent tous deux renvoyer les mêmes résultats:

>>> 6/3
2
>>> 6//3
2

Dans Python 3.x, 5 / 2reviendra 2.5et 5 // 2reviendra 2. La première est une division en virgule flottante, et la seconde est une division au sol , parfois aussi 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 à moins que vous n'effectuiez un from __future__ import division, ce qui fait que Python 2.x adopte le comportement 3.x.

Quelle que soit la future importation, 5.0 // 2elle reviendra, 2.0car c'est le résultat de la division du sol 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

Clarification Python 2.x:

Pour clarifier la ligne Python 2.x, il /n'y a ni division au sol ni division vraie. La réponse actuellement acceptée n'est pas claire à ce sujet.

/est la division du plancher lorsque les deux arguments le sont int, mais est la véritable division lorsque l' un ou les deux arguments le sont float.

Ce qui précède dit plus de vérité et est plus clair que le 2ème paragraphe de la réponse acceptée.

//implémente la "division du sol", quel que soit votre type. Alors 1.0/2.0donnera 0.5, mais les deux 1/2, 1//2et 1.0//2.0donnera 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 étage

Voyons quelques exemples à la fois en python 2.7 et en 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 qu'en python 3.5, vous pouvez faire ce qui 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 Floor en python 2.7 et en 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, //c'est la division du sol.

Ce qui est important, c'est que la //division de l'étage est sans ambiguïté, dans toutes les versions Python de 2.2, y compris les versions Python 3.x.

Le comportement de /peut changer selon:

• __future__Importation active 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 de gauche par l'opérande de droite

Exemple: 4 / 2 = 2

• Division de plancher ( //)

La division des opérandes où le résultat est le quotient dans lequel les chiffres après le point décimal sont supprimés. Mais si l'un des opérandes est négatif, le résultat est plancher, c'est-à-dire arrondi à zéro (vers l'infini négatif):

Exemples: 9//2 = 4et 9.0//2.0 = 4.0, -11//3 = -4,-11.0//3 = -4.0

L' opérateur de la /division et celui de la //division des sols fonctionnent de manière similaire.

La double barre oblique,, //est la division au sol:

>>> 7//3
2

//est la division du 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 au plus petit entier ou flottant suivant avec 0,0 comme point 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'à certaines valeurs, les deux donnent le même quotient. Après cet opérateur de division de plancher ( //) fonctionne bien, mais pas l' /opérateur de division ( ).

 - > int(755349677599789174/2)
 - > 377674838799894592      #wrong answer
 - > 755349677599789174 //2
 - > 377674838799894587      #correct answer

5.0//2résulte en 2.0, et non 2parce que le type de retour de la valeur de retour de 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.

• // est la division du sol, il vous donnera toujours la valeur au sol du résultat.
• Et l'autre /est la division en virgule flottante.

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