This document discusses object-oriented programming concepts in Python including classes, objects, attributes, methods, inheritance, polymorphism, and special methods. Key points include: - Classes are templates that define objects, while objects are instantiations of classes with unique attribute values. - Methods define object behaviors. The self parameter refers to the current object instance. - Inheritance allows classes to extend existing classes, reusing attributes and methods from parent classes. - Special methods with double underscores have predefined meanings (e.g. __init__ for constructors, __repr__ for string representation).

1. Creative Commons License
This work is licensed under a Creative Commons Attribution 4.0 International License.
BS GIS Instructor: Inzamam Baig
Lecture 13
Fundamentals of Programming

2. Object Oriented Programming
Python is a multi-paradigm programming language
Objects are the basic units of object-oriented programming

3. Object
Real-world objects share two characteristics:
They all have state and behavior
Dogs have state (name, color, breed, hungry) and behavior (barking,
fetching, wagging tail)
Bicycles also have state (current gear, current pedal cadence, current
speed) and behavior (changing gear, changing pedal cadence, applying
brakes).
Identifying the state and behavior for real-world objects is a great way to
begin thinking in terms of object-oriented programming

5. State
Current GearCurrent Speed
Current Pedal Candence

6. Behaviour
Change GearApply Brake
Changing Pedal Candence

7. An object has two characteristics:
attributes
behavior

10. Class
A class is a like a template for an object.
The example for class of person can be :
class Person:
pass

11. Object
An object (instance) is an instantiation of a class
When class is defined, only the description for the object is defined
Therefore, no memory or storage is allocated
obj = Person()
Here, obj is an object of class Person.

12. class Person:
# class attribute
employer = 'Karakoram International University'
# instance attribute
def __init__(self, name, age):
self.name = name
self.age = age
# instantiate the Person class
student = Person("Zeeshan", 10)
teacher = Person("Fatima", 15)
# access the class attributes
print("student is employee of {}".format(student.employer))
print("teacher is employee of {}".format(teacher.employer))
# access the instance attributes
print("{} is {} years old".format(student.name, student.age))
print("{} is {} years old".format(teacher.name, teacher.age))

13. Methods
Methods are functions defined inside the body of a class
They are used to define the behaviors of an object

14. class Student:
# instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# instance method
def study(self, book_name):
return "{} is studying {}".format(self.name, book_name)
def playing(self):
return "{} is now playing".format(self.name)
# instantiate the object
zeeshan = Student("Zeeshan", 10)
# call our instance methods
print(zeeshan.study("Programming"))
print(zeeshan.playing())

15. Self
Self keyword is used to represent an instance of the class

16. Constructor
Class functions that begin with double underscore __ are called
special functions as they have special meaning
Of one particular interest is the __init__() function. This special
function gets called whenever a new object of that class is instantiated
This type of function is also called constructors in Object Oriented
Programming (OOP)
We normally use it to initialize all the variables

17. class Person:
def __init__(self, name, age):
self.name = name
self.age = age

18. Deleting Attributes
Any attribute of an object can be deleted anytime, using the del
statement
del zeeshan.name

19. class Student:
# instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
def get_name(self):
return self.name
# instantiate the object
zeeshan = Student("Zeeshan", 10)
del zeeshan.name
student_name = zeeshan.get_name()

20. Deleting Object
del zeeshan
Deleting objects in Python removes the name binding
The object however continues to exist in memory and if no other
name is bound to it, it is later automatically destroyed
This automatic destruction of unreferenced objects in Python is
also called garbage collection

21. Student Object
name = zeeshan,
age = 10
Student Object
name = zeeshan,
age = 10
zeeshan zeeshan
zeeshan = Student('Zeeshan',
10)
del zeeshan

22. Class Methods
class methods take a cls parameter that points to the class
the class method only has access to this cls argument, it can't
modify object instance state
class methods can still modify class state that applies across all
instances of the class

23. @classmethod
def classmethod(cls):
pass

24. Static Methods
This type of method takes neither a self nor a cls parameter
static method can neither modify object state nor class state

25. Inheritance
Inheritance enables us to define a class that takes all the
functionality from a parent class and allows us to add more
The new class is called derived (or child) class and the one
from which it inherits is called the base (or parent) class
Inheritance models is a relationship

26. class BaseClass:
Body of base class
class DerivedClass(BaseClass):
Body of derived class

27. Base
Derived
Extends

28. class Person(object):
# Constructor
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
class Student(Person):
def is_registred(self):
return True
class Teacher(Person):
def is_employeed(self):
return True
zeeshan = Student("Zeeshan")
print(zeeshan.get_name(), zeeshan.is_registred())
adnan = Teacher("Adnan")
print(adnan.get_name(), adnan.is_employeed())

29. Is Instance
isinstance(zeeshan, Student)

30. Is Subclass
issubclass(Student, Person)

31. super()
class Person(object):
# Constructor
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
class Student(Person):
def __init__(self, name, gpa):
super().__init__(name)
self.gpa = gpa
def is_registred(self):
return True

32. Multiple Inheritance
A class can be derived from more than one base class in Python,
similar to C++. This is called multiple inheritance
In multiple inheritance, the features of all the base classes are
inherited into the derived class

33. class Base1:
pass
class Base2:
pass
class MultiDerived(Base1, Base2):
pass

35. class Person:
def __init__(self, name, age):
self.name = name
self.age = age
class Player:
def __init__(self, sports_name):
self.sports_name = sports_name
class Student(Person, Player):
def __init__(self, name, age, sports_name):
Person.__init__(self, name, age)
Player.__init__(self, sports_name)
s = Student('Adnan', 10, 'Cricket')

36. Every class in Python is derived from the object class. It is the
most base type in Python.
So technically, all other classes, either built-in or user-defined,
are derived classes and all objects are instances of the object
class

37. # Output: True
print(issubclass(list,object))
# Output: True
print(isinstance(5.5,object))
# Output: True
print(isinstance("Hello",object))

38. Special Methods
Repr
def __repr__(self):
return '{} {}'.format(self.name, self.gpa)

39. Special Methods
Str
def __str__(self):
return '{} {}'.format(self.fullname(), self.email())

40. Special Methods
Add
int.__add__(1,2)
str.__add__('BS','GIS')
def __init__(self, second_instance):
return self.gpa + second_instance.gpa