If you only master one data structure in Python, make it the list. Lists appear in virtually every Python program ever written. They hold your data when you read a file line by line, store the results when you scrape a website, collect user inputs in a loop, and organize everything from database records to pixel coordinates. A Python list is an ordered, mutable, and dynamically sized collection that can hold items of any type. This guide covers every essential operation — from creating your first list all the way through comprehensions, nested lists, copying pitfalls, and performance considerations — with runnable code at every step.
Python's creator, Guido van Rossum, designed the list to be the general-purpose workhorse of the language, and that decision has shaped how millions of developers write code every day. Whether you are processing a CSV of network logs, building a to-do app, or training a machine learning model, lists will be your constant companion. Let us start at the very beginning.
"I choose a lazy person to do a hard job. Because a lazy person will find an easy way to do it." — Frank Gilbreth (often attributed to Bill Gates)
Creating Lists
A list is defined by placing comma-separated values inside square brackets. You can create a list with initial values, create an empty list and populate it later, or build a list from another iterable using the list() constructor. Lists can contain any mix of data types, though keeping items the same type is cleaner and more common in practice.
# Lists with initial values
fruits = ["apple", "banana", "cherry", "date"]
numbers = [10, 20, 30, 40, 50]
mixed = [1, "hello", 3.14, True, None]
# Empty lists (two equivalent ways)
empty_a = []
empty_b = list()
# Building a list from other iterables
from_string = list("Python") # ['P', 'y', 't', 'h', 'o', 'n']
from_range = list(range(1, 6)) # [1, 2, 3, 4, 5]
from_tuple = list((10, 20, 30)) # [10, 20, 30]
# Repeating elements
zeros = [0] * 10 # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
pattern = ["A", "B"] * 4 # ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B']
print(f"Fruits: {fruits}")
print(f"From string: {from_string}")
print(f"Zeros: {zeros}")The list() constructor is especially useful when you need to convert a generator, a set, a dictionary's keys, or the output of map() and filter() into a concrete list that you can index and manipulate.
Indexing and Negative Indexing
Every item in a list has a position called an index. Python uses zero-based indexing, which means the first element is at index 0, the second is at index 1, and so on. Python also supports negative indexing: -1 refers to the last element, -2 to the second-to-last, and so on. This is incredibly convenient when you need to grab items from the end of a list without knowing its length.
colors = ["red", "orange", "yellow", "green", "blue", "purple"]
# Positive indexing (left to right, starts at 0)
print(colors[0]) # red
print(colors[2]) # yellow
print(colors[5]) # purple
# Negative indexing (right to left, starts at -1)
print(colors[-1]) # purple
print(colors[-2]) # blue
print(colors[-6]) # red
# Modifying an element by index
colors[0] = "crimson"
print(colors) # ['crimson', 'orange', 'yellow', 'green', 'blue', 'purple']
# What happens if you go out of bounds?
# print(colors[10]) # IndexError: list index out of rangeAccessing an index that does not exist raises an IndexError. If you are not sure whether an index is valid, check len(my_list) first or use a try/except block. Negative indexing follows the same rule: colors[-7] on a six-element list will also raise an IndexError.
Slicing: Extracting Sublists
Slicing lets you extract a portion of a list using the syntax list[start:stop:step]. The start index is inclusive, the stop index is exclusive, and step controls how many items to skip. All three are optional. Slicing never raises an IndexError — it gracefully returns as many items as it can, even if you overshoot the boundaries.
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Basic slicing
print(nums[2:5]) # [2, 3, 4] (index 2 up to, not including, 5)
print(nums[:4]) # [0, 1, 2, 3] (from the beginning)
print(nums[6:]) # [6, 7, 8, 9] (to the end)
print(nums[:]) # [0, 1, ..., 9] (full shallow copy)
# Using step
print(nums[::2]) # [0, 2, 4, 6, 8] (every 2nd element)
print(nums[1::2]) # [1, 3, 5, 7, 9] (every 2nd, starting from index 1)
print(nums[::-1]) # [9, 8, ..., 0] (reversed)
print(nums[7:2:-1]) # [7, 6, 5, 4, 3] (reverse slice)
# Negative indices in slices
print(nums[-3:]) # [7, 8, 9] (last three items)
print(nums[-5:-2]) # [5, 6, 7]
# Slice assignment (replace a section)
letters = ["a", "b", "c", "d", "e"]
letters[1:3] = ["X", "Y", "Z"]
print(letters) # ['a', 'X', 'Y', 'Z', 'd', 'e']
# Delete a section
letters[1:4] = []
print(letters) # ['a', 'd', 'e']Slice assignment is a powerful and often overlooked feature. It lets you replace, insert, or delete entire sections of a list in a single operation. Assigning an empty list to a slice effectively deletes those elements, while assigning a longer or shorter list than the slice expands or shrinks the original list.
"Flat is better than nested." — Tim Peters, The Zen of Python (PEP 20)
Adding Elements
Python gives you several ways to add items to a list, each with a different use case. Knowing which one to reach for — and why — is essential for writing clean, efficient code.
stack = ["foundation"]
# append() - add ONE item to the end (most common, O(1))
stack.append("walls")
stack.append("roof")
print(stack) # ['foundation', 'walls', 'roof']
# insert() - add ONE item at a specific index (O(n))
stack.insert(1, "plumbing")
print(stack) # ['foundation', 'plumbing', 'walls', 'roof']
# extend() - add ALL items from another iterable to the end
extras = ["paint", "furniture"]
stack.extend(extras)
print(stack) # ['foundation', 'plumbing', 'walls', 'roof', 'paint', 'furniture']
# Concatenation with + (creates a NEW list)
part_a = [1, 2, 3]
part_b = [4, 5, 6]
combined = part_a + part_b
print(combined) # [1, 2, 3, 4, 5, 6]
print(part_a) # [1, 2, 3] (unchanged)
# In-place concatenation with +=
part_a += [7, 8]
print(part_a) # [1, 2, 3, 7, 8] (modified in place)A common beginner mistake is using append() when extend() is needed. stack.append([4, 5]) adds the entire list [4, 5] as a single nested element. stack.extend([4, 5]) adds 4 and 5 as separate items. The difference is subtle but critical.
Removing Elements
Python provides multiple approaches for removing items, and each one behaves differently. Choosing the right tool avoids unnecessary work and unexpected errors.
devices = ["router", "switch", "firewall", "server", "switch", "AP"]
# remove() - delete the FIRST occurrence of a value (raises ValueError if missing)
devices.remove("switch")
print(devices) # ['router', 'firewall', 'server', 'switch', 'AP']
# pop() - remove and RETURN the item at an index (default: last item)
last = devices.pop()
print(last) # AP
print(devices) # ['router', 'firewall', 'server', 'switch']
second = devices.pop(1)
print(second) # firewall
# del - remove by index or slice (no return value)
del devices[0]
print(devices) # ['server', 'switch']
# clear() - remove ALL items
devices.clear()
print(devices) # []
# Removing while iterating (safe approach with comprehension)
scores = [85, 42, 91, 38, 77, 55, 29]
passing = [s for s in scores if s >= 50]
print(passing) # [85, 91, 77, 55]Never modify a list while iterating over it with a for loop. Removing items shifts the remaining indices and causes elements to be skipped. Instead, build a new list with a comprehension or iterate over a copy: for item in my_list[:]:.
Searching and Counting
Finding items and gathering information about a list's contents are everyday operations. Python provides both methods on the list object and built-in functions for this purpose.
logs = ["INFO", "WARNING", "ERROR", "INFO", "INFO", "ERROR", "DEBUG"]
# Check membership
print("ERROR" in logs) # True
print("CRITICAL" in logs) # False
print("CRITICAL" not in logs)# True
# Find the index of the first occurrence
print(logs.index("ERROR")) # 2
# logs.index("CRITICAL") # ValueError if not found
# Count occurrences
print(logs.count("INFO")) # 3
print(logs.count("DEBUG")) # 1
# Built-in functions
print(len(logs)) # 7
numbers = [42, 7, 99, 13, 56]
print(min(numbers)) # 7
print(max(numbers)) # 99
print(sum(numbers)) # 217
# any() and all()
results = [True, False, True, True]
print(any(results)) # True (at least one is True)
print(all(results)) # False (not ALL are True)
# Practical: check if any score is failing
scores = [88, 92, 45, 76, 91]
has_failing = any(s < 50 for s in scores)
print(f"Has a failing score: {has_failing}") # TrueSorting and Reversing
Python offers two distinct approaches to sorting: the .sort() method, which sorts the list in place and returns None, and the sorted() built-in function, which returns a new sorted list and leaves the original untouched. Both accept a key parameter for custom sort logic and a reverse parameter to sort in descending order.
# In-place sorting with .sort()
names = ["Charlie", "Alice", "Eve", "Bob", "Diana"]
names.sort()
print(names) # ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve']
names.sort(reverse=True)
print(names) # ['Eve', 'Diana', 'Charlie', 'Bob', 'Alice']
# sorted() returns a NEW list
original = [64, 25, 12, 22, 11]
ascending = sorted(original)
print(ascending) # [11, 12, 22, 25, 64]
print(original) # [64, 25, 12, 22, 11] (unchanged)
# Custom sort with key
words = ["banana", "pie", "strawberry", "fig", "kiwi"]
by_length = sorted(words, key=len)
print(by_length) # ['fig', 'pie', 'kiwi', 'banana', 'strawberry']
# Sort dictionaries in a list by a specific field
students = [
{"name": "Kandi", "gpa": 3.85},
{"name": "Alex", "gpa": 3.92},
{"name": "Sam", "gpa": 3.40},
{"name": "Jordan", "gpa": 3.78}
]
by_gpa = sorted(students, key=lambda s: s["gpa"], reverse=True)
for s in by_gpa:
print(f"{s['name']}: {s['gpa']}")
# Reversing
items = [1, 2, 3, 4, 5]
items.reverse() # In-place: [5, 4, 3, 2, 1]
backwards = items[::-1] # New list via slicing"Premature optimization is the root of all evil." — Donald Knuth, The Art of Computer Programming
Iterating Over Lists
Looping through a list is one of the most frequent operations in Python. There are several patterns depending on whether you need just the values, the indices, or both. Python also provides zip() for iterating over multiple lists in parallel.
cities = ["Atlanta", "Seattle", "Denver", "Miami"]
# Basic iteration
for city in cities:
print(city)
# When you need the index too, use enumerate()
for index, city in enumerate(cities):
print(f"{index}: {city}")
# enumerate() with a custom start
for rank, city in enumerate(cities, start=1):
print(f"#{rank} - {city}")
# Iterating over two lists in parallel with zip()
names = ["Kandi", "Alex", "Sam"]
roles = ["Instructor", "Developer", "Analyst"]
for name, role in zip(names, roles):
print(f"{name} is a {role}")
# zip() with three lists
ids = [101, 102, 103]
for uid, name, role in zip(ids, names, roles):
print(f"[{uid}] {name} - {role}")
# Reversed iteration (without modifying the list)
for city in reversed(cities):
print(city)If you find yourself writing for i in range(len(my_list)): followed by my_list[i], stop and use enumerate() instead. It is more readable, more Pythonic, and less prone to off-by-one errors. Idiomatic Python avoids manual index tracking whenever possible.
List Comprehensions
List comprehensions are one of Python's most powerful and distinctive features. They let you create a new list by applying an expression to each item in an iterable, optionally filtering items with a condition, all in a single concise line. Comprehensions replace entire multi-line loops and are generally faster because they are optimized at the interpreter level.
# Basic comprehension: expression for item in iterable
squares = [x ** 2 for x in range(1, 11)]
print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# With a condition (filter)
evens = [x for x in range(20) if x % 2 == 0]
print(evens) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# Transforming strings
words = ["hello", "world", "python"]
upper = [w.upper() for w in words]
print(upper) # ['HELLO', 'WORLD', 'PYTHON']
# Conditional expression (if-else in the expression)
labels = ["EVEN" if x % 2 == 0 else "ODD" for x in range(1, 8)]
print(labels) # ['ODD', 'EVEN', 'ODD', 'EVEN', 'ODD', 'EVEN', 'ODD']
# Flattening a nested list
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# Practical: extract IPs from log entries
log_entries = [
"2026-02-12 10:00:01 LOGIN 192.168.1.10",
"2026-02-12 10:00:05 LOGIN 10.0.0.25",
"2026-02-12 10:00:09 LOGOUT 192.168.1.10",
"2026-02-12 10:00:12 FAILED 172.16.0.99"
]
ips = [entry.split()[-1] for entry in log_entries]
print(ips) # ['192.168.1.10', '10.0.0.25', '192.168.1.10', '172.16.0.99']
# Get only unique failed-login IPs
failed_ips = list(set(
entry.split()[-1] for entry in log_entries if "FAILED" in entry
))
print(failed_ips) # ['172.16.0.99']"There should be one -- and preferably only one -- obvious way to do it." — Tim Peters, The Zen of Python (PEP 20)
Nested Lists
A list can contain other lists as elements, creating a multi-dimensional structure. The most common use case is a two-dimensional grid or matrix, but you can nest to any depth. You access nested elements by chaining index operators.
# 2D list (matrix)
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Accessing elements
print(matrix[0]) # [1, 2, 3] (first row)
print(matrix[0][2]) # 3 (first row, third column)
print(matrix[2][1]) # 8 (third row, second column)
# Modifying a nested element
matrix[1][1] = 99
print(matrix[1]) # [4, 99, 6]
# Iterating over a 2D list
for row in matrix:
for value in row:
print(f"{value:>4}", end="")
print() # New line after each row
# Building a grid with comprehensions
rows, cols = 3, 4
grid = [[0 for _ in range(cols)] for _ in range(rows)]
print(grid) # [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
# Practical: tic-tac-toe board
board = [[" " for _ in range(3)] for _ in range(3)]
board[0][0] = "X"
board[1][1] = "O"
board[2][0] = "X"
for row in board:
print(" | ".join(row))
print("-" * 9)Never create a 2D grid with [[0] * cols] * rows. The * rows operation creates multiple references to the same inner list, so modifying one row changes all of them. Always use the comprehension pattern: [[0 for _ in range(cols)] for _ in range(rows)].
Copying Lists: The Aliasing Trap
Because lists are mutable, assigning one list to another variable does not create a copy — it creates an alias. Both names point to the exact same object in memory. Modifying the list through one name affects the other. This is one of the most common sources of confusion and bugs for beginners.
# The aliasing problem
original = [1, 2, 3, 4, 5]
alias = original # NOT a copy! Same object.
alias.append(6)
print(original) # [1, 2, 3, 4, 5, 6] (also modified!)
# Three ways to make a SHALLOW copy
copy_a = original[:] # Slice copy
copy_b = original.copy() # .copy() method
copy_c = list(original) # list() constructor
copy_a.append(99)
print(original) # [1, 2, 3, 4, 5, 6] (unaffected)
print(copy_a) # [1, 2, 3, 4, 5, 6, 99]
# SHALLOW copies only go one level deep!
nested = [[1, 2], [3, 4]]
shallow = nested.copy()
shallow[0][0] = 999
print(nested) # [[999, 2], [3, 4]] (inner list WAS affected!)
# DEEP copy for nested structures
import copy
nested = [[1, 2], [3, 4]]
deep = copy.deepcopy(nested)
deep[0][0] = 999
print(nested) # [[1, 2], [3, 4]] (safe!)
print(deep) # [[999, 2], [3, 4]]The rule is straightforward: use a shallow copy (.copy(), slicing, or list()) when your list contains only immutable elements like strings and numbers. Use copy.deepcopy() when your list contains other mutable objects like nested lists or dictionaries. Getting this wrong produces some of the most baffling bugs in Python.
Performance Tips
Lists are built on dynamic arrays under the hood, which gives them excellent performance characteristics for most operations but some important trade-offs to be aware of as your data grows.
# Appending is fast (amortized O(1))
data = []
for i in range(1_000_000):
data.append(i) # Very fast
# Inserting at the beginning is slow (O(n) - shifts all elements)
# data.insert(0, "first") # Avoid this in tight loops
# Use collections.deque for fast operations on both ends
from collections import deque
fast_queue = deque([1, 2, 3])
fast_queue.appendleft(0) # O(1)
fast_queue.append(4) # O(1)
print(list(fast_queue)) # [0, 1, 2, 3, 4]
# Membership testing: list vs. set
big_list = list(range(1_000_000))
big_set = set(big_list)
# 999_999 in big_list # O(n) - scans the entire list
# 999_999 in big_set # O(1) - hash table lookup
# List comprehensions are faster than manual loops
import time
# Slower
start = time.time()
result = []
for i in range(1_000_000):
result.append(i * 2)
loop_time = time.time() - start
# Faster
start = time.time()
result = [i * 2 for i in range(1_000_000)]
comp_time = time.time() - start
print(f"Loop: {loop_time:.3f}s | Comprehension: {comp_time:.3f}s")"Make it work, make it right, make it fast." — Kent Beck
Key Takeaways
- Lists are ordered, mutable, and versatile: They are defined with square brackets and can hold any data type. They are the default collection when you need an ordered sequence of items that may change.
- Master indexing and slicing: Zero-based indexing, negative indexing, and the
[start:stop:step]slice syntax are used everywhere in Python. Slice assignment lets you replace, insert, or delete entire sections in one operation. - Know the right method for the job: Use
append()for single items,extend()for merging iterables,insert()sparingly for positional additions,pop()when you need the removed value, andremove()when you know the value but not the index. - Use enumerate() and zip(): These built-in functions make iteration cleaner and more Pythonic. Avoid manual index tracking with
range(len(...))whenever possible. - List comprehensions are essential Python: They replace verbose loops with a single expressive line, and they run faster. Learn the
[expr for item in iterable if condition]pattern until it becomes second nature. - Understand copying deeply: Assignment creates aliases, not copies. Use
.copy()for flat lists andcopy.deepcopy()for nested structures to avoid aliasing bugs.
Lists are the backbone of Python programming. They are the first data structure beginners learn and the last one experts stop using. Every concept you explore from here — file I/O, APIs, data analysis, web scraping, machine learning — will involve lists in some fundamental way. The time you invest in mastering them now will pay dividends in every Python program you write for the rest of your career.