Iterating Through Data Structures Python

Updated: at 03:01 AM

Python provides a variety of built-in data structures that are used to store and organize data in different ways, including lists, tuples, sets, and dictionaries. Learning how to iterate through these data structures is an essential skill for working with data in Python. This comprehensive guide will explain how to loop through and access elements in each of Python’s major data structures using clear examples.

Table of Contents

Open Table of Contents

Overview of Data Structures in Python

Before diving into how to iterate through data structures, let’s briefly review the main data structures available in Python:

Lists

A list is an ordered collection of elements enclosed in square brackets []. Lists can contain elements of different data types including integers, strings, and other objects. Lists are mutable, meaning the elements can be changed after creation.

fruits = ["apple", "banana", "cherry"]

Tuples

A tuple is similar to a list except it is immutable, meaning the elements cannot be changed once created. Tuples use parentheses () instead of square brackets.

colors = ("red", "green", "blue")

Sets

A set is an unordered collection of unique elements. Sets cannot contain duplicate values. Curly braces {} are used to define sets.

vowels = {"a", "e", "i", "o", "u"}

Dictionaries

A dictionary consists of key-value pairs enclosed in curly braces {}. The keys are used to access the associated values. Dictionaries are mutable but keys must be unique.

employee = {"name": "John Doe", "id": 12345, "dept": "Sales"}

Now let’s look at how to iterate through each data structure in Python.

Iterating Through Lists

Lists can be looped through using a for loop. The loop variable will be assigned to each element in the list sequentially.

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

# Output:
# apple
# banana
# cherry

We can also access the index position of each element within the loop using enumerate():

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

# Output:
# 0 apple
# 1 banana
# 2 cherry

To loop through a list in reverse order, we can combine range() and len():

fruits = ["apple", "banana", "cherry"]

for i in range(len(fruits) - 1, -1, -1):
  print(fruits[i])

# Output:
# cherry
# banana
# apple

Iterating Through Tuples

The process of iterating through tuples is identical to lists since tuples are also a sequenced data structure.

colors = ("red", "green", "blue")

for color in colors:
  print(color)

# Output:
# red
# green
# blue

To access the index, use enumerate():

colors = ("red", "green", "blue")

for index, color in enumerate(colors):
  print(index, color)

# Output:
# 0 red
# 1 green
# 2 blue

And reverse order:

colors = ("red", "green", "blue")

for i in range(len(colors) - 1, -1, -1):
  print(colors[i])

# Output:
# blue
# green
# red

Iterating Through Sets

Since sets are unordered, elements will appear in a random order when looping.

vowels = {"a", "e", "i", "o", "u"}

for vowel in vowels:
  print(vowel)

# Output (in random order):
# u
# a
# i
# e
# o

We cannot access elements by index since sets do not have an ordered sequence. But enumerate() can still be used to obtain an index counting up from 0:

vowels = {"a", "e", "i", "o", "u"}

for index, vowel in enumerate(vowels):
  print(index, vowel)

# Output (in random order):
# 0 u
# 1 a
# 2 i
# 3 e
# 4 o

Iterating Through Dictionaries

To loop through a dictionary, we can iterate through the keys by default:

employee = {"name": "John Doe", "id": 12345, "dept": "Sales"}

for key in employee:
  print(key)

# Output:
# name
# id
# dept

To access both keys and values, use .items():

employee = {"name": "John Doe", "id": 12345, "dept": "Sales"}

for key, value in employee.items():
  print(key, value)

# Output:
# name John Doe
# id 12345
# dept Sales

We can also loop through just the values:

employee = {"name": "John Doe", "id": 12345, "dept": "Sales"}

for value in employee.values():
  print(value)

# Output:
# John Doe
# 12345
# Sales

And to access indexes, use enumerate() on .items():

employee = {"name": "John Doe", "id": 12345, "dept": "Sales"}

for index, (key, value) in enumerate(employee.items()):
  print(index, key, value)

# Output:
# 0 name John Doe
# 1 id 12345
# 2 dept Sales

Benefits of Iterating Through Data Structures

Things to Avoid

Iterating Multiple Data Structures

Python allows iterating through multiple data structures at once very cleanly.

Zipping lists together:

names = ["John", "James", "Mary"]
ages = [25, 47, 31]

for name, age in zip(names, ages):
  print(name, age)

# Output:
# John 25
# James 47
# Mary 31

Zipping also works on other data structures like tuples and sets:

colors = ("red", "green", "blue")
codes = {101, 201, 301}

for color, code in zip(colors, codes):
  print(color, code)

# Output:
# red 101
# green 201
# blue 301

Dictionary keys and values:

employee = {"name": "Mary", "id": 4581, "dept": "HR"}

for key, value in employee.items():
  print(key, value)

# Output:
# name Mary
# id 4581
# dept HR

Conclusion

Following Python’s best practices for iteration enables cleaner code and easier access to data elements. Mastering these iteration techniques provides a critical skill for harnessing the power of Python’s data structures.