Lists in Python

List Representation

Reason — The picture shows elements enclosed within square brackets [ ], which represents a List in Python. It also displays both forward (positive) indexing starting from 0 and backward (negative) indexing starting from –1, which are features of List Indexing.

An empty list

Reason — The list() function, when used without any argument, creates and returns an empty list.

L[1:4]

Reason — In list slicing, the syntax is L[initial index : final index], where elements are extracted from the initial index up to (final index − 1).

For L = ['a', 'b', 'c', 'd']:

• L[1:4] extracts elements from index 1 to 3.
• Index 1 → 'b'
• Index 2 → 'c'
• Index 3 → 'd'

Thus, the result is ['b', 'c', 'd'].

[1, 2, 3]

Reason — A Python list is represented by elements separated by commas and enclosed within square brackets [ ]. Therefore, [1, 2, 3] is a valid list representation.

False

Reason — In list comparison, corresponding elements are compared starting from the 0th index, and the result is determined as soon as unequal elements are found.

Comparison:

• 1 = 1
• 2 = 2
• 3 < 8

Since the first unequal elements are 3 and 8, and 3 is less than 8, the relation [1, 2, 3, 4] > [1, 2, 8, 9] becomes False.

extend()

Reason — The extend() function is used to add multiple elements of one list to another list, effectively concatenating two lists. The append() function adds only a single element, while merge() and join() are not list functions.

1. True
2. True
3. False
   Corrected Statement: In forward indexing, the indexing of the last element is (length − 1).
4. True
5. True
6. False
   Corrected Statement: The remove() function is used to delete an element by its value from the list.

1. del
2. extend()
3. count()
4. append()
5. sort()

Both A and R are true and R is the correct explanation of A.

Reason — We can compare two lists together by using relational operators (i.e., ==, <, <=, >, >=, etc.). During the process, the corresponding elements of both the lists are compared with each other starting with the 0th index. The result is determined the moment elements are found different. In case, all the corresponding elements are same, both the lists are declared to be the same. The result of comparison will either be true or false.

(a)

None

The extend() function is used to add multiple elements within another list. It adds the elements of L2 to L1, but it does not return a new list. Since the returned value is assigned to L3, the value of L3 becomes None.

(b)

['e', 'i', 'o', 12, 13, 14]

Step 1: L1[1:4]

List slicing extracts elements from the initial index up to (final index − 1). Here, elements are extracted from index 1 to 3.

L1 = ['a', 'e', 'i', 'o', 'u']

Index positions:
0 → 'a'
1 → 'e'
2 → 'i'
3 → 'o'
4 → 'u'

So, L1[1:4] gives: ['e', 'i', 'o']

Step 2: L2[::]

When no initial and final index is given, all elements of the list are extracted.

L2 = [12, 13, 14]

So, L2[::] gives: [12, 13, 14]

Step 3: + Operator

The + operator is used for concatenation, i.e., to join two lists together to form a single list. Therefore, ['e', 'i', 'o'] + [12, 13, 14] = ['e', 'i', 'o', 12, 13, 14].

(c)

['a', 'o', 'u']

The del keyword is used to delete elements from a list either at a specified index or within a range of indexes. When a range is given, elements from the initial index up to (final index − 1) are deleted. Here, del L1[1:3] deletes elements from index 1 to 2, i.e., 'e' and 'i' from the list ['a', 'e', 'i', 'o', 'u']. Hence, the remaining list becomes ['a', 'o', 'u'].

(d)

[12, 13, 14, 12, 13, 14]

List replication is the system of duplicating the elements of the list (i.e., appending the list with the elements of the same list). It is done with the help of the * operator. Therefore, 2*L2 duplicates the elements of the list [12, 13, 14] and results in [12, 13, 14, 12, 13, 14].

True

In list comparison, the corresponding elements of both the lists are compared with each other starting with the 0th index. The result is determined the moment elements are found different. Here, the first elements are compared: 2 and 5. Since 2 is less than 5, the expression [2, 4, 6, 8] < [5, 9] becomes True.

False

In list comparison, the corresponding elements of both the lists are compared with each other starting with the 0th index, and the result is determined the moment elements are found different.

Comparison:
1 = 1
2 = 2
8 < 13

Since 8 is less than 13, the expression [1, 2, 8, 5] > [1, 2, 13, 5] becomes False.

3

The count() function is used to find the frequency of an element among a set of elements stored in the list. In the list [1, 3, 5, 3, 7, 3, 9], the value 3 occurs three times. Therefore, L1.count(3) returns 3.

To access or slice elements from a list, the index or range of indexes must be enclosed within square brackets [ ] along with the list variable, as per the slicing syntax <List variable>[initial index : final index]. In the given code, parentheses ( ) are used instead of square brackets, i.e., L1(1:4), which is incorrect syntax for list slicing. Therefore, the statement results in an error.

97

The pop(index) function is used to delete and return the element available at the given index of the list. First, L1.pop(1) deletes and returns the element at index 1, i.e., 15. The list becomes [11, 24, 38, 82]. Then, L1.pop(3) deletes and returns the element at index 3 of the updated list, i.e., 82. Therefore, the expression becomes 15 + 82, which results in 97.

sum_even = 0
sum_odd = 0
Lst = eval(input("Enter list elements within []:"))

for i in range(len(Lst)):
    if(Lst[i] % 2 == 0):
        sum_even = sum_even + Lst[i]
    else:
        sum_odd = sum_odd + Lst[i]

print("Sum of even integers:", sum_even)
print("Sum of odd integers:", sum_odd)

Enter list elements within []:[12, 7, 9, 14, 6, 3]
Sum of even integers: 32
Sum of odd integers: 19

sum_even_index = 0
prod_odd_index = 1
L1 = eval(input("Enter list elements within [ ]:"))

for i in range(len(L1)):
    if(i % 2 == 0):
        sum_even_index = sum_even_index + L1[i]
    else:
        prod_odd_index = prod_odd_index * L1[i]

print("Sum of elements at even indexes:", sum_even_index)
print("Product of elements at odd indexes:", prod_odd_index)

Enter list elements within [ ]:[5, 4, 3, 2, 6, 7]
Sum of elements at even indexes: 14
Product of elements at odd indexes: 56

L1 = eval(input("Enter a set of numbers in the list within [ ]:"))

num = eval(input("Enter an element to be searched:"))
flag = False
p = len(L1)

for a in range(p):
    if(num == L1[a]):
        flag = True
        break

if(flag == True):
    print("Search successful")
else:
    print("No such number is found in the list")

Enter a set of numbers in the list within [ ]:[21, 34, 45, 28, 91, 75]
Enter an element to be searched:91
Search successful

L1 = eval(input("Enter names in the list within [ ]:"))
L1.sort()
print("Names in alphabetical order:", L1)

Enter names in the list within [ ]:['Riya', 'Ankit', 'Meera', 'Dev']
Names in alphabetical order: ['Ankit', 'Dev', 'Meera', 'Riya']

L1 = eval(input("Enter elements of first list within [ ]:"))
L2 = eval(input("Enter elements of second list within [ ]:"))
L3 = L1 + L2
print("Elements of the third list:", L3)

Enter elements of first list within [ ]:[1, 3, 5]
Enter elements of second list within [ ]:[2, 4, 6]
Elements of the third list: [1, 3, 5, 2, 4, 6]

L1 = eval(input("Enter numbers in the list within [ ]:"))
print("The composite numbers are:")
for a in L1:
    c = 0
    for b in range(1, a+1):
        if(a % b == 0):
            c = c + 1
    if(c > 2):
        print(a)

Enter numbers in the list within [ ]:[21, 45, 29, 37, 82, 31]
The composite numbers are:
21
45
82

A list is defined as an ordered sequence of data (may be same or different data types) separated by commas and enclosed within opening and closing square brackets [ ].

For example: Lst = [1, 3, 5, 7, 9]

An empty or null list is a list that does not enclose any value under opening and closing square brackets [ ].

For example: Lst = [ ]

Yes, a list can contain data of different types. A list is defined as an ordered sequence of data (may be same or different data types) separated by commas and enclosed within opening and closing square brackets [ ].

For example: ["Robotics", "ICSE", 2025]

List slicing is a technique to create a list after ignoring some elements of the existing list.

Differences between del and pop() functions are:

The len() function is used to find the length of a list (i.e., the number of elements available in the list).

The extend() function is used to add multiple elements within another list. It is also called merging the elements of two lists.

The sort() function is used to arrange the list of elements in a specific order (ascending or descending).

The insert() function is used to add an element at a specified index used as an argument to the function.

The append() function is used to add an element at the end of an existing list of elements. It adds a single element to a list.

The count() function is used to find the frequency of an element among a set of elements stored in the list.