如何按字符读取列表并定位至第10000字符读取后续300字符？

Hey there! Let's break this down for you. When you use readlines() to load your file into list d, each element in the list is a full line from the file—including newline characters (\n) which count towards the total character count. Here are two practical approaches to locate the 10000th character and read the next 300 characters after it:

Approach 1: Combine Lines into a Single String (Best for Small/Medium Files) #

This is the simplest method if your file isn't extremely large. We'll first join all lines in d into one continuous string, then use Python's string slicing to grab the exact characters you need.

Important Note: Python uses 0-based indexing. So the 10000th character (1-based count) sits at index 9999 in the string.

# Merge the list of lines into a single continuous string
full_text = ''.join(d)

# Calculate start and end indices for slicing
start_idx = 9999  # 0-based index of the 10000th character
end_idx = start_idx + 300

# Extract the target character range
target_chars = full_text[start_idx:end_idx]

# Print or process your result
print(target_chars)

Approach 2: Iterate Through Lines (Best for Large Files) #

If your file is huge, merging all lines into one string could hog too much memory. Instead, we'll track the total number of characters as we loop through each line, find which line contains the 10000th character, then collect enough characters from that line and subsequent lines to hit your 300-character goal.

total_chars = 0
target_start = 10000  # 1-based position of the first character we want
target_total = 300    # Total characters to read after (and including) target_start
result = []

for line_num, line in enumerate(d):
    line_length = len(line)
    
    # Check if the current line holds our target starting character
    if total_chars + line_length >= target_start:
        # Convert to 0-based index within the current line
        start_in_line = target_start - total_chars - 1
        # Grab the part of the line starting from our target
        chunk = line[start_in_line:]
        result.append(chunk)
        chars_collected = len(chunk)
        
        # Keep grabbing from next lines if we haven't hit 300 characters yet
        if chars_collected < target_total:
            for next_line in d[line_num + 1:]:
                if chars_collected >= target_total:
                    break
                # Take only the remaining characters we need
                take_amount = target_total - chars_collected
                next_chunk = next_line[:take_amount]
                result.append(next_chunk)
                chars_collected += len(next_chunk)
        break
    # Update total character count if we haven't reached the target line yet
    total_chars += line_length

# Combine all collected chunks into the final result string
target_chars = ''.join(result)
print(target_chars)

Key Reminders #

• Newline characters (\n) count as individual characters, so they'll affect your position calculations.
• If your file has fewer than 10300 characters total, the code will just return whatever is available from the 10000th character to the end of the file.

内容的提问来源于stack exchange，提问作者ceins