if __name__ == '__main__':      # Skips indented lines of code if file was imported.
    main()                      # Executes user-defined `def main(): ...` function.

<list> = [<el>, <el>, ...]      # Creates new list object. E.g. `list_a = [1, 2, 3]`.

<el>   = <list>[index]          # First index is 0, last -1. Also `<list>[i] = <el>`.
<list> = <list>[<slice>]        # Also <list>[from_inclusive : to_exclusive : ±step].

<list>.append(<el>)             # Appends element to the end. Or `<list> += [<el>]`.
<list>.extend(<coll>)           # Appends collection's items. Or `<list> += <coll>`.

<list>.sort()                   # Sorts in ascending order. Accepts `reverse=True`.
<list>.reverse()                # Reverses the order of elements. Takes linear time.
<list> = sorted(<coll>)         # Returns a new sorted list. Accepts `reverse=True`.
<iter> = reversed(<list>)       # Returns reversed iterator. Also list(<iterator>).

<el>  = max(<coll>)             # Returns the largest element. Also min(<el>, <el>).
<num> = sum(<coll>)             # Returns a sum of elements. Also math.prod(<coll>).

elementwise_sum  = [sum(pair) for pair in zip(list_a, list_b)]
sorted_by_second = sorted(<coll>, key=lambda pair: pair[1])
sorted_by_both   = sorted(<coll>, key=lambda p: (p[1], p[0]))
flatter_list     = list(itertools.chain.from_iterable(<list>))

<int> = len(<list/dict/set/…>)  # Returns number of items. Doesn't accept iterators.
<int> = <list>.count(<el>)      # Counts occurrences. Also `if <el> in <coll>: ...`.
<int> = <list>.index(<el>)      # Returns index of first occ. or raises ValueError.
<el>  = <list>.pop()            # Removes item from the end (or at index if passed).
<list>.insert(<int>, <el>)      # Inserts item at index and shifts remaining items.
<list>.remove(<el>)             # Removes the first occurrence or raises ValueError.
<list>.clear()                  # Removes all items. Also provided by dict and set.

<dict> = {key: val, key: val, ...}            # Use `<dict>[key]` to get or assign the value.

<view> = <dict>.keys()                        # A collection of keys reflecting all changes.
<view> = <dict>.values()                      # A collection of values that reflects changes.
<view> = <dict>.items()                       # Coll. of tuples. Each contains key and value.

value  = <dict>.get(key, default=None)        # Returns 'default' argument if key is missing.
value  = <dict>.setdefault(key, default)      # Returns/writes 'default' when key is missing.
<dict> = collections.defaultdict(<type>)      # Dict with automatic default value `<type>()`.

<dict> = dict(<collection>)                   # Creates a dict from coll. of key-value pairs.
<dict> = dict(zip(keys, values))              # Creates key-value pairs from two collections.
<dict> = dict.fromkeys(keys [, value])        # Items get value None if only keys are passed.

<dict>.update(<dict>)                         # Adds items to dict. Passed dict has priority.
value = <dict>.pop(key)                       # Removes item or raises KeyError when missing.
{k for k, v in <dict>.items() if v == 123}    # Returns a set of keys whose value equals 123.
{k: v for k, v in <dict>.items() if k in ks}  # Returns a dict of items with specified keys.

>>> from collections import Counter
>>> counter = Counter(['blue', 'blue', 'red'])
>>> counter['yellow'] += 3
>>> print(counter.most_common())
[('yellow', 3), ('blue', 2), ('red', 1)]

<set> = {<el>, <el>, ...}           # Coll. of unique items. Also set(), set(<coll>).

<set>.add(<el>)                     # Adds item to the set. Same as `<set> |= {<el>}`.
<set>.update(<coll> [, ...])        # Adds items to the set. Same as `<set> |= <set>`.

<set> = <set>.union(<coll>)         # Returns a set of all items. Also <set> | <set>.
<set> = <set>.intersection(<coll>)  # Returns every shared item. Also <set> & <set>.
<set> = <set>.difference(<coll>)    # Returns set's unique items. Also <set> - <set>.

<bool> = <set>.issuperset(<coll>)   # Returns False when collection has unique items.
<bool> = <set>.issubset(<coll>)     # Is collection a superset? Also <set> <= <set>.

<el> = <set>.pop()                  # Removes one of items. Raises KeyError if empty.
<set>.remove(<el>)                  # Removes the item or raises KeyError if missing.
<set>.discard(<el>)                 # Same as remove() but it doesn't raise an error.

<frozenset> = frozenset(<collection>)

<tuple> = ()                        # Returns an empty tuple. Also tuple(), tuple(<coll>).
<tuple> = (<el>,)                   # Returns tuple with one element. Or `<tup.> = <el>,`.
<tuple> = (<el>, <el> [, ...])      # Returns a tuple. Or `<tuple> = <el>, <el> [, ...]`.

>>> import collections as co
>>> Point = co.namedtuple('Point', 'x y')
>>> p = Point(1, y=2)
>>> print(p)
Point(x=1, y=2)
>>> p.x, p[1]
(1, 2)

<range> = range(stop)                # I.e. range(to_exclusive). Ints from 0 to `stop-1`.
<range> = range(start, stop)         # I.e. range(from, to_exc). From start to `stop-1`.
<range> = range(start, stop, step)   # I.e. range(from_inclusive, to_exclusive, ±step).

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

for i, el in enumerate(<coll>):
    print(f'Element {el} has index {i}.')

import itertools as it

<iter> = iter(<coll>)                    # Iterator that returns passed elements one by one.
<iter> = iter(<func>, to_exc)            # Calls `<func>()` until it receives 'to_exc' value.
<iter> = (<expr> for <name> in <coll>)   # E.g. `(i+1 for i in range(3))`. Evaluates lazily.
<el>   = next(<iter> [, default])        # Raises StopIteration or returns 'default' on end.
<list> = list(<iter>)                    # Returns a list of iterator's remaining elements.

<iter> = it.count(start=0, step=1)       # Returns updated 'start' endlessly. Accepts floats.
<iter> = it.repeat(<obj> [, times])      # Returns passed element endlessly or 'times' times.
<iter> = it.cycle(<coll>)                # Repeats the sequence endlessly. Accepts iterators.

<iter> = it.chain(<coll>, <coll>, ...)   # Returns each element of each collection in order.
<iter> = it.chain.from_iterable(<coll>)  # Accepts collection (i.e. iterable) of collections.
<iter> = it.islice(<coll>, stop)         # Also accepts 'start' and 'step'. Args can be None.
<iter> = it.product(<coll>, <coll>)      # Same as `((a, b) for a in arg_1 for b in arg_2)`.

def count(start, step):
    while True:
        yield start
        start += step

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

<type> = type(<obj>)                   # Object's type. Also `<obj>.__class__`.
<bool> = isinstance(<obj>, <type>)     # Also `issubclass(type(<obj>), <type>)`.

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

from types import FunctionType, MethodType, LambdaType, GeneratorType

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

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

<str>  = 'abc'                       # Also "abc". Interprets \n, \t, \x00-\xff, etc.

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

<list> = <str>.split()               # Splits it on one or more whitespace characters.
<list> = <str>.split(<str>)          # Splits on passed string. Also `maxsplit=<int>`.
<list> = <str>.splitlines()          # On [\n\r\f\v\x1c-\x1e\x85\u2028\u2029] and \r\n.
<str>  = <str>.join(<coll_of_str>)   # Joins items by using the string as a separator.

<bool> = <str> in <str>              # Returns True if string contains the substring.
<bool> = <str>.startswith(<str>)     # Pass tuple of strings to give multiple options.
<int>  = <str>.find(<str>)           # Returns start index of the first match or `-1`.

<str>  = <str>.lower()               # Lowers the case. Also upper/capitalize/title().
<str>  = <str>.casefold()            # Lower() that converts ẞ/ß to ss, Σ/ς to σ, etc.
<str>  = <str>.replace(old, new)     # Removes occurrences of string old if new is ''.
<str>  = <str>.translate(table)      # Get table via str.maketrans(<chr_to_str_dict>).

<str>  = chr(<int>)                  # Converts passed integer into Unicode character.
<int>  = ord(<str>)                  # Converts passed Unicode character into integer.

<bool> = <str>.isdecimal()           # Checks all chars for [0-9]. Also [०-९], [٠-٩].
<bool> = <str>.isdigit()             # Checks for [²³¹…] and isdecimal(). Also [፩-፱].
<bool> = <str>.isnumeric()           # Checks for [¼½¾…] and isdigit(). Also [零〇一…].
<bool> = <str>.isalnum()             # Checks for [ABC…] and isnumeric(). Also [ªµº…].
<bool> = <str>.isprintable()         # Checks for [ !"#…], basic emojis and isalnum().
<bool> = <str>.isspace()             # Checks for [ \t\n\r\f\v\x1c\x1d\x1e\x1f\x85…].

import re
<str>   = re.sub(r'<regex>', new, text)  # Substitutes occurrences with string 'new'.
<list>  = re.findall(r'<regex>', text)   # Returns all occurrences as string objects.
<list>  = re.split(r'<regex>', text)     # Add brackets around regex to keep matches.
<Match> = re.search(r'<regex>', text)    # Returns first occ. of the pattern or None.
<Match> = re.match(r'<regex>', text)     # Only searches at the start of the 'text'.
<iter>  = re.finditer(r'<regex>', text)  # Returns all occurrences as Match objects.

<str>   = <Match>.group()                # Returns the whole match. Also group(0).
<str>   = <Match>.group(1)               # Returns part inside the first brackets.
<tuple> = <Match>.groups()               # Returns all bracketed parts as strings.
<int>   = <Match>.start()                # Returns start index of the whole match.
<int>   = <Match>.end()                  # Returns the match's end index plus one.

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

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

{<obj>:<10}                             # '<obj>     '.
{<obj>:^10}                             # '  <obj>   '.
{<obj>:>10}                             # '     <obj>'.
{<obj>:.<10}                            # '<obj>.....'.
{<obj>:0}                               # '<obj>'.

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

{123456:10}                             # '    123456'.
{123456:10,}                            # '   123,456'.
{123456:10_}                            # '   123_456'.
{123456:+10}                            # '   +123456'.
{123456:=+10}                           # '+   123456'.

{1.23456:10.3}                          # '      1.23'.
{1.23456:10.3f}                         # '     1.235'.
{1.23456:10.3e}                         # ' 1.235e+00'.
{1.23456:10.3%}                         # '  123.456%'.

{90:x}                                  # Converts 90 to hexadecimal number '5a'.
{90:b}                                  # Converts 90 to binary number '1011010'.
{90:c}                                  # Converts 90 to Unicode character 'Z'.

<integer> = int(<float/str/bool>)             # A whole number. Truncates floats.
<float>   = float(<integer/str/bool>)         # 8-byte decimal. Also <fl>e±<int>.
<complex> = complex(real=0, imag=0)           # Complex number. Also <fl> ± <fl>j.
<Fract>   = fractions.Fraction(numr, denom)   # `<Fraction> = <Fraction> / <int>`.
<Decimal> = decimal.Decimal(<str/int/tup>)    # `Decimal((1, (2,), 3)) == -2000`.

<num> = abs(<num>)                            # E.g. `abs(-50) == abs(50) == 50`.
<num> = pow(<num>, <num>)                     # E.g. `pow(3, 4) == 3 ** 4 == 81`.
<num> = round(<num> [, ndigits])              # E.g. `round(123.45, -1) == 120`.
<num> = min(<coll_of_nums>)                   # Also `max(<num>, <num> [, ...])`.
<num> = sum(<coll_of_nums>)                   # Also `math.prod(<coll_of_nums>)`.

import math as mt
<num> = mt.pi/inf/nan                         # `inf*0` and `nan+1` return `nan`.
<num> = mt.sqrt/factorial(<num>)              # `sqrt(-1)` will raise ValueError.
<num> = mt.sin/cos/tan(<num>)                 # Also degrees, radians, asin, etc.
<num> = mt.log/log10/log2(<num>)              # Log() can accept 'base' argument.

import statistics as st
<obj>  = st.mean/median(<coll>)               # Mode returns most common element.
<num>  = st.variance/stdev(<coll>)            # Estimates values from the sample.
<list> = st.quantiles(<coll>, n=4)            # Estimates cut points from sample.

import random as rd
<num> = rd.random()                           # Selects random float from [0, 1).
<num> = rd.randint/uniform(a, b)              # Selects an int/float from [a, b].
<num> = rd.gauss(mean, stdev)                 # Also triangular(low, high, mode).
<obj> = rd.choice(<sequence>)                 # Doesn't mutate. Also sample(p, n).
rd.shuffle(<list>)                            # Works with all mutable sequences.

<int> = 0x<hex>                               # E.g. `0xFf == 255`. Also 0b<bin>.
<int> = int('±<hex>', 16)                     # Also int('±0x<hex>/±0b<bin>', 0).
<str> = hex(<int>)                            # Returns '[-]0x<hex>'. Also bin().

<int> = <int> & <int>                         # E.g. `0b1100 & 0b1010 == 0b1000`.
<int> = <int> | <int>                         # E.g. `0b1100 | 0b1010 == 0b1110`.
<int> = <int> ^ <int>                         # E.g. `0b1100 ^ 0b1010 == 0b0110`.
<int> = <int> << n_bits                       # E.g. `0b1111 << 4 == 0b11110000`.
<int> = ~<int>                                # E.g. `~100 == -(100+1) == -101`.

import itertools as it

>>> list(it.product('abc', repeat=2))        #   a  b  c
[('a', 'a'), ('a', 'b'), ('a', 'c'),         # a x  x  x
 ('b', 'a'), ('b', 'b'), ('b', 'c'),         # b x  x  x
 ('c', 'a'), ('c', 'b'), ('c', 'c')]         # c x  x  x

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

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

# $ pip3 install python-dateutil
from datetime import *
import zoneinfo, dateutil.tz

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

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

<tzinfo> = timezone.utc                     # Coordinated universal time. London without DST.
<tzinfo> = timezone(<timedelta>)            # Timezone with fixed offset from universal time.
<tzinfo> = dateutil.tz.tzlocal()            # Local timezone with dynamic offset from the UTC.
<tzinfo> = zoneinfo.ZoneInfo('<iana_key>')  # 'Continent/City_Name' zone with dynamic offset.
<DTa>    = <DT>.astimezone(<tzinfo>)        # Converts to the passed or local fixed timezone.
<Ta/DTa> = <T/DT>.replace(tzinfo=<tzinfo>)  # Changes the timezone object without conversion.

<D/T/DT> = D/T/DT.fromisoformat(<str>)      # Object from the ISO string. Raises ValueError.
<DT>     = DT.strptime(<str>, '<format>')   # Naive or aware datetime from the custom string.
<D/DTn>  = D/DT.fromordinal(<int>)          # Date or DT from days since the Gregorian NYE 1.
<DTn>    = DT.fromtimestamp(<float>)        # A local naive DT from seconds since the epoch.
<DTa>    = DT.fromtimestamp(<float>, <tz>)  # An aware datetime from seconds since the epoch.

<str>    = <D/T/DT>.isoformat(sep='T')      # Also `timespec='auto/hours/minutes/seconds/…'`.
<str>    = <D/T/DT>.strftime('<format>')    # Returns custom string representation of object.
<int>    = <D/DT>.toordinal()               # Days since NYE 1, ignoring DT's time and zone.
<float>  = <DTn>.timestamp()                # Seconds since the epoch from a local naive DT.
<float>  = <DTa>.timestamp()                # Seconds since the epoch from an aware datetime.

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

<bool>  =  <D/DTn>  >  <D/DTn>              # Ignores time jumps (fold attribute). Also `==`.
<bool>  =  <DTa>    >  <DTa>                # Ignores time jumps if they share tzinfo object.
<TD>    =  <D/DTn>  -  <D/DTn>              # Ignores jumps. Convert to UTC for actual delta.
<TD>    =  <DTa>    -  <DTa>                # Ignores jumps if they share the tzinfo object.
<D/DT>  =  <D/DT>   ±  <TD>                 # Returned datetime can fall into a missing hour.
<TD>    =  <TD>     ±  <TD>                 # Also `<TD> = abs(<TD>)`, `<num> = <TD> / <TD>`.

def my_func(<nondefault_args>): ...                   # E.g. `my_func(x, y):`.
def my_func(<default_args>): ...                      # E.g. `my_func(x=0, y=0):`.
def my_func(<nondef_args>, <def_args>): ...           # E.g. `my_func(x, y=0):`.

<obj> = <func>(<positional_args>)                     # E.g. `my_func(0, 0)`.
<obj> = <func>(<keyword_args>)                        # E.g. `my_func(x=0, y=0)`.
<obj> = <func>(<pos_args>, <key_args>)                # E.g. `my_func(0, y=0)`.

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

func(1, 2, z=3)

def add(*args):
    return sum(args)

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

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

<list>  = [*<coll> [, ...]]         # Same as `list(<coll>) [+ ...]`.
<tuple> = (*<coll>, [...])          # Same as `tuple(<coll>) [+ ...]`.
<set>   = {*<coll> [, ...]}         # Same as `set(<coll>) [| ...]`.
<dict>  = {**<dict> [, ...]}        # Last dict has priority. Also |.

<func> = lambda: <return_val>                     # A single statement function.
<func> = lambda <arg> [, ...]: <return_val>       # Also allows default arguments.

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

>>> [l+r for l in 'abc' for r in '123']           # Inner loop is on right side.
['a1', 'a2', 'a3', ..., 'c3']

from functools import reduce

<iter> = map(lambda x: x + 1, range(5))           # Returns `iter([1, 2, 3, 4, 5])`.
<iter> = filter(lambda x: x > 5, range(10))       # Returns `iter([6, 7, 8, 9])`.
<obj>  = reduce(lambda out, x: out+x, range(5))   # Returns 10. Accepts 'initial'.

<bool> = any(<collection>)                        # Is bool(<el>) True for any el?
<bool> = all(<collection>)                        # Is it True for all (or empty)?

<obj> = <exp> if <condition> else <exp>           # Evaluates only one expression.

>>> [i if i else 'zero' for i in (0, 1, 2)]       # `any(['', [], None])` is False.
['zero', 1, 2]

<obj> = <exp> and <exp> [and ...]                 # Returns first false or last obj.
<obj> = <exp> or <exp> [or ...]                   # Returns first true or last obj.

>>> [i for ch in '0123' if (i := int(ch))]        # Assigns to var in mid-sentence.
[1, 2, 3]

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

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

from dataclasses import make_dataclass
Player = make_dataclass('Player', ['p', 'd'])     # Creates a normal class.
player = Player(point, direction)                 # Returns its instance.

import <module>                      # Imports a built-in module or `<module>.py`.
import <package>                     # Built-in package or `<package>/__init__.py`.
import <package>.<module>            # Package's module or `<package>/<module>.py`.
from <pkg/mod>[.…] import <obj>      # Imports a module, class, func or variable.

def get_multiplier(a):
    def out(b):
        return a * b
    return out

>>> mul_by_3 = get_multiplier(3)
>>> mul_by_3(10)
30

def mul(a, b):
    return a * b

>>> import functools as ft
>>> mul_by_3 = ft.partial(mul, 3)
>>> mul_by_3(10)
30

def get_counter():
    i = 0
    def out():
        nonlocal i
        i += 1
        return i
    return out

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

@decorator_name
def func_that_is_passed_to_dec():
    ...

from functools import wraps

def debug(func):
    @wraps(func)
    def out(*args, **kwargs):
        print(func.__name__)
        return func(*args, **kwargs)
    return out

@debug
def add(x, y):
    return x + y

from functools import cache

@cache
def fibonacci(n):
    return n if n < 2 else fibonacci(n-2) + fibonacci(n-1)

from functools import wraps

def debug(print_result=False):
    def decorator(func):
        @wraps(func)
        def out(*args, **kwargs):
            print(func.__name__)
            res = func(*args, **kwargs)
            if print_result:
                print(res)
            return res
        return out
    return decorator

@debug(print_result=True)
def add(x, y):
    return x + y

class MyClass:
    def __init__(self, a):
        self.a = a
    def __str__(self):
        return str(self.a)
    def __repr__(self):
        class_name = self.__class__.__name__
        return f'{class_name}({self.a!r})'

    @classmethod
    def get_class_name(cls):
        return cls.__name__

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

f'{obj}'
str(obj)
print(obj)

f'{obj!r}'
str/repr/print([obj])
str/repr/print({obj: obj})
str/repr/print(MyDataClass(obj))

class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return f'Person({self.name!r})'
    def __lt__(self, other):
        return self.name < other.name

class Employee(Person):
    def __init__(self, name, staff_num):
        super().__init__(name)
        self.staff_num = staff_num
    def __repr__(self):
        return f'Employee({self.name!r}, {self.staff_num})'

>>> people = [Person('Bob'), Employee('Ann', 0)]
>>> sorted(people)
[Employee('Ann', 0), Person('Bob')]

from collections.abc import *

<name>: <type> [| ...] [= <obj>]
<name>: list/set/Iterable/Sequence[<type>] [= <obj>]
<name>: tuple/dict[<type>, ...] [= <obj>]

import dataclasses as dc

@dc.dataclass(order=False, frozen=False)
class MyClass:
    <attr_name>: <type>
    <attr_name>: <type> = <obj>
    <attr_name>: list = dc.field(default_factory=list)

P = dc.make_dataclass('P', ['x', 'y'])
P = dc.make_dataclass('P', [('x', float), ('y', float)])
P = dc.make_dataclass('P', [('x', float, 0), ('y', float, 0)])

class Person:
    @property
    def name(self):
        return ' '.join(self._name)

    @name.setter
    def name(self, value):
        self._name = value.split()

>>> person = Person()
>>> person.name = '\t Guido  van Rossum \n'
>>> person.name
'Guido van Rossum'

class Point:
    __slots__ = ('x', 'y')

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

class MyComparable:
    def __init__(self, a):
        self.a = a
    def __eq__(self, other):
        if isinstance(other, type(self)):
            return self.a == other.a
        return NotImplemented

class MyHashable:
    def __init__(self, a):
        self._a = a
    @property
    def a(self):
        return self._a
    def __eq__(self, other):
        if isinstance(other, type(self)):
            return self.a == other.a
        return NotImplemented
    def __hash__(self):
        return hash(self.a)

from functools import total_ordering

@total_ordering
class MySortable:
    def __init__(self, a):
        self.a = a
    def __eq__(self, other):
        if isinstance(other, type(self)):
            return self.a == other.a
        return NotImplemented
    def __lt__(self, other):
        if isinstance(other, type(self)):
            return self.a < other.a
        return NotImplemented

class Counter:
    def __init__(self):
        self.i = 0
    def __next__(self):
        self.i += 1
        return self.i
    def __iter__(self):
        return self

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

class Counter:
    def __init__(self):
        self.i = 0
    def __call__(self, step):
        self.i += step
        return self.i

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

class MyOpen:
    def __init__(self, filename):
        self.filename = filename
    def __enter__(self):
        self.file = open(self.filename)
        return self.file
    def __exit__(self, exc_type, exception, traceback):
        self.file.close()

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

class MyIterable:
    def __init__(self, a):
        self.a = a
    def __iter__(self):
        return iter(self.a)
    def __contains__(self, el):
        return el in self.a

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

class MyCollection:
    def __init__(self, a):
        self.a = a
    def __iter__(self):
        return iter(self.a)
    def __contains__(self, el):
        return el in self.a
    def __len__(self):
        return len(self.a)

class MySequence:
    def __init__(self, a):
        self.a = a
    def __iter__(self):
        return iter(self.a)
    def __contains__(self, el):
        return el in self.a
    def __len__(self):
        return len(self.a)
    def __getitem__(self, i):
        return self.a[i]
    def __reversed__(self):
        return reversed(self.a)

from collections import abc

class MyAbcSequence(abc.Sequence):
    def __init__(self, a):
        self.a = a
    def __len__(self):
        return len(self.a)
    def __getitem__(self, i):
        return self.a[i]

from enum import Enum, auto

class MyEnum(Enum):
    <member_name> = auto()             # An increment of last numeric value or 1.
    <member_name> = <value>            # Values don't have to be hashable/unique.
    <member_name> = <el>, <el>, ...    # Value can be a collection, e.g. a tuple.

<memb> = <enum>.<member_name>          # Accesses a member via enum's attribute.
<memb> = <enum>['<member_name>']       # Returns the member or raises KeyError.
<memb> = <enum>(<value>)               # Returns the member or raises ValueError.
<str>  = <member>.name                 # Returns the member's name as a string.
<obj>  = <member>.value                # Value can't be a user-defined function.

<list> = list(<enum>)                  # Returns a list containing every member.
<list> = <enum>._member_names_         # Returns a list containing member names.
<list> = [m.value for m in <enum>]     # Returns a list containing member values.

<enum> = type(<member>)                # Returns an enum. Also <memb>.__class__.
<iter> = itertools.cycle(<enum>)       # Returns an endless iterator of members.
<memb> = random.choice(list(<enum>))   # Randomly selects one of enum's members.

Cutlery = Enum('Cutlery', 'FORK KNIFE SPOON')
Cutlery = Enum('Cutlery', ['FORK', 'KNIFE', 'SPOON'])
Cutlery = Enum('Cutlery', {'FORK': 1, 'KNIFE': 2, 'SPOON': 3})

import functools as ft
and_ = ft.partial(lambda l, r: l and r)
or_ = ft.partial(lambda l, r: l or r)
LogicOp = Enum('LogicOp', {'AND': and_, 'OR': or_})

try:
    <code>
except <exception>:
    <code>

try:
    <code_1>
except <exception_a>:
    <code_2_a>
except <exception_b>:
    <code_2_b>
else:
    <code_2_c>
finally:
    <code_3>

except <exception>: ...
except <exception> as <name>: ...
except (<exception>, ...) [as <name>]: ...

raise <exception>
raise <exception>()
raise <exception>(<obj> [, ...])

except <exception> [as <name>]:
    ...
    raise

arguments = <name>.args
exc_type  = <name>.__class__
filename  = <name>.__traceback__.tb_frame.f_code.co_filename
func_name = <name>.__traceback__.tb_frame.f_code.co_name
line_str  = linecache.getline(filename, <name>.__traceback__.tb_lineno)
trace_str = ''.join(traceback.format_tb(<name>.__traceback__))
error_msg = ''.join(traceback.format_exception(*sys.exc_info()))

raise TypeError('Function received argument of the wrong type!')
raise ValueError('Argument has right type but its value is off!')
raise RuntimeError('I am too lazy to define my own exception!')

class MyError(Exception): pass
class MyInputError(MyError): pass

import sys
sys.exit()                     # Exits with exit code 0 (success).
sys.exit(<int>)                # Exits with the passed exit code.
sys.exit(<obj>)                # Prints to stderr and exits with 1.

print(<obj>, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

from pprint import pprint
pprint(<collection>, width=80, depth=None, compact=False)

<str> = input()

import sys
scripts_path = sys.argv[0]
arguments    = sys.argv[1:]

from argparse import ArgumentParser
p = ArgumentParser(description=<str>)                      # Also accepts 'usage' str.
p.add_argument('-<chr>', '--<name>', action='store_true')  # Flag (defaults to False).
p.add_argument('-<chr>', '--<name>', type=<type>)          # Option (defaults to None).
p.add_argument('<name>', type=<type>, nargs=1)             # Mandatory first argument.
p.add_argument('<name>', type=<type>, nargs='+')           # Mandatory remaining args.
p.add_argument('<name>', type=<type>, nargs='?')           # Optional argument. Also *.
args  = p.parse_args()                                     # Exits on a parsing error.
<obj> = args.<name>                                        # Returns `<type>(<arg>)`.

<file> = open(<path>, mode='r', encoding=None, newline=None)

<file>.seek(0)                    # Moves current position to the file's start.
<file>.seek(offset)               # Moves 'offset' chars/bytes from the start.
<file>.seek(0, 2)                 # Moves current position to the end of file.
<b_file>.seek(±offset, origin)    # Origin: 0 start, 1 current position, 2 end.

<obj>  = <file>.read(size=-1)     # Reads 'size' chars/bytes or until the EOF.
<obj>  = <file>.readline()        # Returns a line or empty string/bytes on EOF.
<list> = <file>.readlines()       # Returns remaining lines. Also list(<file>).
<obj>  = next(<file>)             # Returns a line using the read-ahead buffer.

<file>.write(<obj>)               # Writes str or bytes object to write buffer.
<file>.writelines(<coll>)         # Writes a coll. of strings or bytes objects.
<file>.flush()                    # Flushes write buff. Runs every 4096/8192 B.
<file>.close()                    # Closes a file after flushing write buffer.

def read_file(filename):
    with open(filename, encoding='utf-8') as file:
        return file.readlines()

def write_to_file(filename, text):
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(text)

import os, glob
from pathlib import Path

<str>  = os.getcwd()                # Returns working dir. Starts as shell's `$PWD`.
<str>  = os.path.join(<path>, ...)  # Uses `os.sep` to join strings or Path objects.
<str>  = os.path.realpath(<path>)   # Resolves symlinks and calls os.path.abspath().

<str>  = os.path.basename(<path>)   # Returns final component (filename or dirname).
<str>  = os.path.dirname(<path>)    # Returns the path without its final component.
<tup.> = os.path.splitext(<path>)   # Splits on last period of the final component.

<list> = os.listdir(path='.')       # Returns all file/dir names located at 'path'.
<list> = glob.glob('<pattern>')     # Returns paths matching the wildcard pattern.

<bool> = os.path.exists(<path>)     # Checks if path exists. Also <Path>.exists().
<bool> = os.path.isfile(<path>)     # Also <Path>.is_file(), <DirEntry>.is_file().
<bool> = os.path.isdir(<path>)      # Also <Path>.is_dir() and <DirEntry>.is_dir().

<stat> = os.stat(<path>)            # A status object. Also <Path/DirEntry>.stat().
<num>  = <stat>.st_size/st_mtime/…  # Returns size in bytes, modification time, ...

<iter> = os.scandir(path='.')       # Returns DirEntry objects located at the path.
<str>  = <DirEntry>.path            # Is absolute if 'path' argument was absolute.
<str>  = <DirEntry>.name            # Returns the path's final component as string.
<file> = open(<DirEntry>)           # Opens the file and returns its file object.

<Path> = Path(<path> [, ...])       # Accepts strings, Paths, and DirEntry objects.
<Path> = <path> / <path> [/ ...]    # First or second object must be a Path object.
<Path> = <Path>.resolve()           # Returns absolute path with resolved symlinks.

<Path> = Path()                     # Returns current working dir. Also Path('.').
<Path> = Path.cwd()                 # Returns absolute CWD. Also Path().resolve().
<Path> = Path.home()                # Returns the user's absolute home directory.
<Path> = Path(__file__)             # Use resolve() to get module's absolute path.

<Path> = <Path>.parent              # Returns the path without its final component.
<str>  = <Path>.name                # Returns final component (i.e. file/dirname).
<str>  = <Path>.suffix              # Returns the name's last extension with a dot.
<str>  = <Path>.stem                # Returns the name without its last extension.
<tup.> = <Path>.parts               # Starts with '/' or 'C:\' if path is absolute.

<iter> = <Path>.iterdir()           # Returns directory contents as Path objects.
<iter> = <Path>.glob('<patt>')      # Returns Paths matching the wildcard pattern.

<str>  = str(<Path>)                # Returns path as string. Also <Path>.as_uri().
<file> = open(<Path>)               # Also <Path>.read_text/write_bytes/…(<args>).

import os, shutil as sh

os.chdir(<path>)               # Changes the current working directory (or CWD).
os.mkdir(<path>)               # Creates dir. Set permissions with `mode=0o777`.
os.makedirs(<path>)            # Creates all path's dirs. Also `exist_ok=False`.

sh.copy(from, to)              # Copies file (arg. 'to' can exist or be a dir).
sh.copy2(from, to)             # Also copies the creation and modification time.
sh.copytree(from, to)          # Copies directory (arg. 'to' should not exist).

os.rename(from, to)            # Renames or moves the file or directory 'from'.
os.replace(from, to)           # Same, but overwrites file 'to' even on Windows.
sh.move(from, to)              # `rename()` that moves into 'to' if it's a dir.

os.remove(<path>)              # Deletes file. Also `$ pip3 install send2trash`.
os.rmdir(<path>)               # Deletes empty dir. Raises OSError if it's not.
sh.rmtree(<path>)              # Deletes the directory and all of its contents.

import os, subprocess as sp

<int>  = os.system('<cmds>')    # Runs commands in sh/cmd shell. Prints results.
<proc> = sp.run(<str/list>)     # For parameters see examples. Prints by default.
<pipe> = os.popen('<cmds>')     # Prints only stderr. Soft deprecated since 3.14.
<str>  = <pipe>.read()          # Returns combined stdout. Provides readline/s().
<int>  = <pipe>.close()         # Returns None if last command had returncode 0.

>>> sp.run('bc', input='1+1\n', capture_output=True, text=True)
CompletedProcess(args='bc', returncode=0, stdout='2\n', stderr='')

>>> if os.system('echo 1+1 > test.in') == 0:
...     with open('test.in') as in_, open('test.out', 'w') as out:
...         sp.run(shlex.split('bc -s'), stdin=in_, stdout=out)
...     print(open('test.out').read())
2

import json
<str>  = json.dumps(<list/dict>)  # Converts collection to JSON string.
<coll> = json.loads(<str>)        # Converts JSON string to collection.

def read_json_file(filename):
    with open(filename, encoding='utf-8') as file:
        return json.load(file)

def write_to_json_file(filename, coll):
    with open(filename, 'w', encoding='utf-8') as file:
        json.dump(coll, file, ensure_ascii=False, indent=2)

import pickle
<bytes>  = pickle.dumps(<object>)  # Converts object to bytes object.
<object> = pickle.loads(<bytes>)   # Converts bytes object to object.

def read_pickle_file(filename):
    with open(filename, 'rb') as file:
        return pickle.load(file)

def write_to_pickle_file(filename, an_object):
    with open(filename, 'wb') as file:
        pickle.dump(an_object, file)

import csv

<file> = open(<path>, newline='')              # Opens the text file for reading.
<read> = csv.reader(<file>, 'excel')           # Also `delimiter=','`. See Params.
<list> = next(<read>)                          # Returns a row as list of strings.
<list> = list(<read>)                          # Returns list of remaining rows.

<file>  = open(<path>, 'a', newline='')        # Opens the text file for writing.
<write> = csv.writer(<file>, 'excel')          # Also `delimiter=','`. See Params.
<write>.writerow(<collection>)                 # Encodes objects using str(<obj>).
<write>.writerows(<coll_of_coll>)              # Appends rows to the opened file.

def read_csv_file(filename, **csv_params):
    with open(filename, encoding='utf-8', newline='') as file:
        return list(csv.reader(file, **csv_params))

def write_to_csv_file(filename, rows, mode='w', **csv_params):
    with open(filename, mode, encoding='utf-8', newline='') as file:
        writer = csv.writer(file, **csv_params)
        writer.writerows(rows)

import sqlite3
<con> = sqlite3.connect(<path>)        # Opens existing or new file. Also ':memory:'.
<con>.close()                          # Closes connection. Discards uncommitted data.

<cursor> = <con>.execute('SELECT …')   # Can raise a subclass of the `sqlite3.Error`.
<tuple>  = <cursor>.fetchone()         # Returns the next row. Same as next(<cursor>).
<list>   = <cursor>.fetchall()         # Returns remaining rows. Also list(<cursor>).

<con>.execute('INSERT …')              # Can raise a subclass of the `sqlite3.Error`.
<con>.commit()                         # Saves all the changes since the last commit.
<con>.rollback()                       # Discards all changes since the last commit.

with <con>:                            # Exits the block with commit() or rollback(),
    <con>.execute('INSERT …')          # depending on whether any exception occurred.

<con>.execute(<sql>, <list/tuple>)     # Replaces every '?' with corresponding item.
<con>.execute(<sql>, <dict/namedtup>)  # Replaces every ':<key>' with matching value.
<con>.executemany(<sql>, <colls>)      # Executes statement once for each collection.

>>> con = sqlite3.connect('test.db')
>>> con.execute('CREATE TABLE person (name TEXT, height INTEGER) STRICT')
>>> con.execute('INSERT INTO person VALUES (?, ?)', ('Jean-Luc', 187))
>>> con.execute('SELECT rowid, * FROM person').fetchall()
[(1, 'Jean-Luc', 187)]

# $ pip3 install sqlalchemy
import sqlalchemy as sa
<eng> = sa.create_engine(<url>)        # Url: 'dialect://user:password@host/dbname'.
<con> = <eng>.connect()                # Creates new connection. Also <con>.close().
<cur> = <con>.execute(sa.text(<sql>))  # Add dict to execute() to replace ':<key>'s.
with <con>.begin(): ...                # Exits the block with a commit or rollback.

<bytes> = b'<str>'                   # Accepts ASCII characters and \x00 to \xff.
<int>   = <bytes>[index]             # Returns the byte as int between 0 and 255.
<bytes> = <bytes>[<slice>]           # Returns bytes even if it has one element.
<bytes> = <bytes>.join(<coll>)       # Joins bytes objects using bytes as a sep.

<bytes> = bytes(<ints>)              # Accepts coll of integers between 0 and 255.
<bytes> = bytes(<str>, 'utf-8')      # Encodes the string. Same as <str>.encode().
<bytes> = bytes.fromhex('<hex>')     # Hex pairs can be separated by whitespaces.
<bytes> = <int>.to_bytes(n_bytes)    # Accepts `byteorder='little', signed=True`.

<list>  = list(<bytes>)              # Returns a list of ints between 0 and 255.
<str>   = str(<bytes>, 'utf-8')      # Returns a string. Same as <bytes>.decode().
<str>   = <bytes>.hex()              # Returns hex pairs separated by `sep=<str>`.
<int>   = int.from_bytes(<bytes>)    # Accepts `byteorder='little', signed=True`.

def read_bytes(filename):
    with open(filename, 'rb') as file:
        return file.read()

def write_bytes(filename, bytes_obj):
    with open(filename, 'wb') as file:
        file.write(bytes_obj)

from struct import pack, unpack

<bytes> = pack('<format>', <num>, ...)  # Packs numbers according to format.
<tuple> = unpack('<format>', <bytes>)   # Use `iter_unpack()` to get tuples.

>>> pack('>hhl', 1, 2, 3)
b'\x00\x01\x00\x02\x00\x00\x00\x03'
>>> unpack('bhh', b'\x01\x00\x02\x00\x03\x00')
(1, 2, 3)

from array import array

<array> = array('<ctype>' [, <coll>])  # Creates array. Accepts collection of numbers.
<array> = array('<ctype>', <bytes>)    # Copies passed bytes into the array's memory.
<array> = array('<ctype>', <array>)    # Treats passed array as a sequence of numbers.
<array>.fromfile(<file>, n_items)      # Appends file contents to the array's memory.

<bytes> = bytes(<array>)               # Returns copy of the memory as a bytes object.
<file>.write(<array>)                  # Appends the array's memory to a binary file.

<mview> = memoryview(<bytes/array>)  # Returns mutable memoryview if array is passed.
<obj>   = <mview>[index]             # Returns an int/float. Bytes if format is 'c'.
<mview> = <mview>[<slice>]           # Returns a memoryview with rearranged elements.
<mview> = <mview>.cast('<ctype>')    # Only works between B/b/c and the other types.
<mview>.release()                    # Releases the memory buffer of the base object.

<bytes> = bytes(<mview>)             # Returns a new bytes object. Also bytearray().
<bytes> = <bytes>.join(<coll>)       # Joins memoryviews using bytes as a separator.
<array> = array('<ctype>', <mview>)  # Treats passed mview as a sequence of numbers.
<file>.write(<mview>)                # Appends `bytes(<mview>)` to the binary file.

<list>  = list(<mview>)              # Returns list of ints, floats or bytes objects.
<str>   = str(<mview>, 'utf-8')      # Treats passed memoryview as `bytes(<mview>)`.
<str>   = <mview>.hex()              # Returns hex pairs separated with `sep=<str>`.

from collections import deque

<deque> = deque(<coll>)           # Pass `maxlen=<int>` to set the size limit.
<deque>.appendleft(<el>)          # Drops last element if maxlen is exceeded.
<deque>.extendleft(<coll>)        # Prepends reversed collection to the deque.
<deque>.rotate(n=1)               # Moves last element to the start of deque.
<el> = <deque>.popleft()          # Removes and returns deque's first element.

import operator as op

<bool> = op.not_(<obj>)                                    # or, and, not (or/and missing).
<bool> = op.eq/ne/lt/ge/is_/is_not/contains(<obj>, <obj>)  # ==, !=, <, >=, is, is not, in.
<obj>  = op.or_/xor/and_(<int/set>, <int/set>)             # |, ^, & (sorted by precedence).
<int>  = op.lshift/rshift(<int>, <int>)                    # <<, >> (i.e. <int> << n_bits).
<obj>  = op.add/sub(<obj>, <obj>)                          # +, - (e.g. 'a' + 'b' == 'ab').
<obj>  = op.mul/truediv/floordiv/mod(<obj>, <obj>)         # *, /, //, % (evaluated l to r).
<num>  = op.neg/invert(<num>)                              # -, ~ (negate and bitwise not).
<num>  = op.pow(<num>, <num>)                              # ** (pow() accepts 3 arguments).
<func> = op.itemgetter/attrgetter/methodcaller(<obj>, …)   # [i/key], .attr_name, .name(…).

elementwise_sum  = map(op.add, list_a, list_b)
sorted_by_second = sorted(<coll>, key=op.itemgetter(1))
sorted_by_both   = sorted(<coll>, key=op.itemgetter(1, 0))

match <obj/expr>:
    case <pattern> [if <cond>]:
        <code>
    ...

<val_patt> = 1/'a'/True/None/math.pi     # Matches the literal or attribute's value.
<cls_patt> = <type>()                    # Matches any object of that type (or ABC).
<wildcard> = _                           # Matches any object. Useful in last case.
<capture>  = <name>                      # Matches any object and binds it to name.
<as_patt>  = <pattern> as <name>         # Binds match to name. Also <type>(<name>).
<or_patt>  = <pattern> | ...             # Matches if any of listed patterns match.
<seq_patt> = [<pattern>, ...]            # Matches a sequence. All items must match.
<map_patt> = {<val_patt>: <patt>, ...}   # Matches a dict if it has matching items.
<cls_patt> = <type>(<name>=<patt>, ...)  # Matches object with matching attributes.

>>> from pathlib import Path
>>> match Path('/home/bwk/documents/README.md'):
...     case Path(
...         parts=['/', 'home', user, *_, name]
...     ) as p if p.is_file() and 'readme' in name.lower():
...         print(f"{name} is {user}'s readme file.")
README.md is bwk's readme file.

import logging as log

log.basicConfig(filename=<path>)                # Configures the root logger (see Setup).
log.debug/info/warning/error/critical(<str>)    # Sends passed message to the root logger.
<Logger> = log.getLogger(__name__)              # Returns a logger named after the module.
<Logger>.<level>(<str>)                         # Sends the message. Same levels as above.
<Logger>.exception(<str>)                       # `error()` that appends caught exception.

log.basicConfig(
  filename=None,                                # Prints to stderr when filename is None.
  filemode='a',                                 # Use mode 'w' to overwrite existing file.
  format='%(levelname)s:%(name)s:%(message)s',  # Using '%(asctime)s' adds local datetime.
  level=log.WARNING,                            # Drops messages that have lower priority.
  handlers=[log.StreamHandler(sys.stderr)]      # Uses FileHandler when 'filename' is set.
)

<Formatr> = log.Formatter('<format>')           # Formats messages using the format str.
<Handler> = log.FileHandler(<path>, mode='a')   # Appends to file. Also `encoding=None`.
<Handler>.setFormatter(<Formatter>)             # Only outputs bare messages by default.
<Handler>.setLevel(<str/int>)                   # Prints/saves every message by default.
<Logger>.addHandler(<Handler>)                  # Loggers can have more than one handler.
<Logger>.setLevel(<str/int>)                    # What's sent to its/ancestors' handlers.
<Logger>.propagate = <bool>                     # Cuts off ancestors' handlers if False.