Question about typing: ints/floats
Wells
>>> a = 1
>>> a += 1.202
>>> a
2.202
Indicates that 'a' was an int that was implicitly casted to a float.
But:
>>> a = 1
>>> b = 3
>>> a / b
0
This does not implicitly do the casting, it treats 'a' and 'b' as
integers, and the result as well. Changing 'b' to 3.0 will yield a
float as a result (0.33333333333333331)
Is there some way to explain the consistency here? Does python
implicitly change the casting when you add variables of a different
numeric type?
Anyway, just curiosity more than anything else. Thanks!
Zeeshan Quireshi
Python, like most other languages performs only integer division when
both the operands are ints. So only if one of the types is a flot or
you explicitly cast your expression to be a double, then the value
will be a fraction. otherwise you will the quotient.
Mensanator
> This seems sort of odd to me:
>
> >>> a = 1
> >>> a += 1.202
> >>> a
>
> 2.202
>
> Indicates that 'a' was an int that was implicitly casted to a float.
> But:
>
> >>> a = 1
> >>> b = 3
> >>> a / b
>
> 0
>
> This does not implicitly do the casting, it treats 'a' and 'b' as
> integers, and the result as well.
Not in Python 3.1:
Python 3.1 (r31:73574, Jun 26 2009, 20:21:35) [MSC v.1500 32 bit
(Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> a = 1
>>> b = 3
>>> a/b
0.3333333333333333
> Changing 'b' to 3.0 will yield a
> float as a result (0.33333333333333331)
>
> Is there some way to explain the consistency here?
Yes, use Python 3.1.
> Does python
> implicitly change the casting when you add variables of a different
> numeric type?
Sometimes. Floats and ints are compatible. But this doesn't work:
>>> '3' + 1
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
'3' + 1
TypeError: Can't convert 'int' object to str implicitly
Chris Rebert
> This seems sort of odd to me:
>
>>>> a = 1
>>>> a += 1.202
>>>> a
> 2.202
>
> Indicates that 'a' was an int that was implicitly casted to a float.
Remember Python is dynamically typed. Values have types, but variables
don't (I could do a = "foo" at the end of your code and Python won't
complain).
But yes, internally, Python converted the int to a float before doing
the addition.
> But:
>
>>>> a = 1
>>>> b = 3
>>>> a / b
> 0
>
> This does not implicitly do the casting, it treats 'a' and 'b' as
> integers, and the result as well. Changing 'b' to 3.0 will yield a
> float as a result (0.33333333333333331)
This has been fixed in Python v3.x
You can request the new behavior in earlier versions using a magic import:
>>> from __future__ import division
>>> a = 1
>>> b = 3
>>> a / b
0.33333333333333331
Cheers,
Chris
--
http://blog.rebertia.com
MRAB
int + int gives int
float + float gives float
int + float gives float
float + int gives float
Similarly for '-' and '*'.
Division causes a problem because what is int / int? Should it behave
like the others and give an int? That would mean that 1 / 2 == 0, which
can be confusing for newbies.
In older languages (Fortran, for example) integer divided by integer
using the normal division operator '/' was integer, and this is what C
and those influenced by it do.
Newer languages return a float instead of an integer because it causes
less confusion (1 / 2 == 0.5 is less confusing than 1 / 2 == 0), but
also provide a special integer division operator.
In Python v2.x '/' does integer division, but from Python v3.x '/' does
float division and uses '//' for integer division. ('//' is also
available in later versions of 2.x.)
Steven D'Aprano
> But:
>
>>>> a = 1
>>>> b = 3
>>>> a / b
> 0
>
> This does not implicitly do the casting, it treats 'a' and 'b' as
> integers, and the result as well. Changing 'b' to 3.0 will yield a float
> as a result (0.33333333333333331)
This is design flaw in older versions of Python, that the / operator for
ints performs integer division rather than floating point division.
In Python 2.5 and beyond, you can fix this by calling
from __future__ import division
at the top of your module, and then / will perform float division with
int arguments, and you can use // for integer division.
Or upgrade to Python 3.1, where this is the default behaviour and there
is no need for the from __future__ call.
--
Steven
Steven D'Aprano
> But yes, internally, Python converted the int to a float before doing
> the addition.
[pedantic]
To be precise, Python created a *new* float from the int, leaving the
original int alone. Because ints and floats are objects, if Python
actually converted the int to a float, this would happen:
>>> n = 1
>>> m = n
>>> x = 2.0 + n
>>> print x
3.0
>>> print n
1.0
>>> "abc"[m]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: string indices must be integers
and the world would rapidly be destroyed. Fortunately this does not
happen.
[/pedantic]
--
Steven
Albert van der Horst
You skip a step here that the OP may have missed.
a = 1
a += 1.222
This invokes the calculation
1 + 1.222
which is int + float.
Groetjes Albert
--
--
Albert van der Horst, UTRECHT,THE NETHERLANDS
Economic growth -- being exponential -- ultimately falters.
albert@spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst