← Data Types & Variables

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

What are the basic built-in data types in Python?

Python has several built-in data types organized into categories:

Numeric types:

int -- arbitrary-precision integers (e.g., 42, -7, 10**100)
float -- IEEE 754 double-precision floating point (e.g., 3.14, -0.001, 1e10)
complex -- complex numbers with real and imaginary parts (e.g., 3+4j)

Sequence types:

str -- immutable sequence of Unicode characters
list -- mutable ordered sequence
tuple -- immutable ordered sequence

Set types:

set -- mutable unordered collection of unique elements
frozenset -- immutable version of set

Mapping type:

dict -- mutable key-value mapping

Boolean type:

bool -- True or False (subclass of int)

None type:

NoneType -- singleton None, represents absence of a value

Binary types:

bytes, bytearray, memoryview

Everything in Python is an object, including these types themselves. You can check a value's type with type() and verify membership with isinstance().

Pseudo Code

1. Numeric: int, float, complex
2. Text: str
3. Sequence: list, tuple, range
4. Set: set, frozenset
5. Mapping: dict
6. Boolean: bool
7. None: NoneType
8. Binary: bytes, bytearray, memoryview

Code

# Numeric types
print(type(42))         # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type(3+4j))       # <class 'complex'>

# Text type
print(type("hello"))    # <class 'str'>

# Sequence types
print(type([1, 2, 3]))  # <class 'list'>
print(type((1, 2, 3)))  # <class 'tuple'>

# Set types
print(type({1, 2, 3}))  # <class 'set'>

# Mapping type
print(type({"a": 1}))   # <class 'dict'>

# Boolean and None
print(type(True))       # <class 'bool'>
print(type(None))       # <class 'NoneType'>

# bool is a subclass of int
print(isinstance(True, int))  # True
print(True + True)            # 2

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
<class 'bool'>
<class 'NoneType'>
True
2

Key Points

•Everything in Python is an object, including types themselves
•bool is a subclass of int (True == 1, False == 0)
•Python integers have arbitrary precision -- no overflow
•NoneType has exactly one instance: None
•Strings are sequences of Unicode codepoints, not bytes

Gotchas

•An empty dict is {} but an empty set must be set(), not {} -- {} creates a dict
•bool is a subclass of int, so isinstance(True, int) returns True
•float has limited precision -- 0.1 + 0.2 != 0.3 exactly
•None is a singleton: always use 'is None' rather than '== None'

Python's main built-in types are: int, float, complex (numeric), str (text), list, tuple (sequences), set, frozenset (sets), dict (mapping), bool (boolean), and NoneType. Everything is an object. Use type() to check and isinstance() to verify.

•Everything in Python is an object
•bool is a subclass of int

print(type(42))        # <class 'int'>
print(type(3.14))      # <class 'float'>
print(type("hi"))      # <class 'str'>
print(type([1,2]))     # <class 'list'>
print(type((1,2)))     # <class 'tuple'>
print(type({1,2}))     # <class 'set'>
print(type({"a":1}))   # <class 'dict'>
print(type(True))      # <class 'bool'>
print(type(None))      # <class 'NoneType'>

<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
<class 'bool'>
<class 'NoneType'>

{} creates a dict, not a set -- use set() for an empty set

Question 2 / 15

How do type() and isinstance() differ, and when should you use each?

type(obj) returns the exact type of an object. isinstance(obj, cls) checks if an object is an instance of a class or any of its subclasses.

The critical difference is inheritance. type() does an exact match, while isinstance() respects the class hierarchy.

When to use type():

When you need the exact class, not a subclass
For debugging / introspection
When building a type-to-handler dispatch table

When to use isinstance():

Almost all production type checking
When you want to accept subclasses (polymorphism)
PEP 8 recommends isinstance() over type() comparisons

isinstance() also accepts a tuple of types, which acts as an OR check.

Pseudo Code

1. type(obj) returns the exact class of obj
2. isinstance(obj, cls) returns True if obj is an instance of cls or any subclass
3. isinstance(obj, (A, B)) returns True if obj is instance of A or B
4. Prefer isinstance() for type checks in production code

Code

# type() returns the exact type
print(type(42))           # <class 'int'>
print(type(42) == int)    # True
print(type(True) == int)  # False -- bool is not exactly int

# isinstance() respects inheritance
print(isinstance(42, int))    # True
print(isinstance(True, int))  # True -- bool IS-A int

# isinstance with a tuple (OR check)
print(isinstance(42, (int, float)))    # True
print(isinstance(3.14, (int, float)))  # True

# Practical example with custom classes
class Animal:
    pass

class Dog(Animal):
    pass

dog = Dog()
print(type(dog) == Animal)        # False
print(type(dog) == Dog)           # True
print(isinstance(dog, Animal))    # True -- Dog IS-A Animal
print(isinstance(dog, Dog))       # True

<class 'int'>
True
False
True
True
True
True
False
True
True
True

Key Points

•type() does an exact type match, isinstance() checks the inheritance chain
•isinstance() accepts a tuple of types for an OR-style check
•PEP 8 recommends isinstance() over type() comparisons
•isinstance() supports abstract base classes (ABCs) and virtual subclasses

Gotchas

•type(True) == int is False, but isinstance(True, int) is True because bool subclasses int
•Overusing type checks goes against Python's duck typing philosophy
•type() does not respect __instancecheck__ from metaclasses, but isinstance() does
•Never write type(x) is type(y) when isinstance(x, type(y)) is intended

type(obj) gives the exact class. isinstance(obj, cls) checks if obj belongs to cls or any of its subclasses. Use isinstance() in almost all cases because it respects inheritance.

•isinstance() respects inheritance, type() does not
•PEP 8 prefers isinstance() for type checks

print(type(True) == int)       # False (exact match)
print(isinstance(True, int))   # True (bool subclasses int)

# Tuple of types for OR check
print(isinstance(42, (int, float)))  # True

False
True
True

type(True) == int is False even though bool is a subclass of int

Question 3 / 15

Explain type conversion (casting) in Python. What is the difference between implicit and explicit conversion?

Implicit conversion (coercion): Python automatically converts types in certain operations to avoid data loss. For example, when you add an int to a float, the int is promoted to float. This is limited to safe, lossless conversions in numeric operations.

Explicit conversion (casting): You manually convert types using constructor functions: int(), float(), str(), bool(), list(), tuple(), set(), dict(), etc. These can raise exceptions if the conversion is invalid.

Key conversion rules:

int() truncates floats toward zero (not floor): int(-3.7) is -3
float() can convert strings: float("3.14") works
bool() follows truthiness rules: 0, "", [], None are False
str() works on anything via __str__ or __repr__
int() accepts a base argument for string parsing: int("ff", 16) is 255

Pseudo Code

Implicit:
  int + float -> float (automatic promotion)
  int + bool -> int (bool treated as 0 or 1)

Explicit:
  int("42") -> 42
  float(42) -> 42.0
  str(42) -> "42"
  bool(0) -> False
  int(3.7) -> 3 (truncation, not rounding)
  int("ff", 16) -> 255 (base conversion)

Code

# Implicit conversion (coercion)
result = 5 + 3.0     # int + float -> float
print(result, type(result))  # 8.0 <class 'float'>

result = True + 10   # bool + int -> int
print(result)        # 11

# Explicit conversion
print(int("42"))       # 42
print(int(3.9))        # 3  (truncates, does NOT round)
print(int(-3.9))       # -3 (truncates toward zero)
print(float("3.14"))   # 3.14
print(str(42))         # '42'
print(bool(0))         # False
print(bool(""))        # False
print(bool("hello"))   # True

# Base conversion with int()
print(int("ff", 16))   # 255
print(int("1010", 2))  # 10
print(int("77", 8))    # 63

# Collection conversions
print(list("abc"))           # ['a', 'b', 'c']
print(tuple([1, 2, 3]))      # (1, 2, 3)
print(set([1, 2, 2, 3]))     # {1, 2, 3}
print(dict([("a", 1), ("b", 2)]))  # {'a': 1, 'b': 2}

# Invalid conversions raise exceptions
try:
    int("hello")
except ValueError as e:
    print(f"Error: {e}")  # invalid literal for int() with base 10: 'hello'

8.0 <class 'float'>
11
42
3
-3
3.14
42
False
False
True
255
10
63
['a', 'b', 'c']
(1, 2, 3)
{1, 2, 3}
{'a': 1, 'b': 2}
Error: invalid literal for int() with base 10: 'hello'

Key Points

•Implicit conversion only happens for safe numeric promotions (int -> float)
•int() truncates toward zero, it does NOT round
•int() accepts a second argument for base conversion (binary, octal, hex)
•bool() follows truthiness: 0, 0.0, '', [], {}, set(), None are all False
•Invalid conversions raise ValueError or TypeError

Gotchas

•int(3.9) gives 3, not 4 -- use round() if you want rounding
•int(-3.9) gives -3, not -4 -- truncation is toward zero, not floor
•int('3.14') raises ValueError -- you need int(float('3.14')) for string floats
•str([1,2,3]) gives '[1, 2, 3]' as a string, not '123'
•bool('False') is True -- any non-empty string is truthy

Implicit conversion happens automatically in safe numeric operations (int + float -> float). Explicit conversion uses constructor functions: int(), float(), str(), bool(). Use int() to truncate (not round) floats, and it accepts a base for string parsing.

•Implicit conversion only for safe numeric promotions
•int() truncates toward zero, does not round

# Implicit
print(5 + 3.0)        # 8.0 (int promoted to float)

# Explicit
print(int(3.9))        # 3 (truncates, not rounds)
print(int("ff", 16))   # 255
print(float("3.14"))   # 3.14
print(bool(""))        # False
print(bool("False"))   # True (non-empty string!)

8.0
3
255
3.14
False
True

int('3.14') raises ValueError -- need int(float('3.14')) bool('False') is True because the string is non-empty

Question 4 / 15

What is the difference between mutable and immutable types in Python?

Immutable types cannot be changed after creation. Any operation that appears to modify them actually creates a new object. Immutable types include: int, float, str, tuple, frozenset, bytes, bool, NoneType.

Mutable types can be changed in-place without creating a new object. Mutable types include: list, dict, set, bytearray.

This distinction has important implications:

Hashability: Only immutable types can be used as dictionary keys or set members (they must be hashable).
Function arguments: Passing a mutable object to a function lets the function modify the caller's data.
Default arguments: Using mutable default arguments in functions is a famous bug source.
Thread safety: Immutable objects are inherently thread-safe.
Memory: Python can intern/cache immutable objects (e.g., small integers, short strings).

Pseudo Code

Immutable: int, float, str, tuple, frozenset, bytes, bool, None
  - Cannot change in place
  - Can be dict keys / set members
  - Safe as default function arguments

Mutable: list, dict, set, bytearray
  - Can change in place
  - Cannot be dict keys / set members
  - Dangerous as default function arguments

Code

# Immutable: str
s = "hello"
print(id(s))         # e.g., 140234567890
s = s + " world"     # creates a NEW string object
print(id(s))         # different id -- new object

# Mutable: list
lst = [1, 2, 3]
print(id(lst))       # e.g., 140234567000
lst.append(4)        # modifies in place
print(id(lst))       # SAME id -- same object
print(lst)           # [1, 2, 3, 4]

# Immutable: tuple
t = (1, 2, 3)
try:
    t[0] = 99
except TypeError as e:
    print(f"Error: {e}")  # 'tuple' object does not support item assignment

# Hashability consequence
valid_dict = {(1, 2): "tuple key"}  # OK: tuple is immutable
try:
    invalid_dict = {[1, 2]: "list key"}  # Fails
except TypeError as e:
    print(f"Error: {e}")  # unhashable type: 'list'

# Mutable argument trap
def bad_append(item, lst=[]):
    lst.append(item)
    return lst

print(bad_append(1))  # [1]
print(bad_append(2))  # [1, 2] -- BUG! Same list reused

def good_append(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

print(good_append(1))  # [1]
print(good_append(2))  # [2] -- correct, fresh list each time

4381299248
4381370544
4381368576
4381368576
[1, 2, 3, 4]
Error: 'tuple' object does not support item assignment
Error: unhashable type: 'list'
[1]
[1, 2]
[1]
[2]

Key Points

•Immutable: int, float, str, tuple, frozenset, bytes
•Mutable: list, dict, set, bytearray
•Only immutable (hashable) objects can be dict keys or set members
•Modifying a mutable object in a function affects the caller
•Always use None as default for mutable arguments

Gotchas

•A tuple containing a mutable object (e.g., a list) is technically immutable but its contents can change
•Mutable default arguments persist across function calls -- a classic Python bug
•String concatenation in a loop creates many temporary objects -- use join() instead
•Reassignment (x = new_value) is not mutation -- it rebinds the name

Immutable types (int, float, str, tuple, frozenset) cannot be changed in-place. Mutable types (list, dict, set) can. This affects hashability (only immutable types as dict keys), function argument safety, and caching.

•Immutable: int, float, str, tuple, frozenset
•Mutable: list, dict, set

lst = [1, 2, 3]
lst.append(4)     # modifies in place, same object

s = "hello"
s = s + " world"  # creates NEW string, different object

# Mutable default argument trap
def bad(lst=[]):
    lst.append(1)
    return lst
print(bad())  # [1]
print(bad())  # [1, 1] -- bug!

[1]
[1, 1]

Never use mutable objects as default function arguments

Question 5 / 15

What is dynamic typing in Python? How does it differ from static typing?

In dynamically typed languages like Python, type checking happens at runtime, not at compile time. Variables do not have fixed types -- they are just names (labels) bound to objects, and the objects carry the type information.

A variable can be reassigned to a value of a completely different type:

x = 42       # x refers to an int object
x = "hello"  # now x refers to a str object -- perfectly legal

In statically typed languages (C, Java, Go), variables have a declared type that cannot change. The compiler checks types before the program runs.

Python's approach:

Types belong to objects, not variables
Variables are just name bindings (pointers) to objects
Type errors are caught at runtime, not compile time
Python supports optional type hints (PEP 484) for static analysis tools like mypy, but they are not enforced at runtime

Advantages of dynamic typing:

Faster prototyping, more flexible code
Duck typing: "if it quacks like a duck..."

Disadvantages:

Type errors only surface at runtime
Harder to reason about large codebases without type hints

Pseudo Code

Dynamic typing (Python):
  x = 42        # x is bound to an int object
  x = "hello"   # x is now bound to a str object -- OK
  # Type lives on the OBJECT, not the variable

Static typing (C/Java):
  int x = 42;
  x = "hello";  // Compile error -- x must be int

Code

# Variables are just names bound to objects
x = 42
print(type(x))  # <class 'int'>

x = "hello"
print(type(x))  # <class 'str'> -- no error, x now points to a str

x = [1, 2, 3]
print(type(x))  # <class 'list'> -- rebound again

# The type belongs to the object, not the variable
a = 42
b = a         # b and a point to the SAME int object
print(id(a) == id(b))  # True

b = "hello"   # b now points to a different object
print(id(a) == id(b))  # False

# Type hints are optional and NOT enforced at runtime
def greet(name: str) -> str:
    return f"Hello, {name}"

# Python will NOT stop you from passing an int
result = greet(42)  # No runtime error, just returns "Hello, 42"
print(result)

# Duck typing in action
class Cat:
    def speak(self):
        return "Meow"

class Dog:
    def speak(self):
        return "Woof"

def make_speak(animal):
    return animal.speak()  # No type check -- just calls .speak()

print(make_speak(Cat()))  # Meow
print(make_speak(Dog()))  # Woof

<class 'int'>
<class 'str'>
<class 'list'>
True
False
Hello, 42
Meow
Woof

Key Points

•Types belong to objects, not variables -- variables are just name bindings
•You can reassign a variable to a value of a different type at any time
•Type errors are caught at runtime, not compile time
•Type hints (PEP 484) are optional and not enforced by the interpreter
•Duck typing: focus on what an object can DO, not what it IS

Gotchas

•Dynamic typing does not mean no types -- every object has a well-defined type
•Type hints do not prevent runtime type errors unless you use a tool like mypy
•Duck typing means AttributeError at runtime if an object lacks the expected method
•Python is strongly typed (no implicit type coercion like JavaScript) AND dynamically typed

In Python, types belong to objects, not variables. Variables are just names that can be rebound to any object of any type at any time. Type checking happens at runtime. Python is dynamically typed (types checked at runtime) but strongly typed (no implicit coercion like JS).

•Variables are name bindings, not typed containers
•Python is strongly AND dynamically typed

x = 42       # x -> int object
x = "hello"  # x -> str object, perfectly legal
x = [1, 2]   # x -> list object

# Type hints are not enforced
def add(a: int, b: int) -> int:
    return a + b

print(add("hi", "!"))  # "hi!" -- no runtime error

hi!

Dynamic typing != weak typing -- Python won't add '5' + 5 like JavaScript

Question 6 / 15

What does the id() function return, and what does it tell you about objects?

id(obj) returns an integer that uniquely identifies an object during its lifetime. In CPython (the standard implementation), this is the memory address of the object.

Key properties:

Two objects that exist at the same time will have different id() values
An object's id() never changes during its lifetime
After an object is garbage collected, its id() can be reused

Relationship to is operator: a is b is equivalent to id(a) == id(b) -- it checks if two names refer to the exact same object in memory.

Integer and string interning: CPython caches small integers (-5 to 256) and some short strings, so variables with the same small integer value may share the same id(). This is an implementation detail, not a language guarantee.

Pseudo Code

1. id(obj) returns unique integer identity of object
2. In CPython, this is the memory address
3. a is b <==> id(a) == id(b)
4. CPython caches small integers (-5 to 256)
5. id can be reused after object is garbage collected

Code

# id() returns the identity (memory address in CPython)
a = [1, 2, 3]
print(id(a))  # e.g., 140456789012345

# Same object: same id
b = a
print(id(a) == id(b))  # True
print(a is b)          # True -- same object

# Different objects with same value: different id
c = [1, 2, 3]
print(a == c)          # True (same value)
print(a is c)          # False (different objects)
print(id(a) == id(c))  # False

# Integer caching (CPython implementation detail)
x = 256
y = 256
print(x is y)   # True -- cached small integer

x = 257
y = 257
print(x is y)   # False (or True in some contexts -- unreliable!)

# Immutable objects may or may not be shared
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True (string interning)

s3 = "hello world!"
s4 = "hello world!"
print(s3 is s4)  # May be True or False (implementation-dependent)

# Mutation changes the object, not its identity
lst = [1, 2]
original_id = id(lst)
lst.append(3)
print(id(lst) == original_id)  # True -- same object, mutated in place

4381367552
True
True
True
False
False
True
True
True
True
True

Key Points

•id() returns a unique integer identifier for an object's lifetime
•In CPython, id() is the memory address
•a is b checks identity: id(a) == id(b)
•CPython caches small integers (-5 to 256) and some strings
•Mutating a mutable object does not change its id()

Gotchas

•Integer caching range (-5 to 256) is a CPython implementation detail, not guaranteed
•String interning behavior varies -- never rely on 'is' for string comparison
•After an object is garbage collected, its id can be reused by a new object
•In the REPL, the same code may produce different id results than in a script due to compilation units

id(obj) returns a unique integer identifier (memory address in CPython) for an object. a is b is equivalent to id(a) == id(b). CPython caches small integers (-5 to 256), so they share the same id.

•id() returns memory address in CPython
•a is b checks if same object (same id)

a = [1, 2]
b = a
print(id(a) == id(b))  # True (same object)

c = [1, 2]
print(a == c)   # True (same value)
print(a is c)   # False (different objects)

True
True
False

Small integer caching is an implementation detail -- never rely on 'is' for value comparison

Question 7 / 15

What is the difference between 'is' and '==' in Python?

== checks value equality: do the two objects have the same value? It calls the __eq__ method.

is checks identity: are the two names referring to the exact same object in memory? It compares id() values.

Rules of thumb:

Use == for comparing values (almost always what you want)
Use is only for singletons: None, True, False
x is None is idiomatic Python (faster and unambiguous)
Never use is to compare strings or numbers (unreliable due to caching)

Why is None instead of == None?

is cannot be overridden (it always checks identity)
== can be overridden via __eq__, which could produce unexpected results
is None is marginally faster (no method call)

Pseudo Code

== calls __eq__, compares values
is compares id(), checks same object in memory

Use == for: comparing values
Use is for: None, True, False (singletons only)

Code

# == checks value equality
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # True -- same values
print(a is b)  # False -- different objects

# is checks identity
c = a
print(a is c)  # True -- same object

# Always use 'is' for None
x = None
print(x is None)   # True -- correct idiom
print(x == None)   # True, but bad practice

# Why 'is None' matters -- __eq__ can lie
class Sneaky:
    def __eq__(self, other):
        return True  # claims to equal everything

obj = Sneaky()
print(obj == None)   # True -- misleading!
print(obj is None)   # False -- correct

# Integer caching makes 'is' unreliable for numbers
a = 256
b = 256
print(a is b)   # True (cached)

a = 257
b = 257
print(a is b)   # Unreliable! May be True or False

# Always use == for number/string comparison
print(a == b)   # True -- always reliable

True
False
True
True
True
True
False
True
True
True

Key Points

•== compares values via __eq__, 'is' compares object identity via id()
•Use 'is' only for singletons: None, True, False
•'is None' is preferred over '== None' in PEP 8
•'is' cannot be overridden, == can
•Never use 'is' to compare strings or numbers

Gotchas

•Integer caching makes 'is' seem to work for small numbers but it is unreliable
•String interning makes 'is' seem to work for short strings but it is unreliable
•Custom __eq__ can make == return unexpected results, but 'is' always checks identity
•'is not' is the correct negation, not 'not ... is'

== checks value equality (calls __eq__). is checks identity (same object in memory). Use is only for singletons (None, True, False). Use == for everything else.

•== for values, 'is' for identity
•Use 'is None', never '== None'

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # True (same value)
print(a is b)  # False (different objects)

x = None
print(x is None)  # True -- idiomatic Python

True
False
True

Never use 'is' to compare strings or numbers -- caching makes it unreliable

Question 8 / 15

How does Python handle floating-point precision, and what are the common pitfalls?

Python floats follow the IEEE 754 double-precision standard, using 64 bits to represent numbers. This gives about 15-17 significant decimal digits of precision.

The fundamental issue is that most decimal fractions (like 0.1) cannot be represented exactly in binary. 0.1 in binary is a repeating fraction, just like 1/3 in decimal is 0.333....

Solutions for precision-sensitive work:

decimal.Decimal -- arbitrary precision decimal arithmetic
fractions.Fraction -- exact rational number arithmetic
math.isclose() -- for approximate float comparisons
Integer arithmetic -- store cents instead of dollars

When to use each:

Financial calculations: Decimal
Scientific comparisons: math.isclose()
Exact ratios: Fraction
General programming: accept float imprecision and use round() for display

Pseudo Code

1. floats use IEEE 754 double precision (64-bit)
2. 0.1 cannot be represented exactly in binary
3. Never compare floats with ==
4. Use Decimal for money, math.isclose() for comparisons
5. Use round() for display purposes

Code

# The classic floating-point surprise
print(0.1 + 0.2)              # 0.30000000000000004
print(0.1 + 0.2 == 0.3)       # False!

# Use math.isclose() for float comparison
import math
print(math.isclose(0.1 + 0.2, 0.3))  # True
print(math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-9))  # True

# See the actual stored value
print(f"{0.1:.20f}")  # 0.10000000000000000555

# Decimal for exact decimal arithmetic
from decimal import Decimal
a = Decimal("0.1")
b = Decimal("0.2")
print(a + b)                     # 0.3 (exact)
print(a + b == Decimal("0.3"))   # True

# WARNING: Decimal(0.1) vs Decimal("0.1")
print(Decimal(0.1))    # 0.1000000000000000055511151231257827021181583404541015625
print(Decimal("0.1"))  # 0.1 (exact)

# Fraction for exact rational arithmetic
from fractions import Fraction
f = Fraction(1, 3)
print(f)           # 1/3
print(f * 3)       # 1 (exact)
print(float(f))    # 0.3333333333333333

# round() for display
print(round(0.1 + 0.2, 1))  # 0.3

# Accumulation error
total = 0.0
for _ in range(10):
    total += 0.1
print(total)           # 0.9999999999999999 (not 1.0)
print(math.fsum([0.1] * 10))  # 1.0 (math.fsum reduces error)

0.30000000000000004
False
True
True
0.10000000000000000555
0.3
True
0.1000000000000000055511151231257827021181583404541015625
0.1
1/3
1
0.3333333333333333
0.3
0.9999999999999999
1.0

Key Points

•Python floats are IEEE 754 double precision (about 15-17 significant digits)
•Most decimal fractions cannot be represented exactly in binary
•Never compare floats with ==, use math.isclose() instead
•Use decimal.Decimal for financial calculations
•math.fsum() is more accurate than sum() for float lists

Gotchas

•Decimal(0.1) is NOT the same as Decimal('0.1') -- always use string constructor
•Accumulating 0.1 ten times does not give exactly 1.0
•round() uses banker's rounding (round half to even): round(0.5) is 0, round(1.5) is 2
•float('inf') and float('nan') are valid float values

Python floats use IEEE 754 double precision, so 0.1 + 0.2 != 0.3. Never compare floats with ==. Use math.isclose() for comparisons, decimal.Decimal for money, and round() for display.

•0.1 + 0.2 != 0.3 due to binary representation limits
•Use math.isclose() or Decimal for precision

print(0.1 + 0.2 == 0.3)  # False!

import math
print(math.isclose(0.1 + 0.2, 0.3))  # True

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2") == Decimal("0.3"))  # True

False
True
True

Decimal(0.1) != Decimal('0.1') -- always pass strings to Decimal

Question 9 / 15

What are complex numbers in Python and when are they used?

Python has a built-in complex type for complex numbers. A complex number has a real part and an imaginary part, written as a + bj where j (not i) is the imaginary unit.

Creating complex numbers:

Literal syntax: 3 + 4j
Constructor: complex(3, 4)

Accessing parts:

.real -- the real part
.imag -- the imaginary part
.conjugate() -- the complex conjugate

Use cases:

Signal processing (FFT)
Electrical engineering (impedance, phasors)
Scientific computing
Fractal generation (Mandelbrot set)
2D geometry (representing points/rotations)

The cmath module provides mathematical functions for complex numbers (analogous to math for reals).

Pseudo Code

1. Create: 3+4j or complex(3, 4)
2. Access: z.real, z.imag, z.conjugate()
3. Arithmetic: +, -, *, /, abs(), **
4. Use cmath for complex math functions
5. j suffix (not i) for imaginary part

Code

# Creating complex numbers
z1 = 3 + 4j
z2 = complex(1, 2)
print(z1)          # (3+4j)
print(z2)          # (1+2j)

# Accessing parts
print(z1.real)      # 3.0
print(z1.imag)      # 4.0
print(z1.conjugate())  # (3-4j)

# Arithmetic
print(z1 + z2)      # (4+6j)
print(z1 * z2)      # (-5+10j)
print(z1 / z2)      # (2.2-0.4j)
print(abs(z1))      # 5.0 (magnitude: sqrt(3^2 + 4^2))
print(z1 ** 2)      # (-7+24j)

# cmath module for complex math
import cmath
print(cmath.sqrt(-1))     # 1j
print(cmath.phase(z1))    # 0.9272... (angle in radians)
print(cmath.polar(z1))    # (5.0, 0.9272...) -- (magnitude, phase)

# Convert polar to rectangular
r, theta = 5.0, 0.9273
z = cmath.rect(r, theta)
print(z)  # approximately (3+4j)

# Type checking
print(type(3 + 4j))              # <class 'complex'>
print(isinstance(3 + 4j, complex))  # True

(3+4j)
(1+2j)
3.0
4.0
(3-4j)
(4+6j)
(-5+10j)
(2.2-0.4j)
5.0
(-7+24j)
1j
0.9272952180016122
(5.0, 0.9272952180016122)
(2.9999808719721477+4.000014345949428j)
<class 'complex'>
True

Key Points

•Python uses j (not i) for the imaginary unit
•complex(real, imag) or literal syntax 3+4j
•abs() returns the magnitude (modulus) of a complex number
•Use cmath instead of math for complex number functions
•.real and .imag are float attributes, not methods

Gotchas

•Python uses j, not i, for the imaginary unit -- mathematical convention differs
•You cannot use comparison operators (<, >, <=, >=) on complex numbers -- they are not ordered
•math.sqrt(-1) raises ValueError -- use cmath.sqrt(-1) instead
•complex(3) gives (3+0j), not just 3 -- it always has an imaginary part

Python supports complex numbers natively with j suffix: 3+4j. Access .real, .imag, and use abs() for magnitude. Use the cmath module for complex math. Common in signal processing, engineering, and scientific computing.

•Use j, not i, for imaginary unit
•Use cmath instead of math for complex operations

z = 3 + 4j
print(z.real)        # 3.0
print(z.imag)        # 4.0
print(abs(z))        # 5.0 (magnitude)

import cmath
print(cmath.sqrt(-1))  # 1j

3.0
4.0
5.0
1j

math.sqrt(-1) raises ValueError -- must use cmath.sqrt(-1)

Question 10 / 15

What is type coercion in Python, and how does it differ from JavaScript's type coercion?

Type coercion is the automatic conversion of one data type to another during an operation.

Python is strongly typed, meaning it does very little implicit type coercion compared to JavaScript (which is weakly typed).

Python's limited coercion:

Numeric promotion: int + float -> float, int + complex -> complex
Bool in numeric context: True + 1 -> 2
That is essentially it for implicit coercion

Python REFUSES to coerce:

"5" + 5 raises TypeError (JS gives "55")
"5" * "3" raises TypeError
"5" > 3 raises TypeError (JS gives true)

JavaScript's aggressive coercion (for contrast):

"5" + 5 gives "55" (number to string)
"5" - 3 gives 2 (string to number)
[] + {} gives "[object Object]" (nonsense)

Pseudo Code

Python (strong typing):
  "5" + 5 -> TypeError (no coercion)
  5 + 3.0 -> 8.0 (numeric promotion only)
  True + 1 -> 2 (bool is int subclass)

JavaScript (weak typing):
  "5" + 5 -> "55" (coerces number to string)
  "5" - 3 -> 2 (coerces string to number)

Code

# Python: limited, safe coercion
print(5 + 3.0)      # 8.0 (int promoted to float)
print(True + 1)     # 2 (bool is a subclass of int)
print(True + 0.5)   # 1.5 (bool -> int -> float)

# Python REFUSES unsafe coercion
try:
    result = "5" + 5
except TypeError as e:
    print(f"Error: {e}")  # can only concatenate str (not "int") to str

try:
    result = "10" > 5
except TypeError as e:
    print(f"Error: {e}")  # '>' not supported between str and int

# You must explicitly convert
print(int("5") + 5)    # 10
print("5" + str(5))    # '55'

# Numeric tower: int -> float -> complex
print(type(1 + 1.0))       # <class 'float'>
print(type(1 + 1j))        # <class 'complex'>
print(type(1.0 + 1j))      # <class 'complex'>

# Truthiness is NOT coercion -- it's a protocol (__bool__)
if "hello":    # calls bool("hello") implicitly
    print("truthy")

if not []:
    print("empty list is falsy")

8.0
2
1.5
Error: can only concatenate str (not "int") to str
Error: '>' not supported between instances of 'str' and 'int'
10
55
<class 'float'>
<class 'complex'>
<class 'complex'>
truthy
empty list is falsy

Key Points

•Python is strongly typed: minimal implicit coercion
•Only numeric types coerce automatically: int -> float -> complex
•String + int raises TypeError, unlike JavaScript
•You must explicitly convert types with int(), str(), float()
•Truthiness in boolean context is a protocol, not coercion

Gotchas

•Python's bool is an int subclass, so True + True = 2 is technically valid
•'5' * 3 gives '555' (repetition), not 15 -- this is not coercion, it is string repetition
•Truthiness checks in if/while are NOT type coercion -- they call __bool__
•sorted() can compare strings to strings but not strings to ints

Python is strongly typed: it only coerces between numeric types (int + float -> float). Unlike JavaScript, "5" + 5 raises TypeError. You must explicitly convert with int(), str(), etc.

•Python only coerces between numeric types automatically
•Must explicitly convert with int(), str(), float()

print(5 + 3.0)   # 8.0 (numeric promotion OK)

try:
    "5" + 5
except TypeError:
    print("Python refuses to coerce str + int")

print(int("5") + 5)  # 10 (explicit conversion)

8.0
Python refuses to coerce str + int
10

'5' * 3 gives '555' -- this is repetition, not coercion

Question 11 / 15

How does variable assignment work in Python? What does it mean that variables are 'names'?

In Python, variables are names (or labels) that reference objects in memory. Assignment does NOT copy data -- it binds a name to an object.

This is fundamentally different from languages like C, where a variable is a fixed memory location that holds a value.

Python's model:

Objects exist in memory (heap)
Names are entries in a namespace (dictionary)
Assignment (=) binds a name to an object
Multiple names can refer to the same object
Reassignment rebinds the name, it does not modify the object

Multiple assignment:

a = b = c = 0 -- all three names point to the same object
a, b = 1, 2 -- tuple unpacking
a, b = b, a -- swap without a temp variable

Augmented assignment:

x += 1 for immutable types creates a new object and rebinds
lst += [4] for mutable types modifies in-place (calls __iadd__)

Pseudo Code

x = 42
  1. Python creates an int object with value 42
  2. Python binds the name 'x' to that object

y = x
  1. Python binds 'y' to the SAME object x points to
  2. No copying occurs

x = 99
  1. Python creates an int object with value 99
  2. Python rebinds 'x' to the new object
  3. 'y' still points to 42

Code

# Assignment binds a name to an object
x = [1, 2, 3]
y = x          # y is ANOTHER NAME for the same list
print(x is y)  # True -- same object

y.append(4)
print(x)  # [1, 2, 3, 4] -- x sees the change because it's the same object

# Reassignment rebinds the name
a = 42
b = a
print(a is b)  # True

a = 99         # rebinds 'a', does NOT modify the int 42
print(b)       # 42 -- b still points to the old object

# Multiple assignment
x = y = z = []   # ALL point to the SAME list
x.append(1)
print(y)          # [1] -- same list!

# Tuple unpacking
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

# Swap without temp variable
a, b = 1, 2
a, b = b, a
print(a, b)  # 2 1

# Augmented assignment with immutable types
x = 5
print(id(x))
x += 1        # creates new int(6), rebinds x
print(id(x))  # different id!

# Augmented assignment with mutable types
lst = [1, 2]
print(id(lst))
lst += [3]    # calls __iadd__, modifies in place
print(id(lst))  # SAME id
print(lst)      # [1, 2, 3]

True
[1, 2, 3, 4]
True
42
[1]
1 2 3
2 1
4308606784
4308606816
4381367872
4381367872
[1, 2, 3]

Key Points

•Variables are names (references) bound to objects, not memory boxes
•Assignment binds a name to an object, it does not copy
•Multiple names can reference the same object
•Reassignment rebinds the name, it does not modify the object
•a, b = b, a swaps values without a temporary variable

Gotchas

•x = y = [] makes both point to the SAME list -- mutations via one name affect the other
•x += 1 for int creates a new object; lst += [1] for list modifies in place
•Passing a mutable object to a function passes the reference, not a copy
•del x removes the name, not the object -- the object is garbage collected when no names reference it

Python variables are names (labels) bound to objects, not boxes holding values. x = 42 binds the name x to an int object. y = x makes y point to the same object. Reassignment rebinds the name; it does not modify the object.

•Variables are name bindings, not memory boxes
•Assignment does not copy, it creates another reference

x = [1, 2, 3]
y = x          # same object
y.append(4)
print(x)       # [1, 2, 3, 4] -- x sees the change

a = 42
b = a
a = 99
print(b)       # 42 -- b still points to old object

[1, 2, 3, 4]
42

x = y = [] makes both names reference the SAME list

Question 12 / 15

What are Python's None type and its common uses?

None is Python's null value. It is the sole instance of NoneType and is a singleton -- there is only ever one None object in a Python process.

Common uses:

Default return value: Functions without an explicit return return None
Default argument sentinel: def f(x=None) to detect missing arguments
Placeholder / uninitialized: result = None before assignment in a loop
Optional values: Representing the absence of a value

Checking for None:

Always use is None or is not None, never == None
is checks identity (fast, unambiguous)
== calls __eq__ which can be overridden

Truthiness:

None is falsy: bool(None) is False
But if x is None is preferred over if not x when you specifically need to check for None (because 0, "", [] are also falsy)

Pseudo Code

1. None is a singleton (only one instance exists)
2. Functions without return -> return None
3. Always check with 'is None', never '== None'
4. None is falsy but 'if not x' also catches 0, '', []
5. Use None as sentinel for optional parameters

Code

# None is the sole instance of NoneType
print(type(None))       # <class 'NoneType'>
print(None is None)     # True (singleton)

# Functions without explicit return
def greet(name):
    print(f"Hello, {name}")

result = greet("Alice")  # prints "Hello, Alice"
print(result)            # None
print(result is None)    # True

# None as default argument sentinel
def process(data=None):
    if data is None:
        data = []   # create fresh list each call
    data.append(1)
    return data

print(process())       # [1]
print(process())       # [1] (fresh list each time)
print(process([5, 6]))  # [5, 6, 1]

# None is falsy, but be specific
x = None
y = 0
z = ""

# All are falsy
print(bool(x), bool(y), bool(z))  # False False False

# If you specifically need to check for None:
if x is None:
    print("x is None")  # this fires

# 'if not x' would also match 0 and "" -- too broad
for val in [None, 0, "", [], False]:
    if val is None:
        print(f"{val!r} is None")
    elif not val:
        print(f"{val!r} is falsy but not None")

# None in type hints
from typing import Optional

def find_user(user_id: int) -> Optional[str]:
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)  # returns None if not found

print(find_user(1))  # Alice
print(find_user(3))  # None

<class 'NoneType'>
True
Hello, Alice
None
True
[1]
[1]
[5, 6, 1]
False False False
x is None
None is None
0 is falsy but not None
'' is falsy but not None
[] is falsy but not None
False is falsy but not None
Alice
None

Key Points

•None is a singleton -- there is exactly one None object
•Always use 'is None', never '== None'
•Functions without a return statement return None
•None is falsy but 'if not x' catches other falsy values too
•Use None as sentinel for mutable default arguments

Gotchas

•'if not x' is True for None, 0, '', [], {}, set(), False -- too broad for None-checking
•None is not the same as False, 0, or '' -- use 'is None' to distinguish
•You cannot add attributes to None or subclass NoneType
•repr(None) is 'None' (string), not None (the object)

None is Python's null, a singleton of NoneType. Always check with is None. Functions without return give None. Use None as a sentinel for optional parameters.

•None is a singleton; use 'is None' to check
•Functions without return give None

def f():
    pass

print(f() is None)  # True

x = None
if x is None:       # correct way to check
    print("absent")

True
absent

'if not x' catches 0, '', [] too -- not specific enough for None

Question 13 / 15

What is the difference between deep copy and shallow copy?

When you copy a compound object (like a list of lists), there are two levels of copying:

Shallow copy: Creates a new outer container but the elements inside are references to the same objects as the original. Changes to nested mutable objects are visible through both copies.

Deep copy: Creates a new outer container AND recursively copies all nested objects. The copy is completely independent.

Ways to make a shallow copy:

list.copy() or dict.copy()
Slice: lst[:]
list(original) or dict(original)
copy.copy(obj)

Ways to make a deep copy:

copy.deepcopy(obj)

When it matters: The difference only matters when you have nested mutable objects. For flat lists of immutable items, shallow copy is sufficient.

Pseudo Code

Shallow copy:
  new = copy(original)
  new is not original (different outer object)
  new[i] is original[i] (same inner objects)

Deep copy:
  new = deepcopy(original)
  new is not original (different outer object)
  new[i] is not original[i] (different inner objects too)

Code

import copy

# Shallow copy -- nested objects are shared
original = [[1, 2], [3, 4], [5, 6]]
shallow = copy.copy(original)

print(original is shallow)       # False (different outer list)
print(original[0] is shallow[0]) # True (same inner list!)

# Modifying a nested object affects both
shallow[0].append(99)
print(original)  # [[1, 2, 99], [3, 4], [5, 6]] -- original changed!
print(shallow)   # [[1, 2, 99], [3, 4], [5, 6]]

# Deep copy -- completely independent
original = [[1, 2], [3, 4], [5, 6]]
deep = copy.deepcopy(original)

print(original[0] is deep[0])  # False (different inner lists)

deep[0].append(99)
print(original)  # [[1, 2], [3, 4], [5, 6]] -- original unchanged!
print(deep)      # [[1, 2, 99], [3, 4], [5, 6]]

# Various shallow copy methods
lst = [1, 2, 3]
a = lst[:]           # slice
b = list(lst)        # constructor
c = lst.copy()       # method
d = copy.copy(lst)   # copy module

# For flat lists of immutables, shallow copy is fine
lst = [1, 2, 3]
shallow = lst[:]
shallow.append(4)
print(lst)      # [1, 2, 3] -- unchanged (no nested mutables)

# Dict shallow vs deep copy
orig_dict = {"a": [1, 2], "b": [3, 4]}
shallow_dict = orig_dict.copy()
shallow_dict["a"].append(99)
print(orig_dict)  # {'a': [1, 2, 99], 'b': [3, 4]} -- affected!

deep_dict = copy.deepcopy(orig_dict)
deep_dict["a"].append(100)
print(orig_dict)  # {'a': [1, 2, 99], 'b': [3, 4]} -- not affected

False
True
[[1, 2, 99], [3, 4], [5, 6]]
[[1, 2, 99], [3, 4], [5, 6]]
False
[[1, 2], [3, 4], [5, 6]]
[[1, 2, 99], [3, 4], [5, 6]]
[1, 2, 3]
{'a': [1, 2, 99], 'b': [3, 4]}
{'a': [1, 2, 99], 'b': [3, 4]}

Key Points

•Shallow copy: new outer container, shared inner references
•Deep copy: fully independent recursive copy
•Shallow copy methods: [:], .copy(), list(), copy.copy()
•Deep copy: only copy.deepcopy()
•Difference only matters for nested mutable objects

Gotchas

•Assignment (b = a) is NOT a copy -- both names reference the same object
•Shallow copy of a list of lists: modifying inner lists affects both
•deepcopy handles circular references correctly
•deepcopy can be slow for large, deeply nested structures
•dict.copy() and list.copy() are shallow -- a common source of bugs

Shallow copy creates a new outer container but inner objects are shared references. Deep copy (copy.deepcopy()) recursively copies everything. The difference matters only for nested mutable objects.

•Shallow: new container, shared inner objects
•Deep: fully independent copy

import copy

original = [[1, 2], [3, 4]]
shallow = original.copy()     # or original[:]
deep = copy.deepcopy(original)

shallow[0].append(99)
print(original)  # [[1, 2, 99], [3, 4]] -- affected!

deep[0].append(100)
print(original)  # [[1, 2, 99], [3, 4]] -- NOT affected

[[1, 2, 99], [3, 4]]
[[1, 2, 99], [3, 4]]

list.copy() and dict.copy() are SHALLOW -- nested mutables are shared

Question 14 / 15

How do you check if a variable is of a certain type in Python?

There are several ways to check types in Python, from most to least recommended:

1. isinstance() -- recommended: Respects inheritance, accepts tuples for OR checks.

2. type() comparison -- discouraged: Exact match only, does not respect inheritance.

3. Duck typing -- Pythonic: Do not check the type at all. Try the operation and handle exceptions (EAFP).

4. hasattr() -- structural check: Check if an object has a specific attribute or method.

5. Abstract Base Classes (ABCs): Check if an object implements a protocol (e.g., isinstance(obj, Iterable)).

The most Pythonic approach is often to NOT check types at all (duck typing). If you must check, use isinstance(). Use type hints + mypy for compile-time safety without runtime checks.

Pseudo Code

Best to worst:
1. Duck typing: just try the operation (EAFP)
2. isinstance(obj, Type) -- respects inheritance
3. isinstance(obj, (Type1, Type2)) -- OR check
4. isinstance(obj, ABC) -- protocol check
5. hasattr(obj, 'method') -- structural check
6. type(obj) == Type -- exact match (discouraged)

Code

# isinstance() -- recommended
print(isinstance(42, int))           # True
print(isinstance(42, (int, float)))  # True (OR check)
print(isinstance(True, int))         # True (bool subclasses int)

# type() -- exact match, discouraged
print(type(42) == int)     # True
print(type(True) == int)   # False (exact match only)

# Duck typing -- most Pythonic
def get_length(obj):
    try:
        return len(obj)
    except TypeError:
        return None

print(get_length([1, 2, 3]))  # 3
print(get_length("hello"))    # 5
print(get_length(42))         # None

# hasattr() -- structural check
def is_iterable(obj):
    return hasattr(obj, '__iter__')

print(is_iterable([1, 2]))   # True
print(is_iterable("hello"))  # True
print(is_iterable(42))       # False

# Abstract Base Classes
from collections.abc import Iterable, Mapping, Sequence

print(isinstance([1, 2], Sequence))   # True
print(isinstance({"a": 1}, Mapping))  # True
print(isinstance(range(10), Iterable))  # True
print(isinstance(42, Iterable))       # False

# Type hints + runtime checking
from typing import get_type_hints

def add(a: int, b: int) -> int:
    if not isinstance(a, int) or not isinstance(b, int):
        raise TypeError(f"Expected int, got {type(a).__name__} and {type(b).__name__}")
    return a + b

print(add(3, 4))  # 7
try:
    add("3", 4)
except TypeError as e:
    print(f"Error: {e}")  # Expected int, got str and int

True
True
True
True
False
3
5
None
True
True
False
True
True
True
False
7
Error: Expected int, got str and int

Key Points

•isinstance() is the standard way to check types
•isinstance() respects inheritance and accepts tuples
•Duck typing (EAFP) is the most Pythonic approach
•collections.abc provides abstract base classes for protocol checks
•Type hints provide compile-time checking without runtime overhead

Gotchas

•Overusing type checks goes against Python's duck typing philosophy
•isinstance(True, int) is True -- bool is a subclass of int
•type() does not work with ABCs or virtual subclasses
•hasattr() can trigger property getters or __getattr__ -- may have side effects

Use isinstance(obj, Type) for type checking -- it respects inheritance and accepts a tuple of types. The most Pythonic approach is duck typing: do not check types, just try the operation. Use collections.abc for protocol checks.

•Use isinstance() for type checks
•Duck typing is most Pythonic

print(isinstance(42, int))           # True
print(isinstance(42, (int, float)))  # True

from collections.abc import Iterable
print(isinstance([1,2], Iterable))   # True

True
True
True

isinstance(True, int) returns True because bool subclasses int

Question 15 / 15

What are Python's numeric precision limits and how do you handle large numbers?

Integers (int): Python integers have arbitrary precision -- they can be as large as your memory allows. There is NO integer overflow in Python. This is different from C/Java where integers have fixed sizes (32/64 bit).

Floats (float): Python floats are IEEE 754 double precision (64-bit), giving:

About 15-17 significant decimal digits
Range: approximately 1.8 x 10^308 to 5 x 10^-324
Special values: float('inf'), float('-inf'), float('nan')

Decimal: For arbitrary decimal precision, use decimal.Decimal with configurable precision.

Performance note: Arbitrary-precision integers are slower than fixed-size integers. For very large numbers (thousands of digits), operations become noticeably slower.

Pseudo Code

int: arbitrary precision, no overflow
float: 64-bit IEEE 754, ~15-17 digits, can overflow to inf
Decimal: configurable precision, slower but exact
Fraction: exact rational numbers

sys.maxsize: largest native int (platform word size)
sys.float_info: float limits

Code

import sys

# Integers have arbitrary precision
big = 10 ** 100  # googol
print(big)  # 10000...0000 (101 digits)
print(type(big))  # <class 'int'>

# No overflow!
print(2 ** 1000)  # huge number, works fine
print(len(str(2 ** 1000)))  # 302 digits

# sys.maxsize is NOT the max integer -- it's the max native int
print(sys.maxsize)  # 9223372036854775807 on 64-bit
print(sys.maxsize + 1)  # works fine, Python auto-promotes

# Float limits
print(sys.float_info.max)    # 1.7976931348623157e+308
print(sys.float_info.min)    # 2.2250738585072014e-308
print(sys.float_info.epsilon)  # 2.220446049250313e-16

# Float overflow
print(1e308)      # 1e+308
print(1e309)      # inf
print(-1e309)     # -inf

# Special float values
print(float('inf') > 1e308)   # True
print(float('nan') == float('nan'))  # False! NaN != NaN

import math
print(math.isinf(float('inf')))  # True
print(math.isnan(float('nan')))  # True

# Decimal for configurable precision
from decimal import Decimal, getcontext
getcontext().prec = 50  # 50 significant digits
result = Decimal(1) / Decimal(7)
print(result)  # 0.14285714285714285714285714285714285714285714285714

# Integer arithmetic for avoiding float issues
# Store cents instead of dollars
price_cents = 1999  # $19.99
tax_cents = int(price_cents * 0.08)  # 8% tax
total_cents = price_cents + tax_cents
print(f"${total_cents / 100:.2f}")  # $21.59

10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
<class 'int'>
10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376
302
9223372036854775807
9223372036854775808
1.7976931348623157e+308
2.2250738585072014e-308
2.220446049250313e-16
1e+308
inf
-inf
True
False
True
True
0.14285714285714285714285714285714285714285714285714
$21.58

Key Points

•Python integers have arbitrary precision -- no overflow
•Floats are 64-bit IEEE 754 with ~15-17 digits of precision
•sys.maxsize is the max native int size, not the max Python int
•Float overflow gives inf, not an error
•NaN is not equal to itself: float('nan') != float('nan')

Gotchas

•sys.maxsize is NOT the maximum integer -- Python ints are unbounded
•Large integer arithmetic is slower than native int operations
•float('nan') != float('nan') -- always use math.isnan() to check
•int to float conversion can lose precision for very large ints: float(10**20) loses precision
•1e309 silently becomes inf instead of raising an error

Python integers have arbitrary precision -- no overflow. Floats are 64-bit IEEE 754 (~15 digits). Floats overflow to inf. Use decimal.Decimal for exact decimal arithmetic.

•Python ints are arbitrary precision -- no overflow
•Floats overflow to inf, not an error

print(2 ** 1000)   # works! 302-digit number
print(1e309)       # inf (float overflow)

import math
print(math.isnan(float('nan')))  # True
print(math.isinf(float('inf')))  # True

10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376
inf
True
True

float('nan') != float('nan') -- always use math.isnan()

Built by onllm.dev

Home GitHub Support awesomePrep