Added tuples tutorial

Author: majid shahbaz

README.md

@@ -126,27 +126,58 @@
   4.2.4.2. Matrix Transpose (List Comprehension)
   4.2.4.3. Matrix Transformation Algorithms
 
-#### [4.3. Dictionaries]()
+#### [4.3. Dictionaries](https://github.com/Majid460/python_practice_part1/blob/main/src/datastructures/dict/dict.py)
 
 #### Quick Overview 
- 4.3.1. Dictionary Basics and Creation**
+ 4.3.1. Dictionary Basics and Creation
   4.3.1.1. Empty Dictionary Creation
   4.3.1.2. Dictionary with Elements
   4.3.1.3. Constructor Method
- 4.3.2. Accessing Dictionary Elements**
+ 4.3.2. Accessing Dictionary Elements
   4.3.2.1. Direct Key Access
   4.3.2.2. Multiple Access Methods
   4.3.2.3. Loop Iterations
   4.3.2.4. Dictionary Comprehension
- 4.3.3. Dictionary Properties**
+ 4.3.3. Dictionary Properties
   4.3.3.1. Ordering Behavior
   4.3.3.2. Key-Value Relationships
- 4.3.4. Modifying Dictionaries**
+ 4.3.4. Modifying Dictionaries
   4.3.4.1. Update Method
   4.3.4.2. Element Removal (pop, popitem, del, clear)
- 4.3.5. Dictionary Copying**
+ 4.3.5. Dictionary Copying
   4.3.5.1. Shallow vs Deep Copy
   4.3.5.2. Copy Methods
- 4.3.6. Nested Dictionaries**
+ 4.3.6. Nested Dictionaries
   4.3.6.1. Structure and Access
-  4.3.6.2. Nested Iteration
+  4.3.6.2. Nested Iteration
+
+#### [4.4. Tuples](https://github.com/Majid460/python_practice_part1/blob/main/src/datastructures/tuples/tuples.py)
+
+#### Quick Overview
+ 4.4.1. Tuple Basics and Creation
+  4.4.1.1. Basic Tuple Creation
+  4.4.1.2. Mixed Data Types
+  4.4.1.3. Tuple vs List Differences
+ 4.4.2. Tuple Operations
+  4.4.2.1. Index Access (Positive/Negative)
+  4.4.2.2. Range Slicing
+  4.4.2.3. Membership Testing
+ 4.4.3. Immutability and Workarounds
+  4.4.3.1. Converting to List for Modification
+  4.4.3.2. Adding Items (List Conversion)
+  4.4.3.3. Removing Items (List Conversion)
+  4.4.3.4. Deleting Entire Tuple
+  4.4.4. Tuple Unpacking**
+  4.4.4.1. Basic Unpacking
+ 4.4.4.2. Asterisk (*) Unpacking
+  4.4.4.3. Advanced Asterisk Patterns
+ 4.4.5. Looping Through Tuples
+  4.4.5.1. Index-Based For Loop
+  4.4.5.2. Simple For Loop
+  4.4.5.3. While Loop
+ 4.4.6. Joining Tuples
+  4.4.6.1. Concatenation with + Operator
+  4.4.6.2. Multiplication with * Operator
+ 4.4.7. Tuple Methods
+  4.4.7.1. count() Method
+  4.4.7.2. index() Method

src/datastructures/tuples/Readme.md

@@ -0,0 +1,293 @@
+# Python Tuple Tutorial
+
+A comprehensive guide to understanding and working with tuples in Python.
+
+## Table of Contents
+- [What are Tuples?](#what-are-tuples)
+- [Tuple Characteristics](#tuple-characteristics)
+- [Creating Tuples](#creating-tuples)
+- [Basic Tuple Operations](#basic-tuple-operations)
+- [Immutability and Workarounds](#immutability-and-workarounds)
+- [Tuple Unpacking](#tuple-unpacking)
+- [Looping Through Tuples](#looping-through-tuples)
+- [Joining Tuples](#joining-tuples)
+- [Tuple Methods](#tuple-methods)
+
+## What are Tuples?
+
+Tuples are Python's built-in data structure for storing **multiple items in a single variable**. They are similar to lists but with one crucial difference: **immutability**.
+
+### Basic Template
+```python
+this_tuple = ("a", "b", "c", 1, 4)
+```
+
+## Tuple Characteristics
+
+| Feature | Tuple | List |
+|---------|-------|------|
+| **Ordered** | ✅ Yes | ✅ Yes |
+| **Mutable** | ❌ No (Immutable) | ✅ Yes (Mutable) |
+| **Allow Duplicates** | ✅ Yes | ✅ Yes |
+| **Syntax** | `()` Round brackets | `[]` Square brackets |
+| **Indexing** | ✅ Yes | ✅ Yes |
+
+## Creating Tuples
+
+```python
+# Basic tuple with mixed data types
+this_tuple = ("a", "b", "c", 1, 4)
+print(f"This is basic tuple: {this_tuple}")
+# Output: ('a', 'b', 'c', 1, 4)
+
+print(f"Tuple type: {type(this_tuple)}")
+# Output: <class 'tuple'>
+```
+
+## Basic Tuple Operations
+
+### 1. Index Access
+```python
+this_tuple = ("a", "b", "c", 1, 4)
+
+# Positive indexing
+print(f"Index 1: {this_tuple[1]}") # b
+
+# Negative indexing (-1 means last element)
+print(f"Last element: {this_tuple[-1]}") # 4
+```
+
+### 2. Range Slicing
+```python
+# Range slicing (excludes end index)
+print(f"Range 1:4: {this_tuple[1:4]}") # ('b', 'c', 1)
+
+# Negative range slicing
+print(f"Negative range -4:-1: {this_tuple[-4:-1]}") # ('b', 'c', 1)
+```
+
+### 3. Membership Testing
+```python
+item = "Apple"
+tup = ("Banana", "Apple", "Orange", "Peach")
+
+if item in tup:
+ print(f"{item} is in the tuple")
+# Output: Apple is in the tuple
+```
+
+## Immutability and Workarounds
+
+Tuples are **immutable** - you cannot change them after creation. However, there are workarounds:
+
+### 1. Changing Items (Convert to List)
+```python
+tup = ("Banana", "Apple", "Orange", "Peach")
+
+# Convert to list → modify → convert back
+list_tup = list(tup)
+list_tup[1] = "Pear"
+tup_modified = tuple(list_tup)
+
+print(f"After changing: {tup_modified}")
+# Output: ('Banana', 'Pear', 'Orange', 'Peach')
+```
+
+### 2. Adding Items
+
+#### Method 1: Convert to List
+```python
+tuple_original = ("Banana", "Pear", "Orange", "Peach")
+
+# Convert → add → convert back
+temp_list = list(tuple_original)
+temp_list.append("Grapes")
+tuple_with_addition = tuple(temp_list)
+
+print(f"After adding: {tuple_with_addition}")
+# Output: ('Banana', 'Pear', 'Orange', 'Peach', 'Grapes')
+```
+
+#### Method 2: Tuple Concatenation
+```python
+tuple_a = ("q", "s", "d")
+tuple_b = ("r", "f", "g")
+
+tuple_a += tuple_b # Creates new tuple
+print(f"Concatenated: {tuple_a}")
+# Output: ('q', 's', 'd', 'r', 'f', 'g')
+```
+
+### 3. Removing Items
+```python
+tuple_original = ("Banana", "Pear", "Orange", "Peach", "Grapes")
+
+# Convert → remove → convert back
+temp_list = list(tuple_original)
+temp_list.remove("Grapes")
+tuple_after_removal = tuple(temp_list)
+
+print(f"After removing Grapes: {tuple_after_removal}")
+# Output: ('Banana', 'Pear', 'Orange', 'Peach')
+```
+
+### 4. Deleting Entire Tuple
+```python
+my_tuple = ("a", "b", "c")
+del my_tuple # Deletes the entire tuple object
+# print(my_tuple) # This would cause NameError
+```
+
+## Tuple Unpacking
+
+**Unpacking** allows you to assign tuple values to individual variables:
+
+### 1. Basic Unpacking
+```python
+tup = ("Banana", "Apple", "Orange", "Peach")
+(red, green, blue, white) = tup
+
+print(red) # Banana
+print(green) # Apple
+print(blue) # Orange
+print(white) # Peach
+```
+
+### 2. Using Asterisk (*) - Collect Remaining Items
+```python
+# When variables < values, use *
+(red, *green) = tup
+print(red) # Banana
+print(green) # ['Apple', 'Orange', 'Peach']
+```
+
+### 3. Asterisk in Middle
+```python
+fruits = ("apple", "mango", "papaya", "pineapple", "cherry")
+(green, *tropic, red) = fruits
+
+print(green) # apple
+print(tropic) # ['mango', 'papaya', 'pineapple']
+print(red) # cherry
+```
+
+## Looping Through Tuples
+
+### 1. Index-Based Loop
+```python
+fruits = ("apple", "mango", "papaya", "pineapple", "cherry")
+
+for i in range(len(fruits)):
+ print(fruits[i])
+```
+
+### 2. Simple For Loop
+```python
+for fruit in fruits:
+ print(fruit)
+```
+
+### 3. While Loop
+```python
+i = 0
+while i < len(fruits):
+ print(fruits[i])
+ i += 1
+```
+
+## Joining Tuples
+
+### 1. Using + Operator
+```python
+fruits = ("apple", "mango", "papaya")
+more_fruits = ("Banana", "Pear", "Orange")
+
+all_fruits = fruits + more_fruits
+print(all_fruits)
+# Output: ('apple', 'mango', 'papaya', 'Banana', 'Pear', 'Orange')
+```
+
+### 2. Using * Operator (Multiplication)
+```python
+fruits = ("apple", "mango", "papaya")
+doubled_fruits = fruits * 2
+
+print(doubled_fruits)
+# Output: ('apple', 'mango', 'papaya', 'apple', 'mango', 'papaya')
+```
+
+## Tuple Methods
+
+Python provides **only 2 built-in methods** for tuples (due to immutability):
+
+### 1. `count()` - Count Occurrences
+```python
+this_tuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
+
+count_of_5 = this_tuple.count(5)
+print(f"5 appears {count_of_5} times")
+# Output: 5 appears 2 times
+```
+
+### 2. `index()` - Find First Occurrence
+```python
+this_tuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
+
+first_8_index = this_tuple.index(8)
+print(f"First occurrence of 8 is at index {first_8_index}")
+# Output: First occurrence of 8 is at index 3
+```
+
+**⚠️ Warning**: `index()` raises an exception if the value is not found!
+
+## Key Differences: Tuple vs List
+
+| Aspect | Tuple | List |
+|--------|-------|------|
+| **Mutability** | Immutable (cannot change) | Mutable (can change) |
+| **Performance** | Faster (optimized) | Slightly slower |
+| **Use Case** | Fixed data, coordinates | Dynamic data |
+| **Methods** | Only 2 (`count`, `index`) | Many (`append`, `remove`, etc.) |
+| **Memory** | Less memory usage | More memory usage |
+
+## When to Use Tuples
+
+1. **Fixed data**: Coordinates `(x, y)`, RGB colors `(255, 0, 0)`
+2. **Dictionary keys**: Tuples can be dict keys (immutable), lists cannot
+3. **Function returns**: Return multiple values from functions
+4. **Data integrity**: When you want to prevent accidental changes
+5. **Performance**: When you need faster iteration over immutable data
+
+## Best Practices
+
+1. **Use tuples for fixed collections** that won't change
+2. **Use lists for dynamic collections** that need modification
+3. **Remember the conversion pattern**: `tuple → list → modify → tuple`
+4. **Use unpacking** to make code more readable
+5. **Handle exceptions** when using `index()` method
+
+## Common Use Cases
+
+```python
+# Coordinates
+point = (10, 20)
+x, y = point
+
+# RGB Color
+color = (255, 0, 128)
+red, green, blue = color
+
+# Database record
+record = ("John", 25, "Engineer", 50000)
+name, age, job, salary = record
+
+# Multiple return values
+def get_name_age():
+ return "Alice", 30
+
+name, age = get_name_age()
+```
+
+---
+
+**Remember**: Tuples are **immutable by design** - this is a feature, not a limitation! Use them when you want to ensure data doesn't accidentally change.