Lecture on Python class -lecture123456.ppt

OBJECT ORIENTED PROGRAMMING
OBJECT ORIENTED PROGRAMMING
IN PYTHON:
IN PYTHON:
DEFINING CLASSES
DEFINING CLASSES

IT
IT’
’S ALL OBJECTS…
S ALL OBJECTS…
 Everything in Python is really an object.
 We’ve seen hints of this already…
“hello”.upper()
list3.append(‘a’)
dict2.keys()
 New object classes can easily be defined
in addition to these built-in data-types.
 In fact, programming in Python is typically
done in an object oriented fashion.

DEFINING A CLASS
DEFINING A CLASS
 A class is a special data type which defines
how to build a certain kind of object.
 The class also stores some data items that
are shared by all the instances of this class
 Instances are objects that are created which
follow the definition given inside of the class
 Python doesn’t use separate class interface
definitions as in some languages. You just
define the class and then use it

METHODS IN CLASSES
METHODS IN CLASSES
 Define a method in a class by including
function definitions within the scope of the
class block
 There must be a special first argument
self in all of method definitions which gets
bound to the calling instance
 There is usually a special method called
__init__ in most classes
 We’ll talk about both later…

A SIMPLE CLASS DEF:
A SIMPLE CLASS DEF: STUDENT
STUDENT
class student:
“““A class representing a
student ”””
def __init__(self,n,a):
self.full_name = n
self.age = a
def get_age(self):
return self.age

CREATING AND
CREATING AND
DELETING INSTANCES
DELETING INSTANCES

INSTANTIATING OBJECTS
INSTANTIATING OBJECTS
 There is no “new” keyword as in Java.
 Just use the class name with ( ) notation and
assign the result to a variable
 __init__ serves as a constructor for the
class. Usually does some initialization work
 The arguments passed to the class name are
given to its __init__() method
 So, the __init__ method for student is passed
“Bob” and 21 and the new class instance is
bound to b:
b = student(“Bob”, 21)

CONSTRUCTOR: __INIT__
CONSTRUCTOR: __INIT__
 An __init__ method can take any number
of arguments.
 Like other functions or methods, the
arguments can be defined with default
values, making them optional to the caller.
 However, the first argument self in the
definition of __init__ is special…

SELF
SELF
 The first argument of every method is a
reference to the current instance of the class
 By convention, we name this argument
self
 In __init__, self refers to the object
currently being created; so, in other class
methods, it refers to the instance whose
method was called

SELF
SELF
 Although you must specify self explicitly
when defining the method, you don’t
include it when calling the method.
 Python passes it for you automatically
Defining a method: Calling a
method:
(this code inside a class definition.)
def set_age(self, num): >>> x.set_age(23)
self.age = num

DELETING INSTANCES: NO NEED
DELETING INSTANCES: NO NEED
TO
TO “
“FREE
FREE”
”
 When you are done with an object, you don’t
have to delete or free it explicitly.
 Python has automatic garbage collection.
 Python will automatically detect when all of
the references to a piece of memory have
gone out of scope. Automatically frees that
memory.
 There’s also no “destructor” method for
classes

ACCESS TO
ACCESS TO
ATTRIBUTES AND
ATTRIBUTES AND
METHODS
METHODS

DEFINITION OF STUDENT
DEFINITION OF STUDENT
class student:
“““A class representing a student
”””
self.full_name = n
self.age = a
def get_age(self):
return self.age

TRADITIONAL SYNTAX FOR ACCESS
TRADITIONAL SYNTAX FOR ACCESS
>>> f = student(“Bob Smith”, 23)
>>> f.full_name # Access attribute
“Bob Smith”
>>> f.get_age() # Access a method
23

ACCESSING UNKNOWN MEMBERS
ACCESSING UNKNOWN MEMBERS
 Problem: Occasionally the name of an attribute
or method of a class is only given at run time…
 Solution:
getattr(object_instance, string)
 string is a string which contains the name of an
attribute or method of a class
 getattr(object_instance, string)
returns a reference to that attribute or method

GETATTR(OBJECT_INSTANCE,
GETATTR(OBJECT_INSTANCE,
STRING)
STRING)
>>> getattr(f, “full_name”)
“Bob Smith”
>>> getattr(f, “get_age”)
<method get_age of class
studentClass at 010B3C2>
>>> getattr(f, “get_age”)() # call it
23
>>> getattr(f, “get_birthday”)
# Raises AttributeError – No method!

HASATTR(OBJECT_INSTANCE,STRIN
HASATTR(OBJECT_INSTANCE,STRIN
G)
G)
>>> hasattr(f, “full_name”)
True
>>> hasattr(f, “get_age”)
True
>>> hasattr(f, “get_birthday”)
False

TWO KINDS OF ATTRIBUTES
TWO KINDS OF ATTRIBUTES
 The non-method data stored by objects are
called attributes
 Data attributes
 Variable owned by a particular instance of a
class
 Each instance has its own value for it
 These are the most common kind of attribute
 Class attributes
 Owned by the class as a whole
 All class instances share the same value for it
 Called “static” variables in some languages

DATA ATTRIBUTES
DATA ATTRIBUTES
 Data attributes are created and initialized
by an __init__() method.
 Simply assigning to a name creates the
attribute
 Inside the class, refer to data attributes using
self
 for example, self.full_name
class teacher:
“A class representing teachers.”
def __init__(self,n):
self.full_name = n
def print_name(self):
print self.full_name

CLASS ATTRIBUTES
CLASS ATTRIBUTES
 Because all instances of a class share one copy of a
class attribute, when any instance changes it, the
value is changed for all instances
 Class attributes are defined within a class definition
and outside of any method
 Since there is one of these attributes per class and
not one per instance, they’re accessed via a different
notation:
 Access class attributes using self.__class__.name
notation -- This is just one way to do this & the safest in general.
class sample: >>> a = sample()
x = 23 >>> a.increment()
def increment(self): >>> a.__class__.x
self.__class__.x += 1 24

DATA VS. CLASS ATTRIBUTES
DATA VS. CLASS ATTRIBUTES
class counter:
overall_total = 0
# class attribute
def __init__(self):
self.my_total = 0
# data attribute
def increment(self):
counter.overall_total =
counter.overall_total + 1
self.my_total =
self.my_total + 1
>>> a = counter()
>>> b = counter()
>>> a.increment()
>>> b.increment()
>>> b.increment()
>>> a.my_total
1
>>> a.__class__.overall_total
3
>>> b.my_total
2
>>> b.__class__.overall_total
3

SUBCLASSES
SUBCLASSES
Classes can extend the definition of
other classes
 Allows use (or extension) of methods and
attributes already defined in the previous
one
To define a subclass, put the name of
the superclass in parens after the
subclass’s name on the first line of the
definition
Class Cs_student(student):
 Multiple inheritance is supported

REDEFINING METHODS
REDEFINING METHODS
 To redefine a method of the parent class,
include a new definition using the same
name in the subclass
 The old code won’t get executed
 To execute the method in the parent class in
addition to new code for some method,
explicitly call the parent’s version of method
parentClass.methodName(self,a,b,c)
 The only time you ever explicitly pass ‘self’ as
an argument is when calling a method of an
ancestor

DEFINITION OF A CLASS EXTENDING
DEFINITION OF A CLASS EXTENDING
STUDENT
STUDENT
Class Student:
“A class representing a student.”
self.full_name = n
self.age = a
def get_age(self):
return self.age
Class Cs_student (student):
“A class extending student.”
def __init__(self,n,a,s):
student.__init__(self,n,a) #Call __init__ for student
self.section_num = s
def get_age(): #Redefines get_age method entirely
print “Age: ” + str(self.age)

EXTENDING __INIT__
EXTENDING __INIT__
Same as redefining any other method…
 Commonly, the ancestor’s __init__ method
is executed in addition to new commands
 You’ll often see something like this in the
__init__ method of subclasses:
parentClass.__init__(self, x, y)
where parentClass is the name of the parent’s
class

SPECIAL BUILT-IN
SPECIAL BUILT-IN
METHODS AND ATTRIBUTES
METHODS AND ATTRIBUTES

BUILT-IN MEMBERS OF CLASSES
BUILT-IN MEMBERS OF CLASSES
Classes contain many methods and
attributes that are always included
 Most define automatic functionality
triggered by special operators or usage
of that class
 Built-in attributes define information
that must be stored for all classes.
All built-in members have double
underscores around their names:
__init__ __doc__

SPECIAL METHODS
SPECIAL METHODS
E.g., the method __repr__ exists for all
classes, and you can always redefine it
__repr__ specifies how to turn an
instance of the class into a string
 print f sometimes calls f.__repr__()
to produce a string for object f
 Typing f at the REPL prompt calls
__repr__ to determine what to display as
output

SPECIAL METHODS – EXAMPLE
SPECIAL METHODS – EXAMPLE
class student:
...
def __repr__(self):
return “I’m named ” + self.full_name
...
>>> print f
I’m named Bob Smith
>>> f
“I’m named Bob Smith”

SPECIAL METHODS
SPECIAL METHODS
 You can redefine these as well:
__init__ : The constructor for the class
__cmp__ : Define how == works for class
__len__ : Define how len( obj ) works
__copy__ : Define how to copy a class
 Other built-in methods allow you to give a
class the ability to use [ ] notation like an
array or ( ) notation like a function call

SPECIAL DATA ITEMS
SPECIAL DATA ITEMS
 These attributes exist for all classes.
__doc__ : Variable for documentation string
for class
__class__ : Variable which gives you a reference
to the class from any instance of it
__module__ : Variable which gives a reference to
the module in which the particular class is defined
__dict__ :The dictionary that is actually the
namespace for a class (but not its superclasses)
 Useful:
 dir(x) returns a list of all methods and
attributes defined for object x

SPECIAL DATA ITEMS – EXAMPLE
SPECIAL DATA ITEMS – EXAMPLE
>>> print f.__doc__
A class representing a student.
>>> f.__class__
< class studentClass at 010B4C6 >
>>> g = f.__class__(“Tom Jones”,
34)

PRIVATE DATA AND
PRIVATE DATA AND
METHODS
METHODS
 Any attribute/method with two leading
under-scores in its name (but none at the
end) is private and can’t be accessed
outside of class
 Note: Names with two underscores at the
beginning and the end are for built-in
methods or attributes for the class
 Note: There is no ‘protected’ status in
Python; so, subclasses would be unable to
access these private data either

Lecture on Python class -lecture123456.ppt

Recommended

More Related Content

Similar to Lecture on Python class -lecture123456.ppt (20)

More from Reji K Dhaman (20)

Recently uploaded (20)

Lecture on Python class -lecture123456.ppt