chore(classes) add classes examples ⭐

ahsimon · ahsimon · commit a62dd8f3190a · 2022-12-22T20:38:17.000-06:00
diff --git a/notes b/notes
@@ -0,0 +1,9 @@
+
+A local scope refers to the local objects available in the current function.
+A global scope refers to the objects available throughout the code execution since their inception.
+
+
+A local scope refers to the local objects available in the current function.
+A global scope refers to the objects available throughout the code execution since their inception.
+
+The key difference between the two is that while lists are mutable, tuples on the other hand are immutable objects. This means that lists can be modified, appended or sliced on the go but tuples remain constant and cannot be modified in any manner.
diff --git a/training/animals_lambdas.py b/training/animals_lambdas.py
@@ -0,0 +1,7 @@
+animals = ['dog', 'cat', 'parrot', 'rabbit']
+uppered_animals = list(map(lambda animal: animal.upper(), animals))
+print(uppered_animals)
+
+sequences = [10,2,8,7,5,4,3,11,0, 1]
+filtered_result = filter (lambda x: x > 4, sequences) 
+print(list(filtered_result))
diff --git a/training/another_lambda.py b/training/another_lambda.py
@@ -0,0 +1,16 @@
+is_even_list = [lambda arg=x: arg * 10 for x in range(1, 500)]
+
+# iterate on each lambda function
+# and invoke the function to get the calculated value
+for item in is_even_list:
+	print(item())
+
+
+
+# Python 3 code to people above 18 yrs
+ages = [13, 90, 17, 59, 21, 60, 5]
+
+adults = list(filter(lambda age: age > 18, ages))
+
+print(adults)
+
diff --git a/training/command.py b/training/command.py
@@ -0,0 +1,4 @@
+import sys
+
+print ('Number of arguments:', len(sys.argv), 'arguments.')
+print ('Argument List:', str(sys.argv)) 
diff --git a/training/formal_interface.py b/training/formal_interface.py
@@ -0,0 +1,8 @@
+import abc
+class Myinterface( abc.ABC ) :
+    @abc.abstractclassmethod
+    def disp():
+        pass
+class Myclass( Myinterface ) :
+    pass
+o1 = Myclass( )
diff --git a/training/interfaces_notes.py b/training/interfaces_notes.py
@@ -0,0 +1,22 @@
+#In python classes contains no abstract methods
+# Informal Interfaces
+# python informal interface is also a class that defines methods that can be overridden but without force enforcement. An informal interface also called Protocols
+
+class Fruits :
+    def __init__( self, ele) :
+        self.__ele = ele
+    def __contains__( self, ele) :
+        return ele in self.__ele
+    def __len__( self ):
+        return len( self.__ele)
+Fruits_list = Fruits([ "Apple", "Banana", "Orange" ])
+print(len(Fruits_list))
+print("Apple" in Fruits_list)
+print("Mango" in Fruits_list)
+print("Orange" not in Fruits_list)
+
+# As in the above example code, class Fruits implement the _len_, and _contains_ methods, so on the instance of the Fruits class,
+#  we can directly use the len function to get the size and can check the membership by using the in operator. As in the above code, 
+# the _iter_ method (iterable protocol) is not implemented, so we would not iterate over the instance of the Fruits.
+#  Therefore an informal interface cannot be enforced formally.
+
diff --git a/training/lambda.py b/training/lambda.py
@@ -0,0 +1,16 @@
+x = lambda a, b, c : a + b + c
+#print(x(5, 6, 2))
+
+x = lambda a, b, c : a + b + c
+#print(x(5, 6, 2))
+
+
+
+def cube(y):
+	return y*y*y
+lambda_cube = lambda y: y*y*y
+# using function defined
+# using def keyword
+print("Using function defined with `def` keyword, cube:", cube(5))
+# using the lambda function
+print("Using lambda function, cube:", lambda_cube(5))
diff --git a/training/lambda_dif.py b/training/lambda_dif.py
@@ -0,0 +1,15 @@
+
+# #Lambdas, also known as anonymous functions, are small, restricted functions which do not need a name (i.e., an identifier).
+# Every lambda function in Python has 3 essential parts:
+# The lambda keyword.
+# The parameters (or bound variables), and
+# The function body.
+# The syntax for writing a lambda is: lambda parameter: expression
+#Syntax:
+
+lambda x : x + x
+#Syntax:
+
+def sum(x) : return x + x 
+
+
diff --git a/training/lambda_if.py b/training/lambda_if.py
@@ -0,0 +1,4 @@
+# Example of lambda function using if-else
+Max = lambda a, b : a if(a > b) else b
+
+print(Max(1, 2))
diff --git a/training/lambda_list.py b/training/lambda_list.py
@@ -0,0 +1,4 @@
+li = [5, 7, 22, 97, 54, 62, 77, 23, 73, 61]
+
+final_list = list(filter(lambda x: (x % 2 != 0), li))
+print(final_list)
diff --git a/training/lambda_python3.py b/training/lambda_python3.py
@@ -0,0 +1,6 @@
+# Python 3 code to people above 18 yrs
+ages = [13, 90, 17, 59, 21, 60, 5]
+
+adults = list(filter(lambda age: age > 18, ages))
+
+print(adults)
diff --git a/training/poly.py b/training/poly.py
@@ -0,0 +1,7 @@
+def add(x, y, z = 0):
+	return x + y+z
+
+
+
+print(add(2, 3))
+print(add(2, 3, 4))
diff --git a/training/polymorphism.py b/training/polymorphism.py
@@ -0,0 +1,11 @@
+#The word polymorphism means having many forms. In programming, polymorphism means the same function name (but different signatures) being used for different types. The key difference is the data types and number of arguments used in function.
+
+
+# Python program to demonstrate in-built poly-
+# morphic functions
+
+# len() being used for a string
+print(len("Angelica "))
+
+# len() being used for a list
+print(len([10, 20, 30]))
diff --git a/training/vehicles.py b/training/vehicles.py
@@ -0,0 +1,21 @@
+import abc
+class FourWheelVehicle (abc.ABC):
+    @abc.abstractmethod
+    def SpeedUp( self ):
+        pass
+class Car(FourWheelVehicle) :
+    def SpeedUp(self):
+        print(" Running! ")
+class TwoWheelVehicle (abc.ABC) :
+    @abc.abstractmethod
+    def SpeedUp(self):
+        pass
+class Bike(TwoWheelVehicle) :
+    def SpeedUp(self) :
+        print(" Running!.. ")
+a = Bike ()
+s = Car()
+print( isinstance(s, FourWheelVehicle))
+print( isinstance(s, TwoWheelVehicle))
+print( isinstance(a, FourWheelVehicle))
+print( isinstance(a, TwoWheelVehicle))
