Download text file or Fork me on GitHub.
if __name__ == '__main__':
main()<list> = <list>[from_inclusive : to_exclusive : step_size]
<list>.append(<el>)
<list>.extend(<collection>)
<list> += [<el>]
<list> += <collection><list>.sort()
<list>.reverse()
<list> = sorted(<collection>)
<iter> = reversed(<list>)sum_of_elements = sum(<collection>)
elementwise_sum = [sum(pair) for pair in zip(list_a, list_b)]
sorted_by_second = sorted(<collection>, key=lambda el: el[1])
sorted_by_both = sorted(<collection>, 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, <collection>)
no_duplicates = list(dict.fromkeys(<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> = collections.defaultdict(<type>) # Creates a dictionary with default value of type.
<dict> = collections.defaultdict(lambda: 1) # Creates a dictionary with default value 1.<dict>.update(<dict>) # Or: dict_a = {**dict_a, **dict_b}.
<dict> = dict(<list>) # Initiates a dict from list of key-value pairs.
<dict> = dict(zip(keys, values)) # Initiates a dict from two lists.
<dict> = dict.fromkeys(keys [, value]) # Initiates a dict from list of keys.value = <dict>.pop(key) # Removes item from dictionary.
{k: v for k, v in <dict>.items() if k in keys} # Filters dictionary by keys.>>> from collections import Counter
>>> colors = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> counter = Counter(colors)
Counter({'blue': 3, 'red': 2, 'yellow': 1})
>>> counter.most_common()[0][0]
'blue'<set> = set()
<set>.add(<el>)
<set>.update(<collection>)
<set> |= {<el>}
<set> |= <set><set> = <set>.union(<coll.>) # Or: <set> | <set>
<set> = <set>.intersection(<coll.>) # Or: <set> & <set>
<set> = <set>.difference(<coll.>) # Or: <set> - <set>
<set> = <set>.symmetric_difference(<coll.>) # Or: <set> ^ <set>
<bool> = <set>.issubset(<coll.>) # Or: <set> <= <set>
<bool> = <set>.issuperset(<coll.>) # Or: <set> >= <set><set>.remove(<el>) # Throws error.
<set>.discard(<el>) # Doesn't throw error.<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>.stopfor i, el in enumerate(<collection> [, i_start]):
...>>> Point = collections.namedtuple('Point', 'x y')
>>> p = Point(1, y=2)
Point(x=1, y=2)
>>> p[0]
1
>>> p.x
1
>>> getattr(p, 'y')
2
>>> p._fields # Or: Point._fields
('x', 'y')<iter> = iter(<collection>)
<iter> = iter(<function>, to_exclusive)for line in iter(input, ''):
...from functools import partial
for line in iter(partial(input, 'Please enter value: '), ''):
...Returns next item. If there are no more items it raises exception or returns default if specified.
<el> = next(<iter> [, default])next(<iter>)
for element in <iter>:
...Convenient way to implement the iterator protocol.
def step(start, step_size):
while True:
yield start
start += step_size>>> 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
<bool> = isinstance(<el>, Number)<bool> = callable(<el>)<str> = <str>.strip() # Strips all whitespace characters from both ends.
<str> = <str>.strip('<chars>') # Strips all passed characters from both ends.<list> = <str>.split() # Splits on any whitespace character.
<list> = <str>.split(sep=None, maxsplit=-1) # Splits on 'sep' str 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 br
58CF
eaks 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)import re
<str> = re.sub(<regex>, new, text, count=0) # Substitutes all occurrences.
<list> = re.findall(<regex>, text) # Returns all occurrences.
<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.
<iter> = re.finditer(<regex>, text) # Returns all occurrences as match objects.- Parameter
'flags=re.IGNORECASE'can be used with all functions. - Parameter
'flags=re.DOTALL'makes dot also accept newline. - Use
r'\1'or'\\\\1'for backreference. - Use
'?'to make operators non-greedy.
<str> = <Match>.group() # Whole match.
<str> = <Match>.group(1) # Part in first bracket.
<tuple> = <Match>.groups() # All bracketed parts.
<int> = <Match>.start() # Start index of a match.
<int> = <Match>.end() # Exclusive end index of a match.Use capital letter for negation.
'\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>''!r' calls object's repr() method, instead of format(), to get a string.
{'abcde'!r:<10} # "'abcde' "{'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'
{ 123456:+10} # ' +123456'
{-123456:=10} # '- 123456'
{ 123456: } # ' 123456'
{-123456: } # '-123456'{65:c} # 'A'
{3:08b} # '00000011' -> Binary with leading zeros.
{3:0<8b} # '11000000' -> Binary with trailing zeros.'f'- Fixed point:.<precision>f'%'- Percent:.<precision>%'e'- Exponent
'c'- character'b'- binary'x'- hex'X'- HEX
<num> = pow(<num>, <num>) # Or: <num> ** <num>
<real> = abs(<num>)
<real> = round(<real> [, ndigits])from math import e, pifrom math import cos, acos, sin, asin, tan, atan, degrees, radiansfrom math import log, log10, log2
<float> = log(<real> [, base]) # Base e, if not specified.from math import inf, nan, isinf, isnanfloat('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')'*' 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) 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, 8, 9}
<dict> = {i: i*2 for i in range(10)} # {0: 0, 1: 2, ..., 9: 18}
<iter> = (i+5 for i 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, 8, 9)
<int> = reduce(lambda out, x: out + x, range(10)) # 45<bool> = any(<collection>) # False if empty.
<bool> = all(el[1] for el in <collection>) # True if empty.<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')
point = Point(0, 0)from enum import Enum
Direction = Enum('Direction', 'n e s w')
Cutlery = Enum('Cutlery', {'fork': 1, 'knife': 2, 'spoon': 3})# Warning: Objects will share the objects that are initialized in the dictionary!
Creature = type('Creature', (), {'p': Point(0, 0), 'd': Direction.n})
creature = Creature()We have a closure in Python when:
- A nested function references a value of its enclosing function and then
- the enclosing function returns the nested function.
def get_multiplier(a):
def out(b):
return a * b
return out>>> multiply_by_3 = get_multiplier(3)
>>> multiply_by_3(10)
30- If multiple nested functions within enclosing function reference the same value, that value gets shared.
- To dynamicaly acces functions first free variable use
'<function>.__closure__[0].cell_contents'.
from functools import partial
<function> = partial(<function>, <argument_1> [, <argument_2>, ...])>>> multiply_by_3 = partial(operator.mul, 3)
>>> multiply_by_3(10)
30If variable is assigned to anywhere in the scope, it is regarded as a local variable, unless it is declared as global or nonlocal.
def get_counter():
a = 0
def out():
nonlocal a
a += 1
return a
return out>>> counter = get_counter()
>>> counter(), counter(), counter()
(1, 2, 3)A decorator takes a function, adds some functionality and returns it.
@decorator_name
def function_that_gets_passed_to_decorator():
...Decorator that prints function's name every time it gets called.
from functools import wraps
def debug(func):
@wraps(func)
def out(*args, **kwargs):
print(func.__name__)
return func(*args, **kwargs)
return out
@debug
def add(x, y):
return x + y- Wraps is a helper decorator that copies metadata of function add() to function out().
- Without it
'add.__name__'would return'out'.
Decorator that caches function's return values. All function's arguments must be hashable.
from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
return n if n < 2 else fib(n-1) + fib(n-2)>>> [fib(n) for n in range(10)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> fib.cache_info()
CacheInfo(hits=16, misses=10, maxsize=None, currsize=10)from functools import wraps
def debug(print_result=False):
def decorator(func):
@wraps(func)
def out(*args, **kwargs):
result = func(*args, **kwargs)
print(func.__name__, result if print_result else '')
return result
return out
return decorator
@debug(print_result=True)
def add(x, y):
return x + yclass <name>:
def __init__(self, a):
self.a = a
def __repr__(self):
class_name = type(self).__name__
return f'{class_name}({self.a!r})'
def __str__(self):
return str(self.a)
@classmethod
def get_class_name(cls):
return cls.__name__class <name>:
def __init__(self, a=None):
self.a = aclass Person:
def __init__(self, name, age):
self.name = name
self.age = age
class Employee(Person):
def __init__(self, name, age, staff_num):
super().__init__(name, age)
self.staff_num = staff_num- If eq() method is not overridden, it returns
'id(self) == id(other)', which is the same as'self is other'. - That means all objects compare not equal by default.
class MyComparable:
def __init__(self, a):
self.a = a
def __eq__(self, other):
if isinstance(other, type(self)):
return self.a == other.a
return False - Hashable object needs both hash() and eq() methods and it's hash value should never change.
- Hashable objects that compare equal must have the same hash value, meaning default hash() that returns
'id(self)'will not do. - That is why Python automatically makes classes unhashable if you only implement eq().
class MyHashable:
def __init__(self, a):
self.__a = copy.deepcopy(a)
@property
def a(self):
return self.__a
def __eq__(self, other):
if isinstance(other, type(self)):
return self.a == other.a
return False
def __hash__(self):
return hash(self.a)- Methods do not depend on each other, so they can be skipped if not needed.
- Any object with defined getitem() is considered iterable, even if it lacks iter().
class MySequence:
def __init__(self, a):
self.a = a
def __len__(self):
return len(self.a)
def __getitem__(self, i):
return self.a[i]
def __iter__(self):
for el in self.a:
yield elclass Counter:
def __init__(self):
self.a = 0
def __call__(self):
self.a += 1
return self.afrom 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()
@classmethod
def get_member_names(cls):
return [a.name for a in cls.__members__.values()]<member> = <enum>.<member_name>
<member> = <enum>['<member_name>']
<member> = <enum>(<value>)
name = <member>.name
value = <member>.valuelist_of_members = list(<enum>)
member_names = [a.name for a in <enum>]
member_values = [a.value for a in <enum>]
random_member = random.choice(list(<enum>))Cutlery = Enum('Cutlery', ['fork', 'knife', 'spoon'])
Cutlery = Enum('Cutlery', 'fork knife spoon')
Cutlery = Enum('Cutlery', {'fork': 1, 'knife': 2, 'spoon': 3})from functools import partial
LogicOp = Enum('LogicOp', {'AND': partial(lambda l, r: l and r),
'OR' : partial(lambda l, r: l or r)})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.')
breakraise ValueError('A very specific message!')>>> try:
... raise KeyboardInterrupt
... finally:
... print('Goodbye, world!')
Goodbye, world!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterruptimport sys
script_name = sys.argv[0]
arguments = sys.argv[1:]print(<el_1>, ..., sep=' ', end='\n', file=sys.stdout, flush=False)- Use
'file=sys.stderr'for errors.
>>> from pprint import pprint
>>> pprint(dir())
['__annotations__',
'__builtins__',
'__doc__', ...]- Reads a line from user input or pipe if present.
- The trailing newline gets stripped.
- The prompt string is printed to standard output before reading input.
<str> = input(prompt=None)while True:
try:
print(input())
except EOFError:
breakOpens file and returns a corresponding file object.
<file> = open(<path>, mode='r', encoding=None)'r'- Read (default).'w'- Write (truncate).'x'- Write or fail if the file already exists.'a'- Append.'w+'- Read and write (truncate).'r+'- Read and write from the beginning.'a+'- Read and write from the end.'b'- Binary mode.'t'- Text mode (default).
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)from os import path, listdir
<bool> = path.exists(<path>)
<bool> = path.isfile(<path>)
<bool> = path.isdir(<path>)
<list> = listdir(<path>)>>> from glob import glob
>>> glob('../*.gif')
['1.gif', 'card.gif']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>>> import sys
>>> sys.getrecursionlimit()
1000
>>> sys.setrecursionlimit(5000)import json
<str> = json.dumps(<object>, ensure_ascii=True, indent=None)
<object> = json.loads(<str>)from collections import OrderedDict
<object> = 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 pickle
<bytes> = pickle.dumps(<object>)
<object> = pickle.loads(<bytes>)def read_pickle_file(filename):
with open(filename, 'rb') as file:
return pickle.load(file)def write_to_pickle_file(filename, an_object):
with open(filename, 'wb') as file:
pickle.dump(an_object, file)import sqlite3
db = sqlite3.connect(<filename>)
...
db.close()cursor = db.execute(<query>)
if cursor:
<tuple> = cursor.fetchone() # First row.
<list> = cursor.fetchall() # Remaining rows.db.execute(<query>)
db.commit()Bytes object is immutable sequence of single bytes. Mutable version is called bytearray.
< B2F1 div class="highlight highlight-source-python notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="<bytes> = b'<str>' <int> = <bytes>[<index>] <bytes> = <bytes>[<slice>] <bytes> = b''.join(<coll_of_bytes>)"><bytes> = b'<str>' <int> = <bytes>[<index>] <bytes> = <bytes>[<slice>] <bytes> = b''.join(<coll_of_bytes>)