Python Lists, Tuples, and Sets

Click to share! ⬇️

Welcome to this comprehensive tutorial on Python Lists, Tuples, and Sets! Python is a versatile and powerful programming language, and one of its many strengths is its built-in data structures. These data structures allow you to organize, store, and manipulate data efficiently. In this tutorial, we will focus on three of the most commonly used data structures in Python: lists, tuples, and sets.

How To Create and Modify Python Lists
How To Perform Common List Operations
How To Use List Comprehensions and Slicing
How To Create and Manipulate Python Tuples
How To Perform Common Tuple Operations
How To Create and Modify Python Sets
How To Perform Common Set Operations
How To Use Set Methods for Set Manipulation
When To Use a List vs Tuple vs Set

Lists, tuples, and sets are all collection data types, and each has its own unique properties and use cases. Understanding when and how to use these data structures is crucial for any Python programmer, whether you’re just starting out or are a seasoned developer.

By the end of this tutorial, you will have a solid understanding of how to work with lists, tuples, and sets in Python. You’ll also be equipped with the knowledge to choose the most appropriate data structure for your specific programming tasks. Let’s get started!

How To Create and Modify Python Lists

Python lists are ordered, mutable, and can store multiple items of different data types. This flexibility makes them one of the most widely used data structures in Python. In this section, we will learn how to create, modify, and work with lists in Python.

1. Creating a List

You can create a list using square brackets [], with items separated by commas:

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

You can also create an empty list:

empty_list = []

2. Accessing List Elements

To access elements in a list, use the index of the item in square brackets. Keep in mind that indices in Python are zero-based:

my_list = ['apple', 'banana', 'cherry']
print(my_list[0])  # Output: 'apple'

3. Modifying List Elements

Lists are mutable, which means you can change their elements. To modify an element, assign a new value to its index:

my_list = ['apple', 'banana', 'cherry']
my_list[1] = 'blueberry'
print(my_list)  # Output: ['apple', 'blueberry', 'cherry']

4. Adding Elements to a List

You can add elements to a list using the append() method or the extend() method:

my_list = ['apple', 'banana', 'cherry']
my_list.append('orange')  # Adds 'orange' to the end of the list
print(my_list)  # Output: ['apple', 'banana', 'cherry', 'orange']

my_list.extend(['grape', 'kiwi'])  # Adds multiple items to the end of the list
print(my_list)  # Output: ['apple', 'banana', 'cherry', 'orange', 'grape', 'kiwi']

5. Removing Elements from a List

You can remove elements from a list using the remove() method, pop() method, or the del keyword:

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

my_list.remove('banana')  # Removes the first occurrence of 'banana'
print(my_list)  # Output: ['apple', 'cherry']

my_list.pop()  # Removes and returns the last item in the list
print(my_list)  # Output: ['apple']

del my_list[0]  # Deletes the item at index 0
print(my_list)  # Output: []

These are the basics of creating and modifying Python lists. In the next sections, we’ll dive deeper into common list operations, list comprehensions, and slicing techniques.

How To Perform Common List Operations

In this section, we will explore some common list operations that can help you manage and manipulate lists more efficiently.

1. List Length

To find the length of a list, use the len() function:

my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # Output: 5

2. List Concatenation

You can concatenate two lists using the + operator:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list)  # Output: [1, 2, 3, 4, 5, 6]

3. List Repetition

You can repeat the elements of a list using the * operator:

my_list = [1, 2, 3]
repeated_list = my_list * 3
print(repeated_list)  # Output: [1, 2, 3, 1, 2, 3, 1, 2, 3]

4. Checking if an Item is in a List

To check if an item is present in a list, use the in keyword:

my_list = ['apple', 'banana', 'cherry']
print('banana' in my_list)  # Output: True
print('orange' in my_list)  # Output: False

5. List Slicing

You can extract a portion of a list using slicing. List slicing has the following syntax:

list[start:stop:step]

Here’s an example:

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
slice1 = my_list[1:5]  # Slices from index 1 (inclusive) to index 5 (exclusive)
print(slice1)  # Output: [1, 2, 3, 4]

slice2 = my_list[1:8:2]  # Slices from index 1 to index 8 with a step of 2
print(slice2)  # Output: [1, 3, 5, 7]

6. List Sorting

You can sort a list using the sorted() function or the sort() method:

my_list = [5, 2, 8, 1, 6]

sorted_list = sorted(my_list)  # Creates a new sorted list, leaving the original list unchanged
print(sorted_list)  # Output: [1, 2, 5, 6, 8]
print(my_list)  # Output: [5, 2, 8, 1, 6]

my_list.sort()  # Sorts the original list in-place
print(my_list)  # Output: [1, 2, 5, 6, 8]

7. List Reversing

You can reverse a list using the reverse() method:

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  # Output: [5, 4, 3, 2, 1]

These common list operations will help you work with lists more effectively in Python. In the next section, we will discuss list comprehensions and advanced slicing techniques.

How To Use List Comprehensions and Slicing

List comprehensions and advanced slicing techniques can make your code more concise and efficient. In this section, we’ll explore how to use these powerful features in Python.

1. List Comprehensions

List comprehensions are a concise way to create a new list by applying an expression to each item in an existing list or other iterable object. The resulting list comprehension consists of the output of the expression for each item.

Here’s the syntax for list comprehensions:

[expression for item in iterable if condition]

Here’s an example:

numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares)  # Output: [1, 4, 9, 16, 25]

You can also include an optional condition:

even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares)  # Output: [4, 16]

2. Advanced List Slicing

In the previous section, we introduced basic list slicing. Now, let’s explore some advanced slicing techniques:

Omitting the start and stop values:

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
slice1 = my_list[::2]  # Selects every second item from the list
print(slice1)  # Output: [0, 2, 4, 6, 8]

Using negative values for start, stop, or step:

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
slice2 = my_list[-3:]  # Selects the last three items from the list
print(slice2)  # Output: [7, 8, 9]

slice3 = my_list[::-1]  # Reverses the list
print(slice3)  # Output: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

3. Nested List Comprehensions

You can use nested list comprehensions to create multi-dimensional lists. For example, you can create a matrix (a list of lists) using a nested list comprehension:

matrix = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(matrix)  # Output: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

List comprehensions and advanced slicing techniques are powerful tools for working with lists in Python. They allow you to write more concise and efficient code, making your programs easier to read and maintain. By incorporating these techniques into your projects, you’ll be able to create and manipulate lists more effectively.

How To Create and Manipulate Python Tuples

Tuples are similar to lists in Python, but with some key differences. Like lists, tuples can store multiple items of different data types. However, tuples are immutable, which means their elements cannot be changed once they are created. Tuples are useful when you want to store a collection of items that should not be modified. In this section, we will learn how to create and manipulate tuples in Python.

1. Creating a Tuple

You can create a tuple using parentheses () with items separated by commas:

my_tuple = (1, 2, 3, 4, 5)

You can also create a tuple without parentheses, using just commas:

my_tuple = 1, 2, 3, 4, 5

To create a tuple with a single item, include a trailing comma:

single_item_tuple = (1,)

2. Accessing Tuple Elements

To access elements in a tuple, use the index of the item in square brackets. Keep in mind that indices in Python are zero-based:

my_tuple = ('apple', 'banana', 'cherry')
print(my_tuple[0])  # Output: 'apple'

3. Tuple Unpacking

You can assign the elements of a tuple to separate variables using tuple unpacking:

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)  # Output: 1 2 3

4. Concatenating Tuples

You can concatenate two tuples using the + operator:

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # Output: (1, 2, 3, 4, 5, 6)

5. Repeating Tuples

You can repeat the elements of a tuple using the * operator:

my_tuple = (1, 2, 3)
repeated_tuple = my_tuple * 3
print(repeated_tuple)  # Output: (1, 2, 3, 1, 2, 3, 1, 2, 3)

6. Tuple Length

To find the length of a tuple, use the len() function:

my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple))  # Output: 5

7. Checking if an Item is in a Tuple

To check if an item is present in a tuple, use the in keyword:

my_tuple = ('apple', 'banana', 'cherry')
print('banana' in my_tuple)  # Output: True
print('orange' in my_tuple)  # Output: False

Since tuples are immutable, you cannot modify their elements or change their size. However, you can use the above operations to work with tuples and create new tuples as needed.

How To Perform Common Tuple Operations

While tuples are immutable, there are still a few common operations that can help you work with them effectively. In this section, we’ll explore these operations.

1. Counting Occurrences of an Item

To count the occurrences of an item in a tuple, use the count() method:

my_tuple = (1, 2, 3, 2, 4, 2, 5)
count_of_twos = my_tuple.count(2)
print(count_of_twos)  # Output: 3

2. Finding the Index of an Item

To find the index of the first occurrence of an item in a tuple, use the index() method:

my_tuple = ('apple', 'banana', 'cherry', 'banana')
index_of_banana = my_tuple.index('banana')
print(index_of_banana)  # Output: 1

3. Tuple Slicing

Like lists, you can extract a portion of a tuple using slicing. Tuple slicing has the same syntax as list slicing:

tuple[start:stop:step]

Here’s an example:

my_tuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
slice1 = my_tuple[1:5]  # Slices from index 1 (inclusive) to index 5 (exclusive)
print(slice1)  # Output: (1, 2, 3, 4)

slice2 = my_tuple[1:8:2]  # Slices from index 1 to index 8 with a step of 2
print(slice2)  # Output: (1, 3, 5, 7)

4. Sorting a Tuple

Since tuples are immutable, you cannot sort a tuple in-place. However, you can create a new sorted tuple using the sorted() function:

my_tuple = (5, 2, 8, 1, 6)
sorted_tuple = tuple(sorted(my_tuple))  # Creates a new sorted tuple
print(sorted_tuple)  # Output: (1, 2, 5, 6, 8)

5. Iterating Over a Tuple

You can use a for loop to iterate over the elements of a tuple:

my_tuple = ('apple', 'banana', 'cherry')
for item in my_tuple:
    print(item)

These common tuple operations will help you work with tuples more effectively in Python. Although tuples are less flexible than lists due to their immutability, they are useful when you need a fixed-size, ordered collection of items that should not be modified.

How To Create and Modify Python Sets

In Python, sets are unordered collections of unique items. Sets are mutable, which means you can add and remove items, but the items themselves must be immutable, such as strings, numbers, or tuples. Sets are useful for performing operations like union, intersection, and difference on collections. In this section, we’ll learn how to create and modify Python sets.

1. Creating a Set

You can create a set using curly braces {} with items separated by commas:

my_set = {1, 2, 3, 4, 5}

To create an empty set, use the set() function. Note that using empty curly braces {} will create an empty dictionary, not an empty set.

empty_set = set()

You can also create a set from a list or other iterable using the set() function:

my_list = [1, 2, 2, 3, 4, 4, 5]
my_set = set(my_list)
print(my_set)  # Output: {1, 2, 3, 4, 5}

2. Adding an Item to a Set

To add a single item to a set, use the add() method:

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Output: {1, 2, 3, 4}

3. Removing an Item from a Set

To remove an item from a set, use the remove() method:

my_set = {1, 2, 3, 4}
my_set.remove(4)
print(my_set)  # Output: {1, 2, 3}

If you try to remove an item that is not in the set, the remove() method will raise a KeyError. To avoid this, you can use the discard() method, which does not raise an error if the item is not found.

my_set = {1, 2, 3}
my_set.discard(4)  # Does not raise an error
print(my_set)  # Output: {1, 2, 3}

4. Clearing a Set

To remove all items from a set, use the clear() method:

my_set = {1, 2, 3, 4, 5}
my_set.clear()
print(my_set)  # Output: set()

5. Set Length

To find the length of a set, use the len() function:

my_set = {1, 2, 3, 4, 5}
print(len(my_set))  # Output: 5

6. Checking if an Item is in a Set

To check if an item is present in a set, use the in keyword:

my_set = {1, 2, 3, 4, 5}
print(3 in my_set)  # Output: True
print(6 in my_set)  # Output: False

These operations will help you create and modify sets in Python. In the next section, we’ll discuss set operations like union, intersection, and difference that can be performed on sets to manipulate them further.

How To Perform Common Set Operations

Python sets offer a variety of operations that can be performed on them, including union, intersection, difference, and symmetric difference. In this section, we’ll explore these common set operations.

1. Union

Union combines the elements of two sets into a new set. You can perform a union using the union() method or the | operator.

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)
print(union_set)  # Output: {1, 2, 3, 4, 5}

# Alternatively, using the | operator
union_set = set1 | set2
print(union_set)  # Output: {1, 2, 3, 4, 5}

2. Intersection

Intersection returns a new set containing the elements that are common to both input sets. You can perform an intersection using the intersection() method or the & operator.

set1 = {1, 2, 3}
set2 = {3, 4, 5}

intersection_set = set1.intersection(set2)
print(intersection_set)  # Output: {3}

# Alternatively, using the & operator
intersection_set = set1 & set2
print(intersection_set)  # Output: {3}

3. Difference

Difference returns a new set containing the elements that are in the first set but not in the second set. You can perform a difference using the difference() method or the - operator.

set1 = {1, 2, 3}
set2 = {3, 4, 5}

difference_set = set1.difference(set2)
print(difference_set)  # Output: {1, 2}

# Alternatively, using the - operator
difference_set = set1 - set2
print(difference_set)  # Output: {1, 2}

4. Symmetric Difference

Symmetric difference returns a new set containing the elements that are unique to each input set (i.e., elements that are not in the intersection). You can perform a symmetric difference using the symmetric_difference() method or the ^ operator.

set1 = {1, 2, 3}
set2 = {3, 4, 5}

symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set)  # Output: {1, 2, 4, 5}

# Alternatively, using the ^ operator
symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)  # Output: {1, 2, 4, 5}

5. Iterating Over a Set

You can use a for loop to iterate over the elements of a set:

my_set = {1, 2, 3, 4, 5}
for item in my_set:
    print(item)

Keep in mind that sets are unordered, so the elements may not be printed in any specific order.

These common set operations can help you work with sets more effectively in Python. Sets are useful for performing operations on collections of unique elements, making them a valuable data structure for a variety of tasks.

How To Use Set Methods for Set Manipulation

Python sets provide various methods for manipulating and performing operations on sets. In this section, we’ll explore some of these set methods for set manipulation.

1. add(element)

Add an element to the set. If the element already exists, the set remains unchanged.

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Output: {1, 2, 3, 4}

2. update(iterable)

Update the set by adding elements from an iterable (e.g., list, tuple, another set).

my_set = {1, 2, 3}
my_set.update([3, 4, 5])
print(my_set)  # Output: {1, 2, 3, 4, 5}

3. remove(element)

Remove the specified element from the set. If the element is not found, a KeyError is raised.

my_set = {1, 2, 3, 4}
my_set.remove(4)
print(my_set)  # Output: {1, 2, 3}

4. discard(element)

Remove the specified element from the set if it is present, otherwise do nothing.

my_set = {1, 2, 3}
my_set.discard(4)  # Does not raise an error
print(my_set)  # Output: {1, 2, 3}

5. pop()

Remove and return an arbitrary element from the set. If the set is empty, a KeyError is raised.

my_set = {1, 2, 3, 4, 5}
removed_element = my_set.pop()
print(removed_element)
print(my_set)

6. clear()

Remove all elements from the set.

my_set = {1, 2, 3, 4, 5}
my_set.clear()
print(my_set)  # Output: set()

7. issubset(other_set)

Check if the set is a subset of another set (i.e., all elements of the set are in the other set).

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
print(set1.issubset(set2))  # Output: True

8. issuperset(other_set)

Check if the set is a superset of another set (i.e., all elements of the other set are in the set).

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
print(set2.issuperset(set1))  # Output: True

9. isdisjoint(other_set)

Check if the set has no elements in common with another set.

set1 = {1, 2, 3}
set2 = {4, 5, 6}
print(set1.isdisjoint(set2))  # Output: True

These set methods allow you to manipulate and perform operations on sets effectively in Python. Remember that sets are unordered and store unique elements, making them useful for various tasks that involve collections of unique items.

When To Use a List vs Tuple vs Set

Each of these three Python data structures – list, tuple, and set – have their own unique characteristics and use cases. Deciding which one to use depends on your specific needs and requirements. Here’s an overview of when to use a list, tuple, or set:

1. List

Use a list when:

You need an ordered collection of items.
The collection can contain duplicate items.
The collection can be modified, resized, or reordered (i.e., you need a mutable data structure).
You want to use list comprehensions or other advanced list manipulation techniques.

Common use cases for lists include storing sequences of data, implementing stacks or queues, and working with data that needs to be easily modified or extended.

2. Tuple

Use a tuple when:

You need an ordered collection of items.
The collection can contain duplicate items.
The collection should not be modified after creation (i.e., you need an immutable data structure).
You want to use the tuple as a key in a dictionary or as an item in a set.

Common use cases for tuples include storing fixed-size, ordered collections of items that should not be changed, representing a point in a coordinate system, or storing multiple values that are related in some way (e.g., date components like year, month, and day).

3. Set

Use a set when:

You need an unordered collection of unique items.
The collection must not contain duplicate items.
You need to perform set operations like union, intersection, difference, or symmetric difference.
You want a mutable collection but don’t care about the order of items.

Common use cases for sets include storing unique values, performing mathematical set operations, and efficiently checking for membership of an item in a collection.

In summary, use lists when you need a mutable, ordered collection of items (possibly with duplicates); use tuples when you need an immutable, ordered collection of items (possibly with duplicates); and use sets when you need a mutable, unordered collection of unique items. Consider the specific requirements of your task and choose the most appropriate data structure accordingly.

Python Lists, Tuples, and Sets – vegibit (vegibit.com)
5. Data Structures — Python 3.11.3 documentation (docs.python.org)
Python Lists, Tuples, and Sets: What’s the Difference? (learnpython.com)
15 Examples to Master Python Lists vs Sets vs Tuples (towardsdatascience.com)
Beginner to python: Lists, Tuples, Dictionaries, Sets (stackoverflow.com)
Python Lists and Tuples – Python Cheatsheet (www.pythoncheatsheet.org)
Tuples vs. Lists vs. Sets in Python – Jerry Ng (jerrynsh.com)
Differences and Similarities between Python Lists, Sets and Tuples … (medium.com)
Basic Python: Lists, Tuples, Sets, Dictionaries (www.topcoder.com)
Learn Python: Lists, sets, and tuples – Dev Learning Daily (learningdaily.dev)
Python Data Structures: Lists, Dictionaries, Sets, (www.dataquest.io)
Python Set VS List – Sets and Lists in Python – FreeCodecamp (www.freecodecamp.org)
Python Tutorial for Beginners 4: Lists, Tuples, and Sets (www.youtube.com)
Practise Using Lists, Tuples, Dictionaries, and Sets in Python (thepythoncodingbook.com)
Learn Python: Strings, Lists, Sets, Tuples and Dictionary (velocitybytes.com)

Click to share! ⬇️