diff --git a/tech_docs/python/data_structures.md b/tech_docs/python/data_structures.md
new file mode 100644
index 0000000..2553615
--- /dev/null
+++ b/tech_docs/python/data_structures.md
@@ -0,0 +1,171 @@
+Sure, here's a detailed look at common data structures in Python and the types of data they are typically used for:
+
+### 1. Lists
+- **Common Uses**:
+  - Ordered collections of items where the order matters.
+  - Storing items that can be changed, added, or removed.
+  - Examples: To-do lists, sequences of numbers, names of students, etc.
+
+- **Typical Data**:
+  - Numbers: `[1, 2, 3, 4, 5]`
+  - Strings: `['apple', 'banana', 'cherry']`
+  - Mixed types: `[1, 'apple', 3.14, True]`
+
+### 2. Dictionaries
+- **Common Uses**:
+  - Mapping relationships between keys and values.
+  - Fast lookups of values based on unique keys.
+  - Examples: Phone books (name to number), configuration settings, JSON-like data structures.
+
+- **Typical Data**:
+  - Strings to strings: `{'name': 'Alice', 'city': 'New York'}`
+  - Strings to numbers: `{'apples': 10, 'bananas': 5}`
+  - Mixed keys and values: `{1: 'one', 'two': 2, (3, 4): 'tuple_key'}`
+
+### 3. Tuples
+- **Common Uses**:
+  - Fixed collections of items where the order matters and should not change.
+  - Returning multiple values from a function.
+  - Storing related but different pieces of data.
+  - Examples: Coordinates (x, y, z), RGB color values, database records.
+
+- **Typical Data**:
+  - Numbers: `(1, 2, 3)`
+  - Strings: `('red', 'green', 'blue')`
+  - Mixed types: `(1, 'apple', 3.14)`
+
+### 4. Sets
+- **Common Uses**:
+  - Collections of unique items.
+  - Membership tests, eliminating duplicates.
+  - Mathematical set operations like union, intersection, and difference.
+  - Examples: Unique user IDs, unique items in a collection, tags or keywords.
+
+- **Typical Data**:
+  - Numbers: `{1, 2, 3, 4, 5}`
+  - Strings: `{'apple', 'banana', 'cherry'}`
+  - Mixed types (less common due to unhashable types): `{1, 'apple', (3, 4)}`
+
+### 5. Strings
+- **Common Uses**:
+  - Storing and manipulating text.
+  - Examples: Sentences, file paths, URLs, JSON data.
+
+- **Typical Data**:
+  - Sentences: `"Hello, world!"`
+  - Paths: `"/usr/bin/python"`
+  - JSON data: `'{"name": "Alice", "age": 25}'`
+
+### 6. Arrays (from the `array` module)
+- **Common Uses**:
+  - Storing large amounts of numeric data efficiently.
+  - Arrays provide more efficient storage and faster access for numeric data.
+  - Examples: Numerical computations, scientific data.
+
+- **Typical Data**:
+  - Numbers: `array.array('i', [1, 2, 3, 4, 5])`
+
+### 7. Namedtuples (from the `collections` module)
+- **Common Uses**:
+  - Creating simple classes to group related data.
+  - Similar to tuples, but with named fields for better readability.
+  - Examples: Representing rows from a database, simple data structures.
+
+- **Typical Data**:
+  - Custom data structures: 
+    ```python
+    from collections import namedtuple
+    Point = namedtuple('Point', ['x', 'y'])
+    point = Point(1, 2)
+    ```
+
+### 8. Deques (from the `collections` module)
+- **Common Uses**:
+  - Double-ended queues for fast appends and pops from both ends.
+  - Examples: Implementing queues, stacks, and other data structures.
+
+- **Typical Data**:
+  - Items in a queue or stack:
+    ```python
+    from collections import deque
+    my_deque = deque([1, 2, 3, 4, 5])
+    ```
+
+### 9. Defaultdict (from the `collections` module)
+- **Common Uses**:
+  - Dictionaries with a default value for non-existent keys.
+  - Examples: Counting occurrences, grouping data.
+
+- **Typical Data**:
+  - Dictionaries with default values:
+    ```python
+    from collections import defaultdict
+    my_defaultdict = defaultdict(int)
+    my_defaultdict['a'] += 1
+    ```
+
+### Examples of Usage
+
+#### List Example
+```python
+# List of student names
+students = ['Alice', 'Bob', 'Charlie']
+```
+
+#### Dictionary Example
+```python
+# Dictionary of student grades
+grades = {'Alice': 'A', 'Bob': 'B', 'Charlie': 'C'}
+```
+
+#### Tuple Example
+```python
+# Coordinates of a point
+point = (10, 20)
+```
+
+#### Set Example
+```python
+# Set of unique fruits
+unique_fruits = {'apple', 'banana', 'cherry'}
+```
+
+#### String Example
+```python
+# A sentence
+sentence = "The quick brown fox jumps over the lazy dog."
+```
+
+#### Array Example
+```python
+import array
+# Array of integers
+int_array = array.array('i', [1, 2, 3, 4, 5])
+```
+
+#### Namedtuple Example
+```python
+from collections import namedtuple
+# Named tuple for representing a point
+Point = namedtuple('Point', ['x', 'y'])
+point = Point(1, 2)
+```
+
+#### Deque Example
+```python
+from collections import deque
+# Deque for queue operations
+my_deque = deque(['a', 'b', 'c'])
+my_deque.append('d')
+my_deque.appendleft('z')
+```
+
+#### Defaultdict Example
+```python
+from collections import defaultdict
+# Defaultdict for counting
+count = defaultdict(int)
+count['apple'] += 1
+```
+
+Understanding these common data structures and their typical use cases will help you choose the right one for your needs in different programming scenarios.