거대한 텍스트 파일에서 특정 줄로 이동하는 방법은 무엇입니까?

아래 코드에 대한 대안이 있습니까?

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모듈은 하나의 파일에서 여러 줄을 읽는 일반적인 경우 인 캐시를 사용하여 내부적으로 최적화를 시도하면서 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):하지만 파이썬은 한 번에 조금만 이동하여 처리 된 각 버퍼링 된 청크를 버립니다.

나는 아마도 풍부한 램에 의해 망쳐 졌을 것입니다. 그러나 15M은 크지 않습니다. 로 메모리로 읽는 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)

참고 :이 접근 방식에서는 인덱스가 0입니다.

메모리에있는 전체 파일을 읽지 않으려면 .. 일반 텍스트 이외의 다른 형식이 필요할 수 있습니다.

물론 그것은 당신이 무엇을하려고하는지, 얼마나 자주 파일을 건너 뛸 것인지에 달려 있습니다.

예를 들어 같은 파일에서 여러 줄로 건너 뛰고 작업하는 동안 파일이 변경되지 않는다는 것을 알고 있다면 다음과 같이 할 수 있습니다.
먼저 전체 파일을 통과하고 " 몇 개의 키-라인 번호 (예 : 1000 줄)의 탐색 위치 "를 입력 한
다음 12005 줄을 원할 경우 12000 (기록한) 위치로 이동 한 다음 5 줄을 읽으면 알 수 있습니다. 12005 줄에 있습니다.

파일의 위치 (줄 번호가 아니라)를 미리 알고 있다면 file.seek () 를 사용 하여 해당 위치로 이동할 수 있습니다 .

편집 : lineno 라인의 내용을 반환 하는 linecache.getline (filename, lineno) 함수를 사용할 수 있지만 전체 파일을 메모리로 읽은 후에 만 ​​가능합니다. 파일 내에서 무작위로 행에 액세스하는 경우 (파이썬 자체가 역 추적을 인쇄하려고 할 수 있으므로) 좋지만 15MB 파일에는 좋지 않습니다.

처리하려는 파일을 생성하는 것은 무엇입니까? 그것이 당신의 통제하에 있다면, 파일이 추가 될 때 인덱스 (어떤 줄이 어느 위치에 있는지)를 생성 할 수 있습니다. 인덱스 파일은 고정 된 라인 크기 (공백 또는 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 (line_number) – 줄 시작까지 파일 정리를 실행하는 명령입니다. 따라서 다음에 readline을 커밋하면 목표 행을 얻습니다.

이러한 접근 방식을 사용하여 상당한 시간을 절약했습니다.

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 (offsets)를 사용하여 필요한 행으로 이동하십시오.

행 자체에 색인 정보가 포함되어 있습니까? 각 줄의 내용이 " <line index>:Data"와 seek()같으면 양 Data이 가변적 이더라도 파일을 통해 이진 검색을 수행하는 데 접근 방식을 사용할 수 있습니다 . 파일의 중간 지점을 찾고, 한 줄을 읽고, 색인이 원하는 것보다 높거나 낮은 지 확인하는 등의 작업을 수행합니다.

그렇지 않으면 할 수있는 최선의 방법은 readlines(). 15MB를 모두 읽지 않으려면 sizehint인수를 사용하여 최소한 많은 readline()s를 readlines().

linux system 기반 의 텍스트 파일을 다루는 경우 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()