if __name__ == '__main__': main()

<list> = <list>[from_inclusive : to_exclusive : step_size] <list>.append(<el>) <list>.extend(<list>) <list> += [<el>] <list> += <list>

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

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

index = <list>.index(<el>) # Returns first index of item.  <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. <list>.clear() # Removes all items. 

<view> = <dict>.keys() <view> = <dict>.values() <view> = <dict>.items() <value> = <dict>.get(key, default) # Returns default if key does not exist. <value> = <dict>.setdefault(key, default) # Same, but also adds default to dict. <dict>.update(<dict>)

collections.defaultdict(<type>) # Creates a dictionary with default value of type. collections.defaultdict(lambda: 1) # Creates a dictionary with default value 1. collections.OrderedDict() # Creates ordered dictionary.

dict(<list>) # Initiates a dict from list of key-value pairs. dict(zip(keys, values)) # Initiates a dict from two lists. {k: v for k, v in <dict>.items() if k in <list>} # Filters a dict by keys.

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

<set> = set() <set>.add(<el>) <set>.update(<set>) <set>.clear()

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

<frozenset> = frozenset(<collection>)

range(to_exclusive) range(from_inclusive, to_exclusive) range(from_inclusive, to_exclusive, step_size) range(from_inclusive, to_exclusive, -step_size)

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

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

>>> Point = collections.namedtuple('Point', ['x', 'y']) >>> a = Point(1, y=2) Point(x=1, y=2) >>> a.x 1 >>> getattr(a, 'y') 2 >>> Point._fields ('x', 'y')

next(<iter>) for element in <iter>: ...

for line in iter(input, ''): ...

from functools import partial for line in iter(partial(input, 'Please enter value'), ''): ...

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

>>> stepper = step(10, 2) >>> next(stepper), next(stepper), next(stepper) (10, 12, 14)

<type> = type(<el>) # <class 'int'> / <class 'str'> / ...

from numbers import Number, Integral, Real, Rational, Complex is_number = isinstance(<el>, Number) is_function = callable(<el>)

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

<list> = <str>.split() # Splits on any whitespace character. <list> = <str>.split(sep=None, maxsplit=-1) # Splits on 'sep' at most 'maxsplit' times. <str> = <str>.join(<list>) # Joins elements using string as separator.

<str> = <str>.replace(old_str, new_str) <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>.index(<sub_str>) # Returns first index of a substring. <bool> = <str>.isnumeric() # True if str contains only numeric characters. <list> = textwrap.wrap(<str>, width) # Nicely breaks string into lines.

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

>>> ord('0'), ord('9') (48, 57) >>> ord('A'), ord('Z') (65, 90) >>> ord('a'), ord('z') (97, 122)

print(<el_1> [, <el_2>, end='', sep='', file=<file>]) # Use 'file=sys.stderr' for errors.

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

<str> = <Match>.group() # Whole match. <str> = <Match>.group(1) # Part in first bracket. <int> = <Match>.start() # Start index of a match. <int> = <Match>.end() # Exclusive end index of a match.

'\d' == '[0-9]' # Digit '\s' == '[ \t\n\r\f\v]' # Whitespace '\w' == '[a-zA-Z0-9_]' # Alphanumeric

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

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

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

{'abcde':.3} # 'abc' {'abcde':10.3} # 'abc '

{1.23456:.3f} # '1.235' {1.23456:10.3f} # ' 1.235' {123456:10,} # ' 123,456' {123456:10_} # ' 123_456' {3:08b} # '00000011' -> Binary with leading zeros. {3:0<8b} # '11000000' -> Binary with trailing zeros.

round(<num> [, ndigits]) abs(<num>) math.pow(x, y) # Or: x ** y

from math import e, pi

from math import cos, acos, sin, asin, tan, atan, degrees, radians

from math import log, log10, log2 log(x [, base]) # Base e, if not specified. log10(x) # Base 10. log2(x) # Base 2.

from math import inf, nan, isfinite, isinf, isnan

float('inf'), float('nan')

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

from datetime import datetime, strptime now = datetime.now() now.month # 3 now.strftime('%Y%m%d') # '20180315' now.strftime('%Y%m%d%H%M%S') # '20180315002834' <datetime> = strptime('2015-05-12 00:39', '%Y-%m-%d %H:%M')

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

>>> a = (1, 2, 3) >>> [*a] [1, 2, 3]

>>> head, *body, tail = [1, 2, 3, 4] >>> body [2, 3]

lambda: <return_value> lambda <argument_1>, <argument_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, ..., 9} <dict> = {i: i*2 for i in range(10)} # {0: 0, 1: 2, ..., 9: 18} <iter> = (x+5 for x in range(10)) # (5, 6, ..., 14)

out = [i+j for i in range(10) for j in range(10)]

out = [] for i in range(10): for j in range(10): out.append(i+j)

from functools import reduce <iter> = map(lambda x: x + 1, range(10)) # (1, 2, ..., 10) <iter> = filter(lambda x: x > 5, range(10)) # (6, 7, ..., 9) <any_type> = reduce(lambda sum, x: sum+x, range(10)) # 45

<bool> = any(el[1] for el in <collection>)

<expression_if_true> if <condition> else <expression_if_false>

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

from collections import namedtuple Point = namedtuple('Point', 'x y') from enum import Enum Direction = Enum('Direction', 'n e s w') Cutlery = Enum('Cutlery', {'knife': 1, 'fork': 2, 'spoon': 3}) # Warning: Objects will share the objects that are initialized in the dictionary! Creature = type('Creature', (), {'position': Point(0, 0), 'direction': Direction.n}) creature = Creature()

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 partial(<function>, <arg_1> [, <arg_2>, ...])

@closure_name def function_that_gets_passed_to_closure(): ...

from functools import wraps def debug(func): @wraps(func) # Needed for metadata copying (func name, ...). def out(*args, **kwargs): print(func.__name__) return func(*args, **kwargs) return out @debug def add(x, y): return x + y

class <name>: def __init__(self, a): self.a = a def __str__(self): return str(self.a) def __repr__(self): return str({'a': self.a}) # Or: return f'{self.__dict__}' @classmethod def get_class_name(cls): return cls.__name__

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

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

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() # Can be used for automatic indexing. ... @classmethod def get_names(cls): return [a.name for a in cls.__members__.values()] @classmethod def get_values(cls): return [a.value for a in cls.__members__.values()]

<member> = <enum>.<member_name> <member> = <enum>['<member_name>'] <member> = <enum>(<value>) <name> = <member>.name <value> = <member>.value

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

Cutlery = Enum('Cutlery', ['knife', 'fork', 'spoon']) Cutlery = Enum('Cutlery', 'knife fork spoon') Cutlery = Enum('Cutlery', {'knife': 1, 'fork': 2, 'spoon': 3}) # Functions can not be values, so they must be enclosed in tuple: LogicOp = Enum('LogicOp', {'AND': (lambda l, r: l and r, ), 'OR' : (lambda l, r: l or r, )}) # But 'list(<enum>)' will only work if there is another value in the tuple: LogicOp = Enum('LogicOp', {'AND': (auto(), lambda l, r: l and r), 'OR' : (auto(), lambda l, r: l or r)})

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

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 <bool> = os.path.exists(<path>) <bool> = os.path.isfile(<path>) <bool> = os.path.isdir(<path>) <list> = os.listdir(<path>)

import os <str> = os.popen(<command>).read()

>>> import subprocess >>> a = subprocess.run(['ls', '-a'], stdout=subprocess.PIPE) >>> a.stdout b'.\n..\nfile1.txt\nfile2.txt\n' >>> a.returncode 0

filename = input('Enter a file name: ')

while True: try: print(input()) except EOFError: break

>>> sys.getrecursionlimit() 1000 >>> sys.setrecursionlimit(10000)

import json

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

from collections import OrderedDict <dict> = json.loads(<str>, object_pairs_hook=OrderedDict)

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 sqlite3 db = sqlite3.connect(<filename>)

cursor = db.execute(<query>) if cursor: cursor.fetchall() # Or cursor.fetchone() db.close()

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

while True: try: x = int(input('Please enter a number: ')) except ValueError: print('Oops! That was no valid number. Try again...') else: print('Thank you.') break

raise IOError("input/output error")

<Bytes> = b'<str>' <Bytes> = <str>.encode(encoding='utf-8') <Bytes> = <int>.to_bytes(<length>, byteorder='big|little', signed=False) <Bytes> = bytes.fromhex(<hex>)

<str> = <Bytes>.decode('utf-8') <int> = int.from_bytes(<Bytes>, byteorder='big|little', signed=False) <hex> = <Bytes>.hex()

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

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

<Bytes> = b''.join(<list_of_Bytes>)

<Bytes> = struct.pack('<format>', <value_1> [, <value_2>, ...]) <tuple> = struct.unpack('<format>', <Bytes>)

>>> from struct import pack, unpack, calcsize >>> 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) >>> calcsize('hhl') 8

>>> hashlib.md5(<str>.encode()).hexdigest() '33d0eba106da4d3ebca17fcd3f4c3d77'

from threading import Thread, RLock

thread = Thread(target=<function>, args=(<first_arg>, )) thread.start() ... thread.join()

lock = Rlock() lock.acquire() ... lock.release()

from itertools import *

>>> 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')] >>> product('ab', [1, 2]) [('a', 1), ('a', 2), ('b', 1), ('b', 2)] >>> 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)]

>>> i = count(5, 2) >>> next(i), next(i), next(i) (5, 7, 9) >>> a = cycle('abc') >>> [next(a) for _ in range(10)] ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a'] >>> repeat(10, 3) [10, 10, 10]

>>> chain([1, 2], range(3, 5)) [1, 2, 3, 4] >>> compress('abc', [True, 0, 1]) ['a', 'c'] >>> islice([1, 2, 3], 1, None) # islice(<seq>, from_inclusive, to_exclusive)  [2, 3] >>> people = [{'id': 1, 'name': 'bob'}, {'id': 2, 'name': 'bob'}, {'id': 3, 'name': 'peter'}] >>> {name: list(ppp) for name, ppp in groupby(people, key=lambda p: p['name'])} {'bob': [{'id': 1, 'name': 'bob'}, {'id': 2, 'name': 'bob'}], 'peter': [{'id': 3, 'name': 'peter'}]}

<list> = dir() # In-scope variables. <dict> = locals() # Local variables. <dict> = globals() # Global variables.

>>> class Z: ... def __init__(self): ... self.a = 'abcde' ... self.b = 12345 >>> z = Z()

>>> getattr(z, 'a') # Same as Z.__getattribute__(z, 'a') 'abcde' >>> hasattr(z, 'c') False >>> setattr(z, 'c', 10)

from inspect import signature sig = signature(<function>) no_of_params = len(sig.parameters)

type(<class_name>, <parents_tuple>, <attributes_dict>)

>>> Z = type('Z', (), {'a': 'abcde', 'b': 12345}) >>> z = Z()

def my_meta_class(name, parents, attrs): ... return type(name, parents, attrs)

class MyMetaClass(type): def __new__(klass, name, parents, attrs): ... return type.__new__(klass, name, parents, attrs)

class BlaBla: __metaclass__ = Bla

from operator import add, sub, mul, truediv, floordiv, mod, pow, neg, abs, \ eq, ne, lt, le, gt, ge, \ not_, and_, or_, xor, \ itemgetter

from enum import Enum from functools import reduce product_of_elems = reduce(mul, <list>) sorted_by_second = sorted(<list>, key=itemgetter(1)) sorted_by_both = sorted(<list>, key=itemgetter(0, 1)) LogicOp = Enum('LogicOp', {'AND': (and_, ), 'OR' : (or_, )})

>>> from ast import literal_eval >>> literal_eval('1 + 1') 2 >>> literal_eval('[1, 2, 3]') [1, 2, 3]

from ast import parse, Num, BinOp, UnaryOp, \ Add, Sub, Mult, Div, Pow, BitXor, USub import operator as op operators = {Add: op.add, Sub: op.sub, Mult: op.mul, Div: op.truediv, Pow: op.pow, BitXor: op.xor, USub: op.neg} def evaluate(expression): root = parse(expression, mode='eval') return eval_node(root.body) def eval_node(node): type_ = type(node) if type_ == Num: return node.n if type_ not in [BinOp, UnaryOp]: raise TypeError(node) operator = operators[type(node.op)] if type_ == BinOp: left, right = eval_node(node.left), eval_node(node.right) return operator(left, right) elif type_ == UnaryOp: operand = eval_node(node.operand) return operator(operand)

>>> evaluate('2^6') 4 >>> evaluate('2**6') 64 >>> evaluate('1 + 2*3**(4^5) / (6 + -7)') -5.0

def coroutine(func): def start(*args, **kwargs): cr = func(*args, **kwargs) next(cr) return cr return start

def reader(target): for i in range(10): target.send(i) target.close() @coroutine def adder(target): while True: item = (yield) target.send(item + 100) @coroutine def printer(): while True: item = (yield) print(item) reader(adder(printer()))

# $ pip3 install matplotlib from matplotlib import pyplot pyplot.plot(<data_1> [, <data_2>, ...]) pyplot.show() pyplot.savefig(<filename>, transparent=True)

# $ pip3 install tabulate import csv from tabulate import tabulate with open(<filename>, newline='') as csv_file: reader = csv.reader(csv_file, delimiter=';') headers = [a.title() for a in next(reader)] print(tabulate(reader, headers))

# $ pip3 install curses from curses import wrapper def main(): wrapper(draw) def draw(screen): screen.clear() screen.addstr(0, 0, 'Press ESC to quit.') while screen.getch() != 27: pass def get_border(screen): from collections import namedtuple P = namedtuple('P', 'x y') height, width = screen.getmaxyx() return P(width - 1, height - 1)

# $ pip3 install pillow from PIL import Image width, height = 100, 100 img = Image.new('L', (width, height), 'white') img.putdata([255*a/(width*height) for a in range(width*height)]) img.save('out.png')

import wave, struct frames = [struct.pack('h', int((a-0.5)*60000)) for a in <list>] wf = wave.open(<filename>, 'wb') wf.setnchannels(1) wf.setsampwidth(4) wf.setframerate(44100) wf.writeframes(b''.join(frames)) wf.close()

from urllib.parse import quote, quote_plus, unquote, unquote_plus

>>> quote("Can't be in URL!") 'Can%27t%20be%20in%20URL%21' >>> quote_plus("Can't be in URL!") 'Can%27t+be+in+URL%21'

>>> unquote('Can%27t+be+in+URL%21') "Can't+be+in+URL!"' >>> unquote_plus('Can%27t+be+in+URL%21') "Can't be in URL!"

# $ pip3 install bottle import bottle from urllib.parse import unquote

bottle.run(host='localhost', port=8080) bottle.run(host='0.0.0.0', port=80, server='cherrypy')

@route('/img/<image>') def send_image(image): return static_file(image, 'images/', mimetype='image/png')

@route('/<sport>') def send_page(sport): sport = unquote(sport).lower() page = read_file(sport) return template(page)

@post('/odds/<sport>') def odds_handler(sport): team = bottle.request.forms.get('team') team = unquote(team).lower() db = sqlite3.connect(<db_path>) home_odds, away_odds = get_odds(db, sport, team) db.close() response.headers['Content-Type'] = 'application/json' response.headers['Cache-Control'] = 'no-cache' return json.dumps([home_odds, away_odds])

from time import time start_time = time() ... duration = time() - start_time

from timeit import timeit timeit('"-".join(str(n) for n in range(100))', number=10000, globals=globals())

# $ pip3 install pycallgraph import pycallgraph graph = pycallgraph.output.GraphvizOutput() graph.output_file = get_filename() with pycallgraph.PyCallGraph(output=graph): <code_to_be_profiled>

def get_filename(): from datetime import datetime time_str = datetime.now().strftime('%Y%m%d%H%M%S') return f'profile-{time_str}.png'

# $ pip3 install tqdm from tqdm import tqdm from time import sleep for i in tqdm(range(100)): sleep(0.02) for i in tqdm([1, 2, 3]): sleep(0.2)

import sys class Bar(): @staticmethod def range(*args): bar = Bar(len(list(range(*args)))) for i in range(*args): yield i bar.tick() @staticmethod def foreach(elements): bar = Bar(len(elements)) for el in elements: yield el bar.tick() def __init__(s, steps, width=40): s.st, s.wi, s.fl, s.i = steps, width, 0, 0 s.th = s.fl * s.st / s.wi s.p(f"[{' ' * s.wi}]") s.p('\b' * (s.wi + 1)) def tick(s): s.i += 1 while s.i > s.th: s.fl += 1 s.th = s.fl * s.st / s.wi s.p('-') if s.i == s.st: s.p('\n') def p(s, t): sys.stdout.write(t) sys.stdout.flush()

from time import sleep for i in Bar.range(100): sleep(0.02) for el in Bar.foreach([1, 2, 3]): sleep(0.2)

# Linux: #!/usr/bin/env python3 # Mac: #!/usr/local/bin/python3 # # Usage: .py  #  from collections import namedtuple from enum import Enum import re import sys def main(): pass ### ## UTIL # def read_file(filename): with open(filename, encoding='utf-8') as file: return file.readlines() if __name__ == '__main__': main()