Sequence Types in Python

When working with data in Python, understanding sequence types is a must. These sequences form the backbone of Python’s data structures and show up in numerous scenarios—whether you’re storing text, managing lists, or handling numerical ranges. In this guide, we’ll explore four core sequence types: strings, lists, tuples, and range objects. By the end of this article, you’ll have a solid foundation on how to work with these data structures efficiently.

What are Sequence Types in Python?

At its core, a sequence in Python is simply an ordered collection of items. The key here is ordered—meaning the position of each item is crucial. Python offers several built-in sequence types, each tailored for specific use cases and possessing unique properties.

Let’s break down the four main types you’ll encounter: strings, lists, tuples, and range objects.

Strings (str)

A string is a sequence of characters enclosed in quotes. Whether you’re managing user input or displaying text, you’ve likely encountered strings many times. Here’s an example:

message = "Hello, Python!"

In this case, "Hello, Python!" is a string—a collection of characters stored as a single unit. Python allows strings to be defined using single quotes ('), double quotes ("), or even triple quotes (''' or """). Triple quotes are handy for multi-line strings or strings that include special characters.

One standout feature of Python strings is their support for Unicode, making it easy to handle text in different languages:

greeting = "こんにちは"
print(greeting)

Another key property of strings is their immutability. Once created, a string cannot be changed directly. Modifications require creating a new string.

We’ll explore string operations and manipulations in more detail in another posts.

Lists (list)

A list is an ordered, mutable collection of items. Unlike strings, lists can store a variety of data types, even within the same list.

Here’s how to create a list in Python:

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

Lists are enclosed in square brackets ([]), with items separated by commas. You can also mix different data types in a single list:

mixed_list = [1, 'hello', 3.14, True]

What sets lists apart is their mutability—you can modify them after creation. For example, to add an element:

fruits.append('orange')

Now, the list fruits contains ['apple', 'banana', 'cherry', 'orange']. This flexibility makes lists incredibly powerful for dynamic data storage, especially when handling diverse types of data.

We’ll cover more list operations like slicing, indexing, and list comprehensions and more in future posts

Tuples (tuple)

A tuple is similar to a list but with one major difference: tuples are immutable. Once a tuple is created, its contents cannot be altered. This makes them ideal for storing fixed collections of data.

Creating a tuple is straightforward:

coordinates = (10, 20)

Tuples use parentheses (()), but Python can infer a tuple if you simply separate items with commas:

person = 'Alice', 25, 'Designer'

Even without parentheses, person is recognized as a tuple. Tuples can store heterogeneous elements, and one powerful feature is tuple unpacking, where you assign each item in a tuple to a variable:

person = 'Alice', 25, 'Designer'

Now, name is 'Alice', age is 25, and job is 'Designer'.

Range Objects (range)

Unlike strings, lists, and tuples, a range object doesn’t store items directly. Instead, it generates a sequence of numbers on demand, making it memory efficient.

You’ll commonly encounter range objects in loops:

for i in range(5):
    print(i)

This prints numbers from 0 to 4. The range() function takes three parameters: start, stop, and step. By default, it starts at 0, stops before the value you provide, and increments by 1. You can customize it as needed:

for i in range(2, 10, 2):
    print(i)

This prints 2, 4, 6, 8.