Unit 2 Notes – Python Programming

What is a function in Python?

In Python, a function is a group of related statements that performs a specific task.

Functions help break our program into smaller and modular chunks. As our program grows
larger and larger, functions make it more organized and manageable.

Furthermore, it avoids repetition and makes the code reusable.

A function can be defined as the organized block of reusable code, which can be called whenever required.

Python allows us to divide a large program into the basic building blocks known as a function.

Python provide us various inbuilt functions like range() or print(). Although, the user can create its functions,
which can be called user-defined functions.

Advantage of Functions in Python

There are the following advantages of Python functions.

o Using functions, we can avoid rewriting the same logic/code again and again in a program.
o We can call Python functions multiple times in a program and anywhere in a program.
o We can track a large Python program easily when it is divided into multiple functions.
o Reusability is the main achievement of Python functions.
o However, Function calling is always overhead in a Python program.

There are mainly two types of functions.

o User-define functions - The user-defined functions are those define by the user to perform the
specific task.
o Built-in functions - The built-in functions are those functions that are pre-defined in Python.

Python Built-in Functions

The Python built-in functions are defined as the functions whose functionality is pre-defined in Python.

Python abs() Function

The python abs() function is used to return the absolute value of a number. It takes only one argument, a
number whose absolute value is to be returned. The argument can be an integer and floating-point number. If
the argument is a complex number, then, abs() returns its magnitude.
 Python abs() Function Example

# integer number
integer = -20
print('Absolute value of -40 is:', abs(integer))

Output:

Absolute value of -20 is: 20

Python min() Function

Python min() function is used to get the smallest element from the collection. This function takes two
arguments, first is a collection of elements and second is key, and returns the smallest element from the
collection.

Python min() Function Example

# Calling function
small = min(2225,325,2025) # returns smallest element
# Displaying result
print(small)

Output:

325

Python pow() Function

Python pow() function is used to compute the powers of a number. It returns x to the power of y modulus z if a
third argument(z) is present, i.e. (x, y) % z.

Signature
1. pow(x, y, z)

Parameters
x: It is a number, a base

y: It is a number, an exponent.

z (optional): It is a number and the modulus.

Python pow() Function Example 1:

 The below example shows the working of pow().

# positive x, positive y (x**y)

print(pow(4, 2))

Output:

16

Python divmod() Function

Python divmod() function is used to get remainder and quotient of two numbers. This function takes two
numeric arguments and returns a tuple. Both arguments are required and numeric. This function has the
following syntax.

Signature
divmod (number1, number2)

# Python divmod() function example

# Calling function
result = divmod(10,2)
# Displaying result
print(result)

Output:

(5, 0)
1.

Python len() Function

The python len() function is used to return the length (the number of items) of an object.

Python len() Function Example

str = 'Python'
print(len(str))

Output:

6
 Creating a Function

Python provides the def keyword to define the function. The syntax of the define function is given below.

Syntax:

def my_function(parameters):
function_block
return expression

Let's understand the syntax of functions definition.

o The def keyword, along with the function name is used to define the function.
o The identifier rule must follow the function name.
o A function accepts the parameter (argument), and they can be optional.
o The function block is started with the colon (:), and block statements must be at the same indentation.
o The return statement is used to return the value. A function can have only one return

Function Calling

In Python, after the function is created, we can call it from another function. A function must be defined before
the function call; otherwise, the Python interpreter gives an error. To call the function, use the function name
followed by the parentheses.

Consider the following example of a simple example that prints the message "Hello World".

#function definition
def hello_world():
print("hello world")
# function calling
hello_world()

Output:

hello world

The return statement

The return statement is used at the end of the function and returns the result of the function. It terminates the
function execution and transfers the result where the function is called. The return statement cannot be used
outside of the function.

Syntax

1. return [expression_list]
 It can contain the expression which gets evaluated and value is returned to the caller function. If the return
statement has no expression or does not exist itself in the function then it returns the None object.

Consider the following example:

Example 1

# Defining function
def sum():
a = 10
b = 20
c = a+b
return c
# calling sum() function in print statement
print("The sum is:",sum())

Output:

The sum is: 30

In the above code, we have defined the function named sum, and it has a statement c = a+b, which computes
the given values, and the result is returned by the return statement to the caller function.

Example 2 Creating function without return statement

# Defining function
def sum():
a = 10
b = 20
c = a+b
# calling sum() function in print statement
print(sum())

Output:

None

In the above code, we have defined the same function without the return statement as we can see that
the sum() function returned the None object to the caller function.

Arguments in function
The arguments are types of information which can be passed into the function. The arguments are specified in
the parentheses. We can pass any number of arguments, but they must be separate them with a comma.

Consider the following example, which contains a function that accepts a string as the argument.
 Example 1

#defining the function

def func (name):
print("Hi ",name)
#calling the function
func("Devansh")

Output:

Hi Devansh

Example 2

#Python function to calculate the sum of two variables

#defining the function
def sum (a,b):
return a+b;

#taking values from the user

a = int(input("Enter a: "))
b = int(input("Enter b: "))

#printing the sum of a and b

print("Sum = ",sum(a,b))

Default Arguments
Python allows us to initialize the arguments at the function definition. If the value of any of the arguments is
not provided at the time of function call, then that argument can be initialized with the value given in the
definition even if the argument is not specified at the function call.

Example 1

def printme(name,age=22):
print("My name is",name,"and age is",age)
printme(name = "john")

Output:

My name is John and age is 22

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")

The youngest child is Linus

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)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

Python Recursive Function

In Python, we know that a function can call other functions. It is even possible for the function to
call itself. These types of construct are termed as recursive functions.

The following image shows the working of a recursive function called recurse.
 Recursive Function in Python

Following is an example of a recursive function to find the factorial of an integer.

Factorial of a number is the product of all the integers from 1 to that number. For example, the
factorial of 6 (denoted as 6!) is 1*2*3*4*5*6 = 720.

Example of a recursive function

def factorial(x):
"""This is a recursive function
to find the factorial of an integer"""

if x == 1:
return 1
else:
return (x * factorial(x-1))

num = 3
print("The factorial of", num, "is", factorial(num))

Output

The factorial of 3 is 6

In the above example, factorial() is a recursive function as it calls itself.

When we call this function with a positive integer, it will recursively call itself by decreasing the
number.

Each function multiplies the number with the factorial of the number below it until it is equal to
one. This recursive call can be explained in the following steps.

factorial(3) # 1st call with 3

3 * factorial(2) # 2nd call with 2
3 * 2 * factorial(1) # 3rd call with 1
3 * 2 * 1 # return from 3rd call as number=1
3 * 2 # return from 2nd call
6 # return from 1st call
Scope of variables
The scopes of the variables depend upon the location where the variable is being declared. The variable
declared in one part of the program may not be accessible to the other parts.

In python, the variables are defined with the two types of scopes.

1. Global variables
2. Local variables

The variable defined outside any function is known to have a global scope, whereas the variable defined inside
a function is known to have a local scope.

Global Variables
In Python, a variable declared outside of the function or in global scope is known as a global
variable. This means that a global variable can be accessed inside or outside of the function.

Let's see an example of how a global variable is created in Python.

Example 1: Create a Global Variable

x = "global"

def foo():
print("x inside:", x)

foo()
print("x outside:", x)

Output

x inside: global
x outside: global

In the above code, we created x as a global variable and defined a foo() to print the global
variable x. Finally, we call the foo() which will print the value of x.

Example 3: Create a Local Variable

Normally, we declare a variable inside the function to create a local variable.

def foo():
y = "local"
print(y)

foo()
 Output

local

Python Lambda Functions

Python Lambda function is known as the anonymous function that is defined without a name. Python allows us
to not declare the function in the standard manner, i.e., by using the def keyword. Rather, the anonymous
functions are declared by using the lambda keyword. However, Lambda functions can accept any number of
arguments, but they can return only one value in the form of expression.

A lambda function is a small anonymous function.

A lambda function can take any number of arguments, but can only have one expression.

The syntax to define an anonymous function is given below.

Syntax

1. lambda arguments: expression

It can accept any number of arguments and has only one expression. It is useful when the function objects are
required.

Consider the following example of the lambda function.

Example 1

# a is an argument and a+10 is an expression which got evaluated and returned.

x = lambda a:a+10
# Here we are printing the function object
print(x)
print("sum = ",x(20))

Output:

<function <lambda> at 0x0000019E285D16A8>

sum = 30

Lambda functions can take any number of arguments:

Example
Multiply argument a with argument b and return the result:

x = lambda a, b : a * b
print(x(5, 6))
output:

30

1.Write a python program using function to find the sum of first 'n' even numbers and print the result.

# Python3 implementation to find sum of

# first n even numbers

# function to find sum of

# first n even numbers
def evensum(n):
curr = 2
sum = 0
i = 1

# sum of first n even numbers

while i <= n:
sum += curr

# next even number

curr += 2
i = i + 1
return sum

# Driver Code
n = 20
print("sum of first ", n, "even number is: ",
evensum(n))

2.Determine the area of a circle using function.

#program to find area of circle using functions

import math

#Function that calculates area of circle

def area_of_circle(r):
a = r**2 * math.pi
return a

r = float(input("Enter the radius of the circle: "))

print("%.2f" %area_of_circle(r))
 Python String
Python string is the collection of the characters surrounded by single quotes, double quotes, or triple quotes.

'hello' is the same as "hello".

Consider the following example in Python to create a string.

Syntax:

1. str = "Hi Python !"

Creating String in Python

We can create a string by enclosing the characters in single-quotes or double- quotes. Python also provides
triple-quotes to represent the string, but it is generally used for multiline string or docstrings.

#Using single quotes

str1 = 'Hello Python'
print(str1)
#Using double quotes
str2 = "Hello Python"
print(str2)

#Using triple quotes

str3 = '''''Triple quotes are generally used for
represent the multiline or
docstring'''
print(str3)

Output:

Hello Python
Hello Python
Triple quotes are generally used for
represent the multiline or
docstring

Strings indexing and slicing

Like other languages, the indexing of the Python strings starts from 0. For example, The string "HELLO" is
indexed as given in the below figure.
Consider the following example:

str = "HELLO"
print(str[0])
print(str[1])
print(str[2])
print(str[3])
print(str[4])
# It returns the IndexError because 6th index doesn't exist
print(str[6])

Output:

H
E
L
L
O
IndexError: string index out of range

As shown in Python, the slice operator [] is used to access the individual characters of the string. However, we
can use the : (colon) operator in Python to access the substring from the given string. Consider the following
example.
 String Operators

Operator Description

+ It is known as concatenation operator used to join the strings given either side of the
operator.

* It is known as repetition operator. It concatenates the multiple copies of the same string.

[] It is known as slice operator. It is used to access the sub-strings of a particular string.

[:] It is known as range slice operator. It is used to access the characters from the specified
range.

in It is known as membership operator. It returns if a particular sub-string is present in the

specified string.

not in It is also a membership operator and does the exact reverse of in. It returns true if a
particular substring is not present in the specified string.

r/R It is used to specify the raw string. Raw strings are used in the cases where we need to
print the actual meaning of escape characters such as "C://python". To define any string as
a raw string, the character r or R is followed by the string.

% It is used to perform string formatting. It makes use of the format specifiers used in C
programming like %d or %f to map their values in python. We will discuss how formatting
is done in python.
Example

Consider the following example to understand the real use of Python operators.

str = "Hello"
str1 = " world"
print(str*3) # prints HelloHelloHello
print(str+str1)# prints Hello world
print(str[4]) # prints o
print(str[2:4]); # prints ll
print('w' in str) # prints false as w is not present in str
print('wo' not in str1) # prints false as wo is present in str1.
print(r'C://python37') # prints C://python37 as it is written
print("The string str : %s"%(str)) # prints The string str : Hello

Output:

HelloHelloHello
Hello world
o
ll
False
False
C://python37
The string str : Hello

Python String functions

Python provides various in-built functions that are used for string handling. Many String fun

Method Description

capitalize() It capitalizes the first character of the String. This function is

deprecated in python3

casefold() It returns a version of s suitable for case-less comparisons.

center(width ,fillchar) It returns a space padded string with the original string centred
with equal number of left and right spaces.

count(string,begin,end) It counts the number of occurrences of a substring in a String

between begin and end index.
decode(encoding = 'UTF8', errors = Decodes the string using codec registered for encoding.
'strict')

encode() Encode S using the codec registered for encoding. Default

encoding is 'utf-8'.

endswith(suffix It returns a Boolean value if the string terminates with given suffix
,begin=0,end=len(string)) between begin and end.

expandtabs(tabsize = 8) It defines tabs in string to multiple spaces. The default space value
is 8.

find(substring ,beginIndex, It returns the index value of the string where substring is found
endIndex) between begin index and end index.

format(value) It returns a formatted version of S, using the passed value.

index(subsring, beginIndex, It throws an exception if string is not found. It works same as

endIndex) find() method.

isalnum() It returns true if the characters in the string are alphanumeric i.e.,
alphabets or numbers and there is at least 1 character. Otherwise,
it returns false.

isalpha() It returns true if all the characters are alphabets and there is at
least one character, otherwise False.

isdecimal() It returns true if all the characters of the string are decimals.

isdigit() It returns true if all the characters are digits and there is at least
one character, otherwise False.

isidentifier() It returns true if the string is the valid identifier.

islower() It returns true if the characters of a string are in lower case,

otherwise false.

isnumeric() It returns true if the string contains only numeric characters.

isprintable() It returns true if all the characters of s are printable or s is empty,
false otherwise.

isupper() It returns false if characters of a string are in Upper case,

otherwise False.

isspace() It returns true if the characters of a string are white-space,

otherwise false.

istitle() It returns true if the string is titled properly and false otherwise. A
title string is the one in which the first character is upper-case
whereas the other characters are lower-case.

isupper() It returns true if all the characters of the string(if exists) is true
otherwise it returns false.

join(seq) It merges the strings representation of the given sequence.

len(string) It returns the length of a string.

ljust(width[,fillchar]) It returns the space padded strings with the original string left
justified to the given width.

lower() It converts all the characters of a string to Lower case.

lstrip() It removes all leading whitespaces of a string and can also be

used to remove particular character from leading.

partition() It searches for the separator sep in S, and returns the part before
it, the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.

maketrans() It returns a translation table to be used in translate function.

replace(old,new[,count]) It replaces the old sequence of characters with the new sequence.
The max characters are replaced if max is given.

rfind(str,beg=0,end=len(str)) It is similar to find but it traverses the string in backward direction.

rindex(str,beg=0,end=len(str)) It is same as index but it traverses the string in backward
direction.

rjust(width,[,fillchar]) Returns a space padded string having original string right justified
to the number of characters specified.

rstrip() It removes all trailing whitespace of a string and can also be used
to remove particular character from trailing.

rsplit(sep=None, maxsplit = -1) It is same as split() but it processes the string from the backward
direction. It returns the list of words in the string. If Separator is
not specified then the string splits according to the white-space.

split(str,num=string.count(str)) Splits the string according to the delimiter str. The string splits
according to the space if the delimiter is not provided. It returns
the list of substring concatenated with the delimiter.

splitlines(num=string.count('\n')) It returns the list of strings at each line with newline removed.

startswith(str,beg=0,end=len(str)) It returns a Boolean value if the string starts with given str
between begin and end.

strip([chars]) It is used to perform lstrip() and rstrip() on the string.

swapcase() It inverts case of all characters in a string.

title() It is used to convert the string into the title-case i.e., The
string meEruT will be converted to Meerut.

translate(table,deletechars = '') It translates the string according to the translation table passed in
the function .

upper() It converts all the characters of a string to Upper Case.

zfill(width) Returns original string leftpadded with zeros to a total of width

characters; intended for numbers, zfill() retains any sign given (less
one zero).
 Python String capitalize() Method
Python capitalize() method converts first character of the string into uppercase without altering the whole
string. It changes the first character only and skips rest of the string unchanged.

Signature
1. capitalize()
2. # Python capitalize() function example
3. # Variable declaration
4. str = "java"
5. # Calling function
6. str2 = str.capitalize()
7. # Displaying result
8. print("Old value:", str)
9. print("New value:", str2)
Output:

Old value: java

New value: Java

2.upper()

The upper() method returns a string where all characters are in upper case.

Symbols and Numbers are ignored.

Syntax
string.upper()

txt = "Hello"

x = txt.upper()

print(x)

output:

HELLO

3.Python String lower() Method

The lower() method returns a string where all characters are lower case.
Symbols and Numbers are ignored.

Syntax
string.lower()
txt = "PYTHON"

x = txt.lower()

print(x)

output:python

4.Python String len() Method

len() function is an inbuilt function in Python programming language that returns the length of the
string.
Syntax:
len(string)
string = "python"
print(len(string))

5.Python String replace() Method

The replace() method replaces a specified phrase with another specified phrase.

Syntax
string.replace(oldvalue, newvalue, count)

Example
Replace the word "bananas":

txt = "java is scripting language"

x = txt.replace("java", "python")

print(x)