In Python, dealing with different numeric types is very common. You may need to convert an integer to a floating point number, a float to a string representation, or vice versa. Converting between numeric types in Python is straightforward, but it helps to understand the differences between integers, floats, complex numbers, and other numeric objects in Python to avoid errors and unintended results.
This comprehensive guide will provide a deep dive into converting between the main numeric types in Python. We will cover:
Table of Contents
Open Table of Contents
Overview of Major Numeric Types in Python
Python contains many numeric data types to represent numbers. The main types include:

Integers (
int
): Whole numbers like 1, 15, 456. Useful for counting and sequences. Stored precisely. 
Floatingpoint numbers (
float
): Decimal numbers like 1.25, 3.492, 4.0. Useful for measurements and fractions. Imprecise  stored as approximation. 
Complex numbers (
complex
): Numbers with real and imaginary parts like 1 + 2j. Used in many scientific domains. 
Booleans (
bool
): Logical or truth values True and False. Often treated as 1 and 0 in numeric contexts. 
Fractions (
fractions.Fraction
): Rational numbers that keep numerator and denominator forms. Avoid loss of precision from floats. 
Decimals (
decimal.Decimal
): Floatingpoint values that can control precision. Avoid inaccuracies of regular floats.
These types serve different purposes and have tradeoffs in terms of precision, range, memory usage and numeric behavior. Understanding those tradeoffs helps inform when and how to convert between types in Python.
Explicit vs Implicit Type Conversion
Python allows flexible intermixing of numeric types thanks to implicit and explicit conversion between types.
Implicit Type Conversion
Python will automatically coerce numeric types as needed in mixed type expressions. This is implicit type conversion:
>>> 5 + 4.3 # int + float > float
9.3
>>> 3 * True # int * bool > int
3
>>> 4j + 2 # complex + int > complex
(4+2j)
Python tries to convert types to avoid errors and allow reasonable mixedtype math to work. Some key rules:
int
+float
→float
int
+complex
→complex
float
+complex
→complex
 Number +
bool
→ number (True
= 1,False
= 0)
Danger: Implicit conversion can lead to strange bugs! Be careful mixing types.
Explicit Type Conversion
You can control conversion more explicitly by casting values using type constructors:
>>> int(5.4)
5
>>> float(5)
5.0
>>> str(5.1)
'5.1'
Casting with constructors makes the conversion explicit and visible.
int()
: Construct integer from number or stringfloat()
: Construct float from integer, float or stringstr()
: Construct string representation from any object
Explicit casting also allows control over things like rounding behavior and formatting.
Converting Between int, float, and complex
The int
, float
and complex
numeric types have particular conversion behaviors in Python due to their math properties.
int to float
Converting an integer to floating point is intuitive  simply change to a decimal form:
>>> float(5)
5.0
>>> float(10)
10.0
All math on a float
retains decimal precision, even for integers:
>>> 5 / 2
2.5
>>> float(5) / 2
2.5
float to int
Casting a float to integer rounds down to the nearest whole number, truncating the decimal:
>>> int(5.7)
5
>>> int(4.2)
4
>>> int(3.8)
3
This can cause loss of data, so be careful!
Complex Conversion
Complex numbers contain real and imaginary float parts. Convert real numbers to complex with 0j imaginary part:
>>> complex(5)
(5+0j)
>>> complex(4.2)
(4.2+0j)
Create a complex number by passing real and imaginary parts:
>>> complex(2.1, 3.5)
(2.13.5j)
Access the parts with .real
and .imag
attributes:
>>> c = complex(2.5, 3)
>>> c.real
2.5
>>> c.imag
3.0
Changing Numeric Precision and Range
Different numeric types have tradeoffs in precision vs range. You can use type conversion to change precision or range as needed.
float to int: Losing Precision
Floats have decimal fraction precision, but may lose precision when cast to integers:
>>> float(1.99999999)
1.99999999
>>> int(1.99999999)
1 # Precision lost!
Only use float → int when you don’t need the fractional precision.
int to float: Gaining Precision
Integers have unlimited range, but converting to float provides fractional precision:
>>> 2000000000000
2000000000000
>>> float(2000000000000)
2e+12 # Float has precision
Use float for scientific domains even with very large numbers.
float to Fraction: Precise Rationals
The fractions.Fraction
type keeps numerator and denominator instead of a floating point value. This avoids cumulative rounding errors:
>>> from fractions import Fraction
>>> Fraction(1.1)
Fraction(2476979795053773, 2251799813685248) # Precise value
Fractions are useful when float rounding causes issues like equality testing:
>>> .1 + .1 + .1 == .3 # False due to float rounding!
False
>>> Fraction(1, 10) + Fraction(1, 10) + Fraction(1, 10) == Fraction(3, 10)
True
float to Decimal: Controlling Precision
Python’s decimal.Decimal
type allows control of rounding and number of decimal places:
>>> from decimal import Decimal
>>> Decimal(.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal(.1).quantize(Decimal('0.000')) # Round to 3 decimals
Decimal('0.100')
Decimals are great for things like financial applications.
Best Practices for Numeric Conversion
Here are some tips for safely and effectively converting between numeric types in Python:
 Avoid unnecessary conversions  keep data in most precise type possible.
 Use
float
for scientific computing for precision.  Use
int
only for counting or sequences.  Don’t convert
float
→int
unless you understand precision loss.  Use
fractions
for rational numerators/denominators to avoidfloat
issues.  Consider
decimal
for control over rounding and precision.  Use explicit conversion with constructors rather than implicit coercion when possible.
 Add explicit conversion to clarify and document intended numeric casting.
 Annotate types on function inputs/outputs if relying on specific numeric type.
 Always check for information loss or rounding issues when converting numericallysensitive data.
Following best practices helps avoid weird errors and numeric issues down the line!
Real World Example  Data Science Calculations
As a data science example, let’s look at calculating summary statistics on a dataset. We’ll see where numeric type conversions are required and how to implement them properly.
First, we need to read in the raw data. The numbers are stored as strings by default:
import pandas as pd
data = pd.read_csv('dataset.csv')
print(data['value'].dtype) # 'object' (string)
To find quantitative insights, we need to convert the strings to numbers. Let’s convert to floats:
values = data['value'].astype(float) # Convert column to floats
Now we can calculate statistics like the mean, standard deviation, and variance:
mean = values.mean() # Get float mean
stdev = values.std() # Get float standard deviation
variance = stdev ** 2 # Get float variance
But if we try to print these floats, we run into rounding issues:
print(mean)
# 2.3472971124764283  Ugly rounding!
To nicely print the results, we’ll convert the floats to rounded decimals:
from decimal import Decimal
print(Decimal(mean).quantize(Decimal('0.01')))
# 2.35  Rounded to 2 decimals
The correct numeric types allow both precision for math and nice presentation of results!
Conclusion
This guide covered the key details of converting between numeric data types in Python:
 The major numeric types are
int
,float
,complex
along withfractions
,decimals
and more.  Implicit coercion happens in mixed types, but explicit casting is better.
 Constructors like
int()
andfloat()
allow numeric conversion.  Converting between types can change precision, rounding, and range.
 Use best practices to avoid loss of precision or unintended results.
Understanding numeric conversion in Python helps you effectively work with the myriad of available numeric types for your programming needs. Both simple and advanced mathematical applications require knowing how to properly convert integers, floats, decimals, and more. Master these concepts to become proficient in handling numbers in Python!