Session10_Dictionaries.ppggyyyyyyyyyggggggggtx

The dictionary data structure
 In Python, a dictionary is mapping between a set of indices (keys)
and a set of values
 The items in a dictionary are key-value pairs
 Keys can be any Python data type
 Because keys are used for indexing, they should be immutable
 Values can be any Python data type
 Values can be mutable or immutable
#In general, the order of items in a dictionary is unpredictable
#Dictionaries are indexed by keys, not integers
#Note that the in operator works differently for dictionaries
than for
other sequences
• For offset indexed sequences (strings, lists, tuples), x in y
checks to see whether x is an item in the sequence
• For dictionaries, x in y checks to see whether x is a key
in the dictionary

Creating a Dictionary
#Creating Dictionary
d=dict()#Empty Dictionary
print(type(d))#<class
'dict'> d={}
print(type(d))#<class
'dict'>
#Initialization-ex a key
Value pair of Name & Age
d={"Ram":30, "Jai":40}
print(d)
Output-
{'Ram': 30, 'Jai': 40}

Accessing Values
#Accessing Dictionary Values
d={'Ram': 30, 'Jai': 40, 'Hari': 25, 'Shyam': 30,
'Jhon': 25}
x=d['Ram']
print(x)# 30
print(d['Ram'])# 30
print(d.get('Ram'))# 30
print(d.setdefault("Ram"))# 30
#KeyError--if key is not present python raises exception
print(d['James'])# KeyError: 'James'
print(d.setdefault(“Anu"))#None

Adding Elements
#Adding values to dictionary
d={}
d['James']=7
8 print(d)
d.update({‘R
am':42})#if
key present
updates
value else
add key to
dictionary
print(d)
d.setdefault('Syam',2
6) print(d)
#using user input
d[input('Enter
Key')]=eval(input('En
ter Value'))
print(d)
d.setdefault(input('E
nter

Suppressing keyError
#Supressing KeyError
d={"Jhon":34, 1:23, "Harry":25, 22:'abc'}
#Accessing a key not present--suppressing keyError--
Method--1
print(d.get("Alice"))#returns None by
default print(d)#Alice will not be added
as a key in d ##Customizing get
#Override default None by Some customized
value print(d.get("Alice", "Key not found
in dict")) #Method--2
print(d.setdefault("Alice"))
#returns None and key added to dictionary--
value None
print(d.setdefault("Joe", 48))
#returns 48 and key added--value 48
print(d)

Keys, values, items
#keys,values and items
d={'Jhon': 34, 1: 23, 'Harry': 25, 22: 'abc', 'Alice': 32,
'Joe': 48}
l=d.keys()#returns object dict_keys
#dict_keys(['Jhon', 1, 'Harry', 22, 'Alice', 'Joe'])
print(l)
t=d.values()#returns dict_values
#dict_values([34, 23, 25, 'abc', 32,
48]) print(t)
s=d.items()#returns dict_items-- (key,value)
#dict_items([('Jhon', 34), (1, 23), ('Harry', 25), (22,
'abc'),
('Alice', 32), ('Joe', 48)])
print(s)
print(type(l))#<class
'dict_keys'>
print(type(t))#<class
'dict_values'>

Iterating Dictionary
#iterating dictionary
d={'Jhon': 34, 1: 23, 'Harry': 25, 22: 'abc', 'Alice':
None,
'Joe': 48}
for i in
d.keys():
print(i,d[i]
)
for k,v in
d.items():
print(k,v)
Output-
Jhon 34
1 23
Harry 25
22 abc
Alice None
Joe 48
Jhon 34
1 23
Harry 25
22 abc
Alice None
Joe 48

Dictionary Methods-
update()-
The update() method updates the value of the key provided
to it if the item already exists in the dictionary, else it
creates a new key-value pair.
Example:
info = {'name':'Karan', 'age':19, 'eligible':True}
print(info)
info.update({'age':20})
info.update({'DOB':2001})
print(info)
Output:
{'name': 'Karan', 'age': 19, 'eligible': True}
{'name': 'Karan', 'age': 20, 'eligible': True, 'DOB': 2001}

The setdefault() method in Python dictionaries is used to retrieve the value of a specified
key. If the key does not exist in the dictionary, it will insert the key with a specified default
value. This method is helpful when you want to ensure that a key exists in the dictionary
and has a value, without having to check manually
# Creating a dictionary
my_dict = {'name': 'Alice', 'age': 25}
# Using setdefault() to get the value of an existing key
value = my_dict.setdefault('name', 'Unknown')
print(value) # Output: Alice
# Using setdefault() to add a new key with a default value
new_value = my_dict.setdefault('city', 'New York')
print(new_value) # Output: New York
# The updated dictionary
print(my_dict) # Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}
setdefault()

The pop() method removes the key-value pair whose key is
passed as a parameter.
Example:
info.pop('eligible')
print(info)
Output:
{'name': 'Karan', 'age': 19}
pop()

The popitem() method removes the last key-value pair from
the dictionary.
Example:
info = {'name':'Karan', 'age':19, 'eligible':True,
'DOB':2003}
info.popitem()
print(info)
Output:
{'name': 'Karan', 'age': 19, 'eligible': True}
popitem()

The clear() method removes all the items from the list.
Example:
info.clear()
print(info)
Output:
{}
clear()

we can also use the del keyword to remove a dictionary item.
Example:
'DOB':2003}
del info['age']
print(info)
Output:
{'name': 'Karan', 'eligible': True, 'DOB': 2003}
If key is not provided, then the del keyword will delete the
dictionary entirely.
Example:
'DOB':2003}
del info
print(info)
Output:
NameError: name 'info' is not defined
del

Leftovers
15
 #Misc. Dictionary operations
 d={'Jhon': 34, 1: 23, ‘raj': 25, 22: 'abc', 'Alice': None,
'Joe': 48}
 s={'Jhon':32,'ken':19}
 d.update(s)
 print(d)#Existing key gets updated and new key gets added
 l=['ram',23.67,('shyam',67)]
 dt={}
 dt=dt.fromkeys(l)
 #creates dictioanry from a sequence of immutable-value is None
 print((dt))
 dt=dt.fromkeys(l,-1)#default value is -1
 print(dt)
{'Jhon': 32, 1: 23, ‘raj': 25, 22: 'abc', 'Alice': None, 'Joe': 48, 'ken': 19}
{'ram': None, 23.67: None, ('shyam', 67): None}
{'ram': -1, 23.67: -1, ('shyam', 67): -1}

Sorting
#sorting dictionary
d={'Jhon': 34, 'Ram': 23, 'Harry': 25, 'James': 97, 'Alice':
56,
'Joe': 48}
l=sorted(d)#returns sorted list of key
print(l)
Output- ['Alice', 'Harry', 'James', 'Jhon', 'Joe', 'Ram’]
l=sorted(d.keys())#returns list of key
print(l)
Output- ['Alice', 'Harry', 'James', 'Jhon', 'Joe', 'Ram’]
l=sorted(d.items())#returns list of sorted key value pair
based on key
print(l)
Output- [('Alice', 56), ('Harry', 25), ('James', 97),

l=sorted(d.values())#returns list of values
print(l)
Output-[23, 25, 34, 48, 56, 97]
l=sorted(d.items(), key=lambda x:x[1])#sort dictionary on
value
print(l)
Output- [('Ram', 23), ('Harry', 25), ('Jhon', 34), ('Joe',
48), ('Alice', 56), ('James', 97)]
l=sorted(d.items(), key=lambda x:x[0])#sort dictionary on
keys
print(l)
Output-[('Alice', 56), ('Harry', 25), ('James', 97),
('Jhon', 34), ('Joe', 48), ('Ram', 23)]
Sorting

Nested values(left)
18
#nested values & updation d={1:
['ab',34,45.67],23:['rt','yt','lo']}
d[1][1]=90
print(d)
Output- {1: ['ab', 90, 45.67], 23:
['rt', 'yt', 'lo’]}
d={'ab':{'a':2,'b':34},'bc':
{'x':89,90:'n'}} d['ab']['a']=4
print(d)
Output-
{'ab': {'a': 4, 'b': 34},
'bc': {'x': 89, 90: 'n'}}

l=['ram',23.67,
('shyam',67)] dt={}
dt=dt.fromkeys(l)
#creates dictioanry from
a sequence of immutable-
value is None
print((dt))
Output- {'ram': None,
23.67: None, ('shyam',
67): None}
dt=dt.fromkeys(l,-
1)#default value is -1
print(dt)
Nested values(left)

The else block in a for loop (or a while loop) in Python is unique.
It runs after the loop finishes executing all its iterations, but only if the loop was not
terminated by a break statement.
If the loop is terminated using break, the else block is skipped.
Ex-1
for x in range(5):
if x == 3:
break
print("Iteration no {} in for loop".format(x + 1))
else:
print("Else block in loop") # This won't be executed because of the break
print("Out of loop")
Output-
Iteration no 1 in for loop
Out of loop
else in loop

Ex- 2
i=0
While i<5:
print(i)
i+=1
else:
print("Loop completed without interruption")
Output-
0
1
2
3
4
Loop completed without interruption

A lambda function in Python is a small, anonymous function defined using the lambda
keyword.
It can have any number of arguments but only one expression.
It's often used when you need a simple function for a short period of time.
Syntax-
lambda arguments: expression
lambda function
Ex-
# Lambda function to add two numbers
add = lambda x, y: x + y
# Using the lambda function
result = add(5, 3)
print(result) # Output: 8

# Function to double the input
def double(x):
return x * 2
# Lambda function to double the input
lambda x: x * 2
```
The above lambda function has the same functionality as the
double function defined earlier. However, the lambda
function is anonymous, as it does not have a name.
lamda

Lambda
"""Lambda is a tiny function just like macro
in C"""
import math
square=lambda n:n*n
print(square(4)) #16
"""without arguement"""
x=lambda : math.factorial(4)
y=x()
print(y) #24
x=lambda x: math.factorial(x)
y=x(3)
print(y) #6
z=lambda:sum(range(1,4))
y=z()
print(y) #6
p=lambda x:print(x)
p("hello world") #hello world
w=square(3)
print(w) #9s
24
lamda

“Functions that take a function as an argument or return a function.
Called higher order function”
Example:
def foo(f):
f() # calling the function that is passed
def bar():
print "Hello bar"
foo(bar) # function bar is passed to function foo.
Output - Hello bar
Functions and methods are first-class citizen (objects) in Python, so if we want to pass a
function as an argument to another function, we can just treat it as any other object.
It’s worth noting that in some languages functions and objects are distinct, but in python
functions are implemented as objects (That also means functions have attributes).
Higher order function

sorted does pretty much the same thing what you expected.
# sorting numbers
In [0]: sorted([9, 5, 7])
Out[0]: [5, 7, 9]
# sorting alphabetically
In [0]: sorted(['foo', 'bar'])
Out[0]: ['bar', 'foo’]
Using Key :key:
Well you can also customize the sorting also, the parameter key. The key needs to be a
simple function the takes a single value that tells python the value to use in sorting it.
In [0]: sorted([1, -3, 2]) # sorting normally
Out[0]: [-3, 1, 2]
In [0]: sorted([1, -2, 0], key=abs) # sorting by absolute values
Out[0]: [0, 1, -2]
Note: abs is the absolute value function. i.e. abs(-3) = 3

In Python, the map, filter,
and reduce functions are
built-in functions that
allow you to apply a
function to a sequence of
elements and return a new
sequence. These functions
are known as higher-order
functions, as they take
other functions as
arguments.

Takes an input iterable of values and return a list with different values. Same order, same
length, but mapped via a function.
map(function, iterable) map takes a function as the first parameter and then an iterable
containing data.
Ex-
def twice(x):
return 2*x
ans= map(twice, [1, 2, 3, 4, 5])
print(ans)
Output -<map object at 0x7acb29ac2e30>
The conversion to a list (list(ans)) is required to immediately evaluate and display all the
values from the map object.
print(list(ans)) #ouput-[2,4,6,8,10]
map

map
The reason you need to type cast map() to list in order to get the output is that the
map() function in Python 3 returns a map object, which is an iterator. Iterators do not
compute their values immediately; instead, they produce the values one by one when
you iterate over them. To see the output all at once, you need to convert it to a list or
iterate through it.
Alternative Ways:
You can also use a for loop to iterate through the map object without converting it to a
list:
def twice(x):
return 2*x
ans= map(twice, [1, 2, 3, 4, 5])
for item in ans:
print(item, end=“”)
Output – 2 4 6 8 10

 filter takes a function and an iterable and produces an output list of every
item on the input list that passes a test.
 The filter function filters a sequence of elements based on a
given predicate (a function that returns a boolean value) and
returns a new sequence containing only the elements that meet the
predicate. The filter function has the following syntax:
filter(predicate, iterable)
 The predicate argument is a function that returns a boolean value
and is applied to each element in the iterable argument. The
iterable argument can be a list, tuple, or any other iterable
object.
In [0]: def greater_than_5(x):
return x > 5
In [1]: filter(greater_than_5, range[10])
Out[1]: [6, 7, 8, 9]
filter

Special case: When None is passed instead of function, it will filter by Truthiness.
filter(None, [0, 2, 1, 3])
[2, 1, 3]
filter(None, ['a','', 'b' ])
['a', ‘b’]
# filter using with lambda-
# List of numbers
numbers = [1, 2, 3, 4, 5]
# Get only the even numbers using the filter function
evens = filter(lambda x: x % 2 == 0, numbers)
# Print the even numbers
print(list(evens)) #[2,4]
filter

• reduce takes an iterable of input data and consumes it to come up with a single
value.
• The reduce function is a higher-order function that
applies a function to a sequence and returns a single
value. It is a part of the functools module in Python.
• The reduce function applies the function to the first two
elements in the iterable and then applies the function to
the result and the next element, and so on. The reduce
function returns the final result.
Ex-
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# Calculate the sum of the numbers using the reduce function
sum = reduce(lambda x, y: x + y, numbers)
print(sum) #15
reduce

The function we have to write is different too - the function will take two values
and typically reduce will consume the first two values from the iterable then
consume one value at a time from the list using the return value from the
previous call.
In [3]: def add(x,y):
...: return x + y
...:
In [4]: reduce(add, [1,2,3,4])
Out[4]: 10
reduce

Session10_Dictionaries.ppggyyyyyyyyyggggggggtx

Session10_Dictionaries.ppggyyyyyyyyyggggggggtx

More Related Content

Similar to Session10_Dictionaries.ppggyyyyyyyyyggggggggtx

More from pawankamal3

Recently uploaded

Session10_Dictionaries.ppggyyyyyyyyyggggggggtx