Language

Syntax

Comments

# starts a comment that runs to the end of the line.

# A comment on its own line
x = 1  # A trailing comment

python

A string literal as the first statement of a module, function or class body parses and is discarded. There is no __doc__ at runtime.

Line joining

A statement continues on the next line after a trailing backslash. It also continues freely inside (), [] and {}.

total = 1 + \
    2
names = [
  "a",
  "b",
]
print(total, names)

{}

3 ['a', 'b']

Output

Identifiers and assignment

Identifiers start with a letter or underscore and continue with letters, digits and underscores. Non-ASCII characters are allowed.

counter = 0
café = "open"
π = 3.14159

# Multiple targets
a = b = c = 0
print(a, b, c)

{}

0 0 0

Output

Tuple unpacking

a, b = 1, 2
print(a, b)

# Star pattern
first, *middle, last = [1, 2, 3, 4, 5]
print(first, middle, last)

# List-form targets unpack the same way
[x, y] = (10, 20)
print(x, y)

{}

1 2
1 [2, 3, 4] 5
10 20

Output

Targets can also be attributes, subscripts, parenthesized lists or nested patterns.

class Point:
  def __init__(self, x, y):
    self.x, self.y = x, y

p = Point(1, 2)
lst = [0]
lst[0], p.x = p.x, lst[0]
print(lst, p.x)

(a, b) = (3, 4)
h, (i, j) = 5, (6, 7)
print(a, b, h, i, j)

{}

[1] 0
3 4 5 6 7

Output

for loops and comprehensions take the same nested targets, as in for i, (k, v) in enumerate(d.items()). A starred target such as *middle must be a plain name.

Walrus operator

:= assigns inside an expression. It helps in conditions and comprehensions.

data = [1, 2, 3]
if (n := len(data)) > 0:
  print(n)

{}

Output

Numbers

Integer literals are decimal by default. The 0x prefix writes hex, 0o octal and 0b binary. _ may separate digits.

Data types covers the range and overflow.

print(0xDEAD_BEEF)
print(0o777)
print(0b1010_1010)
print(1_000_000)

{}

Output

An underscore must sit between two digits. 1_, 1__2 and 0x_1 are rejected.

Float literals are IEEE-754 doubles.

print(3.14)
print(1e-5)
print(.5)
print(1e16)  # repr switches to scientific notation

{}

3.14
1e-05
0.5
1e+16

Output

Complex literals such as 1j do not exist.

Strings

Strings take single, double or triple quotes. Prefixes change what a literal builds.

An r prefix makes a raw string. Backslashes stay literal.
A b prefix builds bytes instead of a string.
An f prefix makes an f-string.

Adjacent literals concatenate into one.

print('single')
print("double")
print("""triple
quoted""")
print(r'raw\n')  # backslash not escaped
print('hello' ' world')  # implicit concatenation

{}

single
double
triple
quoted
raw\n
hello world

Output

Escape sequences

Escape	Meaning
`\n`, `\t`, `\r`	Line feed, tab, carriage return
`\a`, `\b`, `\f`, `\v`	Bell, backspace, form feed, vertical tab
`\\`, `\'`, `\"`	Backslash and quotes
`\0`, `\NNN`	Octal with 1 to 3 digits, `\0` is the null character
`\xHH`	A character from two hex digits
`\uHHHH`, `\UHHHHHHHH`	A code point from 4 or 8 hex digits

An unknown escape keeps its backslash. A named escape such as \N{GREEK SMALL LETTER ALPHA} fails at compile time, so write the character or \u03b1.

print('\n line break')
print('\t tab')
print('\x41 hex')
print('\u00e9 unicode')
print('\101')  # octal escape, 'A'

{}

 line break
	 tab
A hex
é unicode
A

Output

f-strings

name = "world"
n = 42
pi = 3.14159
print(f"hello {name}")
print(f"answer is {n + 1}")
print(f"{n:04d}")  # zero-padded width
print(f"{pi:.3f}")  # float precision
print(f"{255:#x}")  # hex with prefix
print(f"{name!r}")  # !r conversion
print(f"{{literal braces}}")

{}

hello world
answer is 43
0042
3.142
0xff
'world'
{literal braces}

Output

The format spec follows these rules.

The full form is [[fill]align][sign][#][0][width][,|_][.precision][type].
The conversions !r, !s and !a come before the spec.
Type characters are b c d e E f F g G n o s x X %.
, and _ group digits every three for decimal output.
_ with b, o, x or X groups every four digits.

Operators

Arithmetic

print(7 + 3, 7 - 3, 7 * 3, 7 / 3)
print(7 // 3, 7 % 3, 2 ** 10)
print(-5, +5)

{}

10 4 21 2.3333333333333335
2 1 1024
-5 5

Output

/ always yields a float.
// and % use floored division. The result of % takes the sign of the divisor.
@ has no meaning on builtin types. A class can give it one, see Classes.
With a string on the left, % does printf-style formatting, see Methods.

Comparison and chaining

Comparisons chain, and in, not in, is and is not chain with them. a < b in c means a < b and b in c, with b evaluated once.

Ordering works on numbers, strings and bytes. Lists and tuples compare lexicographically. Mixing types that cannot be ordered raises TypeError.

print(1 < 2 < 3)  # chained
print(0 < 5 in [5, 6])
print(1 == 1 == 1)
print([1, 2] < [1, 3])  # lexicographic

{}

True
True
True
True

Output

try:
  1 < "a"
except TypeError:
  print("cannot order")

{}

cannot order

Output

Logical

and and or short-circuit. They return the deciding operand, not a coerced bool. not negates.

print(True and "second")
print(0 or "fallback")
print(None or 0 or [] or "default")

{}

second
fallback
default

Output

Bitwise

print(5 & 3, 5 | 3, 5 ^ 3, ~5)
print(1 << 4, 32 >> 2)

{}

1 7 6 -6
16 8

Output

Membership and identity

print(2 in [1, 2, 3])
print(4 not in [1, 2, 3])
print('a' in {'a': 1})
print(None is None)
xs = [1, 2]
print(xs is not None)

{}

True
True
True
True
True

Output

is compares only with None, True, False, ... or NotImplemented. Any other operand fails at compile time, so compare values with ==.

Augmented assignment

The forms are += -= *= /= //= %= **= @= &= |= ^= <<= >>=. A class can define its own in-place behavior, see Classes.

x = 10
x += 5
x *= 2
print(x)

{}

Output

Conditional expression

x = 5
print("big" if x > 3 else "small")

{}

big

Output

Containers

Literal	Builds
`[1, 2, 3]`	A list
`(1, 2, 3)`	A tuple
`(1,)`	A one-element tuple
`()`	An empty tuple
`{"a": 1}`	A dict
`{}`	An empty dict
`{1, 2, 3}`	A set

{} is an empty dict. The empty set is written set().

Data types covers the semantics and Methods the methods.

print((1,), ())
print(type({}), type(set()))

{}

(1,) ()
<class 'dict'> <class 'set'>

Output

Unpacking in literals

* spreads an iterable into a list, set or tuple literal. x = *xs, 3 builds a tuple. ** spreads a mapping into a dict literal.

Both mix freely with regular elements. In a dict, later keys win.

xs = [1, 2]
print([*xs, 3, *xs])  # list spread
print(sorted({*xs, 2, 3}))  # set spread, deduped

a = {"x": 1}
print({**a, "y": 2, **{"x": 9}})  # dict spread, later key wins

{}

[1, 2, 3, 1, 2]
[1, 2, 3]
{'x': 9, 'y': 2}

Output

Indexing and slicing

Indices start at 0. Negative indices count back from the end.

Slices take [start:stop:step]. Any part may be omitted. A negative step walks backwards.

a = [1, 2, 3, 4, 5]
print(a[0], a[-1])  # first and last
print(a[1:4])  # [start:stop]
print(a[:2])
print(a[3:])
print(a[::2])  # every 2nd
print(a[::-1])  # reversed

{}

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

Output

Comprehensions

print([x * x for x in range(5)])
print([x for x in range(10) if x % 2 == 0])
print([(i, j) for i in range(2) for j in range(2)])
print([[x for x in range(y)] for y in range(3)])
print({x: x * x for x in range(4)})
print(sorted({x % 3 for x in range(10)}))  # set order is arbitrary, sort to compare

{}

[0, 1, 4, 9, 16]
[0, 2, 4, 6, 8]
[(0, 0), (0, 1), (1, 0), (1, 1)]
[[], [0], [0, 1]]
{0: 0, 1: 1, 2: 4, 3: 9}
[0, 1, 2]

Output

Functions covers generator expressions.

Type annotations

Annotations parse on variables, parameters and return positions. They have no runtime effect. There is no __annotations__ and no runtime check.

Treat them as documentation for humans and static analyzers. Generic classes, type aliases and unions are on Data types.

counter: int = 0
name: str = "edge"

def add(a: int, b: int) -> int:
  return a + b

print(add(3, 4))
print(add("a", "b"))  # annotations do not enforce

{}

7
ab

Output

Data typesThe builtin types, their values and their behavior.MethodsThe methods of strings, bytes, lists, dicts, sets and numbers.