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

<list> = <list>[from_inclusive : to_exclusive : ±step_size]

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

<list>.sort()
<list>.reverse()
<list> = sorted(<collection>)
<iter> = reversed(<list>)

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

<list>.insert(<int>, <el>)     # Inserts item at index and moves the rest to the right. <el> = <list>.pop([<int>])    # Returns and removes item at index or from the end. <int> = <list>.count(<el>)     # Returns number of occurrences. Also works on strings. <int> = <list>.index(<el>)     # Returns index of the first occurrence or raises ValueError. <list>.remove(<el>)            # Removes first occurrence of the item or raises ValueError. <list>.clear()                 # Removes all items. Also works on dictionary and set.

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

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

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

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

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

<set> = set()

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

<set> = <set>.union(<coll.>)                   # Or: <set> | <set> <set> = <set>.intersection(<coll.>)            # Or: <set> & <set> <set> = <set>.difference(<coll.>)              # Or: <set> - <set> <set> = <set>.symmetric_difference(<coll.>)    # Or: <set> ^ <set> <bool> = <set>.issubset(<coll.>)                # Or: <set> <= <set> <bool> = <set>.issuperset(<coll.>)              # Or: <set> >= <set>

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

<frozenset> = frozenset(<collection>)

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

>>> from collections import namedtuple >>> Point = namedtuple('Point', 'x y')
>>> p = Point(1, y=2)
Point(x=1, y=2)
>>> p[0]
1 >>> p.x 1 >>> getattr(p, 'y')
2 >>> p._fields # Or: Point._fields
('x', 'y')

<range> = range(to_exclusive)
<range> = range(from_inclusive, to_exclusive)
<range> = range(from_inclusive, to_exclusive, ±step_size)

from_inclusive = <range>.start to_exclusive = <range>.stop

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

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

from itertools import count, repeat, cycle, chain, islice

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

<iter> = chain(<coll_1>, <coll_2> [, ...])  # Empties collections in order. <iter> = chain.from_iterable(<collection>)  # Empties collections inside a collection in order.

<iter> = islice(<coll>, to_exclusive)       # Only returns first 'to_exclusive' elements. <iter> = islice(<coll>, from_inclusive, …)  # `to_exclusive, step_size`.

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(<el>)                          # Or: <el>.__class__ <bool> = isinstance(<el>, <type>)            # Or: issubclass(type(<el>), <type>)

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

from types import FunctionType, MethodType, LambdaType, GeneratorType

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

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

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

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

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

<str> = <str>.replace(old, new [, count])   # Replaces 'old' with 'new' at most 'count' times. <str> = <str>.translate(<table>)            # Use `str.maketrans(<dict>)` to generate table.

<str> = chr(<int>)                          # Converts int to Unicode char. <int> = ord(<str>)                          # Converts Unicode char to int.

import re <str> = re.sub(<regex>, new, text, count=0)  # Substitutes all occurrences with 'new'. <list> = re.findall(<regex>, text)            # Returns all occurrences as strings. <list> = re.split(<regex>, text, maxsplit=0)  # Use brackets in regex to include the matches. <Match> = re.search(<regex>, text)             # Searches for first occurrence of the pattern. <Match> = re.match(<regex>, text)              # Searches only at the beginning of the text. <iter> = re.finditer(<regex>, text)           # Returns all occurrences as match objects.

<str> = <Match>.group()                      # Returns the whole match. Also group(0). <str> = <Match>.group(1)                     # Returns part in the first bracket. <tuple> = <Match>.groups()                     # Returns all bracketed parts. <int> = <Match>.start()                      # Returns start index of the match. <int> = <Match>.end()                        # Returns exclusive end index of the match.

'\d' == '[0-9]' # Matches decimal characters. '\w' == '[a-zA-Z0-9_]' # Matches alphanumerics and underscore. '\s' == '[ \t\n\r\f\v]' # Matches whitespaces.

<str> = f'{<el_1>}, {<el_2>}' <str> = '{}, {}'.format(<el_1>, <el_2>)

>>> from collections import namedtuple >>> Person = namedtuple('Person', 'name height')
>>> person = Person('Jean-Luc', 187)
>>> f'{person.height}' '187' >>> '{p.height}'.format(p=person)
'187'

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

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

{ 123456:10,}                                  # '   123,456'
{ 123456:10_}                                  # '   123_456'
{ 123456:+10}                                  # '   +123456'
{-123456:=10}                                  # '-   123456'
{ 123456: }                                    # ' 123456'
{-123456: }                                    # '-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:c}                                   # 'Z'
{90:b}                                   # '1011010'
{90:X}                                   # '5A'

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

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

from math import e, pi, inf, nan, isinf, isnan from math import sin, cos, tan, asin, acos, atan, degrees, radians from math import log, log10, log2

from statistics import mean, median, variance, stdev, pvariance, pstdev

from random import random, randint, choice, shuffle, gauss, seed <float> = random()                       # A float inside [0, 1). <int> = randint(from_inc, to_inc)      # An int inside [from_inc, to_inc]. <el> = choice(<list>)                 # Keeps the list intact.

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

<int> = <int> & <int> # And <int> = <int> | <int> # Or <int> = <int> ^ <int> # Xor (0 if both bits equal) <int> = <int> << n_bits # Left shift (>> for right) <int> = ~<int> # Not (also: -<int> - 1)

from itertools import product, combinations, combinations_with_replacement, permutations

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

>>> product('abc', 'abc')                    #   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

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

>>> combinations_with_replacement('abc', 2)  #   a  b  c
[('a', 'a'), ('a', 'b'), ('a', 'c'),         # a x  x  x
 ('b', 'b'), ('b', 'c'),                     # b .  x  x
 ('c', 'c')]                                 # c .  .  x

>>> 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  .

from datetime import date, time, datetime, timedelta from dateutil.tz import UTC, tzlocal, gettz, datetime_exists, resolve_imaginary

<D> = date(year, month, day)
<T> = time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)
<DT> = datetime(year, month, day, hour=0, minute=0, second=0, ...)
<TD> = timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,
                 minutes=0, hours=0, weeks=0)

<D/DTn> = D/DT.today()                     # Current local date or naive datetime. <DTn> = DT.utcnow()                      # Naive datetime from current UTC time. <DTa> = DT.now(<tzinfo>)                 # Aware datetime from current tz time.

<tzinfo> = UTC # UTC timezone. London without DST. <tzinfo> = tzlocal()                        # Local timezone. Also gettz(). <tzinfo> = gettz('<Continent>/<City>')      # 'Continent/City_Name' timezone or None. <DTa> = <DT>.astimezone(<tzinfo>)        # Datetime, converted to the passed timezone. <Ta/DTa> = <T/DT>.replace(tzinfo=<tzinfo>)  # Unconverted object with a new timezone.

<D/T/DT> = D/T/DT.fromisoformat('<iso>')    # Object from ISO string. Raises ValueError. <DT> = DT.strptime(<str>, '<format>')   # Datetime from str, according to format. <D/DTn> = D/DT.fromordinal(<int>)          # D/DTn from days since the Gregorian NYE 1. <DTn> = DT.fromtimestamp(<real>)         # Local time DTn from seconds since the Epoch. <DTa> = DT.fromtimestamp(<real>, <tz.>)  # 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>')    # Custom string representation. <int> = <D/DT>.toordinal()               # Days since Gregorian NYE 1, ignoring time and tz. <float> = <DTn>.timestamp()                # Seconds since the Epoch, from DTn in local tz. <float> = <DTa>.timestamp()                # Seconds since the Epoch, from DTa.

>>> from datetime import datetime >>> dt = datetime.strptime('2015-05-14 23:39:00.00 +0200', '%Y-%m-%d %H:%M:%S.%f %z')
>>> dt.strftime("%A, %dth of %B '%y, %I:%M%p %Z")
"Thursday, 14th of May '15, 11:39PM UTC+02:00"

<D/DT> = <D/DT>   ± <TD> # Returned datetime can fall into missing hour. <TD> = <D/DTn> - <D/DTn> # Returns the difference, ignoring time jumps. <TD> = <DTa> - <DTa> # Ignores time jumps if they share tzinfo object. <TD> = <DT_UTC> - <DT_UTC> # Convert DTs to UTC to get the actual delta.

<function>(<positional_args>)                  # f(0, 0) <function>(<keyword_args>)                     # f(x=0, y=0) <function>(<positional_args>, <keyword_args>)  # f(0, y=0)

def f(<nondefault_args>):                      # def f(x, y): def f(<default_args>):                         # def f(x=0, y=0): def f(<nondefault_args>, <default_args>):      # def f(x, y=0):

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

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

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

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

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

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

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

def 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) def 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) def f(*args, y, **kwargs):     # f(x=1, y=2, z=3) | f(1, y=2, z=3) def f(x, *args, z, **kwargs):  # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3)

<list> = [*<collection> [, ...]]
<set> = {*<collection> [, ...]}
<tup.> = (*<collection>, [...])
<dict> = {**<dict> [, ...]}

head, *body, tail = <collection>

<func> = lambda: <return_value> <func> = lambda <arg_1>, <arg_2>: <return_value>

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

>>> [l+r for l in 'abc' for r in 'abc']
['aa', 'ab', 'ac', ..., 'cc']

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

<bool> = any(<collection>)                                # False if empty. <bool> = all(el[1] for el in <collection>)                # True if empty.

<obj> = <exp_if_true> if <condition> else <exp_if_false>

>>> [a if a else 'zero' for a in (0, 1, 2, 3)]
['zero', 1, 2, 3]

from collections import namedtuple Point = namedtuple('Point', 'x y')
point = Point(0, 0)

from enum import Enum Direction = Enum('Direction', 'n e s w')
direction = Direction.n

from dataclasses import make_dataclass Creature = make_dataclass('Creature', ['loc', 'dir'])
creature = Creature(Point(0, 0), Direction.n)

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

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

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

>>> import operator as op >>> multiply_by_3 = partial(op.mul, 3)
>>> multiply_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 function_that_gets_passed_to_decorator():
    ...

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 lru_cache @lru_cache(maxsize=None) def fib(n):
    return n if n < 2 else fib(n-2) + fib(n-1)

from functools import wraps def debug(print_result=False):
    def decorator(func):
        @wraps(func) def out(*args, **kwargs):
            result = func(*args, **kwargs)
            print(func.__name__, result if print_result else '')
            return result return out return decorator @debug(print_result=True) def add(x, y):
    return x + y

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

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

print(<el>)
print(f'{<el>}')
raise Exception(<el>)
loguru.logger.debug(<el>)
csv.writer(<file>).writerow([<el>])

print([<el>])
print(f'{<el>!r}')
>>> <el> loguru.logger.exception()
Z = dataclasses.make_dataclass('Z', ['a']); print(Z(<el>))

class <name>:
    def __init__(self, a=None):
        self.a = a

class Person:
    def __init__(self, name, age):
        self.name = name self.age = age class Employee(Person):
    def __init__(self, name, age, staff_num):
        super().__init__(name, age)
        self.staff_num = staff_num

class A: pass class B: pass class C(A, B): pass

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

class MyClass:
    @property def a(self):
        return self._a @a.setter def a(self, value):
        self._a = value

>>> el = MyClass()
>>> el.a = 123 >>> el.a 123

from dataclasses import dataclass, field @dataclass(order=False, frozen=False) class <class_name>:
    <attr_name_1>: <type> <attr_name_2>: <type> = <default_value> <attr_name_3>: list/dict/set = field(default_factory=list/dict/set)

from dataclasses import make_dataclass <class> = make_dataclass('<class_name>', <coll_of_attribute_names>)
<class> = make_dataclass('<class_name>', <coll_of_tuples>)
<tuple> = ('<attr_name>', <type> [, <default_value>])

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

from copy import copy, deepcopy <object> = copy(<object>)
<object> = 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):
        self.i += 1 return self.i

>>> counter = Counter()
>>> counter(), counter(), counter()
(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 <enum_name>(Enum):
    <member_name_1> = <value_1> <member_name_2> = <value_2_a>, <value_2_b> <member_name_3> = auto()

<member> = <enum>.<member_name> # Returns a member. <member> = <enum>['<member_name>']              # Returns a member or raises KeyError. <member> = <enum>(<value>)                      # Returns a member or raises ValueError. <str> = <member>.name # Returns member's name. <obj> = <member>.value # Returns member's value.

list_of_members = list(<enum>)
member_names = [a.name for a in <enum>]
member_values = [a.value for a in <enum>]
random_member = random.choice(list(<enum>))

def get_next_member(member):
    members = list(member.__class__)
    index = (members.index(member) + 1) % len(members)
    return members[index]

Cutlery = Enum('Cutlery', 'fork knife spoon')
Cutlery = Enum('Cutlery', ['fork', 'knife', 'spoon'])
Cutlery = Enum('Cutlery', {'fork': 1, 'knife': 2, 'spoon': 3})

from functools import partial LogicOp = Enum('LogicOp', {'AND': partial(lambda l, r: l and r),
                           'OR' : partial(lambda l, r: l or r)})

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>, [...]):
except (<exception>, [...]) as <name>:

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

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 = linecache.getline(filename, <name>.__traceback__.tb_lineno)
error_msg = ''.join(traceback.format_exception(exc_type, <name>, <name>.__traceback__))

raise TypeError('Argument is of wrong type!')
raise ValueError('Argument is of right type but inappropriate value!')
raise RuntimeError('None of above!')

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

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

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

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

<str> = input(prompt=None)

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

from argparse import ArgumentParser, FileType p = ArgumentParser(description=<str>)
p.add_argument('-<short_name>', '--<name>', action='store_true')  # Flag p.add_argument('-<short_name>', '--<name>', type=<type>)          # Option p.add_argument('<name>', type=<type>, nargs=1)                    # First argument p.add_argument('<name>', type=<type>, nargs='+')                  # Remaining arguments p.add_argument('<name>', type=<type>, nargs='*')                  # Optional arguments args = p.parse_args()                                            # Exits on error. value = args.<name>

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

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

<str/bytes> = <file>.read(size=-1)  # Reads 'size' chars/bytes or until EOF. <str/bytes> = <file>.readline()     # Returns a line or empty string/bytes on EOF. <list> = <file>.readlines()    # Returns a list of remaining lines. <str/bytes> = next(<file>)          # Returns a line using buffer. Do not mix.

<file>.write(<str/bytes>)           # Writes a string or bytes object. <file>.writelines(<collection>)     # Writes a coll. of strings or bytes objects. <file>.flush()                      # Flushes 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)

from os import getcwd, path, listdir from glob import glob

<str> = getcwd()                   # Returns the current working directory. <str> = path.join(<path>, ...)     # Joins two or more pathname components. <str> = path.abspath(<path>)       # Returns absolute path.

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

<list> = listdir(path='.')          # Returns filenames located at path. <list> = glob('<pattern>')          # Returns paths matching the wildcard pattern.

<bool> = path.exists(<path>)        # Or: <Path>.exists() <bool> = path.isfile(<path>)        # Or: <DirEntry/Path>.is_file() <bool> = path.isdir(<path>)         # Or: <DirEntry/Path>.is_dir()

from os import scandir

<iter> = scandir(path='.')          # Returns DirEntry objects located at path. <str> = <DirEntry>.path # Returns whole path as a string. <str> = <DirEntry>.name # Returns final component as a string. <file> = open(<DirEntry>)           # Opens the file and returns file object.

from pathlib import Path

<Path> = Path(<path> [, ...])       # Accepts strings, Paths and DirEntry objects. <Path> = <path> / <path> [/ ...]    # One of the paths must be a Path object.

<Path> = Path()                     # Returns relative cwd. Also Path('.'). <Path> = Path.cwd()                 # Returns absolute cwd. Also Path().resolve(). <Path> = Path.home()                # Returns user's home directory. <Path> = Path(__file__).resolve()   # Returns script's path if cwd wasn't changed.

<Path> = <Path>.parent # Returns Path without final component. <str> = <Path>.name # Returns final component as a string. <str> = <Path>.stem # Returns final component without extension. <str> = <Path>.suffix # Returns final component's extension. <tup.> = <Path>.parts # Returns all components as strings.

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

<str> = str(<Path>)                # Returns path as a string. <file> = open(<Path>)               # Opens the file and returns file object.

import os, shutil

os.chdir(<path>)                    # Changes the current working directory. os.mkdir(<path>, mode=0o777)        # Creates a directory. Mode is in octal. os.makedirs(<path>, mode=0o777)     # Creates all directories in the path.

shutil.copy(from, to)               # Copies the file. 'to' can exist or be a dir. shutil.copytree(from, to)           # Copies the directory. 'to' must not exist.

os.rename(from, to)                 # Renames/moves the file or directory. os.replace(from, to)                # Same, but overwrites 'to' if it exists.

os.remove(<path>)                   # Deletes the file. os.rmdir(<path>)                    # Deletes the empty directory. shutil.rmtree(<path>)               # Deletes the directory.

import os <str> = os.popen('<shell_command>').read()

>>> from subprocess import run >>> run('bc', input='1 + 1\n', capture_output=True, encoding='utf-8')
CompletedProcess(args='bc', returncode=0, stdout='2\n', stderr='')

>>> from shlex import split >>> os.popen('echo 1 + 1 > test.in')
>>> run(split('bc -s'), stdin=open('test.in'), stdout=open('test.out', 'w'))
CompletedProcess(args=['bc', '-s'], returncode=0)
>>> open('test.out').read()
'2\n'

import json <str> = json.dumps(<object>, ensure_ascii=True, indent=None)
<object> = json.loads(<str>)

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

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

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

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

<reader> = csv.reader(<file>)       # Also: `dialect='excel', delimiter=','`. <list> = next(<reader>)           # Returns next row as a list of strings. <list> = list(<reader>)           # Returns list of remaining rows.

<writer> = csv.writer(<file>)       # Also: `dialect='excel', delimiter=','`. <writer>.writerow(<collection>)     # Encodes objects using `str(<el>)`. <writer>.writerows(<coll_of_coll>)  # Appends multiple rows.

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

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

import sqlite3 <conn> = sqlite3.connect(<path>)                # Also ':memory:'. <conn>.close()                                  # Closes the connection.

<cursor> = <conn>.execute('<query>')            # Can raise a subclass of sqlite3.Error. <tuple> = <cursor>.fetchone()                  # Returns next row. Also next(<cursor>). <list> = <cursor>.fetchall()                  # Returns remaining rows. Also list(<cursor>).

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

with <conn>:                                    # Exits the block with commit() or rollback(), <conn>.execute('<query>')                   # depending on whether an exception occurred.

<conn>.execute('<query>', <list/tuple>)         # Replaces '?'s in query with values. <conn>.execute('<query>', <dict/namedtuple>)    # Replaces ':<key>'s with values. <conn>.executemany('<query>', <coll_of_above>)  # Runs execute() multiple times.

>>> conn = sqlite3.connect('test.db')
>>> conn.execute('CREATE TABLE person (person_id INTEGER PRIMARY KEY, name, height)')
>>> conn.execute('INSERT INTO person VALUES (NULL, ?, ?)', ('Jean-Luc', 187)).lastrowid 1 >>> conn.execute('SELECT * FROM person').fetchall()
[(1, 'Jean-Luc', 187)]

# $ pip3 install mysql-connector from mysql import connector <conn> = connector.connect(host=<str>, …)     # `user=<str>, password=<str>, database=<str>`. <cursor> = <conn>.cursor()                      # Only cursor has execute method. <cursor>.execute('<query>')                     # Can raise a subclass of connector.Error. <cursor>.execute('<query>', <list/tuple>)       # Replaces '%s's in query with values. <cursor>.execute('<query>', <dict/namedtuple>)  # Replaces '%(<key>)s's with values.

<bytes> = b'<str>' # Only accepts ASCII characters and \x00-\xff. <int> = <bytes>[<index>]               # Returns int in range from 0 to 255. <bytes> = <bytes>[<slice>]               # Returns bytes even if it has only one element. <bytes> = <bytes>.join(<coll_of_bytes>)  # Joins elements using bytes as a separator.

<bytes> = bytes(<coll_of_ints>)          # Ints must be in range from 0 to 255. <bytes> = bytes(<str>, 'utf-8')          # Or: <str>.encode('utf-8') <bytes> = <int>.to_bytes(n_bytes, …)     # `byteorder='big/little', signed=False`. <bytes> = bytes.fromhex('<hex>')         # Hex pairs can be separated by spaces.

<list> = list(<bytes>)                  # Returns ints in range from 0 to 255. <str> = str(<bytes>, 'utf-8')          # Or: <bytes>.decode('utf-8') <int> = int.from_bytes(<bytes>, …)     # `byteorder='big/little', signed=False`.
'<hex>' = <bytes>.hex()                  # Returns a string of hexadecimal pairs.

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, iter_unpack

<bytes> = pack('<format>', <num_1> [, <num_2>, ...])
<tuple> = unpack('<format>', <bytes>)
<tuples> = iter_unpack('<format>', <bytes>)

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

from array import array <array> = array('<typecode>', <collection>)    # Array from collection of numbers. <array> = array('<typecode>', <bytes>)         # Array from bytes object. <array> = array('<typecode>', <array>)         # Treats array as a sequence of numbers. <bytes> = bytes(<array>)                       # Or: <array>.tobytes() <file>.write(<array>)                          # Writes array to the binary file.

<mview> = memoryview(<bytes/bytearray/array>)  # Immutable if bytes, else mutable. <real> = <mview>[<index>]                     # Returns an int or a float. <mview> = <mview>[<slice>]                     # Mview with rearranged elements. <mview> = <mview>.cast('<typecode>')           # Casts memoryview to the new format. <mview>.release()                              # Releases the object's memory buffer.

<bytes> = bytes(<mview>)                       # Creates a new bytes object. <bytes> = <bytes>.join(<coll_of_mviews>)       # Joins mviews using bytes object as sep. <array> = array('<typecode>', <mview>)         # Treats mview as a sequence of numbers. <file>.write(<mview>)                          # Writes mview to the binary file.

<list> = list(<mview>)                        # Returns list of ints or floats. <str> = str(<mview>, 'utf-8')                # Treats mview as a bytes object. <int> = int.from_bytes(<mview>, …)           # `byteorder='big/little', signed=False`.
'<hex>' = <mview>.hex()                        # Treats mview as a bytes object.

from collections import deque <deque> = deque(<collection>, maxlen=None)

<deque>.appendleft(<el>)                       # Opposite element is dropped if full. <deque>.extendleft(<collection>)               # Collection gets reversed. <el> = <deque>.popleft()                       # Raises IndexError if empty. <deque>.rotate(n=1)                            # Rotates elements to the right.