Basic Data Structures Examples

[DadaNanjesha]

Structures

• Lists
• Tuples
• Sets
• Dictionaries
• Collections module

Requirements

• CRUD operations for each
• Performance characteristics
• Real-world use cases
• Comparison table

[Adity-star]

CRUD Operations for Each Data Structure

1. Lists

• Create: Append or insert items into a list.
• Read: Access items via index.
• Update: Modify an item in the list by index.
• Delete: Remove items via del, remove(), or pop().

# Create
my_list = [1, 2, 3]

# Read
print(my_list[0])  # Output: 1

# Update
my_list[0] = 10

# Delete
my_list.pop()  # Removes last item

2. Tuples

-Create: Define a tuple using parentheses.
-Read: Access items via index.
-Update: Cannot update a tuple as it's immutable.
-Delete: You cannot directly delete individual items but can delete the entire tuple.

# Create
my_tuple = (1, 2, 3)

# Read
print(my_tuple[0])  # Output: 1

# Update (Not possible)

# Delete
del my_tuple  # Entire tuple

3. Sets

-Create: Define a set using curly braces or set().
-Read: Iterating over sets.
-Update: Add or discard items with add() or remove().
-Delete: Use clear() to remove all or remove() for individual items.

# Create
my_set = {1, 2, 3}

# Read
for item in my_set:
    print(item)

# Update
my_set.add(4)

# Delete
my_set.remove(2)

4. Dictionaries

-Create: Define a dictionary using curly braces or dict().
-Read: Access values using keys.
-Update: Modify values using keys.
-Delete: Remove key-value pairs using del or pop().

# Create
my_dict = {'a': 1, 'b': 2}

# Read
print(my_dict['a'])  # Output: 1

# Update
my_dict['a'] = 10

# Delete
del my_dict['b']

Performance Characteristics of CRUD Operations

The following table provides a comparison of the time complexity for each operation in different data structures:

Operation	Lists	Tuples	Sets	Dictionaries	Collections
Create	O(1)	O(1)	O(1)	O(1)	O(1)
Read	O(1)	O(1)	O(1)	O(1)	O(1)
Update	O(1)	N/A	O(1)	O(1)	O(1)
Delete	O(n)	N/A	O(1)	O(1)	O(1)
Space	O(n)	O(n)	O(n)	O(n)	O(n)

Detailed Breakdown of Performance

1. Create Operation

• Lists: Creating a list is O(1) when you're simply initializing an empty list or appending an item to the end of the list.
• Tuples: Creating a tuple is O(1) as well. Since tuples are immutable, they are created with a fixed size from the beginning.
• Sets: Creating a set is O(1), as adding elements to an empty set does not involve any searching or reorganization.
• Dictionaries: Creating a dictionary is O(1) because adding a key-value pair does not require searching.
• Collections: The creation of collection types (like Counter, deque, etc.) is also O(1) in most cases.

2. Read Operation

• Lists: Reading an element by index in a list is O(1), as it is a direct access operation.
• Tuples: Reading an element by index is O(1) as well because tuples are indexed similarly to lists.
• Sets: Reading in a set involves hashing, and thus accessing an element is O(1), assuming no hash collisions.
• Dictionaries: Reading a value by key in a dictionary is O(1) due to the efficient hashing mechanism.
• Collections: Reading in most collection types (such as deque or Counter) is O(1).

3. Update Operation

• Lists: Updating an element by index is O(1) as it directly modifies the element in place.
• Tuples: Since tuples are immutable, updating an element is not possible. This will raise a TypeError.
• Sets: Updating (adding/removing elements) is O(1) on average.
• Dictionaries: Updating a value by key is O(1) as dictionaries are implemented using hash tables.
• Collections: The update operation on collections like Counter or deque is O(1) for most cases (e.g., adding/removing items).

4. Delete Operation

• Lists: Deleting an element from a list takes O(n) in the worst case because elements need to be shifted after removal.
• Tuples: You cannot delete individual elements in a tuple, but you can delete the entire tuple. Deleting a tuple is O(1).
• Sets: Deleting an element from a set is O(1) on average due to the nature of hash tables.
• Dictionaries: Deleting a key-value pair is O(1) on average due to the underlying hash table structure.
• Collections: Deleting elements from collections like Counter or deque is generally O(1).

5. Space Complexity

• Lists: Space complexity is O(n), where n is the number of elements in the list.
• Tuples: Space complexity is O(n), as tuples store a fixed number of elements.
• Sets: Space complexity is O(n), where n is the number of unique elements.
• Dictionaries: Space complexity is O(n), as dictionaries store key-value pairs.
• Collections: The space complexity for collections is O(n), where n is the number of elements or items stored in the collection.

Real-World Use Cases

• Lists: Dynamic arrays, storing sequences of items.
  -Tuples: Storing fixed data, returning multiple values from functions.
  -Sets: Ensuring uniqueness, performing mathematical set operations (union, intersection).
  -Dictionaries: Mapping key-value pairs (e.g., database record, frequency count).

Comparison Table

Feature/Property	Lists	Tuples	Sets	Dictionaries	Collections
Mutable	Yes	No	Yes	Yes	Depends
Duplicates Allowed	Yes	No	No	No	Depends
Indexing	Yes	Yes	No	Yes	Depends
Ordered	Yes (since 3.7)	Yes	No	Yes (since 3.7)	Depends
Use Case	Dynamic Arrays	Fixed Data	Uniqueness	Key-Value Pairs	Special Cases

[DadaNanjesha]

@Adity-star Looks great, you can fork the repository , start contribution and raise PR.

• This is an issue so we cannot merge from issue to code repo, follow the guidelines , if you need help let me know.

[DadaNanjesha]

You can track this with sub issue #35 for next changes required for this pr merge