Python essentials: object-oriented programming¶
Description: Classes and objects. Attributes, properties. Encapsulation, inheritance and polymorphism.
Styles of programming languges¶
- Procedural programming
- Series of computational steps to be carried out
- Routines/functions for modularization of steps
- Functional programming
- programming with expressions or declarations instead of statements
- Object-oriented programming
- classes and objects with attributes/properties and methods
Python is a pragmatic mix of styles
Procedural programming¶
In [1]:
def fibonacci_procedural(n, fst=1, sec=1):
''' Return the Fibonacci sequence up to n as a list'''
f = [0]*n # list of n zeros
f[0],f[1] = fst, sec
for i in range(2,n):
f[i] = f[i-1] + f[i-2]
return f
x1, x2 = 1,1 # data stored outside
for k in fibonacci_procedural(10,x1,x2):
print(k,end=' ') # print without new line
1 1 2 3 5 8 13 21 34 55
Functional programming¶
In [2]:
# Returns Fibonacci sequence up to n as a list
fibonacci_functional = (lambda n, first=1, second=1:
[] if n == 0 else
[first] + fibonacci_functional(n - 1, second, first + second))
for k in fibonacci_functional(10):
print(k,end=' ')
1 1 2 3 5 8 13 21 34 55
fibonacci_functional()¶
Lambda function of 3 arguments, last two are optional and defaulted to 1
If $ n=0 $ returns empty list
If $ n>0 $ proceed as follows:
- calls itself with decremented step counter and updated arguments
- appends the returned list to the [first]
Altogether $ n $ recursive calls
- counting steps down from the initial $ n $ to 0
- returning growing list of Fibonacci numbers
In [3]:
# Count how many times the function is actually called
fibonacci_functional = (lambda n, first=1, second=1:
print('.',end='') or (
[] if n == 0 else
[first] + fibonacci_functional(n - 1, second, first + second)))
for k in fibonacci_functional(10):
print(k,end=' ')
...........1 1 2 3 5 8 13 21 34 55
Object-oriented programming¶
In [4]:
class fibonacci:
''' Builds Fibonacci sequence up to n as a list'''
fst = 1 # data stored inside
sec = 1 # static attributes = the same for all objects
def __init__(self,n=5): # initializer/constructor
self.n = n # public attribute
def __call__(self): # method to make object callable
f = [0]*self.n # list of n zeros
f[0],f[1] = fibonacci.fst, fibonacci.sec
for i in range(2,self.n):
f[i] = f[i-1] + f[i-2]
return f
f = fibonacci(10) # instance of a class = object
print(type(f))
for k in f(): # call object fibonacci directly to get the list
print(k,end=' ') # print without new line
<class '__main__.fibonacci'> 1 1 2 3 5 8 13 21 34 55
Object-oriented programming (OOP)¶
- Classes
- Objects
- Attributes/properties
- Methods
OOP principles¶
- Encapsulation and Abstraction = Combining functions and related data withing the object, and exposing only needed interface while hiding internal mechanism for independent code refactoring
- Inheritance = class hierarchies $ \leftrightarrow $ inhereted methods don’t have to be re-implemented, although can be replaced/overloaded
- Polymorphism = same functions/interfaces for different types $ \leftrightarrow $ classes have methods with same names
Function to explore the class/object structure¶
In [5]:
%%writefile 'obj_explore.py'
def obj_explore(obj,what='all'):
'''Lists attributes and methods of a class
Input arguments: obj = variable to explore,
what = string with any combination of
all, public, private, methods, properties
'''
import sys # this function will run rarely, so import here
trstr = lambda s: s[:30] if isinstance(s, str) else s # truncates if string
spacer = lambda s: " "*max(15-len(s),2) # returns spacer to pad strings
hr='-'*60 # horizontal line
print(obj) # string representation of the input
print('%s\nObject report on object = %r' % (hr,obj))
cl=type(obj)
print('Objec class : %s' % cl)
print('Parent classes : %r' % cl.__bases__)
print('Occupied memory : %d bytes' % sys.getsizeof(obj))
if what in 'all public properties':
print('PUBLIC PROPERTIES')
data = [(name,getattr(obj,name)) for name in dir(obj) if not callable(getattr(obj,name)) and name[0:2]!='__']
for item in data:
print('%s = %r %s' % (item[0]+spacer(item[0]),trstr(item[1]),type(item[1])))
if what in 'all private properties':
print('PRIVATE PROPERTIES')
data = [(name,getattr(obj,name)) for name in dir(obj) if not callable(getattr(obj,name)) and name[0:2]=='__']
for item in data:
print('%s = %r %s' % (item[0]+spacer(item[0]),trstr(item[1]),type(item[1])))
if what in 'all public methods':
print('PUBLIC METHODS')
data = [(name,getattr(obj,name)) for name in dir(obj) if callable(getattr(obj,name)) and name[0:2]!='__']
for item in data:
print('%s %s' % (item[0]+spacer(item[0]),type(item[1])))
if what in 'all private methods':
print('PRIVATE METHODS')
data = [(name,getattr(obj,name)) for name in dir(obj) if callable(getattr(obj,name)) and name[0:2]=='__']
for item in data:
print('%s %s' % (item[0]+spacer(item[0]),type(item[1])))
Writing obj_explore.py
In [6]:
# import all functions from obj_explore.py
from obj_explore import *
help(obj_explore)
Help on function obj_explore in module obj_explore:
obj_explore(obj, what='all')
Lists attributes and methods of a class
Input arguments: obj = variable to explore,
what = string with any combination of
all, public, private, methods, properties
In [7]:
x = False # Boolean
obj_explore(x)
False ------------------------------------------------------------ Object report on object = False Objec class : <class 'bool'> Parent classes : <class 'int'> Occupied memory : 24 bytes PUBLIC PROPERTIES denominator = 1 <class 'int'> imag = 0 <class 'int'> numerator = 0 <class 'int'> real = 0 <class 'int'> PRIVATE PROPERTIES __doc__ = 'bool(x) -> bool\n\nReturns True ' <class 'str'> PUBLIC METHODS bit_length <class 'builtin_function_or_method'> conjugate <class 'builtin_function_or_method'> from_bytes <class 'builtin_function_or_method'> to_bytes <class 'builtin_function_or_method'> PRIVATE METHODS __abs__ <class 'method-wrapper'> __add__ <class 'method-wrapper'> __and__ <class 'method-wrapper'> __bool__ <class 'method-wrapper'> __ceil__ <class 'builtin_function_or_method'> __class__ <class 'type'> __delattr__ <class 'method-wrapper'> __dir__ <class 'builtin_function_or_method'> __divmod__ <class 'method-wrapper'> __eq__ <class 'method-wrapper'> __float__ <class 'method-wrapper'> __floor__ <class 'builtin_function_or_method'> __floordiv__ <class 'method-wrapper'> __format__ <class 'builtin_function_or_method'> __ge__ <class 'method-wrapper'> __getattribute__ <class 'method-wrapper'> __getnewargs__ <class 'builtin_function_or_method'> __gt__ <class 'method-wrapper'> __hash__ <class 'method-wrapper'> __index__ <class 'method-wrapper'> __init__ <class 'method-wrapper'> __init_subclass__ <class 'builtin_function_or_method'> __int__ <class 'method-wrapper'> __invert__ <class 'method-wrapper'> __le__ <class 'method-wrapper'> __lshift__ <class 'method-wrapper'> __lt__ <class 'method-wrapper'> __mod__ <class 'method-wrapper'> __mul__ <class 'method-wrapper'> __ne__ <class 'method-wrapper'> __neg__ <class 'method-wrapper'> __new__ <class 'builtin_function_or_method'> __or__ <class 'method-wrapper'> __pos__ <class 'method-wrapper'> __pow__ <class 'method-wrapper'> __radd__ <class 'method-wrapper'> __rand__ <class 'method-wrapper'> __rdivmod__ <class 'method-wrapper'> __reduce__ <class 'builtin_function_or_method'> __reduce_ex__ <class 'builtin_function_or_method'> __repr__ <class 'method-wrapper'> __rfloordiv__ <class 'method-wrapper'> __rlshift__ <class 'method-wrapper'> __rmod__ <class 'method-wrapper'> __rmul__ <class 'method-wrapper'> __ror__ <class 'method-wrapper'> __round__ <class 'builtin_function_or_method'> __rpow__ <class 'method-wrapper'> __rrshift__ <class 'method-wrapper'> __rshift__ <class 'method-wrapper'> __rsub__ <class 'method-wrapper'> __rtruediv__ <class 'method-wrapper'> __rxor__ <class 'method-wrapper'> __setattr__ <class 'method-wrapper'> __sizeof__ <class 'builtin_function_or_method'> __str__ <class 'method-wrapper'> __sub__ <class 'method-wrapper'> __subclasshook__ <class 'builtin_function_or_method'> __truediv__ <class 'method-wrapper'> __trunc__ <class 'builtin_function_or_method'> __xor__ <class 'method-wrapper'>
In [8]:
x = 0b1010 # Integer
obj_explore(x)
10 ------------------------------------------------------------ Object report on object = 10 Objec class : <class 'int'> Parent classes : <class 'object'> Occupied memory : 28 bytes PUBLIC PROPERTIES denominator = 1 <class 'int'> imag = 0 <class 'int'> numerator = 10 <class 'int'> real = 10 <class 'int'> PRIVATE PROPERTIES __doc__ = 'int([x]) -> integer\nint(x, bas' <class 'str'> PUBLIC METHODS bit_length <class 'builtin_function_or_method'> conjugate <class 'builtin_function_or_method'> from_bytes <class 'builtin_function_or_method'> to_bytes <class 'builtin_function_or_method'> PRIVATE METHODS __abs__ <class 'method-wrapper'> __add__ <class 'method-wrapper'> __and__ <class 'method-wrapper'> __bool__ <class 'method-wrapper'> __ceil__ <class 'builtin_function_or_method'> __class__ <class 'type'> __delattr__ <class 'method-wrapper'> __dir__ <class 'builtin_function_or_method'> __divmod__ <class 'method-wrapper'> __eq__ <class 'method-wrapper'> __float__ <class 'method-wrapper'> __floor__ <class 'builtin_function_or_method'> __floordiv__ <class 'method-wrapper'> __format__ <class 'builtin_function_or_method'> __ge__ <class 'method-wrapper'> __getattribute__ <class 'method-wrapper'> __getnewargs__ <class 'builtin_function_or_method'> __gt__ <class 'method-wrapper'> __hash__ <class 'method-wrapper'> __index__ <class 'method-wrapper'> __init__ <class 'method-wrapper'> __init_subclass__ <class 'builtin_function_or_method'> __int__ <class 'method-wrapper'> __invert__ <class 'method-wrapper'> __le__ <class 'method-wrapper'> __lshift__ <class 'method-wrapper'> __lt__ <class 'method-wrapper'> __mod__ <class 'method-wrapper'> __mul__ <class 'method-wrapper'> __ne__ <class 'method-wrapper'> __neg__ <class 'method-wrapper'> __new__ <class 'builtin_function_or_method'> __or__ <class 'method-wrapper'> __pos__ <class 'method-wrapper'> __pow__ <class 'method-wrapper'> __radd__ <class 'method-wrapper'> __rand__ <class 'method-wrapper'> __rdivmod__ <class 'method-wrapper'> __reduce__ <class 'builtin_function_or_method'> __reduce_ex__ <class 'builtin_function_or_method'> __repr__ <class 'method-wrapper'> __rfloordiv__ <class 'method-wrapper'> __rlshift__ <class 'method-wrapper'> __rmod__ <class 'method-wrapper'> __rmul__ <class 'method-wrapper'> __ror__ <class 'method-wrapper'> __round__ <class 'builtin_function_or_method'> __rpow__ <class 'method-wrapper'> __rrshift__ <class 'method-wrapper'> __rshift__ <class 'method-wrapper'> __rsub__ <class 'method-wrapper'> __rtruediv__ <class 'method-wrapper'> __rxor__ <class 'method-wrapper'> __setattr__ <class 'method-wrapper'> __sizeof__ <class 'builtin_function_or_method'> __str__ <class 'method-wrapper'> __sub__ <class 'method-wrapper'> __subclasshook__ <class 'builtin_function_or_method'> __truediv__ <class 'method-wrapper'> __trunc__ <class 'builtin_function_or_method'> __xor__ <class 'method-wrapper'>
In [9]:
x = 4.32913 # Float
obj_explore(x)
4.32913 ------------------------------------------------------------ Object report on object = 4.32913 Objec class : <class 'float'> Parent classes : <class 'object'> Occupied memory : 24 bytes PUBLIC PROPERTIES imag = 0.0 <class 'float'> real = 4.32913 <class 'float'> PRIVATE PROPERTIES __doc__ = 'Convert a string or number to ' <class 'str'> PUBLIC METHODS as_integer_ratio <class 'builtin_function_or_method'> conjugate <class 'builtin_function_or_method'> fromhex <class 'builtin_function_or_method'> hex <class 'builtin_function_or_method'> is_integer <class 'builtin_function_or_method'> PRIVATE METHODS __abs__ <class 'method-wrapper'> __add__ <class 'method-wrapper'> __bool__ <class 'method-wrapper'> __class__ <class 'type'> __delattr__ <class 'method-wrapper'> __dir__ <class 'builtin_function_or_method'> __divmod__ <class 'method-wrapper'> __eq__ <class 'method-wrapper'> __float__ <class 'method-wrapper'> __floordiv__ <class 'method-wrapper'> __format__ <class 'builtin_function_or_method'> __ge__ <class 'method-wrapper'> __getattribute__ <class 'method-wrapper'> __getformat__ <class 'builtin_function_or_method'> __getnewargs__ <class 'builtin_function_or_method'> __gt__ <class 'method-wrapper'> __hash__ <class 'method-wrapper'> __init__ <class 'method-wrapper'> __init_subclass__ <class 'builtin_function_or_method'> __int__ <class 'method-wrapper'> __le__ <class 'method-wrapper'> __lt__ <class 'method-wrapper'> __mod__ <class 'method-wrapper'> __mul__ <class 'method-wrapper'> __ne__ <class 'method-wrapper'> __neg__ <class 'method-wrapper'> __new__ <class 'builtin_function_or_method'> __pos__ <class 'method-wrapper'> __pow__ <class 'method-wrapper'> __radd__ <class 'method-wrapper'> __rdivmod__ <class 'method-wrapper'> __reduce__ <class 'builtin_function_or_method'> __reduce_ex__ <class 'builtin_function_or_method'> __repr__ <class 'method-wrapper'> __rfloordiv__ <class 'method-wrapper'> __rmod__ <class 'method-wrapper'> __rmul__ <class 'method-wrapper'> __round__ <class 'builtin_function_or_method'> __rpow__ <class 'method-wrapper'> __rsub__ <class 'method-wrapper'> __rtruediv__ <class 'method-wrapper'> __set_format__ <class 'builtin_function_or_method'> __setattr__ <class 'method-wrapper'> __sizeof__ <class 'builtin_function_or_method'> __str__ <class 'method-wrapper'> __sub__ <class 'method-wrapper'> __subclasshook__ <class 'builtin_function_or_method'> __truediv__ <class 'method-wrapper'> __trunc__ <class 'builtin_function_or_method'>
In [10]:
x = "Australian National University" # String
obj_explore(x,'public methods')
Australian National University ------------------------------------------------------------ Object report on object = 'Australian National University' Objec class : <class 'str'> Parent classes : <class 'object'> Occupied memory : 79 bytes PUBLIC METHODS capitalize <class 'builtin_function_or_method'> casefold <class 'builtin_function_or_method'> center <class 'builtin_function_or_method'> count <class 'builtin_function_or_method'> encode <class 'builtin_function_or_method'> endswith <class 'builtin_function_or_method'> expandtabs <class 'builtin_function_or_method'> find <class 'builtin_function_or_method'> format <class 'builtin_function_or_method'> format_map <class 'builtin_function_or_method'> index <class 'builtin_function_or_method'> isalnum <class 'builtin_function_or_method'> isalpha <class 'builtin_function_or_method'> isascii <class 'builtin_function_or_method'> isdecimal <class 'builtin_function_or_method'> isdigit <class 'builtin_function_or_method'> isidentifier <class 'builtin_function_or_method'> islower <class 'builtin_function_or_method'> isnumeric <class 'builtin_function_or_method'> isprintable <class 'builtin_function_or_method'> isspace <class 'builtin_function_or_method'> istitle <class 'builtin_function_or_method'> isupper <class 'builtin_function_or_method'> join <class 'builtin_function_or_method'> ljust <class 'builtin_function_or_method'> lower <class 'builtin_function_or_method'> lstrip <class 'builtin_function_or_method'> maketrans <class 'builtin_function_or_method'> partition <class 'builtin_function_or_method'> replace <class 'builtin_function_or_method'> rfind <class 'builtin_function_or_method'> rindex <class 'builtin_function_or_method'> rjust <class 'builtin_function_or_method'> rpartition <class 'builtin_function_or_method'> rsplit <class 'builtin_function_or_method'> rstrip <class 'builtin_function_or_method'> split <class 'builtin_function_or_method'> splitlines <class 'builtin_function_or_method'> startswith <class 'builtin_function_or_method'> strip <class 'builtin_function_or_method'> swapcase <class 'builtin_function_or_method'> title <class 'builtin_function_or_method'> translate <class 'builtin_function_or_method'> upper <class 'builtin_function_or_method'> zfill <class 'builtin_function_or_method'>
Polymorphism for strings¶
- $ == $ (quality) $ \rightarrow $ True/False
- $ + $ (addition) $ \rightarrow $ concatenation
- $ - $ (subtraction) undefined
- $ * $ (multiplication) $ \rightarrow $ repetition (int)
- $ / $ (devision) undefined
- $ < > \le \ge $ (comparison ) $ \rightarrow $ lexicographical comparison based on ASCII codes
In [11]:
s1 = "Economics "
s2 = "Econometrics "
s1 + s2
# s1+2
# s1+str(2)
# (s1+s2)*2
# (s1+s2)*2 == s1*2 + s2*2
Out[11]:
'Economics Econometrics '
In [12]:
x = [4,5,'hello'] # List
obj_explore(x,'public')
[4, 5, 'hello'] ------------------------------------------------------------ Object report on object = [4, 5, 'hello'] Objec class : <class 'list'> Parent classes : <class 'object'> Occupied memory : 96 bytes PUBLIC PROPERTIES PUBLIC METHODS append <class 'builtin_function_or_method'> clear <class 'builtin_function_or_method'> copy <class 'builtin_function_or_method'> count <class 'builtin_function_or_method'> extend <class 'builtin_function_or_method'> index <class 'builtin_function_or_method'> insert <class 'builtin_function_or_method'> pop <class 'builtin_function_or_method'> remove <class 'builtin_function_or_method'> reverse <class 'builtin_function_or_method'> sort <class 'builtin_function_or_method'>
In [13]:
x = (4,5,'hello') # Tuple => immutable
obj_explore(x,'public')
(4, 5, 'hello') ------------------------------------------------------------ Object report on object = (4, 5, 'hello') Objec class : <class 'tuple'> Parent classes : <class 'object'> Occupied memory : 80 bytes PUBLIC PROPERTIES PUBLIC METHODS count <class 'builtin_function_or_method'> index <class 'builtin_function_or_method'>
In [14]:
x = {"key": "value","another_key": 574} # Dictionary
obj_explore(x)
{'key': 'value', 'another_key': 574}
------------------------------------------------------------
Object report on object = {'key': 'value', 'another_key': 574}
Objec class : <class 'dict'>
Parent classes : <class 'object'>
Occupied memory : 248 bytes
PUBLIC PROPERTIES
PRIVATE PROPERTIES
__doc__ = 'dict() -> new empty dictionary' <class 'str'>
__hash__ = None <class 'NoneType'>
PUBLIC METHODS
clear <class 'builtin_function_or_method'>
copy <class 'builtin_function_or_method'>
fromkeys <class 'builtin_function_or_method'>
get <class 'builtin_function_or_method'>
items <class 'builtin_function_or_method'>
keys <class 'builtin_function_or_method'>
pop <class 'builtin_function_or_method'>
popitem <class 'builtin_function_or_method'>
setdefault <class 'builtin_function_or_method'>
update <class 'builtin_function_or_method'>
values <class 'builtin_function_or_method'>
PRIVATE METHODS
__class__ <class 'type'>
__contains__ <class 'builtin_function_or_method'>
__delattr__ <class 'method-wrapper'>
__delitem__ <class 'method-wrapper'>
__dir__ <class 'builtin_function_or_method'>
__eq__ <class 'method-wrapper'>
__format__ <class 'builtin_function_or_method'>
__ge__ <class 'method-wrapper'>
__getattribute__ <class 'method-wrapper'>
__getitem__ <class 'builtin_function_or_method'>
__gt__ <class 'method-wrapper'>
__init__ <class 'method-wrapper'>
__init_subclass__ <class 'builtin_function_or_method'>
__iter__ <class 'method-wrapper'>
__le__ <class 'method-wrapper'>
__len__ <class 'method-wrapper'>
__lt__ <class 'method-wrapper'>
__ne__ <class 'method-wrapper'>
__new__ <class 'builtin_function_or_method'>
__reduce__ <class 'builtin_function_or_method'>
__reduce_ex__ <class 'builtin_function_or_method'>
__repr__ <class 'method-wrapper'>
__setattr__ <class 'method-wrapper'>
__setitem__ <class 'method-wrapper'>
__sizeof__ <class 'builtin_function_or_method'>
__str__ <class 'method-wrapper'>
__subclasshook__ <class 'builtin_function_or_method'>
Inheritance for booleans¶
By-default copy of all methods and properties
In [15]:
x=True
cl=type(x)
print("Own class : %s" % cl) # list of parent classes
print("Parent class: %s" % cl.__bases__) # list of parent classes
Own class : <class 'bool'> Parent class: <class 'int'>
In [16]:
f = lambda x: x # identity lambda-function
obj_explore(f,'methods')
<function <lambda> at 0x7f85c8281440> ------------------------------------------------------------ Object report on object = <function <lambda> at 0x7f85c8281440> Objec class : <class 'function'> Parent classes : <class 'object'> Occupied memory : 144 bytes PUBLIC METHODS PRIVATE METHODS __call__ <class 'method-wrapper'> __class__ <class 'type'> __delattr__ <class 'method-wrapper'> __dir__ <class 'builtin_function_or_method'> __eq__ <class 'method-wrapper'> __format__ <class 'builtin_function_or_method'> __ge__ <class 'method-wrapper'> __get__ <class 'method-wrapper'> __getattribute__ <class 'method-wrapper'> __gt__ <class 'method-wrapper'> __hash__ <class 'method-wrapper'> __init__ <class 'method-wrapper'> __init_subclass__ <class 'builtin_function_or_method'> __le__ <class 'method-wrapper'> __lt__ <class 'method-wrapper'> __ne__ <class 'method-wrapper'> __new__ <class 'builtin_function_or_method'> __reduce__ <class 'builtin_function_or_method'> __reduce_ex__ <class 'builtin_function_or_method'> __repr__ <class 'method-wrapper'> __setattr__ <class 'method-wrapper'> __sizeof__ <class 'builtin_function_or_method'> __str__ <class 'method-wrapper'> __subclasshook__ <class 'builtin_function_or_method'>
Everything in Python is an object!¶
- Variables of all types
- Functions, both custom and inbuilt
- Imported modules
- Input and output (files)
- etc.
How to write classes¶
- When do I need a class/object?
- collection of model parameters
- repeatedly used complex things
- note: collection of functions is module = .py file with defs
- Syntax
List of standard methods: https://docs.python.org/3/reference/datamodel.html#special-method-names
In [17]:
class Firm:
'''Stores the parameters of the production function f(k) = Ak^α,
implements the function.
'''
def __init__(self, α=0.5, A=2.0): # initializer
self.α = α # Public properties
self.A = A
def production(self, val): # public method
return self.A * val**self.α
In [18]:
firm1 = Firm()
obj_explore(firm1)
firm2 = Firm(A=3.0)
firm3 = Firm(A=4.0)
# firm1.α
k = 10.0
print(firm1.production(k))
print(firm2.production(k))
print(firm3.production(k))
<__main__.Firm object at 0x7f85e8a34850>
------------------------------------------------------------
Object report on object = <__main__.Firm object at 0x7f85e8a34850>
Objec class : <class '__main__.Firm'>
Parent classes : <class 'object'>
Occupied memory : 64 bytes
PUBLIC PROPERTIES
A = 2.0 <class 'float'>
α = 0.5 <class 'float'>
PRIVATE PROPERTIES
__dict__ = {'α': 0.5, 'A': 2.0} <class 'dict'>
__doc__ = 'Stores the parameters of the p' <class 'str'>
__module__ = '__main__' <class 'str'>
__weakref__ = None <class 'NoneType'>
PUBLIC METHODS
production <class 'method'>
PRIVATE METHODS
__class__ <class 'type'>
__delattr__ <class 'method-wrapper'>
__dir__ <class 'builtin_function_or_method'>
__eq__ <class 'method-wrapper'>
__format__ <class 'builtin_function_or_method'>
__ge__ <class 'method-wrapper'>
__getattribute__ <class 'method-wrapper'>
__gt__ <class 'method-wrapper'>
__hash__ <class 'method-wrapper'>
__init__ <class 'method'>
__init_subclass__ <class 'builtin_function_or_method'>
__le__ <class 'method-wrapper'>
__lt__ <class 'method-wrapper'>
__ne__ <class 'method-wrapper'>
__new__ <class 'builtin_function_or_method'>
__reduce__ <class 'builtin_function_or_method'>
__reduce_ex__ <class 'builtin_function_or_method'>
__repr__ <class 'method-wrapper'>
__setattr__ <class 'method-wrapper'>
__sizeof__ <class 'builtin_function_or_method'>
__str__ <class 'method-wrapper'>
__subclasshook__ <class 'builtin_function_or_method'>
6.324555320336759
9.486832980505138
12.649110640673518
In [19]:
class Polynomial():
''' Class to implement polynomial objects and binary operations on polynomialss
'''
def __init__(self, coeffs=[0,]): # Initialization
# Public properties
self.degree = len(coeffs) - 1
self.rep = self.str(coeffs)
self.coefficients = coeffs
def __repr__(self):
# Screen reprentation
return self.rep
def str(self, coeffs):
# Create list of nonzero terms
terms = [str(coeffs[k]) + 'x^' + str(k) for k in range(0, self.degree + 1) if coeffs[k] != 0]
# If zero polynomial, return 0
if len(terms) == 0:
return str(0)
# Replace 0 and 1 powers
if coeffs[0]!=0:
terms[0] = str(coeffs[0])
if len(coeffs)>1 and coeffs[1]!=0:
terms[1] = str(coeffs[1]) + 'x'
# Finally, concatenate terms using +
return ' + '.join(terms)
def __add__(self, other):
'''Overloads the + operator.'''
d = max(self.degree, other.degree) + 1 # max length of polynomials' coeff lists
self_temp = self.coefficients + [0]*(d-self.degree-1) # pad coeffs lists with 0s until equal length
other_temp = other.coefficients + [0]*(d-other.degree-1)
new_temp = [self_temp[i] + other_temp[i] for i in range(d)] # sum coeffs lists elementwise
return Polynomial(new_temp) # return NEW polynomial
def __mul__(self, other):
'''Overloads the * operator.'''
n = self.degree + other.degree # degree of the product
prod_coeffs = [0]*(n+1) # initalize coefficient list of product
for i in range(0, self.degree + 1): # compute product
for j in range(0, other.degree + 1):
prod_coeffs[i+j] += self.coefficients[i] * other.coefficients[j]
return Polynomial(prod_coeffs) # return NEW polynomial
def __call__(self, val):
'''Evaluates the polynomial at x = val.'''
res=self.coefficients[0]
x=val
for i in range(self.degree): # using the loop avoid power calculation!
res += x*self.coefficients[i+1]
x*=val
return res
In [20]:
p=Polynomial([1,2,3])
obj_explore(p,'public')
1 + 2x + 3x^2 ------------------------------------------------------------ Object report on object = 1 + 2x + 3x^2 Objec class : <class '__main__.Polynomial'> Parent classes : <class 'object'> Occupied memory : 64 bytes PUBLIC PROPERTIES coefficients = [1, 2, 3] <class 'list'> degree = 2 <class 'int'> rep = '1 + 2x + 3x^2' <class 'str'> PUBLIC METHODS str <class 'method'>
In [21]:
p1=Polynomial([1,2,5,0,0,4])
print('p1(x) = %r' % p1)
print('p1(5) = %r' % p1(5))
p2=Polynomial([10,0,3,7])
print('p2 = %r' % p2)
print('p2(2) = %r' % p2(2))
p3=p1+p2
print('Sum %r' % p3)
p3=p1*p2
print('Product %r' % p3)
p1(x) = 1 + 2x + 5x^2 + 4x^5 p1(5) = 12636 p2 = 10 + 3x^2 + 7x^3 p2(2) = 78 Sum 11 + 2x + 8x^2 + 7x^3 + 4x^5 Product 10 + 20x + 53x^2 + 13x^3 + 29x^4 + 75x^5 + 12x^7 + 28x^8
Further learning resources¶
- Simple explanation to main concepts of OOP https://www.youtube.com/watch?v=pTB0EiLXUC8
- List of standard methods of Python class https://docs.python.org/3/reference/datamodel.html#special-method-names