Types and Variables

Every value in Python is an object with a type, and every variable is a name bound to one of those objects. Getting that model right early explains almost every surprising behaviour you will meet later.

Numbers

int — arbitrary precision

Python integers have no fixed width. They grow to whatever memory allows, so there is no overflow and no int64 ceiling.

2 ** 1000
# => a 302-digit number, exactly correct

import sys
sys.maxsize          # => 9223372036854775807 — the largest *index*, not the largest int

Integer literals accept underscores for readability and prefixes for other bases:

1_000_000        # => 1000000
0b1010           # binary   => 10
0o755            # octal    => 493
0xFF             # hex      => 255

Division is where Python differs most from C-family languages:

7 / 2      # => 3.5    true division, ALWAYS returns a float
7 // 2     # => 3      floor division
-7 // 2    # => -4     floors toward negative infinity, not toward zero
7 % 3      # => 1
-7 % 3     # => 2      the result takes the sign of the divisor
divmod(7, 2)   # => (3, 1)
2 ** 10        # => 1024

Caution

// and % floor; they do not truncate. -7 // 2 is -4, not -3. If you want truncation use int(-7 / 2) — but note that goes through a float and loses precision for huge values. math.trunc() and math.fmod() give C semantics.

float — IEEE 754 doubles

Floats are 64-bit binary doubles, with all the usual consequences.

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

This is not a Python bug; 0.1 has no exact binary representation. Compare floats with a tolerance:

import math
math.isclose(0.1 + 0.2, 0.3)              # => True
math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)

Special values and useful helpers:

float("inf"), float("-inf"), float("nan")
math.isnan(float("nan"))    # => True
float("nan") == float("nan")  # => False — NaN equals nothing, including itself

round(2.675, 2)   # => 2.67  (2.675 is really 2.67499...)
round(0.5)        # => 0     banker's rounding: ties go to even
round(1.5)        # => 2

For money and anywhere exactness matters, use decimal; for exact ratios use fractions:

from decimal import Decimal
Decimal("0.1") + Decimal("0.2")   # => Decimal('0.3')

from fractions import Fraction
Fraction(1, 3) + Fraction(1, 6)   # => Fraction(1, 2)

Danger

Always construct Decimal from a string. Decimal(0.1) inherits the float’s error and gives Decimal('0.1000000000000000055511151231257827021181583404541015625').

complex

Built in, with a j suffix for the imaginary part. Rarely needed outside numeric work, but it exists.

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

bool

bool is a subclass of int. True is 1 and False is 0, and they behave as such in arithmetic.

True + True        # => 2
sum([True, False, True])   # => 2 — a handy way to count matches
isinstance(True, int)      # => True

Strings

str is an immutable sequence of Unicode code points. Not bytes, not UTF-8 — code points.

s = "café"
len(s)       # => 4 characters, regardless of encoding
s[3]         # => 'é'

Literals

'single'
"double"                 # identical; pick one per project
"""triple quoted
spans lines"""
"implicit" " concatenation"     # => 'implicit concatenation'
r"C:\new\table"          # raw: backslashes are literal — essential for regex
b"bytes literal"         # a bytes object, not a str

Immutability

You cannot modify a string in place. Every “modification” builds a new object.

s = "hello"
s[0] = "H"     # TypeError: 'str' object does not support item assignment
s = "H" + s[1:]   # => 'Hello' — a new string

Tip

Building a string in a loop with += is O(n²) in principle. Collect the parts and join once:

parts = [str(n) for n in range(1000)]
result = ",".join(parts)

Indexing and slicing

Slicing is s[start:stop:step] — start inclusive, stop exclusive. Negative indices count from the end. Out-of-range slices clamp instead of raising.

s = "abcdefg"
s[0]      # => 'a'
s[-1]     # => 'g'
s[1:4]    # => 'bcd'
s[:3]     # => 'abc'
s[3:]     # => 'defg'
s[::2]    # => 'aceg'
s[::-1]   # => 'gfedcba'   the idiomatic reverse
s[100]    # IndexError
s[100:]   # => ''          slices never raise

The same slicing rules apply to lists, tuples, and every other sequence.

Methods worth knowing

All of these return new strings; none mutate.

"  pad  ".strip()            # => 'pad'   (also lstrip, rstrip)
"a,b,c".split(",")           # => ['a', 'b', 'c']
"a b  c".split()             # => ['a', 'b', 'c']  — no arg splits on any whitespace run
"-".join(["a", "b"])         # => 'a-b'
"Hello".lower()              # => 'hello'   (also .upper(), .casefold())
"hello world".title()        # => 'Hello World'
"hello".replace("l", "L")    # => 'heLLo'
"hello".startswith("he")     # => True   (also endswith; both accept a tuple)
"hello".find("z")            # => -1
"hello".index("z")           # ValueError
"a1".isdigit(), "ab".isalpha(), "  ".isspace()
"file.txt".removesuffix(".txt")   # => 'file'   (3.9+; also removeprefix)
"line\n".splitlines()        # => ['line']
"%05.2f" % 3.14159           # legacy formatting, still seen

Caution

str.strip("abc") strips any of the characters a, b, c from both ends — it is not a substring removal. That is what removeprefix/removesuffix (Python 3.9+) are for.

f-strings

Introduced in 3.6, f-strings are the default way to build strings. The expression inside the braces is evaluated at runtime.

name, count = "Ada", 3
f"{name} has {count} items"
f"{count * 2}"                 # any expression
f"{name!r}"                    # => "'Ada'"  — !r calls repr(), !s calls str()
f"{3.14159:.2f}"               # => '3.14'
f"{1234567:,}"                 # => '1,234,567'
f"{42:>8}"                     # right-align in 8 columns
f"{42:08b}"                    # => '00101010'  binary, zero-padded
f"{0.256:.1%}"                 # => '25.6%'
f"{name=}"                     # => "name='Ada'"  — self-documenting, 3.8+

Format specs are shared with format() and str.format(): [[fill]align][sign][#][0][width][,][.precision][type].

Python 3.12 relaxed f-string parsing (PEP 701): you may now reuse the same quote character inside, nest arbitrarily, and include backslashes.

# Valid only on 3.12+
f"{d["key"]}"
f"{'\n'.join(items)}"

Caution

On 3.11 and earlier, both of those are syntax errors. If your code must run on older versions, assign to a temporary variable first.

Danger

Never build SQL or shell commands with f-strings. f"SELECT * FROM t WHERE id = {user_input}" is an injection hole. Use parameterised queries and subprocess argument lists instead.

str vs bytes

str is text. bytes is binary data. Converting between them requires an encoding, and Python refuses to guess.

text = "café"
data = text.encode("utf-8")      # => b'caf\xc3\xa9'  — str -> bytes
len(data)                        # => 5 bytes for 4 characters
data.decode("utf-8")             # => 'café'          — bytes -> str

b"abc" + "def"    # TypeError: can't concat str to bytes

Bytes are a sequence of integers 0–255:

data[0]        # => 99  (an int, not a 1-byte object)
data[0:1]      # => b'c'

The rule of thumb, sometimes called the Unicode sandwich: decode bytes to str at the boundary of your program, work in str internally, encode back to bytes on the way out. Files opened in text mode do this for you:

open("f.txt", "r", encoding="utf-8")   # yields str
open("f.bin", "rb")                    # yields bytes

Caution

Always pass encoding= explicitly when opening text files. Without it Python uses the platform default, which is UTF-8 on modern Linux/macOS but was historically cp1252 on Windows — a classic source of “works on my machine”. Python 3.15 will change the default to UTF-8 (PEP 686); until then, be explicit.

None

None is the single instance of NoneType. It means “no value” and is what a function returns when it has no return.

def f():
    pass

f() is None      # => True

Test with is, never ==:

if value is None: ...
if value is not None: ...

Caution

if not value: is not the same as if value is None:. Empty strings, 0, and empty lists are all falsy but are not None. Using the wrong one silently mishandles legitimate empty values.

Variables are names, not boxes

A Python variable is a name bound to an object. Assignment never copies a value; it points a name at an object.

a = [1, 2, 3]
b = a          # b names the SAME list
b.append(4)
a              # => [1, 2, 3, 4]

Rebinding a name affects only that name:

a = [1, 2, 3]
b = a
b = [9]        # b now names a different list
a              # => [1, 2, 3]

This is why mutable objects (list, dict, set, most class instances) behave differently from immutable ones (int, float, str, tuple, frozenset, bytes). With an immutable object there is no way to observe sharing, so you never notice.

x = 5
y = x
y += 1     # rebinds y to a new int object
x          # => 5

id() shows an object’s identity (in CPython, its memory address):

a = [1]
b = a
id(a) == id(b)   # => True

Multiple assignment and unpacking

a, b = 1, 2
a, b = b, a               # swap; no temporary needed
x = y = z = 0             # all three name the same object

first, *rest = [1, 2, 3, 4]      # first=1, rest=[2, 3, 4]
*init, last = [1, 2, 3, 4]       # init=[1, 2, 3], last=4
(a, b), c = (1, 2), 3            # nested
for i, (k, v) in enumerate(d.items()): ...

Caution

x = y = [] binds one list to both names. Mutating through x is visible through y. Chained assignment is safe only for immutables.

Truthiness

Every object is usable in a boolean context. These are falsy — everything else is truthy:

• None, False
• Zero of any numeric type: 0, 0.0, 0j, Decimal(0)
• Empty containers: "", [], (), {}, set(), range(0)
• Objects whose __bool__ returns False, or whose __len__ returns 0

if items:            # idiomatic "not empty"
    ...
if not name:         # idiomatic "empty or None"
    ...

and and or short-circuit and return one of the operands, not a bool:

0 or "default"      # => 'default'
"a" and "b"         # => 'b'
None or 0 or []     # => []  — the last operand when all are falsy

name = user_input or "anonymous"   # common default idiom

Caution

x or default treats 0, "", and False as missing. If those are valid values, test explicitly: x if x is not None else default.

is vs ==

• == asks are these equal? and calls __eq__.
• is asks are these the same object? and compares identities.

a = [1, 2]
b = [1, 2]
a == b     # => True   same contents
a is b     # => False  two distinct list objects

Use is only for singletons: None, True, False, and sentinel objects you create yourself.

MISSING = object()          # a unique sentinel

def get(d, key, default=MISSING):
    if default is MISSING:
        ...

Danger

Small integers and short strings are cached and reused by CPython, so 256 is 256 is True while 1000 is 1000 may be False depending on context. This is an implementation detail. Comparing values with is is a bug even when it appears to work — Python 3.8+ emits a SyntaxWarning for is with a literal.

Inspecting types

type(3)                  # => <class 'int'>
type(3) is int           # => True — exact type, no subclasses

isinstance(True, int)    # => True — subclasses count
isinstance(x, (int, float))          # a tuple means "any of these"
isinstance(x, int | float)           # 3.10+ union syntax works too

issubclass(bool, int)    # => True

Prefer isinstance over type(x) == ...; it respects inheritance, which is almost always what you want. Better still, prefer duck typing — try the operation and handle failure — over type checks. See EAFP vs LBYL.

Conversions

Constructors do the converting, and they raise rather than guess:

int("42")        # => 42
int("1010", 2)   # => 10     parse with an explicit base
int("ff", 16)    # => 255
int("3.9")       # ValueError — int() does not parse floats from strings
int(3.9)         # => 3      truncates toward zero
float("1e3")     # => 1000.0
str(42)          # => '42'
list("abc")      # => ['a', 'b', 'c']
bool("False")    # => True — any non-empty string is truthy

Key points

• int is unbounded; / always returns a float; // and % floor.
• Floats are IEEE doubles — compare with math.isclose, use Decimal("...") for money.
• bool is an int subclass, which makes sum(conditions) a counting idiom.
• str holds code points; bytes holds octets; encode/decode bridge them, always with an explicit encoding.
• Strings are immutable — join a list rather than += in a loop.
• Variables are names bound to objects; assignment never copies.
• == compares values, is compares identity — use is only for None and sentinels.
• or/and return operands, not booleans, and short-circuit.