Merge pull request #1 from levops-cloud/master

pull req

Author: costyaDev

OOP/dog.py

@@ -16,6 +16,9 @@ def __init__(self, name, age):
         self.name = name
         self.age = age
 
+    def speak(self, sound):
+        return f"{self.name} says {sound}"
+
 
 # Instantiate the Dog object
 philo = Dog("Philo", 5)
@@ -27,3 +30,6 @@ def __init__(self, name, age):
 # Is Philo a mammal?
 if philo.species == "mammal":
     print(f"{philo.name} is a {philo.species}!")
+
+print(philo.speak("Woof Woof"))
+print(mikey.speak("Waf Waf"))

OOP/dog_inheritance.py

@@ -0,0 +1,25 @@
+# Using OOP in Python, we can restrict access to methods and variables.
+# This prevents data from direct modification which is called encapsulation.
+# In Python, we denote private attributes using underscore as the prefix i.e single _ or double __.
+
+class Computer:
+
+    def __init__(self):
+        self.__maxprice = 900
+
+    def sell(self):
+        print("Selling Price: {}".format(self.__maxprice))
+
+    def setMaxPrice(self, price):
+        self.__maxprice = price
+
+c = Computer()
+c.sell()
+
+# change the price
+c.__maxprice = 1000
+c.sell()
+
+# using setter function
+c.setMaxPrice(1000)
+c.sell()

OOP/dog_sol.py

@@ -0,0 +1,30 @@
+# parent class
+class Bird:
+    
+    def __init__(self):
+        print("Bird is ready")
+
+    def whoisThis(self):
+        print("Bird")
+
+    def swim(self):
+        print("Swim faster")
+
+# child class
+class Penguin(Bird):
+
+    def __init__(self):
+        # call super() function
+        super().__init__()
+        print("Penguin is ready")
+
+    def whoisThis(self):
+        print("Penguin")
+
+    def run(self):
+        print("Run faster")
+
+peggy = Penguin()
+peggy.whoisThis()
+peggy.swim()
+peggy.run()

OOP/encapsulation.py

@@ -0,0 +1,27 @@
+class Parrot:
+
+    def fly(self):
+        print("Parrot can fly")
+    
+    def swim(self):
+        print("Parrot can't swim")
+
+class Penguin:
+
+    def fly(self):
+        print("Penguin can't fly")
+    
+    def swim(self):
+        print("Penguin can swim")
+
+# common interface
+def flying_test(bird):
+    bird.fly()
+
+#instantiate objects
+blu = Parrot()
+peggy = Penguin()
+
+# passing the object
+flying_test(blu)
+flying_test(peggy)

OOP/inheritance.py

@@ -0,0 +1,16 @@
+def print_msg(msg):
+    # This is the outer enclosing function
+
+    def printer():
+        # This is the nested function
+        print(msg)
+
+    return printer  # returns the nested function
+
+
+# Now let's try calling this function.
+# Output: Hello
+another = print_msg("Hello")
+another()
+
+

OOP/polymorphism.py

@@ -0,0 +1,20 @@
+def make_multiplier_of(n):
+    def multiplier(x):
+        return x * n
+    return multiplier
+
+
+# Multiplier of 3
+times3 = make_multiplier_of(3)
+
+# Multiplier of 5
+times5 = make_multiplier_of(5)
+
+# Output: 27
+print(times3(9))
+
+# Output: 15
+print(times5(3))
+
+# Output: 30
+print(times5(times3(2)))

closures/closure.func.py

@@ -0,0 +1,14 @@
+def print_msg(msg):
+    # This is the outer enclosing function
+
+    def printer():
+        # This is the nested function
+        print(msg)
+
+    printer()
+
+# We execute the function
+# Output: Hello
+print_msg("Hello")
+
+

closures/closure.insted.class.py

@@ -0,0 +1,39 @@
+# This is not a valid Python module - Don't run it.
+
+# ONE DECORATOR
+def func(arg1, arg2, ...):
+    pass
+
+func = decorator(func)
+
+# is equivalent to the following:
+
+@decorator
+def func(arg1, arg2, ...):
+    pass
+
+
+# TWO DECORATORS
+def func(arg1, arg2, ...):
+    pass
+
+func = deco1(deco2(func))
+
+# is equivalent to the following:
+
+@deco1
+@deco2
+def func(arg1, arg2, ...):
+    pass
+
+# DECORATOR WITH ARGUMENTS
+def func(arg1, arg2, ...):
+    pass
+
+func = decoarg(arg_a, arg_b)(func)
+
+# is equivalent to the following:
+
+@decoarg(arg_a, arg_b)
+def func(arg1, arg2, ...):
+    pass