Comprehensive Python Cheatsheet

Main

if __name__ == '__main__':
    main()

List

<list>[from_inclusive : to_exclusive : step_size]
<list>.append(<el>)
<list>.extend(<list>)
<list>.sort()
<list>.reverse()

sum(<list>)
sorted_by_second = sorted(<list>, key=lambda tup: tup[1])
flattened_list = [item for sublist in <list> for item in sublist]

Dictionary

<dict>.items()
<dict>.get(key, default)
<dict>.setdefault(key, default)
<dict>.update(<dict>)

collections.defaultdict(<type>)  # Creates a dictionary with default values.
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 a key in dictionary:

<set> = frozenset()

Range

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

Enumerate

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

Named Tuple

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

Iterator

Skips first element:

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

Reads input until it reaches an empty line:

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

Same, but prints a message every time:

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

Generator

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

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

Type

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

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> [, <el>, ...])

{:min_width}   # '<el>    '
{:>min_width}  # '    <el>'
{:^min_width}  # '  <el>  '
{:_min_width}  # '<el>____'
{:.max_width}  # '<e>'

{:max_width.min_width}        # '    <e>'
{:max_width.no_of_decimalsf}  # '   3.14'

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

Or:

>>> f"{person['height']:.0f}"
'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.month                      # 3
now.strftime('%Y%m%d')         # 20180315
now.strftime('%Y%m%d%H%M%S')   # 20180315002834

Arguments

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

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

Is the same as:

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

Inline

Lambda

lambda: <return_value>
lambda <argument1>, <argument2>: <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))    # (5, 6, ..., 14) -> Generator

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

Is the 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>)

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):
    <name1> = <value1>  
    <name2> = <value2>
    <name3> = enum.auto()  # Can be used 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

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

Write to File

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

Execute Command

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

Or:

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

Input

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

Prints lines until EOF:

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

JSON

import json

Serialization

<str> = json.dumps(<object>)
<object> = json.loads(<str>)

Read File

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

Write to File

with open(filename, 'w', encoding='utf-8') as file:
    json.dump(<object>, file)

SQLite

import sqlite3
db = sqlite3.connect(filename)

Read

cursor = db.execute(<query>)
if cursor:
    cursor.fetchall()  # Or cursor.fetchone()
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 the 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

>>> 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 and 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 a new class (and not the instance!):

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

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

MetaClass

Class that creates class:

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

Or:

class MyMetaClass(type):
    def __new__(klass, name, parents, attrs):
        ...
        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):
    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
import urllib

Run

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

Static request

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

Dynamic request

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

REST request

@post('/p/<sport>')
def p_handler(sport):
    team = request.forms.get('team')
    team = urllib.parse.unquote(team).lower()

    db = sqlite3.connect(conf.DB_PATH)
    p_h, p_a = get_p(db, sport, team)
    db.close()

    response.headers['Content-Type'] = 'application/json'
    response.headers['Cache-Control'] = 'no-cache'
    return json.dumps([p_h, p_a])

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

Times execution of the passed code:

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_filename()
with pycallgraph.PyCallGraph(output=graph):
    <code_to_be_profiled>

Utility code for unique PNG filenames:

def get_filename():
    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(filename, 'wb')
wf.setnchannels(1)
wf.setsampwidth(4)
wf.setframerate(44100)
wf.writeframes(b''.join(frames))
wf.close()