python - redondear - ¿Cómo puedo forzar la división para que sea punto flotante? ¿La división sigue redondeando a 0?

redondear en python (13)

Tengo dos valores enteros b , pero necesito su relación en punto flotante. Sé que a < b y quiero calcular a / b , así que si uso la división entera, siempre obtendré 0 con el resto de a .

¿Cómo puedo forzar que c sea un número de punto flotante en Python en lo siguiente?

c = a / b

¿Cómo puedo forzar que la división sea punto flotante en Python?
Tengo dos valores enteros ayb, pero necesito su relación en punto flotante. Sé que a <b y quiero calcular a / b, así que si uso la división entera, siempre obtendré 0 con el resto de a.
¿Cómo puedo forzar que c sea un número de punto flotante en Python en lo siguiente?
c = a / b

Lo que realmente se pregunta aquí es:

"¿Cómo fuerzo la división verdadera de modo que a / b devuelva una fracción?"

Actualizar a Python 3

En Python 3, para obtener la verdadera división, simplemente debes hacer a / b .

>>> 1/2 0.5

La división de piso, el comportamiento clásico de división para enteros, ahora es a // b :

>>> 1//2 0 >>> 1//2.0 0.0

Sin embargo, puede quedar atrapado usando Python 2, o puede estar escribiendo código que debe funcionar tanto en 2 como en 3.

Si usa Python 2

En Python 2, no es tan simple. Algunas formas de tratar con la división clásica de Python 2 son mejores y más robustas que otras.

Recomendación para Python 2

Puede obtener el comportamiento de división de Python 3 en cualquier módulo dado con la siguiente importación en la parte superior:

from __future__ import division

que luego aplica la división de estilo Python 3 a todo el módulo. También funciona en una concha de pitón en cualquier punto dado. En Python 2:

>>> from __future__ import division >>> 1/2 0.5 >>> 1//2 0 >>> 1//2.0 0.0

Esta es realmente la mejor solución, ya que garantiza que el código de su módulo sea más compatible con Python 3.

Otras opciones para Python 2

Si no desea aplicar esto a todo el módulo, está limitado a algunas soluciones. El más popular es forzar a uno de los operandos a un flotador. Una solución robusta es a / (b * 1.0) . En una cáscara de Python fresca:

>>> 1/(2 * 1.0) 0.5

También robusto es truediv del operator operator.truediv(a, b) truediv operator.truediv(a, b) , pero esto es probablemente más lento porque es una llamada de función:

>>> from operator import truediv >>> truediv(1, 2) 0.5

No recomendado para Python 2

Comúnmente se ve a / float(b) . Esto elevará un TypeError si b es un número complejo. Dado que la división con números complejos está definida, tiene sentido para mí no fallar la división cuando se pasa un número complejo para el divisor.

>>> 1 / float(2) 0.5 >>> 1 / float(2j) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can''t convert complex to float

No tiene mucho sentido para mi propósito hacer que su código sea más frágil.

También puede ejecutar Python con el indicador -Qnew , pero esto tiene el inconveniente de ejecutar todos los módulos con el nuevo comportamiento de Python 3, y algunos de sus módulos pueden esperar una división clásica, por lo que no recomiendo esto excepto para las pruebas. Pero para demostrar:

$ python -Qnew -c ''print 1/2'' 0.5 $ python -Qnew -c ''print 1/2j'' -0.5j

Esto también funcionará
u = 1. / 5 imprime u
0.2
respondió el 24 de diciembre de 2013 a las 19:58 Gaurav Agarwal 6,7172279140

Gracias Gauraw, esto hace el truco y es una solución bastante buena. En caso de que tanto el numerador como el denominador sean variables, la "solución" podría estar multiplicando 1. por el cociente.

Ejemplo:

aa = 2 bb = 3 aa / bb = 0 1. * aa / bb = 0.6666666666666666

;-)

Max - italia

Agregue un punto ( . ) Para indicar números de punto flotante

>>> 4/3. 1.3333333333333333

>>> from __future__ import division >>> 4/3 1.3333333333333333

Al hacer cualquiera de los parámetros para la división en formato de punto flotante también se produce la salida en punto flotante.

Ejemplo:

>>> 4.0/3 1.3333333333333333

>>> 4 / 3.0 1.3333333333333333

>>> 4 / float(3) 1.3333333333333333

>>> float(4) / 3 1.3333333333333333

En Python 3.x, la barra única ( / ) siempre significa división verdadera (no truncadora). (El operador // se usa para truncar la división). En Python 2.x (2.2 y superior), puede obtener este mismo comportamiento al poner un

from __future__ import division

en la parte superior de su módulo.

Esto también funcionará

>>> u=1./5 >>> print u

0.2

Puedes lanzar para flotar haciendo c = a / float(b) . Si el numerador o denominador es un flotante, el resultado también lo será.

Una advertencia: como han señalado los comentaristas, esto no funcionará si b podría ser algo más que un número entero o de coma flotante (o una cadena que representa uno). Si es posible que estés tratando con otros tipos (como números complejos) necesitarás verificarlos o usar un método diferente.

Si desea usar la división "verdadera" (punto flotante) de forma predeterminada, hay un indicador de línea de comando:

python -Q new foo.py

Hay algunos inconvenientes (de la PEP):

Se ha argumentado que una opción de línea de comando para cambiar el valor predeterminado es mala. Ciertamente, puede ser peligroso en las manos equivocadas: por ejemplo, sería imposible combinar un paquete de biblioteca de terceros que requiera -Que con otro que requiera -Qold.

Puede obtener más información sobre los valores de otras banderas que cambian / advierten sobre el comportamiento de la división en la página de manual de python.

Para detalles completos sobre los cambios de división, lea: PEP 238 - Cambiando el Operador de División

Si haces una división de dos enteros, Python te devolverá un entero, entonces debes hacer:

c = float(a)/b

c = a/float(b)

y luego obtener c como un tipo de float

>>> from __future__ import division >>> a = 4 >>> b = 6 >>> c = a / b >>> c 0.66666666666666663

c = a / (b * 1.0)

from operator import truediv c = truediv(a, b)

donde a es dividendo y b es el divisor. Esta función es útil cuando el cociente después de la división de dos enteros es un flotante.