Comprehensive Python Cheatsheet

^{Download text file or Fork me on GitHub.}

Main

if__name__=='__main__':
main()

List

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

Dictionary

<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: vfork, vin<dict>.items() ifkin<list>} # Filters a dict by keys.

Counter

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

Is hashable and can be used as a key in dictionary.

<frozenset>=frozenset(<collection>)

Range

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>.startto_exclusive=<range>.stop

Enumerate

fori, <el>inenumerate(<collection> [, i_start]):
...

Named Tuple

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

Iterator

Skips first element:

next(<iter>)
forelementin<iter>:
...

Reads input until it reaches an empty line:

forlineiniter(input, ''):
...

Same, but prints a message every time:

fromfunctoolsimportpartialforlineiniter(partial(input, 'Please enter value'), ''):
...

Generator

Convenient way to implement the iterator protocol.

defstep(start, step):
whileTrue:
yieldstartstart+=step

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

Type

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

fromnumbersimportNumber, Integral, Real, Rational, Complexis_number=isinstance(<el>, Number)
is_function=callable(<el>)

String

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

Char

<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

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

>>>frompprintimportpprint>>>pprint(locals())
{'__doc__': None,
'__name__': '__main__',
'__package__': None, ...}

Regex

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

• Parameter 'flags=re.IGNORECASE' can be used with all functions. Parameter 'flags=re.DOTALL' makes dot also accept newline.
• Use '\\1' or r'\1' for backreference.
• Use ? to make operators non-greedy.

Match Object

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

Special Sequences

Use capital letter for negation.

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

Format

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

General Options

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

Options Specific to Strings

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

Options specific to Numbers

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

Float presentation types:

• 'f' - Fixed point: .<precision>f
• 'e' - Exponent

Integer presentation types:

• 'c' - Character
• 'b' - Binary
• 'x' - Hex
• 'X' - HEX

Numbers

Basic Functions

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

Constants

frommathimporte, pi

Trigonometry

frommathimportcos, acos, sin, asin, tan, atan, degrees, radians

Logarithm

frommathimportlog, log10, log2log(x [, base]) # Base e, if not specified.log10(x) # Base 10.log2(x) # Base 2.

Infinity, nan

frommathimportinf, nan, isfinite, isinf, isnan

Or:

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

Random

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

Datetime

fromdatetimeimportdatetime, strptimenow=datetime.now()
now.month# 3now.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')

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)

Splat operator can also be used in function declarations:

defadd(*a):
returnsum(a)

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

And in few other places:

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

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

Inline

Lambda

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

Comprehension

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

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

Is the same as:

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

Map, Filter, Reduce

fromfunctoolsimportreduce<iter>=map(lambdax: x+1, range(10)) # (1, 2, ..., 10)<iter>=filter(lambdax: x>5, range(10)) # (6, 7, ..., 9)<any_type>=reduce(lambdasum, x: sum+x, range(10)) # 45

Any, All

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

If - Else

<expression_if_true>if<condition>else<expression_if_false>

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

Namedtuple, Enum, Class

fromcollectionsimportnamedtuplePoint=namedtuple('Point', 'x y')
fromenumimportEnumDirection=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()

Closure

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

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

Or:

fromfunctoolsimportpartialpartial(<function>, <arg_1> [, <arg_2>, ...])

Decorator

@closure_namedeffunction_that_gets_passed_to_closure():
...

Debugger example:

fromfunctoolsimportwrapsdefdebug(func):
@wraps(func) # Needed for metadata copying (func name, ...).defout(*args, **kwargs):
print(func.__name__)
returnfunc(*args, **kwargs)
returnout@debugdefadd(x, y):
returnx+y

Class

class<name>:
def__init__(self, a):
self.a=adef__str__(self):
returnstr(self.a)
def__repr__(self):
returnstr({'a': self.a}) # Or: return f'{self.__dict__}'@classmethoddefget_class_name(cls):
returncls.__name__

Constructor Overloading

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

Copy

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

Enum

fromenumimportEnum, autoclass<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.
...
@classmethoddefget_names(cls):
return [a.nameforaincls.__members__.values()]
@classmethoddefget_values(cls):
return [a.valueforaincls.__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.nameforain<enum>]
random_member=random.choice(list(<enum>))

Inline

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': (lambdal, r: landr, ),
'OR' : (lambdal, r: lorr, )})
# But 'list(<enum>)' will only work if there is another value in the tuple:LogicOp=Enum('LogicOp', {'AND': (auto(), lambdal, r: landr),
'OR' : (auto(), lambdal, r: lorr)})

System

Arguments

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

Read File

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

Write to File

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

Path

importos<bool>=os.path.exists(<path>)
<bool>=os.path.isfile(<path>)
<bool>=os.path.isdir(<path>)
<list>=os.listdir(<path>)

Execute Command

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

Or:

>>>importsubprocess>>>a=subprocess.run(['ls', '-a'], stdout=subprocess.PIPE)
>>>a.stdoutb'.\n..\nfile1.txt\nfile2.txt\n'>>>a.returncode0

Input

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

Prints lines until EOF:

whileTrue:
try:
print(input())
exceptEOFError:
break

Recursion Limit

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

JSON

importjson

Serialization

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

To preserve order:

fromcollectionsimportOrderedDict<dict>=json.loads(<str>, object_pairs_hook=OrderedDict)

Read File

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

Write to 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)

SQLite

importsqlite3db=sqlite3.connect(<filename>)

Read

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

Write

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

Pickle

importpicklefavorite_color= {'lion': 'yellow', 'kitty': 'red'}
pickle.dump(favorite_color, open('data.p', 'wb'))
favorite_color=pickle.load(open('data.p', 'rb'))

Exceptions

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

Raising exception:

raiseValueError('A very specific message!')

Finally:

>>>try:
... raiseKeyboardInterrupt
... finally:
... print('Goodbye, world!')
... Goodbye, world!
Traceback (mostrecentcalllast):
File"<stdin>", line2, in<module>KeyboardInterrupt

Bytes

Bytes objects are immutable sequences of single bytes.

Encode

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

Decode

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

Read Bytes from File

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

Write Bytes to File

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

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

Struct

This module performs conversions between Python values and C struct represented as Python Bytes object.

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

Example

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

Format

Use capital leters for unsigned type.

• 'x' - pad byte
• 'c' - char
• 'h' - short
• 'i' - int
• 'l' - long
• 'q' - long long
• 'f' - float
• 'd' - double

Hashlib

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

Threading

fromthreadingimportThread, RLock

Thread

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

Lock

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

Itertools

Every function returns an iterator and can accept any collection and/or iterator. If you want to print the iterator, you need to pass it to the list() function.

fromitertoolsimport*

Combinatoric iterators

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

Infinite iterators

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

Iterators

>>>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) forname, pppingroupby(people, key=lambdap: p['name'])}
{'bob': [{'id': 1, 'name': 'bob'}, {'id': 2, 'name': 'bob'}], 'peter': [{'id': 3, 'name': 'peter'}]}

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

Variables

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

Attributes

>>>classZ:
... def__init__(self):
... self.a='abcde'
... self.b=12345>>>z=Z()

>>>vars(z)
{'a': 'abcde', 'b': 12345}
>>>getattr(z, 'a')
'abcde'>>>hasattr(z, 'c')
False>>>setattr(z, 'c', 10)

Parameters

Getting the number of parameters of a function:

frominspectimportsignaturesig=signature(<function>)
no_of_params=len(sig.parameters)

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

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

MetaClass

Class that creates class:

defmy_meta_class(name, parents, attrs):
...
returntype(name, parents, attrs)

Or:

classMyMetaClass(type):
def__new__(klass, name, parents, attrs):
...
returntype.__new__(klass, name, parents, attrs)

Metaclass Attribute

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:

classBlaBla:
__metaclass__=Bla

Operator

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

fromenumimportEnumfromfunctoolsimportreduceproduct_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_, )})

Eval

Basic

>>>fromastimportliteral_eval>>>literal_eval('1 + 1')
2>>>literal_eval('[1, 2, 3]')
[1, 2, 3]

Detailed

fromastimportparse, Num, BinOp, UnaryOp, \
Add, Sub, Mult, Div, Pow, BitXor, USubimportoperatorasopoperators= {Add: op.add, Sub: op.sub, Mult: op.mul,
Div: op.truediv, Pow: op.pow, BitXor: op.xor,
USub: op.neg}
defevaluate(expression):
root=parse(expression, mode='eval')
returneval_node(root.body)
defeval_node(node):
type_=type(node)
iftype_==Num:
returnnode.niftype_notin [BinOp, UnaryOp]:
raiseTypeError(node)
operator=operators[type(node.op)]
iftype_==BinOp:
left, right=eval_node(node.left), eval_node(node.right)
returnoperator(left, right)
eliftype_==UnaryOp:
operand=eval_node(node.operand)
returnoperator(operand)

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

Coroutine

• Similar to Generator, but Generator pulls data through the pipe with iteration, while Coroutine pushes data into the pipeline with send().
• Coroutines provide more powerful data routing possibilities than iterators.
• If you built a collection of simple data processing components, you can glue them together into complex arrangements of pipes, branches, merging, etc.

Helper Decorator

• All coroutines must be "primed" by first calling .next()
• Remembering to call .next() is easy to forget.
• Solved by wrapping coroutines with a decorator:

defcoroutine(func):
defstart(*args, **kwargs):
cr=func(*args, **kwargs)
next(cr)
returncrreturnstart

Pipeline Example

defreader(target):
foriinrange(10):
target.send(i)
target.close()
@coroutinedefadder(target):
whileTrue:
item= (yield)
target.send(item+100)
@coroutinedefprinter():
whileTrue:
item= (yield)
print(item)
reader(adder(printer()))

Libraries

Plot

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

Table

Prints CSV file as ASCII table:

# $ pip3 install tabulateimportcsvfromtabulateimporttabulatewithopen(<filename>, newline='') ascsv_file:
reader=csv.reader(csv_file, delimiter=';')
headers= [a.title() forainnext(reader)]
print(tabulate(reader, headers))

Curses

# $ pip3 install cursesfromcursesimportwrapperdefmain():
wrapper(draw)
defdraw(screen):
screen.clear()
screen.addstr(0, 0, 'Press ESC to quit.')
whilescreen.getch() !=27:
passdefget_border(screen):
fromcollectionsimportnamedtupleP=namedtuple('P', 'x y')
height, width=screen.getmaxyx()
returnP(width-1, height-1)

Image

Creates PNG image of greyscale gradient:

# $ pip3 install pillowfromPILimportImagewidth, height=100, 100img=Image.new('L', (width, height), 'white')
img.putdata([255*a/(width*height) forainrange(width*height)])
img.save('out.png')

Modes

• '1' - 1-bit pixels, black and white, stored with one pixel per byte.
• 'L' - 8-bit pixels, greyscale.
• 'RGB' - 3x8-bit pixels, true color.
• 'RGBA' - 4x8-bit pixels, true color with transparency mask.
• 'HSV' - 3x8-bit pixels, Hue, Saturation, Value color space.

Audio

Saves list of floats with values between 0 and 1 to a WAV file:

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

Url

fromurllib.parseimportquote, quote_plus, unquote, unquote_plus

Encode

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

Decode

>>>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!"

Web

# $ pip3 install bottleimportbottlefromurllib.parseimportunquote

Run

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

Static request

@route('/img/<image>')defsend_image(image):
returnstatic_file(image, 'images/', mimetype='image/png')

Dynamic request

@route('/<sport>')defsend_page(sport):
sport=unquote(sport).lower()
page=read_file(sport)
returntemplate(page)

REST request

@post('/odds/<sport>')defodds_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'returnjson.dumps([home_odds, away_odds])

Profile

Basic:

fromtimeimporttimestart_time=time()
...
duration=time() -start_time

Times execution of the passed code:

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

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

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

defget_filename():
fromdatetimeimportdatetimetime_str=datetime.now().strftime('%Y%m%d%H%M%S')
returnf'profile-{time_str}.png'

Progress Bar

Tqdm

# $ pip3 install tqdmfromtqdmimporttqdmfromtimeimportsleepforiintqdm(range(100)):
sleep(0.02)
foriintqdm([1, 2, 3]):
sleep(0.2)

Basic

importsysclassBar():
@staticmethoddefrange(*args):
bar=Bar(len(list(range(*args))))
foriinrange(*args):
yieldibar.tick()
@staticmethoddefforeach(elements):
bar=Bar(len(elements))
forelinelements:
yieldelbar.tick()
def__init__(s, steps, width=40):
s.st, s.wi, s.fl, s.i=steps, width, 0, 0s.th=s.fl*s.st/s.wis.p(f"[{' '*s.wi}]")
s.p('\b'* (s.wi+1))
deftick(s):
s.i+=1whiles.i>s.th:
s.fl+=1s.th=s.fl*s.st/s.wis.p('-')
ifs.i==s.st:
s.p('\n')
defp(s, t):
sys.stdout.write(t)
sys.stdout.flush()

Usage:

fromtimeimportsleepforiinBar.range(100):
sleep(0.02)
forelinBar.foreach([1, 2, 3]):
sleep(0.2)

Basic Script Template

#!/usr/bin/env python3## Usage: .py # fromcollectionsimportnamedtuplefromenumimportEnumimportreimportsysdefmain():
pass##### UTIL#defread_file(filename):
withopen(filename, encoding='utf-8') asfile:
returnfile.readlines()
if__name__=='__main__':
main()