Indexing and Slicing in Python

Indexing and slicing are fundamental operations in Python that allow you to access and manipulate elements in ordered sequences like lists, strings, and tuples.

• Indexing → Accessing a single element
• Slicing → Extracting a portion of a sequence

Understanding these concepts is crucial for working with data structures efficiently.

---

1. Indexing in Python

How Indexing Works

• Python uses zero-based indexing (first element is at index 0).
• Negative indexing starts from -1 (last element).

Examples:

List Indexing

fruits = ["apple", "banana", "cherry", "date"]  
print(fruits[0])   # "apple"  
print(fruits[-1])  # "date"  

String Indexing

word = "Python"  
print(word[0])   # "P"  
print(word[-1])  # "n"  

Tuple Indexing

colors = ("red", "green", "blue")  
print(colors[1])   # "green"  
print(colors[-2])  # "green"  

Common Mistakes

• IndexError → Trying to access an out-of-range index.

  nums = [1, 2, 3]  
  print(nums[3])  # Error! (Valid indices: 0, 1, 2)  

---

2. Slicing in Python

Basic Slicing Syntax

sequence[start : stop : step]  

• start → Index where slicing begins (inclusive).
• stop → Index where slicing ends (exclusive).
• step → Interval between elements (default = 1).

Examples:

List Slicing

numbers = [0, 1, 2, 3, 4, 5]  
print(numbers[1:4])    # [1, 2, 3]  
print(numbers[::2])    # [0, 2, 4] (every 2nd element)  
print(numbers[::-1])   # [5, 4, 3, 2, 1, 0] (reverse)  

String Slicing

text = "Hello, World!"  
print(text[0:5])    # "Hello"  
print(text[7:-1])   # "World"  
print(text[::-1])   # "!dlroW ,olleH" (reverse)  

Tuple Slicing

letters = ('a', 'b', 'c', 'd', 'e')  
print(letters[1:4])   # ('b', 'c', 'd')  

Omitting Start/Stop/Step

• If start is omitted → Starts from 0.
• If stop is omitted → Goes till the end.
• If step is omitted → Defaults to 1.

nums = [1, 2, 3, 4, 5]  
print(nums[:3])   # [1, 2, 3]  
print(nums[2:])   # [3, 4, 5]  

---

3. Key Differences Between Indexing and Slicing

Feature	Indexing	Slicing
Returns	Single element	Sub-sequence (list, string, tuple)
Syntax	seq[index]	seq[start:stop:step]
Error	Raises IndexError if invalid	Returns empty sequence if invalid

---

4. Practical Use Cases

Extracting Substrings

filename = "report_2023.pdf"  
year = filename[6:10]  # "2023"  

Reversing a List

items = [1, 2, 3, 4]  
reversed_items = items[::-1]  # [4, 3, 2, 1]  

Skipping Elements

data = [10, 20, 30, 40, 50, 60]  
every_second = data[::2]  # [10, 30, 50]  

---

5. Common Mistakes & Best Practices

Mistakes to Avoid

1. Off-by-One Errors

   word = "Python"  
   print(word[0:6])  # "Python" (valid)  
   print(word[0:7])  # Still "Python" (but risky)  

2. Confusing Negative Indices

   nums = [1, 2, 3]  
   print(nums[-1])   # 3 (last element)  
   print(nums[-4])   # IndexError!  

Best Practices

✔ Prefer slicing over manual loops for sub-sequence extraction.
✔ Use negative indices for accessing elements from the end.
✔ Remember that slicing excludes the stop index.

---

Conclusion

• Indexing accesses individual elements using [index].
• Slicing extracts sub-sequences using [start:stop:step].
• Works on lists, strings, and tuples.

Key Takeaways:

✔ Python uses 0-based indexing and negative indexing (-1 = last element).
✔ Slicing includes start but excludes stop.
✔ Omitting start/stop defaults to the beginning/end of the sequence.

Now you can efficiently work with sequences in Python! 🚀