Python Type Casting -- Find the Bug¶

def greet(name, age):
    """Create a greeting message."""
    return f"Hello, {name}! You are {age} years old."  # FIX: use f-string

# Alternative fix:
# return "Hello, " + name + "! You are " + str(age) + " years old."

print(greet("Alice", 30))  # Hello, Alice! You are 30 years old.

age = "25"
if int(age) >= 18:  # FIX: convert to int before comparison
    print("Adult")
else:
    print("Minor")

def parse_price(price_str):
    """Parse a price string to integer cents."""
    return int(float(price_str) * 100)  # FIX: convert to float first

# Alternative with better precision:
def parse_price_precise(price_str):
    from decimal import Decimal
    return int(Decimal(price_str) * 100)

print(parse_price("19.99"))         # 1999
print(parse_price_precise("19.99")) # 1999

def load_config(settings):
    """Load settings and cast boolean values."""
    debug = settings.get("debug", "false").lower() == "true"      # FIX
    verbose = settings.get("verbose", "false").lower() == "true"   # FIX
    return {"debug": debug, "verbose": verbose}

config = load_config({"debug": "false", "verbose": "true"})
print(config)  # {'debug': False, 'verbose': True}

def calculate_average(scores_str):
    """Calculate average from a comma-separated string of scores."""
    scores = scores_str.split(",")
    total = sum(float(s.strip()) for s in scores)  # FIX: use float() instead of int()
    average = total / len(scores)
    return average

result = calculate_average("85,92,78.5,90,88.5")
print(f"Average: {result}")  # Average: 86.8

def classify_value(value):
    """Classify a value by its type."""
    if isinstance(value, bool):       # FIX: check bool FIRST
        return "boolean"
    elif isinstance(value, int):
        return "integer"
    elif isinstance(value, float):
        return "float"
    elif isinstance(value, str):
        return "string"
    return "unknown"

print(classify_value(True))    # "boolean" (correct!)
print(classify_value(42))      # "integer"
print(classify_value(3.14))    # "float"

def transfer_id(id_string):
    """Convert a large ID string to an integer for processing."""
    # FIX: convert directly to int, don't go through float
    return int(id_string)

id_str = "9007199254740993"
result = transfer_id(id_str)
expected = 9007199254740993
print(f"Expected: {expected}")
print(f"Got:      {result}")
print(f"Match:    {result == expected}")  # True

from collections import defaultdict


def merge_pairs(pair_list):
    """Merge a list of key-value pairs, collecting duplicates into lists."""
    result = defaultdict(list)
    for key, value in pair_list:
        result[key].append(value)
    return dict(result)  # FIX: preserve all values


# Alternative: detect and warn about duplicates
def merge_pairs_strict(pair_list):
    result = {}
    for key, value in pair_list:
        if key in result:
            raise ValueError(f"Duplicate key: {key!r}")
        result[key] = value
    return result


pairs = [("name", "Alice"), ("age", "30"), ("name", "Bob")]
print(merge_pairs(pairs))
# {'name': ['Alice', 'Bob'], 'age': ['30']}

class TaskQueue:
    def __init__(self):
        self._pending = []
        self._completed_count = 0

    def add(self, task):
        self._pending.append(task)

    def complete(self, task):
        self._pending.remove(task)
        self._completed_count += 1

    def __len__(self):
        """Return number of PENDING tasks (consistent with __bool__)."""
        return len(self._pending)  # FIX: len = pending count

    def __bool__(self):
        """Return True if there are pending tasks."""
        return len(self._pending) > 0

    @property
    def total_processed(self) -> int:
        """Total tasks ever processed (separate from len)."""
        return self._completed_count + len(self._pending)


q = TaskQueue()
q.add("task1")
q.add("task2")
q.complete("task1")
q.complete("task2")

print(f"bool(q): {bool(q)}")           # False
print(f"len(q):  {len(q)}")            # 0 (consistent!)
print(f"total:   {q.total_processed}") # 2

import math


def find_invalid_readings(readings):
    """Find readings that are NaN (not a number)."""
    invalid = []
    for i, reading in enumerate(readings):
        value = float(reading)
        if math.isnan(value):  # FIX: use math.isnan()
            invalid.append(i)
    return invalid

readings = ["3.14", "nan", "2.71", "nan", "1.41"]
result = find_invalid_readings(readings)
print(f"Invalid indices: {result}")  # [1, 3]

class Offset:
    """Represents an offset value for array access."""
    def __init__(self, value):
        self.value = value

    def __int__(self):
        return int(self.value)

    def __index__(self):  # FIX: implement __index__
        return int(self.value)

data = [10, 20, 30, 40, 50]
offset = Offset(2)

print(f"int(offset) = {int(offset)}")       # 2
print(f"data[offset] = {data[offset]}")     # 30
print(f"bin(offset) = {bin(offset)}")        # 0b10
print(f"hex(offset) = {hex(offset)}")        # 0x2

class Celsius:
    def __init__(self, temp):
        self.temp = float(temp)

    def __float__(self):
        return self.temp

    def __eq__(self, other):
        if isinstance(other, Fahrenheit):
            # FIX: compare using raw float values in same unit
            return abs(self.temp - (other.temp - 32) * 5/9) < 0.01
        if isinstance(other, Celsius):
            return abs(self.temp - other.temp) < 0.01
        return NotImplemented

    def __repr__(self):
        return f"Celsius({self.temp})"


class Fahrenheit:
    def __init__(self, temp):
        self.temp = float(temp)

    def __float__(self):
        return self.temp

    def __eq__(self, other):
        if isinstance(other, Celsius):
            # FIX: convert directly using formula, not recursive comparison
            return abs(self.temp - (other.temp * 9/5 + 32)) < 0.01
        if isinstance(other, Fahrenheit):
            return abs(self.temp - other.temp) < 0.01
        return NotImplemented

    def __repr__(self):
        return f"Fahrenheit({self.temp})"


c = Celsius(100)
f = Fahrenheit(212)
print(f == c)  # True (no recursion!)
print(c == f)  # True