Usando la división entera en Python

¿Puedes ayudarme a descubrir esta división de Python?

base = 12.0

altura = 16

Área = 1/2 * Base * Altura

La solución lo demuestra

área = (base * altura) / 2;

lo que me confunde que 1/2 será flotante y Python mostrará solo 0, no 0.5, por qué la solución muestra / 2 en este caso …

Python2.7 usa automáticamente el operador / como división entera (número entero), que siempre producirá un número entero.

Por ejemplo:

1/2 = 0

3/4 = 0

100/30 = 3

Para hacer la división de flotación, debe tener uno o ambos valores como tipo de flotación.

Me gusta esto:

 Area = 1.0/2 * Base * Height # 1.0 is a float type, 1 is an integer type 

Los resultados no son los esperados, ya que Python evalúa las expresiones mediante la división de enteros y el orden de las operaciones.

Si evalúa 16 * 12 / 2 12/2 en Python, Python interpreta esto como (16 * 12) / 2 , o 192 / 2 = 96

Si evalúas 1/2 * 16 * 12 , Python interpreta esto como (((1/2) * 16) * 12) = (0 * 16) * 12

Otros ejemplos:

 Area = Base * Height * (1.0/2.0) 

Python evalúa (1.0 / 2.0) primero esta vez, ya que el orden de las operaciones determina que los paréntesis se evalúen primero. Y como 1.0 y 2.0 son flotantes y no enteros, Python está bien para realizar la división de flotación. Usted obtiene esto:

 Base * Height * (0.5) = 192 * 0.5 = 96 

, que te da lo que esperas.

A diferencia de:

 Base * Height * (1/2) = Base * Height * (0) # since 1/2 rounds down to 0 in integer division = 192 * 0 = 0 

Solución alternativa de Carpetsmoker:

 from __future__ import division 

Esta línea le dará el comportamiento de Python3.x en un progtwig de Python2.x, y Python3.x acepta el operador / como división flotante, incluso si ambos valores son tipos enteros. Por lo tanto, después de importar esto, / convierte en el operador de división flotante.

 >>> from __future__ import division >>> 1/2 0.5 

La división entera es donde el rest pasado el lugar de uno es simplemente descartado. Dividir 7 en 3 nos dará 3 stacks de 2, con una sobra, por lo tanto:

 7 / 3 = 2 

Python tiene dos tipos de números comúnmente usados: los enteros, que solo pueden express números enteros, y los flotantes, que pueden express un número decimal. Tradicionalmente, en muchos lenguajes de progtwigción (C, Java, etc.), realizar una operación básica, como + , - , * o / en dos objetos del mismo tipo le daría otro objeto de ese tipo. Si fueran diferentes, uno de los objetos sería encasillado a la forma más genérica. Por lo general, esto da como resultado que un entero, que no puede express fracciones, se convierta en un flotador, que puede. Los dos flotadores se dividen entonces, dando otro flotador.

Entonces, en Python 2, cuando usa el operador / con dos enteros, el resultado será un entero. 1/2 es 0.5 , pero la parte fraccionaria se descarta, así que te quedas con 0 .

Sin embargo, en Python 3 / se modificó para convertir siempre a un número de punto flotante, lo que resulta en una verdadera división. 1/2 = 0.5 , y 2/1 = 2.0 . Para los nuevos progtwigdores, este es el comportamiento “esperado”, y puede proporcionar un código más limpio para los progtwigdores existentes. Este nuevo comportamiento se puede emular en Python 2 agregando una importación futura en la parte superior de su script:

 from __future__ import division 

Si desea una división truncada en Python 2.5+ o 3.x, existe el nuevo // operador que emula el antiguo / .