Question 1

What will be the output of the following statements?

i.
```
list1 = [12,32,65,26,80,10]
list1.sort()
print(list1)
```

ii.
```
list1 = [12,32,65,26,80,10]
sorted(list1)
print(list1)
```

iii.
```
list1 = [1,2,3,4,5,6,7,8,9,10]
list1[::-2]
list1[:3] + list1[3:]
```

iv.
```
list1 = [1,2,3,4,5]
list1[len(list1)-1]
```

Accepted Answer

i. The list1.sort() method sorts the list in place and returns None. So after sorting, list1 becomes [10, 12, 26, 32, 65, 80]. The print statement outputs:
[10, 12, 26, 32, 65, 80]

ii. The sorted(list1) function returns a new sorted list but does not change list1 itself. Since the returned sorted list is not assigned, list1 remains unchanged. So print(list1) outputs:
[12, 32, 65, 26, 80, 10]

iii. list1[::-2] returns a slice of list1 starting from the end, stepping backwards by 2 elements:
list1 = [1,2,3,4,5,6,7,8,9,10]
list1[::-2] = [10,8,6,4,2]

list1[:3] + list1[3:] concatenates the first 3 elements and the rest of the list, which is the entire list itself:
list1[:3] = [1,2,3]
list1[3:] = [4,5,6,7,8,9,10]
So the concatenation is the original list:
[1,2,3,4,5,6,7,8,9,10]

iv. list1[len(list1)-1] accesses the last element of the list:
list1 = [1,2,3,4,5]
len(list1) = 5
list1[4] = 5
So output is:
5 — Step-by-step:

(i) list1.sort() sorts the list in place.
(ii) sorted(list1) returns a new sorted list but does not modify list1.
(iii) list1[::-2] slices the list from end to start with step -2.
list1[:3] + list1[3:] concatenates the entire list.
(iv) list1[len(list1)-1] accesses the last element by index.

Question 2

Consider the following list `myList`. What will be the elements of `myList` after the following two operations:

```
myList = [10,20,30,40]
i. myList.append([50,60])
ii. myList.extend([80,90])
```

Accepted Answer

Initially, myList = [10, 20, 30, 40]

i. myList.append([50,60]) adds the entire list [50,60] as a single element at the end. So myList becomes:
[10, 20, 30, 40, [50, 60]]

ii. myList.extend([80,90]) adds each element of the list [80,90] individually to the end of myList. So myList becomes:
[10, 20, 30, 40, [50, 60], 80, 90] — append() adds its argument as a single element to the end of the list.
extend() iterates over its argument and adds each element individually to the list.

Question 3

What will be the output of the following code segment:
```python
myList = [1,2,3,4,5,6,7,8,9,10]
for i in range(0,len(myList)):
if i%2 == 0:
print(myList[i])
```

Accepted Answer

The code iterates over indices from 0 to 9 (length of myList - 1).
For each index i, if i is even (i%2 == 0), it prints myList[i].
Indices 0,2,4,6,8 are even.
myList[0] = 1
myList[2] = 3
myList[4] = 5
myList[6] = 7
myList[8] = 9

Output:
1
3
5
7
9 — The for loop checks each index i.
If i is even, it prints the element at that index.
Thus elements at even indices are printed.

Question 4

What will be the output of the following code segment:
a. myList = [1,2,3,4,5,6,7,8,9,10]
del myList[3:]
print(myList)
b. myList = [1,2,3,4,5,6,7,8,9,10]
del myList[:5]
print(myList)
c. myList = [1,2,3,4,5,6,7,8,9,10]
del myList[:2]
print(myList)

Accepted Answer

a. del myList[3:] deletes elements from index 3 to end:
Original list: [1,2,3,4,5,6,7,8,9,10]
After deletion: [1,2,3]

b. del myList[:5] deletes elements from start to index 4:
Original list: [1,2,3,4,5,6,7,8,9,10]
After deletion: [6,7,8,9,10]

c. del myList[:2] deletes first two elements:
Original list: [1,2,3,4,5,6,7,8,9,10]
After deletion: [3,4,5,6,7,8,9,10] — del with slice deletes specified elements from the list.
Indices are zero-based and slicing is inclusive of start index and exclusive of end index.

Question 5

Differentiate between append() and extend() functions of list.

Accepted Answer

append() adds its argument as a single element at the end of the list.
Example:
myList = [1,2,3]
myList.append([4,5])
myList becomes [1,2,3,[4,5]]

extend() iterates over its argument and adds each element individually to the list.
Example:
myList = [1,2,3]
myList.extend([4,5])
myList becomes [1,2,3,4,5] — append() treats the argument as a single element.
extend() treats the argument as an iterable and adds each element separately.

Question 6

Consider a list:
```txt
list1 = [6,7,8,9]
```

What is the difference between the following operations on list1:
a. list1 * 2
b. list1 *= 2
c. list1 = list1 * 2

Accepted Answer

a. list1 * 2 returns a new list which is list1 repeated twice:
[6,7,8,9,6,7,8,9]

b. list1 *= 2 modifies list1 in place by repeating its elements twice. After this operation, list1 becomes:
[6,7,8,9,6,7,8,9]

c. list1 = list1 * 2 creates a new list by repeating list1 twice and assigns it back to list1. This is similar to (a) but list1 now refers to the new list:
[6,7,8,9,6,7,8,9]

Note: In (a), list1 remains unchanged unless assigned.
In (b), list1 is modified in place.
In (c), list1 is reassigned to a new list. — The * operator repeats the list.
*= modifies the list in place.
= assigns a new list to the variable.

Question 7

The record of a student (Name, Roll No., Marks in five subjects and percentage of marks) is stored in the following list:
```txt
stRecord = ['Raman','A-36',[56,98,99,72,69], 78.8]
```

Write Python statements to retrieve the following information from the list `stRecord`.
- a) Percentage of the student
- b) Marks in the fifth subject
- c) Maximum marks of the student
- d) Roll no. of the student
- e) Change the name of the student from 'Raman' to 'Raghav'

Accepted Answer

Given:
stRecord = ['Raman','A-36',[56,98,99,72,69], 78.8]

Python statements:

a) Percentage of the student:
percentage = stRecord[3]
print(percentage)  # Output: 78.8

b) Marks in the fifth subject:
fifth_mark = stRecord[2][4]
print(fifth_mark)  # Output: 69

c) Maximum marks of the student:
max_mark = max(stRecord[2])
print(max_mark)  # Output: 99

d) Roll no. of the student:
roll_no = stRecord[1]
print(roll_no)  # Output: 'A-36'

e) Change the name of the student from 'Raman' to 'Raghav':
stRecord[0] = 'Raghav'
print(stRecord)  # Output: ['Raghav', 'A-36', [56, 98, 99, 72, 69], 78.8] — The list stRecord stores data as:
Index 0: Name
Index 1: Roll No.
Index 2: List of marks
Index 3: Percentage

Access elements using indexing.
Modify name by assigning new value to index 0.

Question 8

Write a program to find the number of times an element occurs in the list.

Accepted Answer

To find the number of times an element occurs in a list, we can use the count() method of the list. For example:

```python
# Sample list
lst = [1, 2, 3, 2, 4, 2, 5]

# Element to count
element = 2

# Count occurrences
count = lst.count(element)
print(f"Element {element} occurs {count} times in the list.")
```

This program will output:
Element 2 occurs 3 times in the list. — The list method count() returns the number of times the specified element appears in the list. We simply call lst.count(element) to get the count.

Question 9

Write a program to read a list of n integers (positive as well as negative). Create two new lists, one having all positive numbers and the other having all negative numbers from the given list. Print all three lists.

Accepted Answer

To solve this problem, we first read n integers into a list. Then, we iterate through the list and separate positive and negative numbers into two different lists. Finally, we print all three lists.

Example program:

```python
# Read number of elements
n = int(input("Enter number of elements: "))

# Read list elements
lst = []
for _ in range(n):
    num = int(input())
    lst.append(num)

# Separate positive and negative numbers
positive = [x for x in lst if x > 0]
negative = [x for x in lst if x < 0]

# Print the lists
print("Original list:", lst)
print("Positive numbers:", positive)
print("Negative numbers:", negative)
```

If the input list is [3, -1, 0, 5, -7], the output will be:
Original list: [3, -1, 0, 5, -7]
Positive numbers: [3, 5]
Negative numbers: [-1, -7] — We use list comprehension to filter positive and negative numbers from the original list. Zero is neither positive nor negative, so it is excluded from both lists.

Question 10

Write a program to read a list of elements. Modify this list so that it does not contain any duplicate elements, i.e., all elements occurring multiple times in the list should appear only once.

Accepted Answer

To remove duplicates from a list, we can use a set to track seen elements and build a new list with unique elements preserving the order.

Example program:

```python
# Read list elements
lst = input("Enter elements separated by space: ").split()

# Remove duplicates while preserving order
unique_lst = []
seen = set()
for elem in lst:
    if elem not in seen:
        unique_lst.append(elem)
        seen.add(elem)

print("List after removing duplicates:", unique_lst)
```

If input is: 1 2 2 3 4 4 5
Output:
List after removing duplicates: ['1', '2', '3', '4', '5'] — Using a set helps to check if an element has already been added to the unique list. This approach preserves the original order of elements.

Question 11

Write a program to read a list of elements. Input an element from the user that has to be inserted in the list. Also input the position at which it is to be inserted. Write a user defined function to insert the element at the desired position in the list.

Accepted Answer

We can define a function insert_element(lst, elem, pos) that inserts elem at position pos in the list lst.

Example program:

```python
# Function to insert element at given position

def insert_element(lst, elem, pos):
    if pos < 0 or pos > len(lst):
        print("Invalid position")
        return lst
    lst.insert(pos, elem)
    return lst

# Read list elements
lst = input("Enter elements separated by space: ").split()

# Read element and position
elem = input("Enter element to insert: ")
pos = int(input("Enter position to insert at (0-based index): "))

# Insert element
lst = insert_element(lst, elem, pos)

print("List after insertion:", lst)
```

If input list is ['a', 'b', 'c'], element='x', position=1, output will be:
List after insertion: ['a', 'x', 'b', 'c'] — The list method insert(pos, elem) inserts the element at the specified index. We check for valid position before insertion.

Question 12

Write a program to read elements of a list.

a) The program should ask for the position of the element to be deleted from the list. Write a function to delete the element at the desired position in the list.

b) The program should ask for the value of the element to be deleted from the list. Write a function to delete the element of this value from the list.

Accepted Answer

a) To delete an element at a given position:

```python
def delete_at_position(lst, pos):
    if pos < 0 or pos >= len(lst):
        print("Invalid position")
        return lst
    lst.pop(pos)
    return lst

# Read list
lst = input("Enter elements separated by space: ").split()

pos = int(input("Enter position to delete (0-based index): "))
lst = delete_at_position(lst, pos)
print("List after deletion:", lst)
```

b) To delete an element by value:

```python
def delete_by_value(lst, val):
    if val in lst:
        lst.remove(val)
    else:
        print("Element not found in list")
    return lst

# Read list
lst = input("Enter elements separated by space: ").split()

val = input("Enter element value to delete: ")
lst = delete_by_value(lst, val)
print("List after deletion:", lst)
```

These functions handle invalid inputs gracefully and modify the list accordingly. — The pop(pos) method removes element at index pos. The remove(val) method removes the first occurrence of val. We check for valid position or existence of element before deletion.

Question 13

Read a list of n elements. Pass this list to a function which reverses this list in-place without creating a new list.

Accepted Answer

To reverse a list in-place, we can swap elements from the start and end moving towards the center.

Example program:

```python
def reverse_list(lst):
    start = 0
    end = len(lst) - 1
    while start < end:
        lst[start], lst[end] = lst[end], lst[start]
        start += 1
        end -= 1

# Read number of elements
n = int(input("Enter number of elements: "))

# Read list elements
lst = []
for _ in range(n):
    lst.append(input())

reverse_list(lst)
print("Reversed list:", lst)
```

This reverses the list without creating a new list. — Swapping elements from both ends towards the center reverses the list in-place. No new list is created, so memory usage is minimal.

Question 14

Which of the following statements correctly describes a list in Python?

Accepted Answer

A list is an ordered sequence of elements that can contain different data types and is mutable. — In Python, a list is an ordered collection of elements that can be of different data types such as integers, floats, strings, tuples, or even other lists. Lists are mutable, meaning their contents can be changed after creation.

Question 15

What will be the output of the following Python code?

```python
list1 = [2, 4, 6, 8, 10, 12]
print(list1[3])
print(list1[-1])
print(list1[1+4])
```

Accepted Answer

8, 12, 12 — list1[3] accesses the fourth element which is 8. list1[-1] accesses the last element which is 12. list1[1+4] equals list1[5], which is 12.

Lists

Lists — Study Notes

9.1 INTRODUCTION TO LIST

9.1.1 Accessing Elements in a List

9.1.2 Lists are Mutable

Practice Questions — Lists

All 11 Chapters in Computer Science