Python unit 2 M.sc cs

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

CODE STRUCTURES
 Python If ... Else
 Python Conditions and If statements
 Python supports the usual logical conditions from
mathematics:
 Equals: a == b
 Not Equals: a != b
 Less than: a < b
 Less than or equal to: a <= b
 Greater than: a > b
 Greater than or equal to: a >= b
 These conditions can be used in several ways, most
commonly in "if statements" and loops.
 An "if statement" is written by using the if keyword.

 Example
 If statement:
a = 33
b = 200
if b > a:
print("b is greater than a")
 In this example we use two variables, a and b, which are used as part
of the if statement to test whether b is greater than a. As a is 33,
and b is 200, we know that 200 is greater than 33, and so we print to
screen that "b is greater than a".
 Indentation
 Python relies on indentation (whitespace at the beginning of a line) to
define scope in the code. Other programming languages often use
curly-brackets for this purpose.
 Example
 If statement, without indentation (will raise an error):
 a = 33
b = 200
if b > a:
print("b is greater than a") # you will get an error

 Elif
 The elif keyword is pythons way of saying "if the previous
conditions were not true, then try this condition".
 Example
a = 33
b = 33
if b > a:
elif a == b:
print("a and b are equal")
 In this example a is equal to b, so the first condition is
not true, but the elif condition is true, so we print to
screen that "a and b are equal".
 Else
 The else keyword catches anything which isn't caught by the
preceding conditions.

 Example
a = 200
b = 33
if b > a:
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
 In this example a is greater than b, so the first condition is
not true, also the elif condition is not true, so we go to
the else condition and print to screen that "a is greater than
b".
 You can also have an else without the elif:
 Example
a = 200
b = 33
if b > a:
else:
print("b is not greater than a")

 Short Hand If
 If you have only one statement to execute, you can put it on
the same line as the if statement.
 Example
 One line if statement:
 if a > b: print("a is greater than b")
 Short Hand If ... Else
 If you have only one statement to execute, one for if, and one
for else, you can put it all on the same line:
 Example
 One line if else statement:
a = 2
b = 330
print("A") if a > b else print("B")
 This technique is known as Ternary Operators,
or Conditional Expressions.

 You can also have multiple else statements on the same
line:
 Example
 One line if else statement, with 3 conditions:
a = 330
b = 330
print("A") if a > b else print("=") if a == b else print("B")
 And
 The and keyword is a logical operator, and is used to combine
conditional statements:
 Example
 Test if a is greater than b, AND if c is greater than a:
a = 200
b = 33
c = 500
if a > b and c > a:
print("Both conditions are True")

 Or
 The or keyword is a logical operator, and is used to combine
conditional statements:
 Example
 Test if a is greater than b, OR if a is greater than c:
a = 200
b = 33
c = 500
if a > b or a > c:
print("At least one of the conditions is True")
 Nested If
 You can have if statements inside if statements, this is
called nested if statements.
 Example
x = 41
if x > 10:
print("Above ten,")
if x > 20:
print("and also above 20!")
else:
print("but not above 20.")

PYTHON WHILE LOOPS
 Python Loops
 Python has two primitive loop commands:
 while loops
 for loops
 The while Loop
 With the while loop we can execute a set of statements as long as a
condition is true.
 Example
 Print i as long as i is less than 6:
i = 1
while i < 6:
print(i)
i += 1
 Note: remember to increment i, or else the loop will continue
forever.
 The while loop requires relevant variables to be ready, in this
example we need to define an indexing variable, i, which we set
to 1.

 The break Statement
 With the break statement we can stop the loop even if the while
condition is true:
 Example
 Exit the loop when i is 3:
i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1
 The continue Statement
 With the continue statement we can stop the current iteration, and
continue with the next:
 Example
 Continue to the next iteration if i is 3:
i = 0
while i < 6:
i += 1
if i == 3:
continue
print(i)

 The else Statement
 With the else statement we can run a block of code once
when the condition no longer is true:
 Example
 Print a message once the condition is false:
i = 1
while i < 6:
print(i)
i += 1
else:
print("i is no longer less than 6")

PYTHON FOR LOOPS
 Python For Loops
 A for loop is used for iterating over a sequence (that is either a
list, a tuple, a dictionary, a set, or a string).
 This is less like the for keyword in other programming
languages, and works more like an iterator method as found in
other object-orientated programming languages.
 With the for loop we can execute a set of statements, once for
each item in a list, tuple, set etc.
 Example
 Print each fruit in a fruit list:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
print(x)
 The for loop does not require an indexing variable to set
beforehand.

 Looping Through a String
 Even strings are iterable objects, they contain a sequence of
characters:
 Example
 Loop through the letters in the word "banana":
for x in "banana":
print(x)
 The break Statement
 With the break statement we can stop the loop before it has
looped through all the items:
 Example
 Exit the loop when x is "banana":
for x in fruits:
print(x)
if x == "banana":
break

 Example
 Exit the loop when x is "banana", but this time the break
comes before the print:
for x in fruits:
if x == "banana":
break
print(x)
 The continue Statement
 With the continue statement we can stop the current
iteration of the loop, and continue with the next:
 Example
 Do not print banana:
for x in fruits:
if x == "banana":
continue
print(x)

 The range() Function
 To loop through a set of code a specified number of times, we
can use the range() function,
 The range() function returns a sequence of numbers, starting
from 0 by default, and increments by 1 (by default), and ends
at a specified number.
 Example
 Using the range() function:
for x in range(6):
print(x)
 Note that range(6) is not the values of 0 to 6, but the values 0
to 5.
 The range() function defaults to 0 as a starting value, however
it is possible to specify the starting value by adding a
parameter: range(2, 6), which means values from 2 to 6 (but
not including 6):

 Example
 Using the start parameter:
for x in range(2, 6):
print(x)
 The range() function defaults to increment the sequence by 1,
however it is possible to specify the increment value by adding
a third parameter: range(2, 30, 3):
 Example
 Increment the sequence with 3 (default is 1):
for x in range(2, 30, 3):
print(x)
 Else in For Loop
 The else keyword in a for loop specifies a block of code to be executed
when the loop is finished:
 Example
 Print all numbers from 0 to 5, and print a message when the loop has
ended:
for x in range(6):
print(x)
else:
print("Finally finished!")

 Note: The else block will NOT be executed if the loop is
stopped by a break statement.
 Example
 Break the loop when x is 3, and see what happens with
the else block:
for x in range(6):
if x == 3: break
print(x)
else:
print("Finally finished!")
 Nested Loops
 A nested loop is a loop inside a loop.
 The "inner loop" will be executed one time for each iteration of
the "outer loop":

 Example
 Print each adjective for every fruit:
adj = ["red", "big", "tasty"]
for x in adj:
for y in fruits:
print(x, y)
 The pass Statement
 for loops cannot be empty, but if you for some reason have
a for loop with no content, put in the pass statement to avoid
getting an error.
 Example
for x in [0, 1, 2]:
pass

PYTHON FUNCTIONS
 A function is a block of code which only runs when it is called.
 You can pass data, known as parameters, into a function.
 A function can return data as a result.
 Creating a Function
 In Python a function is defined using the def keyword:
 Example
 def my_function():
print("Hello from a function")
 Calling a Function
 To call a function, use the function name followed by parenthesis:
 Example
def my_function():
print("Hello from a function")
my_function()

 Arguments
 Information can be passed into functions as arguments.
 Arguments are specified after the function name, inside the
parentheses. You can add as many arguments as you want,
just separate them with a comma.
 The following example has a function with one argument
(fname). When the function is called, we pass along a first
name, which is used inside the function to print the full name:
 Example
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
 Arguments are often shortened to args in Python
documentations.

 Parameters or Arguments?
 The terms parameter and argument can be used for the same thing:
information that are passed into a function.
 From a function's perspective:
 A parameter is the variable listed inside the parentheses in the
function definition.
 An argument is the value that is sent to the function when it is
called.
 Number of Arguments
 By default, a function must be called with the correct number of
arguments. Meaning that if your function expects 2 arguments, you
have to call the function with 2 arguments, not more, and not less.
 Example
 This function expects 2 arguments, and gets 2 arguments:
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")

 If you try to call the function with 1 or 3 arguments, you will get an
error:Example
 This function expects 2 arguments, but gets only 1:
 def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil")
 Arbitrary Arguments, *args
 If you do not know how many arguments that will be passed into your
function, add a * before the parameter name in the function
definition.
 This way the function will receive a tuple of arguments, and can
access the items accordingly:
 Example
 If the number of arguments is unknown, add a * before the parameter
name:
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
 Arbitrary Arguments are often shortened to *args in Python
documentations.

 Keyword Arguments
 You can also send arguments with the key = value syntax.
 This way the order of the arguments does not matter.
 Example
 def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3= "Linus")
 The phrase Keyword Arguments are often shortened to kwargs in
Python documentations.
 Arbitrary Keyword Arguments, **kwargs
 If you do not know how many keyword arguments that will be passed into
your function, add two asterisk: ** before the parameter name in the
function definition.
 This way the function will receive a dictionary of arguments, and can
access the items accordingly:
 Example
 If the number of keyword arguments is unknown, add a double ** before
the parameter name:
 def my_function(**kid):
print("His last name is " + kid["lname"])
my_function(fname = "Tobias", lname = "Refsnes")
 Arbitrary Kword Arguments are often shortened to **kwargs in
Python documentations.

 Default Parameter Value
 The following example shows how to use a default parameter value.
 If we call the function without argument, it uses the default value:
 Example
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
 Passing a List as an Argument
 You can send any data types of argument to a function (string,
number, list, dictionary etc.), and it will be treated as the same
data type inside the function.
 E.g. if you send a List as an argument, it will still be a List
when it reaches the function:

 Example
def my_function(food):
for x in food:
print(x)
my_function(fruits)
 Return Values
 To let a function return a value, use the return statement:
 Example
def my_function(x):
return 5 * x
print(my_function(3))

 function definitions cannot be empty, but if you for some reason have
a function definition with no content, put in the pass statement to
avoid getting an error.
 Example
 def myfunction():
pass
 Recursion
 Python also accepts function recursion, which means a defined
function can call itself.
 Recursion is a common mathematical and programming concept. It
means that a function calls itself. This has the benefit of meaning that
you can loop through data to reach a result.
 The developer should be very careful with recursion as it can be quite
easy to slip into writing a function which never terminates, or one that
uses excess amounts of memory or processor power. However, when
written correctly recursion can be a very efficient and mathematically-
elegant approach to programming.

 In this example, tri_recursion() is a function that we have
defined to call itself ("recurse"). We use the k variable as the
data, which decrements (-1) every time we recurse. The
recursion ends when the condition is not greater than 0 (i.e.
when it is 0).
 To a new developer it can take some time to work out how
exactly this works, best way to find out is by testing and
modifying it.
 Example
 Recursion Example
def tri_recursion(k):
if(k > 0):
result = k + tri_recursion(k - 1)
print(result)
else:
result = 0
return result
print("nnRecursion Example Results")
tri_recursion(6)

PYTHON - EXCEPTIONS HANDLING
 What is Exception?
 An exception is an event, which occurs during the
execution of a program that disrupts the normal flow of
the program's instructions. In general, when a Python
script encounters a situation that it cannot cope with, it
raises an exception. An exception is a Python object that
represents an error.
 When a Python script raises an exception, it must either
handle the exception immediately otherwise it terminates
and quits.

PYTHON TRY EXCEPT
 The try block lets you test a block of code for errors.
 The except block lets you handle the error.
 The finally block lets you execute code, regardless of the
result of the try- and except blocks.
 Exception Handling
 When an error occurs, or exception as we call it, Python will
normally stop and generate an error message.
 These exceptions can be handled using the try statement:
 Example
 The try block will generate an exception, because x is not
defined:
try:
print(x)
except:
print("An exception occurred")

 Since the try block raises an error, the except block will be
executed.
 Without the try block, the program will crash and raise an
error:
 Example
 This statement will raise an error, because x is not defined:
 print(x)
 Many Exceptions
 You can define as many exception blocks as you want, e.g. if you want
to execute a special block of code for a special kind of error:
 Example
 Print one message if the try block raises a NameError and another for
other errors:
try:
print(x)
except NameError:
print("Variable x is not defined")
except:
print("Something else went wrong")

 Else
 You can use the else keyword to define a block of code to be executed
if no errors were raised:
 Example
 In this example, the try block does not generate any error:
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
 Finally
 The finally block, if specified, will be executed regardless if the try
block raises an error or not.
 Example
try:
print(x)
except:
finally:
print("The 'try except' is finished")

 This can be useful to close objects and clean up resources:
 Example
 Try to open and write to a file that is not writable:
try:
f = open("demofile.txt")
try:
f.write("Lorum Ipsum")
except:
print("Something went wrong when writing to the file")
finally:
f.close()
except:
print("Something went wrong when opening the file")
 The program can continue, without leaving the file object
open.

 Raise an exception
 As a Python developer you can choose to throw an exception if
a condition occurs.
 To throw (or raise) an exception, use the raise keyword.
 Example
 Raise an error and stop the program if x is lower than 0:
x = -1
if x < 0:
raise Exception("Sorry, no numbers below zero")
 The raise keyword is used to raise an exception.
 You can define what kind of error to raise, and the text to print
to the user.
 Example
 Raise a TypeError if x is not an integer:
x = "hello"
if not type(x) is int:
raise TypeError("Only integers are allowed")

Sr.No. Exception Name & Description
1 Exception
Base class for all exceptions
2 StopIteration
Raised when the next() method of an iterator does not point to any object.
3 SystemExit
Raised by the sys.exit() function.
4 StandardError
Base class for all built-in exceptions except StopIteration and SystemExit.
5 ArithmeticError
Base class for all errors that occur for numeric calculation.
6 OverflowError
Raised when a calculation exceeds maximum limit for a numeric type.
7 FloatingPointError
Raised when a floating point calculation fails.
8 ZeroDivisionError
Raised when division or modulo by zero takes place for all numeric types.
9 AssertionError
Raised in case of failure of the Assert statement.
10 AttributeError
Raised in case of failure of attribute reference or assignment.
11 EOFError
Raised when there is no input from either the raw_input() or input() function and the end of file is reached.

12 ImportError
Raised when an import statement fails.
13 KeyboardInterrupt
Raised when the user interrupts program execution, usually by pressing Ctrl+c.
14 LookupError
Base class for all lookup errors.
15 IndexError
Raised when an index is not found in a sequence.
16 KeyError
Raised when the specified key is not found in the dictionary.
17 NameError
Raised when an identifier is not found in the local or global namespace.
18 UnboundLocalError
Raised when trying to access a local variable in a function or method but no value has been assigned
to it.
19 EnvironmentError
Base class for all exceptions that occur outside the Python environment.
20 IOError
Raised when an input/ output operation fails, such as the print statement or the open() function when
trying to open a file that does not exist.
21 IOError
Raised for operating system-related errors.
22 SyntaxError
Raised when there is an error in Python syntax.

23 IndentationError
Raised when indentation is not specified properly.
24 SystemError
Raised when the interpreter finds an internal problem, but when this error is
encountered the Python interpreter does not exit.
25 SystemExit
Raised when Python interpreter is quit by using the sys.exit() function. If not
handled in the code, causes the interpreter to exit.
26 TypeError
Raised when an operation or function is attempted that is invalid for the
specified data type.
27 ValueError
Raised when the built-in function for a data type has the valid type of
arguments, but the arguments have invalid values specified.
28 RuntimeError
Raised when a generated error does not fall into any category.
29 NotImplementedError
Raised when an abstract method that needs to be implemented in an inherited
class is not actually implemented.

NAMESPACES AND SCOPING
 Variables are names (identifiers) that map to objects.
A namespace is a dictionary of variable names (keys) and
their corresponding objects (values).
 A Python statement can access variables in a local
namespace and in the global namespace. If a local and a
global variable have the same name, the local variable
shadows the global variable.
 Each function has its own local namespace. Class methods
follow the same scoping rule as ordinary functions.
 Python makes educated guesses on whether variables are
local or global. It assumes that any variable assigned a
value in a function is local.
 Therefore, in order to assign a value to a global variable
within a function, you must first use the global statement.

 The statement global VarName tells Python that VarName is a global
variable. Python stops searching the local namespace for the variable.
 For example, we define a variable Money in the global namespace.
Within the function Money, we assign Money a value, therefore
Python assumes Money as a local variable. However, we accessed the
value of the local variable Money before setting it, so an
UnboundLocalError is the result. Uncommenting the global
statement fixes the problem
 Python Scope
 A variable is only available from inside the region it is created. This is
called scope.
 Local Scope
 A variable created inside a function belongs to the local scope of that
function, and can only be used inside that function.
 Example
 A variable created inside a function is available inside that function:
def myfunc():
x = 300
print(x)
myfunc()

 Function Inside Function
 As explained in the example above, the variable x is not
available outside the function, but it is available for any
function inside the function:
 Example
 The local variable can be accessed from a function within
the function:
def myfunc():
x = 300
def myinnerfunc():
print(x)
myinnerfunc()
myfunc()

 Global Scope
 A variable created in the main body of the Python code is
a global variable and belongs to the global scope.
 Global variables are available from within any scope,
global and local.
 Example
 A variable created outside of a function is global and can be
used by anyone:
x = 300
def myfunc():
print(x)
myfunc()
print(x)

 Naming Variables
 If you operate with the same variable name inside and outside
of a function, Python will treat them as two separate variables,
one available in the global scope (outside the function) and one
available in the local scope (inside the function):
 Example
 The function will print the local x, and then the code will print
the global x:
x = 300
def myfunc():
x = 200
print(x)
myfunc()
print(x)

 Global Keyword
 If you need to create a global variable, but are stuck in
the local scope, you can use the global keyword.
 The global keyword makes the variable global.
 Example
 If you use the global keyword, the variable belongs to the
global scope:
def myfunc():
global x
x = 300
myfunc()
print(x)
 Also, use the global keyword if you want to make a
change to a global variable inside a function.

PYTHON GENERATORS
 Generators in Python
 There is a lot of work in building an iterator in Python. We have
to implement a class with __iter__() and __next__() method,
keep track of internal states, and raise StopIteration when
there are no values to be returned.
 This is both lengthy and counterintuitive. Generator comes to
the rescue in such situations.
 Python generators are a simple way of creating iterators. All
the work we mentioned above are automatically handled by
generators in Python.
 Simply speaking, a generator is a function that returns an
object (iterator) which we can iterate over (one value at a time).

 Create Generators in Python
 It is fairly simple to create a generator in Python. It is as easy as defining
a normal function, but with a yield statement instead of
a return statement.
 If a function contains at least one yield statement (it may contain
other yield or return statements), it becomes a generator function.
Both yield and return will return some value from a function.
 The difference is that while a return statement terminates a function
entirely, yield statement pauses the function saving all its states and later
continues from there on successive calls.
 Differences between Generator function and Normal function
 Here is how a generator function differs from a normal function.
 Generator function contains one or more yield statements.
 When called, it returns an object (iterator) but does not start execution
immediately.
 Methods like __iter__() and __next__() are implemented automatically. So
we can iterate through the items using next().
 Once the function yields, the function is paused and the control is
transferred to the caller.
 Local variables and their states are remembered between successive calls.
 Finally, when the function terminates, StopIteration is raised
automatically on further calls.

 Here is an example to illustrate all of the points stated
above. We have a generator function named my_gen() with
several yield statements.
 # A simple generator function
def my_gen():
n = 1
print('This is printed first') # Generator function contains
yield statements
yield n
n += 1 print('This is printed second')
yield n
n += 1
print('This is printed at last') yield n

 An interactive run in the interpreter is given below. Run these in the Python shell
to see the output.
>>> # It returns an object but does not start execution immediately.
>>> a = my_gen()
>>> # We can iterate through the items using next().
>>> next(a)
This is printed first
1
>>> # Once the function yields, the function is paused and the control is transferred to
the caller.
>>> # Local variables and theirs states are remembered between successive calls.
>>> next(a)
This is printed second
2
>>> next(a)
This is printed at last
3
>>> # Finally, when the function terminates,
StopIteration is raised automatically on further calls.
>>> next(a)
Traceback (most recent call last):
...
StopIteration
>>> next(a)
...
StopIteration

 Python Generators with a Loop
 The above example is of less use and we studied it just to get an idea of
what was happening in the background.
 Normally, generator functions are implemented with a loop having a
suitable terminating condition.
 Let's take an example of a generator that reverses a string.
def rev_str(my_str):
length = len(my_str)
for i in range(length - 1, -1, -1):
yield my_str[i]
# For loop to reverse the string
for char in rev_str("hello"):
print(char)
Output
O
l
l
e
h

 Python Generator Expression
 Simple generators can be easily created on the fly using
generator expressions. It makes building generators easy.
 Similar to the lambda functions which create anonymous
functions, generator expressions create anonymous generator
functions.
 The syntax for generator expression is similar to that of a list
comprehension in Python. But the square brackets are replaced
with round parentheses.
 The major difference between a list comprehension and a
generator expression is that a list comprehension produces the
entire list while the generator expression produces one item at
a time.
 They have lazy execution ( producing items only when asked
for ). For this reason, a generator expression is much more
memory efficient than an equivalent list comprehension.

 # INITIALIZE THE LIST
my_list = [1, 3, 6, 10]
# square each term using list comprehension
list_ = [x**2 for x in my_list]
# same thing can be done using a generator expression #
generator expressions are surrounded by parenthesis ()
generator = (x**2 for x in my_list)
print(list_)
print(generator)
Output
[1, 9, 36, 100]
<generator object <genexpr> at 0x7f5d4eb4bf50>
 We can see above that the generator expression did not
produce the required result immediately. Instead, it
returned a generator object, which produces items only on
demand.

 Use of Python Generators
 There are several reasons that make generators a powerful
implementation.
 1. Easy to Implement
 Generators can be implemented in a clear and concise way as compared to
their iterator class counterpart.
 2. Memory Efficient
 A normal function to return a sequence will create the entire sequence in
memory before returning the result. This is an overkill, if the number of
items in the sequence is very large.
 Generator implementation of such sequences is memory friendly and is
preferred since it only produces one item at a time.
 3. Represent Infinite Stream
 Generators are excellent mediums to represent an infinite stream of data.
Infinite streams cannot be stored in memory, and since generators
produce only one item at a time, they can represent an infinite stream of
data.
 4. Pipelining Generators
 Multiple generators can be used to pipeline a series of operations. This is
best illustrated using an example.
 Suppose we have a generator that produces the numbers in the Fibonacci
series. And we have another generator for squaring numbers.
 If we want to find out the sum of squares of numbers in the Fibonacci
series, we can do it in the following way by pipelining the output of
generator functions together.

DECORATORS IN PYTHON
 Python has an interesting feature called decorators to add functionality
to an existing code.
 This is also called metaprogramming because a part of the program
tries to modify another part of the program at compile time.
 Getting back to Decorators
 Functions and methods are called callable as they can be called.
 In fact, any object which implements the special __call__() method is termed
callable. So, in the most basic sense, a decorator is a callable that returns a
callable.
 Basically, a decorator takes in a function, adds some functionality and returns it.
def make_pretty(func):
def inner():
print("I got decorated")
func()
return inner
def ordinary():
print("I am ordinary")

 Decorating Functions with Parameters
 The above decorator was simple and it only worked with
functions that did not have any parameters. What if we had
functions that took in parameters like:
def divide(a, b):
return a/b
 This function has two parameters, a and b. We know it will give
an error if we pass in b as 0.
>>> divide(2,5) 0.4
>>> divide(2,0)
...
ZeroDivisionError: division by zero
 Now let's make a decorator to check for this case that will cause
the error.

def smart_divide(func):
def inner(a, b):
print("I am going to divide", a, "and", b)
if b == 0:
print("Whoops! cannot divide")
return
return func(a, b)
return inner
@smart_divide
def divide(a, b):
print(a/b)
 Chaining Decorators in Python
 Multiple decorators can be chained in Python.
 This is to say, a function can be decorated multiple times with different
(or same) decorators. We simply place the decorators above the desired
function.

def star(func):
def inner(*args, **kwargs):
print("*" * 30)
func(*args, **kwargs)
print("*" * 30)
return inner
def percent(func):
def inner(*args, **kwargs):
print("%" * 30)
func(*args, **kwargs)
print("%" * 30)
return inner
@star
@percent
def printer(msg):
print(msg)
printer("Hello")
 Output
******************************
%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%
Hello
%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%
******************************

PYTHON TRY EXCEPT
 The try block lets you test a block of code for errors.
 The except block lets you handle the error.
 The finally block lets you execute code, regardless of the result
of the try- and except blocks.
 Exception Handling
 When an error occurs, or exception as we call it, Python will
normally stop and generate an error message.
 These exceptions can be handled using the try statement:
 Example
 The try block will generate an exception, because x is not
defined:
 try:
print(x)
except:
print("An exception occurred")

 Many Exceptions
 You can define as many exception blocks as you want, e.g. if you
want to execute a special block of code for a special kind of
error:
 Example
 Print one message if the try block raises a NameError and
another for other errors:
 try:
print(x)
except NameError:
print("Variable x is not defined")
except:
 Else
 You can use the else keyword to define a block of code to be
executed if no errors were raised:
 print("Something else went wrong“)

 Example
 In this example, the try block does not generate any error:
 try:
print("Hello")
except:
else:
print("Nothing went wrong")
 Finally
 The finally block, if specified, will be executed regardless if the
try block raises an error or not.
 Example
try:
print(x)
except:
finally:
print("The 'try except' is finished")

 This can be useful to close objects and clean up resources:
 Example
 Try to open and write to a file that is not writable:
try:
f = open("demofile.txt")
try:
f.write("Lorum Ipsum")
except:
print("Something went wrong when writing to the file")
finally:
f.close()
except:
print("Something went wrong when opening the file")
 Raise an exception
 As a Python developer you can choose to throw an exception if a
condition occurs.
 To throw (or raise) an exception, use the raise keyword.

 Example
 Raise an error and stop the program if x is lower than 0:
 x = -1
if x < 0:
raise Exception("Sorry, no numbers below zero")
 The raise keyword is used to raise an exception.
 You can define what kind of error to raise, and the text to
print to the user.
 Example
 Raise a TypeError if x is not an integer:
x = "hello"
if not type(x) is int:
raise TypeError("Only integers are allowed")

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
 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.

Python unit 2 M.sc cs

More Related Content

What's hot

Similar to Python unit 2 M.sc cs

More from KALAISELVI P

Recently uploaded

Python unit 2 M.sc cs