Python Dictionary

Python Dictionary is used to store the data in a key-value pair format. The dictionary is the
data type in Python, which can simulate the real-life data arrangement where some specific
value exists for some particular key. It is the mutable data-structure. The dictionary is defined
into element Keys and values.

o Keys must be a single element

o Value can be any type such as list, tuple, integer, etc.

In other words, we can say that a dictionary is the collection of key-value pairs where the
value can be any Python object. In contrast, the keys are the immutable Python object, i.e.,
Numbers, string, or tuple.

Creating the dictionary

The dictionary can be created by using multiple key-value pairs enclosed with the curly
brackets {}, and each key is separated from its value by the colon (:).The syntax to define the
dictionary is given below.

Syntax:

1. Dict = {"Name": "Tom", "Age": 22}

In the above dictionary Dict, The keys Name and Age are the string that is an immutable
object.

Let's see an example to create a dictionary and print its content.

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

print(type(Employee))
print("printing Employee data .... ")
print(Employee)

Output

<class 'dict'>
Printing Employee data ....
{'Name': 'John', 'Age': 29, 'salary': 25000, 'Company': 'GOOGLE'}

Python provides the built-in function dict() method which is also used to create dictionary.
The empty curly braces {} is used to create empty dictionary.

# Creating an empty Dictionary

Dict = {}
print("Empty Dictionary: ")
print(Dict)

# Creating a Dictionary
# with dict() method
Dict = dict({1: 'PEG', 2: 'A', 3:'SUS'})
print("\nCreate Dictionary by using dict(): ")
print(Dict)

# Creating a Dictionary
# with each item as a Pair
Dict = dict([(1, 'Devansh'), (2, 'Sharma')])
print("\nDictionary with each item as a pair: ")
print(Dict)

Output:

Empty Dictionary:
{}

Create Dictionary by using dict():

{1: 'PEG, 2: 'A', 3: 'SUS'}

Dictionary with each item as a pair:

{1: 'Devansh', 2: 'Sharma'}

Accessing the dictionary values

We have discussed how the data can be accessed in the list and tuple by using the indexing.

However, the values can be accessed in the dictionary by using the keys as keys are unique in
the dictionary.

The dictionary values can be accessed in the following way.

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

print(type(Employee))
print("printing Employee data .... ")
print("Name : %s" %Employee["Name"])
print("Age : %d" %Employee["Age"])
print("Salary : %d" %Employee["salary"])
print("Company : %s" %Employee["Company"])

Output:
<class 'dict'>
printing Employee data ....
Name : John
Age : 29
Salary : 25000
Company : GOOGLE

Python provides us with an alternative to use the get() method to access the dictionary values.
It would give the same result as given by the indexing.

Adding dictionary values

The dictionary is a mutable data type, and its values can be updated by using the specific
keys. The value can be updated along with key Dict[key] = value. The update() method is
also used to update an existing value.

Note: If the key-value already present in the dictionary, the value gets updated. Otherwise,
the new keys added in the dictionary.

Let's see an example to update the dictionary values.

Example - 1:

# Creating an empty Dictionary

Dict = {}
print("Empty Dictionary: ")
print(Dict)

# Adding elements to dictionary one at a time

Dict[0] = 'Peter'
Dict[2] = 'Joseph'
Dict[3] = 'Ricky'
print("\nDictionary after adding 3 elements: ")
print(Dict)

# Adding set of values

# with a single Key
# The Emp_ages doesn't exist to dictionary
Dict['Emp_ages'] = 20, 33, 24
print("\nDictionary after adding 3 elements: ")
print(Dict)

# Updating existing Key's Value

Dict[3] = 'pythonpoint'
• print("\nUpdated key value: ")
• print(Dict)

Output:

Empty Dictionary:
{}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky'}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky', 'Emp_ages': (20, 33, 24)}

Updated key value:

{0: 'Peter', 2: 'Joseph', 3: 'pythonpoint', 'Emp_ages': (20, 33, 24)}

Example - 2:

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

print(type(Employee))
print("printing Employee data .... ")
print(Employee)
print("Enter the details of the new employee....");
Employee["Name"] = input("Name: ");
Employee["Age"] = int(input("Age: "));
Employee["salary"] = int(input("Salary: "));
Employee["Company"] = input("Company:");
print("printing the new data");
print(Employee)

Output:

Empty Dictionary:
{}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky'}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky', 'Emp_ages': (20, 33, 24)}

Updated key value:

{0: 'Peter', 2: 'Joseph', 3: 'PythonPoint', 'Emp_ages': (20, 33, 24)}
Deleting elements using del keyword

The items of the dictionary can be deleted by using the del keyword as given below.

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

print(type(Employee))
print("printing Employee data .... ")
print(Employee)
print("Deleting some of the employee data")
del Employee["Name"]
del Employee["Company"]
print("printing the modified information ")
print(Employee)
print("Deleting the dictionary: Employee");
del Employee
print("Lets try to print it again ");
print(Employee)

Output:

<class 'dict'>
printing Employee data ....
{'Name': 'John', 'Age': 29, 'salary': 25000, 'Company': 'GOOGLE'}
Deleting some of the employee data
printing the modified information
{'Age': 29, 'salary': 25000}
Deleting the dictionary: Employee
Lets try to print it again
NameError: name 'Employee' is not defined

The last print statement in the above code, it raised an error because we tried to print the
Employee dictionary that already deleted.

o Using pop() method

The pop() method accepts the key as an argument and remove the associated value. Consider
the following example.

# Creating a Dictionary
Dict = {1: 'PythonPoint', 2: 'Peter', 3: 'Thomas'}
# Deleting a key
# using pop() method
pop_ele = Dict.pop(3)
print(Dict)
 Output:

{1: 'PythonPoint', 2: 'Peter'}

Python also provides a built-in methods popitem() and clear() method for remove elements
from the dictionary. The popitem() removes the arbitrary element from a dictionary, whereas
the clear() method removes all elements to the whole dictionary.

Iterating Dictionary

A dictionary can be iterated using for loop as given below.

Example 1

# for loop to print all the keys of a dictionary

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

for x in Employee:
print(x)

Output:

Name
Age
salary
Company

Example 2

#for loop to print all the values of the dictionary

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

for x in Employee:
print(Employee[x])

Output:

John
29
25000
GOOGLE

Example - 3

#for loop to print the values of the dictionary by using values() method.
Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}
for x in Employee.values():
print(x)

Output:

John
29
25000
GOOGLE

Example 4

#for loop to print the items of the dictionary by using items() method.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}

for x in Employee.items():
print(x)

Output:

('Name', 'John')
('Age', 29)
('salary', 25000)
('Company', 'GOOGLE')

Properties of Dictionary keys

1. In the dictionary, we cannot store multiple values for the same keys. If we pass more than
one value for a single key, then the value which is last assigned is considered as the value of
the key.

Consider the following example.

Employee={"Name":"John","Age":29,"Salary":25000,"Company":"GOOGLE","Name":"
John"}
for x,y in Employee.items():
print(x,y)

Output:

Name John
Age 29
Salary 25000
Company GOOGLE
2. In python, the key cannot be any mutable object. We can use numbers, strings, or tuples as
the key, but we cannot use any mutable object like the list as the key in the dictionary.

Consider the following example.

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE",[100,2

01,301]:"Department ID"}
for x,y in Employee.items():
print(x,y)

Output:

Traceback (most recent call last):

File "dictionary.py", line 1, in
Employee = {"Name": "John", "Age": 29,
"salary":25000,"Company":"GOOGLE",[100,201,301]:"Department ID"}
TypeError: unhashable type: 'list'

Built-in Dictionary functions

The built-in python dictionary methods along with the description are given below.

Python Function

Functions are the most important aspect of an application. 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. The function contains the set of programming statements enclosed by {}. A
function can be called multiple times to provide reusability and modularity to the Python
program.

The Function helps to programmer to break the program into the smaller part. It organizes the
code very effectively and avoids the repetition of the code. As the program grows, function
makes the program more organized.

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

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.
 In this tutorial, we will discuss the user define 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.

Creating a Function

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

Syntax:

1. def my_function(parameters):
2. function_block
3. 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

1. #defining the function

2. def func (name):
3. print("Hi ",name)
4. #calling the function
5. 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))

Output:

Enter a: 10
Enter b: 20
Sum = 30

Call by reference in Python

In Python, call by reference means passing the actual value as an argument in the function.
All the functions are called by reference, i.e., all the changes made to the reference inside the
function revert back to the original value referred by the reference.

Example 1 Passing Immutable Object (List)

#defining the function

def change_list(list1):
list1.append(20)
list1.append(30)
print("list inside function = ",list1)

#defining the list

list1 = [10,30,40,50]

#calling the function

change_list(list1)
print("list outside function = ",list1)

Output:

list inside function = [10, 30, 40, 50, 20, 30]

list outside function = [10, 30, 40, 50, 20, 30]

Example 2 Passing Mutable Object (String)

#defining the function
def change_string (str):
str = str + " Hows you "
print("printing the string inside function :",str)

string1 = "Hi I am there"

#calling the function

change_string(string1)
 print("printing the string outside function :",string1)

Output:

printing the string inside function : Hi I am there Hows you

printing the string outside function : Hi I am there

Types of arguments

There may be several types of arguments which can be passed at the time of function call.

1. Required arguments
2. Keyword arguments
3. Default arguments
4. Variable-length arguments

Required Arguments

Till now, we have learned about function calling in Python. However, we can provide the
arguments at the time of the function call. As far as the required arguments are concerned,
these are the arguments which are required to be passed at the time of function calling with
the exact match of their positions in the function call and function definition. If either of the
arguments is not provided in the function call, or the position of the arguments is changed,
the Python interpreter will show the error.

Consider the following example.

Example 1

def func(name):
message = "Hi "+name
return message
name = input("Enter the name:")
print(func(name))

Output:

Enter the name: John

Hi John

Example 2
#the function simple_interest accepts three arguments and returns the simple interest accordingly

def simple_interest(p,t,r):
return (p*t*r)/100
p = float(input("Enter the principle amount? "))
r = float(input("Enter the rate of interest? "))
t = float(input("Enter the time in years? "))
print("Simple Interest: ",simple_interest(p,r,t))

Output:

Enter the principle amount: 5000

Enter the rate of interest: 5
Enter the time in years: 3
Simple Interest: 750.0

Example 3

#the function calculate returns the sum of two arguments a and b

def calculate(a,b):
return a+b
calculate(10) # this causes an error as we are missing a required arguments b.

Output:

TypeError: calculate() missing 1 required positional argument: '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

Example 2
def printme(name,age=22):
print("My name is",name,"and age is",age)
printme(name = "john") #the variable age is not passed into the function however the default valu
e of age is considered in the function
printme(age = 10,name="David") #the value of age is overwritten here, 10 will be printed as age

Output:

My name is john and age is 22

My name is David and age is 10

Variable-length Arguments (*args)

In large projects, sometimes we may not know the number of arguments to be passed in
advance. In such cases, Python provides us the flexibility to offer the comma-separated
values which are internally treated as tuples at the function call. By using the variable-length
arguments, we can pass any number of arguments.

However, at the function definition, we define the variable-length argument using

the *args (star) as *<variable - name >.

Consider the following example.

Example

def printme(*names):
print("type of passed argument is ",type(names))
print("printing the passed arguments...")
for name in names:
print(name)
printme("john","David","smith","nick")

Output:

type of passed argument is <class 'tuple'>

printing the passed arguments...
john
David
smith
nick
In the above code, we passed *names as variable-length argument. We called the function
and passed values which are treated as tuple internally. The tuple is an iterable sequence the
same as the list. To print the given values, we iterated *arg names using for loop.

Keyword arguments(**kwargs)

Python allows us to call the function with the keyword arguments. This kind of function call
will enable us to pass the arguments in the random order.

The name of the arguments is treated as the keywords and matched in the function calling and
definition. If the same match is found, the values of the arguments are copied in the function
definition.

Consider the following example.

Example 1

#function func is called with the name and message as the keyword arguments
def func(name,message):
print("printing the message with",name,"and ",message)

#name and message is copied with the values John and hello respectively
func(name = "John",message="hello")

Output:

printing the message with John and hello

Example 2 providing the values in different order at the calling

#The function simple_interest(p, t, r) is called with the keyword arguments the order of ar
guments doesn't matter in this case
def simple_interest(p,t,r):
return (p*t*r)/100
print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))

Output:

Simple Interest: 1900.0

If we provide the different name of arguments at the time of function call, an error will be
thrown.

Consider the following example.

 Example 3

1. #The function simple_interest(p, t, r) is called with the keyword arguments.

2. def simple_interest(p,t,r):
3. return (p*t*r)/100
4.
5. # doesn't find the exact match of the name of the arguments (keywords)
6. print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900))

Output:

TypeError: simple_interest() got an unexpected keyword argument 'time'

The Python allows us to provide the mix of the required arguments and keyword arguments
at the time of function call. However, the required argument must not be given after the
keyword argument, i.e., once the keyword argument is encountered in the function call, the
following arguments must also be the keyword arguments.

Consider the following example.

Example 4

1. def func(name1,message,name2):
2. print("printing the message with",name1,",",message,",and",name2)
3. #the first argument is not the keyword argument
4. func("John",message="hello",name2="David")

Output:

printing the message with John , hello ,and David

The following example will cause an error due to an in-proper mix of keyword and required
arguments being passed in the function call.

Example 5

1. def func(name1,message,name2):
2. print("printing the message with",name1,",",message,",and",name2)
3. func("John",message="hello","David")

Output:

SyntaxError: positional argument follows keyword argument

Python provides the facility to pass the multiple keyword arguments which can be
represented as **kwargs. It is similar as the *args but it stores the argument in the dictionary
format.

This type of arguments is useful when we do not know the number of arguments in advance.

Consider the following example:

Example 6: Many arguments using Keyword argument

def food(**kwargs):
print(kwargs)
food(a="Apple")
food(fruits="Orange", Vagitables="Carrot")

Output:

{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}

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.

Consider the following example.

Example 1 Local Variable

def print_message():
message = "hello !! I am going to print a message."
# the variable message is local to the function itself
print(message)
print_message()
print(message) # this will cause an error since a local variable cannot be accessible here.
Output:

hello !! I am going to print a message.

File "/root/PycharmProjects/PythonTest/Test1.py", line 5, in
print(message)
NameError: name 'message' is not defined

Example 2 Global Variable

def calculate(*args):
sum=0
for arg in args:
sum = sum +arg
print("The sum is",sum)
sum=0
calculate(10,20,30) #60 will be printed as the sum
print("Value of sum outside the function:",sum) # 0 will be printed Output:

Output:

The sum is 60
Value of sum outside the function: 0

SN Function Description

1 cmp(dict1, It compares the items of both the dictionary and returns true if the first
dict2) dictionary values are greater than the second dictionary, otherwise it
returns false.

2 len(dict) It is used to calculate the length of the dictionary.

3 str(dict) It converts the dictionary into the printable string representation.

4 type(variable) It is used to print the type of the passed variable.

Built-in Dictionary methods

The built-in python dictionary methods along with the description are given below.
SN Method Description

1 dic.clear() It is used to delete all the items of the dictionary.

2 dict.copy() It returns a shallow copy of the dictionary.

3 dict.fromkeys(iterable, Create a new dictionary from the iterable with the values
value = None, /) equal to value.

4 dict.get(key, default = It is used to get the value specified for the passed key.
"None")

5 dict.has_key(key) It returns true if the dictionary contains the specified

key.

6 dict.items() It returns all the key-value pairs as a tuple.

7 dict.keys() It returns all the keys of the dictionary.

8 dict.setdefault(key,default= It is used to set the key to the default value if the key is
"None") not specified in the dictionary

9 dict.update(dict2) It updates the dictionary by adding the key-value pair of

dict2 to this dictionary.

10 dict.values() It returns all the values of the dictionary.

11 len()

12 popItem()

13 pop()

14 count()
15 index()

Python Function

Functions are the most important aspect of an application. 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. The function contains the set of programming statements enclosed by {}. A
function can be called multiple times to provide reusability and modularity to the Python
program.

The Function helps to programmer to break the program into the smaller part. It organizes the
code very effectively and avoids the repetition of the code. As the program grows, function
makes the program more organized.

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

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.

In this tutorial, we will discuss the user define 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.

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

Syntax:

1. def my_function(parameters):
2. function_block
3. 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".

1. #function definition
2. def hello_world():
3. print("hello world")
4. # function calling
5. 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

1. # Defining function
2. def sum():
3. a = 10
4. b = 20
5. c = a+b
6. return c
7. # calling sum() function in print statement
8. 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

1. # Defining function
2. def sum():
3. a = 10
4. b = 20
5. c = a+b
6. # calling sum() function in print statement
7. 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

1. #defining the function

2. def func (name):
3. print("Hi ",name)
4. #calling the function
5. func("Devansh")

Output:

Hi Devansh

Example 2

1. #Python function to calculate the sum of two variables

2. #defining the function
3. def sum (a,b):
4. return a+b;
5.
6. #taking values from the user
7. a = int(input("Enter a: "))
8. b = int(input("Enter b: "))
9.
10. #printing the sum of a and b
11. print("Sum = ",sum(a,b))

Output:

Enter a: 10
Enter b: 20
Sum = 30
 Call by reference in Python

In Python, call by reference means passing the actual value as an argument in the function.
All the functions are called by reference, i.e., all the changes made to the reference inside the
function revert back to the original value referred by the reference.

Example 1 Passing Immutable Object (List)

1. #defining the function

2. def change_list(list1):
3. list1.append(20)
4. list1.append(30)
5. print("list inside function = ",list1)
6.
7. #defining the list
8. list1 = [10,30,40,50]
9.
10. #calling the function
11. change_list(list1)
12. print("list outside function = ",list1)

Output:

list inside function = [10, 30, 40, 50, 20, 30]

list outside function = [10, 30, 40, 50, 20, 30]

Example 2 Passing Mutable Object (String)

1. #defining the function
2. def change_string (str):
3. str = str + " Hows you "
4. print("printing the string inside function :",str)
5.
6. string1 = "Hi I am there"
7.
8. #calling the function
9. change_string(string1)
10.
11. print("printing the string outside function :",string1)

Output:

printing the string inside function : Hi I am there Hows you

printing the string outside function : Hi I am there
Types of arguments

There may be several types of arguments which can be passed at the time of function call.

1. Required arguments
2. Keyword arguments
3. Default arguments
4. Variable-length arguments

Required Arguments

Till now, we have learned about function calling in Python. However, we can provide the
arguments at the time of the function call. As far as the required arguments are concerned,
these are the arguments which are required to be passed at the time of function calling with
the exact match of their positions in the function call and function definition. If either of the
arguments is not provided in the function call, or the position of the arguments is changed,
the Python interpreter will show the error.

Consider the following example.

Example 1

def func(name):
message = "Hi "+name
return message
name = input("Enter the name:")
print(func(name))

Output:

Enter the name: John

Hi John

Example 2

#the function simple_interest accepts three arguments and returns the simple interest acco
rdingly
def simple_interest(p,t,r):
return (p*t*r)/100
p = float(input("Enter the principle amount? "))
r = float(input("Enter the rate of interest? "))
t = float(input("Enter the time in years? "))
print("Simple Interest: ",simple_interest(p,r,t))
 Output:

Enter the principle amount: 5000

Enter the rate of interest: 5
Enter the time in years: 3
Simple Interest: 750.0

Example 3

1. #the function calculate returns the sum of two arguments a and b

2. def calculate(a,b):
3. return a+b
4. calculate(10) # this causes an error as we are missing a required arguments b.

Output:

TypeError: calculate() missing 1 required positional argument: '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

Example 2

1. def printme(name,age=22):
2. print("My name is",name,"and age is",age)
3. printme(name = "john") #the variable age is not passed into the function however the default
value of age is considered in the function
4. printme(age = 10,name="David") #the value of age is overwritten here, 10 will be printed as
age

Output:
 My name is john and age is 22
My name is David and age is 10

Variable-length Arguments (*args)

In large projects, sometimes we may not know the number of arguments to be passed in
advance. In such cases, Python provides us the flexibility to offer the comma-separated
values which are internally treated as tuples at the function call. By using the variable-length
arguments, we can pass any number of arguments.

However, at the function definition, we define the variable-length argument using

the *args (star) as *<variable - name >.

Consider the following example.

Example

def printme(*names):
print("type of passed argument is ",type(names))
print("printing the passed arguments...")
for name in names:
print(name)
printme("john","David","smith","nick")

Output:

type of passed argument is <class 'tuple'>

printing the passed arguments...
john
David
smith
nick

In the above code, we passed *names as variable-length argument. We called the function
and passed values which are treated as tuple internally. The tuple is an iterable sequence the
same as the list. To print the given values, we iterated *arg names using for loop.

Keyword arguments(**kwargs)

Python allows us to call the function with the keyword arguments. This kind of function call
will enable us to pass the arguments in the random order.
The name of the arguments is treated as the keywords and matched in the function calling and
definition. If the same match is found, the values of the arguments are copied in the function
definition.

Consider the following example.

Example 1

#function func is called with the name and message as the keyword arguments
def func(name,message):
print("printing the message with",name,"and ",message)

#name and message is copied with the values John and hello respectively
func(name = "John",message="hello")

Output:

printing the message with John and hello

Example 2 providing the values in different order at the calling

#The function simple_interest(p, t, r) is called with the keyword arguments the order of ar
guments doesn't matter in this case
def simple_interest(p,t,r):
return (p*t*r)/100
print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))

Output:

Simple Interest: 1900.0

If we provide the different name of arguments at the time of function call, an error will be
thrown.

Consider the following example.

Example 3

#The function simple_interest(p, t, r) is called with the keyword arguments.

def simple_interest(p,t,r):
return (p*t*r)/100

# doesn't find the exact match of the name of the arguments (keywords)
print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900))
 Output:

TypeError: simple_interest() got an unexpected keyword argument 'time'

The Python allows us to provide the mix of the required arguments and keyword arguments
at the time of function call. However, the required argument must not be given after the
keyword argument, i.e., once the keyword argument is encountered in the function call, the
following arguments must also be the keyword arguments.

Consider the following example.

Example 4

1. def func(name1,message,name2):
2. print("printing the message with",name1,",",message,",and",name2)
3. #the first argument is not the keyword argument
4. func("John",message="hello",name2="David")

Output:

printing the message with John , hello ,and David

The following example will cause an error due to an in-proper mix of keyword and required
arguments being passed in the function call.

Example 5

1. def func(name1,message,name2):
2. print("printing the message with",name1,",",message,",and",name2)
3. func("John",message="hello","David")

Output:

SyntaxError: positional argument follows keyword argument

Python provides the facility to pass the multiple keyword arguments which can be
represented as **kwargs. It is similar as the *args but it stores the argument in the dictionary
format.

This type of arguments is useful when we do not know the number of arguments in advance.

Consider the following example:

Example 6: Many arguments using Keyword argument

def food(**kwargs):
 print(kwargs)
food(a="Apple")
food(fruits="Orange", Vagitables="Carrot")

Output:

{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}

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.

Consider the following example.

Example 1 Local Variable

def print_message():
message = "hello !! I am going to print a message." # the variable message is local to th
e function itself
print(message)
print_message()
print(message) # this will cause an error since a local variable cannot be accessible here.

Output:

hello !! I am going to print a message.

File "/root/PycharmProjects/PythonTest/Test1.py", line 5, in
print(message)
NameError: name 'message' is not defined

Example 2 Global Variable

 def calculate(*args):
sum=0
for arg in args:
sum = sum +arg
print("The sum is",sum)
sum=0
calculate(10,20,30) #60 will be printed as the sum
print("Value of sum outside the function:",sum) # 0 will be printed Output:

Output:

The sum is 60
Value of sum outside the function: 0
Python Built-in Functions

The Python built-in functions are defined as the functions whose functionality is pre-defined
in Python. The python interpreter has several functions that are always present for use. These
functions are known as Built-in Functions. There are several built-in functions in Python
which are listed below:

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

# floating number
floating = -20.83
print('Absolute value of -40.83 is:', abs(floating))

Output:

Absolute value of -20 is: 20

Absolute value of -20.83 is: 20.83
Python all() Function

The python all() function accepts an iterable object (such as list, dictionary, etc.). It returns
true if all items in passed iterable are true. Otherwise, it returns False. If the iterable object is
empty, the all() function returns True.

Python all() Function Example

# all values true

k = [1, 3, 4, 6]
print(all(k))

# all values false

k = [0, False]
print(all(k))

# one false value

k = [1, 3, 7, 0]
print(all(k))

# one true value

k = [0, False, 5]
print(all(k))

# empty iterable
k = []
print(all(k))

Output:

True
False
False
False
True

Python bin() Function

The python bin() function is used to return the binary representation of a specified integer. A
result always starts with the prefix 0b.

Python bin() Function Example

x = 10
 y = bin(x)
print (y)

Output:

0b1010

Python bool()

The python bool() converts a value to boolean(True or False) using the standard truth testing
procedure.

Python bool() Example

test1 = []
print(test1,'is',bool(test1))
test1 = [0]
print(test1,'is',bool(test1))
test1 = 0.0
print(test1,'is',bool(test1))
test1 = None
print(test1,'is',bool(test1))
test1 = True
print(test1,'is',bool(test1))
test1 = 'Easy string'
print(test1,'is',bool(test1))

Output:

[] is False
[0] is True
0.0 is False
None is False
True is True
Easy string is True

Python bytes()

The python bytes() in Python is used for returning a bytes object. It is an immutable version
of the bytearray() function.

It can create empty bytes object of the specified size.

Python bytes() Example

 string = "Hello World."
array = bytes(string, 'utf-8')
print(array)

Output:

b ' Hello World.'

Python callable() Function

A python callable() function in Python is something that can be called. This built-in function
checks and returns true if the object passed appears to be callable, otherwise false.

Python callable() Function Example

x=8
print(callable(x))

Output:

False

Python compile() Function

The python compile() function takes source code as input and returns a code object which
can later be executed by exec() function.

Python compile() Function Example

# compile string source to code

code_str = 'x=5 \n y=10 \n print("sum =",x+y)'
code = compile(code_str, 'sum.py', 'exec')
print(type(code))
exec(code)
exec(x)

Output:

<class 'code'>
sum = 15
Python exec() Function

The python exec() function is used for the dynamic execution of Python program which can
either be a string or object code and it accepts large blocks of code, unlike the eval() function
which only accepts a single expression.

Python exec() Function Example

x=8
exec('print(x==8)')
exec('print(x+4)')

Output:

True
12

Python sum() Function

As the name says, python sum() function is used to get the sum of numbers of an iterable,
i.e., list.

Python sum() Function Example

s = sum([1, 2,4 ])
print(s)

s = sum([1, 2, 4], 10)

print(s)

Output:

7
17

Python any() Function

The python any() function returns true if any item in an iterable is true. Otherwise, it returns
False.

Python any() Function Example

l = [4, 3, 2, 0]
print(any(l))
 l = [0, False]
print(any(l))

l = [0, False, 5]
print(any(l))

l = []
print(any(l))

Output:

True
False
True
False

Python ascii() Function

The python ascii() function returns a string containing a printable representation of an object
and escapes the non-ASCII characters in the string using \x, \u or \U escapes.

Python ascii() Function Example

normalText = 'Python is interesting'

print(ascii(normalText))

otherText = 'Pythön is interesting'

print(ascii(otherText))

print('Pyth\xf6n is interesting')

Output:

'Python is interesting'
'Pyth\xf6n is interesting'
Pythön is interesting

Python bytearray()

The python bytearray() returns a bytearray object and can convert objects into bytearray
objects, or create an empty bytearray object of the specified size.
Python bytearray() Example

string = "Python is a programming language."

# string with encoding 'utf-8'

arr = bytearray(string, 'utf-8')
print(arr)

Output:

bytearray(b'Python is a programming language.')

Python eval() Function

The python eval() function parses the expression passed to it and runs python
expression(code) within the program.

Python eval() Function Example

x=8
print(eval('x + 1'))

Output:

Python float()

The python float() function returns a floating-point number from a number or string.

Python float() Example

# for integers
print(float(9))

# for floats
print(float(8.19))

# for string floats

print(float("-24.27"))

# for string floats with whitespaces

print(float(" -17.19\n"))
 # string float error
print(float("xyz"))

Output:

9.0
8.19
-24.27
-17.19
ValueError: could not convert string to float: 'xyz'

Python format() Function

The python format() function returns a formatted representation of the given value.

Python format() Function Example

# d, f and b are a type

# integer
print(format(123, "d"))

# float arguments
print(format(123.4567898, "f"))

# binary format
print(format(12, "b"))

Output:

123
123.456790
1100

Python frozenset()

The python frozenset() function returns an immutable frozenset object initialized with
elements from the given iterable.

Python frozenset() Example

# tuple of letters
letters = ('m', 'r', 'o', 't', 's')
 fSet = frozenset(letters)
print('Frozen set is:', fSet)
print('Empty frozen set is:', frozenset())

Output:

Frozen set is: frozenset({'o', 'm', 's', 'r', 't'})

Empty frozen set is: frozenset()

Python getattr() Function

The python getattr() function returns the value of a named attribute of an object. If it is not
found, it returns the default value.

Python getattr() Function Example

class Details:
age = 22
name = "Phill"

details = Details()
print('The age is:', getattr(details, "age"))
print('The age is:', details.age)

Output:

The age is: 22

The age is: 22

Python globals() Function

The python globals() function returns the dictionary of the current global symbol table.

A Symbol table is defined as a data structure which contains all the necessary information
about the program. It includes variable names, methods, classes, etc.

Python globals() Function Example

age = 22

globals()['age'] = 22
print('The age is:', age)

Output:
The age is: 22

Python hasattr() Function

The python any() function returns true if any item in an iterable is true, otherwise it returns
False.

Python hasattr() Function Example

Hasattr() ??????

Output:

Python iter() Function

The python iter() function is used to return an iterator object. It creates an object which can
be iterated one element at a time.

Python iter() Function Example

# list of numbers
list = [1,2,3,4,5]

listIter = iter(list)

# prints '1'
print(next(listIter))

# prints '2'
print(next(listIter))

# prints '3'
print(next(listIter))

# prints '4'
print(next(listIter))

# prints '5'
print(next(listIter))

Output:
 1
2
3
4
5

Python len() Function

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

Python len() Function Example

1. strA = 'Python'
2. print(len(strA))

Output:

Python list()

The python list() creates a list in python.

Python list() Example

# empty list
print(list())

# string
String = 'abcde'
print(list(String))

# tuple
Tuple = (1,2,3,4,5)
print(list(Tuple))
# list
List = [1,2,3,4,5]
print(list(List))

Output:

[]
['a', 'b', 'c', 'd', 'e']
[1,2,3,4,5]
[1,2,3,4,5]
Python locals() Function

The python locals() method updates and returns the dictionary of the current local symbol
table.

A Symbol table is defined as a data structure which contains all the necessary information
about the program. It includes variable names, methods, classes, etc.

Python locals() Function Example

def localsAbsent():
return locals()

def localsPresent():
present = True
return locals()

print('localsNotPresent:', localsAbsent())
print('localsPresent:', localsPresent())

Output:

localsAbsent: {}
localsPresent: {'present': True}

Python map() Function

The python map() function is used to return a list of results after applying a given function to
each item of an iterable(list, tuple etc.).

Python map() Function Example

def calculateAddition(n):
return n+n

numbers = (1, 2, 3, 4)
result = map(calculateAddition, numbers)
print(result)

# converting map object to set

numbersAddition = set(result)
print(numbersAddition)
 Output:

<map object at 0x7fb04a6bec18>

{8, 2, 4, 6}

Python memoryview() Function

The python memoryview() function returns a memoryview object of the given argument.

Python memoryview () Function Example

#A random bytearray
randomByteArray = bytearray('ABC', 'utf-8')

mv = memoryview(randomByteArray)

# access the memory view's zeroth index

print(mv[0])

# It create byte from memory view

print(bytes(mv[0:2]))

# It create list from memory view

print(list(mv[0:3]))

Output:

65
b'AB'
[65, 66, 67]

Python object()

The python object() returns an empty object. It is a base for all the classes and holds the
built-in properties and methods which are default for all the classes.

Python object() Example

python = object()

print(type(python))
print(dir(python))

Output:
<class 'object'>
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__']

Python open() Function

The python open() function opens the file and returns a corresponding file object.

Python open() Function Example

# opens python.text file of the current directory

f = open("d:/python.txt")
# specifying full path
f = open("d:/Python/README.txt")

Output:

Since the mode is omitted, the file is opened in 'r' mode; opens for reading.

Python chr() Function

Python chr() function is used to get a string representing a character which points to a
Unicode code integer. For example, chr(97) returns the string 'a'. This function takes an
integer argument and throws an error if it exceeds the specified range. The standard range of
the argument is from 0 to 1,114,111.

Python chr() Function Example

# Calling function
result = chr(102) # It returns string representation of a char
result2 = chr(112)
# Displaying result
print(result)
print(result2)
# Verify, is it string type?
print("is it string type:", type(result) is str)

Output:

ValueError: chr() arg not in range(0x110000)

Python complex()

Python complex() function is used to convert numbers or string into a complex number. This
method takes two optional parameters and returns a complex number. The first parameter is
called a real and second as imaginary parts.

Python complex() Example

# Python complex() function example

# Calling function
a = complex(1) # Passing single parameter
b = complex(1,2) # Passing both parameters
# Displaying result
print(a)
print(b)

Output:

(1.5+0j)
(1.5+2.2j)

Python delattr() Function

Python delattr() function is used to delete an attribute from a class. It takes two parameters,
first is an object of the class and second is an attribute which we want to delete. After
deleting the attribute, it no longer available in the class and throws an error if try to call it
using the class object.

Python delattr() Function Example

class Student:
id = 101
name = "Pranshu"
email = "[email protected]"
# Declaring function
def getinfo(self):
print(self.id, self.name, self.email)
s = Student()
s.getinfo()
delattr(Student,'course') # Removing attribute which is not available
s.getinfo() # error: throws an error

Output:
 101 Pranshu [email protected]
AttributeError: course

Python dir() Function

Python dir() function returns the list of names in the current local scope. If the object on
which method is called has a method named __dir__(), this method will be called and must
return the list of attributes. It takes a single object type argument.

Python dir() Function Example

# Calling function
att = dir()
# Displaying result
print(att)

Output:

['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',

'__name__', '__package__', '__spec__']

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

Python divmod() Function Example

# Python divmod() function example

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

Output:

(5, 0)
Python enumerate() Function

Python enumerate() function returns an enumerated object. It takes two parameters, first is a
sequence of elements and the second is the start index of the sequence. We can get the
elements in sequence either through a loop or next() method.

Python enumerate() Function Example

# Calling function
result = enumerate([1,2,3])
# Displaying result
print(result)
print(list(result))

Output:

<enumerate object at 0x7ff641093d80>

[(0, 1), (1, 2), (2, 3)]

Python dict()

Python dict() function is a constructor which creates a dictionary. Python dictionary provides
three different constructors to create a dictionary:

o If no argument is passed, it creates an empty dictionary.

o If a positional argument is given, a dictionary is created with the same key-value
pairs. Otherwise, pass an iterable object.
o If keyword arguments are given, the keyword arguments and their values are added to
the dictionary created from the positional argument.

Python dict() Example

# Calling function
result = dict() # returns an empty dictionary
result2 = dict(a=1,b=2)
# Displaying result
print(result)
print(result2)

Output:

{}
{'a': 1, 'b': 2}
Python filter() Function

Python filter() function is used to get filtered elements. This function takes two arguments,
first is a function and the second is iterable. The filter function returns a sequence of those
elements of iterable object for which function returns true value.

The first argument can be none, if the function is not available and returns only elements that
are true.

Python filter() Function Example

# Python filter() function example

def filterdata(x):
if x>5:
return x
# Calling function
result = filter(filterdata,(1,2,6))
# Displaying result
print(list(result))

Output:

[6]

Python hash() Function

Python hash() function is used to get the hash value of an object. Python calculates the hash
value by using the hash algorithm. The hash values are integers and used to compare
dictionary keys during a dictionary lookup. We can hash only the types which are given
below:

Hashable types: * bool * int * long * float * string * Unicode * tuple * code object.

Python hash() Function Example

# Calling function
result = hash(21) # integer value
result2 = hash(22.2) # decimal value
# Displaying result
print(result)
print(result2)

Output:
21
461168601842737174

Python help() Function

Python help() function is used to get help related to the object passed during the call. It takes
an optional parameter and returns help information. If no argument is given, it shows the
Python help console. It internally calls python's help function.

Python help() Function Example

# Calling function
info = help() # No argument
# Displaying result
print(info)

Output:

Welcome to Python 3.5's help utility!

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
small2 = min(1000.25,2025.35,5625.36,10052.50)
# Displaying result
print(small)
print(small2)

Output:

325
1000.25
 Python set() Function

In python, a set is a built-in class, and this function is a constructor of this class. It is used to
create a new set using elements passed during the call. It takes an iterable object as an
argument and returns a new set object.

Python set() Function Example

# Calling function
result = set() # empty set
result2 = set('12')
result3 = set('PythonPoint')
# Displaying result
print(result)
print(result2)
print(result3)

Output:

set()
{'1', '2'}
{'a', 'n', 'v', 't', 'j', 'p', 'i', 'o'}

Python hex() Function

Python hex() function is used to generate hex value of an integer argument. It takes an integer
argument and returns an integer converted into a hexadecimal string. In case, we want to get a
hexadecimal value of a float, then use float.hex() function.

Python hex() Function Example

# Calling function
result = hex(1)
# integer value
result2 = hex(342)
# Displaying result
print(result)
print(result2)

Output:

0x1
0x156
 Python id() Function

Python id() function returns the identity of an object. This is an integer which is guaranteed
to be unique. This function takes an argument as an object and returns a unique integer
number which represents identity. Two objects with non-overlapping lifetimes may have the
same id() value.

Python id() Function Example

# Calling function
val = id("PythonPoint") # string object
val2 = id(1200) # integer object
val3 = id([25,336,95,236,92,3225]) # List object
# Displaying result
print(val)
print(val2)
print(val3)

Output:

139963782059696
139963805666864
139963781994504

Python setattr() Function

Python setattr() function is used to set a value to the object's attribute. It takes three
arguments, i.e., an object, a string, and an arbitrary value, and returns none. It is helpful when
we want to add a new attribute to an object and set a value to it.

Python setattr() Function Example

class Student:
id = 0
name = ""

def __init__(self, id, name):

self.id = id
self.name = name

student = Student(102,"Sohan")
print(student.id)
print(student.name)
#print(student.email) product error
 setattr(student, 'email','[email protected]') # adding new attribute
print(student.email)

Output:

102
Sohan
[email protected]

Python slice() Function

Python slice() function is used to get a slice of elements from the collection of elements.
Python provides two overloaded slice functions. The first function takes a single argument
while the second function takes three arguments and returns a slice object. This slice object
can be used to get a subsection of the collection.

Python slice() Function Example

# Calling function
result = slice(5) # returns slice object
result2 = slice(0,5,3) # returns slice object
# Displaying result
print(result)
print(result2)

Output:

slice(None, 5, None)
slice(0, 5, 3)

Python sorted() Function

Python sorted() function is used to sort elements. By default, it sorts elements in an

ascending order but can be sorted in descending also. It takes four arguments and returns a
collection in sorted order. In the case of a dictionary, it sorts only keys, not values.

Python sorted() Function Example

str = "PythonPoint" # declaring string

# Calling function
sorted1 = sorted(str) # sorting string
# Displaying result
print(sorted1)
 Output:

['a', 'a', 'i', 'j', 'n', 'o', 'p', 't', 't', 'v']

Python next() Function

Python next() function is used to fetch next item from the collection. It takes two arguments,
i.e., an iterator and a default value, and returns an element.

This method calls on iterator and throws an error if no item is present. To avoid the error, we
can set a default value.

Python next() Function Example

number = iter([256, 32, 82]) # Creating iterator

# Calling function
item = next(number)
# Displaying result
print(item)
# second item
item = next(number)
print(item)
# third item
item = next(number)
print(item)

Output:

256
32
82

Python input() Function

Python input() function is used to get an input from the user. It prompts for the user input
and reads a line. After reading data, it converts it into a string and returns it. It throws an
error EOFError if EOF is read.

Python input() Function Example

# Calling function
val = input("Enter a value: ")
# Displaying result
print("You entered:",val)
Output:

Enter a value: 45
You entered: 45

Python int() Function

Python int() function is used to get an integer value. It returns an expression converted into
an integer number. If the argument is a floating-point, the conversion truncates the number. If
the argument is outside the integer range, then it converts the number into a long type.

If the number is not a number or if a base is given, the number must be a string.

Python int() Function Example

# Calling function
val = int(10) # integer value
val2 = int(10.52) # float value
val3 = int('10') # string value
# Displaying result
print("integer values :",val, val2, val3)

Output:

integer values : 10 10 10

Python isinstance() Function

Python isinstance() function is used to check whether the given object is an instance of that
class. If the object belongs to the class, it returns true. Otherwise returns False. It also returns
true if the class is a subclass.

The isinstance() function takes two arguments, i.e., object and classinfo, and then it returns
either True or False.

Python isinstance() function Example

class Student:
id = 101
name = "John"
def __init__(self, id, name):
self.id=id
self.name=name
 student = Student(1010,"John")
lst = [12,34,5,6,767]
# Calling function
print(isinstance(student, Student)) # isinstance of Student class
print(isinstance(lst, Student))

Output:

True
False

Python oct() Function

Python oct() function is used to get an octal value of an integer number. This method takes an
argument and returns an integer converted into an octal string. It throws an error TypeError,
if argument type is other than an integer.

Python oct() function Example

1. # Calling function
2. val = oct(10)
3. # Displaying result
4. print("Octal value of 10:",val)

Output:

Octal value of 10: 0o12

Python ord() Function

The python ord() function returns an integer representing Unicode code point for the given
Unicode character.

Python ord() function Example

1. # Code point of an integer

2. print(ord('8'))
3.
4. # Code point of an alphabet
5. print(ord('R'))
6.
7. # Code point of a character
8. print(ord('&'))
 Output:

56
82
38

Python pow() Function

The python pow() function is used to compute the power of a number. It returns x to the
power of y. If the third argument(z) is given, it returns x to the power of y modulus z, i.e. (x,
y) % z.

Python pow() function Example

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

print(pow(4, 2))

# negative x, positive y
print(pow(-4, 2))

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

print(pow(4, -2))

# negative x, negative y
print(pow(-4, -2))

Output:

16
16
0.0625
0.0625

Python print() Function

The python print() function prints the given object to the screen or other standard output
devices.

Python print() function Example

1. print("Python is programming language.")

2.
3. x = 7
4. # Two objects passed
5. print("x =", x)
6.
7. y=x
8. # Three objects passed
9. print('x =', x, '= y')

Output:

Python is programming language.

x=7
x=7=y

Python range() Function

The python range() function returns an immutable sequence of numbers starting from 0 by
default, increments by 1 (by default) and ends at a specified number.

Python range() function Example

# empty range
print(list(range(0)))

# using the range(stop)

print(list(range(4)))

# using the range(start, stop)

print(list(range(1,7 )))

Output:

[]
[0, 1, 2, 3]
[1, 2, 3, 4, 5, 6]

Python reversed() Function

The python reversed() function returns the reversed iterator of the given sequence.

Python reversed() function Example

# for string
String = 'Pega'
print(list(reversed(String)))
 # for tuple
Tuple = ('P', 'e', 'g', 'a')
print(list(reversed(Tuple)))

# for range
Range = range(8, 12)
print(list(reversed(Range)))

# for list
List = [1, 2, 7, 5]
print(list(reversed(List)))

Output:

['a', 'g', 'e', 'P']

['a', 'g', 'e', 'P']
[11, 10, 9, 8]
[5, 7, 2, 1]

Python round() Function

The python round() function rounds off the digits of a number and returns the floating point
number.

Python round() Function Example

# for integers
print(round(10))

# for floating point

print(round(10.8))

# even choice
print(round(6.6))

Output:

10
11
7
 Python issubclass() Function

The python issubclass() function returns true if object argument(first argument) is a subclass
of second class(second argument).

Python issubclass() Function Example

class Rectangle:
def __init__(rectangleType):
print('Rectangle is a ', rectangleType)

class Square(Rectangle):
def __init__(self):
Rectangle.__init__('square')

print(issubclass(Square, Rectangle))
print(issubclass(Square, list))
print(issubclass(Square, (list, Rectangle)))
print(issubclass(Rectangle, (list, Square)))

Output:

True
False
True
False

Python str

The python str() converts a specified value into a string.

Python str() Function Example

1. str('4')

Output:

'4'

Python tuple() Function

The python tuple() function is used to create a tuple object.

Python tuple() Function Example

t1 = tuple()
print('t1=', t1)

# creating a tuple from a list

t2 = tuple([1, 6, 9])
print('t2=', t2)

# creating a tuple from a string

t1 = tuple('Pega')
print('t1=',t1)

# creating a tuple from a dictionary

t1 = tuple({4: 'four', 5: 'five'})
print('t1=',t1)

Output:

t1= ()
t2= (1, 6, 9)
t1= ('P', 'e', 'g', 'a')
t1= (4, 5)

Python type()

The python type() returns the type of the specified object if a single argument is passed to the
type() built in function. If three arguments are passed, then it returns a new type object.

Python type() Function Example

List = [4, 5]
print(type(List))

Dict = {4: 'four', 5: 'five'}

print(type(Dict))

class Python:
a=0

InstanceOfPython = Python()
print(type(InstanceOfPython))

Output:

<class 'list'>
<class 'dict'>
<class '__main__.Python'>

Python vars() function

The python vars() function returns the __dict__ attribute of the given object.

Python vars() Function Example

class Python:
def __init__(self, x = 7, y = 9):
self.x = x
self.y = y

InstanceOfPython = Python()
print(vars(InstanceOfPython))

Output:

{'y': 9, 'x': 7}

Python zip() Function

The python zip() Function returns a zip object, which maps a similar index of multiple
containers. It takes iterables (can be zero or more), makes it an iterator that aggregates the
elements based on iterables passed, and returns an iterator of tuples.

Python zip() Function Example

numList = [4,5, 6]
strList = ['four', 'five', 'six']

# No iterables are passed

result = zip()

# Converting itertor to list

resultList = list(result)
print(resultList)

# Two iterables are passed

result = zip(numList, strList)

# Converting itertor to set

 resultSet = set(result)
print(resultSet)

Output:

[]
{(5, 'five'), (4, 'four'), (6, 'six')}

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.

The anonymous function contains a small piece of code. It simulates inline functions of C and
C++, but it is not exactly an inline function.

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

def x(a):
return a+10
print(sum = x(10))

Output:

<function <lambda> at 0x0000019E285D16A8>

sum = 30
In the above example, we have defined the lambda a: a+10 anonymous function where a is
an argument and a+10 is an expression. The given expression gets evaluated and returned the
result. The above lambda function is same as the normal function.

Example 2

Multiple arguments to Lambda function

# a and b are the arguments and a*b is the expression which gets evaluated and returned.

x = lambda a,b: a*b

print("mul = ", x(20,10))
<p><strong>Output:</strong></p>
<div class="codeblock3"><pre>
mul = 200
</pre></div>
<h2 class="h2">Why use lambda function?</h2>
<p>The main role of the lambda function is better described in the scenarios when we us
e them anonymously inside another function. In Python, the lambda function can be used
as an argument to the <strong>higher-
order functions</strong> which accepts other functions as arguments.</p>
<p>Consider the following example:</p>
<h3 class="h3">Example 1:</h3>
<div class="codeblock"><textarea name="code" class="python">
#the function table(n) prints the table of n
def table(n):
return lambda a:a*n # a will contain the iteration variable i and a multiple of n is retur
ned at each function call
n = int(input("Enter the number:"))
b = table(n) #the entered number is passed into the function table. b will contain a lambda
function which is called again and again with the iteration variable i
for i in range(1,11):
print(n,"X",i,"=",b(i)) #the lambda function b is called with the iteration variable i

Output:

Enter the number:10

10 X 1 = 10
10 X 2 = 20
10 X 3 = 30
10 X 4 = 40
10 X 5 = 50
10 X 6 = 60
10 X 7 = 70
 10 X 8 = 80
10 X 9 = 90
10 X 10 = 100

The lambda function is commonly used with Python built-in functions filter() function
and map() function.

Use lambda function with filter()

The Python built-in filter() function accepts a function and a list as an argument. It provides
an effective way to filter out all elements of the sequence. It returns the new sequence in
which the function evaluates to True.

Consider the following example where we filter out the only odd number from the given list.

#program to filter out the tuple which contains odd numbers

lst = (10,22,37,41,100,123,29)
oddlist = tuple(filter(lambda x:(x%3 == 0),lst)) # the tuple contains all the items of the tu
ple for which the lambda function evaluates to true
print(oddlist)

Output:

(37, 41, 123, 29)

Using lambda function with map()

The map() function in Python accepts a function and a list. It gives a new list which contains
all modified items returned by the function for each item.

Consider the following example of map() function.

#program to filter out the list which contains odd numbers

lst = (10,20,30,40,50,60)
square_list = list(map(lambda x:x**2,lst)) # the tuple contains all the items of the list for which t
he lambda function evaluates to true
print(square_tuple)

Output:

(100, 400, 900, 1600, 2500, 3600)

Python File Handling

 Till now, we were taking the input from the console and writing it back to the console to
interact with the user.

Sometimes, it is not enough to only display the data on the console. The data to be displayed
may be very large, and only a limited amount of data can be displayed on the console since
the memory is volatile, it is impossible to recover the programmatically generated data again
and again.

The file handling plays an important role when the data needs to be stored permanently into
the file. A file is a named location on disk to store related information. We can access the
stored information (non-volatile) after the program termination.

The file-handling implementation is slightly lengthy or complicated in the other

programming language, but it is easier and shorter in Python.

In Python, files are treated in two modes as text or binary. The file may be in the text or
binary format, and each line of a file is ended with the special character.

Hence, a file operation can be done in the following order.

o Open a file
o Read or write - Performing operation
o Close the file

Opening a file

Python provides an open() function that accepts two arguments, file name and access mode
in which the file is accessed. The function returns a file object which can be used to perform
various operations like reading, writing, etc.

Syntax:

1. file object = open(<file-name>, <access-mode>, <buffering>)

The files can be accessed using various modes like read, write, or append. The following are
the details about the access mode to open a file.

SN Access Description
mode

1 r It opens the file to read-only mode. The file pointer exists at the
 beginning. The file is by default open in this mode if no access mode is
passed.

2 rb It opens the file to read-only in binary format. The file pointer exists at
the beginning of the file.

3 r+ It opens the file to read and write both. The file pointer exists at the
beginning of the file.

4 rb+ It opens the file to read and write both in binary format. The file pointer
exists at the beginning of the file.

5 w It opens the file to write only. It overwrites the file if previously exists or
creates a new one if no file exists with the same name. The file pointer
exists at the beginning of the file.

6 wb It opens the file to write only in binary format. It overwrites the file if it
exists previously or creates a new one if no file exists. The file pointer
exists at the beginning of the file.

7 w+ It opens the file to write and read both. It is different from r+ in the sense
that it overwrites the previous file if one exists whereas r+ doesn't
overwrite the previously written file. It creates a new file if no file exists.
The file pointer exists at the beginning of the file.

8 wb+ It opens the file to write and read both in binary format. The file pointer
exists at the beginning of the file.

9 a It opens the file in the append mode. The file pointer exists at the end of
the previously written file if exists any. It creates a new file if no file
exists with the same name.

10 ab It opens the file in the append mode in binary format. The pointer exists
 at the end of the previously written file. It creates a new file in binary
format if no file exists with the same name.

11 a+ It opens a file to append and read both. The file pointer remains at the
end of the file if a file exists. It creates a new file if no file exists with the
same name.

12 ab+ It opens a file to append and read both in binary format. The file pointer
remains at the end of the file.

Let's look at the simple example to open a file named "file.txt" (stored in the same directory)
in read mode and printing its content on the console.

Example
#opens the file file.txt in read mode
fileptr = open("file.txt","r")

if fileptr:
print("file is opened successfully")

Output:

<class '_io.TextIOWrapper'>
file is opened successfully

In the above code, we have passed filename as a first argument and opened file in read mode
as we mentioned r as the second argument. The fileptr holds the file object and if the file is
opened successfully, it will execute the print statement

The close() method

Once all the operations are done on the file, we must close it through our Python script using
the close() method. Any unwritten information gets destroyed once the close() method is
called on a file object.

We can perform any operation on the file externally using the file system which is the
currently opened in Python; hence it is good practice to close the file once all the operations
are done.

The syntax to use the close() method is given below.

 Syntax

fileobject.close()

Consider the following example.

# opens the file file.txt in read mode

fileptr = open("file.txt","r")

if fileptr:
print("file is opened successfully")

#closes the opened file

fileptr.close()

After closing the file, we cannot perform any operation in the file. The file needs to be
properly closed. If any exception occurs while performing some operations in the file then the
program terminates without closing the file.

We should use the following method to overcome such type of problem.

try:
fileptr = open("file.txt")
# perform file operations
finally:
fileptr.close()

The with statement

The with statement was introduced in python 2.5. The with statement is useful in the case of
manipulating the files. It is used in the scenario where a pair of statements is to be executed
with a block of code in between.

The syntax to open a file using with the statement is given below.

1. with open(<file name>, <access mode>) as <file-pointer>:

2. #statement suite

The advantage of using with statement is that it provides the guarantee to close the file
regardless of how the nested block exits.

It is always suggestible to use the with statement in the case of files because, if the break,
return, or exception occurs in the nested block of code then it automatically closes the file, we
don't need to write the close() function. It doesn't let the file to corrupt.
Consider the following example.

Example

with open("file.txt",'r') as f:
content = f.read();
print(content)

Writing the file

To write some text to a file, we need to open the file using the open method with one of the
following access modes.

w: It will overwrite the file if any file exists. The file pointer is at the beginning of the file.

a: It will append the existing file. The file pointer is at the end of the file. It creates a new file
if no file exists.

Consider the following example.

Example

# open the file.txt in append mode. Create a new file if no such file exists.
fileptr = open("file2.txt", "w")

# appending the content to the file

fileptr.write('''''Python is the modern day language. It makes things so simple.
It is the fastest-growing programing language''')

# closing the opened the file

fileptr.close()

Output:

File2.txt

Python is the modern-day language. It makes things so simple. It is the fastest growing
programming language.

Snapshot of the file2.txt

We have opened the file in w mode. The file1.txt file doesn't exist, it created a new file and
we have written the content in the file using the write() function.

Example 2

#open the file.txt in write mode.

fileptr = open("file2.txt","a")

#overwriting the content of the file

fileptr.write(" Python has an easy syntax and user-friendly interaction.")

#closing the opened file

fileptr.close()

Output:

Python is the modern day language. It makes things so simple.

It is the fastest growing programing language Python has an easy syntax and user-friendly
interaction.

Snapshot of the file2.txt

 We can see that the content of the file is modified. We have opened the file in a mode and it
appended the content in the existing file2.txt.

To read a file using the Python script, the Python provides the read() method.
The read() method reads a string from the file. It can read the data in the text as well as a
binary format.

The syntax of the read() method is given below.

Syntax:

1. fileobj.read(<count>)

Here, the count is the number of bytes to be read from the file starting from the beginning of
the file. If the count is not specified, then it may read the content of the file until the end.

Consider the following example.

Example

#open the file.txt in read mode. causes error if no such file exists.
fileptr = open("file2.txt","r")
#stores all the data of the file into the variable content
content = fileptr.read(10)
# prints the type of the data stored in the file
print(type(content))
#prints the content of the file
print(content)
#closes the opened file
fileptr.close()

Output:

<class 'str'>
Python is

In the above code, we have read the content of file2.txt by using the read() function. We
have passed count value as ten which means it will read the first ten characters from the file.

If we use the following line, then it will print all content of the file.

content = fileptr.read()
print(content)

Output:
 Python is the modern-day language. It makes things so simple.
It is the fastest-growing programing language Python has easy an syntax and user-friendly
interaction.

Read file through for loop

We can read the file using for loop. Consider the following example.

#open the file.txt in read mode. causes an error if no such file exists.
fileptr = open("file2.txt","r");
#running a for loop
for i in fileptr:
print(i) # i contains each line of the file

Output:

Python is the modern day language.

It makes things so simple.

Python has easy syntax and user-friendly interaction.

Read Lines of the file

Python facilitates to read the file line by line by using a function readline() method.
The readline() method reads the lines of the file from the beginning, i.e., if we use the
readline() method two times, then we can get the first two lines of the file.

Consider the following example which contains a function readline() that reads the first line
of our file "file2.txt" containing three lines. Consider the following example.

Example 1: Reading lines using readline() function

#open the file.txt in read mode. causes error if no such file exists.
fileptr = open("file2.txt","r");
#stores all the data of the file into the variable content
content = fileptr.readline()
content1 = fileptr.readline()
#prints the content of the file
print(content)
print(content1)
#closes the opened file
fileptr.close()
 Output:

Python is the modern day language.

It makes things so simple.

We called the readline() function two times that's why it read two lines from the file.

Python provides also the readlines() method which is used for the reading lines. It returns the
list of the lines till the end of file(EOF) is reached.

Example 2: Reading Lines Using readlines() function

1. #open the file.txt in read mode. causes error if no such file exists.
2. fileptr = open("file2.txt","r");
3.
4. #stores all the data of the file into the variable content
5. content = fileptr.readlines()
6.
7. #prints the content of the file
8. print(content)
9.
10. #closes the opened file
11. fileptr.close()

Output:

['Python is the modern day language.\n', 'It makes things so simple.\n', 'Python has easy
syntax and user-friendly interaction.']

Creating a new file

The new file can be created by using one of the following access modes with the function
open().

x: it creates a new file with the specified name. It causes an error a file exists with the same
name.

a: It creates a new file with the specified name if no such file exists. It appends the content to
the file if the file already exists with the specified name.

w: It creates a new file with the specified name if no such file exists. It overwrites the
existing file.

Consider the following example.

 Example 1

#open the file.txt in read mode. causes error if no such file exists.
fileptr = open("file2.txt","x")
print(fileptr)
if fileptr:
print("File created successfully")

Output:

<_io.TextIOWrapper name='file2.txt' mode='x' encoding='cp1252'>

File created successfully

File Pointer positions

Python provides the tell() method which is used to print the byte number at which the file
pointer currently exists. Consider the following example.

# open the file file2.txt in read mode

fileptr = open("file2.txt","r")

#initially the filepointer is at 0

print("The filepointer is at byte :",fileptr.tell())

#reading the content of the file

content = fileptr.read();

#after the read operation file pointer modifies. tell() returns the location of the fileptr.

print("After reading, the filepointer is at:",fileptr.tell())

Output:

The filepointer is at byte : 0

After reading, the filepointer is at: 117

Modifying file pointer position

In real-world applications, sometimes we need to change the file pointer location externally
since we may need to read or write the content at various locations.

For this purpose, the Python provides us the seek() method which enables us to modify the
file pointer position externally.

The syntax to use the seek() method is given below.

 Syntax:

1. <file-ptr>.seek(offset[, from)

The seek() method accepts two parameters:

offset: It refers to the new position of the file pointer within the file.

from: It indicates the reference position from where the bytes are to be moved. If it is set to
0, the beginning of the file is used as the reference position. If it is set to 1, the current
position of the file pointer is used as the reference position. If it is set to 2, the end of the file
pointer is used as the reference position.

Consider the following example.

Example

# open the file file2.txt in read mode

fileptr = open("file2.txt","r")

#initially the filepointer is at 0

print("The filepointer is at byte :",fileptr.tell())

#changing the file pointer location to 10.

fileptr.seek(10);

#tell() returns the location of the fileptr.

print("After reading, the filepointer is at:",fileptr.tell())

Output:

The filepointer is at byte : 0

After reading, the filepointer is at: 10

• Python OS module

Renaming the file

The Python os module enables interaction with the operating system. The os module provides
the functions that are involved in file processing operations like renaming, deleting, etc. It
provides us the rename() method to rename the specified file to a new name. The syntax to
use the rename() method is given below.

Syntax:
1. rename(current-name, new-name)

The first argument is the current file name and the second argument is the modified name.
We can change the file name bypassing these two arguments.

Example 1:

import os

#rename file2.txt to file3.txt

os.rename("file2.txt","file3.txt")

Output:

The above code renamed current file2.txt to file3.txt

Removing the file

The os module provides the remove() method which is used to remove the specified file. The
syntax to use the remove() method is given below.

1. remove(file-name)

Example 1

1. import os;
2. #deleting the file named file3.txt
3. os.remove("file3.txt")

Creating the new directory

The mkdir() method is used to create the directories in the current working directory. The
syntax to create the new directory is given below.

Syntax:

mkdir(directory name)

Example 1

import os

#creating a new directory with the name new

os.mkdir("new")
 The getcwd() method

This method returns the current working directory.

The syntax to use the getcwd() method is given below.

Syntax

os.getcwd()

Example

import os
os.getcwd()

Output:

'C:\\Users\\DEVANSH SHARMA'

Changing the current working directory

The chdir() method is used to change the current working directory to a specified directory.

The syntax to use the chdir() method is given below.

Syntax

1. chdir("new-directory")

Example

import os
# Changing current directory with the new directiory
os.chdir("C:\\Users\\DEVANSH SHARMA\\Documents")
#It will display the current working directory
os.getcwd()

Output:

'C:\\Users\\DEVANSH SHARMA\\Documents'

Deleting directory

The rmdir() method is used to delete the specified directory.

The syntax to use the rmdir() method is given below.

 Syntax

1. os.rmdir(directory name)

Example 1

import os
#removing the new directory
os.rmdir("directory_name")

It will remove the specified directory.

Writing Python output to the files

In Python, there are the requirements to write the output of a Python script to a file.

The check_call() method of module subprocess is used to execute a Python script and write
the output of that script to a file.

The following example contains two python scripts. The script file1.py executes the script
file.py and writes its output to the text file output.txt.

Example

file.py

temperatures=[10,-20,-289,100]
def c_to_f(c):
if c< -273.15:
return "That temperature doesn't make sense!"
else:
f=c*9/5+32
return f
for t in temperatures:
print(c_to_f(t))

file.py

import subprocess

with open("output.txt", "wb") as f:

subprocess.check_call(["python", "file.py"], stdout=f)
The file related methods

The file object provides the following methods to manipulate the files on various operating
systems.

SN Method Description

1 file.close() It closes the opened file. The file once closed, it can't be
read or write anymore.

2 File.fush() It flushes the internal buffer.

3 File.fileno() It returns the file descriptor used by the underlying

implementation to request I/O from the OS.

4 File.isatty() It returns true if the file is connected to a TTY device,

otherwise returns false.

5 File.next() It returns the next line from the file.

6 File.read([size]) It reads the file for the specified size.

7 File.readline([size]) It reads one line from the file and places the file pointer
to the beginning of the new line.

8 File.readlines([sizehint]) It returns a list containing all the lines of the file. It reads
the file until the EOF occurs using readline() function.

9 File.seek(offset[,from) It modifies the position of the file pointer to a specified

offset with the specified reference.
10 File.tell() It returns the current position of the file pointer within the
file.

11 File.truncate([size]) It truncates the file to the optional specified size.

12 File.write(str) It writes the specified string to a file

13 File.writelines(seq) It writes a sequence of the strings to a file.

Python Modules

A python module can be defined as a python program file which contains a python code
including python functions, class, or variables. In other words, we can say that our python
code file saved with the extension (.py) is treated as the module. We may have a runnable
code inside the python module.

Modules in Python provides us the flexibility to organize the code in a logical way.

To use the functionality of one module into another, we must have to import the specific
module.

Example

In this example, we will create a module named as file.py which contains a function func that
contains a code to print some message on the console.

Let's create the module named as file.py.

#displayMsg prints a message to the name being passed.

def displayMsg(name)
print("Hi "+name);

Here, we need to include this module into our main module to call the method displayMsg()
defined in the module named file.
 Loading the module in our python code

We need to load the module in our python code to use its functionality. Python provides two
types of statements as defined below.

1. The import statement

2. The from-import statement

The import statement

The import statement is used to import all the functionality of one module into another. Here,
we must notice that we can use the functionality of any python source file by importing that
file as the module into another python source file.

We can import multiple modules with a single import statement, but a module is loaded once
regardless of the number of times, it has been imported into our file.

The syntax to use the import statement is given below.

1. import module1,module2,........ module n

Hence, if we need to call the function displayMsg() defined in the file file.py, we have to
import that file as a module into our module as shown in the example below.

Example:
import file;
name = input("Enter the name?")
file.displayMsg(name)

Output:

Enter the name?John

Hi John

The from-import statement

Instead of importing the whole module into the namespace, python provides the flexibility to
import only the specific attributes of a module. This can be done by using from? import
statement. The syntax to use the from-import statement is given below.

1. from < module-name> import <name 1>, <name 2>..,<name n>

Consider the following module named as calculation which contains three functions as
summation, multiplication, and divide.
 calculation.py:

#place the code in the calculation.py

def summation(a,b):
return a+b
def multiplication(a,b):
return a*b;
def divide(a,b):
return a/b;

Main.py:

from calculation import summation

#it will import only the summation() from calculation.py
a = int(input("Enter the first number"))
b = int(input("Enter the second number"))
print("Sum = ",summation(a,b)) #we do not need to specify the module name while acce
ssing summation()

Output:

Enter the first number10

Enter the second number20
Sum = 30

The from...import statement is always better to use if we know the attributes to be imported
from the module in advance. It doesn't let our code to be heavier. We can also import all the
attributes from a module by using *.

Consider the following syntax.

1. from <module> import *

Renaming a module

Python provides us the flexibility to import some module with a specific name so that we can
use this name to use that module in our python source file.

The syntax to rename a module is given below.

1. import <module-name> as <specific-name>

Example
1. #the module calculation of previous example is imported in this example as cal.
2. import calculation as cal;
3. a = int(input("Enter a?"));
4. b = int(input("Enter b?"));
5. print("Sum = ",cal.summation(a,b))

Output:

Enter a?10
Enter b?20
Sum = 30

Using dir() function

The dir() function returns a sorted list of names defined in the passed module. This list
contains all the sub-modules, variables and functions defined in this module.

Consider the following example.

Example
import json

List = dir(json)

print(List)

Output:

['JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__builtins__', '__cached__',

'__doc__',
'__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__',
'_default_decoder', '_default_encoder', 'decoder', 'dump', 'dumps', 'encoder', 'load', 'loads',
'scanner']

The reload() function

As we have already stated that, a module is loaded once regardless of the number of times it
is imported into the python source file. However, if you want to reload the already imported
module to re-execute the top-level code, python provides us the reload() function. The syntax
to use the reload() function is given below.

1. reload(<module-name>)

for example, to reload the module calculation defined in the previous example, we must use
the following line of code.

1. reload(calculation)
Scope of variables

In Python, variables are associated with two types of scopes. All the variables defined in a
module contain the global scope unless or until it is defined within a function.

All the variables defined inside a function contain a local scope that is limited to this function
itself. We can not access a local variable globally.

If two variables are defined with the same name with the two different scopes, i.e., local and
global, then the priority will always be given to the local variable.

Consider the following example.

Example
• name = "john"
• def print_name(name):
• print("Hi",name) #prints the name that is local to this function only.
• name = input("Enter the name?")
• print_name(name)

Output:

Hi David

Python packages

The packages in python facilitate the developer with the application development
environment by providing a hierarchical directory structure where a package contains sub-
packages, modules, and sub-modules. The packages are used to categorize the application
level code efficiently.

Let's create a package named Employees in your home directory. Consider the following
steps.

1. Create a directory with name Employees on path /home.

2. Create a python source file with name ITEmployees.py on the path /home/Employees.

ITEmployees.py

def getITNames():
List = ["John", "David", "Nick", "Martin"]
return List;
 3. Similarly, create one more python file with name BPOEmployees.py and create a function
getBPONames().

4. Now, the directory Employees which we have created in the first step contains two python
modules. To make this directory a package, we need to include one more file here, that is
__init__.py which contains the import statements of the modules defined in this directory.

__init__.py

1. from ITEmployees import getITNames

2. from BPOEmployees import getBPONames

5. Now, the directory Employees has become the package containing two python modules.
Here we must notice that we must have to create __init__.py inside a directory to convert this
directory to a package.

6. To use the modules defined inside the package Employees, we must have to import this in
our python source file. Let's create a simple python source file at our home directory (/home)
which uses the modules defined in this package.

Test.py

1. import Employees
2. print(Employees.getNames())

Output:

['John', 'David', 'Nick', 'Martin']

We can have sub-packages inside the packages. We can nest the packages up to any level
depending upon the application requirements.

The following image shows the directory structure of an application Library management
system which contains three sub-packages as Admin, Librarian, and Student. The sub-
packages contain the python modules.
Python Exception

An exception can be defined as an unusual condition in a program resulting in the

interruption in the flow of the program.

Whenever an exception occurs, the program stops the execution, and thus the further code is
not executed. Therefore, an exception is the run-time errors that are unable to handle to
Python script. An exception is a Python object that represents an error

Python provides a way to handle the exception so that the code can be executed without any
interruption. If we do not handle the exception, the interpreter doesn't execute all the code
that exists after the exception.

Python has many built-in exceptions that enable our program to run without interruption and
give the output. These exceptions are given below:

Common Exceptions

Python provides the number of built-in exceptions, but here we are describing the common
standard exceptions. A list of common exceptions that can be thrown from a standard Python
program is given below.

1. ZeroDivisionError: Occurs when a number is divided by zero.

2. NameError: It occurs when a name is not found. It may be local or global.
3. IndentationError: If incorrect indentation is given.
4. IOError: It occurs when Input Output operation fails.
 5. EOFError: It occurs when the end of the file is reached, and yet operations are being
performed.

The problem without handling exceptions

As we have already discussed, the exception is an abnormal condition that halts the execution
of the program.

Suppose we have two variables a and b, which take the input from the user and perform the
division of these values. What if the user entered the zero as the denominator? It will
interrupt the program execution and through a ZeroDivision exception. Let's see the
following example.

Example

a = int(input("Enter a:"))
b = int(input("Enter b:"))
c = a/b
print("a/b = %d" %c)

#other code:
print("Hi I am other part of the program")

Output:

Enter a:10
Enter b:0
Traceback (most recent call last):
File "exception-test.py", line 3, in <module>
c = a/b;
ZeroDivisionError: division by zero

The above program is syntactically correct, but it through the error because of unusual input.
That kind of programming may not be suitable or recommended for the projects because
these projects are required uninterrupted execution. That's why an exception-handling plays
an essential role in handling these unexpected exceptions. We can handle these exceptions in
the following way.

Exception handling in python

The try-expect statement

 If the Python program contains suspicious code that may throw the exception, we must place
that code in the try block. The try block must be followed with the except statement, which
contains a block of code that will be executed if there is some exception in the try block.

Syntax

1. try:
2. #block of code
3.
4. except Exception1:
5. #block of code
6.
7. except Exception2:
8. #block of code
9.
10. #other code

Consider the following example.

Example 1

try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
c = a/b
except:
print("Can't divide with zero")

Output:

Enter a:10
 Enter b:0
Can't divide with zero

We can also use the else statement with the try-except statement in which, we can place the
code which will be executed in the scenario if no exception occurs in the try block.

The syntax to use the else statement with the try-except statement is given below.

1. try:
2. #block of code
3.
4. except Exception1:
5. #block of code
6.
7. else:
8. #this code executes if no except block is executed

Consider the following program.

Example 2

try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
 c = a/b
print("a/b = %d"%c)
# Using Exception with except statement. If we print(Exception) it will return exception c
lass
except Exception:
print("can't divide by zero")
print(Exception)
else:
print("Hi I am else block")

Output:

Enter a:10
Enter b:0
can't divide by zero
<class 'Exception'>

The except statement with no exception

Python provides the flexibility not to specify the name of exception with the exception
statement.

Consider the following example.

Example

try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
c = a/b;
print("a/b = %d"%c)
except:
print("can't divide by zero")
else:
print("Hi I am else block")

The except statement using with exception variable

We can use the exception variable with the except statement. It is used by using
the as keyword. this object will return the cause of the exception. Consider the following
example:

try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
 c = a/b
print("a/b = %d"%c)
# Using exception object with the except statement
except Exception as e:
print("can't divide by zero")
print(e)
else:
print("Hi I am else block")

Output:

Enter a:10
Enter b:0
can't divide by zero
division by zero

Points to remember
1. Python facilitates us to not specify the exception with the except statement.
2. We can declare multiple exceptions in the except statement since the try block may
contain the statements which throw the different type of exceptions.
3. We can also specify an else block along with the try-except statement, which will be
executed if no exception is raised in the try block.
4. The statements that don't throw the exception should be placed inside the else block.

Example

try:
#this will throw an exception if the file doesn't exist.
fileptr = open("file.txt","r")
except IOError:
print("File not found")
else:
print("The file opened successfully")
fileptr.close()

Output:

File not found

Declaring Multiple Exceptions

The Python allows us to declare the multiple exceptions with the except clause. Declaring
multiple exceptions is useful in the cases where a try block throws multiple exceptions. The
syntax is given below.
 Syntax

1. try:
2. #block of code
3.
4. except (<Exception 1>,<Exception 2>,<Exception 3>,...<Exception n>)
5. #block of code
6.
7. else:
8. #block of code

Consider the following example.

try:
a=10/0;
except(ArithmeticError, IOError):
print("Arithmetic Exception")
else:
print("Successfully Done")

Output:

Arithmetic Exception

The try...finally block

Python provides the optional finally statement, which is used with the try statement. It is
executed no matter what exception occurs and used to release the external resource. The
finally block provides a guarantee of the execution.

We can use the finally block with the try block in which we can pace the necessary code,
which must be executed before the try statement throws an exception.

The syntax to use the finally block is given below.

Syntax

1. try:
2. # block of code
3. # this may throw an exception
4. finally:
5. # block of code
6. # this will always be executed
Example

try:
fileptr = open("file2.txt","r")
try:
fileptr.write("Hi I am good")
finally:
fileptr.close()
print("file closed")
except:
print("Error")

Output:

file closed
Error
 Raising exceptions

An exception can be raised forcefully by using the raise clause in Python. It is useful in in
that scenario where we need to raise an exception to stop the execution of the program.

For example, there is a program that requires 2GB memory for execution, and if the program
tries to occupy 2GB of memory, then we can raise an exception to stop the execution of the
program.

The syntax to use the raise statement is given below.

Syntax

1. raise Exception_class,<value>

Points to remember

1. To raise an exception, the raise statement is used. The exception class name follows
it.
2. An exception can be provided with a value that can be given in the parenthesis.
3. To access the value "as" keyword is used. "e" is used as a reference variable which
stores the value of the exception.
4. We can pass the value to an exception to specify the exception type.

Example

try:
age = int(input("Enter the age:"))
if(age<18):
raise ValueError
else:
print("the age is valid")
except ValueError:
print("The age is not valid")

Output:

Enter the age:17

The age is not valid

Example 2 Raise the exception with message

try:
num = int(input("Enter a positive integer: "))
 if(num <= 0):
# we can pass the message in the raise statement
raise ValueError("That is a negative number!")
except ValueError as e:
print(e)

Output:

Enter a positive integer: -5

That is a negative number!

Example 3

try:
a = int(input("Enter a:"))
b = int(input("Enter b:"))
if b is 0:
raise ArithmeticError
else:
print("a/b = ",a/b)
except ArithmeticError:
print("The value of b can't be 0")

Output:

Enter a:10
Enter b:0
The value of b can't be 0

Custom Exception

The Python allows us to create our exceptions that can be raised from the program and caught
using the except clause. However, we suggest you read this section after visiting the Python
object and classes.

Consider the following example.

Example

class ErrorInCode(Exception):
def __init__(self, data):
self.data = data
def __str__(self):
return repr(self.data)
 try:
raise ErrorInCode(2000)
except ErrorInCode as ae:
print("Received error:", ae.data)

Output:

Received error: 2000

Python Date and time

Python provides the datetime module work with real dates and times. In real-world
applications, we need to work with the date and time. Python enables us to schedule our
Python script to run at a particular timing.

In Python, the date is not a data type, but we can work with the date objects by importing the
module named with datetime, time, and calendar.

In this section of the tutorial, we will discuss how to work with the date and time objects in
Python.

The datetime classes are classified in the six main classes.

o date - It is a naive ideal date. It consists of the year, month, and day as attributes.
o time - It is a perfect time, assuming every day has precisely 24*60*60 seconds. It has
hour, minute, second, microsecond, and tzinfo as attributes.
o datetime - It is a grouping of date and time, along with the attributes year, month,
day, hour, minute, second, microsecond, and tzinfo.
o timedelta - It represents the difference between two dates, time or datetime instances
to microsecond resolution.
o tzinfo - It provides time zone information objects.
o timezone - It is included in the new version of Python. It is the class that implements
the tzinfo abstract base class.

Tick

In Python, the time instants are counted since 12 AM, 1st January 1970. The
function time() of the module time returns the total number of ticks spent since 12 AM, 1st
January 1970. A tick can be seen as the smallest unit to measure the time.

Consider the following example

 import time;
#prints the number of ticks spent since 12 AM, 1st January 1970
print(time.time())

Output:

1585928913.6519969

How to get the current time?

The localtime() functions of the time module are used to get the current time tuple. Consider
the following example.

Example

import time;

#returns a time tuple

print(time.localtime(time.time()))

Output:

time.struct_time(tm_year=2020, tm_mon=4, tm_mday=3, tm_hour=21, tm_min=21,

tm_sec=40, tm_wday=4, tm_yday=94, tm_isdst=0)

Time tuple

The time is treated as the tuple of 9 numbers. Let's look at the members of the time tuple.

Index Attribute Values

0 Year 4 digit (for example 2018)

1 Month 1 to 12

2 Day 1 to 31

3 Hour 0 to 23
4 Minute 0 to 59

5 Second 0 to 60

6 Day of weak 0 to 6

7 Day of year 1 to 366

8 Daylight savings -1, 0, 1 , or -1

Getting formatted time

The time can be formatted by using the asctime() function of the time module. It returns the
formatted time for the time tuple being passed.

Example

import time
#returns the formatted time

print(time.asctime(time.localtime(time.time())))

Output:

Tue Dec 18 15:31:39 2018

Python sleep time

The sleep() method of time module is used to stop the execution of the script for a given
amount of time. The output will be delayed for the number of seconds provided as the float.

Consider the following example.

Example

import time
for i in range(0,5):
print(i)
#Each element will be printed after 1 second
 time.sleep(1)

Output:

0
1
2
3
4

The datetime Module

The datetime module enables us to create the custom date objects, perform various
operations on dates like the comparison, etc.

To work with dates as date objects, we have to import the datetime module into the python
source code.

Consider the following example to get the datetime object representation for the current
time.

Example

import datetime
#returns the current datetime object
print(datetime.datetime.now())

Output:

2020-04-04 13:18:35.252578

Creating date objects

We can create the date objects bypassing the desired date in the datetime constructor for
which the date objects are to be created.

Consider the following example.

Example

import datetime
#returns the datetime object for the specified date
print(datetime.datetime(2020,04,04))

Output:
2020-04-04 00:00:00

We can also specify the time along with the date to create the datetime object. Consider the
following example.

Example

import datetime

#returns the datetime object for the specified time

print(datetime.datetime(2020,4,4,1,26,40))

Output:

2020-04-04 01:26:40

In the above code, we have passed in datetime() function year, month, day, hour, minute, and
millisecond attributes in a sequential manner.

Comparison of two dates

We can compare two dates by using the comparison operators like >, >=, <, and <=.

Consider the following example.

Example

from datetime import datetime as dt

#Compares the time. If the time is in between 8AM and 4PM, then it prints working hours
otherwise it prints fun hours
if dt(dt.now().year,dt.now().month,dt.now().day,8)<dt.now()<dt(dt.now().year,dt.now().m
onth,dt.now().day,16):
print("Working hours....")
else:
print("fun hours")

Output:

fun hours

The calendar module

Python provides a calendar object that contains various methods to work with the calendars.

Consider the following example to print the calendar for the last month of 2018.
 Example

import calendar;
cal = calendar.month(2020,3)
#printing the calendar of December 2018
print(cal)

Output:

March 2020
Mo Tu We Th Fr Sa Su
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31

Printing the calendar of whole year

The prcal() method of calendar module is used to print the calendar of the entire year. The
year of which the calendar is to be printed must be passed into this method.

Example

1. import calendar
2. #printing the calendar of the year 2019
3. s = calendar.prcal(2020)

Output:
 Python Regular Expressions

The regular expressions can be defined as the sequence of characters which are used to search
for a pattern in a string. The module re provides the support to use regex in the python
program. The re module throws an exception if there is some error while using the regular
expression.

The re module must be imported to use the regex functionalities in python.

1. import re

Regex Functions

The following regex functions are used in the python.

SN Function Description
1 match This method matches the regex pattern in the string with the optional
flag. It returns true if a match is found in the string otherwise it returns
false.

2 search This method returns the match object if there is a match found in the
string.

3 findall It returns a list that contains all the matches of a pattern in the string.

4 split Returns a list in which the string has been split in each match.

5 sub Replace one or many matches in the string.

Forming a regular expression

A regular expression can be formed by using the mix of meta-characters, special sequences,
and sets.

Meta-Characters

Metacharacter is a character with the specified meaning.

Metacharacter Description Example

[] It represents the set of characters. "[a-z]"

\ It represents the special sequence. "\r"

. It signals that any character is present at some specific "Pe.a."

place.

^ It represents the pattern present at the beginning of the "^sus"

 string.

$ It represents the pattern present at the end of the string. "asus$"

* It represents zero or more occurrences of a pattern in the "hello*"

string.

+ It represents one or more occurrences of a pattern in the "hello+"

string.

{} The specified number of occurrences of a pattern the "pega{2}"

string.

| It represents either this or that "pega|sus"

Char i = 0

3. str1 = 'Pegasus' 4. 5. while i < len(str1): 6. if

str1[i] == 'a' or str1[i] == 'u': 7. i += 1 8.
continue 9. print('Current Letter :', a[i]) 10. i += 1
er is present.

() Capture and group

Special Sequences

Special sequences are the sequences containing \ followed by one of the characters.

Character Description

\A It returns a match if the specified characters are present at the beginning of the
string.
\b It returns a match if the specified characters are present at the beginning or the
end of the string.

\B It returns a match if the specified characters are present at the beginning of the
string but not at the end.

\d It returns a match if the string contains digits [0-9].

\D It returns a match if the string doesn't contain the digits [0-9].

\s It returns a match if the string contains any white space character.

\S It returns a match if the string doesn't contain any white space character.

\w It returns a match if the string contains any word characters.

\W It returns a match if the string doesn't contain any word.

\Z Returns a match if the specified characters are at the end of the string.

Sets

A set is a group of characters given inside a pair of square brackets. It represents the special
meaning.

SN Set Description

1 [arn] Returns a match if the string contains any of the specified characters in
the set.
2 [a-n] Returns a match if the string contains any of the characters between a to
n.

3 [^arn] Returns a match if the string contains the characters except a, r, and n.

4 [0123] Returns a match if the string contains any of the specified digits.

5 [0-9] Returns a match if the string contains any digit between 0 and 9.

6 [0-5][0- Returns a match if the string contains any digit between 00 and 59.
9]

10 [a-zA-Z] Returns a match if the string contains any alphabet (lower-case or upper-
case).

The findall() function

This method returns a list containing a list of all matches of a pattern within the string. It
returns the patterns in the order they are found. If there are no matches, then an empty list is
returned.

Consider the following example.

Example

import re

str = "How are you. How is everything"

matches = re.findall("How", str)

print(matches)

print(matches)

Output:
 ['How', 'How']

The match object

The match object contains the information about the search and the output. If there is no
match found, the None object is returned.

Example

1. import re
2.
3. str = "How are you. How is everything"
4.
matches = re.search("How", str)

print(type(matches))

print(matches) #matches is the search object

Output:

<class '_sre.SRE_Match'>
<_sre.SRE_Match object; span=(0, 3), match='How'>

The Match object methods

There are the following methods associated with the Match object.

1. span(): It returns the tuple containing the starting and end position of the match.
2. string(): It returns a string passed into the function.
3. group(): The part of the string is returned where the match is found.

Example

1. import re
2.
3. str = "How are you. How is everything"
4.
5. matches = re.search("How", str)
6.
print(matches.span())

print(matches.group())

print(matches.string)
Output:

(0, 3)
How
How are you. How is everything