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) forpairinzip(list_a, list_b)] sorted_by_second=sorted(<collection>, key=lambdael: el[1]) sorted_by_both=sorted(<collection>, key=lambdael: (el[1], el[0])) flatter_list=list(itertools.chain.from_iterable(<list>)) product_of_elems=functools.reduce(lambdaout, x: out*x, <collection>) list_of_chars=list(<str>)

<int>=<list>.count(<el>) # Returns number of occurrences. Also works on strings.index=<list>.index(<el>) # Returns index of first occurrence or raises ValueError.<list>.insert(index, <el>) # Inserts item at index and moves the rest to the right.<el>=<list>.pop([index]) # Removes and returns item at index or from the end.<list>.remove(<el>) # Removes first occurrence of 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.{kfork, vin<dict>.items() ifv==value} # Returns set of keys that point to the value.{k: vfork, vin<dict>.items() ifkinkeys} # Returns dictionary filtered by keys.

>>>fromcollectionsimportCounter>>>colors= ['blue', 'red', 'blue', 'red', 'blue'] >>>counter=Counter(colors) >>>counter['yellow'] +=1Counter({'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>, ) <tuple>= (<el_1>, <el_2> [, ...])

>>>fromcollectionsimportnamedtuple>>>Point=namedtuple('Point', 'x y') >>>p=Point(1, y=2) Point(x=1, y=2) >>>p[0] 1>>>p.x1>>>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>.startto_exclusive=<range>.stop

fori, elinenumerate(<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.

fromitertoolsimportcount, repeat, cycle, chain, islice

<iter>=count(start=0, step=1) # Returns incremented value endlessly.<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(<collection>, to_exclusive) <iter>=islice(<collection>, from_inclusive, to_exclusive [, +step_size])

defcount(start, step): whileTrue: yieldstartstart+=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'>)

fromtypesimportFunctionType, MethodType, LambdaType, GeneratorType

>>>fromcollections.abcimportSequence, Collection, Iterable>>>isinstance([1, 2, 3], Iterable) True

>>>fromnumbersimportIntegral, 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 line breaks. Keeps them if 'keepends'.<str>=<str>.join(<coll_of_strings>) # Joins elements using string as 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 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.

importre<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 whole match. Also group(0).<str>=<Match>.group(1) # Returns part in first bracket.<tuple>=<Match>.groups() # Returns all bracketed parts.<int>=<Match>.start() # Returns start index of a match.<int>=<Match>.end() # Returns exclusive end index of a match.

'\d'=='[0-9]'# Matches any digit.'\w'=='[a-zA-Z0-9_]'# Matches any alphanumeric.'\s'=='[ \t\n\r\f\v]'# Matches any whitespace.

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

>>>fromcollectionsimportnamedtuple>>>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':.3} # 'abc'{'abcde':10.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(numerator=0, denominator=1) <Decimal>=decimal.Decimal(<str/int/float>)

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

frommathimporte, pi, inf, nanfrommathimportcos, acos, sin, asin, tan, atan, degrees, radiansfrommathimportlog, log10, log2

fromstatisticsimportmean, median, variance, pvariance, pstdev

fromrandomimportrandom, randint, choice, shuffle<float>=random() <int>=randint(from_inclusive, to_inclusive) <el>=choice(<list>) shuffle(<list>)

<int>=0b<bin># Or: 0x<hex><int>=int('<bin>', 2) # Or: int('<hex>', 16)<int>=int('0b<bin>', 0) # Or: int('0x<hex>', 0)'0b<bin>'=bin(<int>) # Or: '0x<hex>' = hex(<int>)

<int>=<int>&<int># And<int>=<int>|<int># Or<int>=<int>^<int># Xor (0 if both bits equal)<int>=<int><<n_bits# Shift left<int>=<int>>>n_bits# Shift right<int>=~<int># Compliment (flips bits)

fromitertoolsimportproduct, combinations, combinations_with_replacement, permutations

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

>>>product('ab', '12') [('a', '1'), ('a', '2'), ('b', '1'), ('b', '2')]

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

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

>>>permutations('abc', 2) [('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]

fromdatetimeimportdate, time, datetime, timedeltafromdateutil.tzimportUTC, tzlocal, gettz, 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('<Cont.>/<City>') # 'Continent/City_Name' timezone or None.<DTa>=<DT>.astimezone(<tzinfo>) # Datetime, converted to passed timezone.<Ta/DTa>=<T/DT>.replace(tzinfo=<tzinfo>) # Unconverted object with 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 Christ, at midnight.<DTn>=DT.fromtimestamp(<real>) # Local time DTn from seconds since Epoch.<DTa>=DT.fromtimestamp(<real>, <tz.>) # Aware datetime from seconds since 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 Christ, ignoring time and tz.<float>=<DTn>.timestamp() # Seconds since Epoch from DTn in local time.<float>=<DTa>.timestamp() # Seconds since Epoch from DTa.

>>>fromdatetimeimportdatetime>>>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)

deff(<nondefault_args>): # def f(x, y):deff(<default_args>): # def f(x=0, y=0):deff(<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)

defadd(*a): returnsum(a)

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

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

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

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

deff(*args, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)deff(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)deff(*args, y, **kwargs): # f(x=1, y=2, z=3) | f(1, y=2, z=3)deff(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> [, ...]} <tuple>= (*<collection>, [...]) <dict>={**<dict> [, ...]}

head, *body, tail=<collection>

<function>=lambda: <return_value><function>=lambda<argument_1>, <argument_2>: <return_value>

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

out= [i+jforiinrange(10) forjinrange(10)]

out= [] foriinrange(10): forjinrange(10): out.append(i+j)

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

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

<obj>=<expression_if_true>if<condition>else<expression_if_false>

>>> [aifaelse'zero'forain (0, 1, 2, 3)] ['zero', 1, 2, 3]

fromcollectionsimportnamedtuplePoint=namedtuple('Point', 'x y') point=Point(0, 0)

fromenumimportEnumDirection=Enum('Direction', 'n e s w') direction=Direction.n

fromdataclassesimportmake_dataclassCreature=make_dataclass('Creature', ['location', 'direction']) creature=Creature(Point(0, 0), Direction.n)

defget_multiplier(a): defout(b): returna*breturnout

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

fromfunctoolsimportpartial<function>=partial(<function> [, <arg_1>, <arg_2>, ...])

>>>importoperatorasop>>>multiply_by_3=partial(op.mul, 3) >>>multiply_by_3(10) 30

defget_counter(): i=0defout(): nonlocalii+=1returnireturnout

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

@decorator_namedeffunction_that_gets_passed_to_decorator(): ...

fromfunctoolsimportwrapsdefdebug(func): @wraps(func)defout(*args, **kwargs): print(func.__name__) returnfunc(*args, **kwargs) returnout@debugdefadd(x, y): returnx+y

fromfunctoolsimportlru_cache@lru_cache(maxsize=None)deffib(n): returnnifn<2elsefib(n-2) +fib(n-1)

fromfunctoolsimportwrapsdefdebug(print_result=False): defdecorator(func): @wraps(func)defout(*args, **kwargs): result=func(*args, **kwargs) print(func.__name__, resultifprint_resultelse'') returnresultreturnoutreturndecorator@debug(print_result=True)defadd(x, y): returnx+y

class<name>: def__init__(self, a): self.a=adef__repr__(self): class_name=self.__class__.__name__returnf'{class_name}({self.a!r})'def__str__(self): returnstr(self.a) @classmethoddefget_class_name(cls): returncls.__name__

print(<el>) print(f'{<el>}') raiseException(<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

classPerson: def__init__(self, name, age): self.name=nameself.age=ageclassEmployee(Person): def__init__(self, name, age, staff_num): super().__init__(name, age) self.staff_num=staff_num

classA: passclassB: passclassC(A, B): pass

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

classMyClass: @propertydefa(self): returnself._a@a.setterdefa(self, value): self._a=value

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

fromdataclassesimportdataclass, 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)

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

classMyClassWithSlots: __slots__= ['a'] def__init__(self): self.a=1

fromcopyimportcopy, deepcopy<object>=copy(<object>) <object>=deepcopy(<object>)

classMyComparable: def__init__(self, a): self.a=adef__eq__(self, other): ifisinstance(other, type(self)): returnself.a==other.areturnNotImplemented

classMyHashable: def__init__(self, a): self._a=copy.deepcopy(a) @propertydefa(self): returnself._adef__eq__(self, other): ifisinstance(other, type(self)): returnself.a==other.areturnNotImplementeddef__hash__(self): returnhash(self.a)

fromfunctoolsimporttotal_ordering@total_orderingclassMySortable: def__init__(self, a): self.a=adef__eq__(self, other): ifisinstance(other, type(self)): returnself.a==other.areturnNotImplementeddef__lt__(self, other): ifisinstance(other, type(self)): returnself.a<other.areturnNotImplemented

classCounter: def__init__(self): self.i=0def__next__(self): self.i+=1returnself.idef__iter__(self): returnself

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

classCounter: def__init__(self): self.i=0def__call__(self): self.i+=1returnself.i

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

classMyOpen(): def__init__(self, filename): self.filename=filenamedef__enter__(self): self.file=open(self.filename) returnself.filedef__exit__(self, exc_type, exc_value, traceback): self.file.close()

>>>withopen('test.txt', 'w') asfile: ... file.write('Hello World!') >>>withMyOpen('test.txt') asfile: ... print(file.read()) HelloWorld!

classMyIterable: def__init__(self, a): self.a=adef__iter__(self): forelinself.a: yieldel

>>>z=MyIterable([1, 2, 3]) >>>iter(z) <generatorobjectMyIterable.__iter__>>>>1inzTrue

classMyCollection: def__init__(self, a): self.a=adef__iter__(self): returniter(self.a) def__contains__(self, el): returnelinself.adef__len__(self): returnlen(self.a)

classMySequence: def__init__(self, a): self.a=adef__iter__(self): returniter(self.a) def__contains__(self, el): returnelinself.adef__len__(self): returnlen(self.a) def__getitem__(self, i): returnself.a[i] def__reversed__(self): returnreversed(self.a)

fromcollectionsimportabcclassMyAbcSequence(abc.Sequence): def__init__(self, a): self.a=adef__len__(self): returnlen(self.a) def__getitem__(self, i): returnself.a[i]

fromenumimportEnum, autoclass<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.nameforain<enum>] member_values= [a.valueforain<enum>] random_member=random.choice(list(<enum>))

defget_next_member(member): members=list(member.__class__) index= (members.index(member) +1) %len(members) returnmembers[index]

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

fromfunctoolsimportpartialLogicOp=Enum('LogicOp',{'AND': partial(lambdal, r: landr), 'OR' : partial(lambdal, r: lorr)})

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>: <code>raise

raiseValueError('Argument is of right type but inappropriate value!') raiseTypeError('Argument is of wrong type!') raiseRuntimeError('None of above!')

classMyError(Exception): passclassMyInputError(MyError): pass

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

frompprintimportpprintpprint(<collection>, width=80, depth=None)

<str>=input(prompt=None)

importsysscript_name=sys.argv[0] arguments=sys.argv[1:]

fromargparseimportArgumentParser, FileTypep=ArgumentParser(description=<str>) p.add_argument('-<short_name>', '--<name>', action='store_true') # Flagp.add_argument('-<short_name>', '--<name>', type=<type>) # Optionp.add_argument('<name>', type=<type>, nargs=1) # First argumentp.add_argument('<name>', type=<type>, nargs='+') # Remaining argumentsp.add_argument('<name>', type=<type>, nargs='*') # Optional argumentsargs=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 pos., 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.

defread_file(filename): withopen(filename, encoding='utf-8') asfile: returnfile.readlines()

defwrite_to_file(filename, text): withopen(filename, 'w', encoding='utf-8') asfile: file.write(text)

fromosimportgetcwd, path, listdirfromglobimportglob

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

<str>=path.basename(<path>) # Returns final component.<str>=path.dirname(<path>) # Returns path without final component.<tup.>=path.splitext(<path>) # Splits on last period of 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()

fromosimportscandir

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

frompathlibimportPath

<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>.resolve() # Returns absolute Path without symlinks.

<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 a file object.

importos, shutil

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

shutil.copy(from, to) # Copies the file.shutil.copytree(from, to) # Copies the directory.

os.rename(from, to) # Renames 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 empty directory.shutil.rmtree(<path>) # Deletes non-empty directory.

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

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

>>>fromshleximportsplit>>>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'

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

defread_json_file(filename): withopen(filename, encoding='utf-8') asfile: returnjson.load(file)

defwrite_to_json_file(filename, an_object): withopen(filename, 'w', encoding='utf-8') asfile: json.dump(an_object, file, ensure_ascii=False, indent=2)

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

defread_pickle_file(filename): withopen(filename, 'rb') asfile: returnpickle.load(file)

defwrite_to_pickle_file(filename, an_object): withopen(filename, 'wb') asfile: pickle.dump(an_object, file)

importcsv

<reader>=csv.reader(<file>, 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>, dialect='excel', delimiter=',') <writer>.writerow(<collection>) # Encodes objects using `str(<el>)`.<writer>.writerows(<coll_of_coll>) # Appends multiple rows.

defread_csv_file(filename): withopen(filename, encoding='utf-8', newline='') asfile: returnlist(csv.reader(file))

defwrite_to_csv_file(filename, rows): withopen(filename, 'w', encoding='utf-8', newline='') asfile: writer=csv.writer(file) writer.writerows(rows)

importsqlite3db=sqlite3.connect('<path>') # Also ':memory:'. ... db.close()

<cursor>=db.execute('<query>') # Can raise sqlite3.OperationalError.<tuple>=<cursor>.fetchone() # Returns next row. Also next(<cursor>).<list>=<cursor>.fetchall() # Returns remaining rows.

db.execute('<query>') db.commit()

withdb: db.execute('<query>')

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

>>>db=sqlite3.connect('test.db') >>>db.execute('create table t (a, b, c)') >>>db.execute('insert into t values (1, 2, 3)') >>>db.execute('select * from t').fetchall() [(1, 2, 3)]

# $ pip3 install mysql-connectorfrommysqlimportconnectordb=connector.connect(host=<str>, user=<str>, password=<str>, database=<str>) <cursor>=db.cursor() <cursor>.execute('<query>') # Only cursor has execute method.<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 object as 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>')

<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()

defread_bytes(filename): withopen(filename, 'rb') asfile: returnfile.read()

defwrite_bytes(filename, bytes_obj): withopen(filename, 'wb') asfile: file.write(bytes_obj)

fromstructimportpack, 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)

fromarrayimportarray<array>=array('<typecode>', <collection>) # Array from coll. of numbers.<array>=array('<typecode>', <bytes>) # Array from bytes object.<bytes>=bytes(<array>) # Or: <array>.tobytes()

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

<bin_file>.write(<mview>) # Appends mview to the binary file.<bytes>=bytes(<mview>) # Creates a new bytes object.<bytes>=<bytes>.join(<coll_of_mviews>) # Joins mviews using bytes object as sep.<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()

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

fromthreadingimportThread, RLock

thread=Thread(target=<function>, args=(<first_arg>, )) thread.start() ... <bool>=thread.is_alive() # Checks if thread has finished executing.thread.join() # Waits for thread to finish.

lock=RLock() lock.acquire() # Waits for lock to be available. ... lock.release()

lock=RLock() withlock: ...

fromconcurrent.futuresimportThreadPoolExecutorwithThreadPoolExecutor(max_workers=None) asexecutor: <iter>=executor.map(lambdax: x+1, range(3)) # (1, 2, 3)<iter>=executor.map(lambdax, y: x+y, 'abc', '123') # ('a1', 'b2', 'c3')<Future>=executor.submit(<function> [, <arg_1>, ...])

<bool>=<Future>.done() # Checks if thread has finished executing.<obj>=<Future>.result() # Waits for thread to finish and returns result.

fromqueueimportQueue<Queue>=Queue(maxsize=0)

<Queue>.put(<el>) # Blocks until queue stops being full.<Queue>.put_nowait(<el>) # Raises queue.Full exception if full.<el>=<Queue>.get() # Blocks until queue stops being empty.<el>=<Queue>.get_nowait() # Raises queue.Empty exception if empty.

fromoperatorimportadd, sub, mul, truediv, floordiv, mod, pow, neg, absfromoperatorimporteq, ne, lt, le, gt, gefromoperatorimportand_, or_, not_fromoperatorimportitemgetter, attrgetter, methodcaller

importoperatorasopsorted_by_second=sorted(<collection>, key=op.itemgetter(1)) sorted_by_both=sorted(<collection>, key=op.itemgetter(1, 0)) product_of_elems=functools.reduce(op.mul, <collection>) LogicOp=enum.Enum('LogicOp',{'AND': op.and_, 'OR' : op.or_}) last_el=op.methodcaller('pop')(<list>)

<list>=dir() # Returns names of local variables (including functions).<dict>=vars() # Returns dict of local variables. Also locals().<dict>=globals() # Returns dict of global variables.