Python Data Structures: Sets and Dictionaries

Introduction
Sets
Dictionaries
Conclusion

Introduction

Welcome to the tutorial on Python Data Structures: Sets and Dictionaries. In this tutorial, we will explore two important data structures in Python - Sets and Dictionaries. We will learn about their properties, how to create and manipulate them, and understand their various operations.

By the end of this tutorial, you will have a solid understanding of Sets and Dictionaries in Python and be able to effectively use them in your programs.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Python programming. Familiarity with variables, data types, and control flow will be helpful. Additionally, ensure that Python is installed on your system.

Set up

There is no specific setup required for this tutorial. You can use any Python IDE or a simple text editor along with the Python interpreter to practice the examples.

Sets

Sets are an unordered collection of unique elements. They are defined by enclosing comma-separated values inside curly braces {}. Sets are mutable but cannot contain duplicate values.

Creating a Set

To create a set, you can simply enclose the elements inside curly braces {}. Let’s create a set of fruits: python fruits = {'apple', 'banana', 'orange'} print(fruits) Output: {'apple', 'banana', 'orange'} In the above example, we created a set named fruits containing three elements: ‘apple’, ‘banana’, and ‘orange’.

Adding and Removing Elements

Sets provide several methods to add and remove elements. The add() method allows adding a single element to the set. Here’s an example: python fruits.add('grape') print(fruits) Output: {'apple', 'banana', 'orange', 'grape'} To add multiple elements to a set, you can use the update() method. Let’s add multiple fruits to the set: python fruits.update(['watermelon', 'mango']) print(fruits) Output: {'apple', 'banana', 'orange', 'grape', 'watermelon', 'mango'} To remove an element from the set, you can use the remove() method. Let’s remove ‘banana’ from the fruits set: python fruits.remove('banana') print(fruits) Output: {'apple', 'orange', 'grape', 'watermelon', 'mango'} However, if you try to remove an element that doesn’t exist, a KeyError will be raised. To avoid this, you can use the discard() method, which doesn’t raise an error if the element is not found.

Set Operations

Sets support various set operations that can be performed to obtain useful results. Let’s explore some of the common operations:

Union: The union of two sets contains all the unique elements from both sets. It can be obtained using the union() method or the pipe operator (|).

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

Intersection: The intersection of two sets contains the common elements present in both sets. It can be obtained using the intersection() method or the ampersand operator (&).
```
  set1 = {1, 2, 3}
  set2 = {3, 4, 5}
	
  intersection_set = set1.intersection(set2)
  print(intersection_set)
	
  # Output: {3}
```
Difference: The difference between two sets contains the elements present in the first set but not in the second set. It can be obtained using the difference() method or the minus operator (-).
```
  set1 = {1, 2, 3}
  set2 = {3, 4, 5}
	
  difference_set = set1.difference(set2)
  print(difference_set)
	
  # Output: {1, 2}
```
Subset: A set A is said to be a subset of set B if every element of A is also present in B. It can be checked using the issubset() method.
```
  set1 = {1, 2}
  set2 = {1, 2, 3, 4, 5}
	
  print(set1.issubset(set2))
	
  # Output: True
```
These are just a few examples of the set operations available in Python, and there are many more that you can explore.

Dictionaries

Dictionaries are unordered collections of key-value pairs. They are defined by enclosing comma-separated key-value pairs inside curly braces {}. Dictionaries are mutable and can contain elements of different data types.

Creating a Dictionary

To create a dictionary, you can enclose key-value pairs inside curly braces {}. Let’s create a dictionary of student names and their corresponding ages: python students = {'John': 25, 'Alice': 22, 'Bob': 28} print(students) Output: {'John': 25, 'Alice': 22, 'Bob': 28} In the above example, we created a dictionary named students with three key-value pairs, where the names are keys and ages are values.

Accessing and Modifying Elements

To access the value associated with a key in a dictionary, you can use the square bracket [] notation. Let’s access the age of ‘John’ from the dictionary: python john_age = students['John'] print(john_age) Output: 25 You can also use the get() method to access the value associated with a key. This method returns None if the key is not found, whereas using square brackets directly will raise a KeyError. Here’s an example: python alice_age = students.get('Alice') print(alice_age) Output: 22 To modify the value associated with a key, simply assign a new value to it using the square bracket notation. Let’s update the age of ‘John’: python students['John'] = 26 print(students) Output: {'John': 26, 'Alice': 22, 'Bob': 28}

Dictionary Operations

Dictionaries provide various operations to manipulate the data stored in them. Let’s explore some of the common operations:

Adding a new key-value pair: To add a new key-value pair to a dictionary, you can directly assign a value to a new key using the square bracket notation.
```
  students['Eve'] = 24
  print(students)
	
  # Output: {'John': 26, 'Alice': 22, 'Bob': 28, 'Eve': 24}
```
Removing a key-value pair: To remove a key-value pair from a dictionary, you can use the del keyword followed by the dictionary name and the key.
```
  del students['Bob']
  print(students)
	
  # Output: {'John': 26, 'Alice': 22, 'Eve': 24}
```
Checking if a key exists: You can use the in keyword to check if a key exists in a dictionary.
```
  print('Alice' in students)
	
  # Output: True
```
These are just a few examples of the dictionary operations available in Python, and there are many more that you can explore.

Conclusion

In this tutorial, we covered two important data structures in Python - Sets and Dictionaries. We learned how to create and manipulate sets, and understand their various operations such as adding elements, removing elements, and performing set operations. We also explored dictionaries, including creating dictionaries, accessing and modifying elements, and performing dictionary operations.

Sets and dictionaries are powerful data structures that are widely used in Python programming. They provide efficient ways to store and retrieve data, making them essential tools for many applications.

I hope this tutorial has helped you understand sets and dictionaries in Python. Happy coding!

Published: 6 August 2019