Type Casting & Conversions

Implicit vs. Explicit Conversion

Python handles conversions in two ways. Understanding the difference is key to writing clean code.

1. Implicit Conversion (Coercion)

Python performs this automatically when it is 100% safe and data loss is impossible. The most common example is mixing integers and floats.

# Safe Automatic Upgrade
x_int = 10      # Integer
y_float = 2.5   # Float

result = x_int + y_float
print(result)          # 12.5
print(type(result))    # <class 'float'>

# Python "promotes" the integer 10 to 10.0 to match the float.
# No precision is lost, so Python allows it.

2. Explicit Conversion (Casting)

Python never implicitly converts between types if there's ambiguity or risk of validation error. This is why "5" + 5 throws an error. Do you want "55" (String) or 10 (Integer)? Python refuses to guess. You must use a constructor function to tell it exactly what to do.

The Big Three Constructors

Three constructor functions handle 90% of everyday data transformation needs.

1. The Integer Constructor: int()

int() is strict. It truncates floats (rounding down towards zero) and demands pure whole-number strings. However, it is smarter than it looks.

Parsing Bases (Binary/Hex)

Did you know int() can act as a base converter? By default it assumes Base-10, but you can decode Binary, Octal, or Hexadecimal strings.

# Standard Base-10
print(int("100"))      # 100

# Truncation behavior
print(int(3.99))       # 3 (Floors towards zero)

# Underscores in strings (Python 3.6+)
print(int("1_000_000")) # 1000000 (Readable!)

# Base Conversion
print(int("101", 2))   # 5  (Binary '101')
print(int("FF", 16))   # 255 (Hex 'FF')
print(int("77", 8))    # 63 (Octal '77')

# ❌ The Common Trap
# print(int("3.14"))   # ValueError! It doesn't know how to handle the dot.

# ✅ The Fix
print(int(float("3.14"))) # 3 (String -> Float -> Int)

2. The Float Constructor: float()

float() is more accommodating. It can handle scientific notation and special values like Infinity.

print(float(5))       # 5.0
print(float("3.14"))  # 3.14
print(float("1e3"))   # 1000.0 (scientific notation for 10^3)

# Special Mathematical Values
infinity = float("inf")
nan = float("nan")    # Not a Number
print(infinity > 10**100) # True

3. The String Constructor: str() vs repr()

str() is the friendliest function. It can turn any object into a string representation, usually for printing or logging. However, Python has a secret second way to convert to string: repr().

• str(obj): Readable, user-friendly text. (e.g., used by print()).
• repr(obj): Unambiguous, developer-focused text. Often code that could recreate the object.

import datetime

now = datetime.datetime.now()

# User Friendly
print(str(now))   # 2023-10-25 14:30:00.123456

# Developer Friendly (Debugging)
print(repr(now))  # datetime.datetime(2023, 10, 25, 14, 30, 0, 123456)

s = "Hello
World"
print(str(s))     
# Hello
# World

print(repr(s))    # 'Hello\nWorld' (Shows the escape character)

Deep Dive: Bytes and Encodings

In the modern web, the most critical casting you will do is not between numbers, but betweenText (Unicode) and Data (Bytes).

In Python 3, str is abstract Unicode text. You can't send it over a network or save it to a file directly. You must encode it into bytes. Conversely, effectively reading a file means receiving bytes and decoding them into text.

# 1. Text (Abstract Idea)
text = "Café ☕"
print(type(text)) # <class 'str'>

# ❌ You cannot save 'text' to a binary file directly.
# You must CAST it to bytes via encoding.

# 2. Encoding (Serialization)
# We cast string -&gt; bytes using UTF-8 standard
data = text.encode('utf-8')
print(type(data)) # <class 'bytes'>
print(data)       # b'Café ☕' (The raw numbers)

# 3. Decoding (Deserialization)
# We cast bytes -&gt; string
decoded_text = data.decode('utf-8')
print(decoded_text) # "Café ☕"

The Boolean Constructor: Truthiness

In Python, everything can be cast to a Boolean. This is extremely useful for writing concise control flow logic.

The rule is simple: Empty/Zero/None is False. Everything else is True.

# Falsy Values (evaluate to False)
print(bool(0))          # False (Zero)
print(bool(0.0))        # False (Zero float)
print(bool(""))         # False (Empty string)
print(bool([]))         # False (Empty list)
print(bool({}))         # False (Empty dict)
print(bool(None))       # False (The void)

# Truthy Values (evaluate to True)
print(bool(1))          # True
print(bool(-5))         # True (Any non-zero number)
print(bool("False"))    # True (Non-empty string!)
print(bool([0]))        # True (Non-empty container)

Custom Casting: The Dunder Methods

Want your own classes to support casting? Python's object-oriented model allows you to define how your objects behave when passed to int(), str(), or bool(). This is done using "Dunder" (Double Underscore) methods.

class BitcoinWallet:
    def __init__(self, balance):
        self.balance = balance

    def __int__(self):
        """Called when int(wallet) is run"""
        return int(self.balance)

    def __str__(self):
        """Called when str(wallet) or print(wallet) is run"""
        return f"{self.balance} BTC"

    def __bool__(self):
        """Called when bool(wallet) or if wallet: is run"""
        return self.balance > 0

my_wallet = BitcoinWallet(0.5)

print(int(my_wallet))   # 0 (Casts to int)
print(str(my_wallet))   # "0.5 BTC" (Casts to string)

if my_wallet:
    print("You have money!") # Uses __bool__

Collection Molding: Reshaping Data

Casting isn't just for scalars. You can cast between collection types to gain their superpowers.

1. Removes Duplicates (List -> Set -> List)

The fastest way to deduplicate a list is to cast it to a Set (which forbids duplicates) and back.

raw_data = ["apple", "banana", "apple", "cherry", "banana"]

# transform
unique_data = list(set(raw_data))

print(unique_data) 
# ['banana', 'cherry', 'apple'] (Order is lost!)

2. Freezing Data (List -> Tuple)

Need to use a list as a dictionary key? You can't, because lists are mutable. Cast it to a tuple first!

coords = [10, 20]

# location_map = {coords: "Home"} # ❌ TypeError: unhashable type: 'list'

frozen_coords = tuple(coords)
location_map = {frozen_coords: "Home"} # ✅ Works!

3. Zipping to Dictionary (List of Tuples -> Dict)

If you have paired data, dict() can snap it together intelligently.

pairs = [
    ("name", "Alice"),
    ("age", 30),
    ("role", "Engineer")
]

user_profile = dict(pairs)
print(user_profile["name"]) # "Alice"