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

redondear en python

Question

¿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

Answer 1

**

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

Answer 2

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 args son int, pero es división verdadera cuando uno o ambos args son float.

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

Answer 3

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

La razón por la que esto es importante es que // es una división de piso sin ambigüedades, 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 comandos de Python, ya sea -Q old o -Q new

Answer 4

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

Answer 5

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

>>> 7//3
2

Answer 6

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

Answer 7

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

Answer 8

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

Answer 9

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.

Answer 10

/ -> División de punto flotante

// -> División del 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 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

Answer 11

>>> print 5.0 / 2
2.5
>>> print 5.0 // 2
2.0