¿Cuál es la diferencia entre '/' y '//' cuando se usa para la división?

¿Hay algún beneficio en usar uno sobre el otro? En Python 2, ambos parecen devolver los mismos resultados:

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

En Python 3.x, 5 / 2volverá 2.5y 5 // 2volverá 2. La primera es la división de coma flotante, y la segunda es la división de piso , a veces también llamada división de enteros .

En Python 2.2 o posterior en la línea 2.x, no hay diferencia para los enteros a menos que ejecute a from __future__ import division, lo que hace que Python 2.x adopte el comportamiento 3.x.

Independientemente de la importación futura, 5.0 // 2regresará 2.0ya que ese es el resultado de la división de piso de la operación.

Puede encontrar una descripción detallada en https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator

Python 2.x Aclaración:

Para aclarar para la línea Python 2.x, /no es ni división de piso ni división verdadera. La respuesta aceptada actual no está clara en esto.

/es la división del piso cuando ambos args son int, pero es la división verdadera cuando uno o ambos args lo son float.

Lo anterior dice más verdad y es más claro que el segundo párrafo en la respuesta aceptada.

//implementa "división de piso", independientemente de su tipo. Entonces 1.0/2.0dará 0.5, pero ambos 1/2, 1//2y 1.0//2.0dará 0.

Ver https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator para más detalles

/ -> División de punto flotante

// -> División de piso

Veamos algunos ejemplos tanto en Python 2.7 como en 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

Ahora, si desea tener (en Python 2.7) la misma salida que en Python 3.5, puede hacer lo siguiente:

Python 2.7.10

from __future__ import division
print (2/3)  ----> 0.6666666666666666   #Python 2.7
print (4/2)  ----> 2.0                  #Python 2.7

Donde como no hay diferencia entre la división de piso en Python 2.7 y 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

Como todos ya han respondido, //es la división de piso.

Por qué esto es importante es que //es una división de piso inequívoca, en todas las versiones de Python desde 2.2, incluidas las versiones de Python 3.x.

El comportamiento de /puede cambiar dependiendo de:

• __future__Importación activa o no (módulo local)
• Opción de línea de comando de Python, ya sea -Q oldo-Q new

>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0

Python 2.7 y otra próxima versión de python:

• División ( /)

Divide el operando de la izquierda por el operando de la derecha

Ejemplo: 4 / 2 = 2

• División de piso ( //)

La división de operandos donde el resultado es el cociente en el que se eliminan los dígitos después del punto decimal. Pero si uno de los operandos es negativo, el resultado se anula, es decir, se redondea desde cero (hacia el infinito negativo):

Ejemplos: 9//2 = 4y 9.0//2.0 = 4.0, -11//3 = -4,-11.0//3 = -4.0

Tanto la /división como el //operador de la división de piso operan de manera similar.

La doble barra //, es la división del piso:

>>> 7//3
2

//es la división de piso, siempre le dará el piso entero del resultado. La otra es la división 'regular'.

La respuesta de la ecuación se redondea al siguiente entero más pequeño o flotante con .0 como punto decimal.

>>>print 5//2
2
>>> print 5.0//2
2.0
>>>print 5//2.0
2.0
>>>print 5.0//2.0
2.0

Las respuestas anteriores son buenas. Quiero agregar otro punto. Hasta algunos valores, ambos dan como resultado el mismo cociente. Después de ese operador de división de piso ( //) funciona bien pero no el /operador de división ( ).

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

5.0//2da como resultado 2.0, y no 2porque el tipo de retorno del valor de retorno del //operador siga las reglas de coerción de python (conversión de tipo).

Python promueve la conversión de un tipo de datos más bajo (entero) a un tipo de datos más alto (flotante) para evitar la pérdida de datos.

• // es la división de piso, siempre le dará el valor de piso del resultado.
• Y el otro /es la división de punto flotante.

Los siguientes son la diferencia entre /y //; He ejecutado estas operaciones aritméticas en 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