Python Enumerate: How to Use enumerate() with Index and Value

from typing import List, Tuple, Iterator, Any


def demonstrate_enumerate() -> None:
    """
    Basic enumerate usage patterns.
    """
    fruits = ["apple", "banana", "cherry", "date"]
    
    # Basic usage — index and value
    print("Basic enumerate:")
    for index, fruit in enumerate(fruits):
        print(f"  Index {index}: {fruit}")
    
    # Custom start value
    print("\nWith start=1:")
    for index, fruit in enumerate(fruits, start=1):
        print(f"  Item {index}: {fruit}")
    
    # What enumerate actually returns
    print("\nType of enumerate object:", type(enumerate(fruits)))
    print("As list:", list(enumerate(fruits)))
    print("As list with start=5:", list(enumerate(fruits, start=5)))


def enumerate_vs_range_len() -> None:
    """
    Compare enumerate with the range(len()) anti-pattern.
    """
    data = [10, 20, 30, 40, 50]
    
    # Anti-pattern: range(len(seq))
    print("Anti-pattern (range(len)):")
    for i in range(len(data)):
        print(f"  Index {i}: {data[i]}")
    
    # Correct pattern: enumerate
    print("\nCorrect pattern (enumerate):")
    for i, value in enumerate(data):
        print(f"  Index {i}: {value}")


def enumerate_different_iterables() -> None:
    """
    Show any iterable and returns an enumerate object yielding enumerate working with different iterable types.
    """
    # String
    print("String:")
    for i, char in enumerate("hello"):
        print(f"  {i}: {char}")
    
    # Tuple
    print("\nTuple:")
    for i, val in enumerate((100, 200, 300)):
        print(f"  {i}: {val}")
    
    # Dictionary — iterates over keys
    print("\nDictionary (keys only):")
    d = {"a": 1, "b": 2, "c": 3}
    for i, key in enumerate(d):
        print(f"  {i}: {key}")
    
    # Dictionary — keys and values
    print("\nDictionary (items):")
    for i, (key, value) in enumerate(d.items()):
        print(f"  {i}: {key} = {value}")
    
    # Generator
    print("\nGenerator:")
    gen = (x ** 2 for x in range(5))
    for i, square in enumerate(gen):
        print(f"  {i}: {square}")


demonstrate_enumerate()
enumerate_vs_range_len()
enumerate_different_iterables()

from typing import List, Iterator, Tuple


class EnumerateAnalyzer:
    """
    Analyzes enumerate behavior with different parameters
    and iterable types.
    """
    
    @staticmethod
    def show_start_parameter() -> None:
        """
        Demonstrate the start parameter.
        """
        items = ["first", "second", "third"]
        
        # Default start=0
        print("Default (start=0):")
        for i, item in enumerate(items):
            print(f"  {i}: {item}")
        
        # start=1 for human-readable numbering
        print("\nWith start=1:")
        for i, item in enumerate(items, start=1):
            print(f"  {i}: {item}")
        
        # start=10 for continuation
        print("\nWith start=10:")
        for i, item in enumerate(items, start=10):
            print(f"  {i}: {item}")
    
    @staticmethod
    def show_return_type() -> None:
        """
        Show what enumerate returns and how to consume it.
        """
        data = ["a", "b", "c"]
        enum_obj = enumerate(data)
        
        print(f"Type: {type(enum_obj)}")
        print(f"Is iterator: {hasattr(enum_obj, '__next__')}")
        
        # Consume as list
        print(f"As list: {list(enumerate(data))}")
        
        # Consume as dict
        print(f"As dict: {dict(enumerate(data))}")
        
        # Consume as tuple
        print(f"As tuple: {tuple(enumerate(data))}")
    
    @staticmethod
    def memory_comparison(seq: List[int]) -> dict:
        """
        Compare memory behavior of enumerate vs range(len()).
        """
        import sys
        
        # enumerate is an iterator — constant memory
        enum_obj = enumerate(seq)
        enum_size = sys.getsizeof(enum_obj)
        
        # list(enumerate()) allocates full list
        enum_list = list(enumerate(seq))
        list_size = sys.getsizeof(enum_list)
        
        # range(len()) with list access
        range_obj = range(len(seq))
        range_size = sys.getsizeof(range_obj)
        
        return {
            "enumerate_object_bytes": enum_size,
            "enumerate_list_bytes": list_size,
            "range_object_bytes": range_size,
            "sequence_length": len(seq),
            "recommendation": "Use enumerate() directly — do not convert to list"
        }


# Example
analyzer = EnumerateAnalyzer()
analyzer.show_start_parameter()
analyzer.show_return_type()

mem = analyzer.memory_comparison(list(range(10000)))
print(f"\nMemory for 10000 items:")
print(f"  enumerate object: {mem['enumerate_object_bytes']} bytes")
print(f"  enumerate as list: {mem['enumerate_list_bytes']} bytes")
print(f"  range object: {mem['range_object_bytes']} bytes")

from typing import List, Tuple, Dict, Any, Optional
from dataclasses import dataclass


@dataclass
class ProcessingResult:
    index: int
    value: Any
    status: str
    error: Optional[str] = None


class EnumeratePatterns:
    """
    Production patterns using enumerate().
    """
    
    @staticmethod
    def find_all_indices(data: List[Any], target: Any) -> List[int]:
        """
        Find all indices where a value appears.
        Replaces loop with data.index() which only finds first match.
        """
        return [i for i, val in enumerate(data) if val == target]
    
    @staticmethod
    def process_with_error_tracking(
        items: List[Any],
        processor: callable
    ) -> List[ProcessingResult]:
        """
        Process items while tracking which index failed.
        Critical for batch processing where partial failures must be reported.
        """
        results = []
        for i, item in enumerate(items):
            try:
                processor(item)
                results.append(ProcessingResult(
                    index=i, value=item, status="success"
                ))
            except Exception as e:
                results.append(ProcessingResult(
                    index=i, value=item, status="failed", error=str(e)
                ))
        return results
    
    @staticmethod
    def numbered_output(
        items: List[str],
        start: int = 1,
        separator: str = ". "
    ) -> str:
        """
        Create numbered list output for logging or display.
        """
        lines = [
            f"{i}{separator}{item}"
            for i, item in enumerate(items, start=start)
        ]
        return "\n".join(lines)
    
    @staticmethod
    def zip_with_index(*iterables) -> List[Tuple[int, ...]]:
        """
        Combine enumerate with zip for parallel iteration
        with a shared index.
        """
        return [
            (i, *values)
            for i, values in enumerate(zip(*iterables))
        ]
    
    @staticmethod
    def create_index_map(data: List[Any]) -> Dict[Any, List[int]]:
        """
        Create a mapping from values to their indices.
        Useful for fast lookup of all positions of a value.
        """
        index_map: Dict[Any, List[int]] = {}
        for i, val in enumerate(data):
            if val not in index_map:
                index_map[val] = []
            index_map[val].append(i)
        return index_map
    
    @staticmethod
    def sliding_window_with_index(
        data: List[Any],
        window_size: int
    ) -> List[Tuple[int, List[Any]]]:
        """
        Create indexed sliding windows over data.
        """
        windows = []
        for i, _ in enumerate(data):
            if i + window_size > len(data):
                break
            window = data[i:i + window_size]
            windows.append((i, window))
        return windows
    
    @staticmethod
    def diff_with_index(
        old: List[Any],
        new: List[Any]
    ) -> List[Tuple[int, Any, Any]]:
        """
        Compare two lists and return differences with indices.
        """
        diffs = []
        for i, (old_val, new_val) in enumerate(zip(old, new)):
            if old_val != new_val:
                diffs.append((i, old_val, new_val))
        return diffs


# Example: batch processing with error tracking
processor = EnumeratePatterns()

items = [10, 20, 0, 40, 50]
results = processor.process_with_error_tracking(
    items,
    lambda x: 100 / x
)

for r in results:
    if r.status == "failed":
        print(f"Item {r.index} ({r.value}): FAILED - {r.error}")
    else:
        print(f"Item {r.index} ({r.value}): OK")

# Example: numbered output
print("\n" + processor.numbered_output(["Buy milk", "Write code", "Deploy"]))

# Example: find all indices
print(f"\nIndices of 20: {processor.find_all_indices([10, 20, 30, 20, 40], 20)}")

import itertools
from typing import List


class IndexingComparison:
    """
    Compares different approaches to indexed iteration.
    """
    
    @staticmethod
    def anti_pattern_range_len(data: List[str]) -> None:
        """
        Anti-pattern: range(len(seq)).
        Fails with non-list iterables. Less readable.
        """
        for i in range(len(data)):
            print(f"  {i}: {data[i]}")
    
    @staticmethod
    def anti_pattern_manual_counter(data: List[str]) -> None:
        """
        Anti-pattern: manual counter variable.
        Error-prone — counter can be forgotten or mis-incremented.
        """
        i = 0
        for item in data:
            print(f"  {i}: {item}")
            i += 1
    
    @staticmethod
    def correct_enumerate(data: List[str]) -> None:
        """
        Correct: enumerate().
        Clean, safe, works with any iterable.
        """
        for i, item in enumerate(data):
            print(f"  {i}: {item}")
    
    @staticmethod
    def alternative_itertools_count(data: List[str], start: int = 0) -> None:
        """
        Alternative: itertools.count().
        Useful when you need an infinite counter or custom step.
        """
        for count, item in zip(itertools.count(start), data):
            print(f"  {count}: {item}")
    
    @staticmethod
    def alternative_underscore_discard(data: List[str]) -> None:
        """
        When you only need the value but want to skip enumerate.
        Use _ to discard the index.
        """
        for _, item in enumerate(data):
            print(f"  {item}")
        # Note: in this case, just use a plain for loop instead
    
    @staticmethod
    def compare_readability() -> dict:
        """
        Readability and safety comparison.
        """
        return {
            "range(len(seq))": {
                "readability": "poor",
                "safety": "fails with non-list iterables",
                "memory": "creates range object",
                "recommendation": "avoid — use enumerate instead"
            },
            "manual_counter": {
                "readability": "poor",
                "safety": "off-by-one risk, counter can be forgotten",
                "memory": "minimal",
                "recommendation": "avoid — use enumerate instead"
            },
            "enumerate()": {
                "readability": "excellent",
                "safety": "works with any iterable, no manual state",
                "memory": "lazy iterator, constant memory",
                "recommendation": "preferred approach"
            },
            "itertools.count()": {
                "readability": "good",
                "safety": "safe but overkill for simple cases",
                "memory": "lazy iterator",
                "recommendation": "use for infinite counters or custom steps"
            }
        }


# Example
comparison = IndexingComparison()
data = ["alpha", "beta", "gamma"]

print("Anti-pattern (range(len)):")
comparison.anti_pattern_range_len(data)

print("\nAnti-pattern (manual counter):")
comparison.anti_pattern_manual_counter(data)

print("\nCorrect (enumerate):")
comparison.correct_enumerate(data)

print("\nAlternative (itertools.count):")
comparison.alternative_itertools_count(data, start=1)