Python unit 3 m.sc cs

SRI VASAVI COLLEGE,ERODE
(Self -Finance Wing)
Department of Computer Science
I-M.Sc (CS)
Python Programming
Unit-3
Presented by
P.KALAISELVI
Assistant Professor
Department of Computer Science

PYTHON MODULES
 What is a Module?
 Consider a module to be the same as a code library.
 A file containing a set of functions you want to include in your
application.
 Create a Module
 To create a module just save the code you want in a file with the file
extension .py:
 Example
 Save this code in a file named mymodule.py
def greeting(name):
print("Hello, " + name)
 Use a Module
 Now we can use the module we just created, by using
the import statement:
 Example
 Import the module named mymodule, and call the greeting function:
import mymodule
mymodule.greeting("Jonathan")

 Variables in Module
 The module can contain functions, as already described, but
also variables of all types (arrays, dictionaries, objects etc):
 Example
 Save this code in the file mymodule.py
person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
 Example
 Import the module named mymodule, and access the person1
dictionary:
import mymodule
a = mymodule.person1["age"]
print(a)

 Naming a Module
 You can name the module file whatever you like, but it must have the
file extension .py
 Re-naming a Module
 You can create an alias when you import a module, by using
the as keyword:
 Example
 Create an alias for mymodule called mx:
import mymodule as mx
a = mx.person1["age"]
print(a)
 Built-in Modules
 There are several built-in modules in Python, which you can import
whenever you like.
 Example
 Import and use the platform module:
import platform
x = platform.system()
print(x)

 Using the dir() Function
 There is a built-in function to list all the function names (or
variable names) in a module. The dir() function:
 Example
 List all the defined names belonging to the platform module:
import platform
x = dir(platform)
print(x)
 Note: The dir() function can be used on all modules, also the
ones you create yourself.
 Import From Module
 You can choose to import only parts from a module, by using
the from keyword.

 Example
 The module named mymodule has one function and one
dictionary:
def greeting(name):
print("Hello, " + name)
person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}
 Example
 Import only the person1 dictionary from the module:
 from mymodule import person1
print (person1["age"])

PYTHON CLASSES AND OBJECTS
 Python Classes/Objects
 Python is an object oriented programming language.
 Almost everything in Python is an object, with its properties and
methods.
 A Class is like an object constructor, or a "blueprint" for creating objects.
 Create a Class
 To create a class, use the keyword class:
 Example
 Create a class named MyClass, with a property named x:
class MyClass:
x = 5
 Create Object
 Now we can use the class named MyClass to create objects:
 Example
 Create an object named p1, and print the value of x:
p1 = MyClass()
print(p1.x)

 The __init__() Function
 The examples above are classes and objects in their simplest form, and
are not really useful in real life applications.
 To understand the meaning of classes we have to understand the built-
in __init__() function.
 All classes have a function called __init__(), which is always executed
when the class is being initiated.
 Use the __init__() function to assign values to object properties, or
other operations that are necessary to do when the object is being
created:
 Example
 Create a class named Person, use the __init__() function to assign
values for name and age:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1.name)
print(p1.age)

 Note: The __init__() function is called automatically every time
the class is being used to create a new object.
 Object Methods
 Objects can also contain methods. Methods in objects are
functions that belong to the object.
 Let us create a method in the Person class:
 Example
 Insert a function that prints a greeting, and execute it on the p1
object:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def myfunc(self):
print("Hello my name is " + self.name)
p1.myfunc()

 Note: The self parameter is a reference to the current instance
of the class, and is used to access variables that belong to the
class.
 The self Parameter
 The self parameter is a reference to the current instance of the
class, and is used to access variables that belongs to the class.
 It does not have to be named self , you can call it whatever you
like, but it has to be the first parameter of any function in the
class:
 Example
 Use the words mysillyobject and abc instead of self:
class Person:
def __init__(mysillyobject, name, age):
mysillyobject.name = name
mysillyobject.age = age

def myfunc(abc):
print("Hello my name is " + abc.name)
p1.myfunc()
 Modify Object Properties
 You can modify properties on objects like this:
 Example
 Set the age of p1 to 40:
p1.age = 40
 Delete Object Properties
 You can delete properties on objects by using the del keyword:
 Example
 Delete the age property from the p1 object:
del p1.age

 Delete Objects
 You can delete objects by using the del keyword:
 Example
 Delete the p1 object:
del p1
 The pass Statement
 class definitions cannot be empty, but if you for some reason
have a class definition with no content, put in
the pass statement to avoid getting an error.
 Example
class Person:
pass

PYTHON INHERITANCE
 Python Inheritance
 Inheritance allows us to define a class that inherits all the
methods and properties from another class.
 Parent class is the class being inherited from, also called base
class.
 Child class is the class that inherits from another class, also
called derived class.
 Create a Parent Class
 Any class can be a parent class, so the syntax is the same as
creating any other class:

 Example
 Create a class named Person,
with firstname and lastname properties, and
a printname method:
class Person:
def __init__(self, fname, lname):
self.firstname = fname
self.lastname = lname
def printname(self):
print(self.firstname, self.lastname)
#Use the Person class to create an object, and then execute the
printname method:
x = Person("John", "Doe")
x.printname()

 Create a Child Class
 To create a class that inherits the functionality from another
class, send the parent class as a parameter when creating the
child class:
 Example
 Create a class named Student, which will inherit the properties
and methods from the Person class:
class Student(Person):
pass
 Note: Use the pass keyword when you do not want to add any
other properties or methods to the class.
 Now the Student class has the same properties and methods as
the Person class.
 Example
 Use the Student class to create an object, and then execute
the printname method:
 x = Student("Mike", "Olsen")
x.printname()

 Add the __init__() Function
 So far we have created a child class that inherits the properties
and methods from its parent.
 We want to add the __init__() function to the child class (instead
of the pass keyword).
 Note: The __init__() function is called automatically every time
the class is being used to create a new object.
 Example
 Add the __init__() function to the Student class:
#add properties etc.
 When you add the __init__() function, the child class will no
longer inherit the parent's __init__() function.
 Note: The child's __init__() function overrides the inheritance
of the parent's __init__() function.
 To keep the inheritance of the parent's __init__() function, add a
call to the parent's __init__() function:

 Example
Person.__init__(self, fname, lname)
 Now we have successfully added the __init__() function, and
kept the inheritance of the parent class, and we are ready to
add functionality in the __init__() function.
 Use the super() Function
 Python also has a super() function that will make the child class
inherit all the methods and properties from its parent:
 Example
super().__init__(fname, lname)
 By using the super() function, you do not have to use the
name of the parent element, it will automatically inherit
the methods and properties from its parent.

 Add Properties
 Example
 Add a property called graduationyear to the Student class:
self.graduationyear = 2019
 In the example below, the year 2019 should be a variable, and
passed into the Student class when creating student objects. To
do so, add another parameter in the __init__() function:
 Example
 Add a year parameter, and pass the correct year when creating
objects:
def __init__(self, fname, lname, year):
self.graduationyear = year
x = Student("Mike", "Olsen", 2019)

 Add Methods
 Example
 Add a method called welcome to the Student class:
def __init__(self, fname, lname, year):
self.graduationyear = year
def welcome(self):
print("Welcome", self.firstname, self.lastname, "to the class
of", self.graduationyear)
 If you add a method in the child class with the same name
as a function in the parent class, the inheritance of the
parent method will be overridden.

METHOD OVERRIDING
 We can provide some specific implementation of the parent
class method in our child class. When the parent class method
is defined in the child class with some specific implementation,
then the concept is called method overriding. We may need to
perform method overriding in the scenario where the different
definition of a parent class method is needed in the child class.
 Consider the following example to perform method overriding
in python.
 Example
class Animal:
def speak(self):
print("speaking")
class Dog(Animal):
def speak(self):
print("Barking")
d = Dog()
d.speak()
Output:
Barking

Real Life Example of method overriding
class Bank:
def getroi(self):
return 10;
class SBI(Bank):
def getroi(self):
return 7;
class ICICI(Bank):
def getroi(self):
return 8;
b1 = Bank()
b2 = SBI()
b3 = ICICI()
print("Bank Rate of interest:",b1.getroi());
print("SBI Rate of interest:",b2.getroi());
print("ICICI Rate of interest:",b3.getroi());
Output:
Bank Rate of interest: 10 SBI Rate of interest: 7 ICICI Rate of interest: 8

GET HELP FROM YOUR PARENT WITH SUPER
 We saw how the child class could add or override a method from
the parent. What if
 it wanted to call that parent method? “I‟m glad you asked,” says
super(). We‟ll define
 a new class called EmailPerson that represents a Person with an
email address. First,
 our familiar Person definition:
>>> class Person():
... def __init__(self, name):
... self.name = name
...
 Notice that the __init__() call in the following subclass has an
additional email
 parameter:
>>> class EmailPerson(Person):
... def __init__(self, name, email):
... super().__init__(name)
... self.email = email

 When you define an __init__() method for your class, you‟re
replacing the __init__() method of its parent class, and the
latter is not called automatically anymore.
 As a result, we need to call it explicitly. Here‟s what‟s
happening:
 The super() gets the definition of the parent class, Person.
 The __init__() method calls the Person.__init__() method. It
takes care of
 passing the self argument to the superclass, so you just
need to give it any
 optional arguments. In our case, the only other argument
Person() accepts is name.
 The self.email = email line is the new code that makes this
EmailPerson different from a Person.
 Moving on, let‟s make one of these creatures:

>>> bob = EmailPerson('Bob Frapples', 'bob@frapples.com')
 We should be able to access both the name and email attributes:
>>> bob.name
'Bob Frapples'
>>> bob.email
'bob@frapples.com'
 Why didn‟t we just define our new class as follows?
>>> class EmailPerson(Person):
... def __init__(self, name, email):
... self.name = name
... self.email = email
 We could have done that, but it would have defeated our use of
inheritance. We used super() to make Person do its work, the
same as a plain Person object would. There‟s another benefit: if
the definition of Person changes in the future, using super() will
ensure that the attributes and methods that EmailPerson
inherits from Person will reflect the change.
 Use super() when the child is doing something its own way but
still needs something from the parent (as in real life).

IN SELF DEFENSE
 One criticism of Python (besides the use of whitespace) is the need to
include self as the first argument to instance methods (the kind of
method you‟ve seen in the previous examples). Python uses the self
argument to find the right object‟s attributes and methods. For an
example, I‟ll show how you would call an object‟s method, and what
Python actually does behind the scenes.
 Remember class Car from earlier examples? Let‟s call its exclaim()
method again:
>>> car = Car()
>>> car.exclaim()
I'm a Car!
 Here‟s what Python actually does, under the hood:
 Look up the class (Car) of the object car.
 Pass the object car to the exclaim() method of the Car class as the self
parameter.
 Just for fun, you can even run it this way yourself and it will work the
same as the
 normal (car.exclaim()) syntax:
>>> Car.exclaim(car)
I'm a Car!

GET AND SET ATTRIBUTE VALUES WITH PROPERTIES
 Python doesn‟t need getters or setters, because all
attributes and methods are public, and you‟re expected to
behave yourself. If direct access to attributes makes you
nervous,you can certainly write getters and setters. But be
Pythonic—use properties.
 In this example, we‟ll define a Duck class with a single
attribute called hidden_name.(In the next section, I‟ll show
you a better way to name attributes that you want to keep
private.) We don‟t want people to access this directly, so
we‟ll define two methods: a getter (get_name()) and a setter
(set_name()). I‟ve added a print() statement to each method
to show when it‟s being called. Finally, we define these
methods as properties of the name attribute:

>>> class Duck():
... def __init__(self, input_name):
... self.hidden_name = input_name
... def get_name(self):
... print('inside the getter')
... return self.hidden_name
... def set_name(self, input_name):
... print('inside the setter')
... self.hidden_name = input_name
... name = property(get_name, set_name)
 The new methods act as normal getters and setters until
that last line; it defines the two methods as properties of
the attribute called name. The first argument to property()
is the getter method, and the second is the setter. Now,
when you refer to the name of any Duck object, it actually
calls the get_name() method to return it:

>>> fowl = Duck('Howard')
>>> fowl.name
inside the getter
'Howard'
 You can still call get_name() directly, too, like a normal
getter method:
>>> fowl.get_name()
inside the getter
'Howard'
 When you assign a value to the name attribute, the
set_name() method will be called:
>>> fowl.name = 'Daffy'
Ins
>>> fowl.name
inside the getter
'Daffy‟

 You can still call the set_name() method directly:
>>> fowl.set_name('Daffy')
inside the setter
>>> fowl.name
inside the getter
„Daffy„
 Name Mangling for Privacy
 Python has a naming convention for attributes that should not be
visible outside of their class definition: begin by using with two
underscores (__).
 Let‟s rename hidden_name to __name, as demonstrated here:
>>> class Duck():
... def __init__(self, input_name):
... self.__name = input_name
... @property
... def name(self):
... print('inside the getter')
... return self.__name
... @name.setter
... def name(self, input_name):
... print('inside the setter')
... self.__name = input_name

 Take a moment to see if everything still works:
>>> fowl = Duck('Howard')
>>> fowl.name
inside the getter
'Howard'
>>> fowl.name = 'Donald'
inside the setter
>>> fowl.name
inside the getter
'Donald'
 Looks good. And, you can‟t access the __name attribute:
>>> fowl.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Duck' object has no attribute '__name'
 This naming convention doesn‟t make it private, but Python
does mangle the name to make it unlikely for external code to
stumble upon it.

METHOD TYPES
 Some data (attributes) and functions (methods) are part of
the class itself, and some are part of the objects that are
created from that class.
 When you see an initial self argument in methods within a
class definition, it‟s an instance method. These are the
types of methods that you would normally write when
creating your own classes. The first parameter of an
instance method is self, and Python passes the object to
the method when you call it.
 In contrast, a class method affects the class as a whole. Any
change you make to the class affects all of its objects.
Within a class definition, a preceding @classmethod
decorator indicates that that following function is a class
method.

 Also, the first parameter to the method is the class itself. The
Python tradition is to call the parameter cls, because class is a
reserved word and can‟t be used here. Let‟s define a class
method for A that counts how many object instances have been
made from it:
>>> class A():
... count = 0
... def __init__(self):
... A.count += 1
... def exclaim(self):
... print("I'm an A!")
... @classmethod
... def kids(cls):
... print("A has", cls.count, "little objects.")
...
>>>
>>> easy_a = A()
>>> breezy_a = A()
>>> wheezy_a = A()
>>> A.kids()
A has 3 litte objects.

 Notice that we referred to A.count (the class attribute) rather
than self.count (which would be an object instance attribute).
In the kids() method, we used cls.count, but we could just as
well have used A.count.
 A third type of method in a class definition affects neither the
class nor its objects; it‟s just in there for convenience instead of
floating around on its own. It‟s a static method, preceded by a
@staticmethod decorator, with no initial self or class
parameter. Here‟s an example that serves as a commercial for
the class CoyoteWeapon:
>>> class CoyoteWeapon():
... @staticmethod
... def commercial():
... print('This CoyoteWeapon has been brought to you by Acme')
...
>>>
>>> CoyoteWeapon.commercial()
This CoyoteWeapon has been brought to you by Acme
 Notice that we didn‟t need to create an object from class
CoyoteWeapon to access this method. Very class-y.

DUCK TYPING
 Python has a loose implementation of polymorphism; this means that it applies the
same operation to different objects, regardless of their class.
 Let‟s use the same __init__() initializer for all three Quote classes now, but add two
new functions:
 • who() just returns the value of the saved person string
 • says() returns the saved words string with the specific punctuation
 And here they are in action:
>>> class Quote():
... def __init__(self, person, words):
... self.person = person
... self.words = words
... def who(self):
... return self.person
... def says(self):
... return self.words + '.'
...
>>> class QuestionQuote(Quote):
... def says(self):
... return self.words + '?'
...
>>> class ExclamationQuote(Quote):
... def says(self):
... return self.words + '!'
...
>>>

 We didn‟t change how QuestionQuote or ExclamationQuote
were initialized, so we didn‟t override their __init__()
methods. Python then automatically calls the __init__()
method of the parent class Quote to store the instance
variables person and words. That‟s why we can access
self.words in objects created from the subclasses
QuestionQuote and ExclamationQuote.
 Next up, let‟s make some objects:
>>> hunter = Quote('Elmer Fudd', "I'm hunting wabbits")
>>> print(hunter.who(), 'says:', hunter.says())
Elmer Fudd says: I'm hunting wabbits.
>>> hunted1 = QuestionQuote('Bugs Bunny', "What's up,
doc")
>>> print(hunted1.who(), 'says:', hunted1.says())
Bugs Bunny says: What's up, doc?
>>> hunted2 = ExclamationQuote('Daffy Duck', "It's rabbit
season")
>>> print(hunted2.who(), 'says:', hunted2.says())
Daffy Duck says: It's rabbit season!

 Three different versions of the says() method provide
different behavior for the three classes. This is traditional
polymorphism in object-oriented languages. Python goes a
little further and lets you run the who() and says() methods
of any objects that have them. Let‟s define a class called
BabblingBrook that has no relation to our previous woodsy
hunter and huntees (descendants of the Quote class):
>>> class BabblingBrook():
... def who(self):
... return 'Brook'
... def says(self):
... return 'Babble'
...
>>> brook = BabblingBrook()
 Now, run the who() and says() methods of various objects,
one (brook) completely unrelated to the others:

>>> def who_says(obj):
... print(obj.who(), 'says', obj.says())
...
>>> who_says(hunter)
Elmer Fudd says I'm hunting wabbits.
>>> who_says(hunted1)
Bugs Bunny says What's up, doc?
>>> who_says(hunted2)
Daffy Duck says It's rabbit season!
>>> who_says(brook)
Brook says Babble
 This behavior is sometimes called duck typing, after the old
saying:
 If it walks like a duck and quacks like a duck, it‟s a duck.
 —A Wise Person

SPECIAL METHODS
 When you type something such as a = 3 + 8, how do the
integer objects with values 3 and 8 know how to implement
+? Also, how does a know how to use = to get the result?
You can get at these operators by using Python‟s special
methods (you might also see them called magic methods).
You don’t need Gandalf to perform any magic, and they‟re
not even complicated.
 The names of these methods begin and end with double
underscores (__). You‟ve already seen one: __init__
initializes a newly created object from its class definition
and any arguments that were passed in.
 Suppose that you have a simple Word class, and you want
an equals() method that compares two words but ignores
case. That is, a Word cont aining the value 'ha„ would be
considered equal to one containing 'HA'.

 The example that follows is a first attempt, with a normal
method we‟re calling equals(). self.text is the text string
that this Word object contains, and the equals() method
compares it with the text string of word2 (another Word
object):
>>> class Word():
... def __init__(self, text):
... self.text = text
...
... def equals(self, word2):
... return self.text.lower() == word2.text.lower()
...
 Then, make three Word objects from three different text
string
>>> first = Word('ha')
>>> second = Word('HA')
>>> third = Word('eh')s:

 When strings 'ha' and 'HA' are compared to lowercase, they
should be equal:
>>> first.equals(second)
True
 But the string 'eh' will not match 'ha':
>>> first.equals(third)
False
 We defined the method equals() to do this lowercase
conversion and comparison. It would be nice to just say if
first == second, just like Python‟s built-in types. So, let‟s do
that. We change the equals() method to the special name __
>>> class Word():
... def __eq__(self, word2):
...eq__() (you‟ll see why in a moment):

 Let‟s see if it works:
>>> second = Word('HA')
>>> third = Word('eh')
>>> first == second
True
>>> first == third
False
 Magic! All we needed was the Python‟s special method
name for testing equality,__eq__(). Tables 6-1 and 6-2 list
the names of the most useful magic methods.

 Table 6-1. Magic methods for comparison
__eq__( self, other ) self == other
__ne__( self, other ) self != other
__lt__( self, other ) self < other
__gt__( self, other ) self > other
__le__( self, other ) self <= other
__ge__( self, other ) self >= other
 Table 6-2. Magic methods for math
__add__( self, other ) self + other
__sub__( self, other ) self - other
__mul__( self, other ) self * other
__floordiv__( self, other ) self // other
__truediv__( self, other ) self / other
__mod__( self, other ) self % other
__pow__( self, other ) self ** other

 You aren‟t restricted to use the math operators such as + (magic
method __add__()) and - (magic method __sub__()) with
numbers. For instance, Python string objects use + for
concatenation and * for duplication. There are many more,
documented online at Special method names. The most common
among them are presented in Table 6-3.
 Table 6-3. Other, miscellaneous magic methods
__str__( self ) str( self )
__repr__( self ) repr( self )
__len__( self ) len( self )
 Besides __init__(), you might find yourself using __str__() the
most in your own methods. It‟s how you print your object. It‟s
used by print(), str().The interactive interpreter uses the
__repr__() function to echo variables to output. If you fail to defi
ne either __str__() or __repr__(), you get Python‟s default string
version of your object:
>>> first
<__main__.Word object at 0x1006ba3d0>
>>> print(first)
<__main__.Word object at 0x1006ba3d0>

 Let‟s add both __str__() and __repr__() methods to the
Word class to make it prettier:
>>> class Word():
... def __eq__(self, word2):
... def __str__(self):
... return self.text
... def __repr__(self):
... return 'Word("' self.text '")'
...
>>> first # uses __repr__
Word("ha")
>>> print(first) # uses __str__
ha

AGGREGATION AND COMPOSITION
 Inheritance is a good technique to use when you want a child
class to act like its parent class most of the time (when child is-a
parent). It’s tempting to build elaborate inheritance hierarchies,
but sometimes composition or aggregation make more sense.
 What‟s the difference? In composition, one thing is part of
another. A duck is-a bird (inheritance), but has-a tail
(composition). A tail is not a kind of duck, but part of a duck. In
this next example, let‟s make bill and tail objects and provide
them to a new duck object:
>>> class Bill():
... def __init__(self, description):
... self.description = description
...
>>> class Tail():
... def __init__(self, length):
... self.length = length

...
>>> class Duck():
... def __init__(self, bill, tail):
... self.bill = bill
... self.tail = tail
... def about(self):
... print('This duck has a', self.bill.description,
... 'bill and a', self.tail.length, 'tail')
...
>>> a_tail = Tail('long')
>>> a_bill = Bill('wide orange')
>>> duck = Duck(a_bill, a_tail)
>>> duck.about()
This duck has a wide orange bill and a long tail
 Aggregation expresses relationships, but is a little looser:
one thing uses another, but both exist independently. A
duck uses a lake, but one is not a part of the other.

Python unit 3 m.sc cs

Recommended

More Related Content

What's hot (20)

Similar to Python unit 3 m.sc cs (20)

More from KALAISELVI P (9)

Recently uploaded (20)

Python unit 3 m.sc cs