3.1 Python Lists

In Python, a list is one of the most powerful and flexible data structures. It allows you to store a sequence of values that can be of the same or different data types. Lists are ordered, mutable, and can hold a mix of integers, strings, floats, booleans, complex numbers, or even other lists.

What is a List in Python?

A list is defined using square brackets [] with elements separated by commas. Lists can store any number of items, including duplicates.

Syntax:

my_list = [item1, item2, item3, ...]

Example Lists:

list1 = ["Riya", "Math", 18, 89.5]
list2 = [10, 20, 30, 40]
list3 = ["x", "y", "z"]
list4 = [3.14, False, -42, 5+3j]

Indexing in Lists

Python uses zero-based indexing. This means the first element has index 0, the second has index 1, and so on. You can also use negative indices to access elements from the end of the list.

Example:

items = ['apple', 'banana', 'cherry']
print(items[0])      # Output: apple
print(items[-1])     # Output: cherry

Accessing Elements Using Slicing

Slicing lets you retrieve a portion of the list. The syntax for slicing is [start:stop:step].

• start: The index of the first element to include (inclusive). Defaults to the beginning of the list if omitted.
• stop: The index of the first element to exclude (exclusive). Defaults to the end of the list if omitted.
• step: The increment between elements. Defaults to 1 if omitted.

Examples:

data1 = ['Math', 'Science', 2020, 2023]
data2 = [10, 20, 30, 40, 50, 60]

print(data1[0])          # Output: Math (accessing the first element)
print(data2[2:5])        # Output: [30, 40, 50] (elements from index 2 up to, but not including, index 5)
print(data2[::2])        # Output: [10, 30, 50] (every second element)
print(data2[::-1])       # Output: [60, 50, 40, 30, 20, 10] (reversing the list)

Modifying List Elements

You can update an existing list element by assigning a new value to a specific index. Lists are mutable, meaning their contents can be changed after creation.

Example:

marks = ['Math', 'Science', 2021, 2022]
print("Before update:", marks[2])
marks[2] = 2025
print("After update:", marks[2])

Output:

Before update: 2021
After update: 2025

Deleting List Elements

You can remove elements from a list using del, remove(), or pop().

• del list[index]: Deletes the element at the specified index.
• list.remove(value): Removes the first occurrence of the specified value.
• list.pop([index]): Removes and returns the item at the specified index. If no index is specified, it removes and returns the last item.

Example:

languages = ['Python', 'Java', 'C++', 'Go']
print("Original:", languages)

del languages[2]
print("After deletion using del:", languages)

numbers = [10, 20, 30, 20]
numbers.remove(20) # Removes the first occurrence of 20
print("After removing 20:", numbers)

last_item = languages.pop()
print("Popped item:", last_item)
print("After pop():", languages)

Output:

Original: ['Python', 'Java', 'C++', 'Go']
After deletion using del: ['Python', 'Java', 'Go']
After removing 20: [10, 30, 20]
Popped item: Go
After pop(): ['Python', 'Java']

Common List Operations

Python supports several convenient operations for lists:

List Methods in Python

Python lists have a rich set of built-in methods for various manipulations.

Adding Elements

• append(obj): Adds a single item to the end of the list.
• extend(seq): Adds all items from an iterable (like another list or tuple) to the end of the list.
• insert(i, obj): Inserts an item obj at a specified index i.

Example:

colors = ['red', 'blue']
colors.append('green')         # colors is now ['red', 'blue', 'green']
colors.extend(['yellow', 'orange']) # colors is now ['red', 'blue', 'green', 'yellow', 'orange']
colors.insert(1, 'purple')     # colors is now ['red', 'purple', 'blue', 'green', 'yellow', 'orange']
print(colors)

Output:

['red', 'purple', 'blue', 'green', 'yellow', 'orange']

Removing Elements

• pop([i]): Removes and returns the item at index i. If no index is provided, it removes and returns the last item.
• remove(obj): Removes the first occurrence of the specified value obj.
• clear(): Removes all items from the list, making it empty.

Example:

numbers = [10, 20, 30, 40, 20]
print("Original numbers:", numbers)

last_num = numbers.pop() # Removes and returns 20
print("Popped:", last_num)
print("After pop():", numbers)

numbers.remove(20)      # Removes the first occurrence of 20
print("After remove(20):", numbers)

numbers.clear()         # Empties the list
print("After clear():", numbers)

Output:

Original numbers: [10, 20, 30, 40, 20]
Popped: 20
After pop(): [10, 20, 30, 40]
After remove(20): [10, 30, 40]
After clear(): []

Other Useful Methods

• copy(): Returns a shallow copy of the list. Changes to the original list will not affect the copy, and vice-versa, for nested elements.
• sort(): Sorts the list in place (modifies the original list). By default, it sorts in ascending order.
• reverse(): Reverses the order of elements in the list in place.
• count(obj): Returns the number of times an element obj appears in the list.
• index(obj): Returns the index of the first occurrence of an element obj. Raises a ValueError if the item is not found.

Example:

values = [1, 3, 2, 4, 2, 3, 2]
print("Original values:", values)

print("Index of 3:", values.index(3))      # Output: 1
print("Count of 2:", values.count(2))      # Output: 3

values.sort()
print("Sorted values:", values)          # Output: [1, 2, 2, 2, 3, 3, 4]

values.reverse()
print("Reversed values:", values)        # Output: [4, 3, 3, 2, 2, 2, 1]

copied_values = values.copy()
print("Copied values:", copied_values)

Output:

Original values: [1, 3, 2, 4, 2, 3, 2]
Index of 3: 1
Count of 2: 3
Sorted values: [1, 2, 2, 2, 3, 3, 4]
Reversed values: [4, 3, 3, 2, 2, 2, 1]
Copied values: [4, 3, 3, 2, 2, 2, 1]

Built-in Functions for Lists

Besides list methods, several built-in Python functions can be used with lists:

• len(list): Returns the number of elements in the list.
• max(list): Returns the largest item in the list.
• min(list): Returns the smallest item in the list.
• list(seq): Converts another sequence (like a tuple, string, or set) to a list.

Example:

data = [4, 7, 2, 9, 1, 5]
print("Data:", data)
print("Length:", len(data))       # Output: 6
print("Max value:", max(data))    # Output: 9
print("Min value:", min(data))    # Output: 1

my_tuple = (1, 2, 3)
list_from_tuple = list(my_tuple)
print("List from tuple:", list_from_tuple) # Output: [1, 2, 3]

Exploring List Methods Dynamically

You can use built-in functions to inspect list objects:

• dir([]): Lists all attributes and methods of a list object.
• help([].append): Displays the documentation (docstring) for a specific method.

Example:

# Lists all methods and attributes of a list
print(dir([]))

# Shows documentation for the append method
# help([].append)

Summary

Python lists are incredibly powerful for handling dynamic data. They are flexible, easy to manipulate, and come with a rich set of built-in methods. Whether you’re managing datasets, performing computations, or building complex applications, mastering lists is essential for any Python programmer.

Interview Questions for Python Lists

• What is a list in Python, and how is it different from arrays in other languages?
• How do you define a list in Python?
• What does it mean that lists are mutable in Python?
• Explain the difference between list indexing and slicing with examples.
• How would you add elements to a list? Explain append(), extend(), and insert() methods.
• How can elements be removed from a list? Explain remove(), pop(), and clear() methods.
• What’s the difference between del and remove() when working with lists?
• What are the advantages of using lists over arrays in Python?
• How do you sort a list in Python? How do you reverse a list?
• How does the count() method work in Python lists?