Python Enumerate: インデックス付きループの正しい方法

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
 
# Output:
# 0: apple
# 1: banana
# 2: cherry

# Without enumerate (less Pythonic)
colors = ['red', 'green', 'blue']
for i in range(len(colors)):
    print(f"Color {i} is {colors[i]}")
 
# With enumerate (Pythonic)
for i, color in enumerate(colors):
    print(f"Color {i} is {color}")

tasks = ['Review code', 'Write tests', 'Deploy']
for num, task in enumerate(tasks, start=1):
    print(f"Task #{num}: {task}")
 
# Output:
# Task #1: Review code
# Task #2: Write tests
# Task #3: Deploy

coordinates = [(10, 20), (30, 40), (50, 60)]
for idx, (x, y) in enumerate(coordinates):
    print(f"Point {idx}: x={x}, y={y}")

word = "Python"
for position, char in enumerate(word):
    print(f"Character at position {position}: {char}")
 
# Output:
# Character at position 0: P
# Character at position 1: y
# Character at position 2: t
# ...

config = {'host': 'localhost', 'port': 8080, 'debug': True}
 
# Enumerate keys
for i, key in enumerate(config):
    print(f"{i}: {key}")
 
# Enumerate key-value pairs
for i, (key, value) in enumerate(config.items()):
    print(f"{i}: {key} = {value}")

with open('data.txt', 'r') as file:
    for line_num, line in enumerate(file, start=1):
        if 'ERROR' in line:
            print(f"Error found on line {line_num}: {line.strip()}")

data = ['a', 'b', 'c']
 
# Method 1: enumerate (推奨)
for i, item in enumerate(data):
    print(i, item)
 
# Method 2: range(len()) (Pythonicでない)
for i in range(len(data)):
    print(i, data[i])
 
# Method 3: zip with range (過度に複雑)
for i, item in zip(range(len(data)), data):
    print(i, item)
 
# Method 4: manual counter (エラーが発生しやすい)
counter = 0
for item in data:
    print(counter, item)
    counter += 1

numbers = [10, 20, 30, 40]
 
# Add index to each element
indexed = [(i, n) for i, n in enumerate(numbers)]
# Result: [(0, 10), (1, 20), (2, 30), (3, 40)]
 
# Filter based on index
even_positions = [n for i, n in enumerate(numbers) if i % 2 == 0]
# Result: [10, 30]
 
# Transform with index
multiplied = [n * i for i, n in enumerate(numbers, start=1)]
# Result: [10, 40, 90, 160]

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
 
for rank, (name, score) in enumerate(zip(names, scores), start=1):
    print(f"#{rank}: {name} scored {score}")
 
# Output:
# #1: Alice scored 85
# #2: Bob scored 92
# #3: Charlie scored 78

items = ['first', 'second', 'third']
 
# Reverse the items, but indices still go 0, 1, 2
for i, item in enumerate(reversed(items)):
    print(f"{i}: {item}")
 
# Output:
# 0: third
# 1: second
# 2: first
 
# If you want descending indices, calculate them manually
length = len(items)
for i, item in enumerate(reversed(items)):
    actual_index = length - 1 - i
    print(f"{actual_index}: {item}")
 
# Output:
# 2: third
# 1: second
# 0: first

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
 
for row_idx, row in enumerate(matrix):
    for col_idx, value in enumerate(row):
        print(f"matrix[{row_idx}][{col_idx}] = {value}")

# enumerate returns an iterator
large_list = range(1_000_000)
enum_obj = enumerate(large_list)
print(type(enum_obj))  # <class 'enumerate'>
 
# Memory efficient - doesn't create a million tuples at once
for i, value in enum_obj:
    if i > 5:
        break
    print(i, value)

import timeit
 
data = list(range(10_000))
 
# Time enumerate
time_enum = timeit.timeit(
    'for i, x in enumerate(data): pass',
    globals={'data': data},
    number=1000
)
 
# Time range(len())
time_range = timeit.timeit(
    'for i in range(len(data)): x = data[i]',
    globals={'data': data},
    number=1000
)
 
print(f"enumerate: {time_enum:.4f}s")
print(f"range(len): {time_range:.4f}s")
# enumerate is typically 10-20% faster due to fewer lookups

# Wrong - causes unexpected behavior
items = [1, 2, 3, 4, 5]
for i, item in enumerate(items):
    if item % 2 == 0:
        items.remove(item)  # Modifies list during iteration
 
# Correct - collect indices first
items = [1, 2, 3, 4, 5]
to_remove = [i for i, item in enumerate(items) if item % 2 == 0]
for i in reversed(to_remove):
    items.pop(i)

# Wrong - tries to unpack the enumerate object itself
for item in enumerate(['a', 'b']):
    print(item)  # Prints: (0, 'a'), (1, 'b')
 
# Correct - unpack each tuple
for i, item in enumerate(['a', 'b']):
    print(i, item)

# Wrong - wastes memory
for i, item in list(enumerate(huge_dataset)):
    process(i, item)
 
# Correct - keep it as iterator
for i, item in enumerate(huge_dataset):
    process(i, item)

# Wrong - unnecessary complexity
for i, item in enumerate(items):
    print(item)  # Never uses i
 
# Correct - simple iteration
for item in items:
    print(item)

# Wrong - users see 0-based indexing
results = ['first', 'second', 'third']
for i, result in enumerate(results):
    print(f"{i}. {result}")  # 0. first, 1. second...
 
# Correct - users see natural numbering
for i, result in enumerate(results, start=1):
    print(f"{i}. {result}")  # 1. first, 2. second...

class Enumerate:
    def __init__(self, iterable, start=0):
        self.iterable = iter(iterable)
        self.count = start
 
    def __iter__(self):
        return self
 
    def __next__(self):
        value = next(self.iterable)
        result = (self.count, value)
        self.count += 1
        return result
 
# Using our implementation
items = ['x', 'y', 'z']
for i, item in Enumerate(items):
    print(i, item)

import csv
 
with open('sales.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row_num, row in enumerate(reader, start=2):  # start=2 accounts for header
        try:
            amount = float(row['amount'])
            if amount < 0:
                print(f"Warning: Negative amount on row {row_num}")
        except ValueError:
            print(f"Error: Invalid amount on row {row_num}: {row['amount']}")

def create_html_list(items):
    html = "<ol>\n"
    for i, item in enumerate(items, start=1):
        html += f'  <li id="item-{i}">{item}</li>\n'
    html += "</ol>"
    return html
 
tasks = ["Write code", "Review PR", "Deploy"]
print(create_html_list(tasks))

def process_dataset(data, batch_size=100):
    total = len(data)
    for i, record in enumerate(data):
        process_record(record)
 
        # Show progress every batch_size items
        if (i + 1) % batch_size == 0:
            progress = (i + 1) / total * 100
            print(f"Progress: {progress:.1f}% ({i + 1}/{total})")

def find_all_positions(text, substring):
    positions = [i for i, char in enumerate(text) if text[i:i+len(substring)] == substring]
    return positions
 
text = "Python is powerful. Python is popular. Python is everywhere."
positions = find_all_positions(text, "Python")
print(f"'Python' found at positions: {positions}")
# Output: 'Python' found at positions: [0, 20, 40]