A Python Guide for the Ages

#Contents

ToC = {
    '1. Collections': [List, Dictionary, Set, Tuple, Range, Enumerate, Iterator, Generator],
    '2. Types':       [Type, String, Regular_Exp, Format, Numbers, Combinatorics, Datetime],
    '3. Syntax':      [Args, Inline, Imports, Decorator, Class, Duck_Type, Enum, Exception],
    '4. System':      [Exit, Print, Input, Command_Line_Arguments, Open, Path, OS_Commands],
    '5. Data':        [JSON, Pickle, CSV, SQLite, Bytes, Struct, Array, Memory_View, Deque],
    '6. Advanced':    [Threading, Operator, Introspection, Metaprograming, Eval, Coroutine],
    '7. Libraries':   [Progress_Bar, Plot, Table, Curses, Logging, Scraping, Web, Profile,
                       NumPy, Image, Audio, Games, Data]
}

#Main

if __name__ == '__main__':     
    main()

#List

 = []

.append()            
.extend()

.sort()                  
.reverse()               
 = sorted()  
 = reversed()

sum_of_elements  = sum()
elementwise_sum  = [sum(pair) for pair in zip(list_a, list_b)]
sorted_by_second = sorted(, key=lambda el: el[1])
sorted_by_both   = sorted(, key=lambda el: (el[1], el[0]))
flatter_list     = list(itertools.chain.from_iterable())
product_of_elems = functools.reduce(lambda out, el: out * el, )
list_of_chars    = list()

For details about sorted(), min() and max() see sortable.
Module operator provides functions itemgetter() and mul() that offer the same functionality as lambda expressions above.

.insert(, )     
  = .pop([])    
 = .count()     
 = .index()     
.remove()            
.clear()

#Dictionary

 = .keys()                          
 = .values()                        
 = .items()

value  = .get(key, default=None)          
value  = .setdefault(key, default=None)   
 = collections.defaultdict()        
 = collections.defaultdict(lambda: 1)

 = dict()                     
 = dict(zip(keys, values))                
 = dict.fromkeys(keys [, value])

.update()                           
value = .pop(key)                         
{k for k, v in .items() if v == value}    
{k: v for k, v in .items() if k in keys}

Counter

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

.add()                                 
.update( [, ...])

  = .union()                   
  = .intersection()            
  = .difference()              
  = .symmetric_difference()    
 = .issubset()                
 = .issuperset()

 = .pop()                              
.remove()                              
.discard()

Frozen Set

Is immutable and hashable.
That means it can be used as a key in a dictionary or as an element in a set.

 = frozenset()

#Tuple

Tuple is an immutable and hashable list.

Featured Content Ads

add advertising here

COGNAC Metaverse

Explore World's first metaverse that is as real as our Real world.

https://cognac.knowasiak.com

 = ()
 = (,)                           
 = (,  [, ...])

Named Tuple

Tuple’s subclass with named elements.

>>> from collections import namedtuple
>>> Point = 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  
('x', 'y')

#Range

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

from_inclusive = .start
to_exclusive   = .stop

#Enumerate

for i, el in enumerate( [, i_start]):
    ...

#Iterator

 = iter()                 
 = iter(, to_exclusive)     
   = next( [, default])           
 = list()

Itertools

from itertools import count, repeat, cycle, chain, islice

 = count(start=0, step=1)             
 = repeat( [, times])             
 = cycle()

 = chain(,  [, ...])  
 = chain.from_iterable()

 = islice(, to_exclusive)       
 = islice(, from_inclusive, …)

#Generator

Any function that contains a yield statement returns a generator.
Generators and iterators are interchangeable.

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

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

#Type

Everything is an object.
Every object has a type.
Type and class are synonymous.

 = type()                          
 = isinstance(, )

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

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

from types import FunctionType, MethodType, LambdaType, GeneratorType, ModuleType

Abstract Base Classes

Each abstract base class specifies a set of virtual subclasses. These classes are then recognized by isinstance() and issubclass() as subclasses of the ABC, although they are really not. ABC can also manually decide whether or not a specific class is its virtual subclass, usually based on which methods the class has implemented. For instance, Iterable ABC looks for method iter() while Collection ABC looks for methods iter(), contains() and len().

>>> from collections.abc import Sequence, Collection, Iterable
>>> isinstance([1, 2, 3], Iterable)
True

┏━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━┯━━━━━━━━━━━━┓
┃                  │  Sequence  │ Collection │  Iterable  ┃
┠──────────────────┼────────────┼────────────┼────────────┨
┃ list, range, str │     ✓      │     ✓      │     ✓      ┃
┃ dict, set        │            │     ✓      │     ✓      ┃
┃ iter             │            │            │     ✓      ┃
┗━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━┷━━━━━━━━━━━━┛

>>> from numbers import Integral, Rational, Real, Complex, Number
>>> isinstance(123, Number)
True

┏━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┓
┃                    │ Integral │ Rational │   Real   │ Complex  │  Number  ┃
┠────────────────────┼──────────┼──────────┼──────────┼──────────┼──────────┨
┃ int                │    ✓     │    ✓     │    ✓     │    ✓     │    ✓     ┃
┃ fractions.Fraction │          │    ✓     │    ✓     │    ✓     │    ✓     ┃
┃ float              │          │          │    ✓     │    ✓     │    ✓     ┃
┃ complex            │          │          │          │    ✓     │    ✓     ┃
┃ decimal.Decimal    │          │          │          │          │    ✓     ┃
┗━━━━━━━━━━━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┛

#String

  = .strip()                       
  = .strip('')

 = .split()                       
 = .split(sep=None, maxsplit=-1)  
 = .splitlines(keepends=False)    
  = .join()

 =  in                   
 = .startswith()         
 = .endswith()           
  = .find()               
  = .index()

  = .replace(old, new [, count])   
  = .translate()            
  = chr()                          
  = ord()                          

Also: 'lstrip()', 'rstrip()' and 'rsplit()'.
Also: 'lower()', 'upper()', 'capitalize()' and 'title()'.

Property Methods
┏━━━━━━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┯━━━━━━━━━━┓
┃               │ [ !#$%…] │ [a-zA-Z] │  [¼½¾]   │  [²³¹]   │  [0-9]   ┃
┠───────────────┼──────────┼──────────┼──────────┼──────────┼──────────┨
┃ isprintable() │    ✓     │    ✓     │    ✓     │    ✓     │    ✓     ┃
┃ isalnum()     │          │    ✓     │    ✓     │    ✓     │    ✓     ┃
┃ isnumeric()   │          │          │    ✓     │    ✓     │    ✓     ┃
┃ isdigit()     │          │          │          │    ✓     │    ✓     ┃
┃ isdecimal()   │          │          │          │          │    ✓     ┃
┗━━━━━━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┷━━━━━━━━━━┛


Also: 'isspace()' checks for '[ tnrfvx1c-x1fx85…]'.

#Regex
import re
   = re.sub(, new, text, count=0)  
  = re.findall(, text)            
  = re.split(, text, maxsplit=0)  
 = re.search(, text)             
 = re.match(, text)              
  = re.finditer(, text)           


Search() and match() return None if they can’t find a match.
Argument 'flags=re.IGNORECASE' can be used with all functions.
Argument 'flags=re.MULTILINE' makes '^' and '$' match the start/end of each line.
Argument 'flags=re.DOTALL' makes dot also accept the 'n'.
Use r'1' or '\1' for backreference.
Add '?' after an operator to make it non-greedy.

Match Object
   = .group()                      
   = .group(1)                     
 = .groups()                     
   = .start()                      
   = .end()                        


Special Sequences

By default, decimal characters, alphanumerics and whitespaces from all alphabets are matched unless 'flags=re.ASCII' argument is used.
As shown below, it restricts special sequence matches to the first 128 characters and prevents 's' from accepting '[x1c-x1f]' (the so-called separator characters).
Use a capital letter for negation.

'd' == '[0-9]'                                
'w' == '[a-zA-Z0-9_]'                         
's' == '[ tnrfv]'                        


#Format
 = f'{}, {}'
 = '{}, {}'.format(, )


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


General Options
{:<10}                                     
{:^10}                                     
{:>10}                                     
{:.<10}                                    
{:0}                                       


Options can be generated dynamically: f'{:{}[…]}'.
Adding '!r' before the colon converts object to string by calling its repr() method.

Strings
{'abcde':10}                                   
{'abcde':10.3}                                 
{'abcde':.3}                                   
{'abcde'!r:10}                                 


Numbers
{123456:10}                                    
{123456:10,}                                   
{123456:10_}                                   
{123456:+10}                                   
{123456:=+10}                                  
{123456: }                                     
{-123456: }                                    


Floats
{1.23456:10.3}                                 
{1.23456:10.3f}                                
{1.23456:10.3e}                                
{1.23456:10.3%}                                


Comparison of presentation types:
┏━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┓
┃              │    {}   │   {:f}  │   {:e}  │   {:%}  ┃
┠──────────────┼────────────────┼────────────────┼────────────────┼────────────────┨
┃  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%' ┃
┗━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┛

┏━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━┓
┃              │  {:.2}  │  {:.2f} │  {:.2e} │  {:.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%'   ┃
┗━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┷━━━━━━━━━━━━━━━━┛

When both rounding up and rounding down are possible, the one that returns result with even last digit is chosen. That makes '{6.5:.0f}' a '6' and '{7.5:.0f}' an '8'.

#Numbers

Types
      = int()       
    = float()       
  = complex(real=0, imag=0)     
 = fractions.Fraction(0, 1)    
  = decimal.Decimal()  



'int()' and 'float()' raise ValueError on malformed strings.
Decimal numbers can be represented exactly, unlike floats where '1.1 + 2.2 != 3.3'.
Precision of decimal operations is set with: 'decimal.getcontext().prec = '.

Basic Functions
 = pow(, )                
 = abs()                       
 = round( [, ±ndigits])        


Math
from math import e, pi, inf, nan, isinf, isnan
from math import sin, cos, tan, asin, acos, atan, degrees, radians
from math import log, log10, log2


Statistics
from statistics import mean, median, variance, stdev, pvariance, pstdev


Random
from random import random, randint, choice, shuffle, gauss, seed

 = random()                       
   = randint(from_inc, to_inc)      
    = choice()                 


Bin, Hex
 = ±0b                         
 = int('±', 2)                 
 = int('±0b', 0)               
 = bin()                       


Bitwise Operators
 =  &                     
 =  |                     
 =  ^                     
 =  << n_bits                  
 = ~                           


#Combinatorics

Every function returns an iterator.
If you want to print the iterator, you need to pass it to the list() function first!

from itertools import product, combinations, combinations_with_replacement, permutations

>>> product([0, 1], repeat=3)
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), ..., (1, 1, 1)]
>>> product('abc', 'abc')                    
[('a', 'a'), ('a', 'b'), ('a', 'c'),         
 ('b', 'a'), ('b', 'b'), ('b', 'c'),         
 ('c', 'a'), ('c', 'b'), ('c', 'c')]         
>>> 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

Module ‘datetime’ provides ‘date’ , ‘time’ , ‘datetime’  and ‘timedelta’ 




















































































 classes. All are immutable and hashable.
Time and datetime objects can be ‘aware’ , meaning they have defined timezone, or ‘naive’ , meaning they don’t.

If object is naive, it is presumed to be in the system’s timezone.

from datetime import date, time, datetime, timedelta
from dateutil.tz import UTC, tzlocal, gettz, datetime_exists, resolve_imaginary



Constructors
  = date(year, month, day)
  = time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)
 = datetime(year, month, day, hour=0, minute=0, second=0, ...)
 = timedelta(weeks=0, days=0, hours=0, minutes=0, seconds=0, ...)



Use '.weekday()' to get the day of the week (Mon == 0).
'fold=1' means the second pass in case of time jumping back for one hour.
TD converts and normalizes args to ±days, seconds (< 86 400) and microseconds (< 1M).


Now
  = D/DT.today()                     
    = DT.utcnow()                      
    = DT.now()                 



To extract time use '.time()', '.time()' or '.timetz()'.


Timezone
 = UTC                              
 = tzlocal()                        
 = gettz('/')      
    = .astimezone()        
 = .replace(tzinfo=)  



Encode
 = D/T/DT.fromisoformat('')    
     = DT.strptime(, '')   
  = D/DT.fromordinal()          
    = DT.fromtimestamp()         
    = DT.fromtimestamp(, )  



ISO strings come in following forms: 'YYYY-MM-DD', 'HH:MM:SS.ffffff[±]', or both separated by an arbitrary character. Offset is formatted as: 'HH:MM'.
Epoch on Unix systems is: '1970-01-01 00:00 UTC', '1970-01-01 01:00 CET', …


Decode
    = .isoformat(sep='T')      
    = .strftime('')    
    = .toordinal()               
  = .timestamp()                
  = .timestamp()                



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



'%Z' only accepts 'UTC/GMT' and local timezone’s code. '%z' also accepts '±HH:MM'.
For abbreviated weekday and month use '%a' and '%b'.


Arithmetics
   =   ±                    
     =  -                 
     =    -                   
     =     *                  
  =     /                    



#Arguments

Inside Function Call
()                  
()                     
(, )  




Inside Function Definition
def f():                      
def f():                         
def f(, ):      



#Splat Operator

Inside Function Call
Splat expands a collection into positional arguments, while splatty-splat expands a dictionary into keyword 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)



Inside Function Definition
Splat combines zero or more positional arguments into a tuple, while splatty-splat combines zero or more keyword arguments into a dictionary.
Featured Content Ads
add advertising here
COGNAC Metaverse
Explore World's first metaverse that is as real as our Real world.
https://cognac.knowasiak.com
 

def add(*a):
    return sum(a)


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


Legal argument combinations:
def f(x, y, z):                
def f(*, x, y, z):             
def f(x, *, y, z):             
def f(x, y, *, z):             


def f(*args):                  
def f(x, *args):               
def f(*args, z):               
def f(x, *args, z):            

def f(**kwargs):               
def f(x, **kwargs):            
def f(*, x, **kwargs):         

def f(*args, **kwargs):        
def f(x, *args, **kwargs):     
def f(*args, y, **kwargs):     
def f(x, *args, z, **kwargs):  


Other Uses
  = [* [, ...]]
   = {* [, ...]}
 = (*, [...])
  = {** [, ...]}


head, *body, tail = 


#Inline

Lambda
 = lambda: 
 = lambda , : 




Comprehensions
 = [i+1 for i in range(10)]                         
  = {i for i in range(10) if i > 5}                  
 = (i+5 for i in range(10))                         
 = {i: i*2 for i in range(10)}                      


>>> [l+r for l in 'abc' for r in 'abc']
['aa', 'ab', 'ac', ..., 'cc']


Map, Filter, Reduce
 = map(lambda x: x + 1, range(10))                  
 = filter(lambda x: x > 5, range(10))               
  = reduce(lambda out, x: out + x, range(10))        



Reduce must be imported from the functools module.


Any, All
 = any()                                
 = all()                                



Conditional Expression
 =  if  else 


>>> [a if a else 'zero' for a in (0, 1, 2, 3)]
['zero', 1, 2, 3]


Named Tuple, Enum, Dataclass
from collections import namedtuple
Point = namedtuple('Point', 'x y')
point = Point(0, 0)


from enum import Enum
Direction = Enum('Direction', 'n e s w')
direction = Direction.n

from dataclasses import make_dataclass
Creature = make_dataclass('Creature', ['loc', 'dir'])
creature = Creature(point, direction)


#Imports
import             
import            
import .  



Package is a collection of modules, but it can also define its own objects.
On a filesystem this corresponds to a directory of Python files with an optional init script.
Running 'import ' does not automatically provide access to the package’s modules unless they are explicitly imported in its init script.


#Closure
We have/get 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 dynamically access function’s first free variable use '.__closure__[0].cell_contents'.


Partial
from functools import partial
 = partial( [, , , ...])


>>> import operator as op
>>> multiply_by_3 = partial(op.mul, 3)
>>> multiply_by_3(10)
30


Partial is also useful in cases when function needs to be passed as an argument because it enables us to set its arguments beforehand.
A few examples being: 'defaultdict()', 'iter(, to_exclusive)' and dataclass’s 'field(default_factory=)'.


Non-Local
If variable is being assigned to anywhere in the scope, it is regarded as a local variable, unless it is declared as a ‘global’ or a ‘nonlocal’.
def get_counter():
    i = 0
    def out():
        nonlocal i
        i += 1
        return i
    return out


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


#Decorator

A decorator takes a function, adds some functionality and returns it.
It can be any callable, but is usually implemented as a function that returns a closure.

@decorator_name
def function_that_gets_passed_to_decorator():
    ...



Debugger Example
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 the metadata of the passed function (func) to the function it is wrapping (out).
Without it 'add.__name__' would return 'out'.


LRU Cache
Decorator that caches function’s return values. All function’s arguments must be hashable.
Featured Content Ads
add advertising here
Join Bing with ChatGPT-4
Use the new internet where you get what you ask, Fast and precise using AI.
https://www.bing.com
 

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n-2) + fib(n-1)



CPython interpreter limits recursion depth to 1000 by default. To increase it use 'sys.setrecursionlimit()'.


Parametrized Decorator
A decorator that accepts arguments and returns a normal decorator that accepts a function.
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 + y



#Class
class <name>:
    def __init__(self, a):
        self.a = a
    def __repr__(self):
        class_name = self.__class__.__name__
        return f'{class_name}({self.a!r})'
    def __str__(self):
        return str(self.a)

    @classmethod
    def get_class_name(cls):
        return cls.__name__



Return value of repr() should be unambiguous and of str() readable.
If only repr() is defined, it will also be used for str().


Str() use cases:
print()
print(f'{}')
raise Exception()
csv.writer().writerow([])
logging.warning()



Repr() use cases:
print([])
print(f'{!r}')
>>> 
Z = dataclasses.make_dataclass('Z', ['a']); print(Z())



Constructor Overloading
class <name>:
    def __init__(self, a=None):
        self.a = a



Inheritance
class 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



Multiple Inheritance
class A: pass
class B: pass
class C(A, B): pass


MRO determines the order in which parent classes are traversed when searching for a method:
>>> C.mro()
[<class 'C'>, <class 'A'>, <class 'B'>, <class 'object'>]


Property
Pythonic way of implementing getters and setters.
class MyClass:
    @property
    def a(self):
        return self._a

    @a.setter
    def a(self, value):
        self._a = value


>>> obj = MyClass()
>>> obj.a = 123
>>> obj.a
123


Dataclass
Decorator that automatically generates init(), repr() and eq() special methods.
from dataclasses import dataclass, field

@dataclass(order=False, frozen=False)
class <class_name>:
    : 
    :  = 
    : list/dict/set = field(default_factory=list/dict/set)



Objects can be made sortable with 'order=True' and immutable with 'frozen=True'.
For object to be hashable, all attributes must be hashable and frozen must be True.
Function field() is needed because ': list = []' would make a list that is shared among all instances. Its ‘default_factory’ argument can be any callable.
For attributes of arbitrary type use 'typing.Any'.


Inline:
from dataclasses import make_dataclass
 = make_dataclass('', )
 = make_dataclass('', )
 = ('',  [, ])


Slots
Mechanism that restricts objects to attributes listed in ‘slots’ and significantly reduces their memory footprint.
class MyClassWithSlots:
    __slots__ = ['a']
    def __init__(self):
        self.a = 1



Copy
from copy import copy, deepcopy