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

Respuestas:

651

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

Eli Courtwright
fuente
editado: ¡Puedes "arreglar" la división desde Python 2.2! (Acabo de leer el PEP vinculado)
u0b34a0f6ae
2
También python -Qnew. otras opciones de división: -Qold(predeterminado) -Qwarn,-Qwarnall
John La Rooy
2
Vale la pena señalar que 5.0 / 2regresa 2.5en todas las versiones, como lo hace 5 / 2.0: el comportamiento anterior solo es diferente cuando ambos operandos lo son int.
Chris
2
¿Qué pasa cuando los números son negativos? ¿Es el comportamiento el mismo para enteros negativos?
Aaron Franke
1
@Srinivasu Tu ejemplo no es útil. Mejor sería 5 // 2 (que produce 2) y -5 // 2 (que produce -3).
Marvin el
67

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.

Yichun
fuente
33

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

Kena
fuente
Esta es una buena respuesta. El enlace PEP es útil. Además, considere usar math.floor()o math.fmod()si no está seguro de lo que sucede con los operadores unarios.
Scott Lowrey
/y //son operadores binarios (dos operandos, izquierdo y derecho, numerador y denominador)
iono
28

/ -> 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
N Randhawa
fuente
¿Es esto lo mismo que int (5/2)?
PirateApp
¿Qué pasa cuando los números son negativos? ¿Es el comportamiento el mismo para enteros negativos?
Aaron Franke
1
Re: Negativos - El comportamiento es el mismo, pero recuerda que el resultado es baja, por lo que es siempre el redondeo hacia abajo hacia la más negativa . Algunos ejemplos: -100 // 33=> -4 ; 100 // -33=> -4 ; pero debido a la dirección de redondeo de las funciones del piso, el siguiente podría parecer contra-intuitivo en comparación con el anterior: -100 // -33=> 3 .
Erdős-Bacon
22

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
u0b34a0f6ae
fuente
10
>>> print 5.0 / 2
2.5

>>> print 5.0 // 2
2.0
Calle Jonas Sciangula
fuente
1
No me había dado cuenta de que la división de piso también funciona con números no enteros. ¡Gracias!
Mike
5

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.

Abrar Ahmad
fuente
2
Hacia el infinito y lejos de cero hay cosas diferentes. Ejemplo para (-1.2 y 3.4): "piso" está hacia el infinito negativo (-2 y 3), "truncar" está hacia cero (-1 y 3), "saturar" está lejos de cero (-2 y 4), y "techo" es hacia el infinito positivo (-1 y 4).
Phernost
4

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

>>> 7//3
2
Mark Roddy
fuente
3

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

Adam Bellaire
fuente
2

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
G.Ant
fuente
2

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
jaya ram
fuente
-1

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.

Sebastian Purakan
fuente
-1
  • // 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
Fatema T. Zuhora
fuente
2
¿Cómo agrega esta respuesta algo que las otras ideas no cubren? ¿O cómo es esta respuesta mejor de alguna manera que las otras respuestas?
Rory Daulton el
2
La siguiente es la salida de un programa. No explica nada.
Marqués de Lorne