Module 3 Notes

MODULE 3
Conditionals
by
Prathiksha Pai
Boolean expressions
• A Boolean expression is an expression that is either true or false. The following
examples use the operator ==, which compares two operands and produces True if
they are equal and False otherwise:
>>> 5 == 5
True
>>> 5 == 6
False
• True and False are special values that belong to the type bool; they are not strings:
>>> type(True)
<type 'bool'>
>>> type(False)
<type 'bool'>
• The == operator is one of the relational operators; the others are:
• x != y # x is not equal to y
• x > y # x is greater than y
• x < y # x is less than y
• x >= y # x is greater than or equal to y
• x <= y # x is less than or equal to y
• Modulus operator
• The modulus operator works on integers and yields the remainder when the first
operand is divided by the second. In Python, the modulus operator is a percent sign
(%). The syntax is the same as for other operators:
>>> quotient = 7 / 3
>>> print quotient
2
>>> remainder = 7 % 3
>>> print remainder
1
• So 7 divided by 3 is 2 with 1 left over.
There are three logical operators: and, or, and not.
The semantics (meaning) of these operators is similar to their meaning
in English.
For example, x > 0 and x < 10 is true only if x is greater than 0 and less
than 10.
n%2 == 0 or n%3 == 0 is true if either of the conditions is true, that is,
if the number is divisible by 2 or 3.
Conditional statement (if)
• Conditional statements give us the ability to check conditions and
change the behaviour of the program accordingly.
The syntax for if statement:
if <test_expression>:
<body>
• Eg:
num = 3
if num > 0:
print(num, "is a positive number.")
num = -1
if num > 0:
print(num, "is a positive number.")
The boolean expression after if is called the condition. If it is true, then

the indented statement gets executed. If not, nothing happens.
Alternative execution (if… else)
• A second form of the if statement is alternative execution, in which
there are two possibilities and the condition determines which one gets
executed. The syntax looks like this:
if <test_expression>:
<body_1>
else:
<body_2>
• Eg:
#Program checks if the number is positive or negative
num = 3
if num > 0:
print("Positive number")
else:
print("Negative number")
Chained conditionals (if-elif-else)
• Sometimes there are more than two possibilities and we need more
than two branches.
• The syntax looks like this:
if <test_expression_1>:
<body 1>
elif <test_expression_2>:
<body 2>
elif <test_expression_3>:
<body 3>
….
else:
<body N>
#Try these two variations as well:
#num = 0
#num = -4.5
if num > 0:
print("Positive number")
elif num == 0:
print("Zero")
else:
print("Negative number")
Ex 2:
if choice == 'a’:
draw_a()
elif choice == 'b’:
draw_b()
elif choice == 'c’:
draw_c()
Iteration
The while statement
• The keyword while followed by a test expression (which can be any
valid expression), and a colon.
• Following the header is an indented body. The test expression is
evaluated.
• If it evaluates to True, then the body of the loop is executed. After
executing the body, the test expression is evaluated again.
• While test expression evaluates to True, the body of the loop is
executed.
• When the test expression evaluates to False, the loop is terminated and
execution continues with the statement following the body.
• Syntax: while <test_expression>:
<body>
Print n natural numbers
i=1
while(i<=5):
print(i)
i=i+1
Output
5
The for Statement
• Python’s for statement iterates over the items of any sequence (a list or
a string), in the order that they appear in the sequence.
Syntax:
for val in sequence:
Body of for
# Program to find the sum of all numbers stored in a list
#List of numbers
numbers = [6, 5, 3, 8, 4, 2, 5, 4, 11]
sum = 0 #variable to store the sum
for val in numbers: #iterate over the list
sum = sum+val
print("The sum is", sum)
Output: The sum is 48

The range() function
• If you do need to iterate over a sequence of numbers, the built-in
function range() comes in handy. It generates arithmetic progressions:
• Print n natural numbers

for i in range(1,5,1):
print(i)
Output
1234
Python break and continue
Break:
• The break statement terminates the loop containing it. Control of the
program flows to the statement immediately after the body of the loop.
• If break statement is inside a nested loop (loop inside another loop),

break will terminate the innermost loop.
• The working of break statement in for loop and while loop is shown
below.
Eg:
for val in “string”:
if val == “i”:
break
print(val)
Print(“the end”)
Output: s
t
r
the end
Continue:
• The continue statement is used to skip the rest of the

code inside a loop for the current iteration only. Loop
does not terminate but continues on with the next
iteration.
• The working of continue statement in for and while
loop is shown below.
Ex:
for val in “string”:
if val == “i”:
continue
print(val)
Print(“the end”)
Output: s
t
r
n
g
the end
Pass:
• In Python programming, the pass statement is a null statement.
The difference between a comment and a pass statement in
Python is that while the interpreter ignores a comment entirely,
pass is not ignored.
• However, nothing happens when the pass is executed. It results
in no operation.
• Syntax:
pass
Suppose we have a loop or a function that is not implemented
yet, but we want to implement it in the future. They cannot have
an empty body. The interpreter would give an error. So, we use
the pass statement to construct a body that does nothing.
Example 1:
Sequence={‘p’, ’a’, ’s’, ’s’}
for val in sequence:
pass
Example 2:
while True:
pass
Example 3:
def function():
pass
FRUITFUL FUNCTIONS
Return values
• The built-in functions we have used, such as abs, pow, and max, have
produced results.
• Calling each of these functions generates a value,
which we usually assign to a variable or use as part of an expression.
biggest = max(3, 7, 2, 5)
x = abs(3 - 11) + 10
But so far, none of the functions we have written has returned a value.
In this chapter, we are going to write functions that return values, which
we will call fruitful functions
def area(radius):
temp = 3.14159 * radius**2
return temp
• We have seen the return statement before, but in a fruitful function the
return statement includes a return value.
• This statement means: Return immediately from this function and use
the following expression as a return value.
• The expression provided can be arbitrarily complicated, so
we could have written this function more concisely:
def area(radius):
return 3.14159 * radius**2
• We have already seen the built-in abs, now we see how to write our
own:
def absolute_value(x):
if x < 0:
return -x
else:
return x
• Since these return statements are in an alternative conditional, only
one will be executed. As soon as one is executed, the function
terminates without executing any subsequent statements.
• Another way to write the above function is to leave out the else and
just follow the if condition by the second return statement.
def absolute_value(x):
if x < 0:
return -x
return x
• Think about this version and convince yourself it works the same as
the first one.
• Code that appears after a return statement, or any other place the flow
of execution can never reach, is called dead code.
Scope and Lifetime of variables
• Scope of a variable is the portion of a program where
the variable is recognized. Parameters and variables
defined inside a function is not visible from outside.
Hence, they have a local scope.
• Lifetime of a variable is the period throughout which

the variable exits in the memory.
• The lifetime of variables inside a function is as long as
the function executes.
• They are destroyed once we return from the function.

Hence, a function does not remember the value of a
variable from its previous calls.
• Eg:
def my_func():
x = 10
print("Value inside function:",x)
x = 20
my_func()
print("Value outside function:",x)
• Output:
• Value inside function: 10
• Value outside function: 20
Local Variables and Local Scope
• A local variable is a variable that is only accessible from
within a given function. Such variables are said to have local
scope.
Global Variables and Global Scope
• A global variable is a variable that is defined outside of any
function definition. Such variables are said to have global
scope.
Variable max is defined outside func1 and func2 and therefore “global” to each.
Function Composition
• As you should expect by now, you can call one function from
within another. This ability is called composition.
• As an example, we’ll write a function that takes two points,
The center of the circle and a point on the perimeter, and
computes the area of the circle.
• Assume that the center point is stored in the variables xc and
yc, and the perimeter point is in xp and yp. The first step is to
find the radius of the circle, which is the distance between the
two points. Fortunately, we’ve just written a function,
distance, that does just that, so now all we have to do is use it:
radius = distance(xc, yc, xp, yp)

• The second step is to find the area of a circle with that radius
and return it. Again we will use one of our earlier functions:
result = area(radius)
• return result Wrapping that up in a function, we get:

def area2(xc, yc, xp, yp):
radius = distance(xc, yc, xp, yp)
result = area(radius) return result
• We called this function area2 to distinguish it from the area
function defined earlier. There can only be one function with a
given name within a given module.
• The temporary variables radius and result are useful for
development and debugging, but once the program is working,
we can make it more concise by composing the function calls:
def area2(xc, yc, xp, yp):

return area(distance(xc, yc, xp, yp))
Recursion
• Recursion is the process of calling the function that is currently

executing. It is legal for one function to call another; it is also legal for
a function to call itself. An example of recursive function to find the
factorial of an integer.
Note: Refer factorial of number using recursion from module 1

The Advantages of recursion
 Recursive functions make the code look clean and elegant.
 A complex task can be broken down into simpler sub-problems
using recursion.
 Sequence generation is easier with recursion than using some
nested iteration.
The Disadvantages of recursion

 Sometimes the logic behind recursion is hard to follow through.
 Recursive calls are expensive (inefficient) as they take up a lot of
memory and time.
 Recursive functions are hard to debug.
STRINGS
• A string is a sequence of characters. You can access the characters
one at a time with the bracket operator:
>>>fruit = ‘apple'
>>>letter = fruit[1]
• The second statement selects character number 1 from fruit and

assigns it to letter. The expression in brackets is called an index. The
index indicates which character in the sequence you want (hence the
name).
>>>print letter
p
• For most people, the first letter of ‘apple' is a, not p. But for computer
scientists, the index is an offset from the beginning of the string, and
the offset of the first letter is zero.
>>>letter = fruit[0]
>>>print letter
a
• So a is the 0th letter (“zero-eth”) of ‘apple’, p is the 1th letter (“one

-eth”), and n is the 2th(“two-eth”) letter.
• You can use any expression, including variables and operators, as an
index, but the value of the index has to be an integer. Otherwise you
get:
>>> letter = fruit[1.5]
• TypeError: string indices must be integers, not float

String slices
• A segment of a string is called a slice. Selecting a slice is similar to
selecting a character:
>>> s = 'Monty Python'
>>> print s[0:5]
Monty
print s[6:12]
Python
• The operator [n:m] returns the part of the string from the “n-eth” character to the “m-eth” character,
including the first but excluding the last. This behaviour is counter intuitive, but it might help to imagine the
indices pointing between the characters
• If you omit the first index (before the colon), the slice starts at the
beginning of the string.
• If you omit the second index, the slice goes to the end of the string:
>>> fruit = ‘apple'
>>> fruit[:3]
‘app'
>>> fruit[2:]
‘ple’
• If the first index is greater than or equal to the second the result is
an empty string, represented by two quotation marks:
>>> fruit = ‘apple'
fruit[2:2]
• An empty string contains no characters and has length 0, but other
than that, it is the same as any other string.
Strings are immutable
• It is tempting to use the [] operator on the left side of an assignment,
with the intention of changing a character in a string. For example:
>>> greeting = 'Hello, world!'
>>> greeting[0] = 'J'
TypeError: 'str' object does not support item assignment
The reason for the error is that strings are immutable, which means
you can’t change an existing string. The best you can do is create a new
string that is a variation on the original:
>>> greeting = 'Hello, world!'
>>> new_greeting = 'J' + greeting[1:]
>>> print new_greeting
Jello, world!
• This example concatenates a new first letter onto a slice of greeting. It

has no effect on the original string.
String functions and methods
len
• len is a built-in function that returns the number of characters in a string:
>>>fruit = ‘apple'
>>>len(fruit)
5
• To get the last character, you have to subtract 1 from length:
>>> last = fruit[length-1]

>>> print last
e
• Alternatively, you can use negative indices, which count backward
from the end of the string. The expression fruit[-1] yields the last letter,
fruit[-2] yields the second to last, and so on.
String methods
• A method is similar to a function—it takes arguments and returns a
value—but the syntax is different. For example, the method upper takes
a string and returns a new string with all uppercase letters:
• Instead of the function syntax upper(word), it uses the method syntax
word.upper()
>>> word = ‘apple'
>>> new_word = word.upper()
>>> print new_word
APPLE
• This form of dot notation specifies the name of the method, upper, and
the name of the string to apply the method to, word. The empty
parentheses indicate that this method takes no argument.
• A method call is called an invocation; in this case, we would say that
we are invoking upper on the word.
• As it turns out, there is a string method named find that is remarkably
similar to the function we wrote:
>>> word = ‘coin'

>>> index = word.find(‘o')
>>> print index
1
• In this example, we invoke find on word and pass the letter we are
looking for as a parameter.
• Actually, the find method is more general than our function; it can find
substrings, not just characters:
>>> word.find(‘pl')
2
• It can take as a second argument the index where it should start:
>>> word.find(‘le’, 2)
3
• And as a third argument the index where it should stop:
>>> name = 'bob'
>>> name.find('b', 1, 2)
• This search fails because b does not appear in the index range from 1 to 2
(not including 2).
String module
• String module contains a number of functions to process
standard python strings
• Mostly used string modules:
string.upper()
string.lower()
string.split()
string.join()
string.replace()
string.find()
string.count()
Lists as array:
• Lists can be converted to arrays using built in functions in
python numpy library.
• Numpy provides us with 2 functions to use when converting
a list into an array.
1. numpy.array()
2. numpy.asarray()
1. numpy.array()
This function of the numpy library takes a list as an argument & returns
an array that contains all the elements of the list.
Import numpy as np
my_list = [2,4,6,8,10]
my_array = np.array(my_list)
print my_array
print type (my_array)
Output: [2 4 6 8 10]
<type ‘numpy.ndarray’>
2. numpy.asarray()
This function calls the numpy.array() function inside itself.
Import numpy as np
my_list = [2,4,6,8,10]
my_array = np.asarray(my_list)
print my_array
print type (my_array)
Output: [2 4 6 8 10]
<type ‘numpy.ndarray’>
Main difference is that:
• np.array (): It would create a copy of the object array (with
default
parameter).
• np.asarray(): It would reflect changes in original array.
Illustrative Programs
1. Square root
num=float(input(“enter the number:”))
num_sqrt= num ** 0.5
print(“the square root of %0.3f is %0.3f”, %(num, num_sqrt))
Output: the square root of 25.000 is 5.000

2. GCD (HCF)
def hcf(x,y):
if x>y:
smaller=y
else:
smaller=x
for i in range(1, smaller+1):
if((x%i==0)and(y%i==0):
hcf=i
return hcf
num1=int(input(“enter first number”))
num2=int(input(“enter second number”))
Print(“hcf of”, num1, “and”, num2, “is”, hcf(num1,num2))
Output: hcf of 12 and 33 is 3
Output: hcf of 48 and 60 is 12

3. Exponentiation
num= int(input(“enter a number”))
exp=int(input(“enter exponential value:”))
result= num**exp
Print(“result is:”, result)
Output:
num=2
exp=3
result is 8
4. Sum of array of numbers
arr=[1,3,3,4,5]
sum=0
for i in range(0,len(arr)):
sum=sum+arr[i]:
print(“sum of all the elements of an array:”, sum)
Output: sum of all the elements of an array: 16

5. Linear search
num=int(input("enter length"))
list=[int(input())for i in range(num)]
key=int(input("enter the key element:"))
def search(list,key):
for i in range(len(list)):
if key==list[i]:
print("key is found at index:",i)
break
else:
print("element is not found")
search(list,key)
6. Binary search
num=int(input("enter length"))
list=[int(input())for i in range(num)]
key=int(input("enter the key element:"))
def BinarySearch(list, key):
low=0
high=len(list)-1
Found=False
while low<=high and not Found:
mid=(low+high)//2
if key==list[mid]:
Found=True
elif key>list[mid]:
low=mid+1
else:
high=mid-1
if Found==True:
print("key is found")
else:
print("key not found")

Module 3 Notes

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Module 3 Notes

Uploaded by

Copyright:

Available Formats

MODULE 3

The boolean expression after if is called the condition. If it is true, then

Output: The sum is 48

• Print n natural numbers

• If break statement is inside a nested loop (loop inside another loop),

• The continue statement is used to skip the rest of the

• Lifetime of a variable is the period throughout which

• They are destroyed once we return from the function.

radius = distance(xc, yc, xp, yp)

• return result Wrapping that up in a function, we get:

def area2(xc, yc, xp, yp):

• Recursion is the process of calling the function that is currently

Note: Refer factorial of number using recursion from module 1

The Disadvantages of recursion

• The second statement selects character number 1 from fruit and

• So a is the 0th letter (“zero-eth”) of ‘apple’, p is the 1th letter (“one

• TypeError: string indices must be integers, not float

• This example concatenates a new first letter onto a slice of greeting. It

>>> last = fruit[length-1]

>>> word = ‘coin'

Output: the square root of 25.000 is 5.000

Output: hcf of 48 and 60 is 12

Output: sum of all the elements of an array: 16

You might also like