Working with Lists in Python

Lists in Python are one of the most versatile data types. They allow you to store a collection of items in a single variable. Lists can contain elements of different data types and are mutable (you can change them after their creation). This module will cover everything from basic list operations to advanced list methods, including list comprehensions.

Subtopic 1: Introduction to Lists

A list in Python is a collection of ordered, changeable (mutable) elements, which can be of any data type. Lists are defined by enclosing the elements in square brackets ([]).

Creating Lists

Basic List: You can create a list with multiple elements, which can be of mixed data types.

my_list = [1, 2, 3, "Hello", True]
print(my_list)  # Output: [1, 2, 3, "Hello", True]

Empty List: You can also create an empty list and add elements later.
```
empty_list = []
```

Nested Lists: Lists can contain other lists, creating a list of lists.

nested_list = [[1, 2], [3, 4], [5, 6]]
print(nested_list)  # Output: [[1, 2], [3, 4], [5, 6]]

Subtopic 2: List Indexing and Slicing

Lists in Python support indexing and slicing, which allows you to access specific elements or sublists from a list.

List Indexing

Lists are zero-indexed, meaning the first element has an index of 0.

my_list = ['a', 'b', 'c', 'd']
print(my_list[0])  # Output: 'a'
print(my_list[-1]) # Output: 'd' (negative index counts from the end)

List Slicing

You can extract a portion (slice) of a list using the [start:end] syntax.

my_list = [1, 2, 3, 4, 5]
print(my_list[1:4])  # Output: [2, 3, 4] (from index 1 to index 3)
print(my_list[:3])   # Output: [1, 2, 3] (first three elements)
print(my_list[2:])   # Output: [3, 4, 5] (from index 2 to the end)
print(my_list[::2])  # Output: [1, 3, 5] (every second element)

List Modification

You can change the values of list elements by using their index.

my_list = [1, 2, 3]
my_list[0] = 10
print(my_list)  # Output: [10, 2, 3]

Subtopic 3: List Methods and Functions

Python provides a variety of built-in methods for working with lists. Below are the most commonly used list methods:

Common List Methods

append(): Adds an element to the end of the list.

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # Output: [1, 2, 3, 4]

extend(): Adds all elements from an iterable (e.g., another list) to the list.

my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  # Output: [1, 2, 3, 4, 5, 6]

insert(): Inserts an element at a specific index in the list.

my_list = [1, 2, 3]
my_list.insert(1, "Hello")
print(my_list)  # Output: [1, "Hello", 2, 3]

remove(): Removes the first occurrence of an element from the list.

my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # Output: [1, 3, 2]

pop(): Removes and returns the element at the specified index (defaults to the last element).

my_list = [1, 2, 3]
last_element = my_list.pop()
print(last_element)  # Output: 3
print(my_list)  # Output: [1, 2]

index(): Returns the index of the first occurrence of an element.

my_list = [1, 2, 3]
print(my_list.index(2))  # Output: 1

count(): Returns the number of occurrences of an element in the list.

my_list = [1, 2, 2, 3, 2]
print(my_list.count(2))  # Output: 3

sort(): Sorts the elements of the list in place.

my_list = [3, 1, 2]
my_list.sort()
print(my_list)  # Output: [1, 2, 3]

reverse(): Reverses the order of elements in the list.

my_list = [1, 2, 3]
my_list.reverse()
print(my_list)  # Output: [3, 2, 1]

clear(): Removes all elements from the list.

my_list = [1, 2, 3]
my_list.clear()
print(my_list)  # Output: []

copy(): Returns a shallow copy of the list.

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # Output: [1, 2, 3]

len(): Returns the number of elements in the list.

my_list = [1, 2, 3]
print(len(my_list))  # Output: 3

min() and max(): Returns the smallest and largest elements in the list, respectively.

my_list = [1, 2, 3]
print(min(my_list))  # Output: 1
print(max(my_list))  # Output: 3

sum(): Returns the sum of all elements in the list (if they are numbers).
```
my_list = [1, 2, 3]
print(sum(my_list))  # Output: 6
```

Subtopic 4: List Comprehensions

List comprehensions provide a concise way to create lists by applying an expression to each item in an iterable, optionally filtering elements with a condition.

Basic List Comprehension

squares = [x**2 for x in range(5)]
print(squares)  # Output: [0, 1, 4, 9, 16]

List Comprehension with Conditions

You can include a condition to filter items.

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # Output: [0, 4, 16, 36, 64]

List Comprehension with Multiple Loops

You can also use multiple for loops within a list comprehension.

pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)  # Output: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

Using Functions in List Comprehension

You can apply a function to each element in a list comprehension.

def square(x):
    return x**2

squares = [square(x) for x in range(5)]
print(squares)  # Output: [0, 1, 4, 9, 16]