
A Python `str` is an immutable sequence of Unicode code points - not bytes. The separate `bytes` type holds raw binary data. Converting between them requires an explicit `.encode()` call (str to bytes) or `.decode()` call (bytes to str), and you must name the encoding each time.

<ExamplePair>
<ExampleProse>

f-strings (formatted string literals) embed expressions directly inside `{}`. They support Python's full format-spec syntax for alignment, padding, and number formatting - the same spec used by `format()` and `str.format()`.

</ExampleProse>
<ExampleCode>

```python
name = "Ada"
f"Hello, {name}!"         # 'Hello, Ada!'

value = 3.14159
f"{value:.2f}"            # '3.14'  (2 decimal places)

n = 42
f"{n:>10}"                # '        42'  (right-aligned in 10 chars)
f"{n:0>10}"               # '0000000042'  (zero-padded)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`str` and `bytes` are separate types and Python never converts between them automatically. `.encode(encoding)` produces `bytes`; `.decode(encoding)` produces `str`. If the bytes do not match the encoding you name, Python raises `UnicodeDecodeError` - pass `errors="replace"` to substitute replacement characters instead of crashing.

</ExampleProse>
<ExampleCode>

```python
s = "héllo"
b = s.encode("utf-8")       # b'h\xc3\xa9llo'  (5 chars -> 6 bytes)

b.decode("utf-8")            # 'héllo'

# Wrong codec raises UnicodeDecodeError
b.decode("ascii")            # UnicodeDecodeError: invalid start byte

# Safety valve: replace undecodable bytes with the replacement character
b.decode("ascii", errors="replace")   # 'h��llo'
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`len(s)` counts Unicode code points, not characters as humans perceive them (graphemes). A single visible character can be multiple code points when combining marks are used - for example, the letter `a` followed by a combining accent. Naive slicing can split a grapheme in the middle. Normalising with `unicodedata.normalize("NFC", s)` folds as many combining sequences as possible into single composed code points before slicing or comparing.

</ExampleProse>
<ExampleCode>

```python
import unicodedata

# 'a' + combining acute accent = two code points, one visible character
composed = "á"          # á  (precomposed, 1 code point)
decomposed = "á"       # a + combining acute, 2 code points

len(composed)                # 1
len(decomposed)              # 2

# Normalize to NFC before comparing or slicing user input
unicodedata.normalize("NFC", decomposed) == composed   # True
```

</ExampleCode>
</ExamplePair>

<InProduction>
f-strings evaluate arbitrary expressions inside `{...}` - never format untrusted input as if it were a template string; use `str.format_map` with a restricted mapping, or better, keep user input as data rather than embedding it in format strings. `len(s)` counts code points, not graphemes - naive slicing of user input with emoji or combining marks produces mojibake; normalise with `unicodedata.normalize("NFC", s)` or reach for the `regex` package before truncating display strings.
</InProduction>


Python str is an immutable sequence of Unicode code points, not bytes. Encoding, f-strings, and grapheme-aware slicing.

Strings


A Python `bool` is one of two values: `True` or `False`. Comparisons (`==`, `<`, `in`) and logical operators (`and`, `or`, `not`) produce booleans. Beyond the two bool literals, many other values behave as true or false in a boolean context - this is called "truthiness."

<ExamplePair>
<ExampleProse>

`bool(x)` converts any value to its boolean equivalent. The falsy values are: `0`, `0.0`, `""`, `b""`, `[]`, `()`, `{}`, `set()`, and `None`. Every other value is truthy. You can rely on this in `if` conditions without calling `bool()` explicitly.

</ExampleProse>
<ExampleCode>

```python
# All falsy
bool(0)     # False
bool("")    # False
bool([])    # False
bool({})    # False
bool(None)  # False

# All truthy
bool(1)         # True
bool("hello")   # True
bool([0])       # True  - a list with one item, even if the item is 0
bool(0.001)     # True
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`and` and `or` do not necessarily return `True` or `False` - they return one of their operands. `or` returns the first truthy operand (or the last operand if all are falsy). `and` returns the first falsy operand (or the last operand if all are truthy). This short-circuit behaviour is useful for defaults, but it also creates a common footgun.

</ExampleProse>
<ExampleCode>

```python
# or returns the first truthy value
0 or "fallback"         # 'fallback'
"primary" or "fallback" # 'primary'
[] or [1, 2]            # [1, 2]

# and returns the first falsy value
1 and 2                 # 2   (all truthy, returns last)
0 and "unreachable"     # 0   (0 is falsy, short-circuits)

# Footgun: silently uses the fallback when 0 or "" is a valid value
count = 0
display = count or "no items"   # 'no items' -- wrong when count is a valid 0
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`is` checks identity - whether two names refer to the same object in memory. `==` checks value equality. For `None`, `is` is the canonical idiom and is faster. For `True` and `False`, use truthiness (`if x:`) rather than `is True` or `is False` - they are fragile if the value is a truthy non-bool.

</ExampleProse>
<ExampleCode>

```python
x = None
x is None       # True  - canonical None check
x == None       # True  - works, but non-idiomatic

# is True / is False are footguns
result = 1      # truthy, but not the bool True
result == True  # True
result is True  # False  - 1 and True are different objects

# Prefer plain truthiness checks
if result:       # idiomatic - "do I have a value?"
    pass
if result is not None:  # idiomatic - "was something provided?"
    pass
```

</ExampleCode>
</ExamplePair>

<InProduction>
`if my_list:` treats empty containers as false - convenient for "do I have items?", but catastrophic when `0`, `""`, or `[]` is a legitimate value (a counter starting at zero, an empty form field, a response body that is intentionally empty). Use `if x is not None:` when the distinction between "absent" and "falsy but present" matters. `and`/`or` return operands not booleans, so `default = config_value or "fallback"` silently uses the fallback for `0`, `""`, and `[]`.
</InProduction>


Python bool - True and False, truthy and falsy values, short-circuit operators, and when to use is vs ==.

Booleans and Truthiness


Python has three built-in numeric types: `int` (arbitrary precision - no overflow), `float` (IEEE 754 double), and `complex`. The standard library adds `decimal.Decimal` for exact decimal arithmetic and `fractions.Fraction` for rational numbers.

<ExamplePair>
<ExampleProse>

`int` in Python has no fixed size, so it never overflows. Integer division uses `//`, the remainder operator is `%`, and `pow(base, exp, mod)` computes modular exponentiation efficiently without building a huge intermediate number.

</ExampleProse>
<ExampleCode>

```python
2 ** 100          # 1267650600228229401496703205376 - exact, no overflow

10 // 3           # 3  (integer division, rounds toward negative infinity)
10 % 3            # 1  (remainder)

pow(2, 10, 1000)  # 24  (2**10 mod 1000, fast even for huge exponents)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`float` uses IEEE 754 binary representation, which cannot represent most decimal fractions exactly. The classic example: `0.1 + 0.2` is not `0.3`. Use `math.isclose(a, b)` when comparing floats by tolerance rather than exact equality.

</ExampleProse>
<ExampleCode>

```python
import math

0.1 + 0.2           # 0.30000000000000004
0.1 + 0.2 == 0.3    # False

math.isclose(0.1 + 0.2, 0.3)           # True  (relative tolerance 1e-9)
math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-6)  # True
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`decimal.Decimal` stores numbers as exact decimal fractions - the same way humans write them. This makes it the right choice for money and accounting, where rounding rules matter. Pass values as strings to avoid inheriting float imprecision at construction time.

</ExampleProse>
<ExampleCode>

```python
from decimal import Decimal, ROUND_HALF_EVEN, getcontext

Decimal("0.1") + Decimal("0.2")   # Decimal('0.3')  - exact

# Set rounding mode for the current thread's context
getcontext().rounding = ROUND_HALF_EVEN

price = Decimal("19.995")
price.quantize(Decimal("0.01"))   # Decimal('20.00')  - banker's rounding
```

</ExampleCode>
</ExamplePair>

<InProduction>
Never store monetary values as `float` - `0.1 + 0.2 != 0.3` ships production bugs that staging never catches; use `decimal.Decimal` with an explicit rounding mode (`ROUND_HALF_EVEN` for accounting). The small-integer interning trap means `a is b` returns `True` for integers in roughly -5 to 256 but `False` for larger values; always use `==` for numeric value comparison.
</InProduction>


Python's three numeric types: int (arbitrary precision), float (IEEE 754), and complex - plus Decimal for exact arithmetic.