Notes:

• The __init__ method is a special method that will be called automatically when an instance of the class is created.
• The self parameter is a reference to the instance.
• The self parameter is added automatically when calling a method of the class.
• Variables defined using the self keyword will be accessible to all methods in the class and to all instances of the class.

Defining a Class: class Math: def __init__(self, i, j): self.i = i self.j = j def seti(self, i): self.i = i def setj(self, i): self.i = i def add(self): return self.i + self.j def multiply(self): return self.i * self.j
Creating an instance of a class: math1 = Math(2, 3)
Calling methods of an instance: print(math1.add()) # ==> 5 print(math1.multiply()) # ==> 6
Accessing attributes of an instance: print(math1.i) # ==> 2 print(math1.j) # ==> 3
Modifying attributes of an instance: math1.i = 3 math1.setj(7) print(math1.add()) # ==> 10 print(math1.multiply()) # ==> 21
Inheritance: class Operations(Math): def __init__(self, i, j): super().__init__(i, j) self.opename = 'undefined' def setopenmae(self, opename): self.opename = opename def calculate(self, opename='add'): if opename == 'add': return super().add() elif opename == 'multiply': return super().multiply() else: return 0
Creating an instance of the subclass: ope = Operations(4, 9)
Accessing attributes of an instance of a subclass: print(ope.i) # ==> 4 print(ope.j) # ==> 9 print(ope.opename) # ==> undefined
Calling methods of an instance of a subclass: print(ope.calculate()) # ==> 13 print(ope.calculate('multiply')) # ==> 36
Overriding methods from the parent class: class SpeOperations(Math): def __init__(self, i, j): super().__init__(i, j) self.opename = 'undefined' def multiply(self): return self.i * self.j * 10
Calling override methods of an instance of a subclass: sope = SpeOperations(4, 6) print(sope.multiply()) # ==> 240
Storing classes in modules: Create a file file1.py that contains the definition of two classes: #file1.py class MyClassA(): def __init__(self): self.name = 'My Class A' class MyClassB(): def __init__(self): self.name = 'My Class B'
Importing modules:
Create a file file2.py that imports the module file1 (file1.py): #file2.py import file1 # all classes defined in the module will be accessible using the prefix file1 myclassa = file1.MyClassA() # referencing the class MyClassA using the name of the module name as a prefix myclassb = file1.MyClassB() print(myclassa.name) # ==> My Class A print(myclassb.name) # ==> My Class B
Importing specific classes defined in a module:
Create a file file3.py that imports specific classes defined in the module file1 (file1.py): #file3.py from file1 import MyClassA, MyClassB # importing the classes MyClassA and MyClassB from the module file1 myclassa = MyClassA() # referencing directly the class MyClassA without specifying the module name myclassb = MyClassB() print(myclassa.name) # ==> My Class A print(myclassb.name) # ==> My Class B
Importing all classes in a module:
Create a file file4.py that imports all classes defined in the module file1 (file1.py): #file4.py from file1 import * # importing all the classes from the module file1 myclassa = MyClassA() # referencing directly the class MyClassA without specifying the module name myclassb = MyClassB() print(myclassa.name) # ==> My Class A print(myclassb.name) # ==> My Class B
Using the keyword as to define an alias for a module:
Create a file file5.py that imports the module file1 (file1.py) and give it an alias f1: #file5.py import file1 as f1 # defining the alias f1 for the module file1 myclassa = f1.MyClassA() # referencing the class MyClassA using the alias of the module as a prefix myclassb = f1.MyClassB() print(myclassa.name) # ==> My Class A print(myclassb.name) # ==> My Class B
Using the keyword as to define an alias for a class:
Create a file file6.py that imports specific functions defined in the module file1 (file1.py) and give them aliases: #file6.py from file1 import MyClassA as A, MyClassB as B # defining the alias A for the class MyClassA and the alias B for the class MyClassB myclassa = A() # referencing directly the class MyClassA using its alias A myclassb = B() print(myclassa.name) # ==> My Class A print(myclassb.name) # ==> My Class B