Type Conversion

Beginner ~30 min read

Type conversion (or type casting) is the process of converting a value from one data type to another. Python provides built-in functions like int(), float(), str(), and bool() for this purpose.

Basic Type Conversions

Python provides several built-in functions to convert between basic types:

Function	Converts To	Example
`int()`	Integer	`int("42")` → 42
`float()`	Float	`float("3.14")` → 3.14
`str()`	String	`str(42)` → "42"
`bool()`	Boolean	`bool(1)` → True
`type()`	N/A	Returns the type of a value

# Type Conversion Basics in Python
# Converting values from one type to another

print("=" * 50)
print("1. Checking Types with type()")
print("=" * 50)

x = 42
y = 3.14
z = "hello"
b = True

print(f"type({x}) = {type(x)}")
print(f"type({y}) = {type(y)}")
print(f"type('{z}') = {type(z)}")
print(f"type({b}) = {type(b)}")

print("\n" + "=" * 50)
print("2. Converting to Integer: int()")
print("=" * 50)

# From float (truncates decimal)
print(f"int(3.7) = {int(3.7)}")      # 3 (not rounded!)
print(f"int(3.2) = {int(3.2)}")      # 3
print(f"int(-3.7) = {int(-3.7)}")    # -3 (towards zero)

# From string
print(f"int('42') = {int('42')}")
print(f"int('-100') = {int('-100')}")

# From boolean
print(f"int(True) = {int(True)}")    # 1
print(f"int(False) = {int(False)}")  # 0

# Different bases
print(f"int('1010', 2) = {int('1010', 2)}")  # 10 (binary)
print(f"int('FF', 16) = {int('FF', 16)}")    # 255 (hex)

print("\n" + "=" * 50)
print("3. Converting to Float: float()")
print("=" * 50)

# From integer
print(f"float(42) = {float(42)}")

# From string
print(f"float('3.14') = {float('3.14')}")
print(f"float('-2.5') = {float('-2.5')}")
print(f"float('1e-3') = {float('1e-3')}")  # Scientific notation

# Special values
print(f"float('inf') = {float('inf')}")
print(f"float('-inf') = {float('-inf')}")

print("\n" + "=" * 50)
print("4. Converting to String: str()")
print("=" * 50)

# From any type
print(f"str(42) = '{str(42)}'")
print(f"str(3.14) = '{str(3.14)}'")
print(f"str(True) = '{str(True)}'")
print(f"str(None) = '{str(None)}'")
print(f"str([1,2,3]) = '{str([1,2,3])}'")

print("\n" + "=" * 50)
print("5. Converting to Boolean: bool()")
print("=" * 50)

# From numbers (0 is False, others True)
print(f"bool(0) = {bool(0)}")
print(f"bool(1) = {bool(1)}")
print(f"bool(-5) = {bool(-5)}")
print(f"bool(0.0) = {bool(0.0)}")

# From strings (empty is False)
print(f"bool('') = {bool('')}")
print(f"bool('hello') = {bool('hello')}")
print(f"bool('False') = {bool('False')}")  # True! Non-empty string

# From collections (empty is False)
print(f"bool([]) = {bool([])}")
print(f"bool([1,2]) = {bool([1,2])}")

Output

Click Run to execute your code

Remember: int() truncates toward zero - it doesn't round! int(3.9) gives 3, not 4. Use round() if you need rounding.

Numeric Type Conversions

Python has three numeric types: int, float, and complex. Understanding how they convert between each other is crucial.

# Numeric Type Conversions in Python
# Converting between int, float, and complex

print("=" * 50)
print("1. Integer to Float")
print("=" * 50)

x = 42
print(f"x = {x} (type: {type(x).__name__})")
x_float = float(x)
print(f"float(x) = {x_float} (type: {type(x_float).__name__})")

# Automatic conversion in division
result = 10 / 4
print(f"\n10 / 4 = {result} (type: {type(result).__name__})")

# Integer division stays integer
result = 10 // 4
print(f"10 // 4 = {result} (type: {type(result).__name__})")

print("\n" + "=" * 50)
print("2. Float to Integer (Truncation)")
print("=" * 50)

y = 3.7
print(f"y = {y}")
print(f"int(y) = {int(y)}")  # 3, NOT 4!

# Different rounding methods
import math
print(f"\nDifferent ways to round {y}:")
print(f"  int():       {int(y)}")           # 3 (truncate)
print(f"  round():     {round(y)}")         # 4 (round to nearest)
print(f"  math.floor(): {math.floor(y)}")   # 3 (round down)
print(f"  math.ceil():  {math.ceil(y)}")    # 4 (round up)
print(f"  math.trunc(): {math.trunc(y)}")   # 3 (truncate)

# Negative numbers
neg = -3.7
print(f"\nFor negative {neg}:")
print(f"  int():       {int(neg)}")          # -3 (towards zero)
print(f"  math.floor(): {math.floor(neg)}")  # -4 (towards -inf)
print(f"  math.ceil():  {math.ceil(neg)}")   # -3 (towards +inf)

print("\n" + "=" * 50)
print("3. Complex Numbers")
print("=" * 50)

# Creating complex numbers
c1 = complex(3, 4)   # 3 + 4j
c2 = 3 + 4j          # Same thing

print(f"complex(3, 4) = {c1}")
print(f"Real part: {c1.real}")
print(f"Imaginary part: {c1.imag}")

# From other types
print(f"\ncomplex(5) = {complex(5)}")
print(f"complex(2.5) = {complex(2.5)}")

# Cannot convert complex to int/float directly!
# int(c1) would raise TypeError

print("\n" + "=" * 50)
print("4. Automatic Type Coercion")
print("=" * 50)

# Python automatically converts to more general type
print("int + float = float:")
result = 5 + 2.5
print(f"  5 + 2.5 = {result} ({type(result).__name__})")

print("\nint + complex = complex:")
result = 5 + 3j
print(f"  5 + 3j = {result} ({type(result).__name__})")

print("\nfloat + complex = complex:")
result = 2.5 + 3j
print(f"  2.5 + 3j = {result} ({type(result).__name__})")

# Hierarchy: int < float < complex
print("\nType hierarchy: int → float → complex")

Output

Click Run to execute your code

Type Hierarchy: When mixing types in operations, Python converts to the "higher" type: int → float → complex. This is called implicit type coercion.

String Conversions

Converting to and from strings is one of the most common operations, especially when dealing with user input or file data.

# String Type Conversions in Python
# Converting to and from strings

print("=" * 50)
print("1. Converting Numbers to Strings")
print("=" * 50)

num = 42
pi = 3.14159

# Using str()
print(f"str(42) = '{str(num)}'")
print(f"str(3.14159) = '{str(pi)}'")

# Formatting numbers as strings
print(f"\nFormatting options:")
print(f"  f'{{pi:.2f}}' = '{pi:.2f}'")      # 2 decimal places
print(f"  f'{{num:05d}}' = '{num:05d}'")    # Zero-padded
print(f"  f'{{num:,}}' = '{1000000:,}'")    # Thousands separator

# repr() vs str()
print(f"\nstr() vs repr():")
s = "hello"
print(f"  str('{s}'): {str(s)}")      # hello
print(f"  repr('{s}'): {repr(s)}")    # 'hello' (with quotes)

print("\n" + "=" * 50)
print("2. Converting Strings to Numbers")
print("=" * 50)

# String to integer
print(f"int('123') = {int('123')}")
print(f"int('  42  ') = {int('  42  ')}")  # Whitespace OK

# String to float
print(f"float('3.14') = {float('3.14')}")
print(f"float('2.5e-3') = {float('2.5e-3')}")

# Handling invalid input
print("\nWhat happens with invalid input:")
try:
    result = int("hello")
except ValueError as e:
    print(f"  int('hello') raises: ValueError")

try:
    result = int("3.14")  # Can't convert float string directly to int!
except ValueError as e:
    print(f"  int('3.14') raises: ValueError")

# Correct way: convert to float first, then int
print(f"  int(float('3.14')) = {int(float('3.14'))}")

print("\n" + "=" * 50)
print("3. Working with Characters")
print("=" * 50)

# ord() - character to ASCII/Unicode number
print("ord() - character to number:")
print(f"  ord('A') = {ord('A')}")   # 65
print(f"  ord('a') = {ord('a')}")   # 97
print(f"  ord('0') = {ord('0')}")   # 48

# chr() - number to character
print("\nchr() - number to character:")
print(f"  chr(65) = '{chr(65)}'")   # A
print(f"  chr(97) = '{chr(97)}'")   # a
print(f"  chr(128512) = '{chr(128512)}'")  # 😀

print("\n" + "=" * 50)
print("4. Number Formatting Tricks")
print("=" * 50)

num = 255

# Different bases
print(f"Converting {num} to different bases:")
print(f"  bin({num}) = {bin(num)}")    # 0b11111111
print(f"  oct({num}) = {oct(num)}")    # 0o377
print(f"  hex({num}) = {hex(num)}")    # 0xff

# Remove prefix
print(f"\nWithout prefix:")
print(f"  bin({num})[2:] = {bin(num)[2:]}")
print(f"  format({num}, 'b') = {format(num, 'b')}")
print(f"  f'{{{num}:08b}}' = {num:08b}")  # 8 digits, zero-padded

print("\n" + "=" * 50)
print("5. Practical Examples")
print("=" * 50)

# User input is always string
user_input = "25"
age = int(user_input)
print(f"Processing age from input '{user_input}': {age + 10} in 10 years")

# Building URLs or file paths
base_url = "https://api.example.com/users/"
user_id = 42
url = base_url + str(user_id)
print(f"URL: {url}")

# Better: use f-strings
url = f"{base_url}{user_id}"
print(f"Better URL: {url}")

Output

Click Run to execute your code

Common Pitfall: You can't convert a float string directly to int! int("3.14") raises ValueError. Use int(float("3.14")) instead.

Collection Type Conversions

Python's collection types (list, tuple, set, dict) can be converted between each other.

Function	Creates	Key Behavior
`list()`	List	Mutable, ordered sequence
`tuple()`	Tuple	Immutable, ordered sequence
`set()`	Set	Unique values only, unordered
`dict()`	Dictionary	From key-value pairs

# Collection Type Conversions in Python
# Converting between list, tuple, set, dict, and string

print("=" * 50)
print("1. Converting to List: list()")
print("=" * 50)

# From string (each character becomes an element)
s = "hello"
print(f"list('{s}') = {list(s)}")

# From tuple
t = (1, 2, 3)
print(f"list({t}) = {list(t)}")

# From set (order not guaranteed)
st = {3, 1, 2}
print(f"list({st}) = {list(st)}")

# From dictionary (gets keys)
d = {"a": 1, "b": 2}
print(f"list({d}) = {list(d)}")
print(f"list({d}.values()) = {list(d.values())}")
print(f"list({d}.items()) = {list(d.items())}")

# From range
r = range(5)
print(f"list(range(5)) = {list(r)}")

print("\n" + "=" * 50)
print("2. Converting to Tuple: tuple()")
print("=" * 50)

# From list
lst = [1, 2, 3]
print(f"tuple({lst}) = {tuple(lst)}")

# From string
print(f"tuple('abc') = {tuple('abc')}")

# Tuples are immutable - useful for dict keys
point = tuple([10, 20])
print(f"Immutable point: {point}")

print("\n" + "=" * 50)
print("3. Converting to Set: set()")
print("=" * 50)

# From list (removes duplicates!)
lst = [1, 2, 2, 3, 3, 3]
print(f"set({lst}) = {set(lst)}")

# From string
print(f"set('hello') = {set('hello')}")  # Unique chars only

# Useful for removing duplicates
numbers = [1, 2, 2, 3, 1, 4, 3]
unique = list(set(numbers))
print(f"\nRemoving duplicates:")
print(f"  Original: {numbers}")
print(f"  Unique:   {unique}")

# Note: order may not be preserved!
# To preserve order, use dict.fromkeys() in Python 3.7+
unique_ordered = list(dict.fromkeys(numbers))
print(f"  Ordered:  {unique_ordered}")

print("\n" + "=" * 50)
print("4. Converting to Dictionary: dict()")
print("=" * 50)

# From list of tuples
pairs = [("a", 1), ("b", 2), ("c", 3)]
print(f"dict({pairs})")
print(f"  = {dict(pairs)}")

# From two lists using zip
keys = ["name", "age", "city"]
values = ["Alice", 25, "NYC"]
print(f"\ndict(zip({keys}, {values}))")
print(f"  = {dict(zip(keys, values))}")

# From dict comprehension (alternative)
squares = {x: x**2 for x in range(1, 6)}
print(f"\nDict comprehension: {squares}")

print("\n" + "=" * 50)
print("5. Converting String to/from List")
print("=" * 50)

# String to list of characters
text = "Python"
chars = list(text)
print(f"list('{text}') = {chars}")

# List of characters back to string
text_back = ''.join(chars)
print(f"''.join({chars}) = '{text_back}'")

# String to list of words (split)
sentence = "Hello World Python"
words = sentence.split()
print(f"'{sentence}'.split() = {words}")

# List of words back to string (join)
sentence_back = ' '.join(words)
print(f"' '.join({words}) = '{sentence_back}'")

print("\n" + "=" * 50)
print("6. Practical Examples")
print("=" * 50)

# Counting unique items
items = ["apple", "banana", "apple", "cherry", "banana"]
unique_count = len(set(items))
print(f"Unique items in {items}: {unique_count}")

# Inverting a dictionary
original = {"a": 1, "b": 2, "c": 3}
inverted = dict(zip(original.values(), original.keys()))
print(f"\nOriginal: {original}")
print(f"Inverted: {inverted}")

# Converting query string to dict
query = "name=Alice&age=25&city=NYC"
pairs = [p.split('=') for p in query.split('&')]
params = dict(pairs)
print(f"\nQuery string: {query}")
print(f"As dict: {params}")

Output

Click Run to execute your code

Quick Tip: Use set() to easily remove duplicates from a list: unique = list(set(my_list)). Note: order may not be preserved!

Common Mistakes

1. Converting non-numeric strings to int/float

# This raises ValueError!
int("hello")    # ValueError
float("abc")    # ValueError

# Always validate before converting
user_input = "42"
if user_input.isdigit():
    number = int(user_input)

2. Expecting int() to round

# int() truncates, doesn't round!
int(2.9)    # 2, not 3
int(-2.9)   # -2, not -3

# Use round() for rounding
round(2.9)  # 3
round(2.5)  # 2 (banker's rounding!)
round(3.5)  # 4

3. Thinking bool("False") is False

# Any non-empty string is truthy!
bool("False")  # True! (non-empty string)
bool("")       # False (empty string)

# For string "False" to False
text = "False"
result = text.lower() == "true"  # False

4. Losing precision with float-to-string

# str() may not show all decimal places
pi = 3.141592653589793
print(str(pi))   # '3.141592653589793'

# Use formatting for control
print(f"{pi:.2f}")   # '3.14'
print(f"{pi:.10f}")  # '3.1415926536'

Exercise: Type Conversion Practice

Task: Practice converting between Python's different data types.

Skills tested:

Basic type conversions (int, float, str, bool)
Collection conversions (list, tuple, set, dict)
Character conversions (ord, chr)
Chained conversions

# Exercise: Type Conversion Practice
# Convert between different Python types

# Given data:
string_number = "123"
float_number = 45.67
mixed_list = [1, 2, 2, 3, 3, 3, 4]
text = "Python"
pairs = [("name", "Alice"), ("age", "25")]

# TODO: Complete the following tasks:

# 1. Convert string_number to an integer and add 10
# Expected: 133

# 2. Convert float_number to int (truncate)
# Expected: 45

# 3. Convert float_number to string with 1 decimal place
# Expected: '45.7'

# 4. Remove duplicates from mixed_list (convert to set, then back to list)
# Expected: [1, 2, 3, 4] (order may vary)

# 5. Convert text to a list of characters
# Expected: ['P', 'y', 't', 'h', 'o', 'n']

# 6. Convert pairs to a dictionary
# Expected: {'name': 'Alice', 'age': '25'}

# 7. Get the ASCII value of the first character of text
# Expected: 80 (the ASCII value of 'P')

# 8. Convert the boolean result of (10 > 5) to an integer
# Expected: 1

# 9. Create a string from the list [72, 105, 33] using chr()
# Expected: 'Hi!' (72='H', 105='i', 33='!')

# 10. Convert "42" to int, add 8, then convert back to string
# Expected: '50'

Output

Click Run to execute your code

Show Solution

string_number = "123"
float_number = 45.67
mixed_list = [1, 2, 2, 3, 3, 3, 4]
text = "Python"
pairs = [("name", "Alice"), ("age", "25")]

# 1. String to int, add 10
print(int(string_number) + 10)  # 133

# 2. Float to int (truncate)
print(int(float_number))  # 45

# 3. Float to string with 1 decimal
print(f"{float_number:.1f}")  # '45.7'

# 4. Remove duplicates
print(list(set(mixed_list)))  # [1, 2, 3, 4]

# 5. String to list of chars
print(list(text))  # ['P', 'y', 't', 'h', 'o', 'n']

# 6. Pairs to dictionary
print(dict(pairs))  # {'name': 'Alice', 'age': '25'}

# 7. ASCII value of first char
print(ord(text[0]))  # 80

# 8. Boolean to int
print(int(10 > 5))  # 1

# 9. List of ASCII to string
print(''.join(chr(n) for n in [72, 105, 33]))  # 'Hi!'

# 10. String → int → add → string
print(str(int("42") + 8))  # '50'

Summary

int(): Convert to integer (truncates floats)
float(): Convert to floating-point number
str(): Convert to string representation
bool(): Convert to boolean (falsy values → False)
list(), tuple(), set(): Convert sequences
dict(): Create dictionary from key-value pairs
ord(), chr(): Character ↔ ASCII/Unicode conversion
Implicit coercion: Python auto-converts in operations (int → float → complex)

What's Next?

In the next lesson, we'll explore None - Python's special null value that represents the absence of a value.

Previous Booleans

Next None Type

Basic Type Conversions

Numeric Type Conversions

String Conversions

Collection Type Conversions

Common Mistakes

1. Converting non-numeric strings to int/float

2. Expecting int() to round

3. Thinking bool("False") is False

4. Losing precision with float-to-string

Exercise: Type Conversion Practice

Summary

What's Next?

Enjoying these tutorials?