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

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! 🚀