What is the common pitfall with Floating Point Representation Imprecision?

IEEE 754 floats cannot represent 0.1 in finite binary fractions, yielding a tiny representation error. Exam trap note: In exams, `0.1 + 0.2 == 0.3` evaluates to False. Always use math.isclose() or round() for float equality.

What are the core concepts of Python Numbers & Type Casting?

In languages like C or Java, an int overflows at 2^31 - 1 or 2^63 - 1. In Python 3, int objects have arbitrary precision; they automatically allocate as many digits in RAM as needed. You can calculate 2**1000 or factorial(100) without any integer overflow errors.

← Previous: Python Data Types All Modules Next: Python Strings & Slicing →

MOD-05 · Sequence #5 · Python Basics

Python Numbers & Type Casting

Python integers have arbitrary precision (they never overflow into negative numbers). Floats follow IEEE 754 double precision. Understanding integer floor division (//), modulo (%), and explicit type casting is crucial for algorithmic problem solving.

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

a = int(2.8)    # 2
b = float(3)    # 3.0
c = str(42)     # '42'

Core Principles & Mental Models

1. Arbitrary Precision Integers

No 32-bit or 64-bit Overflow

In languages like C or Java, an int overflows at 2^31 - 1 or 2^63 - 1.
In Python 3, int objects have arbitrary precision; they automatically allocate as many digits in RAM as needed.
You can calculate 2**1000 or factorial(100) without any integer overflow errors.

big_int = 2 ** 128
print("2^128:", big_int)
print("Digit count:", len(str(big_int)))

💡 Key Takeaway: Python integers expand dynamically in memory and never suffer from classical buffer/integer overflow.

2. Floor Division (//) and Modulo (%)

Flooring Toward Negative Infinity

The single slash (/) always returns a float: 6 / 2 -> 3.0.
The double slash (//) performs floor division, rounding down towards negative infinity (not towards zero).
For positive numbers: 7 // 2 = 3. For negative numbers: -7 // 2 = -4 (floored down!).
Modulo (%) satisfies the identity: a = (a // b) * b + (a % b).

print("7 // 2 =", 7 // 2)      # 3
print("-7 // 2 =", -7 // 2)    # -4 (Floored toward -infinity!)
print("-7 % 2 =", -7 % 2)      # 1 (Because -4 * 2 + 1 = -7)

💡 Key Takeaway: Python floor division rounds towards -∞, making negative division results differ from C/C++ which truncates towards zero.

Interactive Walkthrough Examples

Floor Division & Modulo Rules (Basic)

Demonstrating division semantics with positive and negative dividends.

pairs = [(7, 3), (-7, 3), (7, -3), (-7, -3)]
for num, denom in pairs:
    q = num // denom
    r = num % denom
    check = (q * denom) + r == num
    print(f"{num:2} // {denom:2} = {q:2}, {num:2} % {denom:2} = {r:2} [Invariant Valid: {check}]")

Explanation: The mathematical division invariant always holds true in Python.

Common Misconceptions & Exam Traps

Common Pitfall: Floating Point Representation Imprecision

IEEE 754 floats cannot represent 0.1 in finite binary fractions, yielding a tiny representation error.

Buggy Code

total = 0.1 + 0.2
if total == 0.3:
    print("Equal")
else:
    print("Not equal:", total)  # 0.30000000000000004!

Correct Solution

import math
total = 0.1 + 0.2
if math.isclose(total, 0.3, rel_tol=1e-9):
    print("Safely Equal!")

Exam Trap Note: In exams, `0.1 + 0.2 == 0.3` evaluates to False. Always use math.isclose() or round() for float equality.

Conceptual Knowledge Self-Check Quiz

Q1: What is the result of the expression `-9 // 2` in Python?

-4
-5
-4.5
Error

-9 / 2 is -4.5. Floor division rounds down toward negative infinity, resulting in -5.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Use math.isclose() when comparing floating-point results.
✅ Use the decimal module for financial calculations requiring exact precision.

← Python Data Types Take Assessed Test → Python Strings & Slicing →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.