Как перейти к определенной строке в огромном текстовом файле?

Есть ли альтернативы приведенному ниже коду:

startFromLine = 141978 # or whatever line I need to jump to

urlsfile = open(filename, "rb", 0)

linesCounter = 1

for line in urlsfile:
    if linesCounter > startFromLine:
        DoSomethingWithThisLine(line)

    linesCounter += 1

Если я обрабатываю огромный текстовый файл (~15MB)со строками неизвестной, но разной длины, и мне нужно перейти к определенной строке, какой номер я знаю заранее? Я чувствую себя плохо, обрабатывая их один за другим, когда знаю, что могу проигнорировать хотя бы первую половину файла. Ищу более элегантное решение, если оно есть.

linecache :

linecacheМодуль позволяет получить любую строку из исходного файла Python, при попытке оптимизировать внутренне, используя кэш, общий случай , когда многие линии считываются из одного файла. Это используется tracebackмодулем для получения исходных строк для включения в отформатированную трассировку ...

Вы не можете продвигаться вперед, не прочитав файл хотя бы один раз, так как вы не знаете, где находятся разрывы строк. Вы можете сделать что-то вроде:

# Read in the file once and build a list of line offsets
line_offset = []
offset = 0
for line in file:
    line_offset.append(offset)
    offset += len(line)
file.seek(0)

# Now, to skip to line n (with the first line being line 0), just do
file.seek(line_offset[n])

У вас действительно не так много вариантов, если строки имеют разную длину ... вам, к сожалению, нужно обработать символы окончания строки, чтобы знать, когда вы перешли к следующей строке.

Однако вы можете значительно ускорить это И уменьшить использование памяти, изменив последний параметр на «open» на значение, отличное от 0.

0 означает, что операция чтения файла не буферизуется, что очень медленно и занимает много места на диске. 1 означает, что файл буферизирован по строкам, что было бы улучшением. Все, что выше 1 (скажем, 8k ... то есть: 8096 или выше), читает фрагменты файла в память. Вы по-прежнему for line in open(etc):получаете к нему доступ , но python работает только понемногу, отбрасывая каждый буферизованный фрагмент после его обработки.

Я наверное избалован обильным тараном, но 15 М - это не так уж и много. Чтение в память с помощью readlines() - это то, что я обычно делаю с файлами такого размера. Доступ к строке после этого тривиален.

Я удивлен, что никто не упомянул islice

line = next(itertools.islice(Fhandle,index_of_interest,index_of_interest+1),None) # just the one line

или если вы хотите, чтобы весь остальной файл

rest_of_file = itertools.islice(Fhandle,index_of_interest)
for line in rest_of_file:
    print line

или если вы хотите, чтобы каждая вторая строка из файла

rest_of_file = itertools.islice(Fhandle,index_of_interest,None,2)
for odd_line in rest_of_file:
    print odd_line

Поскольку невозможно определить длину всех строк, не прочитав их, у вас нет другого выбора, кроме как перебрать все строки перед вашей начальной строкой. Все, что вы можете сделать, это сделать так, чтобы он выглядел красиво. Если файл действительно огромен, вы можете использовать подход на основе генератора:

from itertools import dropwhile

def iterate_from_line(f, start_from_line):
    return (l for i, l in dropwhile(lambda x: x[0] < start_from_line, enumerate(f)))

for line in iterate_from_line(open(filename, "r", 0), 141978):
    DoSomethingWithThisLine(line)

Примечание: при таком подходе индекс равен нулю.

Если вы не хотите читать весь файл в памяти ... вам может потребоваться какой-нибудь формат, отличный от обычного текста.

конечно, все зависит от того, что вы пытаетесь сделать, и как часто вы будете перепрыгивать через файл.

Например, если вы собираетесь много раз переходить к строкам в одном и том же файле и знаете, что файл не изменяется во время работы с ним, вы можете сделать это:
сначала пройти через весь файл и записать " seek-location "некоторых номеров ключевых строк (например, когда-либо 1000 строк).
Затем, если вы хотите строку 12005, перейдите на позицию 12000 (которую вы записали), затем прочтите 5 строк, и вы узнаете себя в очереди 12005 и так далее

Если вы заранее знаете позицию в файле (а не номер строки), вы можете использовать file.seek () для перехода к этой позиции.

Изменить : вы можете использовать функцию linecache.getline (имя файла, белье) , которая вернет содержимое строки белье, но только после чтения всего файла в память. Хорошо, если вы произвольно обращаетесь к строкам из файла (как сам python может захотеть распечатать трассировку), но не подходит для файла размером 15 МБ.

Что создает файл, который вы хотите обработать? Если это что-то под вашим контролем, вы можете сгенерировать индекс (какая строка в какой позиции) во время добавления файла. Индексный файл может иметь фиксированный размер строки (заполненные пробелами или 0 числа) и определенно будет меньше. И поэтому их можно быстро читать и обрабатывать.

• Какая линия вам нужна?
• Вычислить байтовое смещение соответствующего номера строки в индексном файле (возможно, потому что размер строки индексного файла постоянный).
• Используйте поиск или что-то еще, чтобы напрямую перейти к строке из индексного файла.
• Выполните синтаксический анализ, чтобы получить смещение в байтах для соответствующей строки фактического файла.

У меня была такая же проблема (нужно получить из огромной строки файла).

Конечно, я могу каждый раз пробегать все записи в файле и останавливать его, когда счетчик будет равен целевой строке, но это не работает эффективно в случае, когда вы хотите получить множественное количество определенных строк. Это привело к решению главной проблемы - как обращаться непосредственно к нужному месту файла.

Я узнал следующее решение: сначала я заполнил словарь с начальной позицией каждой строки (ключ - номер строки, а значение - суммарная длина предыдущих строк).

t = open(file,’r’)
dict_pos = {}

kolvo = 0
length = 0
for each in t:
    dict_pos[kolvo] = length
    length = length+len(each)
    kolvo = kolvo+1

в конечном итоге прицельная функция:

def give_line(line_number):
    t.seek(dict_pos.get(line_number))
    line = t.readline()
    return line

t.seek (номер_строки) - команда, выполняющая обрезку файла до начала строки. Итак, если вы в следующий раз зафиксируете строку чтения - вы получите целевую строку.

Используя такой подход, я сэкономил значительную часть времени.

Вы можете использовать mmap, чтобы найти смещение линий. MMap кажется самым быстрым способом обработки файла

пример:

with open('input_file', "r+b") as f:
    mapped = mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ)
    i = 1
    for line in iter(mapped.readline, ""):
        if i == Line_I_want_to_jump:
            offsets = mapped.tell()
        i+=1

затем используйте f.seek (смещения), чтобы перейти к нужной строке

Содержат ли сами строки какую-либо информацию индекса? Если бы содержание каждой строки было чем-то вроде " <line index>:Data", то seek()подход можно было бы использовать для выполнения двоичного поиска по файлу, даже если количествоData переменных. Вы должны искать середину файла, читать строку, проверять, выше или ниже ее индекс, чем тот, который вам нужен, и т. Д.

В противном случае лучшее, что вы можете сделать, - это просто readlines(). Если вы не хотите читать все 15 МБ, вы можете использовать sizehintаргумент, чтобы, по крайней мере, заменить много readline()s меньшим количеством вызовов readlines().

Если вы имеете дело с текстовым файлом, основанным на системе Linux , вы можете использовать команды linux.
Для меня это сработало!

import commands

def read_line(path, line=1):
    return commands.getoutput('head -%s %s | tail -1' % (line, path))

line_to_jump = 141978
read_line("path_to_large_text_file", line_to_jump)

Вот пример использования readlines (sizehint) для чтения фрагмента строк за раз. DNS указал на это решение. Я написал этот пример, потому что другие примеры здесь ориентированы на одну строку.

def getlineno(filename, lineno):
    if lineno < 1:
        raise TypeError("First line is line 1")
    f = open(filename)
    lines_read = 0
    while 1:
        lines = f.readlines(100000)
        if not lines:
            return None
        if lines_read + len(lines) >= lineno:
            return lines[lineno-lines_read-1]
        lines_read += len(lines)

print getlineno("nci_09425001_09450000.smi", 12000)

Ни один из ответов не является особенно удовлетворительным, поэтому вот небольшой фрагмент, который поможет.

class LineSeekableFile:
    def __init__(self, seekable):
        self.fin = seekable
        self.line_map = list() # Map from line index -> file position.
        self.line_map.append(0)
        while seekable.readline():
            self.line_map.append(seekable.tell())

    def __getitem__(self, index):
        # NOTE: This assumes that you're not reading the file sequentially.  
        # For that, just use 'for line in file'.
        self.fin.seek(self.line_map[index])
        return self.fin.readline()

Пример использования:

In: !cat /tmp/test.txt

Out:
Line zero.
Line one!

Line three.
End of file, line four.

In:
with open("/tmp/test.txt", 'rt') as fin:
    seeker = LineSeekableFile(fin)    
    print(seeker[1])
Out:
Line one!

Это включает в себя множество поисков файлов, но это полезно в тех случаях, когда вы не можете уместить весь файл в памяти. Он выполняет одно начальное чтение, чтобы получить расположение строк (так что он читает весь файл, но не сохраняет его в памяти), а затем каждый доступ выполняет поиск файла постфактум.

Я предлагаю приведенный выше фрагмент под лицензией MIT или Apache на усмотрение пользователя.

Можно использовать эту функцию для возврата строки n:

def skipton(infile, n):
    with open(infile,'r') as fi:
        for i in range(n-1):
            fi.next()
        return fi.next()