Python Type Casting — Language Specification¶

object.__int__(self)     -> int      # called by int()
object.__float__(self)   -> float    # called by float()
object.__complex__(self) -> complex  # called by complex()
object.__index__(self)   -> int
# __index__ must return an exact int (not a subclass).
# Used by: int(), bin(), oct(), hex(), operator.index(), slicing.
# If defined, the object can be used wherever an integer index is needed.
object.__trunc__(self)   -> int      # called by math.trunc(); fallback for int()
object.__floor__(self)   -> int      # called by math.floor()
object.__ceil__(self)    -> int      # called by math.ceil()

object.__str__(self)     -> str   # called by str(), print(), f-strings (with __format__)
object.__repr__(self)    -> str   # called by repr(); used as fallback by str()
object.__format__(self, format_spec: str) -> str
# Called by format() and f-string format specifications.
# If format_spec is empty, behaves like str(self).
object.__bytes__(self)   -> bytes  # called by bytes()

print(int(3.9))    # 3   (not 4)
print(int(-3.9))   # -3  (not -4)
# Compare with math.floor:
import math
print(math.floor(-3.9))   # -4
print(math.trunc(-3.9))   # -3  (same as int())

print(int("0b1010", 0))   # 10  (base 0 = auto)
print(int("0o17", 0))     # 15
print(int("0xFF", 0))     # 255
print(int("FF", 16))      # 255
print(int("77", 8))       # 63
print(int("11", 2))       # 3
# Underscore separators allowed (Python 3.6+):
print(int("1_000_000"))   # 1000000

print(int(True))          # 1
print(int(False))         # 0
print(True + True)        # 2
print(str(True))          # "True"  (not "1")
print(repr(True))         # "True"

print(bytes(5))             # b'\x00\x00\x00\x00\x00'  — 5 zero bytes
print(bytes([65, 66, 67]))  # b'ABC'
print(bytes("hello", "utf-8"))  # b'hello'

# TRAP: bytes("hello") WITHOUT encoding raises TypeError
try:
    bytes("hello")
except TypeError as e:
    print(e)   # string argument without an encoding

class Meter:
    def __init__(self, value: int):
        self._value = value

    def __index__(self) -> int:
        return self._value

m = Meter(3)
data = [10, 20, 30, 40, 50]
print(data[m])        # 40   — __index__ used for subscript
print(bin(m))         # 0b11 — __index__ used by bin()
print(hex(m))         # 0x3

import sys
print(sys.get_int_max_str_digits())   # 4300 by default

# Override (for trusted data only):
sys.set_int_max_str_digits(10000)
big = 10 ** 5000
s = str(big)   # now allowed
print(len(s))  # 5001

pi = 3.14159265358979
print(str(pi))          # 3.14159265358979
print(repr(pi))         # 3.14159265358979
print(format(pi, ".2f"))  # 3.14
print(f"{pi:.4e}")        # 3.1416e+00

import math
import sys

# ----------------------------------------------------------------
# 1. int() — various inputs
# ----------------------------------------------------------------
print(int(3.9))        # 3    (truncate toward zero)
print(int(-3.9))       # -3   (truncate toward zero, not floor)
print(int("42"))       # 42
print(int("0xFF", 16)) # 255
print(int("0b1010", 0)) # 10
print(int(True))       # 1


# ----------------------------------------------------------------
# 2. float() — various inputs
# ----------------------------------------------------------------
print(float(3))         # 3.0
print(float("3.14"))    # 3.14
print(float("1e10"))    # 10000000000.0
print(float("inf"))     # inf
print(float("-INF"))    # -inf  (case-insensitive)
print(float("nan"))     # nan


# ----------------------------------------------------------------
# 3. str() — various inputs
# ----------------------------------------------------------------
print(str(42))           # "42"
print(str(3.14))         # "3.14"
print(str(True))         # "True"
print(str(None))         # "None"
print(str([1, 2, 3]))    # "[1, 2, 3]"
print(str(b"hello"))     # "b'hello'"  (NOT decoded!)
print(str(b"hello", "utf-8"))  # "hello"  (decoded)


# ----------------------------------------------------------------
# 4. bool() — truth value testing
# ----------------------------------------------------------------
for val in [0, 0.0, "", [], {}, None, False, "x", [0], 1]:
    print(f"bool({repr(val)}) = {bool(val)}")


# ----------------------------------------------------------------
# 5. bytes() — three forms
# ----------------------------------------------------------------
print(bytes(5))               # b'\x00\x00\x00\x00\x00'
print(bytes([72, 101, 108]))  # b'Hel'
print(bytes("hello", "utf-8")) # b'hello'


# ----------------------------------------------------------------
# 6. Container conversions
# ----------------------------------------------------------------
t = (1, 2, 3)
lst = list(t)           # tuple → list
tpl = tuple(lst)        # list → tuple
s   = set(lst)          # list → set (unique, unordered)
fs  = frozenset([1,2,3,2,1])   # deduplicated, immutable

print(lst)    # [1, 2, 3]
print(s)      # {1, 2, 3}
print(fs)     # frozenset({1, 2, 3})


# ----------------------------------------------------------------
# 7. dict() from pairs or keyword args
# ----------------------------------------------------------------
d1 = dict([("a", 1), ("b", 2)])
d2 = dict(a=1, b=2)
d3 = dict({"a": 1}, b=2)
print(d1 == d2 == d3)   # True


# ----------------------------------------------------------------
# 8. Implicit numeric promotion
# ----------------------------------------------------------------
result = 5 + 2.0          # int + float → float
print(type(result))       # <class 'float'>

result2 = 2.0 + (1+0j)   # float + complex → complex
print(type(result2))      # <class 'complex'>


# ----------------------------------------------------------------
# 9. Custom __index__ for slice/index usage
# ----------------------------------------------------------------
class MyInt:
    def __init__(self, n):
        self._n = n
    def __index__(self):
        return self._n

m = MyInt(2)
data = [10, 20, 30, 40]
print(data[m])          # 30
print(data[m:])         # [30, 40]
print(bin(m))           # 0b10


# ----------------------------------------------------------------
# 10. __int__ vs __trunc__ vs math functions
# ----------------------------------------------------------------
class Approx:
    def __init__(self, v):
        self.v = v
    def __int__(self):
        return int(self.v)
    def __float__(self):
        return float(self.v)
    def __trunc__(self):
        return math.trunc(self.v)
    def __floor__(self):
        return math.floor(self.v)
    def __ceil__(self):
        return math.ceil(self.v)

a = Approx(3.7)
print(int(a))          # 3
print(float(a))        # 3.7
print(math.trunc(a))   # 3
print(math.floor(a))   # 3
print(math.ceil(a))    # 4


# ----------------------------------------------------------------
# 11. format() with format spec
# ----------------------------------------------------------------
n = 255
print(format(n, "d"))    # 255   (decimal)
print(format(n, "x"))    # ff    (hex lowercase)
print(format(n, "X"))    # FF    (hex uppercase)
print(format(n, "o"))    # 377   (octal)
print(format(n, "b"))    # 11111111 (binary)
print(format(3.14159, ".3f"))  # 3.142


# ----------------------------------------------------------------
# 12. Large int string conversion limit (Python 3.11+)
# ----------------------------------------------------------------
print(f"Default limit: {sys.get_int_max_str_digits()}")  # 4300

# Convert within limit:
n = 10 ** 100
print(str(n)[:20], "...")   # first 20 chars