División de python

Estaba tratando de normalizar un conjunto de números de -100 a 0 a un rango de 10-100 y estaba teniendo problemas solo para notar que incluso sin ninguna variable, esto no evalúa la forma en que esperaría que:

>>> (20-10) / (100-10) 0 

La división de flotación tampoco funciona:

 >>> float((20-10) / (100-10)) 0.0 

Si cualquiera de los lados de la división se convierte en un flotador, funcionará:

 >>> (20-10) / float((100-10)) 0.1111111111111111 

Cada lado en el primer ejemplo se evalúa como un int, lo que significa que la respuesta final se convertirá en un int. Como 0.111 es menor que .5, se redondea a 0. No es transparente en mi opinión, pero creo que así es.

¿Cuál es la explicación?

Estás utilizando Python 2.x, donde las divisiones de enteros se truncarán en lugar de convertirse en un número de punto flotante.

 >>> 1 / 2 0 

Debes hacer que uno de ellos sea un float :

 >>> float(10 - 20) / (100 - 10) -0.1111111111111111 

o from __future__ import division , que obliga / adopta el comportamiento de Python 3.x que siempre devuelve un flotador.

 >>> from __future__ import division >>> (10 - 20) / (100 - 10) -0.1111111111111111 

Estás poniendo enteros en Python para que te devuelva un entero :

 >>> 10 / 90 0 

Si después de convertir esto en un flotador, el redondeo ya se habrá realizado, en otras palabras, 0 entero siempre se convertirá en 0 flotante.

Si usa flotadores en cualquier lado de la división, Python le dará la respuesta que espera.

 >>> 10 / 90.0 0.1111111111111111 

Así que en tu caso:

 >>> float(20-10) / (100-10) 0.1111111111111111 >>> (20-10) / float(100-10) 0.1111111111111111 

Necesitas cambiarlo a un flotador ANTES de hacer la división. Es decir:

 float(20 - 10) / (100 - 10) 

Tiene que ver con la versión de python que usas. Básicamente, adopta el comportamiento de C: si se dividen dos enteros, los resultados se redondearán a un entero. También tenga en cuenta que Python realiza las operaciones de izquierda a derecha, lo que juega un papel cuando se encasilla.

Ejemplo: dado que esta es una pregunta que siempre aparece en mi cabeza cuando estoy realizando operaciones aritméticas (si convierto a flotar y qué número), se presenta un ejemplo de ese aspecto:

 >>> a = 1/2/3/4/5/4/3 >>> a 0 

Cuando dividimos los enteros, no es sorprendente que se redondee más bajo.

 >>> a = 1/2/3/4/5/4/float(3) >>> a 0.0 

Si escribimos el último número entero para flotar, todavía obtendremos cero, ya que cuando nuestro número se divide por el valor flotante ya se ha convertido en 0 debido a la división entera.

 >>> a = 1/2/3/float(4)/5/4/3 >>> a 0.0 

El mismo escenario que el anterior, pero cambiando el patrón de flotación un poco más cerca del lado izquierdo.

 >>> a = float(1)/2/3/4/5/4/3 >>> a 0.0006944444444444445 

Finalmente, cuando encasillamos el primer entero para flotar, el resultado es el deseado, ya que a partir de la primera división, es decir, la que está más a la izquierda, usamos flotadores.

Extra 1: si está intentando responder eso para mejorar la evaluación aritmética, debe verificar esto

Extra 2: Tenga cuidado con el siguiente escenario:

 >>> a = float(1/2/3/4/5/4/3) >>> a 0.0 

En Python 2.7, el operador / es una división entera si las entradas son enteros:

 >>>20/15 1 >>>20.0/15.0 1.33333333333 >>>20.0/15 1.33333333333 

En Python 3.3, el operador / es una división flotante incluso si las entradas son enteras.

 >>> 20/15 1.33333333333 >>>20.0/15 1.33333333333 

Para la división entera en Python 3, usaremos el operador // .

El operador // es un operador de división de enteros tanto en Python 2.7 como en Python 3.3.

En Python 2.7 y Python 3.3:

 >>>20//15 1 

Ahora, vea la comparación

 >>>a = 7.0/4.0 >>>b = 7/4 >>>print a == b 

Para el progtwig anterior, la salida será False en Python 2.7 y True en Python 3.3.

En Python 2.7 a = 1.75 y b = 1.

En Python 3.3 a = 1.75 y b = 1.75, solo porque / es una división flotante.

Especificando un flotador colocando un ‘.’ después de que el número también hará que flote por defecto.

 >>> 1 / 2 0 >>> 1. / 2. 0.5 

Haga que al menos uno de ellos flote, entonces será división flotante, no entero:

 >>> (20.0-10) / (100-10) 0.1111111111111111 

Lanzar el resultado para flotar es demasiado tarde.

En Python cv2 no se actualizó el cálculo de la división. por lo tanto, debe incluir from __future__ import division en la primera línea del progtwig.

De cualquier manera, es división entera. 10/90 = 0. En el segundo caso, simplemente estás lanzando 0 a un flotador.

Intenta lanzar uno de los operandos de “/” para que sea un flotador:

 float(20-10) / (100-10) 

Estás lanzando para flotar después de que la división ya haya sucedido en tu segundo ejemplo. Prueba esto:

 float(20-10) / float(100-10) 

Estoy algo sorprendido de que nadie haya mencionado que al póster original le hubiera gustado que se obtuvieran números racionales . Si está interesado en esto, el progtwig Sage basado en Python tiene su respaldo . (Actualmente todavía se basa en Python 2.x, aunque 3.x está en curso).

 sage: (20-10) / (100-10) 1/9 

Esta no es una solución para todos, ya que hace algunas tareas de preparing, por lo que estos números no son int s, sino elementos de clase Sage Integer . Aún así, vale la pena mencionar como parte del ecosistema de Python.

Personalmente preferí insertar un 1. * al principio. Así que la expresión se convierte en algo así:

 1. * (20-10) / (100-10) 

Como siempre hago una división para alguna fórmula como:

 accuracy = 1. * (len(y_val) - sum(y_val)) / len(y_val) 

por lo que es imposible simplemente agregar un .0 como 20.0 . Y en mi caso, envolver con un float() puede perder un poco de legibilidad.