In Python, data structures are fundamental constructs used to store, organize, and manipulate data efficiently. Here are some common data structures available in Python:

1. Lists:
   • Lists are ordered, mutable collections of elements.
   • Created using square brackets [ ] and can contain elements of different data types.
   • Supports indexing and slicing operations.
   • Common operations include adding or removing elements, accessing elements by index, and iterating over elements.
2. Tuples:
   • Tuples are ordered, immutable collections of elements.
   • Created using parentheses ( ) and can contain elements of different data types.
   • Supports indexing and slicing operations, but elements cannot be modified after creation.
   • Commonly used for representing fixed collections of items, such as coordinates or function return values.
3. Dictionaries:
   • Dictionaries are unordered collections of key-value pairs.
   • Created using curly braces { } with key-value pairs separated by colons : (e.g., {key1: value1, key2: value2}).
   • Keys must be unique and immutable (e.g., strings, numbers), while values can be of any data type.
   • Supports fast lookups and efficient insertion and deletion of key-value pairs.
4. Sets:
   • Sets are unordered collections of unique elements.
   • Created using curly braces { } or the set() constructor.
   • Automatically removes duplicates when created.
   • Supports set operations such as union, intersection, difference, and symmetric difference.
5. Arrays:
   • Arrays are collections of homogeneous elements (i.e., elements of the same data type).
   • Implemented using the array module or third-party libraries like NumPy.
   • More memory-efficient than lists for large sequences of numeric data.
   • Supports indexing and slicing operations similar to lists.
6. Queues:
   • Queues are ordered collections of elements that follow the First-In, First-Out (FIFO) principle.
   • Implemented using the queue module, or deque from the collections module.
   • Common operations include adding elements to the rear (enqueue) and removing elements from the front (dequeue).
7. Stacks:
   • Stacks are ordered collections of elements that follow the Last-In, First-Out (LIFO) principle.
   • Implemented using lists or the deque class from the collections module.
   • Common operations include adding elements to the top (push) and removing elements from the top (pop).

These data structures provide different ways to organize and manipulate data in Python, each with its own advantages and use cases. Choosing the right data structure depends on factors such as the nature of the data, the operations to be performed, and efficiency considerations.

Example:

1. Lists:

# Example program using lists
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']

# Adding elements to a list
numbers.append(6)
fruits.insert(2, 'grape')

# Accessing elements by index
print(numbers[2])  # Output: 3
print(fruits[-1])  # Output: grape

# Iterating over elements
for fruit in fruits:
    print(fruit)

# Removing elements
numbers.remove(3)
del fruits[0]

# Slicing
print(numbers[1:4])  # Output: [2, 4, 5]

1. Dictionaries:

# Example program using dictionaries
student = {'name': 'Alice', 'age': 20, 'grade': 'A'}

# Accessing values by key
print(student['name'])  # Output: Alice
print(student.get('age'))  # Output: 20

# Adding a new key-value pair
student['city'] = 'New York'

# Iterating over key-value pairs
for key, value in student.items():
    print(key, ':', value)

# Removing a key-value pair
del student['grade']

1. Sets:

# Example program using sets
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Union of sets
union = set1 | set2

# Intersection of sets
intersection = set1 & set2

# Difference of sets
difference = set1 - set2

# Symmetric difference of sets
sym_difference = set1 ^ set2

print(union)
print(intersection)
print(difference)
print(sym_difference)

1. Queues:

# Example program using queues
from collections import deque

queue = deque(['a', 'b', 'c'])

# Enqueue
queue.append('d')

# Dequeue
item = queue.popleft()
print(item)  # Output: a

1. Stacks:

# Example program using stacks
stack = []

# Push
stack.append('a')
stack.append('b')

# Pop
item = stack.pop()
print(item)  # Output: b