- Class is a blueprint/template of an object.
- Each class has its own attributes (its states) and methods (its behaviors).
- Object is a bundle of related attributes and methods.
- Instance is a single and unique unit of a class.
- Many instances may have the same class. They have attributes and methods defined in the class.
Syntactic sugar is syntax within a programming language that is designed to make things easier to read or to express. For example, we use
arr[i,j] but behind the scene, it's get_element(arr, vector(i,j)).1class MyClass()
2 def method(arg):
3 print(arg)
4
5my_object = MyClass()
6my_object.method('foo')
7# TypeError: method() takes exactly 1 positional argument (2 given)my_object.method('foo') means MyClass.method(my_object, 'foo'). That's why we need self or a decorator1class MyClass():
2 def method(self, arg):
3 print(arg)1# DON'T NEED `self`
2class MyClass():
3 @staticmethod
4 def method(self, arg):
5 print(arg)1# CHECK THERE IS AN ATTRIBUTE
2getattr(MyClass, 'report', None)
3# if there is a class, it return this class' detail
4# if not, return None1def props(cls):
2 return [i for i in cls.__dict__.keys() if i[:1] != '_']
3
4# access these attributes
5properties = props(MyClass)
6for att in properties:
7 print(getattr(MyClass, att))1# Get dictionaries of all attributes & their values
2MyClass.__dict__Suppose that we have a folders/files structure like below,
1# ORIGINAL STRUCTURE
2popai/
3 processings/
4 a.py # contains class ABC
5 test/
6 b.py
7 lib/
8 c.py # contains class XYZ1# UPDATED STRUCTURE
2popai/
3 __init__.py
4 processings/
5 __init__.py
6 a.py # contains class ABC
7 test/
8 __init__.py
9 b.py
10 lib/
11 c.py # contains class XYZWe want import both classes
ABC and XYZ1# b.py
2from popai.processings.a import ABC1# a.py
2from popai.lib.c import XYZJust add
__init__.py like in the right box above.Some errors may occur,
1ValueError: attempted relative import beyond top-level package1# FATHER
2class father_class():
3 def __init__(self):
4 self.abc = 11# SON
2class son_class(father_class):
3 def __init__(self):
4 # son_class has attribute `abc`
5 super().__init__()
6 self.xyz = 2If you want son takes all parameters of father and use additional parameters,
1class Shape:
2 def __init__(self, shapename):
3 self.shapename = shapename
4
5class ColoredShape(Shape):
6 def __init__(self, color, **kwargs):
7 super().__init__(**kwargs)
8 self.color = color
9
10cs = ColoredShape(color='red', shapename='circle')1from abc import ABC, abstractmethod1# FATHER CLASS
2class BaseModel(ABC):
3 def __init__(self):
4 pass
5
6 # child class must have
7 @abstractmethod
8 def fit(self, X):
9 pass
10
11 # child class must have
12 @abstractmethod
13 def predit(self, X):
14 pass
15
16 # children class don't need to have
17 # but they can call
18 def fit_predict(self, X):
19 pass1# CHILD CLASS
2class LinearModel(BaseModel)
3 def __init__(self):
4 pass
5
6 # must-have
7 def fit(self, X):
8 pass
9
10 # must-have
11 def predict(self, X):
12 pass
13
14 # this call can use .fix_predict()
15 # from its father!
16