You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Jure Šorn
0b414b8b94
|
6 years ago | |
---|---|---|
.gitignore | 6 years ago | |
README.md | 6 years ago | |
default.min.css | 6 years ago | |
highlight.min.js | 6 years ago | |
index.html | 6 years ago | |
script.js | 6 years ago | |
showdown.min.js | 6 years ago | |
style.css | 6 years ago |
README.md
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])
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.
Range
range(to_exclusive)
range(from_inclusive, to_exclusive)
range(from_inclusive, to_exclusive, step_size)
Negative step_size can be used for backward range.
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
Reads input until it reaches an empty line.
for line in iter(input, ''):
...
Use partial from functools if function needs arguments.
Skips first element.
next(<iter>)
for element in <iter>:
...
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(<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_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.month # 3
now.strftime('%Y%m%d') # 20180315
now.strftime('%Y%m%d%H%M%S') # 20180315002834
Arguments
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)
"*" is the splat operator, that takes a list as input, and expands it into
actual positional arguments in the function call.
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)
Last one creates a 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>
...
Also " = 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
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.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 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/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):
...
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
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
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_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()