Files Added

OOP basics, Inheritance, Polymorphism, Super Keyword, Methods Type in OOP

Author: HassanMahmoodAwan

Advance_Inhertance.py

@@ -0,0 +1,77 @@
+"""
+Inheritance: An Important Concept. It's like a Parent Child Relationship. The parent Class can be used by the Child
+class, which means attributes as well as methods can be used by child class.
+
+
+Note: Credit Goes to Geeks for Geeks
+
+Note: Learn Multilevel Inheritance and also Multiclass Inheritance.
+"""
+
+
+def inheritance_basics():
+    class Person:
+        def __init__(self, name, age):
+            self.name = name
+            self.age = age
+            self.country = 'Pakistan'
+
+        def __str__(self):
+            return 'Hello to Person Class'
+
+    class Employee(Person):
+        # Need to assign Values otherwise through Error.
+        def __init__(self):
+            Person.name = 'Hassan'
+            Person.age = '21'
+
+        @staticmethod
+        def show():
+            print('Its Employee Class')
+
+    # Objects / Instance
+    emp1 = Employee()
+    print(emp1)
+    emp1.show()
+    print(emp1.name)
+    print(emp1.country)  # Through error. Not recognize.
+
+
+# ====== Inheritance Super Keyword ======= #
+def super_keyword():
+    class Person:
+        def __init__(self, name, age):
+            self.name = name   # gives Hassan
+            self.age = age
+
+        def __str__(self):
+            return f'{self.name} {self.age} {self.role} {self.company} '
+
+        # Check if a Person is Employee or Not.
+        def is_employee(self):
+            return False
+
+    class Employee(Person):
+        def __init__(self, name, age, role):
+            self. company = 'Purelogics'
+            self.Name = name  # gives Ali
+            self. role = role
+            super().__init__('Hassan', age)
+
+
+        def show(self):
+            return f'{self.Name} {self.age} {self.role} {self.company} '
+
+        def is_employee(self):
+            return True
+
+    # Objects / Instance
+    emp1 = Employee('Ali', 22, 'Real Estate Agent')
+    print(emp1.show())
+    print(emp1)
+    print(emp1.is_employee())
+
+
+if __name__ == '__main__':
+    # inheritance_basics()
+    super_keyword()

Inhertiance.py

@@ -0,0 +1,54 @@
+"""
+Object-Oriented Programming Concepts
+
+Total 5 Concepts in terms of OOP
+    Class
+    Objects
+    Polymorphism
+    Encapsulation
+    Inheritance
+    Data Abstraction
+
+Note: Very important programming Concepts give max time to work on it.
+
+
+Inheritance: An Important Concept. It's like a Parent Child Relationship. The parent Class can be used by the Child
+class, which means attributes as well as methods can be used by child class.
+
+"""
+
+
+def inheritance():
+    # Parent Class
+    class Person:
+        def __init__(self, name, age):
+            self.name = name
+            self.age = age
+
+        # Instance Method
+        def display(self):
+            print(f'{self.name} {self.age}')
+
+    # Child Class
+    class Student(Person):
+        def __init__(self, name, age, roll_no, degree):
+            super().__init__(name, age)
+            self.roll_no = roll_no
+            self.degree = degree
+
+        # Class attribute
+        University = 'COMSATS University'
+
+        # Just return in __Str__ method, then print by Object.
+        def __str__(self):
+            return f'{self.name} {self.age} {self.roll_no} {self.degree} {self.University}'
+
+    std1 = Student('Hassan', 21, '114', 'BCS')
+
+    std1.display()
+
+    print(std1)
+
+
+if __name__ == '__main__':
+    inheritance()

Method_Types_OOP.py

@@ -0,0 +1,83 @@
+"""
+Object-Oriented Programming Concepts
+
+Total 5 Concepts in terms of OOP
+    Class
+    Objects
+    Polymorphism
+    Encapsulation
+    Inheritance
+    Data Abstraction
+
+Note: Very important programming Concepts give max time to work on it.
+
+Types of Methods in OOP:
+
+    1- Instance Methods:
+             Through which perform getter|setter operations and also can do computation in it.
+
+    2- Class Methods:
+        Used for the class variables to return them. Also, we need to declare a decorator for this type of method.
+        @classmethod
+
+    3- Static Methods:
+            Methods which return nothing's, just used to print somthing like message.
+            Note: it doesn't use self keyword as it not take attributes/properties.
+            @staticmethod
+
+    4- Special Methods:
+            Methods like __str__(), which have some specific purpose are special methods.
+                Constructor -> __init__(self) is also a special method
+
+"""
+
+
+def class_methods():
+    class Student:
+        def __init__(self, name, roll_no):
+            self.name = name
+            self.roll_no = roll_no
+            self.gpa = dict()
+
+        # class variable
+        University = 'COMSATS University'
+
+        # Class method
+        @classmethod
+        def university(cls):
+            return cls.University
+
+        # Instance variable
+        def compute_gpa(self, subject, gpa):
+            update_dict = {f'{subject}': gpa}
+            gpa = self.gpa.update(update_dict)
+
+            return gpa
+
+        # static Method
+        @staticmethod
+        def message():
+            print('This Class represents a individual Student')
+
+        # Instance Method
+        def display(self):
+            print(f'{self.name}, {self.roll_no}, {self.University}, {self.gpa}')
+
+        # __str__() Method (Preferred Way of Display)
+        def __str__(self):
+            return f'{self.name}, {self.roll_no}, {self.University}, {self.gpa}'
+
+    # Declaring Objects Here
+    std1 = Student('Hassan', 'SP20-BCS-114')
+    std1.compute_gpa('DSA', '3')
+    std1.compute_gpa('DIP', '3.3')
+
+    print(std1.university())
+    print(std1.__class__.University)
+
+    # std1.display()
+    print(std1)
+
+
+if __name__ == '__main__':
+    class_methods()

Oop_Basic.py

@@ -0,0 +1,121 @@
+"""
+Object-Oriented Programming Concepts
+
+There are two-way of writing code
+    1- Functional Programming
+    2- OOP
+
+Note: Python Build-in Functionalities are develop using OOP.
+
+Total 6 Concepts in terms of OOP
+    Class
+    Objects
+    Polymorphism
+    Encapsulation
+    Inheritance
+    Data Abstraction
+
+Note: Very important programming Concepts, give max time to work on it.
+
+Important Points:
+    1- One class have many instances called Objects.
+    2- Attributes|Property, Behavior, Methods.
+    3- Attributes define by variables and behavior by methods.
+    4- Self is used to represent an object in a method.
+    5- __Init__ is a method for defining Attribute for objects, it's like constructor.
+
+
+Note: A class is a collection of objects.
+"""
+
+
+def python_build_in():
+    a = 10
+    print(type(a))  # Shows variable 'a' of class <int>
+
+
+def basic_class_concept():
+    class Student:
+        # Class Attribute
+        university = 'COMSATS, Lahore Campus'
+
+    # Creating an Object
+    hassan = Student()
+    print(hassan.university)  # Not prefer way.
+    print(hassan.__class__.university)  # clarify more (prefer).
+
+
+def class_concept_instance_attr():
+    class Student:
+        # declaring instance Attr using Constructor
+        def __init__(self, reg_no):
+            self.reg_no = reg_no
+
+        # Instance Method
+        def display(self):
+            return self.reg_no
+
+        # Class Attribute
+        university = 'COMSATS, Lahore Campus'
+
+    # Creating an Object
+    # pass instance attribute value.
+    hassan = Student('SP20-BCS-114')
+
+    print(hassan.__class__.university)
+    # Instance Attr
+    print(hassan.reg_no)
+
+    print(hassan.display())
+    print(Student.display(hassan))  # Work Same.
+    print(type(hassan))
+
+
+def class_advance_concept():
+    class Person:
+        def __init__(self, name, age):
+            self.name = name
+            self.age = age
+
+        def compare(self, other):
+            return True if self.age == other.age else False
+
+        def update(self):
+            self.age = 22
+
+    p1 = Person('Hassan', 21)
+    p2 = Person('Hamid', 20)
+
+    print('Both are same') if p1.compare(p2) else print('Not same')
+
+    p2.update()
+    print(p1.name + "\n" + p2.name)
+    print(f"{p2.age}")
+
+
+# Variables Type in OOP (instance or (static or class)
+def variables_oop():
+    class Car:
+        def __init__(self):
+            self.Company = 'Toyota'
+            self.model = 'Corolla'
+
+        # Class variable.
+        seater = 5
+
+        # Method of display
+        def display(self):
+            print(self.Company + '\n' + self.model + '\n' + self.seater + ' ')
+            return ''
+
+    # you can change variables inside class using object.
+    car1 = Car()
+    car1.Company = 'Honda'
+    car1.model = 'BRV'
+    car1.seater = '7'
+
+    print(car1.display())
+
+
+if __name__ == '__main__':
+    variables_oop()