OOP finished

Basic/hello-world.py

@@ -1,57 +1,13 @@
-import unittest
+def j(n):
-import random
+    if n == 1:
+        return 1
+    
+    if n % 2 == 0 :
+        return 2 * j(n/2) - 1
+    else:
+        return 2 * j((n-1)/2) + 1
+    
 
-globals = None
+for i in range(1,33):
-report = unittest.Report()
+    print(f'{i} : {j(i)}')
-class ODD_EVEN_TEST_001(unittest.SystemTestCase):
 
-    @classmethod
-    def setUpClass(inst):
-        """ Add the initial configuration if any """
-
-    @classmethod
-    def tearDownClass(inst):
-        """ Add the teardown configuration if any """
-
-    # """Add the definitions for tests defined in suite here"""
-    # def dummy_assert(self):
-    #     report.normal("This is normal print")
-    #     report.error("This is errored print")
-    #     report.notification("This is notify print")
-    #     assrt=unittest.Assert(self)
-    #     assrt.isEquals("1", "2", "1 Equals 2")
-    #     assrt.isEquals("1", "1", "1 Equals 2")
-
-    def generate_number(self,seed_value):
-        random.seed(seed_value)
-
-        gen_value = random.randrange(1,7)
-
-        return gen_value
-
-
-    def check_testcase(self):
-
-        for x in range(1,26):
-            generated_value = self.generate_number(x)
-
-            report.normal(f'For test case {x}:')
-            assrt = unittest.Assert(self)
-
-            if( generated_value == 3):
-                assrt.isEquals("1",str(generated_value), "You win!!!")
-            elif( generated_value == 6):
-                assrt.isEquals("6",str(generated_value), "You win!!!")
-            else:
-                assrt.isEquals("6",str(generated_value), "You lose!!!")
-
-
-def suite():
-    suite = unittest.TestSuite()
-    """Add your tests into the suite here"""
-    suite.addTest(ODD_EVEN_TEST_001("check_testcase"))
-    return suite
-
-def main():
-    runner = unittest.TextTestRunner()
-    return runner.run(suite())

OOP/MRO.py

@@ -0,0 +1,32 @@
+#MRO - Method Resolution order
+
+class A:
+    num = 10
+
+class B(A):
+    pass
+
+class C(A):
+    num = 1
+
+class D(B,C):
+    pass
+
+print(D.mro())
+
+# [<class '__main__.D'>, 
+#  <class '__main__.B'>, 
+#  <class '__main__.C'>, 
+#  <class '__main__.A'>, 
+#  <class 'object'>]
+
+# The order of this determined using DFS.
+
+#     A
+#    / \
+#   /   \
+#  B     C
+#   \   /
+#    \ /
+#     D
+

OOP/SuperList.py

@@ -0,0 +1,18 @@
+#Implementing List:
+
+class SuperList(list):
+    def __len__(self):
+        return 1000
+
+
+super_list1 = SuperList()
+
+print(len(super_list1))
+
+super_list1.append(5)
+
+print(super_list1[0])
+
+print(issubclass(SuperList, list))
+
+print(issubclass(list, object))

OOP/game.py

@@ -0,0 +1,37 @@
+class User(object):
+    def __init__(self, email):
+        self.email = email
+        print('init complete')
+
+    def sign_in(self):
+        print('logged in')
+
+class Wizard(User):
+    def __init__(self, name, power):
+        self.name = name
+        self.power = power
+
+    def attack(self):
+        print(f'attacking with power of {self.power}')
+
+class Archer(User):
+    def __init__(self, name, arrows):
+        self.name = name
+        self.arrows = arrows
+
+    def check_arrows(self):
+        print(f'{self.arrows} remaining')
+
+    def run(self):
+        print('ran really fast')
+
+class HybridBorg(Wizard, Archer):
+    def __init__(self, name, power, arrows):
+        Archer.__init__(self, name, arrows)
+        Wizard.__init__(self, name, power)
+
+hb1 = HybridBorg('borgie', 50, 100)
+
+print(hb1.check_arrows())
+print(hb1.attack())
+print(hb1.sign_in())

OOP/wiki.txt

@@ -109,4 +109,49 @@
     It specify what are the functions and variable the instance of
     a class(object) has access to.
 
--> Dunder methods:
+-> Dunder methods:
+
+    Dunder methods allow us to modify and implement built-in function
+    of objects. This allow us to implement our own custom logic for
+    built-in function which work for objects. The modification only
+    works for that same object only and if we apply it on different
+    object then it would behave as usual(or as implemented for other
+    object)
+
+
+    for ex:
+
+        class Toy():
+            def __init__(self, color, age):
+                self.color = color
+                self.age = age
+                self.my_dict = {
+                    'name' : 'Yoyo',
+                    'has_pets' : False
+                }
+
+            def __str__(self):
+                return f'{self.color}'
+
+            def __len__(self):
+                return 5
+
+            def __call__(self):
+                return ('yes??')
+
+            def __getitem__(self, i):
+                return self.my_dict[i]
+
+
+        action_figure = Toy('red',0)
+        print(action_figure.__str__())
+        print(str(action_figure))
+        print(len(action_figure))
+        print(action_figure())
+        print(action_figure['name'])
+
+-> MRO (Method Resolution order):
+
+    MRO allow us to determine the order in which 
+    the Inheritance need to be processed. This 
+    order is determined using Depth first search.