Difference Between List, Set, Tuple, and Dictionary

In Python, lists, sets, tuples, and dictionaries are essential data structures used to store and manage data. A list is an ordered collection, a tuple is similar but immutable, a set is unordered with no duplicates, and a dictionary stores data in key-value pairs.

Understanding the differences between list, tuple, set, dictionary in Python with examples can be confusing, especially for beginners. You may wonder when to use each and how they differ in performance and functionality.

This tutorial will break down list, tuple, set, dictionary in python with examples, highlighting their key differences, including the probable confusing difference between list and tuple in Python. By the end, you’ll know exactly when and how to use each of them in your code.

Keep reading to learn how mastering these data structures will make your Python programming smoother, more efficient, and flexible!

“Enhance your Python skills further with our Data Science and Machine Learning courses from top universities — take the next step in your learning journey!”

What is List in Python?

A list in Python is an ordered collection of items, which means the elements in a list are stored in a specific order. You can store different data types in a list, such as strings, integers, or even other lists.

Lists are very versatile and are used frequently in Python programming.

Key Features of a List

• Ordered: The elements maintain their order. When you create a list, the items are stored in the sequence you provide.
• Heterogeneous: A list can store items of different data types, including strings, numbers, and even other lists.
• Mutable: Unlike tuples, you can modify lists after creating them—add, remove, or change items as needed.

Also Read: What Is Mutable And Immutable In Python?

Syntax of a Python List

To create a list in Python, you simply use square brackets [] and separate elements with commas:

my_list = [element1, element2, element3, element4, element5]

List Operations in Python

There are many operations you can perform on lists. Here are a few common ones:

1. append(value): Adds a value to the end of the list.
2. insert(index, value): Inserts a value at the specified index.
3. remove(value): Removes the first occurrence of the specified value.
4. pop(index): Removes and returns the item at the given index (default is the last item).
5. len(): Returns the number of items in the list.
6. sort(): Sorts the list in ascending order (can use reverse=True for descending).
7. reverse(): Reverses the order of items in the list.
8. extend(iterable): Adds all elements from an iterable (like another list) to the end of the list.
9. slice(): Creates a new list from a portion of the original list by specifying a range of indices.
10. clear(): Removes all items from the list.

Ready to take your coding skills to the next level? Explore upGrad’s Online Software Development Courses and start building the software solutions of tomorrow. Let's get coding today!

Also Read: List vs Tuple: Understanding the Differences in Python

What is Tuple in Python?

A tuple in Python is similar to a list, but it’s immutable. The difference between list and tuple in python is that once you create a tuple, you cannot change its values. Tuples are ordered collections, meaning the items maintain their order.

They can hold multiple data types and are commonly used when you need a collection that should not be modified.

Key Features of a Tuple

• Immutable: Once created, the values in a tuple cannot be changed.
• Ordered: Tuples maintain the order of elements.
• Heterogeneous: A tuple can store different data types, such as integers, strings, and other tuples.
• Can contain duplicate elements: Like lists, tuples can have repeated values.

Syntax of a Python Tuple

To create a tuple, you use parentheses () with items separated by commas:

my_tuple = (element1, element2, element3)

Tuple Operations in Python

Here are common operations you can perform on tuples:

1. Index(): Returns the first index of the specified value in the tuple.
2. Count(): Counts how many times a specified value appears in the tuple.
3. Len(): Returns the number of items in the tuple.
4. Concatenate (+): Combines two or more tuples into one.
5. Repeat (*): Repeat the tuple a specified number of times.
6. Slice(): Extracts a portion of the tuple by specifying a range of indices.
7. Membership (in): Checks if a value exists in the tuple.
8. Tuple(): Converts other data types (like lists) into a tuple.

Also Read: What is Tuple in DBMS? Types, Examples & How to Work

What is a Set in Python?

A set in Python is an unordered collection of unique elements. Unlike lists or tuples, sets do not allow duplicate values, and they don’t maintain the order of elements. Sets are commonly used when you need to store unique items and perform set operations like unions, intersections, and differences.

Key Features of a Set

• Unordered: The items in a set do not have a specific order.
• Unique Elements: Sets cannot contain duplicate values.
• Mutable: You can add or remove items after creating a set.
• Supports Set Operations: You can perform operations like union, intersection, and difference on sets.

Syntax of a Python Set

To create a set, you use curly braces {} or the set() function:

my_set = {element1, element2, element3}

You can also create an empty set using set():

empty_set = set()

Set Operations in Python

1. Add(): Adds an element to the set.
2. Remove(): Removes the specified element from the set (raises an error if not found).
3. Discard(): Removes an element from the set (doesn’t raise an error if the element is not found).
4. Len(): Returns the number of elements in the set.
5. Union(): Combines two sets and returns a new set with all unique elements.
6. Intersection(): Returns a new set with elements that are common to both sets.
7. Difference(): Returns a new set with elements that are in one set but not the other.
8. Subset (issubset): Checks if all elements of one set are in another set.
9. Superset (issuperset): Checks if a set contains all elements of another set.
10. Clear(): Removes all elements from the set.

“Start your coding journey with our complimentary Python courses designed just for you — dive into Python programming fundamentals, explore key Python libraries, and engage with practical case studies!”

What is a Dictionary in Python?

A dictionary in Python is an unordered collection of data stored in key-value pairs. In simpler terms, it's like a real-world dictionary where each word (key) has a definition (value).

Key Features of a Dictionary

• Unordered: Dictionaries do not maintain the order of elements.
• Key-Value Pairs: Each item in a dictionary is a pair, where the key is unique and maps to a specific value.
• Mutable: You can change, add, or remove key-value pairs after creating the dictionary.
• Keys Must Be Unique: Every key in a dictionary must be unique, but values can be duplicated.
• Fast Lookups: You can access the data associated with a key in constant time, making dictionaries a great choice for fast lookups.

Syntax of a Python Dictionary

my_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

A comma separates each key-value pair.

Dictionary Operations in Python

Some important operations include:

• Accessing values: You can access the value associated with a key.
• Adding items: Add new key-value pairs to the dictionary.
• Removing items: Remove a key-value pair using del or the pop() method.
• Checking existence: Use the in operator to check if a key exists in the dictionary.
• Sorting items: Sort the dictionary by values or keys (Note: Sorting works on dictionary views, like a list)

Want to level up your coding skills? Dive into upGrad’s Data Structures & Algorithms Course, master the essentials, and solve complex problems with ease. Start your journey now!

Differences Between List, Tuple, Set, and Dictionary

Now that you have a basic understanding let’s compare them.

Let’s look at similarities next.

Similarities Between List, Tuple, Set, and Dictionary

1. Can Store Multiple Items: All four data structures can store multiple items, making them useful for managing collections of data.
2. Can Hold Different Data Types: They can each store various data types, such as strings, integers, or even other collections (like lists within dictionaries).
3. Iterables: All of these structures are iterable, meaning you can loop over them using a for loop or other iteration techniques.
4. Used for Storing Data: Whether it’s a list of items, a set of unique elements, or a dictionary of key-value pairs, each one is used to store data in some form.
5. Built-in Python Data Structures: List, tuple, set, and dictionary are all part of Python’s built-in data types, so you don’t need to import anything to use them.
6. Supports Membership Testing: You can check whether an item exists in any of these structures using the in operator (e.g., element in list or key in dictionary).
7. Support for Nested Structures: You can nest these data structures within one another (e.g., lists inside dictionaries, sets inside lists).
8. Can Be Used to Solve Common Programming Problems: All four data structures are commonly used to solve everyday programming problems, such as organizing data, checking for duplicates, or handling mappings.
9. Can Be Empty: Each of these structures can be initialized as an empty collection (e.g., [], (), {}, dict()).
10. Have Methods Associated with Them: Each of these structures has a set of associated methods for performing operations (e.g., .append() for lists, .add() for sets, .get() for dictionaries).

Also Read: Top 10 Python String Methods [With Examples]

When to Use List, Tuple, Set, and Dictionary

1. Dynamic Operations: Use List when you need to add, remove, or modify elements frequently.
2. Storing Immutable Data: Use Tuple when you need to store data that shouldn’t change, like coordinates.
3. Ensuring Unique Elements: Use Set when you need a collection of unique items without duplicates.
4. Mapping Keys to Values: Use Dictionary when you need to associate unique keys with specific values, like name-ID pairs.
5. Preserving Order of Data: Use List when the order of elements matters and needs to be maintained.
6. Faster Lookups for Data: Use Dictionary when you need quick access to data via keys.
7. Iterating Over Elements: Use List or Tuple when you need to iterate over elements in a fixed order.
8. Performing Set Operations: Use Set when you need to perform operations like union, intersection, or difference.
9. Fixed, Non-Changing Data: Use Tuple when the data is fixed and should not be changed, such as configuration settings.
10. Handling Multiple Key-Value Pairs: Use Dictionary when you need to store and retrieve data based on a unique key.

Examples of List, Tuple, Set, and Dictionary

Let’s look at list, tuple, set, dictionary in Python with examples.

Python List Example

In this example, you’ll work with a dataset of employees in a company.

Let’s first create a dictionary that contains employee names and their corresponding employee IDs.

employees = [
{"Name": "Rahul", "Department": "IT"},
{"Name": "Priya", "Department": "HR"},
{"Name": "Amit", "Department": "Finance"},
{"Name": "Neha", "Department": "IT"}
]

Now, let’s extract just the employee names into a list:

employee_names = [employee["Name"] for employee in employees]

This line creates a new list called ‘employee_names’ that contains only the names of the employees by looping through the employees list and accessing the Name field.

Let’s print the list of employee names:

print(employee_names)

Output:

['Rahul', 'Priya', 'Amit', 'Neha']

Now, let’s perform some common list operations on our employee_names list.

# access the name of the second employee in the list

second_employee = employee_names[1]
print(second_employee)

Output:

Priya

The list is zero-indexed, so employee_names[1] refers to the second element in the list, which is "Priya".

# add a new employee to the list

employee_names.append("Suresh")
print(employee_names)

Output:

['Rahul', 'Priya', 'Amit', 'Neha', 'Suresh']

We use append() to add "Suresh" to the end of the employee_names list.

# remove "Amit" from the list

employee_names.remove("Amit")
print(employee_names)

Output:

['Rahul', 'Priya', 'Neha', 'Suresh']

The remove() method removes the first occurrence of the specified element, in this case, "Amit".

# check if "Neha" is in the list

is_neha_present = "Neha" in employee_names
print(is_neha_present)

Output:

True

The “in” keyword checks if the element "Neha" is present in the list. The result is True because "Neha" is indeed in the list.

Python Tuple Example

Let’s first create a tuple to store student names along with their grades:

students_grades = (
("Rahul", 85),
("Priya", 90),
("Amit", 78),
("Neha", 92)
)

Suppose you want to access Amit’s grade:

amit_grade = students_grades[2][1]
print(amit_grade)

Output:

78

The first index students_grades[2] gets the tuple ("Amit", 78), and then [1] accesses Amit’s grade.

Let’s check how many times the grade 90 appears in the dataset:

count_90 = sum(1 for student in students_grades if student[1] == 90)
print(count_90)

Output:

1

The sum() function counts how many times 90 appears in the grades of the students.

Now, let’s extract the grades of the first two students:

first_two_grades = students_grades[:2]
print(first_two_grades)

Output:

[('Rahul', 85), ('Priya', 90)]

This slices the first two student-grade tuples from the original students_grades tuple.

Here are some common tuple operations:

# returns the index of the first occurrence of a specified value

index_of_priya = students_grades.index(("Priya", 90))
print(index_of_priya)

Output:

1

# counts how many times a value appears in the tuple

grade_count = students_grades.count(("Neha", 92))
print(grade_count)

Output:

1

# combines two tuples into one

additional_students = (("John", 88), ("Maya", 95))
all_students = students_grades + additional_students
print(all_students)

Output:

[('Rahul', 85), ('Priya', 90), ('Amit', 78), ('Neha', 92), ('John', 88), ('Maya', 95)]

# repeats a tuple a specified number of times

repeated_grades = students_grades * 2
print(repeated_grades)

Output:

[('Rahul', 85), ('Priya', 90), ('Amit', 78), ('Neha', 92), ('Rahul', 85), ('Priya', 90), ('Amit', 78), ('Neha', 92)]

# extracts a subset of the tuple

subset = students_grades[1:3]
print(subset)

Output:

[('Priya', 90), ('Amit', 78)]

Python Set Example

Let’s first create a set with unique product IDs:

store_products = {101, 102, 103, 104, 105}

Here, we’ve used curly braces {} to define a set of product IDs. Since sets don’t allow duplicates, if you try adding a duplicate value, it will be ignored.

Let’s say a new product with ID 106 arrives in the store:

store_products.add(106)
print(store_products)

Output:

{101, 102, 103, 104, 105, 106}

The add() method adds the product ID 106 to the set.

Now, let’s say product with ID 102 is discontinued and needs to be removed:

store_products.remove(102)
print(store_products)

Output:

{101, 103, 104, 105, 106}

The remove() method removes the specified element, in this case, 102. If the item doesn’t exist, it will raise an error.

Let’s check if product 104 is available:

is_product_available = 104 in store_products
print(is_product_available)

Output:

True

The in operator checks whether 104 is in the set and returns True if it exists.

Here are some important set operations that you can perform in Python:

# combines two sets and returns a new set with all unique elements from both sets

other_products = {107, 108, 109}
all_products = store_products | other_products
print(all_products)

Output:

{101, 103, 104, 105, 106, 107, 108, 109}

# returns a set of elements that are common to both sets

discontinued_products = {102, 103, 106}
common_products = store_products & discontinued_products
print(common_products)

Output:

{103, 106}

# returns a set of elements that are in one set but not in the other

remaining_products = store_products - discontinued_products
print(remaining_products)

Output:

{101, 104, 105}

# returns a set of elements that are in one set or the other, but not in both

unique_products = store_products ^ discontinued_products
print(unique_products)

Output:

{101, 104, 105, 102}

# checks if one set is a subset of another (i.e. if all elements in the first set are also in the second)

smaller_set = {103, 106}
is_subset = smaller_set <= store_products
print(is_subset)

Output:

True

# removes all elements from the set

store_products.clear()
print(store_products)

Output:

set()

Also Read: Difference Between Function and Method in Python

Python Dictionary Example

Let’s create a dictionary to store book titles and authors:

library_books = {
"The Alchemist": "Paulo Coelho",
"1984": "George Orwell",
"To Kill a Mockingbird": "Harper Lee",
"Pride and Prejudice": "Jane Austen"
}

Let’s say you want to add a new book to the library:

library_books["The Catcher in the Rye"] = "J.D. Salinger"
print(library_books)

Output:

{'The Alchemist': 'Paulo Coelho', '1984': 'George Orwell', 'To Kill a Mockingbird': 'Harper Lee', 'Pride and Prejudice': 'Jane Austen', 'The Catcher in the Rye': 'J.D. Salinger'}

Let’s remove "1984" from the library:

del library_books["1984"]
print(library_books)

Output:

{'The Alchemist': 'Paulo Coelho', 'To Kill a Mockingbird': 'Harper Lee', 'Pride and Prejudice': 'Jane Austen', 'The Catcher in the Rye': 'J.D. Salinger'}

If you want to update the author of "The Alchemist":

library_books["The Alchemist"] = "Paulo Coelho (Revised)"
print(library_books)

Output:

{'The Alchemist': 'Paulo Coelho (Revised)', 'To Kill a Mockingbird': 'Harper Lee', 'Pride and Prejudice': 'Jane Austen', 'The Catcher in the Rye': 'J.D. Salinger'}

Let’s check if "Pride and Prejudice" exists in the library:

is_book_present = "Pride and Prejudice" in library_books
print(is_book_present)

Output:

True

The “in” operator checks if "Pride and Prejudice" is a key in the dictionary and returns True since it exists.

Here are some important dictionary operations you can perform in Python:

# retrieves the value associated with a given key

author = library_books.get("1984", "Not Found")
print(author)

Output:

Not Found

# returns a view object of all keys in the dictionary

keys = library_books.keys()
print(keys)

Output:

dict_keys(['The Alchemist', 'To Kill a Mockingbird', 'Pride and Prejudice', 'The Catcher in the Rye'])

# returns a view object of all values in the dictionary

values = library_books.values()
print(values)

Output:

dict_values(['Paulo Coelho (Revised)', 'Harper Lee', 'Jane Austen', 'J.D. Salinger'])

# returns a view object of all key-value pairs in the dictionary

items = library_books.items()
print(items)

Output:

dict_items([('The Alchemist', 'Paulo Coelho (Revised)'), ('To Kill a Mockingbird', 'Harper Lee'), ('Pride and Prejudice', 'Jane Austen'), ('The Catcher in the Rye', 'J.D. Salinger')])

# removes a key-value pair and returns the value

removed_book = library_books.pop("Pride and Prejudice")
print(removed_book)
print(library_books)

Output:

Jane Austen{'The Alchemist': 'Paulo Coelho (Revised)', 'To Kill a Mockingbird': 'Harper Lee', 'The Catcher in the Rye': 'J.D. Salinger'}

# removes all items from the dictionary

library_books.clear()
print(library_books)

Output:

{}

These were the list, tuple, set, dictionary in Python with example, showcasing how each data structure can be used in different scenarios.

To learn more about data structures, OOPs, etc., join upGrad’s Programming with Python: Introduction for Beginners course and kickstart your programming journey!

Applications of List, Tuple, Set, and Dictionary

Applications of List

Let’s take a look at some common use cases where lists shine and how they differ from other data structures.

1. Storing User InputLists are great for storing user-generated data, like survey responses or form inputs, since the data might change or be updated frequently.
2. Managing Tasks or To-Do ListsWhen managing tasks or project management tools, lists allow you to add, remove, or update tasks dynamically. You can use lists to track tasks in an ordered sequence.
3. Handling Data from APIsWhen fetching data from APIs, lists are often used to store the response data (such as JSON objects), like catalog items.
4. Sorting DataThe sort() method allows lists to be sorted, making them perfect for applications that require sorting, such as organizing customer records, product lists, or rankings.
5. Tracking Time-Series DataLists are ideal for applications that need to track time-series data (e.g., stock prices, and temperature readings).
6. Storing Multiple Attributes of ObjectsLists can store attributes or properties of objects (like student grades or product details), allowing for easy access to and manipulation of these grouped data elements.

Also Read: Attributes in DBMS: Types of Attributes in DBMS

Applications of Tuple

Tuples are widely used when you need a fixed collection of items. Here are some practical applications of tuples:

1. Storing CoordinatesUse tuples to store geographical coordinates (latitude, longitude) since the data should not change.
2. Storing Immutable DataWhen you need to ensure the data remains constant, like storing system configuration settings.
3. Used as Dictionary KeysSince tuples are immutable, they can be used as keys in dictionaries, unlike lists.
4. Handling Dates and TimeTuples can store date and time as multiple elements, ensuring that the data does not change accidentally.
5. Memory-Efficient CollectionsWhen a fixed set of data needs to be stored efficiently, tuples are more memory-efficient than lists.
6. Returning Multiple Values from FunctionsTuples are perfect for returning multiple values from a function in a single, immutable container.

Also Read: How to Take Multiple Input in Python: Techniques and Best Practices

Applications of Set

Sets in Python are used when you need to store unique items. Here are some common use cases:

1. Removing Duplicates from DataUse sets to automatically remove duplicates from a list of items, like filtering out repeated email addresses or product IDs.
2. Membership TestingSets are ideal for quickly checking whether an item exists in a collection, such as verifying whether a username has already been taken.
3. Set OperationsUse sets for operations like union, intersection, and difference, such as comparing customer lists or tracking common purchases.
4. Tracking Unique ItemsSets are perfect for storing unique items, like tracking visited pages on a website or unique products purchased.
5. Efficient Data HandlingSets are faster for operations that involve checking membership or uniqueness, making them useful in large datasets.
6. Mathematical Set OperationsSets are widely used in mathematical problems, like finding common elements between groups or eliminating non-overlapping elements.

Applications of Dictionary

Dictionaries in Python are handy for mapping unique keys to values. Here are some common use cases:

1. Efficient LookupsWhen you need to access data quickly using a key, dictionaries allow for fast lookups, such as retrieving a user’s profile by their username.
2. Configuring SettingsUse dictionaries to store configuration settings or properties, where each setting has a unique name (key) and value (e.g., API keys, user preferences).
3. Counting OccurrencesDictionaries are great for counting occurrences of items, like counting the frequency of words in a text or tracking votes in a poll.
4. Storing Complex DataDictionaries can store complex, nested data like records or objects, where each key holds a more detailed set of information (e.g., student grades, product details).
5. Mapping One Piece of Data to AnotherWhen you need to map one piece of data to another, like user IDs to email addresses, dictionaries are perfect for such tasks.

Also Read: 12 Amazing Real-World Applications of Python

Understanding the difference between list, tuple, set, dictionary in Python with example will help you make the right choice for your project.

How upGrad can help you?

With upGrad, you can access global standard education facilities right here in India. upGrad also offers free Python courses that come with certificates, making them an excellent opportunity if you're interested in data science and machine learning.

By enrolling in upGrad's Python courses, you can benefit from the knowledge and expertise of some of the best educators from around the world. These instructors understand the diverse challenges that Python programmers face and can provide guidance to help you navigate them effectively.

So, reach out to an upGrad counselor today to learn more about how you can benefit from a Python course.

Here are some of the best data science and machine learning courses offered by upGrad, designed to meet your learning needs:

• Professional Certificate Program in Business Analytics & Consulting in association with PwC India
• Advanced Certificate Program in Generative AI
• Post Graduate Certificate in Machine Learning and Deep Learning
• Post Graduate Certificate in Data Science & AI (Executive)
• Executive Program in Generative AI for Business Leaders
• Post Graduate Programme in Data Science & AI (Executive)
• Master of Science in Machine Learning & AI
• Master’s Degree in Artificial Intelligence and Data Science
• Doctor of Business Administration in Emerging Technologies with Specialization in Generative AI

Similar Reads: Top Trending Blogs of Python

• Pattern Program in Python
• Leap Year Program in Python
• Difference Between List and Tuple in Python
• Difference between List, Tuple, Set, and Dictionary in Python
• Order Precedence in Python

FAQS

1. Can a tuple be modified after creation?

No, tuples are immutable, meaning once created, you cannot modify their elements.

2. What is the main difference between list and tuple in python?

The main difference is that lists are mutable (can be changed), while tuples are immutable (cannot be changed).

3. Can I store different data types in a set?

Yes, sets can store immutable different data types, but they cannot store mutable types like lists or dictionaries.

4. What happens if I add a duplicate item to a set?

Duplicate values are automatically removed when you add them to a set. Sets only store unique values.

5. Can a dictionary have multiple identical keys?

No, dictionary keys must be unique. If you try to add a duplicate key, it will overwrite the previous value.

6. When should I use a dictionary over a list?

Use a dictionary when you need to map data using unique keys, like associating student IDs with names or product IDs with prices.

7. Can I perform mathematical operations like union or intersection on lists?

No, only sets support mathematical operations like union and intersection directly. Lists require other methods for these operations.

8. What is the difference between set and list in terms of order?

Lists maintain the order of elements, while sets are unordered collections, meaning the elements are not stored in any specific order.

9. Can a dictionary contain a list as a value?

Yes, dictionaries can store lists as values, allowing you to map keys to more complex data types like lists or other dictionaries.

10. What are the performance differences between lists, tuples, and sets?

Lists and tuples are slower for membership tests compared to sets, which are optimized for quick lookups. Tuples are more memory-efficient than lists.

11. Can I use a tuple as a dictionary key?

Yes, since tuples are immutable, they can be used as dictionary keys, unlike lists, which are mutable and cannot be used as keys.

Take our Free Quiz on Python

Answer quick questions and assess your Python knowledge

Start Quiz