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

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

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

En Python 3.0, 5/2 devolverá 2.5 y 5 // 2 devolverá 2 . La primera es la división de punto flotante, y la segunda es la división de piso, a veces también llamada división entera.

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

Independientemente de la importación futura, 5.0 // 2 devolverá 2.0 ya 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

Ayuda a aclarar para la línea Python 2.x, / no es división de piso ni división verdadera. La respuesta aceptada actual no está clara en esto. / es división de piso cuando ambos argumentos son int, pero es división verdadera cuando uno o ambos argumentos son flotantes.

Lo anterior dice mucha más verdad y es mucho 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.0 dará 0.5 , pero ambos 1/2 , 1//2 y 1.0//2.0 darán 0 .

Consulte https://docs.python.org/whatsnew/2.2.html#pep-238-changing-the-division-operator para obtener detalles

/ -> División de punto flotante

// -> División del piso

Veamos algunos ejemplos en Python 2.7 y 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 ya que no hay diferencia entre la división del 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 división de piso.

La razón por la que esto es importante es que // es inequívocamente una división de piso, en todas las versiones de Python a partir de 2.2, incluidas las versiones de Python 3.x.

El comportamiento de / puede cambiar dependiendo de:

  • Activo __future__ importar o no (módulo-local)
  • Opción de línea de comando de Python, ya sea -Q old o -Q new
 >>> print 5.0 / 2 2.5 >>> print 5.0 // 2 2.0 

**

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

** / División Divide el operando de la mano izquierda por el operando de la derecha ex :: 4/2 = 2

División de piso (//): la división de los 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 desplaza, es decir, se redondea desde cero (hacia el infinito negativo): ejemplos: 9 // 2 = 4 y 9.0 // 2.0 = 4.0, -11 // 3 = -4 , -11.0 // 3 = -4.0

Tanto el operador de división de división como el de división y // operan de manera similar

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

 >>> 7//3 2 

// es 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 

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

Python promueve la conversión de un tipo de datos inferior (entero) a un tipo de datos superior (flotante) para evitar la pérdida de datos.

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