Strict Rightmost Substring Lookup in Python: Location with rindex()

1. Method Signature & Parameters 🔝

The standard CPython signature for str.rindex() is:

str.rindex(sub, start=0, end=sys.maxsize, /)

2. Core Mechanics & 0-Based Rightmost Offsets 🔝

Like all Python sequence methods, str.rindex() calculates its return offset from index 0 at the beginning of the string. Searching from the right does not return a reverse or negative index; it returns the highest standard index where the target substring begins.

sentence = "Find the last apple in the apple orchard"

# 'apple' appears at index 14 and index 27
last_pos = sentence.rindex("apple")
first_pos = sentence.index("apple")

print("First occurrence (index): ", first_pos)  # 14
print("Last occurrence  (rindex):", last_pos)   # 27

3. Method Comparison: rindex() vs. rfind() vs. index() 🔝

Choosing between Python's four substring positioning methods depends on two architectural decisions: search direction (left vs. right) and error handling philosophy (sentinel -1 vs. ValueError exception):

4. Robust ValueError Exception Handling 🔝

Because str.rindex() throws an exception when the search target is missing, wrap invocations in structured try-except blocks when handling untrusted or variable user inputs:

def locate_tail_token(payload: str, target: str) -> int | None:
    try:
        return payload.rindex(target)
    except ValueError:
        print(f"Target '{target}' not present in payload.")
        return None

pos1 = locate_tail_token("config.yaml", ".")       # Returns 6
pos2 = locate_tail_token("config_yaml", ".")       # Handles ValueError gracefully

5. Constraining Search Windows with start and end Offsets 🔝

The optional start and end parameters allow you to constrain searches to specific substrings without creating intermediate string slice objects, preserving memory and execution efficiency:

log_entry = "error1: info; error2: critical; error3: debug"

# Search within the first 25 characters [0:25]
range_pos = log_entry.rindex("error", 0, 25)
print("Last error in [0:25]:", range_pos)  # Index 14 (error2)

# Search with negative start boundary (last 15 characters)
tail_pos = log_entry.rindex("error", -15)
print("Last error in tail:  ", tail_pos)   # Index 32 (error3)

6. Real-World Engineering Recipes 🔝

Recipe 1: Strict File Name and Extension Extraction

In data pipelines where files must possess valid extensions, rindex() enforces validation by requiring the dot separator:

def strict_extract_extension(filepath: str) -> str:
    try:
        dot_idx = filepath.rindex(".")
        if dot_idx == 0 or filepath[dot_idx - 1] == "/":
            raise ValueError("Hidden file without extension")
        return filepath[dot_idx + 1:]
    except ValueError as err:
        raise ValueError(f"Malformed filename '{filepath}': {err}")

print("Extension:", strict_extract_extension("reports/financial_2026.pdf"))
# Output: Extension: pdf

Recipe 2: Slicing Text After the Last Delimiter

Isolate the filename from a deeply nested filesystem hierarchy without importing external OS modules:

def get_basename(path: str) -> str:
    try:
        slash_pos = path.rindex("/")
        return path[slash_pos + 1:]
    except ValueError:
        return path

sample_path = "user/documents/reports/summary.pdf"
print("Base name:", get_basename(sample_path))
# Output: Base name: summary.pdf

Recipe 3: Parsing Trailing URL Endpoint Identifiers

Extract resource IDs from REST API paths by locating the rightmost forward slash:

endpoint = "https://api.plus2net.com/v2/users/84920"
last_slash = endpoint.rindex("/")
user_id = endpoint[last_slash + 1:]
print("Extracted User ID:", user_id)  # 84920

7. Common Pitfalls & Boundary Traps 🔝

data = "Apple and apple"
try:
    data.rindex("APPLE")
except ValueError:
    print("Uppercase 'APPLE' not found due to case sensitivity.")

# Case-insensitive rightmost lookup
ci_index = data.casefold().rindex("APPLE".casefold())
print("Case-insensitive index:", ci_index)  # 10

8. Production Implementation & Self-Checking Assertions 🔝

Run this self-contained test suite to verify rindex() edge cases, offset ranges, and exception guarantees:

class RightIndexVerifier:
    @staticmethod
    def safe_rindex(source: str, target: str) -> int | None:
        try:
            return source.rindex(target)
        except ValueError:
            return None

    @staticmethod
    def extract_tail(source: str, sep: str) -> str:
        try:
            idx = source.rindex(sep)
            return source[idx + len(sep):]
        except ValueError:
            return source

# Self-checking unit assertions
verifier = RightIndexVerifier()

# Test 1: Standard rightmost offset
assert verifier.safe_rindex("banana", "a") == 5
assert verifier.safe_rindex("banana", "na") == 4

# Test 2: Missing target returns None via handled ValueError
assert verifier.safe_rindex("banana", "z") is None

# Test 3: Direct ValueError verification
try:
    "hello world".rindex("python")
    assert False, "ValueError should have been raised"
except ValueError:
    pass

# Test 4: Substring extraction after delimiter
assert verifier.extract_tail("/usr/local/bin/python3", "/") == "python3"
assert verifier.extract_tail("standalone", "/") == "standalone"

print("All str.rindex() unit assertions passed successfully!")

Practice in Google Colab & GitHub 🔝

Open in Google Colab View on GitHub

Run all rightmost substring lookup and ValueError exception handling examples interactively, contrast rindex() with rfind() and index(), test slice boundaries, and extract tokens in Google Colab.

More Details & Related Guides 🔝

• str.index() Function — Leftmost substring position lookup raising ValueError.
• str.rfind() Function — Rightmost substring search returning -1 when missing.
• str.find() Function — Leftmost substring search returning -1 when missing.
• str.rpartition() Function — 3-tuple tail splitting around the rightmost delimiter.
• str.rsplit() Function — Right-to-left string tokenization with maxsplit controls.
• Python String Methods Overview — Complete reference of built-in string methods.

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: