1if __name__ == '__main__':      # Runs main() if file wasn't imported.
2    main()

1<el>   = <list>[index]          # First index is 0. Last -1. Allows assignments.
2<list> = <list>[<slice>]        # Or: <list>[from_inclusive : to_exclusive : ±step]

1<list>.append(<el>)             # Or: <list> += [<el>]
2<list>.extend(<collection>)     # Or: <list> += <collection>

1<list>.sort()                   # Sorts in ascending order.
2<list>.reverse()                # Reverses the list in-place.
3<list> = sorted(<collection>)   # Returns a new sorted list.
4<iter> = reversed(<list>)       # Returns reversed iterator.

1sum_of_elements  = sum(<collection>)
2elementwise_sum  = [sum(pair) for pair in zip(list_a, list_b)]
3sorted_by_second = sorted(<collection>, key=lambda el: el[1])
4sorted_by_both   = sorted(<collection>, key=lambda el: (el[1], el[0]))
5flatter_list     = list(itertools.chain.from_iterable(<list>))
6product_of_elems = functools.reduce(lambda out, el: out * el, <collection>)
7list_of_chars    = list(<str>)

1<int> = len(<list>)             # Returns number of items. Also works on other collections.
2<int> = <list>.count(<el>)      # Returns number of occurrences. Also `if <el> in <coll>: ...`.
3<int> = <list>.index(<el>)      # Returns index of the first occurrence or raises ValueError.
4<el>  = <list>.pop()            # Removes and returns item from the end or at index if passed.
5<list>.insert(<int>, <el>)      # Inserts item at index and moves the rest to the right.
6<list>.remove(<el>)             # Removes first occurrence of the item or raises ValueError.
7<list>.clear()                  # Removes all items. Also works on dictionary and set.

1<view> = <dict>.keys()                          # Coll. of keys that reflects changes.
2<view> = <dict>.values()                        # Coll. of values that reflects changes.
3<view> = <dict>.items()                         # Coll. of key-value tuples that reflects chgs.

1value  = <dict>.get(key, default=None)          # Returns default if key is missing.
2value  = <dict>.setdefault(key, default=None)   # Returns and writes default if key is missing.
3<dict> = collections.defaultdict(<type>)        # Returns a dict with default value `<type>()`.
4<dict> = collections.defaultdict(lambda: 1)     # Returns a dict with default value 1.

1<dict> = dict(<collection>)                     # Creates a dict from coll. of key-value pairs.
2<dict> = dict(zip(keys, values))                # Creates a dict from two collections.
3<dict> = dict.fromkeys(keys [, value])          # Creates a dict from collection of keys.

1<dict>.update(<dict>)                           # Adds items. Replaces ones with matching keys.
2value = <dict>.pop(key)                         # Removes item or raises KeyError if missing.
3{k for k, v in <dict>.items() if v == value}    # Returns set of keys that point to the value.
4{k: v for k, v in <dict>.items() if k in keys}  # Filters the dictionary by keys.

1>>> from collections import Counter
2>>> colors = ['blue', 'blue', 'blue', 'red', 'red']
3>>> counter = Counter(colors)
4>>> counter['yellow'] += 1
5Counter({'blue': 3, 'red': 2, 'yellow': 1})
6>>> counter.most_common()[0]
7('blue', 3)

1<set> = set()                                   # `{}` returns a dictionary.

1<set>.add(<el>)                                 # Or: <set> |= {<el>}
2<set>.update(<collection> [, ...])              # Or: <set> |= <set>

1<set>  = <set>.union(<coll.>)                   # Or: <set> | <set>
2<set>  = <set>.intersection(<coll.>)            # Or: <set> & <set>
3<set>  = <set>.difference(<coll.>)              # Or: <set> - <set>
4<set>  = <set>.symmetric_difference(<coll.>)    # Or: <set> ^ <set>
5<bool> = <set>.issubset(<coll.>)                # Or: <set> <= <set>
6<bool> = <set>.issuperset(<coll.>)              # Or: <set> >= <set>

1<el> = <set>.pop()                              # Raises KeyError if empty.
2<set>.remove(<el>)                              # Raises KeyError if missing.
3<set>.discard(<el>)                             # Doesn't raise an error.

1<frozenset> = frozenset(<collection>)

1<tuple> = ()                               # Empty tuple.
2<tuple> = (<el>,)                          # Or: <el>,
3<tuple> = (<el_1>, <el_2> [, ...])         # Or: <el_1>, <el_2> [, ...]

 1>>> from collections import namedtuple
 2>>> Point = namedtuple('Point', 'x y')
 3>>> p = Point(1, y=2)
 4Point(x=1, y=2)
 5>>> p[0]
 61
 7>>> p.x
 81
 9>>> getattr(p, 'y')
102

1<range> = range(stop)                      # range(to_exclusive)
2<range> = range(start, stop)               # range(from_inclusive, to_exclusive)
3<range> = range(start, stop, ±step)        # range(from_inclusive, to_exclusive, ±step_size)

1>>> [i for i in range(3)]
2[0, 1, 2]

1for i, el in enumerate(<collection> [, i_start]):
2    ...

1<iter> = iter(<collection>)                # `iter(<iter>)` returns unmodified iterator.
2<iter> = iter(<function>, to_exclusive)    # A sequence of return values until 'to_exclusive'.
3<el>   = next(<iter> [, default])          # Raises StopIteration or returns 'default' on end.
4<list> = list(<iter>)                      # Returns a list of iterator's remaining elements.

1import itertools as it

1<iter> = it.count(start=0, step=1)         # Returns updated value endlessly. Accepts floats.
2<iter> = it.repeat(<el> [, times])         # Returns element endlessly or 'times' times.
3<iter> = it.cycle(<collection>)            # Repeats the sequence endlessly.

1<iter> = it.chain(<coll>, <coll> [, ...])  # Empties collections in order (figuratively).
2<iter> = it.chain.from_iterable(<coll>)    # Empties collections inside a collection in order.

1<iter> = it.islice(<coll>, to_exclusive)   # Only returns first 'to_exclusive' elements.
2<iter> = it.islice(<coll>, from_inc, …)    # `to_exclusive, +step_size`. Indices can be None.

1def count(start, step):
2    while True:
3        yield start
4        start += step

1>>> counter = count(10, 2)
2>>> next(counter), next(counter), next(counter)
3(10, 12, 14)

1<type> = type(<el>)                          # Or: <el>.__class__
2<bool> = isinstance(<el>, <type>)            # Or: issubclass(type(<el>), <type>)

1>>> type('a'), 'a'.__class__, str
2(<class 'str'>, <class 'str'>, <class 'str'>)

1from types import FunctionType, MethodType, LambdaType, GeneratorType, ModuleType

1>>> from collections.abc import Iterable, Collection, Sequence
2>>> isinstance([1, 2, 3], Iterable)
3True

1+------------------+------------+------------+------------+
2|                  |  Iterable  | Collection |  Sequence  |
3+------------------+------------+------------+------------+
4| list, range, str |    yes     |    yes     |    yes     |
5| dict, set        |    yes     |    yes     |            |
6| iter             |    yes     |            |            |
7+------------------+------------+------------+------------+

1>>> from numbers import Number, Complex, Real, Rational, Integral
2>>> isinstance(123, Number)
3True

1+--------------------+----------+----------+----------+----------+----------+
2|                    |  Number  |  Complex |   Real   | Rational | Integral |
3+--------------------+----------+----------+----------+----------+----------+
4| int                |   yes    |   yes    |   yes    |   yes    |   yes    |
5| fractions.Fraction |   yes    |   yes    |   yes    |   yes    |          |
6| float              |   yes    |   yes    |   yes    |          |          |
7| complex            |   yes    |   yes    |          |          |          |
8| decimal.Decimal    |   yes    |          |          |          |          |
9+--------------------+----------+----------+----------+----------+----------+

1<str>  = <str>.strip()                       # Strips all whitespace characters from both ends.
2<str>  = <str>.strip('<chars>')              # Strips passed characters. Also lstrip/rstrip().

1<list> = <str>.split()                       # Splits on one or more whitespace characters.
2<list> = <str>.split(sep=None, maxsplit=-1)  # Splits on 'sep' str at most 'maxsplit' times.
3<list> = <str>.splitlines(keepends=False)    # On [\n\r\f\v\x1c-\x1e\x85\u2028\u2029] and \r\n.
4<str>  = <str>.join(<coll_of_strings>)       # Joins elements using string as a separator.

1<bool> = <sub_str> in <str>                  # Checks if string contains the substring.
2<bool> = <str>.startswith(<sub_str>)         # Pass tuple of strings for multiple options.
3<int>  = <str>.find(<sub_str>)               # Returns start index of the first match or -1.
4<int>  = <str>.index(<sub_str>)              # Same, but raises ValueError if missing.

1<str>  = <str>.lower()                       # Changes the case. Also upper/capitalize/title().
2<str>  = <str>.replace(old, new [, count])   # Replaces 'old' with 'new' at most 'count' times.
3<str>  = <str>.translate(<table>)            # Use `str.maketrans(<dict>)` to generate table.

1<str>  = chr(<int>)                          # Converts int to Unicode character.
2<int>  = ord(<str>)                          # Converts Unicode character to int.

1<bool> = <str>.isdecimal()                   # Checks for [0-9]. Also [०-९] and [٠-٩].
2<bool> = <str>.isdigit()                     # Checks for [²³¹…] and isdecimal().
3<bool> = <str>.isnumeric()                   # Checks for [¼½¾], [零〇一…] and isdigit().
4<bool> = <str>.isalnum()                     # Checks for [a-zA-Z…] and isnumeric().
5<bool> = <str>.isprintable()                 # Checks for [ !#$%…] and isalnum().
6<bool> = <str>.isspace()                     # Checks for [ \t\n\r\f\v\x1c-\x1f\x85\xa0…].

1import re
2<str>   = re.sub(r'<regex>', new, text, count=0)  # Substitutes all occurrences with 'new'.
3<list>  = re.findall(r'<regex>', text)            # Returns all occurrences as strings.
4<list>  = re.split(r'<regex>', text, maxsplit=0)  # Add brackets around regex to keep matches.
5<Match> = re.search(r'<regex>', text)             # First occurrence of the pattern or None.
6<Match> = re.match(r'<regex>', text)              # Searches only at the beginning of the text.
7<iter>  = re.finditer(r'<regex>', text)           # Returns all occurrences as Match objects.

1<str>   = <Match>.group()                         # Returns the whole match. Also group(0).
2<str>   = <Match>.group(1)                        # Returns part inside the first brackets.
3<tuple> = <Match>.groups()                        # Returns all bracketed parts.
4<int>   = <Match>.start()                         # Returns start index of the match.
5<int>   = <Match>.end()                           # Returns exclusive end index of the match.

1'\d' == '[0-9]'                                   # Also [०-९…]. Matches a decimal character.
2'\w' == '[a-zA-Z0-9_]'                            # Also [ª²³…]. Matches an alphanumeric or _.
3'\s' == '[ \t\n\r\f\v]'                           # Also [\x1c-\x1f…]. Matches a whitespace.

1<str> = f'{<el_1>}, {<el_2>}'            # Curly brackets can also contain expressions.
2<str> = '{}, {}'.format(<el_1>, <el_2>)  # Or: '{0}, {a}'.format(<el_1>, a=<el_2>)
3<str> = '%s, %s' % (<el_1>, <el_2>)      # Redundant and inferior C-style formatting.

1>>> Person = collections.namedtuple('Person', 'name height')
2>>> person = Person('Jean-Luc', 187)
3>>> f'{person.name} is {person.height / 100} meters tall.'
4'Jean-Luc is 1.87 meters tall.'

1{<el>:<10}                               # '<el>      '
2{<el>:^10}                               # '   <el>   '
3{<el>:>10}                               # '      <el>'
4{<el>:.<10}                              # '<el>......'
5{<el>:0}                                 # '<el>'

1{'abcde':10}                             # 'abcde     '
2{'abcde':10.3}                           # 'abc       '
3{'abcde':.3}                             # 'abc'
4{'abcde'!r:10}                           # "'abcde'   "

1{123456:10}                              # '    123456'
2{123456:10,}                             # '   123,456'
3{123456:10_}                             # '   123_456'
4{123456:+10}                             # '   +123456'
5{123456:=+10}                            # '+   123456'
6{123456: }                               # ' 123456'
7{-123456: }                              # '-123456'

1{1.23456:10.3}                           # '      1.23'
2{1.23456:10.3f}                          # '     1.235'
3{1.23456:10.3e}                          # ' 1.235e+00'
4{1.23456:10.3%}                          # '  123.456%'

 1+--------------+----------------+----------------+----------------+----------------+
 2|              |    {<float>}   |   {<float>:f}  |   {<float>:e}  |   {<float>:%}  |
 3+--------------+----------------+----------------+----------------+----------------+
 4|  0.000056789 |   '5.6789e-05' |    '0.000057'  | '5.678900e-05' |    '0.005679%' |
 5|  0.00056789  |   '0.00056789' |    '0.000568'  | '5.678900e-04' |    '0.056789%' |
 6|  0.0056789   |   '0.0056789'  |    '0.005679'  | '5.678900e-03' |    '0.567890%' |
 7|  0.056789    |   '0.056789'   |    '0.056789'  | '5.678900e-02' |    '5.678900%' |
 8|  0.56789     |   '0.56789'    |    '0.567890'  | '5.678900e-01' |   '56.789000%' |
 9|  5.6789      |   '5.6789'     |    '5.678900'  | '5.678900e+00' |  '567.890000%' |
10| 56.789       |  '56.789'      |   '56.789000'  | '5.678900e+01' | '5678.900000%' |
11+--------------+----------------+----------------+----------------+----------------+

 1+--------------+----------------+----------------+----------------+----------------+
 2|              |  {<float>:.2}  |  {<float>:.2f} |  {<float>:.2e} |  {<float>:.2%} |
 3+--------------+----------------+----------------+----------------+----------------+
 4|  0.000056789 |    '5.7e-05'   |      '0.00'    |   '5.68e-05'   |      '0.01%'   |
 5|  0.00056789  |    '0.00057'   |      '0.00'    |   '5.68e-04'   |      '0.06%'   |
 6|  0.0056789   |    '0.0057'    |      '0.01'    |   '5.68e-03'   |      '0.57%'   |
 7|  0.056789    |    '0.057'     |      '0.06'    |   '5.68e-02'   |      '5.68%'   |
 8|  0.56789     |    '0.57'      |      '0.57'    |   '5.68e-01'   |     '56.79%'   |
 9|  5.6789      |    '5.7'       |      '5.68'    |   '5.68e+00'   |    '567.89%'   |
10| 56.789       |    '5.7e+01'   |     '56.79'    |   '5.68e+01'   |   '5678.90%'   |
11+--------------+----------------+----------------+----------------+----------------+

1{90:c}                                   # 'Z'. Unicode character with value 90.
2{90:b}                                   # '1011010'. Number 90 in binary.
3{90:X}                                   # '5A'. Number 90 in uppercase hexadecimal.

1<int>      = int(<float/str/bool>)                # Or: math.floor(<float>)
2<float>    = float(<int/str/bool>)                # Or: <int/float>e±<int>
3<complex>  = complex(real=0, imag=0)              # Or: <int/float> ± <int/float>j
4<Fraction> = fractions.Fraction(0, 1)             # Or: Fraction(numerator=0, denominator=1)
5<Decimal>  = decimal.Decimal(<str/int>)           # Or: Decimal((sign, digits, exponent))

1<num> = pow(<num>, <num>)                         # Or: <number> ** <number>
2<num> = abs(<num>)                                # <float> = abs(<complex>)
3<num> = round(<num> [, ±ndigits])                 # `round(126, -1) == 130`

1from math import e, pi, inf, nan, isinf, isnan    # `<el> == nan` is always False.
2from math import sin, cos, tan, asin, acos, atan  # Also: degrees, radians.
3from math import log, log10, log2                 # Log can accept base as second arg.

1from statistics import mean, median, variance     # Also: stdev, quantiles, groupby.

1from random import random, randint, choice        # Also: shuffle, gauss, triangular, seed.
2<float> = random()                                # A float inside [0, 1).
3<int>   = randint(from_inc, to_inc)               # An int inside [from_inc, to_inc].
4<el>    = choice(<sequence>)                      # Keeps the sequence intact.

1<int> = ±0b<bin>                                  # Or: ±0x<hex>
2<int> = int('±<bin>', 2)                          # Or: int('±<hex>', 16)
3<int> = int('±0b<bin>', 0)                        # Or: int('±0x<hex>', 0)
4<str> = bin(<int>)                                # Returns '[-]0b<bin>'.

1<int> = <int> & <int>                             # And (0b1100 & 0b1010 == 0b1000).
2<int> = <int> | <int>                             # Or  (0b1100 | 0b1010 == 0b1110).
3<int> = <int> ^ <int>                             # Xor (0b1100 ^ 0b1010 == 0b0110).
4<int> = <int> << n_bits                           # Left shift. Use >> for right.
5<int> = ~<int>                                    # Not. Also -<int> - 1.

1import itertools as it

1>>> list(it.product([0, 1], repeat=3))
2[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1),
3 (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

1>>> list(it.product('abc', 'abc'))                    #   a  b  c
2[('a', 'a'), ('a', 'b'), ('a', 'c'),                  # a x  x  x
3 ('b', 'a'), ('b', 'b'), ('b', 'c'),                  # b x  x  x
4 ('c', 'a'), ('c', 'b'), ('c', 'c')]                  # c x  x  x

1>>> list(it.combinations('abc', 2))                   #   a  b  c
2[('a', 'b'), ('a', 'c'),                              # a .  x  x
3 ('b', 'c')]                                          # b .  .  x

1>>> list(it.combinations_with_replacement('abc', 2))  #   a  b  c
2[('a', 'a'), ('a', 'b'), ('a', 'c'),                  # a x  x  x
3 ('b', 'b'), ('b', 'c'),                              # b .  x  x
4 ('c', 'c')]                                          # c .  .  x

1>>> list(it.permutations('abc', 2))                   #   a  b  c
2[('a', 'b'), ('a', 'c'),                              # a .  x  x
3 ('b', 'a'), ('b', 'c'),                              # b x  .  x
4 ('c', 'a'), ('c', 'b')]                              # c x  x  .

1# $ pip3 install python-dateutil
2from datetime import date, time, datetime, timedelta, timezone
3from dateutil.tz import tzlocal, gettz

1<D>  = date(year, month, day)               # Only accepts valid dates from 1 to 9999 AD.
2<T>  = time(hour=0, minute=0, second=0)     # Also: `microsecond=0, tzinfo=None, fold=0`.
3<DT> = datetime(year, month, day, hour=0)   # Also: `minute=0, second=0, microsecond=0, …`.
4<TD> = timedelta(weeks=0, days=0, hours=0)  # Also: `minutes=0, seconds=0, microseconds=0`.

1<D/DTn> = D/DT.today()                      # Current local date or naive DT. Also DT.now().
2<DTa>   = DT.now(<tzinfo>)                  # Aware DT from current time in passed timezone.

1<tzinfo> = timezone.utc                     # London without daylight saving time (DST).
2<tzinfo> = timezone(<timedelta>)            # Timezone with fixed offset from UTC.
3<tzinfo> = tzlocal()                        # Local tz with dynamic offset. Also gettz().
4<tzinfo> = gettz('<Continent>/<City>')      # 'Continent/City_Name' timezone or None.
5<DTa>    = <DT>.astimezone([<tzinfo>])      # Converts DT to the passed or local fixed zone.
6<Ta/DTa> = <T/DT>.replace(tzinfo=<tzinfo>)  # Changes object's timezone without conversion.

1<D/T/DT> = D/T/DT.fromisoformat(<str>)      # Object from ISO string. Raises ValueError.
2<DT>     = DT.strptime(<str>, '<format>')   # Datetime from str, according to format.
3<D/DTn>  = D/DT.fromordinal(<int>)          # D/DT from days since the Gregorian NYE 1.
4<DTn>    = DT.fromtimestamp(<float>)        # Local naive DT from seconds since the Epoch.
5<DTa>    = DT.fromtimestamp(<float>, <tz>)  # Aware datetime from seconds since the Epoch.

1<str>    = <D/T/DT>.isoformat(sep='T')      # Also `timespec='auto/hours/minutes/seconds/…'`.
2<str>    = <D/T/DT>.strftime('<format>')    # Custom string representation of the object.
3<int>    = <D/DT>.toordinal()               # Days since Gregorian NYE 1, ignoring time and tz.
4<float>  = <DTn>.timestamp()                # Seconds since the Epoch, from local naive DT.
5<float>  = <DTa>.timestamp()                # Seconds since the Epoch, from aware datetime.

1>>> dt = datetime.strptime('2025-08-14 23:39:00.00 +0200', '%Y-%m-%d %H:%M:%S.%f %z')
2>>> dt.strftime("%dth of %B '%y (%a), %I:%M %p %Z")
3"14th of August '25 (Thu), 11:39 PM UTC+02:00"

1<bool>   = <D/T/DTn> > <D/T/DTn>            # Ignores time jumps (fold attribute). Also ==.
2<bool>   = <DTa>     > <DTa>                # Ignores jumps if they share tz object. Broken ==.
3<TD>     = <D/DTn>   - <D/DTn>              # Ignores jumps. Convert to UTC for actual delta.
4<TD>     = <DTa>     - <DTa>                # Ignores jumps if they share tzinfo object.
5<D/DT>   = <D/DT>    ± <TD>                 # Returned datetime can fall into missing hour.
6<TD>     = <TD>      * <float>              # Also: <TD> = abs(<TD>) and <TD> = <TD> ±% <TD>.
7<float>  = <TD>      / <TD>                 # How many hours/weeks/years are in TD. Also //.

1func(<positional_args>)                           # func(0, 0)
2func(<keyword_args>)                              # func(x=0, y=0)
3func(<positional_args>, <keyword_args>)           # func(0, y=0)

1def func(<nondefault_args>): ...                  # def func(x, y): ...
2def func(<default_args>): ...                     # def func(x=0, y=0): ...
3def func(<nondefault_args>, <default_args>): ...  # def func(x, y=0): ...

1args   = (1, 2)
2kwargs = {'x': 3, 'y': 4, 'z': 5}
3func(*args, **kwargs)

1func(1, 2, x=3, y=4, z=5)

1def add(*a):
2    return sum(a)

1>>> add(1, 2, 3)
26

1def f(*args): ...               # f(1, 2, 3)
2def f(x, *args): ...            # f(1, 2, 3)
3def f(*args, z): ...            # f(1, 2, z=3)

1def f(**kwargs): ...            # f(x=1, y=2, z=3)
2def f(x, **kwargs): ...         # f(x=1, y=2, z=3) | f(1, y=2, z=3)

1def f(*args, **kwargs): ...     # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)
2def f(x, *args, **kwargs): ...  # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)
3def f(*args, y, **kwargs): ...  # f(x=1, y=2, z=3) | f(1, y=2, z=3)

1def f(*, x, y, z): ...          # f(x=1, y=2, z=3)
2def f(x, *, y, z): ...          # f(x=1, y=2, z=3) | f(1, y=2, z=3)
3def f(x, y, *, z): ...          # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3)

1<list>  = [*<coll.> [, ...]]    # Or: list(<collection>) [+ ...]
2<tuple> = (*<coll.>, [...])     # Or: tuple(<collection>) [+ ...]
3<set>   = {*<coll.> [, ...]}    # Or: set(<collection>) [| ...]
4<dict>  = {**<dict> [, ...]}    # Or: dict(<dict>) [| ...] (since 3.9)

1head, *body, tail = <coll.>     # Head or tail can be omitted.

1<func> = lambda: <return_value>                     # A single statement function.
2<func> = lambda <arg_1>, <arg_2>: <return_value>    # Also allows default arguments.

1<list> = [i+1 for i in range(10)]                   # Or: [1, 2, ..., 10]
2<iter> = (i for i in range(10) if i > 5)            # Or: iter([6, 7, 8, 9])
3<set>  = {i+5 for i in range(10)}                   # Or: {5, 6, ..., 14}
4<dict> = {i: i*2 for i in range(10)}                # Or: {0: 0, 1: 2, ..., 9: 18}

1>>> [l+r for l in 'abc' for r in 'abc']             # Inner loop is on the right side.
2['aa', 'ab', 'ac', ..., 'cc']

1from functools import reduce

1<iter> = map(lambda x: x + 1, range(10))            # Or: iter([1, 2, ..., 10])
2<iter> = filter(lambda x: x > 5, range(10))         # Or: iter([6, 7, 8, 9])
3<obj>  = reduce(lambda out, x: out + x, range(10))  # Or: 45

1<bool> = any(<collection>)                          # Is `bool(<el>)` True for any el?
2<bool> = all(<collection>)                          # True for all? Also True if empty.

1<obj> = <exp> if <condition> else <exp>             # Only one expression is evaluated.

1>>> [a if a else 'zero' for a in (0, 1, 2, 3)]      # `any([0, '', [], None]) == False`
2['zero', 1, 2, 3]

1from collections import namedtuple
2Point = namedtuple('Point', 'x y')                  # Creates a tuple's subclass.
3point = Point(0, 0)                                 # Returns its instance.

1from enum import Enum
2Direction = Enum('Direction', 'N E S W')            # Creates an enum.
3direction = Direction.N                             # Returns its member.

1from dataclasses import make_dataclass
2Player = make_dataclass('Player', ['loc', 'dir'])   # Creates a class.
3player = Player(point, direction)                   # Returns its instance.

1import <module>            # Imports a built-in or '<module>.py'.
2import <package>           # Imports a built-in or '<package>/__init__.py'.
3import <package>.<module>  # Imports a built-in or '<package>/<module>.py'.

1def get_multiplier(a):
2    def out(b):
3        return a * b
4    return out

1>>> multiply_by_3 = get_multiplier(3)
2>>> multiply_by_3(10)
330

1from functools import partial
2<function> = partial(<function> [, <arg_1>, <arg_2>, ...])

1>>> def multiply(a, b):
2...     return a * b
3>>> multiply_by_3 = partial(multiply, 3)
4>>> multiply_by_3(10)
530

1def get_counter():
2    i = 0
3    def out():
4        nonlocal i
5        i += 1
6        return i
7    return out

1>>> counter = get_counter()
2>>> counter(), counter(), counter()
3(1, 2, 3)

1@decorator_name
2def function_that_gets_passed_to_decorator():
3    ...

 1from functools import wraps
 2
 3def debug(func):
 4    @wraps(func)
 5    def out(*args, **kwargs):
 6        print(func.__name__)
 7        return func(*args, **kwargs)
 8    return out
 9
10@debug
11def add(x, y):
12    return x + y

1from functools import lru_cache
2
3@lru_cache(maxsize=None)
4def fib(n):
5    return n if n < 2 else fib(n-2) + fib(n-1)

 1from functools import wraps
 2
 3def debug(print_result=False):
 4    def decorator(func):
 5        @wraps(func)
 6        def out(*args, **kwargs):
 7            result = func(*args, **kwargs)
 8            print(func.__name__, result if print_result else '')
 9            return result
10        return out
11    return decorator
12
13@debug(print_result=True)
14def add(x, y):
15    return x + y

 1class MyClass:
 2    def __init__(self, a):
 3        self.a = a
 4    def __str__(self):
 5        return str(self.a)
 6    def __repr__(self):
 7        class_name = self.__class__.__name__
 8        return f'{class_name}({self.a!r})'
 9
10    @classmethod
11    def get_class_name(cls):
12        return cls.__name__

1>>> obj = MyClass(1)
2>>> obj.a, str(obj), repr(obj)
3(1, '1', 'MyClass(1)')

1print(<el>)
2f'{<el>}'
3logging.warning(<el>)
4csv.writer(<file>).writerow([<el>])
5raise Exception(<el>)

1print/str/repr([<el>])
2print/str/repr({<el>: <el>})
3f'{<el>!r}'
4Z = dataclasses.make_dataclass('Z', ['a']); print/str/repr(Z(<el>))
5>>> <el>

1class Person:
2    def __init__(self, name):
3        self.name = name
4
5class Employee(Person):
6    def __init__(self, name, staff_num):
7        super().__init__(name)
8        self.staff_num = staff_num

1class A: pass
2class B: pass
3class C(A, B): pass

1>>> C.mro()
2[<class 'C'>, <class 'A'>, <class 'B'>, <class 'object'>]

1from collections import abc
2
3<name>: <type> [| ...] [= <obj>]                              # `|` since 3.10.
4<name>: list/set/abc.Iterable/abc.Sequence[<type>] [= <obj>]  # Since 3.9.
5<name>: dict/tuple[<type>, ...] [= <obj>]                     # Since 3.9.

1from dataclasses import dataclass, field, make_dataclass
2
3@dataclass(order=False, frozen=False)
4class <class_name>:
5    <attr_name>: <type>
6    <attr_name>: <type> = <default_value>
7    <attr_name>: list/dict/set = field(default_factory=list/dict/set)

1<class> = make_dataclass('<class_name>', <coll_of_attribute_names>)
2<class> = make_dataclass('<class_name>', <coll_of_tuples>)
3<tuple> = ('<attr_name>', <type> [, <default_value>])

1class Person:
2    @property
3    def name(self):
4        return ' '.join(self._name)
5
6    @name.setter
7    def name(self, value):
8        self._name = value.split()

1>>> person = Person()
2>>> person.name = '\t Guido  van Rossum \n'
3>>> person.name
4'Guido van Rossum'

1class MyClassWithSlots:
2    __slots__ = ['a']
3    def __init__(self):
4        self.a = 1

1from copy import copy, deepcopy
2<object> = copy/deepcopy(<object>)

1class MyComparable:
2    def __init__(self, a):
3        self.a = a
4    def __eq__(self, other):
5        if isinstance(other, type(self)):
6            return self.a == other.a
7        return NotImplemented

 1class MyHashable:
 2    def __init__(self, a):
 3        self._a = a
 4    @property
 5    def a(self):
 6        return self._a
 7    def __eq__(self, other):
 8        if isinstance(other, type(self)):
 9            return self.a == other.a
10        return NotImplemented
11    def __hash__(self):
12        return hash(self.a)

 1from functools import total_ordering
 2
 3@total_ordering
 4class MySortable:
 5    def __init__(self, a):
 6        self.a = a
 7    def __eq__(self, other):
 8        if isinstance(other, type(self)):
 9            return self.a == other.a
10        return NotImplemented
11    def __lt__(self, other):
12        if isinstance(other, type(self)):
13            return self.a < other.a
14        return NotImplemented

1class Counter:
2    def __init__(self):
3        self.i = 0
4    def __next__(self):
5        self.i += 1
6        return self.i
7    def __iter__(self):
8        return self

1>>> counter = Counter()
2>>> next(counter), next(counter), next(counter)
3(1, 2, 3)

1class Counter:
2    def __init__(self):
3        self.i = 0
4    def __call__(self):
5        self.i += 1
6        return self.i

1>>> counter = Counter()
2>>> counter(), counter(), counter()
3(1, 2, 3)

1class MyOpen:
2    def __init__(self, filename):
3        self.filename = filename
4    def __enter__(self):
5        self.file = open(self.filename)
6        return self.file
7    def __exit__(self, exc_type, exception, traceback):
8        self.file.close()

1>>> with open('test.txt', 'w') as file:
2...     file.write('Hello World!')
3>>> with MyOpen('test.txt') as file:
4...     print(file.read())
5Hello World!

1class MyIterable:
2    def __init__(self, a):
3        self.a = a
4    def __iter__(self):
5        return iter(self.a)
6    def __contains__(self, el):
7        return el in self.a

1>>> obj = MyIterable([1, 2, 3])
2>>> [el for el in obj]
3[1, 2, 3]
4>>> 1 in obj
5True

1class MyCollection:
2    def __init__(self, a):
3        self.a = a
4    def __iter__(self):
5        return iter(self.a)
6    def __contains__(self, el):
7        return el in self.a
8    def __len__(self):
9        return len(self.a)

 1class MySequence:
 2    def __init__(self, a):
 3        self.a = a
 4    def __iter__(self):
 5        return iter(self.a)
 6    def __contains__(self, el):
 7        return el in self.a
 8    def __len__(self):
 9        return len(self.a)
10    def __getitem__(self, i):
11        return self.a[i]
12    def __reversed__(self):
13        return reversed(self.a)

1from collections import abc
2
3class MyAbcSequence(abc.Sequence):
4    def __init__(self, a):
5        self.a = a
6    def __len__(self):
7        return len(self.a)
8    def __getitem__(self, i):
9        return self.a[i]

 1+------------+------------+------------+------------+--------------+
 2|            |  Iterable  | Collection |  Sequence  | abc.Sequence |
 3+------------+------------+------------+------------+--------------+
 4| iter()     |    REQ     |    REQ     |    Yes     |     Yes      |
 5| contains() |    Yes     |    Yes     |    Yes     |     Yes      |
 6| len()      |            |    REQ     |    REQ     |     REQ      |
 7| getitem()  |            |            |    REQ     |     REQ      |
 8| reversed() |            |            |    Yes     |     Yes      |
 9| index()    |            |            |            |     Yes      |
10| count()    |            |            |            |     Yes      |
11+------------+------------+------------+------------+--------------+

1from enum import Enum, auto

1class <enum_name>(Enum):
2    <member_name> = auto()              # Increment of the last numeric value or 1.
3    <member_name> = <value>             # Values don't have to be hashable.
4    <member_name> = <value>, <value>    # Tuple can be used for multiple values.

1<member> = <enum>.<member_name>         # Returns a member.
2<member> = <enum>['<member_name>']      # Returns a member. Raises KeyError.
3<member> = <enum>(<value>)              # Returns a member. Raises ValueError.
4<str>    = <member>.name                # Returns member's name.
5<obj>    = <member>.value               # Returns member's value.

1<list>   = list(<enum>)                 # Returns enum's members.
2<list>   = [a.name for a in <enum>]     # Returns enum's member names.
3<list>   = [a.value for a in <enum>]    # Returns enum's member values.