Lists

Beginner ~25 min read

Lists are Python's most versatile data structure - ordered, mutable collections that can hold any type of data. Think of a list like a dynamic container that can grow, shrink, and change its contents at any time. If you're coming from other languages, lists are similar to arrays but much more powerful!

Creating Lists

Lists are created using square brackets [] with items separated by commas. Python lists can hold any data type - numbers, strings, booleans, even other lists!

# Creating Lists in Python

# Empty list
empty_list = []
print(f"Empty list: {empty_list}")

# List with elements
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
print(f"Fruits: {fruits}")
print(f"Numbers: {numbers}")

# Mixed data types (Python allows this!)
mixed = [1, "hello", 3.14, True, None]
print(f"Mixed types: {mixed}")

# Using list() constructor
from_string = list("hello")
from_range = list(range(5))
print(f"\nFrom string 'hello': {from_string}")
print(f"From range(5): {from_range}")

# Nested lists (list of lists)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(f"\nMatrix (nested list): {matrix}")

# List with repeated elements
zeros = [0] * 5
pattern = ["a", "b"] * 3
print(f"\n[0] * 5 = {zeros}")
print(f"['a', 'b'] * 3 = {pattern}")

# List properties
print(f"\n--- List Properties ---")
print(f"Length of fruits: {len(fruits)}")
print(f"Type: {type(fruits)}")
print(f"Lists are ordered: fruits[0] always = {fruits[0]}")
print(f"Lists allow duplicates: {[1, 1, 2, 2, 3]}")

Output

Click Run to execute your code

List Characteristics: Lists in Python are (1) Ordered - items maintain their insertion order, (2) Mutable - you can change, add, and remove items, (3) Allow duplicates - the same value can appear multiple times, and (4) Heterogeneous - can mix different data types in one list.

Accessing Elements with Indexing

Every item in a list has a position called an index. Python uses zero-based indexing - the first element is at index 0, the second at index 1, and so on. You can also use negative indices to count from the end!

# List Indexing and Accessing Elements

fruits = ["apple", "banana", "cherry", "date", "elderberry"]
print(f"List: {fruits}")
print(f"Indices:  0        1         2        3          4")
print()

# Positive indexing (from start)
print("=== Positive Indexing ===")
print(f"fruits[0] = {fruits[0]}")  # First element
print(f"fruits[1] = {fruits[1]}")  # Second element
print(f"fruits[4] = {fruits[4]}")  # Fifth (last) element

print()

# Negative indexing (from end)
print("=== Negative Indexing ===")
print(f"fruits[-1] = {fruits[-1]}")  # Last element
print(f"fruits[-2] = {fruits[-2]}")  # Second to last
print(f"fruits[-5] = {fruits[-5]}")  # Fifth from end (first)

print()

# Checking if element exists
print("=== Checking Membership ===")
print(f"'banana' in fruits: {'banana' in fruits}")
print(f"'grape' in fruits: {'grape' in fruits}")
print(f"'grape' not in fruits: {'grape' not in fruits}")

print()

# Finding index of element
print("=== Finding Index ===")
print(f"Index of 'cherry': {fruits.index('cherry')}")

# Count occurrences
numbers = [1, 2, 3, 2, 4, 2, 5]
print(f"\nList: {numbers}")
print(f"Count of 2: {numbers.count(2)}")

Output

Click Run to execute your code

Pro Tip: Use negative indexing when you need elements from the end of a list. my_list[-1] always gives you the last element, regardless of list length - much cleaner than my_list[len(my_list)-1]!

Extracting Sublists with Slicing

Slicing lets you extract a portion of a list using the syntax list[start:end:step]. It creates a new list containing elements from start up to (but not including) end, optionally skipping by step.

# List Slicing - Extracting Sublists

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(f"Original: {numbers}")
print(f"Indices:  0  1  2  3  4  5  6  7  8  9")
print()

# Basic slicing: list[start:end]
# Note: start is inclusive, end is exclusive
print("=== Basic Slicing [start:end] ===")
print(f"numbers[2:5] = {numbers[2:5]}")   # Elements 2, 3, 4
print(f"numbers[0:3] = {numbers[0:3]}")   # First 3 elements
print(f"numbers[7:10] = {numbers[7:10]}") # Last 3 elements

print()

# Omitting start or end
print("=== Omitting Start/End ===")
print(f"numbers[:4] = {numbers[:4]}")     # From beginning to 4
print(f"numbers[6:] = {numbers[6:]}")     # From 6 to end
print(f"numbers[:] = {numbers[:]}")       # Copy entire list

print()

# Negative indices in slicing
print("=== Negative Indices ===")
print(f"numbers[-4:] = {numbers[-4:]}")   # Last 4 elements
print(f"numbers[:-3] = {numbers[:-3]}")   # All except last 3
print(f"numbers[-5:-2] = {numbers[-5:-2]}") # From -5 to -2

print()

# Step parameter: list[start:end:step]
print("=== With Step [start:end:step] ===")
print(f"numbers[::2] = {numbers[::2]}")    # Every 2nd element
print(f"numbers[1::2] = {numbers[1::2]}")  # Odd indices
print(f"numbers[::3] = {numbers[::3]}")    # Every 3rd element

print()

# Reversing
print("=== Reversing ===")
print(f"numbers[::-1] = {numbers[::-1]}")  # Reverse entire list
print(f"numbers[5:2:-1] = {numbers[5:2:-1]}") # Reverse slice

Output

Click Run to execute your code

Slicing Creates a Copy! When you slice a list, Python creates a new list. The original list remains unchanged. This is important to remember for memory usage with large lists. my_list[:] is a common idiom to create a shallow copy of a list.

Modifying Lists

Unlike strings and tuples, lists are mutable - you can change their contents after creation. You can modify individual elements, replace entire sections, add new elements, or remove existing ones.

# Modifying Lists - Lists are Mutable!

# Change single element
fruits = ["apple", "banana", "cherry"]
print(f"Original: {fruits}")

fruits[1] = "blueberry"
print(f"After fruits[1] = 'blueberry': {fruits}")

print()

# Change multiple elements with slice assignment
numbers = [1, 2, 3, 4, 5]
print(f"Original: {numbers}")

numbers[1:4] = [20, 30, 40]
print(f"After numbers[1:4] = [20, 30, 40]: {numbers}")

# Replace with different length
numbers[1:4] = [200]  # Replace 3 elements with 1
print(f"After numbers[1:4] = [200]: {numbers}")

print()

# Adding elements
print("=== Adding Elements ===")
fruits = ["apple", "banana"]

fruits.append("cherry")  # Add to end
print(f"After append('cherry'): {fruits}")

fruits.insert(1, "apricot")  # Insert at position
print(f"After insert(1, 'apricot'): {fruits}")

fruits.extend(["date", "elderberry"])  # Add multiple
print(f"After extend(['date', 'elderberry']): {fruits}")

print()

# Removing elements
print("=== Removing Elements ===")
items = ["a", "b", "c", "d", "e"]
print(f"Original: {items}")

items.remove("c")  # Remove by value
print(f"After remove('c'): {items}")

popped = items.pop()  # Remove last
print(f"After pop(): {items}, popped: {popped}")

popped = items.pop(0)  # Remove at index
print(f"After pop(0): {items}, popped: {popped}")

del items[0]  # Delete at index
print(f"After del items[0]: {items}")

Output

Click Run to execute your code

Common Mistakes

1. IndexError - Accessing invalid index

# Wrong - index out of range
fruits = ["apple", "banana", "cherry"]
print(fruits[3])  # IndexError! Valid indices: 0, 1, 2

# Correct - check length first or use try/except
if len(fruits) > 3:
    print(fruits[3])
else:
    print("Index out of range")

2. Confusing index and value

# Wrong - remove() takes value, not index
numbers = [10, 20, 30]
numbers.remove(1)  # Tries to remove VALUE 1, not index 1!

# Correct
numbers.remove(20)  # Remove by value
# OR
numbers.pop(1)      # Remove by index

3. Off-by-one in slicing

# Wrong assumption - end index is exclusive!
numbers = [0, 1, 2, 3, 4]
first_three = numbers[0:2]  # Only gets [0, 1], not [0, 1, 2]

# Correct - remember end is exclusive
first_three = numbers[0:3]  # Gets [0, 1, 2]
# Or more simply:
first_three = numbers[:3]

4. Forgetting that assignment creates references

# Wrong - both variables point to same list!
original = [1, 2, 3]
copy = original  # This is NOT a copy!
copy.append(4)
print(original)  # [1, 2, 3, 4] - original changed too!

# Correct - create actual copy
copy = original[:]      # Slice copy
copy = original.copy()  # copy() method
copy = list(original)   # list() constructor

Exercise: Shopping List Manager

Task: Create and manipulate a shopping list.

Requirements:

Create a list with "milk", "eggs", "bread"
Print the second item (eggs)
Change "bread" to "whole wheat bread"
Add "butter" to the end of the list
Print the final list

Output

Click Run to execute your code

Show Solution

# Create the shopping list
shopping_list = ["milk", "eggs", "bread"]

# Print second item (index 1)
print(shopping_list[1])  # eggs

# Change bread to whole wheat bread (index 2)
shopping_list[2] = "whole wheat bread"

# Add butter to end
shopping_list.append("butter")

print(f"Final Shopping List: {shopping_list}")
# Output: ['milk', 'eggs', 'whole wheat bread', 'butter']

Summary

Creating: Use [] with comma-separated values
Properties: Ordered, mutable, allow duplicates, heterogeneous
Positive index: list[0] = first, list[1] = second
Negative index: list[-1] = last, list[-2] = second to last
Slicing: list[start:end:step] - end is exclusive!
Modifying: list[i] = value, append(), insert(), remove(), pop()
Copy: Use list[:] or .copy(), not =

What's Next?

Now that you understand how to create and access lists, let's explore the powerful built-in List Methods that let you sort, search, count, and transform your lists with ease!

Previous Nested Loops

Next List Methods

Creating Lists

Accessing Elements with Indexing

Extracting Sublists with Slicing

Modifying Lists

Common Mistakes

1. IndexError - Accessing invalid index

2. Confusing index and value

3. Off-by-one in slicing

4. Forgetting that assignment creates references

Exercise: Shopping List Manager

Summary

What's Next?

Enjoying these tutorials?