Comprehensive Python Cheatsheet

Main

if __name__ == '__main__':
    main()

List

<list>[from_inclusive : to_exclusive : step_size]
<list>.extend(<list>)
<list>.sort()
<list>.reverse()
sum(<list>)
sorted_by_second = sorted(<list>, key=lambda tup: tup[1])
[item for sublist in <list> for item in sublist]  # Flattens List

Dictionary

<dict>.items()
<dict>.get(key, default)
<dict>.setdefault(key, default)
<dict>.update(<dict>)
collections.defaultdict(<type>)
dict(zip(keys, values))  # Initiates a dict from two lists
{k: v for k, v in <dict>.iteritems() if k in <list>}  # Filters a dict by keys

Counter

>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})

Set

<set> = set()
<set>.add(<el>)
<set>.update(<set>)
<set>.union(<set>)
<set>.intersection(<set>)
<set>.difference(<set>)
<frozenset>  # Is hashable and can be used as key in dictionary

Range

range(to_exclusive)
range(from_inclusive, to_exclusive)
range(from_inclusive, to_exclusive, step_size)  # Negative step for backward

Enumerate

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

Named Tuple

>>> TestResults = collections.namedtuple('TestResults', ['filed', 'attempted'])
>>> TestResults(1, 2)
TestResults(filed=1, attempted=2)

Iterator

Reads input until it reaches empty line

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

Use partial from functools if function needs arguments.

Skips first element

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

Generator

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

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

Type

type(<el>)  # is int/str/set/list/...

import numbers
isinstance(<el>, numbers.Number)

String

str.replace(text, old, new)
<str>.isnumeric()
<str>.split()
<str>.strip()
<str>.join(<list>)

Print

print(<el> [, <el>, end='', sep='', file=<file>])

Regex

import re
re.sub(<regex>, new, text)
re.search(<regex>, text)

Format

'{}'.format(<el>)

{:min_width}   # -> '<el>    '
{:>min_width}  # -> '    <el>'
{:^min_width}  # -> '  <el>  '
{:_min_width}  # -> '<el>____'
{:.max_width}  # -> '<e>'
{:max_widht.min_width}        # -> '    <e>'
{:max_width.no_of_decimalsf}  # -> '   3.14'

>>> person = {'name': 'Jean-Luc', 'height': 187.1}
>>> '{p[height]:.0f}'.format(p=person)
'187'

Text Wrap

import textwrap
textwrap.wrap(text, width)

Random

import random
random.random()
random.randint(from_inclusive, to_inclusive)
random.shuffle(<list>)

Infinity

float("inf")

Datetime

import datetime
now = datetime.datetime.now()
now.strftime('%Y%m%d')
now.strftime('%Y%m%d%H%M%S')

Arguments

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

"*" is the "splat" operator, that takes a list as input, and expands it into actual positional arguments in the function call.

Inline

Lambda

lambda <argument1>, <argument2>: <return value>
lambda: <return value>

Comprehension

[i+1 for i in range(10)]       # 1, 2, ..., 10
[i for i in range(10) if i>5]  # 6, 7, ..., 9
{i: i*2 for i in range(10)}    # {0: 0, 1: 2, ..., 9: 18}
(x+5 for x in range(0, 10))    # -> Generator

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

Is same as:

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

Map, Filter, Reduce

map(lambda x: x+1, range(10))     # 1, 2, ..., 10
filter(lambda x: x>5, range(10))  # 6, 7, ..., 9
functools.reduce(combining_function, list_of_inputs)

Any, All

any(el[1] for el in <collection>)  # -> Boolean

If - Else

expression_if_true if condition else expression_if_false

Closure

def multiply_closure(x):
    def wrapped(y):
        return x * y
    return wrapped 

multiply_by_3 = multiply_closure(3)

or

from functools import partial
partial(<function>, <argument>)

Decorator

@closure_name
def function_that_gets_passed_to_closure():
    pass

Debugger example

from functools import wraps

def debug(func):
    @wraps(func)  # Needed for metadata copying (func name, ...)
    def wrapper(*args, **kwargs):
        print(func.__name__)
        return func(*args, **kwargs)
    return wrapper

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

Class

class <name>:
    def __init__(self, a):
        self.a = a
    def __repr__(self):
        return str({'a': self.a})
    def __str__(self):
        return str(self.a)

Enum

import enum
class <enum_name>(enum.Enum):
    <name> = <value>  # Or enum.auto() for automatic indexing.

<enum_name>.<name>  # == <enum>
<enum_name>(value)  # == <enum>
<enum>.name         # == <name>
<enum>.value        # == <value>

Cutlery = Enum('Cutlery', ['knife', 'fork', 'spoon'])
list(<enum_name>)  # == [<enum1>, <enum2>, ...]
random.choice(list(<enum_name>))  # == random <enum>

Copy

import copy
copy.copy(<object>)
copy.deepcopy(<object>)

System

Arguments

import sys
sys.argv

Read File

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

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

Write to File

with open(file_name, 'w', enconding='utf-8') as file:
    file.write(text)

Execute Command

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

Input

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

Print lines until EOF

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

JSON

import json

Read File

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

Write to File

with open(file_name, 'w', enconding='utf-8') as file:
    file.write(json.dumps(<object>))

SQLite

import sqlite3
db = sqlite3.connect(file_name)

Read

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

Write

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

Exceptions

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

Threading

import threading

Thread

thread = threading.Thread(target=<function>, args=(<first arg>, ))
thread.start()
thread.join()

Lock

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

Itertools

Every function returns a generator and can accept any collection. If you want to print an output of generator, as in examples, you need to pass it to list() function.

from itertools import *

Chain

>>> chain([1, 2], range(3, 5))
[1, 2, 3, 4]

Combinations

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

Permutations

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

Product

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

Compress

>>> compress("abc", [True, 0, 23])
['a', 'c']

Count

>>> a = count(5, 2)
>>> next(a), next(a)
(5, 7)

Cycle

>>> a = cycle("abc")
>>> [next(a) for _ in range(10)]
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a']

Groupby

>>> {k: list(v) for k, v in groupby("aabbbc")}
{'a': ['a', 'a'], 'b': ['b', 'b', 'b'], 'c': ['c']}

>>> a = [{"id": 1, "name": "bob"}, {"id": 2, "name": "bob"}, {"id": 3, "name": "peter"}]
>>> {k: list(v) for k, v in groupby(a, key=lambda x: x["name"])}
{'bob': [{'id': 1, 'name': 'bob'}, {'id': 2, 'name': 'bob'}], 'peter': [{'id': 3, 'name': 'peter'}]}

Islice

islice([1, 2, 3], 1, None)
[2, 3]

Ifilter/imap/izip

Filter, map and zip functions that return generators instead of iterators

Introspection and Metaprograming

Inspecting code at runtime and code that generates code. You can:

• Look at the attributes
• Set new attributes
• Create functions dynamically
• Traverse the parent classes
• Change values in the class

>>> class B:
...     def __init__(self):
...             self.a= 'sdfsd'
...             self.b = 123324
>>> b = B()

Getattr

>>> getattr(b, 'a')
'sdfsd'

Is the same as

B.__getattribute__(b, 'a')

Hasattr

>>> hasattr(b, 'c')
False

Setattr

>>> setattr(b, 'c', 10)

Type

Type is the root class. If only passed the object it returns it's type. Otherwise it creates new class (and not the instance!).

type(class_name, parents<tuple>, attributes<dict>)

>>> BB = type('B', (), {'a': 'sdfsd', 'b': 123324}
>>> b = BB()

MetaClass

Classes that create classes.

def my_meta_class(name, parents, attrs):
    # do stuff
    return type(name, parents, attrs)

or

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

Metaclass Attr

When class is created it checks if it has metaclass defined. If not, it recursively checks if any of his parents has it defined, and eventually comes to type.

class BlaBla:
    __metaclass__ = Bla

Eval

import ast
import operator as op

# Supported operators
operators = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul,
             ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor,
             ast.USub: op.neg}

def eval_expr(expr):
    print(expr)
    return eval_(ast.parse(expr, mode='eval').body)

def eval_(node):
    if isinstance(node, ast.Num):  # <number>
        return node.n
    elif isinstance(node, ast.BinOp):  # <left> <operator> <right>
        return operators[type(node.op)](eval_(node.left), eval_(node.right))
    elif isinstance(node, ast.UnaryOp):  # <operator> <operand> e.g., -1
        return operators[type(node.op)](eval_(node.operand))
    else:
        raise TypeError(node)

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

Libraries

Plot

import matplotlib
matplotlib.pyplot.plot(<data> [, <data>])
matplotlib.pyplot.show()
matplotlib.pyplot.savefig(filename)

Web

import bottle

Run

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

Static request

Dynamic request

REST request

Curses

import curses
def main():
    curses.wrapper(draw)
def draw(screen):
    screen.clear()
    screen.addstr(0, 0, "Press ESC to quit.")
    while screen.getch() != 27:
        pass

Gets char from int

chr(<int>)

Profile

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

Generates a PNG image of call graph and highlights the bottlenecks.

import pycallgraph
graph = pycallgraph.output.GraphvizOutput()
graph.output_file = get_file_name()
with pycallgraph.PyCallGraph(output=graph):
    <code_to_be_profiled>

Utility code for unique PNG filenames.

def get_file_name():
    return "{}-{}.png".format("profile", get_current_datetime_string())

def get_current_datetime_string():
    now = datetime.datetime.now()
    return get_datetime_string(now)

def get_datetime_string(a_datetime):
    return a_datetime.strftime('%Y%m%d%H%M%S')

Audio

Saves list of floats of size 0 to 1 to a WAV file.

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