OOP Basic added

Author: rubada

01.Python_OOP_basics/01.Classes_script/01.OOP_intro_and_concept.py

@@ -0,0 +1,47 @@
+# Object-Oriented Programming (OOP)
+# OOP is a programming languages paradigm, where classes and objects are used.
+# Objects in OOP are the same as any system components, remember the shoe shop
+# where the shop is a class (main object, system), while the salesperson, other
+# employees, the goods, etc., are all objects (components) inside the shop
+# serve the main purpose of the shoe shop, and that is selling shoes.
+# OOP has similarities to the shoe shop, where the class has a purpose and the
+# objects inside the class serve that purpose, and from the class, an object
+# can be created
+# Let's take an example, the list class:
+
+nums = [7, 5, 1, 6, 4, 3, 2]
+
+# "nums" is an object created from the list class
+
+# print(type(nums))
+
+# The list class has many methods or functions, when using these methods with
+# the list object (nums), we can modify or change the list object (nums), to
+# create the final list, which is the class's main purpose.
+nums.append(9)
+nums.sort()
+num_pop = nums.pop()
+# print(nums)
+# print(num_pop)
+
+# OOP is used to bind the objects (data and functions) work together as a
+# single unit (class), in which these objects inside the class are isolated
+# from the outside scope, and used to serve the purpose of this class.
+
+# In OOP there are six concepts, that should be taken in account:
+
+# The first two concepts are:
+# 1. Classes
+# 2. Objects
+
+# The other four concepts are called the four pillars of object-oriented
+# programming:
+# 1. Inheritance
+# 2. Polymorphism
+# 3. Encapsulation
+# 4. Abstraction
+
+# When writing classes, same as functions, your code will be:
+# 1. Clean.
+# 2. Readable.
+# 3. D.R.Y Don't Repeat Yourself.

01.Python_OOP_basics/01.Classes_script/02.Classes_and_objects.py

@@ -0,0 +1,108 @@
+# What are a class and objects?
+# 1. A class is a category of things (objects) that have some properties in
+# common and these properties differentiate it from other classes.
+# Let's take cars for example, underneath the cars there are the brands,
+# models, sizes, speed, etc., so the car is the general category or class (main
+# object) that is used to create objects related to it, such as brands, sizes,
+# number of wheels, speeds, etc., each one of them is an object that can be
+# created from this car class.
+
+# In Python classes are the blueprint or code template to create objects.
+# To define a class, use the class keyword and then choose a class name, it is
+# recommended (not compulsory) for the words in the class name to start with
+# capital letters, without using an underscore to separate the words, if more
+# than one word is used.
+# Define a class:
+class ClassName:
+    # Class attributes (class variables)
+    number = 10
+
+    # Instance (object) attributes (instance variables)
+    def __init__(self):
+        pass
+
+    # Behavior or object (instance) method
+    def method_class(self):
+        pass
+
+
+# Create an instance or object
+obj = ClassName()
+# print(obj.number)
+# print(obj.method_class())
+
+# Creating an object or class instance is done by assigning the class to a
+# variable.
+
+
+# 2. Objects, as mentioned before everything in Python is an object, and
+# objects are instances of a class, when a list is created as shown below:
+numbers = [1, 2, 3]
+
+# "numbers" is an instance or object of the list class, it is an object of the
+# class and has a location in memory.
+
+# Objects are collections of methods (behavior) and attributes (state).
+# Below are the object properties:
+
+# 1. State: It is the instance (object) attributes (instance variables), which
+# reflects the object's properties or characteristics.
+
+# For example in the Shoe Shop, the defined attributes or states:
+# Number of shoes
+# Shoe type
+# Employee name
+# Salespeople name
+# color
+# size
+# etc.
+
+# When using the above attributes to create objects, each object will have a
+# different attribute, as shown below.
+
+# Shoe type = “heels”
+# Quantity = 50
+# Salesperson name = “Tom”
+# color = "red"
+# size = "36"
+# The above attributes or states of the "heel1" object reflect the properties
+# and characteristics for this object.
+
+# If other attributes are created as shown below:
+# Shoe type = “heels”
+# Quantity = 50
+# Salesperson name = “Sam”
+# color = "red"
+# size = "39"
+
+# This is another object, although it shares some properties with "heel1"
+# object but they are the state or properties of the second object.
+
+# An important note that even the above objects share some properties and
+# their states have common representation, none of these objects shares
+# the memory location, meaning the shoe type in the first object has
+# a different memory location than the shoe type of object2, because they are
+# two different objects.
+
+# 2. Behavior: It is the object (instance) method, it is how the objects act
+# on itself or reacts to other objects, changing or using the object states or
+# attribute.
+# Thus, the behavior of an object is a way to perform actions.
+
+# In the Shoe Shop, the object "heel1" has many attributes, using these
+# attributes to:
+# Calculate Cost
+# Calculate Profit
+# Check if the shoe type is popular
+# etc.
+
+# The above operations are the behavior and actions (methods) the object does
+# on the states (attributes) to get some results.
+
+# 3. Identity: Every object should have a unique name, used to give it and
+# identify and differentiate it from other objects.
+# In the above example, "heel1" is a unique name for this object.
+
+# Note: the object's state or attributes will be defined using the init dunder
+# method which will be discussed in detail later.
+# The objects variables are called the instance attributes.

01.Python_OOP_basics/01.Classes_script/03.classes_vs_functions_creating_class.py

@@ -0,0 +1,74 @@
+# As discussed before a class is used to create an objects, this is how classes
+# are different from functions, the function is used to perform one task, for
+# example to perform numbers addition, subtraction, division, multiplication,
+# different functions should be written.
+
+# While writing one class will be sufficient to perform the above operations.
+# Let's create a simple class that does math operations.
+# How are classes defined?
+# 1. Use the class keyword then give the class its name, after the name
+# parentheses can be used or left without parentheses.
+# 4. Create the attributes.
+# 3. Create the methods needed. Methods are the behavior of an object, where
+# actions can be executed, such as lists dictionaries, etc., methods.
+# Methods can be considered functions that belong to a class, they are
+# created inside the class, and they are linked to the class or the object
+# created from it.
+# To invoke or call a method, an object should be created object, then methods
+# Can be invoked.
+# Methods may have arguments and, the self-argument is required as the
+# first argument in a method.
+
+class MathOperations:
+    # class attributes (class variables)
+    a = 4
+    b = 5
+    c = 6
+
+    # methods
+    def addition(self):
+        return self.a + self.b + self.c
+
+    def subtraction(self):
+        return self.a - self.b - self.c
+
+    def multiplication(self):
+        return self.a * self.b * self.c
+
+    def division(self):
+        return self.a / self.b
+
+
+# This is how a class is created, let's execute this class.
+# Note: the self parameter will be discussed later in this section.
+
+# To execute the class follow the below steps:
+# 1. Create an object from the class MathOperations:
+math_oper = MathOperations()
+# math_oper2 =MathOperations()
+# print(MathOperations())
+
+# 2. Use this object math_oper to get the attributes:
+x = math_oper.a
+y = math_oper.b
+z = math_oper.c
+
+# print(f"x = {x}", f"y = {y}", f"z = {z}", sep="\n")
+
+# 3. Using the object math_oper to get results or perform actions:
+add = math_oper.addition()
+sub = math_oper.subtraction()
+div = math_oper.division()
+multi = math_oper.multiplication()
+# print(f"Addition = {add}")
+# print(f"Subtraction = {sub}")
+# print(f"Division = {div}")
+# print(f"Multiplication = {multi}")
+
+# As shown above instead of writing four different functions for math
+# operations, we created one class that combines the four operations, and then
+# we created different objects to get the results, the result is clean,
+# readable and DRY code.
+# That doesn't mean that classes are better than functions, or vice versa,
+# because each one has its usage when writing the code and choosing the right
+# approach is the programmer's decision.

01.Python_OOP_basics/01.Classes_script/04.Attributes.py

@@ -0,0 +1,123 @@
+# Two types of variables can be defined inside the class:
+# 1. Class variables or attributes are the variables that are defined inside
+# the class, and outside of any class method.
+# These variables can be shared across all the created objects, they belong to
+# the class itself not to any specific instance (object).
+# As discussed before when creating objects from a class each object has its
+# own state or attributes, which are different for each object.
+# This is not true for the class variables, different objects have the same
+# class variables and can be used with these objects.
+
+class MathOperations:
+    # class attributes (class variable2s)
+    a = 4
+    b = 5
+    c = 6
+
+    # methods
+    def addition(self):
+        return self.a + self.b + self.c
+
+    # Another way of accessing the class variable is using the class name
+    # because these attributes belongs to the class itself.
+    def subtraction(self):
+        return MathOperations.a - MathOperations.b - MathOperations.c
+
+    def multiplication(self):
+        return self.a * self.b * self.c
+
+    def division(self):
+        return self.a / self.b
+
+
+# The class attributes can be called using the class itself:
+# print(MathOperations.a)
+# print(MathOperations.b)
+# print(MathOperations.c)
+
+# Creating two objects and using the class attributes give the same result.
+obj1 = MathOperations()
+# print(obj1.a)
+# print(obj1.subtraction())
+# print("")
+obj2 = MathOperations()
+# print(obj2.a)
+# print(obj2.subtraction())
+
+
+# 2. Instance variables or attributes are the objects' attributes or states,
+# and their values or states vary from object to object.
+# How can they be defined?
+# They can be defined using the __init__ constructor.
+
+class MathOperations:
+    # instance attributes or variables, __init__ constructor
+    def __init__(self, a, b, c=0):
+        self.a = a
+        self.b = b
+        self.c = c
+
+    # methods
+    def addition(self):
+        return self.a + self.b + self.c
+
+    def subtraction(self):
+        return self.a - self.b - self.c
+
+    def multiplication(self):
+        return self.a * self.b * self.c
+
+    def division(self):
+        return self.a / self.b
+
+
+# 1. Creating the first object
+math_op_obj1 = MathOperations(2, 3, 5)
+add_obj1 = math_op_obj1.addition()
+sub_obj1 = math_op_obj1.subtraction()
+div_obj1 = math_op_obj1.division()
+multi_obj1 = math_op_obj1.multiplication()
+# print("Object1")
+# print(f"Addition object1 = {add_obj1}")
+# print(f"Subtraction object1 = {sub_obj1}")
+# print(f"Division object1 = {div_obj1}")
+# print(f"Multiplication object1= {multi_obj1}")
+# print("")
+
+# 2. Creating the second object
+math_op_obj2 = MathOperations(1, 2)
+add_obj2 = math_op_obj2.addition()
+sub_obj2 = math_op_obj2.subtraction()
+div_obj2 = math_op_obj2.division()
+multi_obj2 = math_op_obj2.multiplication()
+# print("Object2")
+# print(f"Addition object1 = {add_obj2}")
+# print(f"Subtraction object1 = {sub_obj2}")
+# print(f"Division object1 = {div_obj2}")
+# print(f"Multiplication object1= {multi_obj2}")
+
+
+# Class variables and instance variables can be used together.
+# Let's consider a company that sells cars and we will create a class that
+# calculates the sales percentage for different car brands.
+
+class Sales:
+    # creating a class variable that can be shared with all objects
+    company_name = "Luxury Cars"
+
+    # Creating the instance variables, by using the __init__ constructor
+    def __init__(self, brand, total_brand_sold, total_cars_sold):
+        self.brand = brand
+        self.total_brand_sold = total_brand_sold
+        self.total_cars_sold = total_cars_sold
+
+    def sales_percentage(self):
+        sales_per = self.total_brand_sold/self.total_cars_sold * 100
+        return f"{Sales.company_name} sales percentage for \
+{self.brand} brand = {int(sales_per)}%"
+
+
+sales_car1 = Sales("Car1", 20000, 100000)
+sales_car2 = Sales("Car2", 50000, 100000)
+# print(sales_car1.sales_percentage())
+# print(sales_car2.sales_percentage())