1Q.

What are lists in Python and how are they used to store and manipulate a
collection of data?
Definition:
A list is a collection of items in Python.
It is ordered and changeable (mutable).
Lists are written inside square brackets [ ] and items are separated by commas.
---
Syntax:
list_name = [item1, item2, item3
Example:
fruits = ['apple', 'banana', 'mango'

Accessing & Modifying List Elements:

Access items using index (starts from 0)

print(fruits[0]) # Output: apple

fruits[1] = 'grape' # Changes 'banana' to 'grape'

Common List Operations:

Operation Code Example

Add item fruits.append('orange')

Insert item fruits.insert(1, 'kiwi')
Remove item fruits.remove('apple')
Delete by index del fruits[0]
Length len(fruits)
Slicing fruits[1:3]

Program Example:

fruits = ['apple', 'banana', 'mango']

fruits.append('orange')
fruits[1] = 'grape'
print(fruits)

Output:

['apple', 'grape', 'mango', 'orange']

2. Explain Augmented Assignment Operators in Python with examples.

Definition:
In Python, Augmented Assignment Operators are shorthand operators that combine arithmetic or
bitwise operations with assignment.
Example: x = x + 5 can be written as x += 5.

Syntax Format:
variable <augmented_operator> expression
Example: x += 3 is the same as x = x + 3.
List of Common Augmented Assignment Operators:

Operator Description Example Equivalent To

+= Add and assign x += 2 x=x+2

-= Subtract and assign x -= 3 x=x-3
*= Multiply and assign x *= 4 x=x*4
/= Divide and assign x /= 2 x=x/2
//= Floor divide and assign x //= 3 x = x // 3
%= Modulus and assign x %= 2 x=x%2
**= Exponent and assign x **= 2 x = x ** 2
&= Bitwise AND and assign x &= y x=x&y
= Bitwise OR and assign x
^= Bitwise XOR and assign x ^= y x=x^y
<<= Left shift and assign x <<= 1 x = x << 1
>>= Right shift and assign x >>= 1 x = x >> 1

Example 1: Numbers

x = 10
x += 5
x *= 2
x -= 10
print(x)

Output:
20

Example 2: Strings

name = "Yash"
name += "wanth"
print(name)

Output:
Yashwanth

Example 3: Lists

mylist = [1, 2, 3]
mylist += [4, 5]
print(mylist)

Output:
[1, 2, 3, 4, 5]

3. Q. Explain negative indexing and slicing of a list with an example.

Negative Indexing: In Python, list elements can be accessed using negative indexes. -1 refers to the
last element, -2 to the second last, and so on. It is useful when accessing elements from the end

Example:

fruits = ['apple', 'banana', 'cherry', 'date', 'fig']

print(fruits[-1]) # Output: fig
print(fruits[-3]) # Output: cherry

Slicing: Slicing is used to extract a portion of the list. Syntax: list[start:stop] returns elements from
index start to stop-1.

Example:

fruits = ['apple', 'banana', 'cherry', 'date', 'fig']

print(fruits[1:4]) # Output: ['banana', 'cherry', 'date']

Slicing with Negative Indexes:

print(fruits[-4:-1]) # Output: ['banana', 'cherry', 'date']

Shortcut Slicing:

print(fruits[:3]) # Output: ['apple', 'banana', 'cherry']

print(fruits[2:]) # Output: ['cherry', 'date', 'fig']

Conclusion: Negative indexing allows access to elements from the end of the list. Slicing helps
extract sublists using index ranges. Both features make list handling easier and more efficient.

Q4. Define list and explain different list methods like append(), sort(),
index(), insert(), remove(), and pop() with examples.

Definition: A list in Python is an ordered, mutable collection used to store multiple items. Lists are
defined using square brackets [ ], and elements are separated by commas.
Example:

fruits = ['apple', 'banana', 'mango']

1. append() – Adds an element to the end of the list.

fruits = ['apple', 'banana']

fruits.append('mango')
print(fruits) # Output: ['apple', 'banana', 'mango']

2. sort() – Sorts the list in ascending order.

numbers = [4, 1, 3, 2]
numbers.sort()
print(numbers) # Output: [1, 2, 3, 4]

3. index() – Returns index of first occurrence of given element.

fruits = ['apple', 'banana', 'mango']

print(fruits.index('banana')) # Output: 1

4. insert(index, value) – Inserts value at specified index.

fruits = ['apple', 'mango']

fruits.insert(1, 'banana')
print(fruits) # Output: ['apple', 'banana', 'mango']

5. remove(value) – Removes first occurrence of specified value.

fruits = ['apple', 'banana', 'mango']

fruits.remove('banana')
print(fruits) # Output: ['apple', 'mango']

6. pop(index) – Removes and returns element at given index. If index not given, removes last item.

fruits = ['apple', 'banana', 'mango']

fruits.pop(1)
print(fruits) # Output: ['apple', 'mango']

Conclusion: Lists in Python are flexible and powerful. These methods allow us to efficiently add,
remove, sort, and access elements in a list.

Q5. What is Pretty Printing? How does it work?

Definition: Pretty Printing in Python means printing complex data (like nested dictionaries) in a neat
and readable format. Python provides a module called pprint which contains pprint() and pformat()
functions.

Why use pprint():

print() gives messy single-line output for large/nested structures.
pprint() prints them with indentation and structure.
Useful for nested dictionaries and debugging.

How it works (as per module):

Import the module: import pprint
Count character frequency using a dictionary
Use pprint.pprint() to print the result neatly

import pprint
message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
count = {}
for character in message:
count.setdefault(character, 0)
count[character] += 1
pprint.pprint(count)

Output (from module):

{' ': 13,

',': 1,
'.': 1,
'A': 1,
'I': 1,
'a': 4,
'b': 1,
'c': 3,
'd': 3,
...
'w': 2}

Conclusion: pprint() is used to print large or nested dictionaries in a readable format. It is helpful for
debugging and clean output

6Q. Read N numbersfrom the console and create a list. Develop a

program to print mean, variance
and standard deviation with suitable messages.

frommath importsqrt
mylist= []
n= int(input("Enter the Number of Elements: "))
for i in range(n):
val= int(input("Enter the element:"))
mylist.append(val)
sum=0
for elem in mylist:
sum=sum+elem
mean = sum/n
print("Sum=",sum)
print("Mean=",mean)
variance = 0
for elem in mylist:
variance+= (elem-mean)*(elem-mean)
variance=variance/n
print("variance=",variance)
stddev= sqrt(variance)
print("Stddev=",stddev)

output:
Enter the Number of Elements: 3
Enter the element :15
Enter the element :10
Enter the element :10
Sum= 35
Mean= 11.666666666666666
variance= 5.5555555555555545
Stddev= 2.357022603955158

7Q. Explain in and not in operators used in lists with an example.

Definition: In Python, in and not in are membership operators used to check whether a value exists
in a list. They return a Boolean value: True or False.

in → returns True if the value is present in the list

not in → returns True if the value is not present in the list

Example (from Module 2):

myPets = ['Zophie', 'Pooka', 'Fat-tail']

print('Enter a pet name:')
name = input()
if name in myPets:
print(name + ' is my pet.')
else:
print('I do not have a pet named ' + name)

Sample Output 1:
Input: Pooka
Output: Pooka is my pet.

Sample Output 2:
Input: Tiger
Output: I do not have a pet named Tiger

Explanation: The list contains 3 pet names. The program takes user input and checks if the name
exists in the list using in. If found, it prints a confirmation. If not found, the else block runs.
Note: not in can be used to check if a value is missing from the list:

if name not in myPets:

print('That pet is not in my list.')

Conclusion: in and not in operators are useful for checking the presence or absence of values in a
list, and are commonly used in conditional statements.

8Q. How is tuple different from list? Which function is used to convert list to
tuple?
Definition:
A list is a mutable (changeable) sequence of values, whereas a tuple is an immutable (unchangeable)
sequence. Both can store multiple items, but only lists can be modified after creation
Difference between List and Tuple (as per Module):

Property List Tuple

Mutability Mutable Immutable

Syntax [ ] square brackets ( ) parentheses
Modification Elements can change Elements cannot change
Use When data changes When data stays fixed

Example (from Module 2 PDF):

myList = [1, 2, 3]
myTuple = (1, 2, 3)

Conversion Function:
To convert a list into a tuple, use the tuple() function.

Example:

myList = [10, 20, 30]

myTuple = tuple(myList)
print(myTuple) # Output: (10, 20, 30)

Q9. Show that lists are mutable in Python.

Definition:
A mutable object is one that can be modified after it is created.
Lists in Python are mutable, meaning their elements can be changed, added, or removed.

myList = [1, 2, 3]
print(myList)

myList[0] = 100 # modifying the first element

print(myList)

Output:

[1, 2, 3]
[100, 2, 3]

Explanation:

The list myList was originally [1, 2, 3]

We updated the first element using myList[0] = 100

The list became [100, 2, 3]

This shows that lists are mutable because their contents can be changed after creation

Conclusion:
Lists in Python are mutable. We can modify individual elements using indexing.
This property makes lists flexible and useful in dynamic programs.

Q10. Explain the concept of mutable and immutable data

types in Python with examples.

In Python, data types are classified as mutable and immutable based on whether their values can be
changed after creation.

1. Mutable Data Types

Definition:
Mutable data types can be modified after their creation. Elements can be added, removed, or
changed.

Common Mutable Types:

List
Dictionary
Set

Example (from Module 2 – Page 5):

myList = [1, 2, 3]
print(myList)
myList[0] = 100
print(myList)

Output:

[1, 2, 3]
[100, 2, 3]

Explanation:
The list element at index 0 was modified from 1 to 100.
This proves that lists are mutable, as their contents can be changed.

2. Immutable Data Types

Definition:
Immutable data types cannot be changed after their creation.
Any operation that tries to change the value will result in a new object or an error.

Common Immutable Types:

Tuple
String
Integer
Float

Example (from Module 2 – Page 5):

myTuple = (1, 2, 3)
myTuple[0] = 100

Output:

TypeError: 'tuple' object does not support item assignment

Explanation:
Tuples do not allow item assignment. Any such operation results in an error.
This shows that tuples are immutable.

Conclusion:

Mutable types: Values can be changed (e.g., list)

Immutable types: Values cannot be changed (e.g., tuple, string)

Choosing the correct type depends on whether the data should remain constant or not.

Q11. Explain random.choice() and random.shuffle() functions with lists.

Python’s random module provides functions to work with random operations on lists.

1. random.choice()
Returns a random element from a list.
Syntax: random.choice(list_name)

import random
names = ['Alice', 'Bob', 'Charlie']
print(random.choice(names))

Output:
Any one name: Alice, Bob, or CharliE

2. random.shuffle()
Shuffles elements of a list randomly (modifies list in-place).
Syntax: random.shuffle(list_name)
Example (Module – Page 6):

import random
cards = ['A', 'K', 'Q', 'J']
random.shuffle(cards)
print(cards)

Output:
Random order like: ['J', 'Q', 'K', 'A']
Conclusion:
random.choice() → selects one random item
random.shuffle() → shuffles the full list randomly

Q12. The copy Module’s copy() and deepcopy() Functions

➢ If the function modifies the list or dictionary that is passed, we may not want these
changes in the original list or dictionary value.
➢ For this, Python provides a module named copy that provides both the copy() and
deepcopy() functions.
➢ copy(), can be used to make a duplicate copy of a mutable value like a list or
dictionary, not just a copy of a reference.
➢ Now the spam and cheese variables refer to separate lists, which is why only the list
in cheese is modified when you assign 42 at index 1.
➢ The reference ID numbers are no longer the same for both variables because the
variables refer to independent lists

>>> import copy

>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 42
>>> spam
Output: ['A', 'B', 'C', 'D']
>>> cheese
Output: ['A', 42, 'C', 'D']

copy function
>>> import copy
>>> old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
>>> new_list = copy.copy(old_list)
>>> old_list[1][0] = 'BB'
>>> print("Old list:", old_list)
>>> print("New list:", new_list)
>>> print(id(old_list))
>>> print(id(new_list))

Output:
Old list: [[1, 1, 1], ['BB', 2, 2], [3, 3, 3]]
New list: [[1, 1, 1], ['BB', 2, 2], [3, 3, 3]]
1498111334272
1498110961152

deepcopy() Function
>>> import copy
>>> old_list = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
>>> new_list = copy.deepcopy(old_list)
>>> old_list[1][0] = 'BB'
>>> print("Old list:", old_list)
>>> print("New list:", new_list)
>>> print(id(old_list))
>>> print(id(new_list))

Output
Old list: [[1, 1, 1], ['BB', 2, 2], [3, 3, 3]]
New list: [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
1498111298880
1498111336064

Q13. Explain two ways to remove values from lists (as per
module).
1. Using del Statement

The del statement deletes a value at a specific index in the list.

Once deleted, the value is removed permanently.

Syntax:

del list_name[index]

Example:

spam = ['a', 'b', 'c']

del spam[1]
print(spam) # Output: ['a', 'c']

> “The del statement will delete values at an index in a list.”

“Mostly used to delete values from lists.

2. Using remove() Method

The remove() method deletes a value by value, not by index.

Removes only the first occurrence of the value.

Syntax:
list_name.remove(value)

Example:
spam = ['a', 'b', 'a']
spam.remove('a')
print(spam) # Output: ['b', 'a']

> “The remove() method is passed the value to be removed from the list it is called on.”
“If the value appears multiple times, only the first instance will be removed.”
✅ Conclusion:
Use del when you know the index.
Use remove() when you know the value.

Q14. Explain the concept of List Concatenation and List Replication in detail.
1. List Concatenation using + Operator

🔹 Definition:
List concatenation is the process of joining two or more lists to create a single new list.
This is done using the + operator.

🔹 Key Points:

Only lists can be concatenated with other lists.

Original lists are not modified; a new list is created.
Items are joined in the order given.

🔹 Syntax:
list3 = list1 + list2
🔹 Example:
list1 = [1, 2, 3]
list2 = [4, 5]
result = list1 + list2
print(result) # Output: [1, 2, 3, 4, 5]

> “The + operator can combine two lists to create a new list value in the same way it combines two
strings into a new string value.”

2. List Replication using * Operator

🔹 Definition:
List replication is the process of repeating the elements of a list multiple times using the * operator.

🔹 Key Points:

A list is multiplied by an integer.

A new list is returned with repeated values.
Does not modify the original list.

🔹 Syntax:
list2 = list1 * n

🔹 Example:
list1 = ['Hi']
result = list1 * 3
print(result) # Output: ['Hi', 'Hi', 'Hi']
> “The * operator can also be used with a list and an integer value to replicate the list.”

✅ Conclusion:

List Concatenation joins multiple lists using +.

List Replication repeats the same list multiple times using *.
Both operations return new lists without altering the original.

Q15. Dictionaries vs. Lists

➢ Unlike lists, items in dictionaries are unordered.

➢ The first item in a list named spam would be spam[0]. But there is no “first” item in a
dictionary. While the order of items matters for determining whether two lists are the
same, it does not matter in what order the key-value pairs are typed in a dictionary.

>>> spam = ['cats', 'dogs', 'moose']

>>> bacon = ['dogs', 'moose', 'cats']
>>> spam == bacon
False

>>> eggs = {'name': 'Zophie', 'species': 'cat', 'age': '8'}

>>> ham = {'species': 'cat', 'age': '8', 'name': 'Zophie'}
>>> eggs == ham
True

> Trying to access a key that does not exist in a dictionary will result in a KeyError
error message, much like a list’s “out-of-range” IndexError error message.

>>> spam = {'name': 'Zophie', 'age': 7}

>>> spam['color']
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
spam['color']
KeyError: 'color'

16.Explain keys(), values(), and items() methods of a dictionary in

detail with examples.
🔹 Introduction

Dictionaries in Python are collections of key-value pairs.

To access keys, values, or both, Python provides three useful methods:

1. keys()
2. values()
3. items()

These methods return view objects, which act like lists and are commonly used in loops

🔹 1. keys() Method
Returns a view object that displays all the keys of the dictionary.

📌 Syntax:
dictionary.keys()

📌 Returns: dict_keys view object

📌 Example:

student = {'name': 'Yash', 'age': 19, 'branch': 'CSE'}

print(student.keys())

📌 Output:

dict_keys(['name', 'age', 'branch'])

✅ You can also convert it into a list:

print(list(student.keys()))

Output:

['name', 'age', 'branch']

> “The keys() method returns list-like values of the dictionary’s keys.”

🔹 2. values() Method

Returns a view object that contains all the values in the dictionary.

📌 Syntax:

dictionary.values()

📌 Returns: dict_values view object

📌 Example:

student = {'name': 'Yash', 'age': 19, 'branch': 'CSE'}

print(student.values())

📌 Output:

dict_values(['Yash', 19, 'CSE'])

✅ Convert to list:

print(list(student.values()))

📌 From module:

> “The values() method returns all values of the dictionary.”

🔹 3. items() Method

📌 Definition:
Returns a view object that returns all (key, value) pairs as tuples.

📌 Syntax:

dictionary.items()

📌 Returns: dict_items view object containing tuples

📌 Example:

student = {'name': 'Yash', 'age': 19, 'branch': 'CSE'}

print(student.items())

📌 Output:

dict_items([('name', 'Yash'), ('age', 19), ('branch', 'CSE')])

✅ Convert to list:

print(list(student.items()))

> “The values in the dict_items returned by items() are tuples of the key and value.”

🔹 Using in for Loops

You can use all three methods inside for loops.

✅ Using keys():

for key in student.keys():

print(key)

✅ Using values():

for value in student.values():

print(value)

✅ Using items() with Multiple Assignment:

for key, value in student.items():
print(key, ":", value)

> “We can use the multiple assignment trick in a for loop to assign the key and value to separate
variables.”

17. Write a Python program to add elements into a dictionary using a

while loop.

# Program to add elements into a dictionary using while loop

Student
_data = {}
n = int(input("Enter how many key-value pairs you want to add: "))
i=0
while i < n:
key = input("Enter key: ")
value = input("Enter value: ")
student_data[key] = value
i += 1
print("\nFinal Dictionary:")
print(student_data)

Sample Output:

Enter how many key-value pairs you want to add: 3

Enter key: name
Enter value: Yash
Enter key: age
Enter value: 19
Enter key: city
Enter value: Bengaluru

Final Dictionary:
{'name': 'Yash', 'age': '19', 'city': 'Bengaluru'}

18. Read a multi-digit number (as chars) from the console. Develop a program
to print the frequency
of each digit with suitable message.
num = input("Enter a number : ")
print("The number entered is:", num)
uniqDig = set(num)
for elem in uniqDig:
print(elem, "occurs", num.count(elem), "times")

output:
Enter a number : 11232
The number entered is: 11232
3 occurs 1 times
2 occurs 2 times
1 occurs 2 times

19. The setdefault() Method

➢ To set a value in a dictionary for a certain key only if that key does not already have a
Value

>>> picnicItems = {'apples': 5, 'cups': 2}

> > > 'I am bringing ' + str(picnicItems.get('cups', 0)) + ' cups.'
> > > 'I am bringing 2 cups.'
> > > 'I am bringing ' + str(picnicItems.get('eggs', 0)) + ' eggs.'
> > > 'I am bringing 0 eggs.'"

The setdefault() Method

➢ To set a value in a dictionary for a certain key only if that key does not already have a
Value
➢ The setdefault() method offers a way to do this in one line of code.
➢ Setdeafault() takes 2 arguments:
o The first argument is the key to check for, and
o The second argument is the value to set at that key if the key does not
exist. If the key does exist, the setdefault() method returns the key’s value.

> spam = {'name': 'Pooka', 'age': 5}

> spam.setdefault('color', 'black')
lack'
> spam
color': 'black', 'age': 5, 'name': 'Pooka'}
> spam.setdefault('color', 'white')
lack'
> spam
color': 'black', 'age': 5, 'name': 'Pooka'}

The first time setdefault() is called, the dictionary in spam changes to {'color': 'black', 'age': 5, 'name':
'Pooka'}. The method returns the value 'black' because this is now the value set for the key 'color'.
When spam.setdefault('color', 'white') is called next, the value for that key is not changed to 'white'
because spam already has a key named 'color'.

20. What are Nested Dictionaries? Explain with an example.

➢ We can have program that contains dictionaries and lists which in turn contain other
dictionaries and lists.
➢ Lists are useful to contain an ordered series of values, and dictionaries are useful for
associating keys with values.
➢ Program: which contains nested dictionaries in order to see who is bringing what to a
Picnic

allGuests = {
'Alice': {'apples': 5, 'pretzels': 12},
'Bob': {'ham sandwiches': 3, 'apples': 2},
'Carol': {'cups': 3, 'apple pies': 1}
}

def totalBrought(guests, item):

numBrought = 0
for k, v in guests.items():
numBrought = numBrought + v.get(item, 0)
return numBrought

print('Number of things being brought:')

print(' - Apples ', totalBrought(allGuests, 'apples'))
print(' - Cups ', totalBrought(allGuests, 'cups'))
print(' - Cakes ', totalBrought(allGuests, 'cakes'))
print(' - Ham Sandwiches', totalBrought(allGuests, 'ham sandwiches'))
print(' - Apple Pies ', totalBrought(allGuests, 'apple pies'))

➢ Inside the totalBrought() function, the for loop iterates over the keyvalue pairs in
guests 1.
➢ Inside the loop, the string of the guest’s name is assigned to k, and the dictionary of
picnic items they’re bringing is assigned to v.
➢ If the item parameter exists as a key in this dictionary, it’s value (the quantity) is
added to numBrought 2.
➢ If it does not exist as a key, the get() method returns 0 to be added to numBrought

Number of things being brought:

- Apples 7
- Cups 3
- Cakes 0
- Ham Sandwiches 3
- Apple Pies 1

21. # Program to input 10 student records and print only the student
names
students = {}

for i in range(10):
name = input("Enter student name: ")
marks = int(input("Enter marks for " + name + ": "))
students[name] = marks

print("\nStudent Names:")
for student in students:
print(student)
Enter student name: Akash
Enter marks: 85
Enter student name: Riya
Enter marks: 90
Enter student name: Vivek
Enter marks: 88
Enter student name: Neha
Enter marks: 92
Enter student name: Rahul
Enter marks: 77
Enter student name: Sneha
Enter marks: 84
Enter student name: Deepa
Enter marks: 79
Enter student name: Arjun
Enter marks: 93
Enter student name: Kiran
Enter marks: 80
Enter student name: Divya
Enter marks: 86

Then the final output will be:

Student Names:
Akash
Riya
Vivek
Neha
Rahul
Sneha
Deepa
Arjun
Kiran
Divya

Q22. Q. Explain List Methods in Python: Adding, Removing, Finding, Sorting, Reversing (With
Examples

🔹 1. Adding Elements

a) append() – Adds an element to the end

l = [1, 2, 3]
l.append(4)
print(l)
# Output: [1, 2, 3, 4]
b) insert(index, value) – Inserts at specific index

l = [10, 20, 30]

l.insert(1, 15)
print(l)
# Output: [10, 15, 20, 30]

🔹 2. Removing Elements

a) remove(value) – Removes first occurrence of value

l = [5, 10, 15, 10]

l.remove(10)
print(l)
# Output: [5, 15, 10]

b) pop(index) – Removes and returns element at index (last by default)

l = [100, 200, 300]

l.pop()
print(l)
# Output: [100, 200]

🔹 3. Finding Elements

a) index(value) – Returns index of first occurrence

l = [10, 20, 30]

print(l.index(20))
# Output: 1

b) in – Checks if element exists in list

l = [10, 20, 30]

print(30 in l)
# Output: True

🔹 4. Sorting List

a) sort() – Sorts list in ascending order

l = [9, 2, 5, 1]
l.sort()
print(l)
# Output: [1, 2, 5, 9]

🔹 5. Reversing List
a) reverse() – Reverses the list order

l = [1, 2, 3, 4]
l.reverse()
print(l)
# Output: [4, 3, 2, 1]

✅ Final Summary Table

Operation MethodExample Output

Add append() [1, 2, 3, 4]

Insert insert() [10, 15, 20, 30]
Remove remove() [5, 15, 10]
Pop pop() [100, 200]
Find index() 1
Check in True
Sort sort() [1, 2, 5, 9]
Reverse reverse() [4, 3, 2, 1]

🔚 Conclusion

List methods are used to add, delete, find, sort and reverse data in a collection. These are essential
operations covered in Module 2 and commonly used in all Python programs.