Bagaimana cara melompat ke baris tertentu dalam file teks besar?

Apakah ada alternatif untuk kode di bawah ini:

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

Jika saya memproses file teks besar (~15MB)dengan baris yang tidak diketahui tetapi panjangnya berbeda, dan perlu melompat ke baris tertentu, nomor mana yang saya ketahui sebelumnya? Saya merasa tidak enak dengan memprosesnya satu per satu ketika saya tahu saya dapat mengabaikan setidaknya paruh pertama file. Mencari solusi yang lebih elegan jika ada.

linecache :

The linecacheModul memungkinkan seseorang untuk mendapatkan setiap baris dari file sumber Python, ketika mencoba untuk mengoptimalkan internal, menggunakan cache, kasus umum di mana banyak baris dibaca dari file tunggal. Ini digunakan oleh tracebackmodul untuk mengambil baris sumber untuk dimasukkan dalam pelacakan balik yang diformat ...

Anda tidak dapat melompat ke depan tanpa membaca file setidaknya sekali, karena Anda tidak tahu di mana letak baris baru. Anda bisa melakukan sesuatu seperti:

# 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])

Anda tidak benar-benar memiliki banyak opsi jika garisnya memiliki panjang yang berbeda ... sayangnya Anda perlu memproses karakter akhir baris untuk mengetahui kapan Anda maju ke baris berikutnya.

Anda dapat, bagaimanapun, secara dramatis mempercepat ini DAN mengurangi penggunaan memori dengan mengubah parameter terakhir menjadi "terbuka" menjadi sesuatu yang bukan 0.

0 berarti operasi pembacaan file tidak disangga, yang sangat lambat dan intensif disk. 1 berarti file tersebut memiliki buffering baris, yang akan menjadi peningkatan. Apa pun di atas 1 (katakanlah 8k .. yaitu: 8096, atau lebih tinggi) membaca potongan file ke dalam memori. Anda masih mengaksesnya for line in open(etc):, tetapi python hanya berjalan sedikit demi sedikit, membuang setiap potongan yang di-buffer setelah diproses.

Saya mungkin dimanjakan oleh ram yang melimpah, tapi 15 M tidaklah besar. Membaca ke dalam memori dengan readlines() adalah apa yang biasanya saya lakukan dengan file sebesar ini. Mengakses baris setelah itu sepele.

Saya heran tidak ada yang menyebutkan islice

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

atau jika Anda menginginkan seluruh file lainnya

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

atau jika Anda ingin setiap baris lain dari file tersebut

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

Karena tidak ada cara untuk menentukan panjang semua garis tanpa membacanya, Anda tidak punya pilihan selain mengulang semua garis sebelum garis mulai. Yang bisa Anda lakukan hanyalah membuatnya terlihat bagus. Jika file sangat besar maka Anda mungkin ingin menggunakan pendekatan berbasis generator:

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)

Catatan: indeks berbasis nol dalam pendekatan ini.

Jika Anda tidak ingin membaca seluruh file di memori .. Anda mungkin perlu membuat beberapa format selain teks biasa.

tentu saja itu semua tergantung pada apa yang Anda coba lakukan, dan seberapa sering Anda akan melompati file.

Misalnya, jika Anda akan berpindah ke baris berkali-kali dalam file yang sama, dan Anda tahu bahwa file tidak berubah saat bekerja dengannya, Anda dapat melakukan ini:
Pertama, lewati seluruh file, dan catat " seek-location "dari beberapa nomor-baris-kunci (seperti, pernah 1000 baris),
Kemudian jika Anda menginginkan baris 12005, lompat ke posisi 12000 (yang telah Anda rekam) kemudian baca 5 baris dan Anda akan mengenal Anda berada di baris 12005 dan seterusnya

Jika Anda mengetahui sebelumnya posisi di file (bukan nomor baris), Anda dapat menggunakan file.seek () untuk menuju ke posisi itu.

Edit : Anda dapat menggunakan fungsi linecache.getline (nama file, lineno) , yang akan mengembalikan konten baris lineno, tetapi hanya setelah membaca seluruh file ke dalam memori. Baik jika Anda mengakses baris secara acak dari dalam file (seperti yang mungkin ingin dilakukan python untuk mencetak traceback) tetapi tidak bagus untuk file 15MB.

Apa yang menghasilkan file yang ingin Anda proses? Jika itu adalah sesuatu di bawah kendali Anda, Anda dapat membuat indeks (baris mana di posisi mana.) Pada saat file ditambahkan. File indeks dapat berukuran baris tetap (spasi berisi atau 0 angka berlapis) dan pasti akan lebih kecil. Dan dengan demikian bisa dibaca dan diproses secara cepat.

• Jalur mana yang Anda inginkan ?.
• Hitung offset byte dari nomor baris terkait dalam file indeks (mungkin karena ukuran baris file indeks konstan).
• Gunakan seek atau apapun untuk langsung melompat untuk mendapatkan baris dari file indeks.
• Parse untuk mendapatkan offset byte untuk baris yang sesuai dari file aktual.

Saya memiliki masalah yang sama (perlu mengambil dari baris khusus file besar).

Tentunya, saya dapat setiap saat menjalankan semua catatan dalam file dan menghentikannya ketika penghitung akan sama dengan baris target, tetapi itu tidak bekerja secara efektif dalam kasus ketika Anda ingin mendapatkan jumlah jamak dari baris tertentu. Itu menyebabkan masalah utama diselesaikan - bagaimana menangani langsung ke tempat file yang diperlukan.

Saya menemukan keputusan berikutnya: Pertama saya menyelesaikan kamus dengan posisi awal setiap baris (kuncinya adalah nomor baris, dan nilai - panjang kumulatif baris sebelumnya).

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

akhirnya, fungsi tujuan:

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

t.seek (line_number) - perintah yang menjalankan pemangkasan file hingga awal baris. Jadi, jika Anda selanjutnya melakukan readline - Anda mendapatkan garis target Anda.

Dengan menggunakan pendekatan seperti itu, saya telah menghemat sebagian besar waktu.

Anda dapat menggunakan mmap untuk menemukan offset garis. MMap tampaknya menjadi cara tercepat untuk memproses file

contoh:

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

kemudian gunakan f.seek (offset) untuk berpindah ke baris yang Anda butuhkan

Apakah baris itu sendiri berisi informasi indeks? Jika konten setiap baris adalah seperti " <line index>:Data", maka seek()pendekatan tersebut dapat digunakan untuk melakukan pencarian biner melalui file tersebut, bahkan jika jumlahnya Dataadalah variabel. Anda akan mencari titik tengah file, membaca baris, memeriksa apakah indeksnya lebih tinggi atau lebih rendah dari yang Anda inginkan, dll.

Jika tidak, hal terbaik yang dapat Anda lakukan adalah adil readlines(). Jika Anda tidak ingin membaca semua 15MB, Anda dapat menggunakan sizehintargumen untuk setidaknya mengganti banyak readline()dengan jumlah panggilan ke yang lebih kecil readlines().

Jika Anda berurusan dengan file teks & berbasis sistem linux , Anda dapat menggunakan perintah linux.
Bagi saya, ini bekerja dengan baik!

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)

Berikut adalah contoh menggunakan 'readlines (sizehint)' untuk membaca potongan baris pada satu waktu. DNS menunjukkan solusi itu. Saya menulis contoh ini karena contoh lain di sini berorientasi pada garis tunggal.

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)

Tidak ada jawaban yang memuaskan, jadi berikut ini cuplikan kecil untuk membantu.

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()

Contoh penggunaan:

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!

Ini melibatkan melakukan banyak pencarian file, tetapi berguna untuk kasus di mana Anda tidak dapat memasukkan seluruh file ke dalam memori. Itu melakukan satu pembacaan awal untuk mendapatkan lokasi baris (jadi itu membaca seluruh file, tetapi tidak menyimpan semuanya di memori), dan kemudian setiap akses file mencari fakta.

Saya menawarkan potongan di atas di bawah lisensi MIT atau Apache atas kebijaksanaan pengguna.

Dapat menggunakan fungsi ini untuk mengembalikan baris n:

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