Python Lists

What are Lists?

Lists in Python are ordered, mutable sequences used to store collections of items. They can contain elements of different types, including other lists. Lists are defined by enclosing elements in square brackets [] and separating them with commas.

my_list = [1, "hello", 3.14, [1, 2, 3]]

Why Use Lists?

Mutability: Unlike tuples, lists can be modified after creation.
Ordering: Lists maintain the order of elements.
Heterogeneous Data: Lists can store different types of data in a single structure.
Dynamic Sizing: Lists can grow or shrink as needed.
Rich Set of Methods: Python provides many built-in methods for list manipulation.

Creating Lists

# Empty list
empty_list = []

# List with elements
numbers = [1, 2, 3, 4, 5]

# List with mixed types
mixed = [1, "two", 3.0, [4, 5]]

# List comprehension
squares = [x**2 for x in range(5)]

# Using the list() constructor
char_list = list("hello")

Accessing List Elements

my_list = [10, 20, 30, 40, 50]

# Indexing
print(my_list[1])  # Output: 20

# Negative indexing
print(my_list[-1])  # Output: 50

# Slicing
print(my_list[1:4])  # Output: [20, 30, 40]

# Stride
print(my_list[::2])  # Output: [10, 30, 50]

List Methods

append(x): Add an item to the end of the list.
```
my_list.append(60)
```
extend(iterable): Extend the list by appending elements from the iterable.
```
my_list.extend([70, 80])
```
insert(i, x): Insert an item at a given position.
```
my_list.insert(1, 15)
```
remove(x): Remove the first item from the list whose value is x.
```
my_list.remove(30)
```
pop([i]): Remove the item at the given position and return it. If no index is specified, removes and returns the last item.
```
popped = my_list.pop()
```
clear(): Remove all items from the list.
```
my_list.clear()
```
index(x[, start[, end]]): Return the index of the first occurrence of x.
```
index = my_list.index(30)
```
count(x): Return the number of times x appears in the list.
```
count = my_list.count(20)
```
sort(*, key=None, reverse=False): Sort the list in place.
```
my_list.sort(reverse=True)
```
reverse(): Reverse the elements of the list in place.
```
my_list.reverse()
```
copy(): Return a shallow copy of the list.
```
new_list = my_list.copy()
```

List Operations

Concatenation

list1 = [1, 2]
list2 = [3, 4]
result = list1 + list2  # [1, 2, 3, 4]

Repetition

list1 = [1, 2]
result = list1 * 3  # [1, 2, 1, 2, 1, 2]

Membership testing
```
print(2 in [1, 2, 3])  # True
```
Iteration
```
for item in [1, 2, 3]:
    print(item)
```

List Comprehensions

List comprehensions provide a concise way to create lists based on existing lists or other iterables.

# Basic list comprehension
squares = [x**2 for x in range(10)]

# With condition
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# Nested list comprehension
matrix = [[i*j for j in range(5)] for i in range(5)]

Common Use Cases for Lists

Storing Collections of Data
```
fruits = ["apple", "banana", "cherry"]
```

Implementing Stacks and Queues

# Stack
stack = []
stack.append("a")  # push
stack.pop()  # pop

# Queue
from collections import deque
queue = deque(["a", "b", "c"])
queue.append("d")  # enqueue
queue.popleft()  # dequeue

Storing Heterogeneous Data

person = ["Alice", 30, ["Python", "Java"], True]

Temporary Storage in Algorithms

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

Data Processing

numbers = [1, 2, 3, 4, 5]
squared = [x**2 for x in numbers]

Best Practices and Tips

Use list comprehensions for simple list creation and transformation.
Prefer enumerate() for getting both index and value in loops.
Use reversed() instead of reverse() if you don't need to modify the original list.
Use sorted() instead of sort() if you want to keep the original list unchanged.
Be cautious with large lists as they can consume significant memory.
Use collections.deque for efficient insertion and deletion at both ends.

Common Pitfalls

Modifying a List While Iterating Over It

# This can lead to unexpected results
my_list = [1, 2, 3, 4, 5]
for item in my_list:
    if item == 3:
        my_list.remove(item)

Unexpected Behavior with Shallow Copies

original = [1, [2, 3], 4]
shallow_copy = original.copy()
shallow_copy[1][0] = 5  # This also modifies original

Creating Lists of Lists Incorrectly

# This creates a list of references to the same inner list
wrong = [[0] * 3] * 3

# Correct way
correct = [[0 for _ in range(3)] for _ in range(3)]

Comparing Lists

# This compares list identity, not contents
if list1 is list2:
    print("Same list")

# Correct way to compare contents
if list1 == list2:
    print("Same contents")

Understanding lists and their appropriate use cases is crucial for effective Python programming. Their flexibility and rich set of operations make them one of the most commonly used data structures in Python.

Python Lists

What are Lists?​

Why Use Lists?​

Creating Lists​

Accessing List Elements​

List Methods​

List Operations​

List Comprehensions​

Common Use Cases for Lists​

Best Practices and Tips​

Common Pitfalls​