Summary
This chapter covers how to access and extract parts of sequences using zero-based and negative indexing, including single-element indexing, range slicing with start:stop:step (with exclusive stop), out-of-bounds safety, negative steps for reversing, and the immutability of strings.

General domain of usage
Text processing

Strings are sequences: each character has a position (an **index**). Python uses **zero-based** indexing, so the first character is at index `0`. You can take single characters with **indexing** and ranges of characters with **slicing**.

## Indexing

Use square brackets with a single position.


s = "python"
print(s[0])    # 'p'   (first character)
print(s[5])    # 'n'   (sixth character)

s = "python"
print(s[-1])   # 'n'   (last character)
print(s[-2])   # 'o'   (second from the end)

Indexing must hit an existing position, otherwise you get `IndexError`.


s = "python"
print(s[10])  # IndexError: string index out of range

Also, strings are **immutable**, so you can read `s[i]` but not assign to it.

s = "python"
s[0] = 'P'  # TypeError: 'str' object does not support item assignment

## Slicing

A slice uses `start:stop:step` and returns a **new** string. `stop` is **exclusive** (it's not included).


s = "python"
print(s[1:4])    # 'yth'   (indices 1,2,3)
print(s[:4])     # 'pyth'  (start defaults to 0)
print(s[3:])     # 'hon'   (stop defaults to len(s))
print(s[::2])    # 'pto'   (every 2nd character)

Slices are **forgiving**: going past the ends just trims to valid bounds (no error).


### Negative Indices and Reversing

You can mix negative indices in slices, and a negative `step` walks backward.


s = "python"
print(s[-3:])    # 'hon'   (last three)
print(s[::-1])   # 'nohtyp'  (reverse)

`step` cannot be `0`. Leaving out `step` implies `1`. Leaving out `start` or `stop` means "from the beginning" / "to the end".

Note

Which statement **raises an error** for `u = "hello"`?

Gain a solid understanding of Python's core data types and learn how to work with them effectively. Explore numbers, booleans, and strings through hands-on exercises and practical examples. Build confidence in performing basic operations and develop the foundational skills needed to write clean and efficient Python code.

Discover the essentials of numerical data types in Python and learn how to work with integers and floating-point numbers. Master basic arithmetic operations, explore the concept of immutability, and get hands-on experience using Python's built-in functions and tools to handle numbers efficiently in real-world scenarios.

Gain a clear understanding of the Boolean data type, a specialized subtype of numeric data that represents truth values. Although it may seem challenging at first, mastering Booleans is essential for writing logical and efficient programs. This section will help you confidently apply Boolean logic to real-world programming scenarios.

Strings allow you to work with text in Python, from displaying messages to processing user input. You'll explore how to create, modify, and manipulate strings effectively. Understanding strings is essential for writing interactive programs and communicating information clearly through your code.

Learn how to handle data types effectively to ensure accuracy and consistency in your programs. Convert values to the appropriate type, clean text before comparison, and separate numeric operations from text formatting. You'll also discover how to manage missing data deliberately and handle human-readable text differently from raw input, achieving reliable, consistent, and easy-to-read results.

Indexing and Slicing

Indexing

Slicing

Negative Indices and Reversing

1. What value will this code output?

2. What value will this code output?

3. Which statement raises an error for `u = "hello"`?