# Indexing and Slicing Lists in Python PCEP Exam preparation

## PCEP Certification Practice Test - Questions, Answers and Explanations

Here are 25 questions related to the subtopic of "indexing and slicing" using lists in Python, formatted according to the PCEP-30-0x examination style.

Question 1: What will the following code output?

```my_list = [10, 20, 30, 40, 50]
print(my_list[2])
```
1. 10
2. 20
3. 30
4. 40

Explanation: List indexing in Python starts at 0. The element at index 2 is 30.

Question 2: Complete the code to access the first element of the list my_list = [5, 10, 15, 20]:

```first_element = my_list[___]
```

Explanation: The first element of a list is accessed using index 0.

Question 3: What will the following code output?

```my_list = [1, 2, 3, 4, 5]
print(my_list[-1])
```
1. 1
2. 5
3. 4
4. IndexError

Explanation: Negative indexing in Python allows you to access elements from the end of the list. my_list[-1] gives the last element, which is 5.

Question 4: Which of the following will return the element 4 from the list my_list = [1, 2, 3, 4, 5]? (Select all that apply)

1. my_list[3]
2. my_list[-2]
3. my_list[2]
4. my_list[4]

b) my_list[-2]

Explanation: my_list[3] and my_list[-2] both access the element 4. Index 3 corresponds to the fourth element, and index -2 accesses the second-to-last element.

Question 5: Fill in the blank to get the sublist [2, 3, 4] from my_list = [1, 2, 3, 4, 5]:

`sub_list = my_list[1:___]`

Explanation: Slicing syntax my_list[start:end] returns elements from index start to end-1. my_list[1:4] returns [2, 3, 4].

Question 6: What does the following code return?

```my_list = [5, 10, 15, 20, 25]
print(my_list[::2])
```
1. [5, 10, 15]
2. [10, 20]
3. [5, 15, 25]
4. [25, 20, 15]

Explanation: The slicing my_list[::2] returns every second element from the list, starting with the first element, giving [5, 15, 25].

Question 7: Complete the code to reverse the list my_list = [1, 2, 3, 4, 5] using slicing:

`reversed_list = my_list[___]`

Explanation: The slice my_list[::-1] reverses the list by starting from the end and stepping backwards.

Question 8: What will be the output of the following code?

```my_list = [2, 4, 6, 8, 10]
print(my_list[1:4])
```
1. [2, 4, 6, 8]
2. [4, 6, 8]
3. [4, 6]
4. [6, 8, 10]

Explanation: The slice my_list[1:4] returns elements from index 1 to 3, which are [4, 6, 8].

Question 9: Insert the correct code to access the second-to-last element of the list my_list = [10, 20, 30, 40, 50].

Explanation: Negative indexing allows accessing elements from the end of the list. my_list[-2] refers to the second-to-last element.

Question 10: Which of the following slices will result in an empty list? (Select all that apply)

1. my_list[4:2]
2. my_list[2:2]
3. my_list[1:1]
4. my_list[-1:-2]

1. my_list[2:2]
2. my_list[4:2]
3. my_list[-1:-2]
4. my_list[1:1]

Explanation: All these slices return an empty list because the start index is either equal to or greater than the end index.

Question 11: Reorder the following operations to correctly slice the list my_list = [10, 20, 30, 40, 50] and get the result [20, 30, 40].

1. my_list[4]
2. my_list[1:4]
3. my_list[:4]

Explanation: The slice my_list[1:4] gives the sublist [20, 30, 40] by including elements from index 1 to 3.

Question 12: Fill in the blank to access the first three elements of my_list = [7, 14, 21, 28, 35]:

`sub_list = my_list[___:3]`

Explanation: Omitting the start index in slicing starts from the beginning. my_list[:3] gives [7, 14, 21].

Question 13: Insert the correct code to slice the list my_list = [10, 20, 30, 40, 50] and get every second element starting from the second element.

Explanation: The slice my_list[1::2] starts from index 1 and steps by 2, returning every second element [20, 40].

Question 14: What will the following code output?

```my_list = [3, 6, 9, 12, 15]
print(my_list[-3])
```
1. 9
2. 12
3. 15
4. 6

Explanation: Negative index -3 refers to the third element from the end, which is 9.

Question 15: Which of the following will correctly slice the list my_list = [5, 10, 15, 20, 25] to get the sublist [10, 15, 20]? (Select all that apply)

1. my_list[1:4]
2. my_list[-4:-1]
3. my_list[1:-1]
4. my_list[2:4]

b) my_list[-4:-1]
c) my_list[1:-1]

Explanation: These slices correctly extract the sublist [10, 15, 20] from the original list.

Question 16: Complete the code to access the middle three elements of my_list = [11, 22, 33, 44, 55, 66, 77]:

```sub_list = my_list[___:___]
```

Explanation: The slice my_list[2:5] returns [33, 44, 55], which are the middle three elements of the list.

Question 17: Which slicing operation will return a new list that is a copy of the original list my_list = [1, 2, 3, 4, 5]?

1. my_list[:]
2. my_list[0:]
3. my_list[::-1]
4. my_list[:0]

Explanation: Slicing with my_list[:] returns a new list that is a copy of the entire original list.

Question 18: Sort the following operations to access the last three elements of the list my_list = [10, 20, 30, 40, 50, 60].

1. my_list[-3:]
2. my_list[-3:6]
3. my_list[3:]

Explanation: The slice my_list[-3:] returns the last three elements [40, 50, 60].

Question 19: Complete the code to replace the first two elements of my_list = [1, 2, 3, 4, 5] with [10, 20]:

`my_list[___:___] = [10, 20]`

Explanation: The slice my_list[0:2] targets the first two elements, allowing them to be replaced by [10, 20].

Question 20: What will be the result of the following code?

```my_list = [100, 200, 300, 400]
print(my_list[-1:-4:-1])
```
1. [400, 300, 200]
2. [400, 300, 200, 100]
3. [300, 200, 100]
4. [200, 300, 400]

Explanation: The slice my_list[-1:-4:-1] starts at index -1 (400) and moves backwards by 1 step until it reaches -4.

Question 21: Fill in the blank to access every third element of my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]:

`sub_list = my_list[___]`

Explanation: The slice my_list[::3] returns every third element [1, 4, 7].

Question 22: Insert the correct code to remove the last element of the list my_list = [1, 2, 3, 4, 5] without using the pop() method.

Explanation: The slice my_list[:-1] excludes the last element and can be reassigned to the original list.

Question 23: What will the following code output?

```my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[7:3:-1])
```
1. [8, 7, 6, 5]
2. [8, 7, 6, 5, 4]
3. [7, 6, 5, 4]
4. [6, 5, 4]

Answer: a) [8, 7, 6, 5]

Explanation: The slice my_list[7:3:-1] starts at index 7 and moves backward, ending just before index 3.

Question 24: Complete the code to extract the elements [3, 4, 5] from my_list = [0, 1, 2, 3, 4, 5, 6]:

`sub_list = my_list[___:___]`

Explanation: The slice my_list[3:6] returns the sublist [3, 4, 5].

Question 25: Reorder the following steps to access elements from the third to the last element of the list my_list = [1, 2, 3, 4, 5, 6, 7]:

1. my_list[2:]
2. my_list[-3:]
3. my_list[:-2]