Question Bank: Lists

What is the main feature of a list in Python?

Which of the following correctly initializes a list containing mixed data types?

How is the first element of a list accessed in Python?

What will the code list = [0, 1, 2, 3]; print(list[2]) output?

Which of the following is a correct way to create a nested list?

In Python, which of the following will raise an IndexError?

What does the following code return? list = ['x', 'y', 'z']; print(list[-1])

Which of these operations can be performed on a list?

What will the following code output? list = [1, 2, 3]; list.append(4); print(list)

What does the expression 'len(list)' return?

Given the list 'nested = [[1, 2], [3, 4]]', how would you access the number '4'?

If you have a list 'alpha = [5, 10, 15]' and execute 'alpha[1:3]', what will be the output?

What happens when you execute 'list = [1, 2, 3]; list[0] = 10'?

Which of the following correctly removes an element from a list?

What does the statement 'list2 = list1' do in Python?

Which method is used to make a distinct copy of a list using slicing?

What will be the output of 'list1 = [1,2,3]; list2 = list(list1); list2.append(4); print(list1)'?

What is the purpose of the 'copy()' function from the copy module?

Which of the following will directly modify the original list when passed to a function?

Which of the following statements is FALSE about list copying in Python?

What happens if you modify an element in a shallow copy of a list?

If you want to copy a list that contains nested lists, which method will ensure the deep copy?

What is the effect of modifying a list inside a function where the list was passed as an argument?

Which of the following methods would you use to assign a copy of a list that maintains the changes separately?

Which of the following indicates that two lists are the same object in memory?

What is the simplest way to copy a list if it should include only elements, not nested lists?

What Python statement would create a copy of 'data' such that changes to 'copy_data' do not affect 'data'?

What will be the result of the operation list1 + list2 if list1 = [1, 2, 3] and list2 = [4, 5]?

Which method would you use to add an element at the end of a list?

What is the output of the following code: myList = [10, 20, 30]; myList[1] = 40; print(myList)?

How do you access the last element of a list called myList?

What will happen if you try to access a position in a list that is out of range?

Which of the following methods removes an element by its value from a list?

If myList = [5, 10, 15, 20] and you execute myList.pop(), what will be the output?

What is the time complexity of appending an item to a list in Python?

What will be the output of sorted([3, 1, 2])?

What does the extend() method do in regard to lists?

If you execute myList.clear(), what will myList become?

How do you sort a list named myList in descending order in Python?

Which of the following creates a nested list?

What will happen if you use myList.remove(25) when myList = [10, 20, 30]?

What is the primary difference between the pop() and remove() methods of a list?

How can you copy a list named myList to another list named newList?

What is a nested list?

How do you access the second element of a nested list within a list?

In the list example list1 = [1,2,'a','c',[6,7,8],4,9], what will list1[4][1] return?

Which of the following correctly describes how to traverse a nested list?

What will the output be for the command list1 = [[1, 2], [3, 4]] and then executing list1[0][1]?

Which method can be used to access each item in a list?

If a list is created as lst = [1, [2, 3], 4], what would lst[1][0] return?

During list manipulation, what happens when you attempt to access an index that is out of range?

What will be the output of the code: 'for i in range(len(list1)):' where list1 = [10, 20, 30]?

What will the index out of range error in Python indicate when accessing a list?

How can you create a copy of a nested list without affecting the original?

How would you print each item in 'list1' using a while loop?

What type of data structure is returned when accessing a single element of a nested list?

What is the first element of the list 'list1 = [3, 5, 7, 9]'?

Given the nested list lst = [1, [2, [3, 4], 5], 6], what is lst[1][1][0]?

When traversing a list, what does the 'len()' function return?

Which of the following is a correct way to check the length of a nested list?

Which of the following is NOT a valid way to traverse a list?

If a nested list is defined as nested = [[1, 2], [3, 4]], what will nested[0][0] return?

What will happen if you attempt to access list1[5] when list1 = [1, 2, 3]?

What is the main reason to use nested lists in programming?

Using which statement can you combine the functionalities of both 'for' and 'while' loops in a single traversal?

In a list traversal using 'for item in list1:', what will you access?

What is the correct way to initialize an empty list in Python?

If 'list1 = [1, 2, 3, 4]' and you want to print the last element, which index will you use?

In Python, how can you iterate with indices through a list of varying lengths?

What type of error occurs if you try to use list methods on a variable that is not a list?

When modifying a list during traversal, which method is generally safest to avoid skipping elements?

If you want to traverse a nested list, which method is correct?

What will be the output of the function call 'print_list([1, 2, 3])' if defined correctly to print all elements?

Which of the following statements correctly defines a function that accepts a list as an argument?

How do you pass a list to a function in Python?

What happens if you attempt to access an out-of-range index in a list passed to a function?

Which of the following is a valid way to modify a list inside a function?

When passing a list to a function, what is passed by default?

What will happen if you change an element of the list within a function?

What is the term for passing a copy of a list to a function?

Given the function 'def print_elements(lst):', what will 'print_elements([])' output?

What is the output of the following code? def modify_list(lst): lst[0] = 99; modify_list([1, 2, 3]) print([1, 2, 3])

How can you return multiple values from a function that takes a list?

Why is it essential to handle list boundaries when defining functions?

In which scenario would passing a list to a function result in unintended changes?

What does the `len()` function return when applied to a list?

What will `list1.append([5, 6])` do to the list `list1 = [1, 2, 3]`?

Which method will you use to combine elements from another list into an existing list?

What does the `remove()` method do when an element is not found in the list?

How does the `insert(index, element)` method work?

If `list1 = [1, 2, 3]`, what will `list1.pop(1)` return?

How can you find the index of the first occurrence of an element in a list?

What would be the result of executing `list1.count(5)` on `list1 = [1, 2, 3]`?

Which method should be used to clear all elements from a list?

What will the list be after `list1 = [1, 2, 3]; list1.append(4); list1.append(5)`?

What does `list1.pop()` do if `list1 = [10, 20, 30]`?

If `list2 = list1.copy()`, what does `list2` contain?

Regarding list methods, what is a key difference between `append()` and `extend()`?

What will happen if you call `list1.index(4)` on `list1 = [1, 2, 3]`?

Which method may cause an error if an element is not found when invoked?

What will the output be after executing the following code? list1 = [5, 3, 8, 6]; list1.sort(); print(list1)

What does the len() function return when applied to the list myList = [10, 20, 30]?

If myList = [1, 2, 3, 4] and the statement myList.append(5) is executed, what will myList contain?

What will be the output of list1 = [1, 2, 3]; list1.extend([4, 5]); print(list1)?

Which operator can be used to concatenate two lists in Python?

What does myList.pop(0) do when myList = [1, 2, 3]?

If list1 = [10, 20, 30, 40] and you execute list1.insert(2, 25), what will list1 be?

What would be the result of applying myList.remove(20) to myList = [10, 20, 30]?

What is the result of list1 = [1, 2, 3]; sorted(list1)?

After executing list1 = [1, 2, 3]; list1.reverse(); what will list1 contain?

If myList = [10, 20, 30, 40] and you execute myList.extend(myList), what will myList contain?

What is the output of list1 = ['a', 'b', 'c', 'd']; print(list1[1:3])?

Which statement is true regarding a nested list?

If list1 = [1, 2, 3] and you perform the operation list1 *= 2, what will the result be?