UNIT-III

Sets, Dictionary and Functions

Python Set

A Python set is the collection of the unordered items. Each element in the set must be
unique, immutable, and the sets remove the duplicate elements. Sets are mutable
which means we can modify it after its creation.

Unlike other collections in Python, there is no index attached to the elements of the
set, i.e., we cannot directly access any element of the set by the index. However, we can
print them all together, or we can get the list of elements by looping through the set.

Creating a set

The set can be created by enclosing the comma-separated immutable items with the
curly braces {}. Python also provides the set() method, which can be used to create the
set by the passed sequence.

Example 1: Using curly braces

1. Days = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",

"Sunday"}
2. print(Days)
3. print(type(Days))
4. print("looping through the set elements ... ")
5. for i in Days:
6. print(i)

Output:

{'Friday', 'Tuesday', 'Monday', 'Saturday', 'Thursday', 'Sunday', 'Wednesday'}

<class 'set'>
looping through the set elements ...
Friday
Tuesday
Monday
Saturday
Thursday
Sunday
Wednesday

Example 2: Using set() method

1. Days = set(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",

"Sunday "])
2. print(Days)
3. print(type(Days))
4. print("looping through the set elements ... ")
5. for i in Days:
6. print(i)
Output:

{'Friday', 'Wednesday', 'Thursday', 'Saturday', 'Monday', 'Tuesday', 'Sunday'}

<class 'set'>
looping through the set elements ...
Friday
Wednesday
Thursday
Saturday
Monday
Tuesday
Sunday

It can contain any type of element such as integer, float, tuple etc. But mutable
elements (list, dictionary, set) can't be a member of set. Consider the following
example.

1. # Creating a set which have immutable elements

2. set1 = {1,2,3, "Python", 20.5, 14}
3. print(type(set1))
4. #Creating a set which have mutable element
5. set2 = {1,2,3,["Python",4]}
6. print(type(set2))

Output:

<class 'set'>

Traceback (most recent call last)

<ipython-input-5-9605bb6fbc68> in
<module> 4
5 #Creating a set which holds mutable elements
----> 6 set2 = {1,2,3,["Python",4]}
7 print(type(set2))
TypeError: unhashable type:
'list'
In the above code, we have created two sets, the set set1 have immutable elements and
set2 have one mutable element as a list. While checking the type of set2, it raised an
error, which means set can contain only immutable elements.

Creating an empty set is a bit different because empty curly {} braces are also used
to create a dictionary as well. So Python provides the set() method used without an
argument to create an empty set.

1. # Empty curly braces will create dictionary

2. set3 = {}
3. print(type(set3))
4. # Empty set using set() function
5. set4 = set()
6. print(type(set4))

Output:
<class 'dict'>
<class 'set'>

Let's see what happened if we provide the duplicate element to the set.

1. set5 = {1,2,4,4,5,8,9,9,10}
2. print("Return set with unique elements:",set5)

Output:
Return set with unique elements: {1, 2, 4, 5, 8, 9, 10}

In the above code, we can see that set5 consisted of multiple duplicate elements when
we printed it remove the duplicity from the set.

Adding items to the set

Python provides the add() method and update() method which can be used to add some
particular item to the set. The add() method is used to add a single element whereas the
update() method is used to add multiple elements to the set. Consider the
following example.

Example: 1 - Using add() method

1. Months = set(["January","February", "March", "April", "May", "June"])

2. print("\nprinting the original set ... ")
3. print(months)
4. print("\nAdding other months to the set...");
5. Months.add("July");
6. Months.add ("August");
7. print("\nPrinting the modified set...");
8. print(Months)
9. print("\nlooping through the set elements ... ")
10. for i in Months:
11. print(i)

Output:
printing the original set ...
{'February', 'May', 'April', 'March', 'June',
'January'} Adding other months to the set...
Printing the modified set...
 {'February', 'July', 'May', 'April', 'March', 'August', 'June', 'January'}

looping through the set elements ...

February
July
May
April
March
August
June
Januay

To add more than one item in the set, Python provides the update() method. It
accepts iterable as an argument.

Consider the following example.

Example - 2 Using update() function

1. Months = set(["January","February", "March", "April", "May", "June"])

2. print("\nprinting the original set ... ")
3. print(Months)
4. print("\nupdating the original set ... ")
5. Months.update(["July","August","September","October"]);
6. print("\nprinting the modified set ... ")
7. print(Months);

Output:

printing the original set ...

{'January', 'February', 'April', 'May', 'June', 'March'}

updating the original set ...

printing the modified set
...
{'January', 'February', 'April', 'August', 'October', 'May', 'June', 'July', 'September',
'March'}
, 'July', 'September', 'March'}

Dictionary:
A dictionary is a collection which is unordered, changeable and indexed. In Python
dictionaries are written with curly brackets, and they have keys and values.
 Key-value pairs
 Unordered

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.

We can construct or create dictionary like:

X={1:‟A‟,2:‟B‟,3:‟c‟}
X=dict([(„a‟,3) („b‟,4)]
X=dict(„A‟=1,‟B‟ =2)
Example:
dict1 = {"brand":"NEC","model":"college","year":2004}
print(dict1)

Output
{'brand': 'NEC', 'model': 'college', 'year': 2004}

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.

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

2. print(type(Employee))
3. print("printing Employee data..")
4. 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.

1. # Creating an empty Dictionary

2. Dict = {}
3. print("Empty Dictionary: ")
4. print(Dict)
5. # Creating a Dictionary
6. # with dict() method
7. Dict = dict({1: 'Python', 2: 'T', 3:'Point'})
8. print("\nCreate Dictionary by using dict(): ")
9. print(Dict)
10. # Creating a Dictionary
11. # with each item as a Pair
12. Dict = dict([(1, 'Devansh'), (2, 'Sharma')])
13. print("\nDictionary with each item as a pair: ")
14. print(Dict)

Output:
Empty Dictionary:
{}

Create Dictionary by using dict():

{1: 'Python', 2: 'T', 3: 'Point'}

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.

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

2. print(type(Employee))
3. print("printing Employee data..")
4. print("Name : %s" %Employee["Name"])
5. print("Age : %d" %Employee["Age"])
6. print("Salary : %d" %Employee["salary"])
7. print("Company : %s" %Employee["Company"])

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

Operations and methods:

Methods that are available with dictionary are tabulated below. Some of them have already
been used in the above examples.

Method Description

clear()
Remove all items form the dictionary.
copy()
Return a shallow copy of the dictionary.
fromkeys(seq[, v])
Return a new dictionary with keys from seq and
value equal to v (defaults to None).
get(key[,d])
Return the value of key. If key doesnot exit,
return d (defaults to None).
items()
Return a new view of the dictionary's items(key, value).
keys()
Return a new view of the dictionary's keys.
pop(key[,d])
Remove the item with key and return its value or d if key is not found. If d is not provided and
key is not found, raises KeyError.
popitem()
Remove and return an arbitary item (key,value). Raises KeyError if the dictionary is empty.
setdefault(key[,d])
If key is in the dictionary, return its value. If not, insert key with a value of d and
return d (defaults to None).
update([other])
Update the dictionary with the key/value pairs
from other, overwriting existing keys.
values() Return a new view of the dictionary's values

Built-in Dictionary functions

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

SN Function Description

1 cmp(dict1, dict2) It compares the items of both the dictionary and returns
true if the first 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.

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 pop() Delete the element and return the deleted
element
3 dict.fromkeys(iterabl value =
Create a new dictionary from the iterable
e, None, /)
with the values equal to value.

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

"None") passed key.

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

"None") the key is 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() It is used to count the no. of items in a dictiobnary

12 popItem() It is used to extract the last item of dictionary

It is used to find the occurance of a value in a

13 count() dictionary.
 14 index() It returns the index of a particular value in a
dictionary

Below are some dictionary operations:

To access specific value of a dictionary, we must pass its key,

dict1 = {"brand":"NEC","model":"college","year":2004}
x=dict1["brand"]
print(x)
Output
'NEC'

To access keys and values and items of dictionary:

dict1 = {"brand":"NEC","model":"college","year":2004}
print (dict1.keys())
print (dict1.values())
print (dict1.items())

Output
dict_keys(['brand', 'model', 'year'])
dict_values (['NEC', 'college', 2004])
dict_items ([('brand', 'NEC'), ('model', 'college'), ('year', 2004)])

for items in dict1.values():

print(items)
Output
NEC
college
2004

for items in dict1.keys():

print(items)
Output
brand
model
year

for i in dict1.items():
print(i)
Output
('brand', 'NEC')
('model', 'college')
('year', 2004)
Some more operations like:
 Add/change
 Remove
 Length
 Delete
Add/change values: You can change the value of a specific item by referring to its key name
dict1 = {"brand":"NEC","model":"college","year":2004}
dict1["year"]=2005
print(dict1)
Output
{'brand': 'NEC', 'model': 'college', 'year': 2005}

Remove(): It removes or pop the specific item of dictionary.

dict1 = {"brand":"NEC","model":"college","year":2004}
print(dict1.pop("model"))
print(dict1)
Output
college
{'brand': 'NEC', 'year': 2005}

Delete: Deletes a particular item.

x = {1:1, 2:4, 3:9, 4:16, 5:25}
del x[5]
print(x)
Output
{1:1, 2:4, 3:9, 4:16}

Length: we use len() method to get the length of dictionary.

x={1: 1, 2: 4, 3: 9, 4: 16}
y=len(x)
print( y)
Output
4
Iterating over (key, value) pairs:
x = {1:1, 2:4, 3:9, 4:16, 5:25}
for key in x:
print(key, x[key])
Output
11
24
39
4 16
5 25
for k,v in x.items():
print(k,v)
Output
11
24
39
4 16
5 25

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.

1. Employee={"Name":"John","Age":29,"Salary":25000,"Company":"GOOGLE","Name":
 "Joh n"}
2. for x,y in Employee.items():
3. 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.

1. Employee = {"Name": "John", "Age": 29,

"salary":25000,"Company":"GOOGLE",[100,201, 301]:"Department ID"}
2. for x,y in Employee.items():
3. 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'

List of Dictionaries:
customer=[{"uid":1,"name":"John"},{"uid":2,"name":"Smith"},
{"uid":3,"name":"Andersson}]
print(customers)
Output
[{'uid': 1, 'name': 'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name': 'Andersson'}]

## Print the uid and name of each customer

for x in customers:
print(x["uid"], x["name"])
Output
1 John
2 Smith
3 Andersson

## Modify an entry, This will change the name of customer 2 from Smith to Charlie
customers[2]["name"]="charlie"
print(customers)
Output
[{'uid': 1, 'name': 'John'}, {'uid': 2, 'name': 'Smith'}, {'uid': 3, 'name': 'charlie'}]
## Add a new field to each entry
>>> for x in customers:
x["password"]="123456" # any initial value
print(customers)
Output
[{'uid': 1, 'name': 'John', 'password': '123456'}, {'uid': 2, 'name': 'Smith', 'password':
'123456'}, {'uid': 3, 'name': 'charlie', 'password': '123456'}]

## Delete a field
del customers[1]
print(customers)
Output
[{'uid': 1, 'name': 'John', 'password': '123456'}, {'uid': 3, 'name': 'charlie', 'password':
'123456'}]

del customers[1]
print(customers)
Output
[{'uid': 1, 'name': 'John', 'password': '123456'}]

## Delete all fields

>>> for x in customers:
del x["uid"]
print(x)
Output
{'name': 'John', 'password': '123456'}

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

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

# 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

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

2. #defining the function
3. def sum (a,b):
4. return a+b;
5. #taking values from the user
6. a = int(input("Enter a: "))
7. b = int(input("Enter b: "))
8. #printing the sum of a and b
9. 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 mutable 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. #defining the list
7. list1 = [10,30,40,50]
8. #calling the function
9. change_list(list1)
10. 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 Imutable 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. string1 = "Hi I am there"
6. #calling the function
7. change_string(string1)
8. 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

1. def func(name):
2. message = "Hi "+name
3. return message
4. name = input("Enter the name:")
5. print(func(name)
) Output:
Enter the name: John
Hi John
Example 2
1. #the function simple_interest accepts three arguments and returns the simple interest
accordin gly
2. def simple_interest(p,t,r):
3. return (p*t*r)/100
4. p = float(input("Enter the principle amount? "))
5. r = float(input("Enter the rate of interest? "))
6. t = float(input("Enter the time in years? "))
7. 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
1. def printme(name,age=22):
2. print("My name is",name,"and age is",age)
3. 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

1. def printme(*names):
2. print("type of passed argument is ",type(names))
3. print("printing the passed arguments...")
4. for name in names:
5. print(name)
6. 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

1. #function func is called with the name and message as the keyword arguments
2. def func(name, message):
3. print("printing the message with", name, "and ",message)
4. #name and message is copied with the values John and hello respectively
5. func(name = "John", message="hello")
Output:
printing the message with John and hello
Example 2 providing the values in different order at the calling
1. #The function simple_interest(p, t, r) is called with the keyword arguments the order
of argu ments doesn't matter in this case
2. def simple_interest(p, t, r):
3. return (p*t*r)/100
4. 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. # doesn't find the exact match of the name of the arguments (keywords)
5. 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

1. def food(**kwargs):
2. print(kwargs)
3. food(a="Apple")
4. food(fruits="Orange", Vegetables="Carrot")
Output:
{'a': 'Apple'}
{'fruits': 'Orange', 'Vegetables': '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

1. def print_message():
2. message = "hello !! I am going to print a message." # the variable message is local to
the fu nction itself
3. print(message)
4. print_message()
5. 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

Example 3
def calculate(*args):
global sum#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)

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

Python Lambda Functions (Anonymous Function)

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

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

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

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

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.

1. def x(a):
2. return a+10
3. print(“sum =”, x(10))
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))

mul = 200

Example

#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
returned 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

References:

1. https://www.javatpoint.com/python-tutorial
2. https://www.w3schools.com/python/
3. https://www.tutorialspoint.com/python/index.htm
4. https://www.geeksforgeeks.org/python-programming-language/