List Methods

Beginner ~25 min read

Python lists come with powerful built-in methods that let you manipulate data with ease. Whether you need to add items, remove duplicates, sort data, or find elements, there's a method for that. Mastering these methods is essential for writing clean, efficient Python code!

Adding Elements

Three methods let you add elements to a list: append() adds one item to the end, insert() adds at a specific position, and extend() adds multiple items from another iterable.

# List Methods: Adding Elements

fruits = ["apple", "banana"]
print(f"Original: {fruits}")
print()

# 1. append() - Add single element to end
print("=== append() - Add to End ===")
fruits.append("cherry")
print(f"After fruits.append('cherry'): {fruits}")

fruits.append(["date", "elderberry"])  # Adds list as single element!
print(f"After appending a list: {fruits}")
print()

# Reset for clarity
fruits = ["apple", "banana", "cherry"]

# 2. insert() - Add at specific index
print("=== insert(index, element) ===")
fruits.insert(0, "apricot")  # Insert at beginning
print(f"After insert(0, 'apricot'): {fruits}")

fruits.insert(2, "blueberry")  # Insert in middle
print(f"After insert(2, 'blueberry'): {fruits}")

fruits.insert(100, "zucchini")  # Index > length adds to end
print(f"After insert(100, 'zucchini'): {fruits}")
print()

# 3. extend() - Add multiple elements
print("=== extend(iterable) ===")
colors = ["red", "green"]
print(f"Original colors: {colors}")

colors.extend(["blue", "yellow"])
print(f"After extend(['blue', 'yellow']): {colors}")

# extend() works with any iterable
colors.extend("AB")  # String becomes ['A', 'B']
print(f"After extend('AB'): {colors}")
print()

# 4. += operator (same as extend)
print("=== += Operator ===")
numbers = [1, 2, 3]
numbers += [4, 5]
print(f"[1,2,3] += [4,5] = {numbers}")
print()

# Key difference: append vs extend
print("=== append() vs extend() ===")
list1 = [1, 2, 3]
list1.append([4, 5])
print(f"append([4, 5]): {list1}")  # [1, 2, 3, [4, 5]]

list2 = [1, 2, 3]
list2.extend([4, 5])
print(f"extend([4, 5]): {list2}")  # [1, 2, 3, 4, 5]

Output

Click Run to execute your code

append() vs extend(): append() adds its argument as a single element, even if it's a list. extend() iterates over its argument and adds each element individually. Use append() for single items, extend() for combining lists.

Removing Elements

Python provides several ways to remove elements: remove() by value, pop() by index (with return), del by index or slice, and clear() to empty the entire list.

# List Methods: Removing Elements

fruits = ["apple", "banana", "cherry", "banana", "date"]
print(f"Original: {fruits}")
print()

# 1. remove(value) - Remove first occurrence of value
print("=== remove(value) ===")
fruits.remove("banana")  # Removes FIRST banana only
print(f"After remove('banana'): {fruits}")
# Note: fruits.remove("grape") would raise ValueError!
print()

# 2. pop() - Remove and return element by index
print("=== pop([index]) ===")
items = ["a", "b", "c", "d", "e"]
print(f"Original: {items}")

last = items.pop()  # Remove last
print(f"items.pop() returned: '{last}', list: {items}")

first = items.pop(0)  # Remove at index 0
print(f"items.pop(0) returned: '{first}', list: {items}")

middle = items.pop(1)  # Remove at index 1
print(f"items.pop(1) returned: '{middle}', list: {items}")
print()

# 3. del statement - Delete by index or slice
print("=== del statement ===")
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(f"Original: {numbers}")

del numbers[0]  # Delete first element
print(f"After del numbers[0]: {numbers}")

del numbers[2:5]  # Delete slice
print(f"After del numbers[2:5]: {numbers}")

del numbers[::2]  # Delete every other element
print(f"After del numbers[::2]: {numbers}")
print()

# 4. clear() - Remove all elements
print("=== clear() ===")
data = [1, 2, 3, 4, 5]
print(f"Before clear: {data}")
data.clear()
print(f"After clear: {data}")
print()

# Comparison table
print("=== Method Comparison ===")
print("remove(x)  - By value, first occurrence only")
print("pop(i)     - By index, returns removed item")
print("del list[i]- By index or slice, no return")
print("clear()    - Removes all elements")

Output

Click Run to execute your code

Pro Tip: Use pop() when you need the removed value (like implementing a stack). Use remove() when you know the value but not the index. Use del when removing multiple items with a slice.

Sorting and Ordering

Sort lists with sort() (modifies in place) or sorted() (returns new list). Reverse with reverse() or reversed(). Both support custom sorting with the key parameter.

# List Methods: Sorting and Ordering

# 1. sort() - Sort in place (modifies original)
print("=== sort() - In-Place Sorting ===")
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"Original: {numbers}")

numbers.sort()
print(f"After sort(): {numbers}")

numbers.sort(reverse=True)
print(f"After sort(reverse=True): {numbers}")
print()

# Sorting strings
print("=== Sorting Strings ===")
words = ["banana", "Apple", "cherry", "date"]
print(f"Original: {words}")

words.sort()  # Uppercase comes before lowercase!
print(f"After sort(): {words}")

words.sort(key=str.lower)  # Case-insensitive
print(f"After sort(key=str.lower): {words}")
print()

# 2. sorted() - Returns new sorted list (original unchanged)
print("=== sorted() - Returns New List ===")
original = [3, 1, 4, 1, 5]
print(f"Original: {original}")

new_sorted = sorted(original)
print(f"sorted(original): {new_sorted}")
print(f"Original after sorted(): {original}")  # Unchanged!
print()

# 3. reverse() - Reverse in place
print("=== reverse() - In-Place Reversal ===")
items = ["a", "b", "c", "d"]
print(f"Original: {items}")

items.reverse()
print(f"After reverse(): {items}")
print()

# 4. reversed() - Returns iterator (original unchanged)
print("=== reversed() - Returns Iterator ===")
nums = [1, 2, 3, 4, 5]
print(f"Original: {nums}")

reversed_list = list(reversed(nums))
print(f"list(reversed(nums)): {reversed_list}")
print(f"Original after reversed(): {nums}")  # Unchanged!
print()

# 5. Custom sorting with key
print("=== Custom Sorting with key ===")
students = [
    {"name": "Alice", "grade": 85},
    {"name": "Bob", "grade": 92},
    {"name": "Charlie", "grade": 78}
]

students.sort(key=lambda x: x["grade"])
print("Sorted by grade (ascending):")
for s in students:
    print(f"  {s['name']}: {s['grade']}")

Output

Click Run to execute your code

In-Place vs New List: sort() and reverse() modify the original list and return None. Don't do x = mylist.sort() - x will be None! Use sorted() or reversed() if you need to keep the original list unchanged.

Searching and Counting

Find elements with index(), count occurrences with count(), and check membership with the in operator.

# List Methods: Searching and Counting

fruits = ["apple", "banana", "cherry", "banana", "date", "banana"]
print(f"List: {fruits}")
print()

# 1. index() - Find position of first occurrence
print("=== index(value) ===")
pos = fruits.index("banana")
print(f"index('banana'): {pos}")  # First banana at index 1

pos = fruits.index("cherry")
print(f"index('cherry'): {pos}")

# index() with start and end
pos = fruits.index("banana", 2)  # Start searching from index 2
print(f"index('banana', 2): {pos}")

# Note: index() raises ValueError if not found!
# fruits.index("grape")  # ValueError: 'grape' is not in list
print()

# 2. count() - Count occurrences
print("=== count(value) ===")
banana_count = fruits.count("banana")
print(f"count('banana'): {banana_count}")

grape_count = fruits.count("grape")
print(f"count('grape'): {grape_count}")  # 0, doesn't exist
print()

# 3. 'in' operator - Check membership
print("=== 'in' Operator ===")
print(f"'apple' in fruits: {'apple' in fruits}")
print(f"'grape' in fruits: {'grape' in fruits}")
print(f"'grape' not in fruits: {'grape' not in fruits}")
print()

# 4. Safe searching pattern
print("=== Safe Search Pattern ===")
search_item = "cherry"

# Method 1: Check with 'in' first
if search_item in fruits:
    position = fruits.index(search_item)
    print(f"Found '{search_item}' at index {position}")
else:
    print(f"'{search_item}' not found")

# Method 2: Try/except
try:
    position = fruits.index("grape")
    print(f"Found 'grape' at index {position}")
except ValueError:
    print("'grape' not found")
print()

# 5. Finding all occurrences
print("=== Finding All Occurrences ===")
item = "banana"
indices = [i for i, x in enumerate(fruits) if x == item]
print(f"All positions of '{item}': {indices}")

Output

Click Run to execute your code

Common Mistakes

1. Assigning result of sort() or reverse()

# Wrong - sort() returns None!
numbers = [3, 1, 2]
sorted_nums = numbers.sort()
print(sorted_nums)  # None!

# Correct
numbers.sort()  # Modifies in place
print(numbers)  # [1, 2, 3]

# Or use sorted() for new list
sorted_nums = sorted([3, 1, 2])

2. remove() raises error if item not found

# Wrong - crashes if item doesn't exist
fruits = ["apple", "banana"]
fruits.remove("grape")  # ValueError!

# Correct - check first
if "grape" in fruits:
    fruits.remove("grape")
else:
    print("Not found")

3. Confusing append() with extend()

# Unexpected result
list1 = [1, 2, 3]
list1.append([4, 5])
print(list1)  # [1, 2, 3, [4, 5]] - nested list!

# What you probably wanted
list2 = [1, 2, 3]
list2.extend([4, 5])
print(list2)  # [1, 2, 3, 4, 5]

4. Modifying list while iterating

# Wrong - removing while iterating causes issues
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # Skips elements!

# Correct - iterate over copy or use list comprehension
numbers = [1, 2, 3, 4, 5]
numbers = [num for num in numbers if num % 2 != 0]
print(numbers)  # [1, 3, 5]

Exercise: List Operations

Task: Perform various operations on a list of numbers.

Requirements:

Add the number 10 to the end of the list
Remove the first occurrence of 5
Sort the list in ascending order
Print the final list

Output

Click Run to execute your code

Show Solution

numbers = [5, 2, 9, 1, 5, 6]

# Add 10 to end
numbers.append(10)

# Remove first 5
numbers.remove(5)

# Sort ascending
numbers.sort()

print(f"Final list: {numbers}")
# Output: [1, 2, 5, 6, 9, 10]

Summary

Adding: append(x), insert(i, x), extend(iterable)
Removing: remove(x), pop([i]), del list[i], clear()
Sorting: sort() (in-place), sorted() (new list)
Reversing: reverse() (in-place), reversed() (iterator)
Searching: index(x), count(x), x in list
In-place methods: Return None, modify original
Functional versions: sorted(), reversed() preserve original

What's Next?

Now that you've mastered list methods, let's learn List Comprehensions - Python's elegant, one-liner syntax for creating and transforming lists. It's one of Python's most loved features!

Previous Lists

Next List Comprehensions

Adding Elements

Removing Elements

Sorting and Ordering

Searching and Counting

Common Mistakes

1. Assigning result of sort() or reverse()

2. remove() raises error if item not found

3. Confusing append() with extend()

4. Modifying list while iterating

Exercise: List Operations

Summary

What's Next?

Enjoying these tutorials?