Contents

Main

if__name__=='__main__':# Runs main() if file wasn't imported.main()

List

<list>=<list>[from_inclusive :to_exclusive : ±step_size]

<list>.append(<el>)# Or: <list> += [<el>]<list>.extend(<collection>)# Or: <list> += <collection>

<list>.sort()<list>.reverse()<list>=sorted(<collection>)<iter>=reversed(<list>)

sum_of_elements=sum(<collection>)elementwise_sum= [sum(pair)forpairinzip(list_a,list_b)]sorted_by_second=sorted(<collection>,key=lambdael:el[1])sorted_by_both=sorted(<collection>,key=lambdael: (el[1],el[0]))flatter_list=list(itertools.chain.from_iterable(<list>))product_of_elems=functools.reduce(lambdaout,el:out*el,<collection>)list_of_chars=list(<str>)

<int>=<list>.count(<el>)# Returns number of occurrences. Also works on strings.index=<list>.index(<el>)# Returns index of first occurrence or raises ValueError.<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 or raises ValueError.<list>.clear()# Removes all items. Also works on dictionary and set.

Dictionary

<view>=<dict>.keys()# Coll. of keys that reflects changes.<view>=<dict>.values()# Coll. of values that reflects changes.<view>=<dict>.items()# Coll. of key-value tuples that reflects chgs.

value=<dict>.get(key,default=None)# Returns default if key is missing.value=<dict>.setdefault(key,default=None)# Returns and writes default if key is missing.<dict>=collections.defaultdict(<type>)# Creates a dict with default value of type.<dict>=collections.defaultdict(lambda:1)# Creates a dict with default value 1.

<dict>=dict(<collection>)# Creates a dict from coll. of key-value pairs.<dict>=dict(zip(keys,values))# Creates a dict from two collections.<dict>=dict.fromkeys(keys [,value])# Creates a dict from collection of keys.

<dict>.update(<dict>)# Adds items. Replaces ones with matching keys.value=<dict>.pop(key)# Removes item or raises KeyError.{kfork,vin<dict>.items()ifv==value}# Returns set of keys that point to the value.{k:vfork,vin<dict>.items()ifkinkeys}# Returns a dictionary, filtered by keys.

Counter

>>>fromcollectionsimportCounter>>>colors= ['blue','blue','blue','red','red']>>>counter=Counter(colors)>>>counter['yellow']+=1Counter({'blue':3,'red':2,'yellow':1})>>>counter.most_common()[0]('blue',3)

Set

<set>=set()

<set>.add(<el>)# Or: <set> |= {<el>}<set>.update(<collection>)# Or: <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>

<el>=<set>.pop()# Raises KeyError if empty.<set>.remove(<el>)# Raises KeyError if missing.<set>.discard(<el>)# Doesn't raise an error.

Frozen Set

<frozenset>=frozenset(<collection>)

Tuple

<tuple>= ()<tuple>= (<el>, )<tuple>= (<el_1>,<el_2> [, ...])

Named Tuple

>>>fromcollectionsimportnamedtuple>>>Point=namedtuple('Point','x y')>>>p=Point(1,y=2)Point(x=1,y=2)>>>p[0]1>>>p.x1>>>getattr(p,'y')2>>>p._fields# Or: Point._fields('x','y')

Range

<range>=range(to_exclusive)<range>=range(from_inclusive,to_exclusive)<range>=range(from_inclusive,to_exclusive, ±step_size)

from_inclusive=<range>.startto_exclusive=<range>.stop

Enumerate

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

Iterator

<iter>=iter(<collection>)# `iter(<iter>)` returns unmodified iterator.<iter>=iter(<function>,to_exclusive)# A sequence of return values until 'to_exclusive'.<el>=next(<iter> [,default])# Raises StopIteration or returns 'default' on end.<list>=list(<iter>)# Returns a list of iterator's remaining elements.

Itertools

fromitertoolsimportcount,repeat,cycle,chain,islice

<iter>=count(start=0,step=1)# Returns incremented value endlessly.<iter>=repeat(<el> [,times])# Returns element endlessly or 'times' times.<iter>=cycle(<collection>)# Repeats the sequence endlessly.

<iter>=chain(<coll_1>,<coll_2> [, ...])# Empties collections in order.<iter>=chain.from_iterable(<collection>)# Empties collections inside a collection in order.

<iter>=islice(<collection>,to_exclusive)<iter>=islice(<collection>,from_inclusive,to_exclusive [,+step_size])

Generator

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

>>>counter=count(10,2)>>>next(counter),next(counter),next(counter)(10,12,14)

Type

<type>=type(<el>)# Or: <el>.__class__<bool>=isinstance(<el>,<type>)# Or: issubclass(type(<el>), <type>)

>>>type('a'),'a'.__class__,str(<class'str'>,<class'str'>,<class'str'>)

Some types do not have built-in names, so they must be imported:

fromtypesimportFunctionType,MethodType,LambdaType,GeneratorType

ABC

>>>fromcollections.abcimportSequence,Collection,Iterable>>>isinstance([1,2,3],Iterable)True

+------------------+------------+------------+------------+|                  |  Sequence  | Collection |  Iterable  |+------------------+------------+------------+------------+| list, range, str |    yes     |    yes     |    yes     || dict, set        |            |    yes     |    yes     || iter             |            |            |    yes     |+------------------+------------+------------+------------+

>>>fromnumbersimportIntegral,Rational,Real,Complex,Number>>>isinstance(123,Number)True

+--------------------+----------+----------+----------+----------+----------+|                    | Integral | Rational |   Real   | Complex  |  Number  |+--------------------+----------+----------+----------+----------+----------+| int                |   yes    |   yes    |   yes    |   yes    |   yes    || fractions.Fraction |          |   yes    |   yes    |   yes    |   yes    || float              |          |          |   yes    |   yes    |   yes    || complex            |          |          |          |   yes    |   yes    || decimal.Decimal    |          |          |          |          |   yes    |+--------------------+----------+----------+----------+----------+----------+

String

<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 one or more whitespace characters.<list>=<str>.split(sep=None,maxsplit=-1)# Splits on 'sep' str at most 'maxsplit' times.<list>=<str>.splitlines(keepends=False)# Splits on \n,\r,\r\n. Keeps them if 'keepends'.<str>=<str>.join(<coll_of_strings>)# Joins elements using string as separator.

<bool>=<sub_str>in<str># Checks if string contains a substring.<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>.find(<sub_str>)# Returns start index of first match or -1.<int>=<str>.index(<sub_str>)# Same but raises ValueError if missing.

<str>=<str>.replace(old,new [,count])# Replaces 'old' with 'new' at most 'count' times.<str>=<str>.translate(<table>)# Use `str.maketrans(<dict>)` to generate table.

<str>=chr(<int>)# Converts int to Unicode char.<int>=ord(<str>)# Converts Unicode char to int.

Property Methods

+---------------+----------+----------+----------+----------+----------+|               | [ !#$%…] | [a-zA-Z] |  [¼½¾]   |  [²³¹]   |  [0-9]   |+---------------+----------+----------+----------+----------+----------+| isprintable() |   yes    |   yes    |   yes    |   yes    |   yes    || isalnum()     |          |   yes    |   yes    |   yes    |   yes    || isnumeric()   |          |          |   yes    |   yes    |   yes    || isdigit()     |          |          |          |   yes    |   yes    || isdecimal()   |          |          |          |          |   yes    |+---------------+----------+----------+----------+----------+----------+

Regex

importre<str>=re.sub(<regex>,new,text,count=0)# Substitutes all occurrences with 'new'.<list>=re.findall(<regex>,text)# Returns all occurrences as strings.<list>=re.split(<regex>,text,maxsplit=0)# Use brackets in regex to include the matches.<Match>=re.search(<regex>,text)# Searches for first occurrence of the 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.

Match Object

<str>=<Match>.group()# Returns the whole match. Also group(0).<str>=<Match>.group(1)# Returns part in the first bracket.<tuple>=<Match>.groups()# Returns all bracketed parts.<int>=<Match>.start()# Returns start index of the match.<int>=<Match>.end()# Returns exclusive end index of the match.

Special Sequences

'\d'=='[0-9]'# Matches any digit.'\w'=='[a-zA-Z0-9_]'# Matches any alphanumeric.'\s'=='[\t\n\r\f\v]'# Matches any whitespace.

Format

<str>= f'{<el_1>}, {<el_2>}'<str> = '{}, {}'.format(<el_1>,<el_2>)

Attributes

>>>fromcollectionsimportnamedtuple>>>Person=namedtuple('Person','name height')>>>person=Person('Jean-Luc',187)>>>f'{person.height}''187'>>>'{p.height}'.format(p=person)'187'

General Options

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

Strings

{'abcde'!r:10}# "'abcde'   "{'abcde':10.3}# 'abc       '{'abcde':.3}# 'abc'

Numbers

{123456:10,}# '   123,456'{123456:10_}# '   123_456'{123456:+10}# '   +123456'{-123456:=10}# '-   123456'{123456: }# ' 123456'{-123456: }# '-123456'

Floats

{1.23456:10.3}# '      1.23'{1.23456:10.3f}# '     1.235'{1.23456:10.3e}# ' 1.235e+00'{1.23456:10.3%}# '  123.456%'

Comparison of presentation types:

+---------------+-----------------+-----------------+-----------------+-----------------+|               |    {<float>}    |   {<float>:f}   |   {<float>:e}   |   {<float>:%}   |+---------------+-----------------+-----------------+-----------------+-----------------+|   0.000056789 |    '5.6789e-05' |     '0.000057'  |  '5.678900e-05' |     '0.005679%' ||   0.00056789  |    '0.00056789' |     '0.000568'  |  '5.678900e-04' |     '0.056789%' ||   0.0056789   |    '0.0056789'  |     '0.005679'  |  '5.678900e-03' |     '0.567890%' ||   0.056789    |    '0.056789'   |     '0.056789'  |  '5.678900e-02' |     '5.678900%' ||   0.56789     |    '0.56789'    |     '0.567890'  |  '5.678900e-01' |    '56.789000%' ||   5.6789      |    '5.6789'     |     '5.678900'  |  '5.678900e+00' |   '567.890000%' ||  56.789       |   '56.789'      |    '56.789000'  |  '5.678900e+01' |  '5678.900000%' || 567.89        |  '567.89'       |   '567.890000'  |  '5.678900e+02' | '56789.000000%' |+---------------+-----------------+-----------------+-----------------+-----------------+

+---------------+-----------------+-----------------+-----------------+-----------------+|               |   {<float>:.2}  |  {<float>:.2f}  |  {<float>:.2e}  |  {<float>:.2%}  |+---------------+-----------------+-----------------+-----------------+-----------------+|   0.000056789 |    '5.7e-05'    |       '0.00'    |    '5.68e-05'   |       '0.01%'   ||   0.00056789  |    '0.00057'    |       '0.00'    |    '5.68e-04'   |       '0.06%'   ||   0.0056789   |    '0.0057'     |       '0.01'    |    '5.68e-03'   |       '0.57%'   ||   0.056789    |    '0.057'      |       '0.06'    |    '5.68e-02'   |       '5.68%'   ||   0.56789     |    '0.57'       |       '0.57'    |    '5.68e-01'   |      '56.79%'   ||   5.6789      |    '5.7'        |       '5.68'    |    '5.68e+00'   |     '567.89%'   ||  56.789       |    '5.7e+01'    |      '56.79'    |    '5.68e+01'   |    '5678.90%'   || 567.89        |    '5.7e+02'    |     '567.89'    |    '5.68e+02'   |   '56789.00%'   |+---------------+-----------------+-----------------+-----------------+-----------------+

Ints

{90:c}# 'Z'{90:b}# '1011010'{90:X}# '5A'

Numbers

Types

<int>=int(<float/str/bool>)# Or: math.floor(<float>)<float>=float(<int/str/bool>)# Or: <real>e±<int><complex>=complex(real=0,imag=0)# Or: <real> ± <real>j<Fraction>=fractions.Fraction(numerator=0,denominator=1)<Decimal>=decimal.Decimal(<str/int/float>)

Basic Functions

<num>=pow(<num>,<num>)# Or: <num> ** <num><num>=abs(<num>)# <float> = abs(<complex>)<num>=round(<num> [, ±ndigits])# `round(126, -1) == 130`

Math

frommathimporte,pi,inf,nanfrommathimportcos,acos,sin,asin,tan,atan,degrees,radiansfrommathimportlog,log10,log2

Statistics

fromstatisticsimportmean,median,variance,pvariance,pstdev

Random

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

Bin, Hex

<int>=0b<bin># Or: 0x<hex><int>=int('<bin>',2)# Or: int('<hex>', 16)<int>=int('0b<bin>',0)# Or: int('0x<hex>', 0)'0b<bin>'=bin(<int>)# Or: hex(<int>)

Bitwise Operators

<int>=<int>&<int># And<int>=<int>|<int># Or<int>=<int>^<int># Xor (0 if both bits equal)<int>=<int><<n_bits# Shift left<int>=<int>>>n_bits# Shift right<int>=~<int># Compliment (flips bits)

Combinatorics

fromitertoolsimportproduct,combinations,combinations_with_replacement,permutations

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

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

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

Datetime

fromdatetimeimportdate,time,datetime,timedeltafromdateutil.tzimportUTC,tzlocal,gettz,resolve_imaginary

Constructors

<D>=date(year,month,day)<T>=time(hour=0,minute=0,second=0,microsecond=0,tzinfo=None,fold=0)<DT>=datetime(year,month,day,hour=0,minute=0,second=0, ...)<TD>=timedelta(days=0,seconds=0,microseconds=0,milliseconds=0,minutes=0,hours=0,weeks=0)

Now

<D/DTn>=D/DT.today()# Current local date or naive datetime.<DTn>=DT.utcnow()# Naive datetime from current UTC time.<DTa>=DT.now(<tzinfo>)# Aware datetime from current tz time.

Timezone

<tzinfo>=UTC# UTC timezone. London without DST.<tzinfo>=tzlocal()# Local timezone. Also gettz().<tzinfo>=gettz('<Cont.>/<City>')# 'Continent/City_Name' timezone or None.<DTa>=<DT>.astimezone(<tzinfo>)# Datetime, converted to passed timezone.<Ta/DTa>=<T/DT>.replace(tzinfo=<tzinfo>)# Unconverted object with new timezone.

Encode

<D/T/DT>=D/T/DT.fromisoformat('<iso>')# Object from ISO string. Raises ValueError.<DT>=DT.strptime(<str>,'<format>')# Datetime from str, according to format.<D/DTn>=D/DT.fromordinal(<int>)# D/DTn from days since Christ, at midnight.<DTn>=DT.fromtimestamp(<real>)# Local time DTn from seconds since Epoch.<DTa>=DT.fromtimestamp(<real>,<tz.>)# Aware datetime from seconds since Epoch.

Decode

<str>=<D/T/DT>.isoformat(sep='T')# Also timespec='auto/hours/minutes/seconds'.<str>=<D/T/DT>.strftime('<format>')# Custom string representation.<int>=<D/DT>.toordinal()# Days since Christ, ignoring time and tz.<float>=<DTn>.timestamp()# Seconds since Epoch, from DTn in local tz.<float>=<DTa>.timestamp()# Seconds since Epoch, from DTa.

Format

>>>fromdatetimeimportdatetime>>>dt=datetime.strptime('2015-05-14 23:39:00.00 +0200','%Y-%m-%d %H:%M:%S.%f %z')>>>dt.strftime("%A, %dth of %B '%y, %I:%M%p %Z")"Thursday, 14th of May '15, 11:39PM UTC+02:00"

Arithmetics

<D/DT>=<D/DT>   ±<TD># Returned datetime can fall into missing hour.<TD>=<D/DTn>-<D/DTn># Returns the difference, ignoring time jumps.<TD>=<DTa>-<DTa># Ignores time jumps if they share tzinfo object.<TD>=<DT_UTC>-<DT_UTC># Convert DTs to UTC to get the actual delta.

Arguments

Inside Function Call

<function>(<positional_args>)# f(0, 0)<function>(<keyword_args>)# f(x=0, y=0)<function>(<positional_args>,<keyword_args>)# f(0, y=0)

Inside Function Definition

deff(<nondefault_args>):# def f(x, y):deff(<default_args>):# def f(x=0, y=0):deff(<nondefault_args>,<default_args>):# def f(x, y=0):

Splat Operator

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

Inside Function Definition

defadd(*a):returnsum(a)

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

Legal argument combinations:

deff(x,y,z):# f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)deff(*,x,y,z):# f(x=1, y=2, z=3)deff(x,*,y,z):# f(x=1, y=2, z=3) | f(1, y=2, z=3)deff(x,y,*,z):# f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3)

deff(*args):# f(1, 2, 3)deff(x,*args):# f(1, 2, 3)deff(*args,z):# f(1, 2, z=3)deff(x,*args,z):# f(1, 2, z=3)

deff(**kwargs):# f(x=1, y=2, z=3)deff(x,**kwargs):# f(x=1, y=2, z=3) | f(1, y=2, z=3)deff(*,x,**kwargs):# f(x=1, y=2, z=3)

deff(*args,**kwargs):# f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)deff(x,*args,**kwargs):# f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3) | f(1, 2, 3)deff(*args,y,**kwargs):# f(x=1, y=2, z=3) | f(1, y=2, z=3)deff(x,*args,z,**kwargs):# f(x=1, y=2, z=3) | f(1, y=2, z=3) | f(1, 2, z=3)

Other Uses

<list>= [*<collection> [, ...]]<set>= {*<collection> [, ...]}<tuple>= (*<collection>, [...])<dict>= {**<dict> [, ...]}

head,*body,tail=<collection>

Inline

Lambda

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

Comprehension

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

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, 8, 9)<obj>=reduce(lambdaout,x:out+x,range(10))# 45

Any, All

<bool>=any(<collection>)# False if empty.<bool>=all(el[1]forelin<collection>)# True if empty.

If - Else

<obj>=<expression_if_true>if<condition>else<expression_if_false>

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

Namedtuple, Enum, Dataclass

fromcollectionsimportnamedtuplePoint=namedtuple('Point','x y')point=Point(0,0)

fromenumimportEnumDirection=Enum('Direction','n e s w')direction=Direction.n

fromdataclassesimportmake_dataclassCreature=make_dataclass('Creature', ['location','direction'])creature=Creature(Point(0,0),Direction.n)

Closure

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

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

Partial

fromfunctoolsimportpartial<function>=partial(<function> [,<arg_1>,<arg_2>, ...])

>>>importoperatorasop>>>multiply_by_3=partial(op.mul,3)>>>multiply_by_3(10)30

Nonlocal

defget_counter():i=0defout():nonlocalii+=1returnireturnout

>>>counter=get_counter()>>>counter(),counter(),counter()(1,2,3)

Decorator

@decorator_namedeffunction_that_gets_passed_to_decorator():    ...

Debugger Example

fromfunctoolsimportwrapsdefdebug(func):@wraps(func)defout(*args,**kwargs):print(func.__name__)returnfunc(*args,**kwargs)returnout@debugdefadd(x,y):returnx+y

LRU Cache

fromfunctoolsimportlru_cache@lru_cache(maxsize=None)deffib(n):returnnifn<2elsefib(n-2)+fib(n-1)

Parametrized Decorator

fromfunctoolsimportwrapsdefdebug(print_result=False):defdecorator(func):@wraps(func)defout(*args,**kwargs):result=func(*args,**kwargs)print(func.__name__,resultifprint_resultelse'')returnresultreturnoutreturndecorator@debug(print_result=True)defadd(x,y):returnx+y

Class

class<name>:def__init__(self,a):self.a=adef__repr__(self):class_name=self.__class__.__name__returnf'{class_name}({self.a!r})'def__str__(self):returnstr(self.a)@classmethoddefget_class_name(cls):returncls.__name__

Str() use cases:

print(<el>)print(f'{<el>}')raiseException(<el>)loguru.logger.debug(<el>)csv.writer(<file>).writerow([<el>])

Repr() use cases:

print([<el>])print(f'{<el>!r}')>>><el>loguru.logger.exception()Z=dataclasses.make_dataclass('Z', ['a']);print(Z(<el>))

Constructor Overloading

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

Inheritance

classPerson:def__init__(self,name,age):self.name=nameself.age=ageclassEmployee(Person):def__init__(self,name,age,staff_num):super().__init__(name,age)self.staff_num=staff_num

Multiple Inheritance

classA:passclassB:passclassC(A,B):pass

>>>C.mro()[<class'C'>,<class'A'>,<class'B'>,<class'object'>]

Property

classMyClass:@propertydefa(self):returnself._a@a.setterdefa(self,value):self._a=value

>>>el=MyClass()>>>el.a=123>>>el.a123

Dataclass

fromdataclassesimportdataclass,field@dataclass(order=False,frozen=False)class<class_name>:<attr_name_1>:<type><attr_name_2>:<type>=<default_value><attr_name_3>:list/dict/set=field(default_factory=list/dict/set)

Inline:

fromdataclassesimportmake_dataclass<class>=make_dataclass('<class_name>',<coll_of_attribute_names>)<class>=make_dataclass('<class_name>',<coll_of_tuples>)<tuple>= ('<attr_name>',<type> [,<default_value>])

Slots

classMyClassWithSlots:__slots__= ['a']def__init__(self):self.a=1

Copy

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

Duck Types

Comparable

classMyComparable:def__init__(self,a):self.a=adef__eq__(self,other):ifisinstance(other,type(self)):returnself.a==other.areturnNotImplemented

Hashable

classMyHashable:def__init__(self,a):self._a=a@propertydefa(self):returnself._adef__eq__(self,other):ifisinstance(other,type(self)):returnself.a==other.areturnNotImplementeddef__hash__(self):returnhash(self.a)

Sortable

fromfunctoolsimporttotal_ordering@total_orderingclassMySortable:def__init__(self,a):self.a=adef__eq__(self,other):ifisinstance(other,type(self)):returnself.a==other.areturnNotImplementeddef__lt__(self,other):ifisinstance(other,type(self)):returnself.a<other.areturnNotImplemented

Iterator

classCounter:def__init__(self):self.i=0def__next__(self):self.i+=1returnself.idef__iter__(self):returnself

>>>counter=Counter()>>>next(counter),next(counter),next(counter)(1,2,3)

Python has many different iterator objects:

Callable

classCounter:def__init__(self):self.i=0def__call__(self):self.i+=1returnself.i

>>>counter=Counter()>>>counter(),counter(),counter()(1,2,3)

Context Manager

classMyOpen():def__init__(self,filename):self.filename=filenamedef__enter__(self):self.file=open(self.filename)returnself.filedef__exit__(self,exc_type,exception,traceback):self.file.close()

>>>withopen('test.txt','w')asfile:...file.write('Hello World!')>>>withMyOpen('test.txt')asfile:...print(file.read())HelloWorld!

Iterable Duck Types

Iterable

classMyIterable:def__init__(self,a):self.a=adef__iter__(self):returniter(self.a)def__contains__(self,el):returnelinself.a

>>>obj=MyIterable([1,2,3])>>> [elforelinobj][1,2,3]>>>1inobjTrue

Collection

classMyCollection:def__init__(self,a):self.a=adef__iter__(self):returniter(self.a)def__contains__(self,el):returnelinself.adef__len__(self):returnlen(self.a)

Sequence

classMySequence:def__init__(self,a):self.a=adef__iter__(self):returniter(self.a)def__contains__(self,el):returnelinself.adef__len__(self):returnlen(self.a)def__getitem__(self,i):returnself.a[i]def__reversed__(self):returnreversed(self.a)

Collections.abc.Sequence

fromcollectionsimportabcclassMyAbcSequence(abc.Sequence):def__init__(self,a):self.a=adef__len__(self):returnlen(self.a)def__getitem__(self,i):returnself.a[i]

Table of required and automatically available special methods:

+------------+------------+------------+------------+--------------+|            |  Iterable  | Collection |  Sequence  | abc.Sequence |+------------+------------+------------+------------+--------------+| iter()     |    REQ     |    REQ     |    Yes     |     Yes      || contains() |    Yes     |    Yes     |    Yes     |     Yes      || len()      |            |    REQ     |    REQ     |     REQ      || getitem()  |            |            |    REQ     |     REQ      || reversed() |            |            |    Yes     |     Yes      || index()    |            |            |            |     Yes      || count()    |            |            |            |     Yes      |+------------+------------+------------+------------+--------------+

Enum

fromenumimportEnum,autoclass<enum_name>(Enum):<member_name_1>=<value_1><member_name_2>=<value_2_a>,<value_2_b><member_name_3>=auto()

<member>=<enum>.<member_name># Returns a member.<member>=<enum>['<member_name>']# Returns a member or raises KeyError.<member>=<enum>(<value>)# Returns a member or raises ValueError.<str>=<member>.name# Returns member's name.<obj>=<member>.value# Returns member's value.

list_of_members=list(<enum>)member_names= [a.nameforain<enum>]member_values= [a.valueforain<enum>]random_member=random.choice(list(<enum>))

defget_next_member(member):members=list(member.__class__)index= (members.index(member)+1)%len(members)returnmembers[index]

Inline

Cutlery=Enum('Cutlery','fork knife spoon')Cutlery=Enum('Cutlery', ['fork','knife','spoon'])Cutlery=Enum('Cutlery', {'fork':1,'knife':2,'spoon':3})

User-defined functions cannot be values, so they must be wrapped:

fromfunctoolsimportpartialLogicOp=Enum('LogicOp', {'AND':partial(lambdal,r:landr),'OR' :partial(lambdal,r:lorr)})

Exceptions

Basic Example

try:<code>except<exception>:<code>

Complex Example

try:<code_1>except<exception_a>:<code_2_a>except<exception_b>:<code_2_b>else:<code_2_c>finally:<code_3>

Catching Exceptions

except<exception>:except<exception>as<name>:except (<exception>, ...):except (<exception>, ...)as<name>:

Raising Exceptions

raise<exception>raise<exception>()raise<exception>(<el> [, ...])

Re-raising caught exception:

except<exception>as<name>:    ...raise

Exception Object

arguments=<name>.argsexc_type=<name>.__class__filename=<name>.__traceback__.tb_frame.f_code.co_filenamefunc_name=<name>.__traceback__.tb_frame.f_code.co_nameline=linecache.getline(filename,<name>.__traceback__.tb_lineno)error_msg=traceback.format_exception(exc_type,<name>,<name>.__traceback__)

Built-in Exceptions

BaseException +-- SystemExit                   # Raised by the sys.exit() function. +-- KeyboardInterrupt            # Raised when the user hits the interrupt key (ctrl-c). +-- Exception                    # User-defined exceptions should be derived from this class.      +-- ArithmeticError         # Base class for arithmetic errors.      |    +-- ZeroDivisionError  # Raised when dividing by zero.      +-- AttributeError          # Raised when an attribute is missing.      +-- EOFError                # Raised by input() when it hits end-of-file condition.      +-- LookupError             # Raised when a look-up on a collection fails.      |    +-- IndexError         # Raised when a sequence index is out of range.      |    +-- KeyError           # Raised when a dictionary key or set element is not found.      +-- NameError               # Raised when a variable name is not found.      +-- OSError                 # Failures such as “file not found” or “disk full”.      |    +-- FileNotFoundError  # When a file or directory is requested but doesn't exist.      +-- RuntimeError            # Raised by errors that don't fall in other categories.      |    +-- RecursionError     # Raised when the maximum recursion depth is exceeded.      +-- StopIteration           # Raised by next() when run on an empty iterator.      +-- TypeError               # Raised when an argument is of wrong type.      +-- ValueError              # When an argument is of right type but inappropriate value.           +-- UnicodeError       # Raised when encoding/decoding strings to/from bytes fails.

Collections and their exceptions:

+-----------+------------+------------+------------+|           |    list    |    dict    |    set     |+-----------+------------+------------+------------+| getitem() | IndexError |  KeyError  |            || pop()     | IndexError |  KeyError  |  KeyError  || remove()  | ValueError |            |  KeyError  || index()   | ValueError |            |            |+-----------+------------+------------+------------+

Useful built-in exceptions:

raiseTypeError('Argument is of wrong type!')raiseValueError('Argument is of right type but inappropriate value!')raiseRuntimeError('None of above!')

User-defined Exceptions

classMyError(Exception):passclassMyInputError(MyError):pass

Exit

importsyssys.exit()# Exits with exit code 0 (success).sys.exit(<int>)# Exits with passed exit code.sys.exit(<obj>)# Prints the object and exits with 1 (failure).

Print

print(<el_1>, ...,sep=' ',end='\n',file=sys.stdout,flush=False)

Pretty Print

frompprintimportpprintpprint(<collection>,width=80,depth=None,compact=False,sort_dicts=True)

Input

<str>=input(prompt=None)

Command Line Arguments

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

Argparse

fromargparseimportArgumentParser,FileTypep=ArgumentParser(description=<str>)p.add_argument('-<short_name>','--<name>',action='store_true')# Flagp.add_argument('-<short_name>','--<name>',type=<type>)# Optionp.add_argument('<name>',type=<type>,nargs=1)# First argumentp.add_argument('<name>',type=<type>,nargs='+')# Remaining argumentsp.add_argument('<name>',type=<type>,nargs='*')# Optional argumentsargs=p.parse_args()# Exits on error.value=args.<name>

Open

<file>=open('<path>',mode='r',encoding=None,newline=None)

Modes

Exceptions

File Object

<file>.seek(0)# Moves to the start of the file.<file>.seek(offset)# Moves 'offset' chars/bytes from the start.<file>.seek(0,2)# Moves to the end of the file.<bin_file>.seek(±offset,<anchor>)# Anchor: 0 start, 1 current pos., 2 end.

<str/bytes>=<file>.read(size=-1)# Reads 'size' chars/bytes or until EOF.<str/bytes>=<file>.readline()# Returns a line or empty string/bytes on EOF.<list>=<file>.readlines()# Returns a list of remaining lines.<str/bytes>=next(<file>)# Returns a line using buffer. Do not mix.

<file>.write(<str/bytes>)# Writes a string or bytes object.<file>.writelines(<collection>)# Writes a coll. of strings or bytes objects.<file>.flush()# Flushes write buffer.

Read Text from File

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

Write Text to File

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

Path

fromosimportgetcwd,path,listdirfromglobimportglob

<str>=getcwd()# Returns the current working directory.<str>=path.join(<path>, ...)# Joins two or more pathname components.<str>=path.abspath(<path>)# Returns absolute path.

<str>=path.basename(<path>)# Returns final component of the path.<str>=path.dirname(<path>)# Returns path without the final component.<tup.>=path.splitext(<path>)# Splits on last period of the final component.

<list>=listdir(path='.')# Returns filenames located at path.<list>=glob('<pattern>')# Returns paths matching the wildcard pattern.

<bool>=path.exists(<path>)# Or: <Path>.exists()<bool>=path.isfile(<path>)# Or: <DirEntry/Path>.is_file()<bool>=path.isdir(<path>)# Or: <DirEntry/Path>.is_dir()

DirEntry

fromosimportscandir

<iter>=scandir(path='.')# Returns DirEntry objects located at path.<str>=<DirEntry>.path# Returns path as a string.<str>=<DirEntry>.name# Returns final component as a string.<file>=open(<DirEntry>)# Opens the file and returns file object.

Path Object

frompathlibimportPath

<Path>=Path(<path> [, ...])# Accepts strings, Paths and DirEntry objects.<Path>=<path>/<path> [/ ...]# One of the paths must be a Path object.

<Path>=Path()# Returns relative cwd. Also Path('.').<Path>=Path.cwd()# Returns absolute cwd. Also Path().resolve().<Path>=<Path>.resolve()# Returns absolute Path without symlinks.

<Path>=<Path>.parent# Returns Path without final component.<str>=<Path>.name# Returns final component as a string.<str>=<Path>.stem# Returns final component without extension.<str>=<Path>.suffix# Returns final component's extension.<tup.>=<Path>.parts# Returns all components as strings.

<iter>=<Path>.iterdir()# Returns dir contents as Path objects.<iter>=<Path>.glob('<pattern>')# Returns Paths matching the wildcard pattern.

<str>=str(<Path>)# Returns path as a string.<file>=open(<Path>)# Opens the file and returns file object.

OS Commands

Files and Directories

importos,shutil

os.chdir(<path>)# Changes the current working directory.os.mkdir(<path>,mode=0o777)# Creates a directory. Mode is in octal.

shutil.copy(from,to)# Copies the file. 'to' can be a directory.shutil.copytree(from,to)# Copies the directory. 'to' must not exist.

os.rename(from,to)# Renames/moves the file or directory.os.replace(from,to)# Same, but overwrites 'to' if it exists.

os.remove(<path>)# Deletes the file.os.rmdir(<path>)# Deletes the empty directory.shutil.rmtree(<path>)# Deletes the directory.

Shell Commands

importos<str>=os.popen('<shell_command>').read()

Sends '1 + 1' to the calculator and captures its output:

>>>fromsubprocessimportrun>>>run('bc',input='1 + 1\n',capture_output=True,encoding='utf-8')CompletedProcess(args='bc',returncode=0,stdout='2\n',stderr='')

Sends test.in to the calculator running in standard mode and saves its output to test.out:

>>>fromshleximportsplit>>>os.popen('echo 1 + 1 > test.in')>>>run(split('bc -s'),stdin=open('test.in'),stdout=open('test.out','w'))CompletedProcess(args=['bc','-s'],returncode=0)>>>open('test.out').read()'2\n'

JSON

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

Read Object from JSON File

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

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

Pickle

importpickle<bytes>=pickle.dumps(<object>)<object>=pickle.loads(<bytes>)

Read Object from File

defread_pickle_file(filename):withopen(filename,'rb')asfile:returnpickle.load(file)

Write Object to File

defwrite_to_pickle_file(filename,an_object):withopen(filename,'wb')asfile:pickle.dump(an_object,file)

CSV

importcsv

Read

<reader>=csv.reader(<file>,dialect='excel',delimiter=',')<list>=next(<reader>)# Returns next row as a list of strings.<list>=list(<reader>)# Returns list of remaining rows.

Write

<writer>=csv.writer(<file>,dialect='excel',delimiter=',')<writer>.writerow(<collection>)# Encodes objects using `str(<el>)`.<writer>.writerows(<coll_of_coll>)# Appends multiple rows.

Parameters

Dialects

+------------------+--------------+--------------+--------------+|                  |     excel    |   excel-tab  |     unix     |+------------------+--------------+--------------+--------------+| delimiter        |       ','    |      '\t'    |       ','    || quotechar        |       '"'    |       '"'    |       '"'    || doublequote      |      True    |      True    |      True    || skipinitialspace |     False    |     False    |     False    || lineterminator   |    '\r\n'    |    '\r\n'    |      '\n'    || quoting          |         0    |         0    |         1    || escapechar       |      None    |      None    |      None    |+------------------+--------------+--------------+--------------+

Read Rows from CSV File

defread_csv_file(filename):withopen(filename,encoding='utf-8',newline='')asfile:returnlist(csv.reader(file))

Write Rows to CSV File

defwrite_to_csv_file(filename,rows):withopen(filename,'w',encoding='utf-8',newline='')asfile:writer=csv.writer(file)writer.writerows(rows)

SQLite

Connect

importsqlite3db=sqlite3.connect('<path>')# Also ':memory:'....db.close()

Read

<cursor>=db.execute('<query>')# Can raise a subclass of sqlite3.Error.<tuple>=<cursor>.fetchone()# Returns next row. Also next(<cursor>).<list>=<cursor>.fetchall()# Returns remaining rows. Also list(<cursor>).

Write

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

Or:

withdb:db.execute('<query>')

Placeholders

db.execute('<query>',<list/tuple>)# Replaces '?'s in query with values.db.execute('<query>',<dict/namedtuple>)# Replaces ':<key>'s with values.db.executemany('<query>',<coll_of_above>)# Runs execute() many times.

Example

>>>db=sqlite3.connect('test.db')>>>db.execute('create table t (a, b, c)')>>>db.execute('insert into t values (1, 2, 3)')>>>db.execute('select * from t').fetchall()[(1,2,3)]

MySQL

# $ pip3 install mysql-connectorfrommysqlimportconnectordb=connector.connect(host=<str>,user=<str>,password=<str>,database=<str>)<cursor>=db.cursor()<cursor>.execute('<query>')# Can raise a subclass of connector.Error.<cursor>.execute('<query>',<list/tuple>)# Replaces '%s's in query with values.<cursor>.execute('<query>',<dict/namedtuple>)# Replaces '%(<key>)s's with values.

Bytes

<bytes>=b'<str>'# Only accepts ASCII characters and \x00 - \xff.<int>=<bytes>[<index>]# Returns int in range from 0 to 255.<bytes>=<bytes>[<slice>]# Returns bytes even if it has only one element.<bytes>=<bytes>.join(<coll_of_bytes>)# Joins elements using bytes object as separator.

Encode

<bytes>=bytes(<coll_of_ints>)# Ints must be in range from 0 to 255.<bytes>=bytes(<str>,'utf-8')# Or: <str>.encode('utf-8')<bytes>=<int>.to_bytes(n_bytes,byteorder='big/little',signed=False)<bytes>=bytes.fromhex('<hex>')

Decode

<list>=list(<bytes>)# Returns ints in range from 0 to 255.<str>=str(<bytes>,'utf-8')# Or: <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_obj):withopen(filename,'wb')asfile:file.write(bytes_obj)

Struct

fromstructimportpack,unpack,iter_unpack<bytes>=pack('<format>',<num_1> [,<num_2>, ...])<tuple>=unpack('<format>',<bytes>)<tuples>=iter_unpack('<format>',<bytes>)

Example

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

Format

For standard type sizes start format string with:

Integer types. Use a capital letter for unsigned type. Standard sizes are in brackets:

Floating point types:

Array

fromarrayimportarray<array>=array('<typecode>',<collection>)# Array from collection of numbers.<array>=array('<typecode>',<bytes>)# Array from bytes object.<array>=array('<typecode>',<array>)# Treats array as a sequence of numbers.<bytes>=bytes(<array>)# Or: <array>.tobytes()

Memory View

<mview>=memoryview(<bytes/bytearray/array>)# Immutable if bytes, else mutable.<real>=<mview>[<index>]# Returns an int or a float.<mview>=<mview>[<slice>]# Mview with rearranged elements.<mview>=<mview>.cast('<typecode>')# Casts memoryview to the new format.<mview>.release()# Releases the object's memory buffer.

Decode

<bin_file>.write(<mview>)# Writes mview to the binary file.<bytes>=bytes(<mview>)# Creates a new bytes object.<bytes>=<bytes>.join(<coll_of_mviews>)# Joins mviews using bytes object as sep.<array>=array('<typecode>',<mview>)# Treats mview as a sequence of numbers.<list>=list(<mview>)# Returns list of ints or floats.<str>=str(<mview>,'utf-8')# Treats mview as a bytes object.<int>=int.from_bytes(<mview>,byteorder='big/little',signed=False)'<hex>'=<mview>.hex()

Deque

fromcollectionsimportdeque<deque>=deque(<collection>,maxlen=None)

<deque>.appendleft(<el>)# Opposite element is dropped if full.<deque>.extendleft(<collection>)# Collection gets reversed.<el>=<deque>.popleft()# Raises IndexError if empty.<deque>.rotate(n=1)# Rotates elements to the right.

Threading

fromthreadingimportThread,RLock,Semaphore,Event,Barrier

Thread

thread=Thread(target=<function>,args=(<first_arg>, ))thread.start()...<bool>=thread.is_alive()# Checks if thread has finished executing.thread.join()# Waits for thread to finish.

Lock

lock=RLock()lock.acquire()# Waits for lock to be available....lock.release()

Or:

lock=RLock()withlock:    ...

Semaphore, Event, Barrier

<Semaphore>=Semaphore(value=1)# Lock that can be acquired 'value' times.<Event>=Event()# Method wait() blocks until set() is called.<Barrier>=Barrier(n_times)# Method wait() blocks until it's called 'n_times'.

Thread Pool Executor

fromconcurrent.futuresimportThreadPoolExecutorwithThreadPoolExecutor(max_workers=None)asexecutor:<iter>=executor.map(lambdax:x+1,range(3))# (1, 2, 3)<iter>=executor.map(lambdax,y:x+y,'abc','123')# ('a1', 'b2', 'c3')<Future>=executor.submit(<function> [,<arg_1>, ...])

Future:

<bool>=<Future>.done()# Checks if thread has finished executing.<obj>=<Future>.result()# Waits for thread to finish and returns result.

Queue

fromqueueimportQueue<Queue>=Queue(maxsize=0)

<Queue>.put(<el>)# Blocks until queue stops being full.<Queue>.put_nowait(<el>)# Raises queue.Full exception if full.<el>=<Queue>.get()# Blocks until queue stops being empty.<el>=<Queue>.get_nowait()# Raises queue.Empty exception if empty.