Chapter 7: Data Structures in Python

Understanding Data Structures in Python

Introduction

Data structures are the backbone of efficient programming. Whether you’re developing a small script or building a complex application, understanding how to store and manipulate data effectively is crucial. In this chapter, we’ll dive into some of the most commonly used data structures in Python: lists, tuples, sets, and dictionaries. We’ll also explore operations on these data structures and how to work with nested data structures. By the end of this post, you’ll have a solid understanding of how to manage and organize data in your Python projects.

Lists: The Versatile Container

Lists are one of the most flexible data structures in Python. They can store a collection of items, which can be of different types (integers, strings, objects, etc.). The items in a list are ordered, changeable, and allow duplicate values.

Creating a List

Creating a list is straightforward:

Here, fruits is a list containing three elements. You can access any item using its index:

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

print(fruits[0])  # Output: apple

Common List Operations

• Appending Items: Add an item to the end of the list.

• Inserting Items: Insert an item at a specified position.

• Removing Items: Remove an item by value.

• List Slicing: Access a range of items.

  fruits.append('orange')

  fruits.insert(1, 'mango')

  fruits.remove('banana')

  print(fruits[1:3])  # Output: ['mango', 'cherry']

Lists are incredibly versatile and are often used when you need an ordered, mutable collection of items.

Tuples: Immutable and Efficient

Tuples are similar to lists but with one key difference: they are immutable, meaning that once a tuple is created, it cannot be modified. This immutability makes tuples a bit faster and safer to use when you want to ensure that data remains unchanged.

Creating a Tuple

• Tuples are defined using parentheses:

Accessing Tuple Elements

• You can access tuple elements just like you would with a list:

coordinates = (10, 20)

print(coordinates[0])  # Output: 10

Why Use Tuples?
Tuples are ideal for storing data that should not change, like coordinates, database records, or fixed configuration values. Their immutability also allows them to be used as keys in dictionaries, unlike lists.

Sets: Unique and Unordered

Sets are collections of unique elements, meaning that they automatically remove duplicates. Sets are unordered, so the items do not have a defined sequence.

numbers = {1, 2, 3, 4}

Or:

numbers = set([1, 2, 3, 4])

Creating a Set
Sets are created using curly braces or the set() function:

Common Set Operations

• Adding Items: Add an item to the set.
• Removing Items: Remove an item from the set.
• Set Operations: Perform mathematical operations like union, intersection, and difference.

Sets are useful when you need to ensure all elements are unique, such as when filtering duplicates out of a list.

  numbers.add(5)

  numbers.remove(3)

  odd = {1, 3, 5}
  even = {2, 4, 6}
  union = odd.union(even)  # Output: {1, 2, 3, 4, 5, 6}

Dictionaries: Key-Value Pairs

Dictionaries are perhaps the most powerful and flexible data structures in Python. They store data as key-value pairs, allowing for fast lookups, insertions, and deletions based on the key.

Creating a Dictionary
Dictionaries are defined using curly braces, with keys and values separated by a colon:

Accessing Dictionary Items
You can access any value by referencing its key:

student = {
    'name': 'John',
    'age': 25,
    'courses': ['Math', 'Science']
}

print(student['name'])  # Output: John

Common Dictionary Operations

• Adding/Updating Items: Add or update a key-value pair.
• Removing Items: Remove a key-value pair.
• Iterating through Keys and Values:

Dictionaries are perfect for situations where you need to associate keys with values, like storing user information, configuration settings, or any other data where quick lookups are essential.

  student['age'] = 26

  del student['courses']

  for key, value in student.items():
      print(f'{key}: {value}')

Nested Data Structures: Combining the Power

Nested data structures allow you to create more complex data models by combining lists, tuples, sets, and dictionaries within each other.

Example: Nested Dictionary
You can create a dictionary where each value is a list or another dictionary:
Accessing nested data is straightforward:

students = {
    'student1': {
        'name': 'John',
        'age': 25,
        'courses': ['Math', 'Science']
    },
    'student2': {
        'name': 'Jane',
        'age': 22,
        'courses': ['History', 'Literature']
    }
}

print(students['student1']['courses'][0])  # Output: Math

Nested structures are particularly useful when modeling real-world data that has a hierarchical or multi-level organization, such as a list of employees with their respective departments and roles.

• Complete Python Course : Click here
• Free Notes :- Click here
• New Project :-https://www.youtube.com/@Decodeit2
• How to setup this Project Complete video – Click here

Coding Questions

1. List Manipulation:
   • Write a function that takes a list of numbers and returns a new list with each number doubled.
   • Create a function that takes two lists and returns a list that contains only the common elements.
2. Working with Tuples:
   • Write a function that takes a list of tuples, each containing a name and age, and returns a list of names of people who are above 18.
   • Create a function that accepts a tuple of numbers and returns a new tuple with the numbers sorted in ascending order.
3. Set Operations:
   • Write a function that takes two sets and returns their symmetric difference (elements that are in either set, but not in both).
   • Create a function to check if one set is a subset of another.
4. Nested Data Structures:
   • Given a list of dictionaries representing students (each dictionary containing keys like name, age, and grades), write a function to calculate the average grade of all students.
   • Write a function that flattens a list of lists into a single list (e.g., [[1, 2], [3, 4]] should become [1, 2, 3, 4]).

Solution of all Question – Click Here

Download Pdf For this chapter : – Click here

---