Python: Lists and Loops

Python Lists and Loops

python

lists

loops

The file system is organized into a hierarchical structure, starting with the root directory

Author

Isaac Boixaderas

Published

Sunday, June 1, 2025

Modified

Sunday, November 16, 2025

1 Overview

📘 Lists and Loops in Python

Lists in Python are mutable, ordered sequences that can hold elements of different types, support indexing, and allow modifications like adding, removing, and changing items. Loops in Python, such as for and while, are control flow constructs that repeatedly execute a block of code over collections like lists or as long as a condition is met.

2 Lists

Ordered collection.
Enclosed in square brackets and separated by commas.
It is allowed to store elements from multiple types.

# list of integers
my_list = [1, 4, 3, 2, 7]

# list of mixed types
my_mixed_list = [1, 'hello', 3.4, [8, 4, 6], ['a']]

3 Indexing and slicing

Indexing and slicing works like in strings.

From: https://favtutor.com/blogs/get-list-index-python

my_list = [1, 4, 3, 2, 7]

print(my_list[0])
print(my_list[-1])
print(my_list[1:4])
print(my_list[::2])

1
7
[4, 3, 2]
[1, 3, 7]

4 Operations

Like strings as well, with + for concatenation and * for repetition.

my_list = [1, 2, 3]

# The + operator concatenates lists
print(my_list + [8, 9, 10])

[1, 2, 3, 8, 9, 10]

# The * operator repeats lists
print(my_list * 3)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

4.1 Empty

Check if a list is empty with len, not, and [].

# Using `len()`

my_list = []

if len(my_list) == 0:
    print("The list is empty.")
else:
    print("The list contains elements.")

The list is empty.

# Using `not`

a = []

if not a:
    print("The list is empty.")
else:
    print("The list contains elements.")

The list is empty.

# Using empty list

my_list = []

if my_list == []:
    print("The list is empty.")
else:
    print("The list contains elements.")

The list is empty.

5 Updating

Lists are mutable (unlike strings)!

my_list = [1, 2, 3]

# Set the first element to 8
my_list[0] = 8
print(my_list)

[8, 2, 3]

my_list = [1, 2, 3]

# Set indices 1 to 3 (not included) to 9 and 10
my_list[1:3] = [9, 10]
print(my_list)

[1, 9, 10]

6 Adding elements

We can add elements to a list using:

append(): Adds an element to the end of the list.

my_list = [1, 2, 3]

# The list grows as we append elements
my_list.append(4)
print(my_list)

[1, 2, 3, 4]

my_list.append(5)
print(my_list)

[1, 2, 3, 4, 5]

extend(): Adds multiple elements to the end of the list.

my_list = [1, 2, 3]

# The list grows as we extend it with another list
my_list.extend([7, 8, 9])
print(my_list)

[1, 2, 3, 7, 8, 9]

insert(): Adds an element at a specific index.

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Insert element 10 at index 5 
my_list.insert(5, 10)
print(my_list)

[1, 2, 3, 4, 5, 10, 6, 7, 8, 9]

7 Removing elements

To remove elements from a list:

remove(): Deletes the first occurrence of a specified element.

my_list = [1, 2, 'a', 3, 2, 'b']

# Remove the first 2 you find
my_list.remove(2)
print(my_list)

[1, ‘a’, 3, 2, ‘b’]

It crashes if there is no equal element…

my_list = [1, 2, 'a', 3, 2, 'b']

# Remove non-existing element
my_list.remove(8)
print(my_list)

ValueError: list.remove(x): x not in list

pop(): Removes an element at a given index.

my_list = [1, 2, 'a', 3, 2, 'b']

# Remove the element at index 1
my_list.pop(1)
print(my_list)

[1, ‘a’, 3, 2, ‘b’]

If the index is not specified, it deletes the last element.

my_list = [1, 2, 'a', 3, 2, 'b']

# Remove the last element
my_list.pop()
print(my_list)

[1, 2, ‘a’, 3, 2]

The removed element is returned.
We can optionally store it in a variable.

my_list = [1, 2, 'a', 3, 2, 'b']

# The removed element is returned.
# Previously we did not use them, but they were returned as well
returned_element = my_list.pop()
print(returned_element)
print(my_list)

‘b’
[1, 2, ‘a’, 3, 2]

- `del`: Keyword that removes elements based on their index or a slice.
my_list = [1, 2, 'a', 3, 2, 'b']
# Remove the element in the given index, it is not returned
del my_list[2]
print(my_list)

[1, 2, 3, 2, ‘b’]

7.1 When to use each?

remove(): When you only want to remove the first occurrence of an element.
pop(): When you want to remove by index and preserve the value in a variable.
- Also comfortable when you want to remove the last element.
  - del: When you want to remove by index. It is a bit more efficient than pop().
- You could also use pop() without storing the returned value though…

8 Other list methods

Some of the most common are:

index(): Returns the index of the first occurrence of a specified element in the list.

my_list = [1, 2, 2, 2, 3, 4, 2, 5]

print(f'The index of the number 5 is: {my_list.index(5)}.')
print(f'The index of the first occurrence of 2 is: {my_list.index(2)}.')

The index of the number 5 is: 7.
The index of the first occurrence of 2 is: 1.

count(): Counts the number of occurrences of a specified element in the list.
```
my_list = [1, 2, 2, 2, 3, 4, 2, 5]
```

print(f’The number 2 appears {my_list.count(2)} times.’)

<div class="output">The number 2 appears 4 times.</div>

***

- `sort()`: Sorts the elements of the list in-place (modifies the original list).
<!-- - `reverse()`: Reverses the elements of the list in-place (modifies the original list).
- `copy()`: Returns a copy of the list. -->

```python
my_list = [1, 2, 2, 2, 3, 4, 2, 5]

my_list.sort()
print(my_list)

[1, 2, 2, 2, 2, 3, 4, 5]

Extensive explanation of list methods: https://docs.python.org/3/tutorial/datastructures.html.

9 Built-in functions

Some of the most common general built-in functions for lists are:

len(): Returns the number of elements in a list.
sum(): Returns the sum of all elements in a list (for numeric lists).
max(): Returns the maximum value in a list.
min(): Returns the minimum value in a list.
sorted(): Returns a sorted list (does not modify the original list).

my_list = [1, 4, 2, 7, 3]

print(f'The length of the list is: {len(my_list)}.')
print(f'The sum of all the elements is: {sum(my_list)}.')
print(f'The maximum element is: {max(my_list)}.')

# Unlike the `sort()` method,
# `sorted()` returns another list without modifying the original one
print(f'The list sorted in ascending order is: {sorted(my_list)}.')

The length of the list is: 5.
The sum of all the elements is: 17.
The maximum element is: 7.
The list sorted in ascending order is: [1, 2, 3, 4, 7].

What is printed?

a = [1, 2, 3]
b = a
b[0] = 8

print('a =', a)
print('b =', b)

When setting a list as equal to another, both variables affect the same list.

a = [1, 2, 3]
b = a
b[0] = 8

# `a` and `b` are the same list
# If we change `b`, then `a` changes as well
print('a =', a)
print('b =', b)

a = [8, 2, 3]
b = [8, 2, 3]

If we want independent lists we can use the copy() method:

a = [1, 2, 3]
# Make a copy of `a` and assign it to `b`
b = a.copy()
b[0] = 8

# If we change `b`, then `a` does not change
print('a =', a)
print('b =', b)

a = [1, 2, 3]
b = [8, 2, 3]

10 `in` Keyword

Can be used for checking if a specific value is inside the sequence.
It also has a special usage in “for loops” (next slides).

fruits = ['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon']

print('apple' in fruits)

True

print('pear' in fruits)

False

11 Loops

Essential in programming.
They allow us to execute a block of code repeatedly.
Python supports two types: for and while loops.

11.1 `for`

Iterate over a sequence, such as a list or a string.

Syntax:

for [variable_name] in [iterable_sequence]:
  code block

11.2 List iteration example

my_list = [1, 2, 3]

for element in my_list:
    # This goes over each element in the list,
    # executing this code block for each one
    print(element)

1
2
3

Commonly used built-in functions for for loops:

enumerate(): Gives back two variables: the count of the current iteration and the value of the item at the current iteration.

# With the enumerate function we get the:
#       index (iteration count)
#       value of each element

my_list = [3, 2, 1]

for index, value in enumerate(my_list):
    print(f'The element at index {index} is {value}.')

The element at index 0 is 3.
The element at index 1 is 2.
The element at index 2 is 1.

range(): Sequence of numbers. By default, starts from 0 and increments by 1. Stops before a specified number.

# It starts at 0 (default) and ends at 4 (not included)
for i in range(4):
    print(i)

0
1
2
3

# Starts at 2 and ends at 6 (not included)
for i in range(2, 6):
    print(i)

2
3
4
5

# Starts at 0 and ends at 10 (not included), in increments of 2
for i in range(0, 10, 2):
    print(i)

0
2
4
6
8

11.3 String iteration example

my_list = "Hello"

for character in my_list:
    # This goes over each character in the string
    print(character)

H
e
l
l
o

11.4 While

Executes an iteration if condition remains True.
Syntax:
```
while [condition]:
  code block
```

count = 0
while count < 4:
    print(f'{count} is less than 4.')
    count += 1

print(f'The loop ended because {count} is greater or equal to 4.')

0 is less than 4.
1 is less than 4.
2 is less than 4.
3 is less than 4.
The loop ended because 4 is greater or equal to 4.

We can chain as many conditions as we want:

count = 0
while count < 4 and count * 3 < 8:
    print(f'{count} is less than 4 and {count * 3} is less than 8.')
    count += 1

print(f'{count} is greater or equal to 4 or {count * 3} is greater than 8.')

0 is less than 4 and 0 is less than 8.
1 is less than 4 and 3 is less than 8.
2 is less than 4 and 6 is less than 8.
3 is greater or equal to 4 or 9 is greater than 8.

Take care of infinite loops!
If the specified condition is never met, while will execute forever…
Raising a Python error (maybe after some time!).

# Do not run this
a = 5
while a < 10:
    print('Hi')

Error because of infinite loop

12 Example

Create a list that contains the squares of the first 5 integers.

# Squares of the first 5 integers
squares = []

for x in range(1, 6):
    squares.append(x**2)

print(squares)

[1, 4, 9, 16, 25]

13 List comprehension

List comprehension is a concise way to create a new list by performing an operation on every element of an existing iterable (like a list, tuple, or range). It can also include a condition to filter which items are included. The Syntax:

newlist = [expression for item in iterable if condition == True]

*The return value is a new list, leaving the old list unchanged.

expression: What you want to do with each item (e.g., multiply by 2).
item: The current element from the iterable.
iterable: The list, range, or other object you are looping over.
if condition: (optional) Only include items that meet this condition.

# Squares of the first 5 integers
squares = [x**2 for x in range(1, 6)]
print(squares)

[1, 4, 9, 16, 25]

{pyodide-python numbers = [1, 2, 3, 4] doubled_numbers = [num * 2 for num in numbers] print(doubled_numbers)

[2, 4, 6, 8]

In this example, num * 2 is the expression, num is each item from numbers, and numbers is the iterable.

# With an `if` condition

# Squares of the first 5 even integers
even_squares = [x**2 for x in range(1, 6) if x % 2 == 0]
print(even_squares)

[4, 16]

14 Loop control statements

Allow us to change the flow of loops during execution.

Keywords:

break: Terminates the current loop.
continue: Skips the remaining code in the current iteration and proceeds to the next one.

# `break` example

for num in range(10):
    if num == 5:
        # Break the loop
        break
    print(num)
print('Outside the loop')

0
1
2
3
4
Outside the loop

# `continue` example

for num in range(10):
    if num % 2 == 0:
        # Skip the rest of the code in this iteration,
        # going to the next iteration
        continue
    print(num)
print('Outside the loop')

1
3
5
7
9
Outside the loop

15 Unpacking

Taking the elements of a collection (list, string…) and assigning them to variables.

l = [3, 4]
a, b = l

print(a)
print(b)

3
4

16 Unpacking

Another example with strings.

x, y, z = 'hey'

print(x)
print(y)
print(z)

h
e
y

17 Example

Write a program that finds the common elements between two lists with the same length.
Input:
- list1 = [1, 2, 3, 4, 5]
- list2 = [4, 5, 6, 7, 8]
Output:
- [4, 5]

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = []

for element in list1:
    if element in list2:
        common_elements.append(element)

print(common_elements)

1 Overview

2 Lists

3 Indexing and slicing

4 Operations

4.1 Empty

5 Updating

6 Adding elements

7 Removing elements

7.1 When to use each?

8 Other list methods

9 Built-in functions

10 in Keyword

11 Loops

11.1 for

11.2 List iteration example

11.3 String iteration example

11.4 While

12 Example

13 List comprehension

14 Loop control statements

15 Unpacking

16 Unpacking

17 Example

10 `in` Keyword

11.1 `for`