Q.Consider the statements given below and then choose the correct output from the given options:

L=['TIC', 'TAC']  
print(L[::-1])  

(A) ['CIT', 'CAT'] (B) ['TIC', 'TAC'] (C) ['CAT', 'CIT'] (D) ['TAC', 'TIC']

Python lists are 0-indexed, and the key is how different list methods treat an index at the boundary.

For a list L with 6 elements, the valid indices for accessing or removing an existing element are 0, 1, 2, 3, 4, 5. Any attempt to remove an element at an index outside this range raises an IndexError.

The insert() method behaves differently: it says where to place a new element. If the index equals the list length, the element is appended; if the index is even larger, it is still appended. So insert() is more forgiving than pop().

Take a sample list L = [10, 20, 30, 40, 50, 60] where len(L) is 6.

1. (A) L.pop(1) — index 1 exists, so this removes 20. No exception.

2. (B) L.pop(6) — pop() needs 0 <= index < len(L). Here len(L) is 6, so the valid indices are 0 to 5. Index 6 is out of range, so this raises an IndexError.

   Watch out

   A common mistake is confusing the length of the list with the highest valid index. For a list of length N, the highest valid index is N minus 1, not N. …

The Concept: Dynamic Typing and Containers

The heart of this question lies in understanding how Python handles data types. Python is a dynamically typed language. This means variables don't have fixed types; instead, the type is attached to the value at runtime. A list is just a sequence of references to objects, and those objects can be anything — integers, strings, floats, other lists, functions, or even None.

In contrast, languages like C or Java require arrays (or typed lists like ArrayList<Integer>) to hold elements of a single, predetermined type. Python deliberately avoids this restriction to be flexible.

Step-by-Step Reasoning

1. Check the definition of a Python list.

   The official Python documentation defines a list as a mutable, ordered sequence of items. It does not impose any type constraint on those items. The syntax [1, "hello", 3.14] is perfectly valid.

2. Test with a concrete example.

   Run the following in any Python interpreter:

   my_list = [42, "apple", 3.14, True, [1, 2]]
   print(my_list)
   

   This prints [42, 'apple', 3.14, True, [1, 2]] without error. The list contains an integer, a string, a float, a boolean, and a nested list — five different types.

3. Consider the underlying mechanism.

   Each element in a Python list is a pointer (reference) to an object. The list itself only stores these references. Since Python objects carry their own type information, the list doesn't need to enforce a single type. This is fundamentally different from a C array, where memory is laid out contiguously for one type.

4. Address the "must always" phrasing. …

When you work with lists in Python, slicing notation gives you powerful control over which elements you extract and in what order. The general form [start:stop:step] lets you specify where to begin, where to end, and how to move through the list. The step parameter is the key here.

A step of -1 tells Python to walk backward through the list. So L[::-1] means "start at the end, go to the beginning, taking steps of -1"—in other words, reverse the entire list. Crucially, this operation reverses the sequence of elements, not the contents of individual elements.

In the given code, L is a list containing two strings: 'TIC' and 'TAC'. When you apply [::-1], Python flips the order of these two items. The first element 'TIC' moves to the second position, and the second element 'TAC' moves to the first position. The strings themselves remain unchanged—'TIC' is still 'TIC', not 'CIT'. …

Let's break down this Python code step by step to understand its output. The core concepts here are string splitting and list slicing, both fundamental operations in Python.

First, we have the string event = "G20 Presidency@2023". This string contains two distinct parts separated by a space.

The next line, L = event.split(' '), uses the split() method. This method is called on a string and, when given an argument like ' ' (a space), it divides the string into a list of substrings wherever that delimiter (the space) is found.

In our case, event.split(' ') will take "G20 Presidency@2023" and split it at the space between "G20" and "Presidency@2023".

This operation results in a list: ['G20', 'Presidency@2023']. So, the variable L now holds this list.

Finally, we have print(L[::-2]). This is a list slicing operation. List slicing in Python uses the syntax [start:stop:step].

• start: The index where the slice begins (inclusive). If omitted, it defaults to the beginning of the list.
• stop: The index where the slice ends (exclusive). If omitted, it defaults to the end of the list.
• step: The increment between elements. If omitted, it defaults to 1.

In [::-2]:

• Both start and stop are omitted.
• The step is -2. A negative step value indicates that the slicing should proceed in reverse order, starting from the end of the list.

Let's apply this to our list L = ['G20', 'Presidency@2023']:

1. Since the step is negative, Python starts from the last element of the list. The last element of L is 'Presidency@2023'. This element is included in the result.
2. From this position, it moves backwards by 2 steps.
   • The index of 'Presidency@2023' is 1 (or -1 when counting from the end).
   • Moving back 2 steps from index 1 would take us to index 1 - 2 = -1. This is the same element. …

Python's standard library includes several aggregate functions that operate on collections. When you need to add up all numbers in a list, you want a function that iterates through every element and maintains a running total.

The sum() function does exactly this. It takes an iterable (like a list, tuple, or range) and returns the arithmetic sum of its elements. The syntax is straightforward:

sum(iterable, start=0)

where start is an optional initial value (defaults to 0) that gets added to the sum.

Let me show why each option is or isn't correct:

1. count() is a list method that counts occurrences of a specific value. For example, [1, 2, 2, 3].count(2) returns 2. It doesn't sum anything.

2. sum() is the built-in function we need. sum([1, 2, 3, 4]) returns 10. It works with any numeric iterable and is part of Python's core built-ins.

3. total() doesn't exist as a built-in Python function. You'd get a NameError if you tried to call it without defining it first. …

Python lists come with a suite of built-in methods that let you manipulate them directly. The key is knowing which operations are methods (called on the list itself, like my_list.append(x)) versus which are standalone functions (like len(my_list)).

Let's examine each option:

1. count() — This is a valid list method. It returns the number of times a specified element appears in the list. For example, [1, 2, 2, 3].count(2) returns 2.

2. length() — This does not exist as a list method in Python. Many students coming from other languages (like JavaScript's array.length property) expect this, but Python uses the built-in function len(my_list) instead. There is no my_list.length() method.

3. append() — A fundamental list method that adds a single element to the end of the list. my_list.append(5) modifies the list in place. …