Language

Data types

Type checks

print(type(42))
print(type(3.14))
print(type("hi"))
print(type([1, 2]))
print(type((1, 2)))
print(type({1, 2}))
print(type({"a": 1}))
print(type(None))
print(type(True))

{}

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

Output

Use isinstance to test whether a value belongs to a type. Constructors such as int, float, str, bool, list, tuple and set double as converters. Builtins lists every conversion.

int(3.7) is 3 and int(-3.7) is -3. The conversion truncates toward zero and never rounds.

Integer

There is one int type with a signed 128-bit range, from -(2**127) to 2**127 - 1. Going out of range raises OverflowError. Limits and errors has the details.

There is no complex type.

big = (2**126 - 1) * 2 + 1
print(big)
try:
  big + 1
except OverflowError:
  print("overflow")

{}

170141183460469231731687303715884105727
overflow

Output

Float

Floats are IEEE-754 doubles. Mixing int and float in arithmetic yields a float.

print(0.1 + 0.2 == 0.3)
print(-0.0 == 0.0)
print(2 + 3.0)

{}

False
True
5.0

Output

round rounds ties to even, see Builtins.

Boolean

bool has two values, True and False. It is a subclass of int. Truthy and falsy lists which values count as true.

print(isinstance(True, int))
print(True + True)

{}

True
2

Output

String

A string is an immutable sequence of Unicode code points.

Indexing returns a one-character string.
len counts code points, not bytes.
Iteration yields characters.

s = "héllo"
print(s[0], s[-1])
print(s[1:4])
print(len(s))
print(s + " world")
print(s * 2)
print("ll" in s)

{}

h o
éll
5
héllo world
héllohéllo
True

Output

Syntax covers quotes and escapes. Methods lists the methods.

Bytes

bytes is an immutable sequence of octets, each 0 to 255. It stores raw data, not text. Indexing returns an int, and iteration yields ints.

data = b"hello"
print(data)
print(len(data))
print(data[0])  # int, the byte value
print(data[1:4])  # bytes slice

for byte in b"abc":
  print(byte)

{}

b'hello'
5
104
b'ell'
97
98
99

Output

bytes never equals str, even for valid UTF-8. Non-ASCII characters in a bytes literal are stored as their UTF-8 encoding.

print(b"abc" == "abc")
print(b"é")  # stored as UTF-8

{}

False
b'\xc3\xa9'

Output

Encoding round-trips use str.encode and bytes.decode.

encoded = "Edge Python".encode("utf-8")
print(encoded, encoded.decode("utf-8"))

{}

b'Edge Python' Edge Python

Output

Builtins lists the constructor forms, such as bytes(n) and bytes from an int iterable. Methods covers hex, split, fromhex and the rest.

List

A list is a mutable sequence. Assignment copies the reference. Aliases share mutations.

xs = [1, 2, 3]
xs[0] = 99
xs.append(4)
print(xs)
print(len(xs))

# Aliasing, both names see the mutation
ys = xs
ys.append(5)
print(xs)

{}

[99, 2, 3, 4]
4
[99, 2, 3, 4, 5]

Output

Equality is structural.

print([1, 2, 3] == [1, 2, 3])
print([1, [2, 3]] == [1, [2, 3]])

{}

True
True

Output

Slices change a list in place.

Slice assignment with step 1 resizes the list.
Slice deletion removes a range.
Assigning into an empty slice inserts.

xs = [1, 2, 3, 4, 5]
xs[1:3] = [20, 30, 40]
print(xs)

del xs[2:4]
print(xs)

xs[1:1] = [99]
print(xs)

{}

[1, 20, 30, 40, 4, 5]
[1, 20, 4, 5]
[1, 99, 20, 4, 5]

Output

+= on a list extends it in place. Aliases see the change.

xs = [1, 2, 3]
ys = xs
xs += [4]
print(ys)

{}

[1, 2, 3, 4]

Output

Tuple

A tuple is an immutable sequence. It is hashable when its elements are. That makes it the usual compound dict key.

t = (1, 2, 3)
print(t[0])
print(t + (4, 5))
print({(1, 2): "key"}[(1, 2)])

{}

1
(1, 2, 3, 4, 5)
key

Output

Syntax covers literal forms such as the trailing comma in (1,).

Dict

A dict is a mapping that keeps insertion order.

Keys must be hashable. Numbers, strings, bytes, bools, None, frozensets and tuples of hashables qualify.
An unhashable key raises TypeError.
Numerically equal keys collapse. 1, 1.0 and True are one key, and the latest assignment wins.
Iteration yields keys.

d = {"a": 1, "b": 2}
print(d["a"])
d["c"] = 3
print(d)

e = {1: "int"}
e[1.0] = "float"
e[True] = "bool"
print(e)  # 1, 1.0, and True are one key

for k in {"x": 1, "y": 2}:
  print(k)

{}

1
{'a': 1, 'b': 2, 'c': 3}
{1: 'bool'}
x
y

Output

try:
  d = {[1, 2]: "x"}
except TypeError:
  print("unhashable key")

{}

unhashable key

Output

Methods covers keys, values, items, get and the rest.

Set

A set is an unordered collection of unique, hashable values.

|, &, - and ^ build new sets.
|=, &= and ^= update the set in place. Aliases observe the change.
<= and < test subsets.

s = {1, 2, 2, 3}
s.add(4)
print(len(s))
print(sorted(s))  # set order is arbitrary, sort to compare

# Algebra
print(sorted({1, 2, 3} | {3, 4}))
print(sorted({1, 2, 3} & {2, 3, 4}))
print({1, 2} <= {1, 2, 3})

# Augmented forms mutate in place
t = s
s |= {5}
print(sorted(t))

{}

4
[1, 2, 3, 4]
[1, 2, 3, 4]
[2, 3]
True
[1, 2, 3, 4, 5]

Output

Syntax shows how to write an empty set. Methods covers named operations such as union and issubset.

Frozenset

A frozenset is an immutable, hashable set built with frozenset(iterable).

It supports len, iteration, membership, unpacking, the algebra operators and the subset comparisons.
In mixed set and frozenset algebra the result takes the type of the left operand.
It has no named methods. frozenset({1}).union({2}) raises AttributeError. Convert with set(fs) for the method API.

fs = frozenset({1, 2, 3})
print(len(fs))
print(2 in fs)

a, b, c = fs  # unpacking
print(sorted([a, b, c]))

print(type(fs | {4}))   # left operand wins
print(type({4} | fs))

print(sorted(fs | frozenset({4})))
print(fs <= frozenset({1, 2, 3, 4}))  # subset

print({fs: "ok"}[frozenset({3, 2, 1})])  # hashable, usable as a key

{}

3
True
[1, 2, 3]
<class 'frozenset'>
<class 'set'>
[1, 2, 3, 4]
True
ok

Output

Range

A range is a lazy integer sequence, built with range(stop), range(start, stop) or range(start, stop, step). Builtins has examples.

None and Ellipsis

None is the only value of NoneType. Test for it with is None.

... is the only value of type ellipsis. It compares equal only to itself and is distinct from the string '...'.

print(...)
print(... is ...)
print(type(...))
print(... == '...')

{}

Ellipsis
True
<class 'ellipsis'>
False

Output

Generic aliases

Type parameters, aliases and unions exist at runtime as small values. None of them checks a type.

list[int] is a generic alias. It prints as list[int] and calling it builds a plain list.
class Box[T] keeps its parameters in __type_params__, and Box[int] is a generic alias.
On a class that defines __class_getitem__, C[x] calls it.
def f[T] parses its type parameters and discards them.
type X = v binds a lazy alias. X.__value__ evaluates v when read.
int | None is a union that isinstance accepts.

class Box[T]:
  def __init__(self, v):
    self.v = v

print(Box.__type_params__)
print(Box[int](3).v)
print(list[int], list[int]("ab"))

type Pair = tuple[int, int]
print(Pair.__value__)
print(isinstance(None, int | None))

{}

(T,)
3
list[int] ['a', 'b']
tuple[int, int]
True

Output

Truthy and falsy

These values are falsy. Everything else is truthy.

Falsy values
`None`
`False`
`0`, `0.0`
`""`, `b""`
`[]`, `()`
`{}`, `set()`, `frozenset()`
`range(0)`

for v in [None, 0, "", [], [0], "x"]:
  print(bool(v))

{}

False
False
False
False
True
True

Output

Behavioral notes

Set iteration and repr order. Sets store elements in a hash table. Iteration and repr follow hash order, not insertion order. Sort a set when the order matters.
Every NaN is one value. A NaN is found in a list holding another NaN, and a set keeps a single one, where CPython keeps one per object. Memory model explains why.

print({3, 1, 2})
n = float('nan')
print(n in [float('nan')], len({n, float('nan')}), n == n)

{}

{3, 2, 1}
True 1 False

Output

Control flowConditionals, loops, pattern matching and exceptions.BuiltinsConstructors, conversions and the other builtin functions.