How Does Type Conversion Work in Python?

Python has no cast syntax like the parentheses you would use in C. A conversion is done by calling the type you want as if it were a function, and that call either gives you a new object or raises an error. That makes conversion ordinary code that you can read and inspect, instead of a special operator.

print(int('42'))                 # 42
print(float('3.5'))             # 3.5
print(str(42) + '!')            # 42!
print(bool(0), bool(''))        # False False
print(bool([0]))                # True, the list is not empty

try:
    int('abc')
except ValueError as error:
    print('ValueError:', error)

try:
    int('3.5')
except ValueError as error:
    print('ValueError:', error)

print(int(3.9), int(-3.9))      # 3 and -3, it cuts off the decimal
print(round(3.9), round(-3.9))  # 4 and -4, it goes to the nearest even

The two failures are the interesting part of this example. int('abc') raises a ValueError with the message "invalid literal for int() with base 10: 'abc'". int('3.5') also raises a ValueError, because the int constructor will not accept a decimal point. If you really want that path, then you have to write int(float('3.5')).

The last two lines show a genuine difference in behaviour. int() cuts the decimal off towards zero, so int(-3.9) is -3. round() gives you the nearest whole number and uses banker's rounding for exact halves, so round(-3.9) is -4 and round(2.5) is 2 and not 3.

One more thing to know is that int() also accepts a base, so int('ff', 16) is 255 and int('0b1010', 2) is 10.

They answer two different questions. type() asks what an object is, and it gives you back the class itself, so type(42) is int and type('text') is str. Nothing is converted and nothing new is created. The conversion functions answer a different question, because they build a brand new object of the target type out of the value that you give them, and they leave the original object alone.

That difference shows up straight away in what happens when a conversion cannot work. type() never fails, because every object has a type. int('abc') raises a ValueError, because there is no whole number that corresponds to the text "abc".

There is a subtle point about the return values as well. Calling int() on something that is already an int gives you back the very same object rather than a new one, because there is no work to be done. The same is true of str() on a str. So conversions are cheap no-ops for values that are already the right type, but they are not identity functions in general, because int(3.9) is a different object from 3.9.

Two more details are worth knowing. The int constructor takes an optional base, so int('ff', 16) is 255. That is parsing rather than casting, and it is how you read a number that was written in another radix. And because a conversion is just a function call, it composes nicely. int(float(user_input)) is a perfectly normal thing to write, even though the first conversion may raise an error before the second one ever runs.