PYTHON DATA Mr Rupnar P.M.

STRUCTURES
DATA STRUCTURE IN PYTHON
The most basic data structure in Python is the sequence. Each element
of a sequence is assigned a number - its position or index. The first
index is zero, the second index is one, and so forth.
Python has six built-in types of sequences, but the most common ones
are lists and tuples, There are certain things you can do with all
sequence types. These operations include indexing, slicing, adding,
multiplying, and checking for membership. In addition, Python has
built-in functions for finding the length of a sequence and for finding its
largest and smallest elements.
LIST
Python Lists
The list is a most versatile datatype available in Python which can be
written as a list of comma-separated values (items) between square
brackets. Important thing about a list is that items in a list need not be of
the same type.
Creating a list is as simple as putting different comma-separated values
between square brackets.
For example −
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
LIST EXAMPLE
>>> L1=[17,18,15,19,14]
LIST ACCESS
languages = ["Python", "Swift", "C++"]

# access item at index 0

print(languages[2]) # C++

# access item at index 2

print(languages[-3]) # Python
ACCESSING VALUES IN LISTS
To access values in lists, use the square brackets for slicing along with
the index or indices to obtain value available at that index. For example

#!/usr/bin/python
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print ("list1[0]: ", list1[0] )
print ("list2[1:5]: ", list2[1:5])

When the above code is executed, it produces the following result −

list1[0]: physics
list2[:]: [2, 3, 4, 5]
ADDING ELEMENT
1. Using append()
The append() method adds an item at the end of the list. For example,

numbers = [21, 34, 54, 12]

print("Before Append:", numbers)

# using append method

numbers.append(32)
print("After Append:", numbers)
ADDING LIST ELEMENT
2. Using extend()
We use the extend() method to add all items of one list to another. For example,
prime_numbers = [2, 3, 5]
print("List1:", prime_numbers)
even_numbers = [4, 6, 8]
print("List2:", even_numbers)

# join two lists

prime_numbers.extend(even_numbers)
print("List after append:", prime_numbers)
Updating Lists
You can update single or multiple elements of lists by giving the slice on
the left-hand side of the assignment operator.

For example −
list = ['physics', 'chemistry', 1997, 2000]
print "Value available at index 2 : " print list[2]
list[2] = 2001
print "New value available at index 2 : "
print list[2]
UPDATING LIST ELEMENT
Change List Items
Python lists are mutable. Meaning lists are changeable. And, we can change items of a
list by assigning new values using = operator. For example,

languages = ['Python', 'Swift', 'C++']

# changing the third item to 'C'

languages[2] = 'C'

print(languages)
 Delete List Elements
To remove a list element, you can use either the del statement if you know
exactly which element(s) you are deleting or the remove() method if you do
not know.

For example −
list1 = ['physics', 'chemistry', 1997, 2000]
print (list1)
del list1[2]
print ("After deleting value at index 2 : " )
print (list1)
DELETE LIST ELEMENT
2. Using remove()
We can also use the remove() method to delete a list item. For example,

languages = ['Python', 'Swift', 'C++', 'C', 'Java',

'Rust', 'R']

# remove 'Python' from the list

languages.remove('Python')

print(languages)
 BASIC LIST OPERATIONS
Lists respond to the + and * operators much like strings; they mean
concatenation and repetition here too, except that the result is a new list, not
a string.
Python Expression Results Description
len([1, 2, 3]) 3 Length
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] Concatenation
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] Repetition
3 in [1, 2, 3] True Membership
for x in [1, 2, 3]:
123 Iteration
print x,
INDEXING, SLICING, AND
MATRIXES
Because lists are sequences, indexing and slicing work the same way for
lists as they do for strings.

Assuming following input −

L = ['spam', 'Spam', 'SPAM!']
Python Expression Results Description
L[2] SPAM! Offsets start at zero
Negative: count from
L[-2] Spam
the right
Slicing fetches
L[1:] ['Spam', 'SPAM!']
sections
BUILT-IN LIST FUNCTIONS
Sr.No. Function with Description
2 len(list) Gives the total length of the list.
3 max(list) Returns item from the list with max value.
4 min(list) Returns item from the list with min value.
PYTHON METHODS
Sr.No. Methods with Description

1 list.append(obj) Appends object obj to list

2 list.count(obj) Returns count of how many times obj occurs in list
3 list.extend(seq) Appends the contents of seq to list
4 list.index(obj) Returns the lowest index in list that obj appears
5 list.insert(index, obj) Inserts object obj into list at offset index
6 list.pop(obj=list[-1]) Removes and returns last object or obj from list
7 list.remove(obj) Removes object obj from list
8 list.reverse() Reverses objects of list in place
9 list.sort([func]) Sorts objects of list, use compare func if given
PYTHON LIST APPEND() METHOD
Python append() method adds an item to the end of the list. It appends an
element by modifying the list. The method does not return itself. The item
can also be a list or dictionary which makes a nested list. Method is
described below.
# Python list append() Method # Creating a list
list = ['1','2','3']
for l in list: # Iterating list
print(l)
# Appending element to the list
list.append(4)
print("List after appending element : ",list) # Displaying list
PYTHON LIST COUNT() METHOD
Python count() method returns the number of times element appears in
the list. If the element is not present in the list, it returns 0. The examples
and syntax is described below.
# Python list count() Method
# Creating a list
apple = ['a','p','p','l','e']
# Method calling
count = apple.count('p')
# Displaying result
print("count of p :",count)
PYTHON LIST EXTEND()
METHOD
Python extend() method extends the list by appending all the items from the
iterable. Iterable can be a List, Tuple or a Set. Examples are described below.
# Python list extend() Method
list = ['1','2','3']
for l in list: # Iterating list
print(l)
list.extend('4')
print("After extending:")
for l in list: # Iterating list
print(l)
PYTHON LIST INDEX() METHOD
Python index() method returns index of the passed element. This method
takes an argument and returns index of it. If the element is not present, it
raises a ValueError.
If list contains duplicate elements, it returns index of first occurred element.
This method takes two more optional parameters start and end which are used
to search index within a limit.
index(x[, start[, end]])
# Python list index() Method
# Creating a list apple = ['a','p','p','l','e']
# Method calling index = apple.index('p')
# Displaying result print("Index of p :",index)
PYTHON LIST INSERT(I,X)
METHOD
Python insert() method inserts the element at the specified index in the list. The first argument
is the index of the element before which to insert the element.

# Python list insert() Method

# Creating a list
list = ['1','2','3']
for l in list: # Iterating list
print(l)
list.insert(3,4)
print("After extending:")
for l in list: # Iterating list
print(l)
PYTHON LIST POP() METHOD
Python pop() element removes an element present at specified
index from the list. It returns the popped element. The syntax and
signature is described below.

list = ['1','2','3']
for l in list: # Iterating list
print(l)
list.pop(2)
print("After poping:")
for l in list: # Iterating list
print(l)
PYTHON LIST REMOVE(X) METHOD
Python remove() method removes the first item from the list which is
equal to the passed value. It throws an error if the item is not present in the
list. Signature and examples are described below.

list = ['1','2','3']
for l in list: # Iterating list
print(l)
list.remove('2')
print("After removing:")
for l in list: # Iterating list
print(l)
PYTHON LIST REVERSE() METHOD
Python reverse() method reverses elements of the list. If the list is
empty, it simply returns an empty list. After reversing the last
index value of the list will be present at 0 index. The examples and
method signature is given below.
# Python list reverse() Method
# Creating a list
apple = ['a','p','p','l','e']
# Method calling
apple.reverse() # Reverse elements of the list
# Displaying result
print(apple)
PYTHON LIST SORT()
METHOD
Python sort() method sorts the list elements. It also sorts the items into
descending and ascending order. It takes an optional parameter 'reverse' which
sorts the list into descending order. By default, list sorts the elements into
ascending order. The examples and signature are given below.
apple = ['a', 'p', 'p', 'l', 'e'] # Char list
even = [6,8,2,4] # int list
print(apple)
print(even)
# Calling Method
apple.sort()
even.sort()
# Displaying result
print("\nAfter Sorting:\n",apple)
print(even)
TUPLES
A tuple is a sequence of immutable Python objects. Tuples are sequences,
just like lists. The differences between tuples and lists are, the tuples
cannot be changed unlike lists and tuples use parentheses, whereas lists
use square brackets.
Creating a tuple is as simple as putting different comma-separated values.
Optionally you can put these comma-separated values between
parentheses also.

For example −
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d";
ACCESSING VALUES IN
TUPLES
To access values in tuple, use the square brackets for slicing along with
the index or indices to obtain value available at that index.

For example −
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

When the above code is executed, it produces the following result −

tup1[0]: physics
tup2[1:5]: [2, 3, 4, 5]
 UPDATING TUPLES
Tuples are immutable which means you cannot update or change the
values of tuple elements. You are able to take portions of existing tuples
to create new tuples as the following example demonstrates −

tup1 = (12, 34.56)

tup2 = ('abc', 'xyz')
# Following action is not valid for tuples #
# tup1[0] = 100 #
So let's create a new tuple as follows
tup3 = tup1 + tup2
print (tup3)
DELETE TUPLE ELEMENTS
Removing individual tuple elements is not possible. There is, of course,
nothing wrong with putting together another tuple with the undesired
elements discarded.
To explicitly remove an entire tuple, just use the del statement. For
example −
tup = ('physics', 'chemistry', 1997, 2000)
print (tup)
del tup
print ("After deleting tup :”)
print (tup; )
BASIC TUPLES OPERATIONS

Python Expression Results Description

len((1, 2, 3)) 3 Length
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) Concatenation
('Hi!', 'Hi!', 'Hi!',
('Hi!',) * 4 Repetition
'Hi!')
3 in (1, 2, 3) True Membership
for x in (1, 2, 3):
123 Iteration
print x,
INDEXING, SLICING, AND MATRIXES
Because tuples are sequences, indexing and slicing work the same way
for tuples as they do for strings. Assuming following input −
T = ('spam', 'Spam', 'SPAM!')

Python Expression Results Description

T[2] 'SPAM!' Offsets start at zero
Negative: count from
T[-2] 'Spam'
the right
Slicing fetches
T[1:] ['Spam', 'SPAM!']
sections
Built-in Tuple Functions
Sr.No. Function with Description
1 len(tuple) Gives the total length of the tuple.
2 max(tuple) Returns item from the tuple with max value.
3 min(tuple) Returns item from the tuple with min value.
4 tuple(seq) Converts a list into tuple.
TUPLE METHODS
Methods that add items or remove items are not available with tuple. Only
the following two methods are available.

Method Description
count(x) Returns the number of items x
Returns the index of the first
index(x)
item that is equal to x
COUNT AND INDEX METHODS
my_tuple = ('a','p','p','l','e',)
print(my_tuple.count('p'))
# Output: 2
print(my_tuple.index('l'))
# Output: 3
 ADVANTAGES OF TUPLE OVER LIST
Since tuples are quite similar to lists, both of them are used in similar situations as
well. However, there are certain advantages of implementing a tuple over a list.
Below listed are some of the main advantages:
1. We generally use tuple for heterogeneous (different) datatypes and list for
homogeneous (similar) datatypes.
2. Since tuples are immutable, iterating through tuple is faster than with list. So
there is a slight performance boost.
3. Tuples that contain immutable elements can be used as a key for a dictionary.
With lists, this is not possible.
4. If you have data that doesn't change, implementing it as tuple will guarantee
that it remains write-protected.
PYTHON SET

The set in python can be defined as the unordered collection of various

items enclosed within the curly braces. The elements of the set can not
be duplicate. The elements of the python set must be immutable.
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

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

, "Sunday"}
print(Days)
print(type(Days))
print("looping through the set elements ... ")
for i in Days:
print(i)
 DIFFERENT PYTHON SET METHODS
Method Description
add() Adds an element to the set
clear() Removes all elements from the set
copy() Returns a copy of the set
difference() Returns the difference of two or more sets as a new set
difference_update() Removes all elements of another set from this set
Removes an element from the set if it is a member. (Do
discard()
nothing if the element is not in set)
intersection() Returns the intersection of two sets as a new set
intersection_update() Updates the set with the intersection of itself and another
 DIFFERENT PYTHON SET
METHODS
isdisjoint() Returns True if two sets have a null intersection
issubset() Returns True if another set contains this set
issuperset() Returns True if this set contains another set
Removes and returns an arbitary set element. Raise KeyError if
pop()
the set is empty
Removes an element from the set. If the element is not a member,
remove()
raise a KeyError
symmetric_difference
Returns the symmetric difference of two sets as a new set
()
symmetric_difference_ Updates a set with the symmetric difference of itself and another
update()
union() Returns the union of sets in a new set
update() Updates the set with the union of itself and others
PYTHON SET ADD(),
UPDATE()
The set add() method adds a given element to a set. If the element is
already present, it doesn't add any element.
The syntax of set add() method is:
set.add(elem)
The add() method doesn't add an element to the set if it's already present
in it.
set.update(elem)
UNION OF TWO SETS
The union of two sets are calculated by using the or (|) operator.
The union of the two sets contains the all the items that are present
in both the sets.
Consider the following example to calculate the union of two sets.
Example 1 : using union | operator
Days1 = {"Monday","Tuesday","Wednesday","Thursday"}
Days2 = {"Friday","Saturday","Sunday"}
print(Days1|Days2) #printing the union of the sets
 SET DIFFERENCE

Difference of A and B (A - B) is a set of elements that are only in A but not in

B. Similarly, B - A is a set of element in B but not in A.
Difference is performed using - operator. Same can be accomplished using the
method difference().
 SET INTERSECTION

Intersection of A and B is a set of elements that are common in both sets.

Intersection is performed using & operator. Same can be accomplished
using the method intersection().
 SET SYMMETRIC
DIFFERENCE

Symmetric Difference of A and B is a set of elements in both A and B except

those that are common in both.
Symmetric difference is performed using ^ operator. Same can be
accomplished using the method symmetric_difference().
PYTHON SET ISDISJOINT()

Two sets are said to be disjoint sets if they have no common elements.
For example:
A = {1, 5, 9, 0}
B = {2, 4, -5}
Here, sets A and B are disjoint sets.
PYTHON SET ISSUBSET()

The issubset() method returns True if all elements of a

set are present in another set (passed as an argument).
If not, it returns False.
PYTHON SET ISSUPERSET()

The issuperset() method returns True if a

set has every elements of another set
(passed as an argument). If not, it returns
False.
REMOVING ITEMS FROM THE SET

Python provides discard() method which can be used to remove the

items from the set.
Python also provide the remove() method to remove the items from the
set. Consider the following example to remove the items using remove()
method.
We can also use the pop() method to remove the item. However, this
method will always remove the last item.
Consider the following example to remove the last item from the set.
DIFFERENCE BETWEEN
DISCARD() AND REMOVE()
Despite the fact that discard() and remove() method both perform
the same task, There is one main difference between discard() and
remove().
If the key to be deleted from the set using discard() doesn't exist in
the set, the python will not give the error. The program maintains
its control flow.
On the other hand, if the item to be deleted from the set using
remove() doesn't exist in the set, the python will give the error.
DICTIONARIES
What is dictionary in Python?
Python dictionary is an unordered collection of items. While other
compound data types have only value as an element, a dictionary
has a key: value pair.
Dictionaries are optimized to retrieve values when the key is
known.
 HOW TO CREATE A DICTIONARY?
Creating a dictionary is as simple # empty dictionary
as placing items inside curly braces my_dict = {}
{} separated by comma. # dictionary with integer keys
An item has a key and the my_dict = {1: 'apple', 2: 'ball'}
corresponding value expressed as a # dictionary with mixed keys
pair, key: value. my_dict = {'name': 'John', 1: [2, 4, 3]}
# using dict()
While values can be of any data
type and can repeat, keys must be my_dict = dict({1:'apple', 2:'ball'})
of immutable type (string, number # from sequence having each item as a pair
or tuple with immutable elements) my_dict = dict([(1,'apple'), (2,'ball')])
and must be unique.
HOW TO ACCESS ELEMENTS FROM A DICTIONARY?
While indexing is used with other container types to access values,
dictionary uses keys. Key can be used either inside square brackets or
with the get() method.The difference while using get() is that it returns
None instead of KeyError, if the key is not found.
my_dict = {'name':'Jack', 'age': 26}
# Output: Jack
print(my_dict['name'])
# Output: 26
print(my_dict.get('age'))
# Trying to access keys which doesn't exist throws error#
my_dict.get('address')
# my_dict['address']
HOW TO CHANGE OR ADD ELEMENTS IN A DICTIONARY?
Dictionary are mutable. We can add new items or change the value
of existing items using assignment operator.
If the key is already present, value gets updated, else a new key:
value pair is added to the dictionary.
my_dict = {'name':'Jack', 'age': 26}
# updatevalue
my_dict['age'] = 27
#Output: {'age': 27, 'name': 'Jack'}
print(my_dict)
# add item
my_dict['address'] = 'Downtown'
# Output: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}
print(my_dict)
HOW TO DELETE OR REMOVE ELEMENTS FROM
A DICTIONARY?

We can remove a particular item in a dictionary by using the method

pop(). This method removes as item with the provided key and
returns the value.
The method, popitem() can be used to remove and return an arbitrary
item (key, value) form the dictionary. All the items can be removed at
once using the clear() method.
We can also use the del keyword to remove individual items or the
entire dictionary itself.
PROPERTIES OF DICTIONARY KEYS
Dictionary values have no restrictions. They can be any arbitrary Python
object, either standard objects or user-defined objects. However, same is
not true for the keys.
There are two important points to remember about dictionary keys −
(a) More than one entry per key not allowed. Which means no duplicate
key is allowed. When duplicate keys encountered during assignment, the
last assignment wins.
(b) Keys must be immutable. Which means you can use strings, numbers
or tuples as dictionary keys.
BUILT-IN DICTIONARY
FUNCTIONS & METHODS
Sr.No. Function with Description
len(dict) Gives the total length of the dictionary. This would be
2
equal to the number of items in the dictionary.
str(dict) Produces a printable string representation of a
3
dictionary
type(variable) Returns the type of the passed variable. If passed
4
variable is dictionary, then it would return a dictionary type.
 PYTHON DICTIONARY METHODS
Method Description
clear() Remove all items form the dictionary.
copy() Return a shallow copy of the dictionary.
Return a new dictionary with keys from seq and value equal
fromkeys(seq[, v])
to v (defaults to None).
Return the value of key. If key doesnot exit, return d
get(key[,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.
Remove the item with key and return its value or d if key is
pop(key[,d]) not found. If d is not provided and key is not found, raises
KeyError.
 DICTIONARY METHODS

Remove and return an arbitary item (key, value). Raises

popitem()
KeyError if the dictionary is empty.
If key is in the dictionary, return its value. If not, insert key
setdefault(key[,d])
with a value of d and return d (defaults to None).
Update the dictionary with the key/value pairs from other,
update([other])
overwriting existing keys.
values() Return a new view of the dictionary's values
PYTHON DICTIONARY
CLEAR()
The clear() method removes all items from the dictionary.
The syntax of clear() is:
dict.clear()
clear() Parameters
The clear() method doesn't take any parameters.
Return Value from clear()
The clear() method doesn't return any value (returns None).

d = {1: "one", 2: "two"}

d.clear()
print('d =', d)
PYTHON DICTIONARY COPY()
They copy() method returns a shallow copy of the dictionary.
The syntax of copy() is:
dict.copy()
copy() Parameters
The copy() method doesn't take any parameters.
Return Value from copy()
This method returns a shallow copy of the dictionary. It doesn't
modify the original dictionary.
original = {1:'one', 2:'two'}
new = original.copy()
print('Orignal: ', original)
print('New: ', new)
 PYTHON DICTIONARY FROMKEYS()
The fromkeys() method creates a new dictionary from the given sequence of
elements with a value provided by the user.
The syntax of fromkeys() method is: dictionary.fromkeys(sequence[, value])
fromkeys() Parameters:- The fromkeys() method takes two parameters:
sequence - sequence of elements which is to be used as keys for the new
dictionary
value (Optional) - value which is set to each each element of the dictionary
Return value from fromkeys()
The fromkeys() method returns a new dictionary with the given sequence of
elements as the keys of the dictionary.If the value argument is set, each element
of the newly created dictionary is set to the provided value.
EXAMPLE
# vowels keys
keys = {'a', 'e', 'i', 'o', 'u' }
vowels = dict.fromkeys(keys)
print(vowels)
#Output
#{'o': None, 'u': None, 'i': None, 'a': None, 'e': None}
 PYTHON DICTIONARY GET()
The get() method returns the value for the specified key if key is in
dictionary.
The syntax of get() is: dict.get(key[, value])
get() Parameters
The get() method takes maximum of two parameters:
•key - key to be searched in the dictionary
•value (optional) - Value to be returned if the key is not found. The default
value is None
Return Value from get()
The get() method returns:
•the value for the specified key if key is in dictionary.
•None if the key is not found and value is not specified.
•value if the key is not found and value is specified.
EXAMPLE
person = {'name': 'Phill', 'age': 22}
print('Name: ', person.get('name'))
print('Age: ', person.get('age'))
# value is not provided
print('Salary: ', person.get('salary'))
# value is provided
print('Salary: ', person.get('salary', 0.0))
PYTHON DICTIONARY ITEMS()
The items() method returns a view object that displays a list of
dictionary's (key, value) tuple pairs.
The syntax of items() method is:
dictionary.items()
items() Parameters
The items() method doesn't take any parameters.
Return value from items()
The items() method returns a view object that displays a list of a
given dictionary's (key, value) tuple pair.
EXAMPLE
# random sales dictionary
sales = { 'apple': 2, 'orange': 3, 'grapes': 4 }
print(sales.items())

#output dict_items([('orange', 3), ('apple', 2), ('grapes', 4)])

PYTHON DICTIONARY
KEYS()
The keys() method returns a view object that displays a list of all
the keys in the dictionary
The syntax of keys() is:
dict.keys()
keys() Parameters
The keys() doesn't take any parameters.
Return Value from keys()
The keys() returns a view object that displays a list of all the keys.
When the dictionary is changed, the view object also reflect these
changes.
EXAMPLE
person = {'name': 'Phill', 'age': 22, 'salary': 3500.0}
print(person.keys())
empty_dict = {}
print(empty_dict.keys())

#dict_keys(['name', 'salary', 'age'])

#dict_keys([])
 PYTHON DICTIONARY POP()
The pop() method removes and returns an element from a dictionary having the
given key.
The syntax of pop() method is :-dictionary.pop(key[, default])
pop() Parameters
The pop() method takes two parameters:
key - key which is to be searched for removal
default - value which is to be returned when the key is not in the dictionary
Return value from pop()
The pop() method returns:
•If key is found - removed/popped element from the dictionary
•If key is not found - value specified as the second argument (default)
•If key is not found and default argument is not specified - KeyError exception is
raised
EXAMPLE
# random sales dictionary
sales = { 'apple': 2, 'orange': 3, 'grapes': 4 }
element = sales.pop('apple')
print('The popped element is:', element)
print('The dictionary is:', sales)
element = sales.pop('apple’,’None’)
print('The popped element is:', element)
PYTHON DICTIONARY
POPITEM()
The popitem() returns and removes an arbitrary element (key, value) pair
from the dictionary.
dict.popitem()
popitem() Parameters
The popitem() doesn't take any parameters.
Return Value from popitem()
The popitem()
returns an arbitrary element (key, value) pair from the dictionary
removes an arbitrary element (the same element which is returned) from
the dictionary.
EXAMPLE
person = {'name': 'Phill', 'age': 22, 'salary': 3500.0}
result = person.popitem()
print('person = ',person)
print('Return Value = ',result)
#output
#person = {'name': 'Phill', 'salary': 3500.0}
#Return Value = ('age', 22)
PYTHON DICTIONARY SETDEFAULT()
The setdefault() method returns the value of a key (if the key is in
dictionary). If not, it inserts key with a value to the dictionary.

dict.setdefault(key[, default_value])
setdefault() Parameters
The setdefault() takes maximum of two parameters:
•key - key to be searched in the dictionary
•default_value (optional) - key with a value default_value is inserted to
the dictionary if key is not in the dictionary.
If not provided, the default_value will be None.
RETURN VALUE FROM
SETDEFAULT()
Return Value from setdefault()
The setdefault() returns:
value of the key if it is in the dictionary
None if key is not in the dictionary and default_value is not specified
default_value if key is not in the dictionary and default_value is specified
person = {'name': 'Phill', 'age': 22}
age = person.setdefault(‘age1‘,28)
print('person = ',person)
print('Age =‘,age) #person = {'name': 'Phill', 'age': 22} Age = 22
PYTHON DICTIONARY UPDATE()
The update() method updates the dictionary with the elements from the another
dictionary object or from an iterable of key/value pairs.
The update() method adds element(s) to the dictionary if the key is not in the
dictionary. If the key is in the dictionary, it updates the key with the new value.
dict.update([other])
update() Parameters
The update() method takes either a dictionary or an iterable object of key/value
pairs (generally tuples).
If update() is called without passing parameters, the dictionary remains
unchanged.
They update() method updates the dictionary with elements from a dictionary
object or an iterable object of key/value pairs.
EXAMPLE
d = {1: "one", 2: "three"}
d1 = {2: "two"}
d.update(d1)# updates the value of key 2
print(d)
d1 = {3: "three"}
d.update(d1)# adds element with key 3
print(d)
#output
#{1: 'one', 2: 'two'}
#{1: 'one', 2: 'two', 3: 'three'}
PYTHON DICTIONARY
VALUES()
The values() method returns a view object that displays a list of all the
values in the dictionary.
dictionary.values()
values() Parameters: The values() method doesn't take any parameters.
Return value from values():- The values() method returns a view object
that displays a list of all values in a given dictionary.
# random sales dictionary
sales = { 'apple': 2, 'orange': 3, 'grapes': 4 }
print(sales.values())
#output
#dict_values([3, 2, 4])