Why Does Python Keep Appending the Same Value in a Loop?

Many beginners understand that a for loop runs multiple times, but they often wonder why Python sometimes keeps adding the same value to a list.

Consider the following example:

text = "abc"

result = []

for letter in text:
    result.append(text.title())

print(result)

At first glance, it seems that the changing value of letter should affect the result.

However, the output may be surprising.

---

Understanding the Output

The code produces:

['Abc', 'Abc', 'Abc']

The same string appears three times.

Many beginners expect different values because the loop variable changes during each iteration.

---

What Happens During Each Iteration?

Python performs two separate actions during every loop iteration:

1. Assign a value to the loop variable.
2. Execute the code inside the loop body.

For the string:

abc

the loop variable takes these values:

letter = 'a'
letter = 'b'
letter = 'c'

One value at a time.

---

Iteration 1

Python sets:

letter = 'a'

Then executes:

result.append(text.title())

Since:

text.title()

returns:

Abc

the list becomes:

['Abc']

---

Iteration 2

Python sets:

letter = 'b'

Then executes:

result.append(text.title())

Again:

text.title()

returns:

Abc

The list becomes:

['Abc', 'Abc']

---

Iteration 3

Python sets:

letter = 'c'

Then executes:

result.append(text.title())

Again:

text.title()

returns:

Abc

The final list becomes:

['Abc', 'Abc', 'Abc']

---

The Important Observation

Notice that the expression:

text.title()

depends only on:

text

It does not depend on:

letter

Even though Python changes the value of letter during every iteration, the expression being appended remains exactly the same.

---

Visualizing the Situation

Think of the loop like this:

Loop Variable      Expression Result

'a'      ------->     'Abc'
'b'      ------->     'Abc'
'c'      ------->     'Abc'

The input changes, but the expression ignores it.

Therefore the output never changes.

---

Compare with a Useful Loop

Now consider:

text = "abc"

result = []

for letter in text:
    result.append(letter.upper())

print(result)

Output:

['A', 'B', 'C']

Why is this different?

Because the expression now uses the loop variable:

letter.upper()

---

Visualizing the Difference

letter      letter.upper()

'a'    →    'A'
'b'    →    'B'
'c'    →    'C'

As the value of letter changes, the result also changes.

Therefore different values are appended to the list.

---

A Key Programming Principle

A loop determines:

How many times the code executes.

The expression inside the loop determines:

What value is produced during each execution.

These are two separate ideas.

A loop can execute many times while still producing the same value repeatedly.

---

Applying This Idea to List Comprehensions

The list comprehension:

[text.title() for letter in text]

is equivalent to:

result = []

for letter in text:
    result.append(text.title())

Since the expression ignores letter, Python repeatedly appends the same value.

---

Rule of Thumb

Whenever you write:

[expression for variable in collection]

ask yourself:

Does the expression actually depend on the variable?

If not, the same value may be produced repeatedly.

If it does depend on the variable, the output will usually change as the variable changes.

---

Key Takeaway

Many beginners think that a changing loop variable automatically produces different results.

That is not true.

Remember:

• The loop controls how many times the code runs.
• The expression controls what value gets produced.
• If the expression ignores the loop variable, the same value may be repeated.
• If the expression uses the loop variable, the result can change during each iteration.

Understanding this distinction is an important step toward mastering loops and list comprehensions in Python.