UNIT 3 PY.pptx - OOPS CONCEPTS IN PYTHON

Unit III OOP Concepts in Python

Object and classes , Defining classes for objects * UML Class diagram * Immutable Objects vs. Mutable Objects, Hiding data fields * Class abstraction and encapsulation * Object-Oriented Thinking , The str Class * Inheritance and Polymorphism * Super classes and Sub classes , overriding methods * Object class , Polymorphism and Dynamic Binding * The isinstance Function , Class Relationships.

Object and classes Python is an object oriented programming language. An object is simply a collection of data (variables) and methods (functions) that act on those data. Similarly, a class is a blueprint for that object. We can think of class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows etc. Based on these descriptions we build the house. House is the object.

Classes • A python class uses variables to store data fields and defines methods to perform actions. • A class is also known as template or blueprint • To create a class, use the keyword - class • Attributes or data fields are the variables that belong to a class • Attributes are always public and can be accessed using dot(.) operator

Objects • An object represents an entity in the real world that can be distinctly identified. • An object consists of: State: It is represented by the attributes of an object. ex: breed, color, age Behavior: It is represented by the methods of an object. ex: bark, sleep, eat Identity: It gives a unique name to an object. ex: Name of the dog

Defining a Class in Python Like function definitions begin with the def keyword in Python, class definitions begin with a class keyword. The first string inside the class is called docstring and has a brief description about the class. Although not mandatory. Syntax: class class_name(object): ‘’’doc string about the class ‘’’ variable declaration function definition

Example: class MyNewClass: '''This is a docstring. I have created a new class''' pass By using object we access the class variables and functions.

(OOPS)An object oriented programming involves the use of objects to create programs. An object is an entity in real world that can be distinctly identified. Example: student , button, loan ….. Etc An object’s identity is like a person’s Social Security number. Python automatically assigns each object a unique id for identifying the object at runtime.

An object’s state (also known as its properties or attributes) is represented by variables. A rectangle object has the data fields width and height, which are properties that characterize a rectangle.

Python uses methods to define an object’s behavior (also known as its actions). Recall that methods are defined as functions.

Class Template Class Name: Circle Data Fields: radius is _____ Methods: getArea(), getPerimeter(), setRadius()

Defining classes Here by using variables to store data fields and defining the methods. A class provide special method _ _ init _ _ This method known as an initializer, Initilizer can perform any action, but initializer are designed to perform initializing action. Syntax : Class classname: initializer methods

Example: class student: '''display student information''' department="CSE" def __init__(self,name,Rollno): self.name=name self.Rollno=Rollno def display(self): print(self.name) print(self.Rollno) print(student.department)

Constructing Object Once a class is defined, you can create objects from the class with a constructor. The constructor does two things: It creates an object in the memory for the class. It invokes the class’s _ _init_ _ method to initialize the object. All methods, including the initializer, have the first parameter self.

The self parameter refers to the object that invokes the method. The self parameter in the _ _init_ _ method is automatically set to reference, the object that was just created.

Example: class student: '''display student information''' department="CSE" def __init__(self,name,Rollno): self.name=name self.Rollno=Rollno def display(self): print(self.name) print(self.Rollno) print(student.department) s=student("ram",101) s.display()

UML Class Diagram: Here class template and objects standardized using UML( Unified Modeling Language)notation. It is a language independent, that is other programming languages use this same modeling and notation.

Class field denoted as: class name: dataFieldName: dataFieldType Constructors are shown as: ClassName(parameterName: parameterType) Methods are represented as: methodName(parameterName: parameterType): returnType

Student # class name Name :str Rollno: integer Data Fields Department :str . . . .etc Student (rollno = 101: integer) # Constructor Display(self, name, deparment) #Methods Findtotal(m1,m2,m3)

The method definition in the class always has the special self parameter, but don’t include it in the UML diagram, because the client does not need to know this parameter and does not use this parameter to invoke the methods.

class student: '''display student information''' department="CSE" def __init__(self,name,Rollno): self.name=name self.Rollno=Rollno def display(self): print(self.name) print(self.Rollno) print(student.department) s1=student("ram",101) s2=student(“sam",103) s1.display() s2.display()

Mutable vs Immutable Objects in Python: Whenever an object is instantiated, Pyhton assigned a unique object id. The type of the object is defined at the runtime and it can’t be changed afterwards. However, it’s state can be changed if it is a mutable object. mutable objects can change their state or contents Immutable objects can’t change their state or content.

Immutable Objects : These are of in-built types like string, tuple are immutable type in python. In simple words, an immutable object can’t be changed after it is created.

class Count: def __init__(self, count = 0): self.count = count def main(): c = Count() n = 1 m(c, n) print("count is", c.count) print("n is", n) def m(c, n): c = Count(5) n = 3 main() # Call the main function

Example: tuple1 = (0, 1, 2, 3) tuple1[0] = 4 print(tuple1) Error : Traceback (most recent call last): File "e0eaddff843a8695575daec34506f126.py", line 3, in tuple1[0]=4 TypeError: 'tuple' object does not support item assignment

Mutable Objects : These are of type list, dict, set . Custom classes are generally mutable. Example: A=[10,20,40] A[0]=100 Print(A) Output: [100,20,40]

Example: class Count: def __init__(self, count = 0): self.count = count def main(): c = Count() times = 0 for i in range(100): increment(c, times) print("count is", c.count) print("times is", times) def increment(c, times): c.count += 1 times += 1 main() # Call the main function Output: count is 100 times is 0

Hiding Data Fields: Data hiding in Python is the method to prevent access to specific users in the application. Data hiding in Python is done by using a double underscore before (prefix) the attribute name. This makes the attribute private/ inaccessible and hides them from users.

Data hiding helps computer programmers create classes with unique data sets and functions by avoiding unnecessary entrance from other classes in the program. Advantages of Data Hiding The objects within the class are disconnected from irrelevant data. It prevents programmers from linkage to incorrect data. It helps to prevent damage to volatile data by hiding it from the public.

Example:(public variable access any where) class JustCounter: secretCount = 0 # public variable def count(self): self.secretCount += 1 print(self.secretCount) counter = JustCounter() counter.count() counter.count() print(counter.secretCount)

Example:(private variable only access with in class) class JustCounter: __secretCount = 0 # private variable def count(self): self.__secretCount += 1 print(self.__secretCount) counter = JustCounter() counter.count() counter.count() print(counter.__secretCount)

Class Abstraction and Encapsulation Abstraction and Encapsulation both are OOP concepts of any object oriented programming languages. Both Abstraction and Encapsulation in OOPs using hiding information to the world.

Class Abstraction: Abstraction which focuses on the process of hiding the unwanted details and exposing only the essential features of a particular object, while designing time. Abstraction hides complexity by giving you a more abstract picture of a complex system. For example, a class Car would be made up of an Engine, Gearbox, Steering objects,and many more components. To build the Car class, one does not need to know how the different components work internally, but only how to interface with them.

Class encapsulation: Encapsulation also hides data from outside world, it hide actual data and method implementation from designer to client. Encapsulation hide things at implementation level. The. user of the class does not need to know how the class is implemented The details of implementation are encapsulated and hidden from the user. This is known as class encapsulation.

Encapsulation combines data and methods into a single object and hides the data fields and method implementation from the user. class implementation Class abstraction separates class implementation from the use of the class. Class Class’s Contract (headers of initializer and methods Clients use the class through the class’s contract

Object Oriented Thinking Python uses a programming pattern called object-oriented programming, which models concepts using classes and objects. This is a flexible, powerful paradigm where classes represent and define concepts, while objects are instances of classes. An object has two characteristics:  Attributes  behavior

Example: A parrot is an object, as it has the following properties: • name, age, color as attributes • singing, dancing as behavior

The str class • A string (str) is immutable. • Its content cannot be changed once the string is created • The input function returns a string from the keyboard • print function displays a string on the monitor

Creating strings • You can create strings by using str constructor Example: s=str() ---- empty string s=str(“welcome”) ----content • String can be enclosed by either double or single quotes • Although single quotes are more commonly used

Accessing a string • String can be accessed by index operator and slice operator. (i) Index operator: A string is a sequence operator. A character in the string can be accessed through the index operator Syntax: stringname[index] Example: >>> s=“ program” >>>s[2] -- o >>>s[6] -- m >>> s[0] -- p >>> s[7] -- Out of range

• Python also allows the use of negative numbers as index to reference positions relative to the end of the string Example: >>> s=“program” >>> s[-1] >>> s[-4] (ii) Slicing Operator: The slicing operator returns a slice of the string syntax : Stringname [start:end] Example: >>> s=“welcome” >>> s[0:4] --- welc >>> s[1:-1] --- elcom >>> s[5:-5] ---

Functions for strings • max(stringname) --- Returns largest number among given string >>> s=“welcome” >>> max(s) --- w • min(stringname) --- Returns smallest number among given string >>> s=“welcome” >>> min(s) --- e • len(stringname) ---- Returns length of the given string >>> s=“welcome” >>> len(s) --- 7

List operators • List having more operation like string ( ‘ + ‘ and ‘ * ‘ ), that is concatenation, in and not in • Following basic operation performed in list: Concatenation (+) Repetition (*) Membership (in) • Concatenation is the process of combine two list elements (+) >>> “we” + “come” “welcome” • To repeat the list elements in specified number of time (Repetition) (*) >>> “wel” * 3 “welwelwel” • Membership – To find specified elements is in the list or not >>> w in “welcome” True

Converting string or methods • capitalize() ---- Converts the first character to upper case >>> s=“kncet” >>> s.capitalize() ---- Kncet • count() ---- Returns the number of times a specified value occurs in a string >>>s=“kncet” >>>s.count(“k”) ---- 1 • title() ----Converts the first character of each word to upper case >>> s=“welcome hai” >>> s.title() ---- Welcome Hai

• lower() ---- Converts a string into lower case >>> s=“KNCET” >>> s.lower() ---- kncet • upper() ---- Converts a string into upper case >>>s=“kncet” >>>s.upper() ---- KNCET • swapcase() ---- lowercase becomes upper case and vice versa >>> s=“knceT” >>> s.swapcase() ---- KNCEt • replace(old,new) ---- Returns a string where a specified value is replaced with a specified value >>>s=“hai hello” >>>s.replace(“hai”,”kncet”) ---- kncet hello

Testing Strings • isalnum() -- Returns true if all characters in the strings are alphanumeric >>> a=“wel123” >>> a.alnum() ---- True • isalpha() -- Returns True if all characters in string are in the alphabet >>> a=“wel123” >>> a.alpha() ---- False • islower() -- Returns true if all characters in the string are lower case >>> a=“welcome” >>> a.islower() ---- True

• isspace() --- Returns true if this contains only whitespace characters >>> a=“ “ >>> a.isspace() --- True • isupper() --Returns true if all characters in the string are upper case >>> a=“welcome” >>> a.isupper() ---- False

Comparing Strings • You can compare strings by using the comparison operators (==, !=,>,=>,=<,<) • Python compares strings by comparing their corresponding characters. • It does this by evaluating the characters numeric code • Small letters starts from 97 • Uppercase Letters from 65 Example: >>> a=“KNCET” >>> b=“kncet” >>> a= =b ---- False

Iterating a String • A string is iterable. This means that you can use a for loop to traverse all characters in the string sequentially Example: >>> s="kncet" >>> for i in s: print(i) ---- k n c e t

Inheritance • Inheritance is an important aspect of the object-oriented paradigm. • The method of inheriting the properties of parent class into a child class is known as inheritance. • Inheritance provides code reusability to the program • Types Of Inheritance --- Single level --- Multi level --- Multiple --- Hierarchical

SINGLE INHERITANCE: • Classes are represented as boxes with the class name on top. • The inheritance relationship is represented by an arrow from the derived class pointing to the base class. • The word extends is usually added to the arrow. Base class Derived Class Extends

Super classes • The class from which a class inherits is called the super class • It is also known as parent class or base class. • Superclasses are sometimes called ancestors as well Syntax: class super_class_name: Attributes Methods

Subclasses • A class which inherits from a super class is called a subclass. • It is also known as child class. • The child class acquires the properties and can access all the data members and functions defined in the parent class. • Syntax: class derived-class(base class): <class-suite> To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class

Single Level inheritance: When a child class inherits only a single parent class. Example: class parent: def add(self): print(“addition”) class child (parent): def sub(self): print(“subtraction”) a=parent() a.add() a.sub()

Multiple Inheritance: When a child class inherits from more than one parent class. Parent 1 Parent 2 Parent 3 Child

class parent1: def add(self): print(“Addition”) class parent2: def sub(self): print(“Subtraction”) class child( parent1, parent2): def mul (self): print (“Multiplication”) super().add() super().sub() a=child() a.mul()

Multilevel Inheritance • When a child class becomes a parent class for another child class. Parent 1 Child 1 Child 2

class parent: def add(self): print(“Addition”) class child1(parent): def sub(self): print(“Subtraction”) class child2( child1): def mul (self): print (“Multiplication”) super().add() super().sub() a=child2() a.mul()

Hierarchical Inheritance: Hierarchical Inheritance: When more than one derived classes are created from a single base, this type of inheritance is called hierarchical inheritance. In this program, we have a parent (base) class and two child (derived) classes.

class Parent: def func1(self): print("This function is in parent class.") # Derived class1 class Child1(Parent): def func2(self): print("This function is in child 1.") # Derivied class2 class Child2(Parent): def func3(self): print("This function is in child 2.") object1 = Child1() object2 = Child2() object1.func1() object1.func2() object2.func1() object2.func3()

Method Overriding • To override a method, the method must be defined in the subclass using the same header as in its super class. • When a method in a subclass has the same name, same parameters or signature and same return type(or sub-type) as a method in its super-class, then the method in the subclass is said to override the method in the super-class.

Example program: class parent (): def add(self,x,y): z=x+y print (z) class child (parent): def add(self, x, y): z=x+y print (z) a=child() a.add(30,20) a.add(40,20)

Polymorphism: What is Polymorphism : The word polymorphism means having many forms. In programming, polymorphism means same function name (but different signatures) being uses for different types. Polymorphism is the ability to leverage the same interface for different underlying forms such as data types or classes. This permits functions to use entities of different types at different times.

Example 1: Polymorphism in addition operator The + Operator in python perform two operation For integer data types, + operator is used to perform arithmetic addition operation. Example: num1 = 1 num2 = 2 print(num1+num2)

Similarly, for string data types, + operator is used to perform concatenation. Example: str1 = "Python" str2 = "Programming" print(str1+" "+str2) output: Python Programming This is one of the most simple occurrences of polymorphism in Python.

Here are some functions in Python which are compatible to run with multiple data types. One such function is the len() function. It can run with many data types in Python. Example: print(len("Programiz")) print(len(["Python", "Java", "C"])) print(len({"Name": "John", "Address": "Nepal"}))

Polymorphism and dynamic Binding: We can use the concept of polymorphism while creating class methods as Python allows different classes to have methods with the same name. Polymorphism means that an object of a subclass can be passed to a parameter of a super class type. A method may be implemented in several classes along the inheritance chain. is also called method overriding. Python decides which method is invoked at runtime. This is known as dynamic binding.

Example: class India(): def capital(self): print("New Delhi is the capital of India.") def language(self): print("Hindi is the most widely spoken language of India.") def type(self): print("India is a developing country.")

class USA(): def capital(self): print("Washington, D.C. is the capital of USA.") def language(self): print("English is the primary language of USA.") def type(self): print("USA is a developed country.") obj_ind = India() obj_usa = USA() for country in (obj_ind, obj_usa): country.capital() country.language() country.type()

Output: New Delhi is the capital of India. Hindi is the most widely spoken language of India. India is a developing country. Washington, D.C. is the capital of USA. English is the primary language of USA. USA is a developed country.

Dynamic Binding: class Student: def __str__(self): return "Student" def printStudent(self): print(self.__str__()) class GraduateStudent(Student): def __str__(self): return "Graduate Student" a = Student() b = GraduateStudent() a.printStudent() b.printStudent()

The Isinstance Function: The isinstance function can be used to determine whether an object is an instance of a class. The isinstance() function returns True if the specified object is of the specified type, otherwise False.

Example: class myObj: name = "John" y = myObj() x = isinstance(y, myObj)

Class Relationship: To design classes, you need to explore the relationships among classes. The common relationships among classes are association, aggregation, composition, and inheritance.

Association: Association is a general binary relationship that describes an activity between two classes. For example, a student taking a course is an association between the Student class and the Course class, and a faculty member teaching a course is an association between the Faculty class and the Course class Take Teach Student course faculty

The above UML diagram shows that a student may take any number of courses, A faculty member may teach at most three courses, a course may have from five to sixty students, and a course is taught by only one faculty member. In Python code, you can implement associations by using data fields and methods.

Example: class Student: #Add course to a list def addCourse(self, course): class Course: # Add student to a list def addStudent(self, student): def setFaculty(self, faculty): class Faculty: # Add course to a list def addCourse(self, course):

Aggregation and Composition: Aggregation and Composition are subsets of association meaning they are specific cases of association. Aggregation models has-a relationships. The owner object is called an aggregating object, and its class is called an aggregating class.

• Aggregation It implies a relationship where the child can exist independently of the parent. In this child class not dependent with parent class. Example: Class (parent) and Student (child). Delete the Class and the Students still exist.

Composition It implies a relationship where the child cannot exist independent of the parent. Here child class dependent with parent class. Example: House (parent) and Room (child). Rooms don't exist separate to a House.

UNIT 3 PY.pptx - OOPS CONCEPTS IN PYTHON

More Related Content

Similar to UNIT 3 PY.pptx - OOPS CONCEPTS IN PYTHON

Recently uploaded

UNIT 3 PY.pptx - OOPS CONCEPTS IN PYTHON