Python List Operations

In the last lesson you learned Introduction to Lists. So now you know how to put a bunch of values together in one place. But a list is only useful if you can actually do things with it. You need to read one item out. You need to change an item. You need to ask how many items are inside. You need to check if something is even there. That is what list operations are. Let me walk you through the everyday ones, one at a time.

🤔 Why You Need List Operations

Say you have a list of names for a chat group:

friends = ["Alex", "Riya", "Arjun"]

The list just sitting there does nothing. The real work starts when you ask questions of it. Who is the first person? How many people are in the group? Is “Riya” in here? Can I show every name on screen? Each of those is a list operation. They are the small, everyday moves you make on a list. Once you know them, you can build almost anything with lists.

🔢 Read an Item by Index

Every item in a list has a position number. We call that position the index. Here is the part that trips people up. Counting starts at 0, not 1. So the first item is at index 0. The second is at index 1. And so on.

This code reads single items out of the list by their position:

friends = ["Alex", "Riya", "Arjun"]

print(friends[0])
print(friends[1])
print(friends[2])

Alex
Riya
Arjun

So friends[0] gives you “Alex” because Alex sits at position 0. You put the index inside square brackets right after the list name.

Python also lets you count from the end using negative numbers. So -1 means the last item. And -2 means the second to last. This is handy when you do not know how long the list is but you want the last thing.

This code grabs the last item without caring about the length:

friends = ["Alex", "Riya", "Arjun"]

print(friends[-1])
print(friends[-2])

Arjun
Riya

✏️ Change an Item

A list is changeable. That means you can replace an item after you make the list. You point at the position you want. Then you assign a new value to it.

This code swaps the second name for a different one:

friends = ["Alex", "Riya", "Arjun"]
friends[1] = "Sara"

print(friends)

['Alex', 'Sara', 'Arjun']

See what happened? friends[1] used to be “Riya”. We assigned “Sara” to that spot. So now the list holds “Sara” there instead. The list itself stays the same list. It just has one item changed.

📏 Check the Length with len()

Often you need to know how many items are in a list. Maybe you want to show “3 people in this group”. The len() function counts the items for you and gives back a number.

This code asks how many friends are in the list:

friends = ["Alex", "Riya", "Arjun"]
count = len(friends)

print(count)
print(f"There are {count} people in the group.")

3
There are 3 people in the group.

You pass the list to len() and it returns the count as a plain number. One thing worth remembering. The last valid index is always len(list) - 1. The list above has length 3. So the last item sits at index 2. That is because counting started at 0.

➕ Join Lists with +

Sometimes you have two separate lists and you want one combined list. The + operator joins them end to end. This is called concatenation, which just means sticking one list after another.

This code joins a list of close friends and a list of new friends into one:

close_friends = ["Alex", "Riya"]
new_friends = ["Arjun", "Sara"]

everyone = close_friends + new_friends
print(everyone)

['Alex', 'Riya', 'Arjun', 'Sara']

The + makes a brand new list. It holds all the items from the first list followed by all the items from the second. The two original lists stay exactly as they were.

✖️ Repeat with *

The * operator repeats a list a given number of times. This is great when you want a list filled with the same starting value.

This code makes a list of three zeros. Say you want three rounds of a game that all start at score 0:

scores = [0] * 3
print(scores)

dashes = ["-"] * 5
print(dashes)

[0, 0, 0]
['-', '-', '-', '-', '-']

So [0] * 3 means “take this one-item list and repeat it three times”. You get a fresh list with the contents copied that many times. It saves you from typing the same value over and over.

🔍 Check if a Value Is Inside with in

Before you do something with an item, you often want to know if it is even in the list. The in operator answers that with a simple True or False.

This code checks whether certain names are in the group:

friends = ["Alex", "Riya", "Arjun"]

print("Riya" in friends)
print("Sara" in friends)
print("Sara" not in friends)

True
False
True

So "Riya" in friends is True because Riya really is in the list. "Sara" in friends is False because she is not. You can flip it with not in to ask the opposite question. This is perfect inside an if statement. For example, you only add someone if they are not already there.

🔁 Loop Over a List

Most of the time you do not want just one item. You want to go through every item and do something with each. A for loop walks through the list one item at a time, from first to last.

This code prints a greeting for every friend in the list:

friends = ["Alex", "Riya", "Arjun"]

for name in friends:
    print(f"Hello, {name}!")

Hello, Alex!
Hello, Riya!
Hello, Arjun!

Read it almost like English. “For each name in friends, print a greeting.” On the first turn name is “Alex”. Then “Riya”. Then “Arjun”. The loop stops on its own when the list runs out. You do not deal with index numbers at all here. That is why this is the cleanest way to visit every item.

If you also need the position number while you loop, enumerate() gives you both the index and the item together:

friends = ["Alex", "Riya", "Arjun"]

for position, name in enumerate(friends):
    print(f"{position}: {name}")

0: Alex
1: Riya
2: Arjun

Here enumerate() hands you the index in position and the value in name on each turn. Use this when the position actually matters, like numbering a list on screen.

⚠️ Common Mistakes

A few things tend to bite people early. Watch for these.

• Forgetting that counting starts at 0. The first item is friends[0], not friends[1].

friends = ["Alex", "Riya", "Arjun"]

# ❌ Avoid: thinking index 1 is the first item
print(friends[1])  # prints "Riya", not "Alex"

# ✅ Good: index 0 is the first item
print(friends[0])  # prints "Alex"

• Asking for an index that is past the end. A three-item list only has indexes 0, 1, and 2. Asking for friends[3] raises an IndexError.

• Mixing up len() and the last index. len(friends) is 3, but the last item is at index 2. The last index is always len(list) - 1.

• Thinking + adds the lists item by item. It does not. With lists, + joins them end to end. [1, 2] + [3, 4] gives [1, 2, 3, 4], not [4, 6].

✅ Best Practices

Small habits that keep your list code clean and clear.

• Loop with for item in list when you just need each value. Reach for enumerate() only when you actually need the position too.
• Use in to check before you act, so you do not assume an item is there when it is not.
• Reach for len() instead of counting items by hand. It is always right, even when the list grows or shrinks.
• Give your list a clear plural name like friends or scores, so for name in friends reads naturally.

🧩 What You’ve Learned

✅ Read any item by its index, where counting starts at 0 and negative numbers count from the end.

✅ Change an item by assigning a new value to its position.

✅ Count items with len(), and remember the last index is len(list) - 1.

✅ Join two lists with + and repeat a list with *.

✅ Check if a value is present with in (and not in for the opposite).

✅ Visit every item with a for loop, and use enumerate() when you also need the position.

🚀 What’s Next?

You can now do the everyday moves on a list. Next you will meet the built-in tools that lists carry with them, like adding, removing, and sorting items.

List Methods