Büyük bir dosya satır satır nasıl okunur?

Tüm bir dosyanın her satırı üzerinden yineleme yapmak istiyorum. Bunu yapmanın bir yolu, tüm dosyayı okumak, bir listeye kaydetmek ve daha sonra ilgilenilen çizgiyi aşmaktır. Bu yöntem çok fazla bellek kullanıyor, bu yüzden bir alternatif arıyorum.

Kodum şu ana kadar:

for each_line in fileinput.input(input_file):
    do_something(each_line)

    for each_line_again in fileinput.input(input_file):
        do_something(each_line_again)

Bu kodu yürütülmesi bir hata mesajı verir: device active.

Herhangi bir öneri?

Amaç çift bilge dize benzerliğini hesaplamak, yani dosyadaki her satır için, diğer satırlarla Levenshtein mesafesini hesaplamak istiyorum.

Bir dosyayı okumak için doğru, tamamen Pythonic yolu şudur:

with open(...) as f:
    for line in f:
        # Do something with 'line'

withAçılması ve bir istisna iç blokta yükseltilir edenler de dahil, dosyayı kapatırken deyim kolları. for line in fDavranır dosya nesnesi fBüyük dosyaları hakkında endişe zorunda kalmamak için otomatik I / O ve bellek yönetimini tamponlu kullanır ki, bir iterable olarak.

Bunu yapmanın tek ve tercihen tek bir yolu olmalı.

Sıralı düzende iki bellek verimli yol (birincisi en iyisi) -

1. kullanımı with - python 2.5 ve üstü tarafından desteklenir
2. kullanımı yieldgerçekten okumak için ne kadar üzerinde kontrole sahip isterseniz

1. kullanımı with

withbüyük dosyaları okumak için güzel ve verimli bir pythonic yoludur. avantajları - 1) dosya nesnesi withyürütme bloğundan çıktıktan sonra otomatik olarak kapatılır . 2) withblok içinde istisna işleme . 3) bellek fordöngüsü fdosya nesnesi boyunca satır satır yinelenir . dahili olarak IO (maliyetli IO işlemlerinde optimize etmek için) ve bellek yönetimini tamponluyor.

with open("x.txt") as f:
    for line in f:
        do something with data

2. kullanımı yield

Bazen her bir yinelemede ne kadar okunacağı üzerinde daha ayrıntılı bir denetim istenebilir. Bu durumda iter ve verimi kullanın . Bu yöntemle dosyanın sonunda dosyanın kapatılması gerektiği unutulmamalıdır.

def readInChunks(fileObj, chunkSize=2048):
    """
    Lazy function to read a file piece by piece.
    Default chunk size: 2kB.
    """
    while True:
        data = fileObj.read(chunkSize)
        if not data:
            break
        yield data

f = open('bigFile')
for chuck in readInChunks(f):
    do_something(chunk)
f.close()

Tuzaklar ve bütünlük uğruna - aşağıdaki yöntemler, büyük dosyaları okumak için iyi veya zarif değil, ancak yuvarlak bir anlayış elde etmek için lütfen okuyun.

Python'da, bir dosyadan satır okumanın en yaygın yolu aşağıdakileri yapmaktır:

for line in open('myfile','r').readlines():
    do_something(line)

Ancak bu yapıldığında, readlines()işlev (işlev için de aynıdır read()) tüm dosyayı belleğe yükler, ardından tekrarlar. Büyük dosyalar için biraz daha iyi bir yaklaşım (ilk bahsedilen iki yöntem en iyisidir) fileinputmodülü aşağıdaki gibi kullanmaktır :

import fileinput

for line in fileinput.input(['myfile']):
    do_something(line)

fileinput.input()Çağrı sırayla satırları okur, ama onlar bile basitçe bu nedenle bu okumak veya oldum sonra yana, bunları bellekte tutmaz filepiton iterable vardir.

Referanslar

1. Deyimli Python

Yeni satırları çıkarmak için:

with open(file_path, 'rU') as f:
    for line_terminated in f:
        line = line_terminated.rstrip('\n')
        ...

İle evrensel satır desteği tüm metin dosyası satırlarını ile sonlandırıldı görünecek '\n'olursa olsun dosyasında sonlandırıcılar, '\r', '\n', veya'\r\n' .

EDIT - Evrensel yeni satır desteği belirtmek için:

• Unix'te Python 2 - open(file_path, mode='rU')- gerekli ^{[teşekkürler @Dave ]}
• Windows'da Python 2 - open(file_path, mode='rU') - isteğe bağlı
• Python 3 - open(file_path, newline=None)- isteğe bağlı

newlineParametresi yalnızca Python 3 ve varsayılan desteklenir None. modeParametre varsayılan 'r'her durumda. UWindows üzerinde Python 3. yılında Python 2 önerilmiyor diğer bazı mekanizma çevirmek için görünür \r\niçin\n .

Dokümanlar:

• Python 2 için open ()
• Python 3 için open ()

Yerel hat sonlandırıcılarını korumak için:

with open(file_path, 'rb') as f:
    with line_native_terminated in f:
        ...

İkili mod, dosyayı hala satırlara ayrıştırabilir. in . Her satır, dosyada bulunan sonlandırıcılara sahip olacaktır.

Teşekkür etmek @katrielalex 'ın cevabını , Python'un açık () doc ve ipython deneyleri.

bu, python'da bir dosyayı okumanın olası bir yoludur:

f = open(input_file)
for line in f:
    do_stuff(line)
f.close()

tam bir liste ayırmaz. Çizgiler üzerinde yinelenir.

Nereden geldiğime dair bazı bağlamlar ön plana çıkıyor. Kod parçacıkları sonunda.

Mümkün olduğunda, süper yüksek performanslı paralel CSV dosyası okumak için H2O gibi bir açık kaynak aracı kullanmayı tercih ederim, ancak bu araç özellik kümesinde sınırlıdır. Denetimli öğrenme için H2O kümesine beslenmeden önce veri bilimi boru hatları oluşturmak için bir sürü kod yazıyorum.

Çok işlemli kütüphanenin havuz nesnesi ve harita fonksiyonu ile çok sayıda paralellik ekleyerek veri bilimi amaçlı 8GB HIGGS veri seti ve hatta 40GB CSV dosyaları gibi dosyaları çok daha hızlı okuyorum. Örneğin, en yakın komşu aramalarıyla ve ayrıca DBSCAN ve Markov kümeleme algoritmalarıyla kümeleme, bazı ciddi zorlayıcı bellek ve duvar saati zaman sorunlarını atlamak için bazı paralel programlama inceliği gerektirir.

Genellikle dosyayı ilk önce gnu araçlarını kullanarak parçalara ayırmayı ve sonra bunları python programında paralel olarak bulup okumak için glob-filemask etmeyi severim. Genelde 1000'den fazla kısmi dosya gibi bir şey kullanıyorum. Bu hileleri yapmak, işlem hızı ve bellek sınırlarına son derece yardımcı olur.

Panda dataframe.read_csv tek iş parçacıklı olduğundan, paralel yürütme için bir harita () çalıştırarak pandaları daha hızlı hale getirmek için bu hileleri yapabilirsiniz. Düz eski sıralı pandalar dataframe.read_csv ile, sadece bir çekirdekteki% 100 cpu'nun disk değil, pd.read_csv'deki gerçek darboğaz olduğunu görmek için htop'u kullanabilirsiniz.

SATA6 veriyolunda dönen bir HD değil, 16 CPU çekirdeği yerine hızlı video kartı veriyolunda SSD kullanıyorum.

Ayrıca, bazı uygulamalarda harika çalıştığını keşfettiğim başka bir teknik, büyük bir dosyayı birçok parça dosyasına önceden bölmek yerine, her bir çalışanı farklı bir ofsetle başlatan, bir CSP dosyası okuyor. Büyük dosyadaki farklı bayt uzaklığı başlangıç ​​bayt ve bitiş bayt konumlarında, aynı anda aynı anda büyük metin dosyasını şeritler halinde okumak için her paralel çalışanda python'un file seek () ve tell () işlevlerini kullanın. Baytlar üzerinde regex findall yapabilir ve satır besleme sayısını döndürebilirsiniz. Bu kısmi bir meblağdır. Son olarak, harita işlevi çalışanlar bittikten sonra döndüğünde küresel toplamı elde etmek için kısmi toplamları toplayın.

Paralel bayt ofset hilesi kullanan bazı örnek karşılaştırmalar:

2 dosya kullanıyorum: HIGGS.csv 8 GB. UCI makine öğrenim deposundan. all_bin .csv 40.4 GB ve şu anki projemden. 2 program kullanıyorum: Linux ile birlikte gelen GNU wc programı ve geliştirdiğim saf python fastread.py programı.

HP-Z820:/mnt/fastssd/fast_file_reader$ ls -l /mnt/fastssd/nzv/HIGGS.csv
-rw-rw-r-- 1 8035497980 Jan 24 16:00 /mnt/fastssd/nzv/HIGGS.csv

HP-Z820:/mnt/fastssd$ ls -l all_bin.csv
-rw-rw-r-- 1 40412077758 Feb  2 09:00 all_bin.csv

ga@ga-HP-Z820:/mnt/fastssd$ time python fastread.py --fileName="all_bin.csv" --numProcesses=32 --balanceFactor=2
2367496

real    0m8.920s
user    1m30.056s
sys 2m38.744s

In [1]: 40412077758. / 8.92
Out[1]: 4530501990.807175

Bu yaklaşık 4,5 GB / sn veya 45 Gb / sn dosya sıkıştırma hızıdır. Dönen bir sabit disk değil dostum. Bu aslında bir Samsung Pro 950 SSD.

Aşağıda, aynı dosya için saf C derlenmiş bir program olan gnu wc tarafından sayılan hız karşılaştırması yer almaktadır.

Güzel olan şey, bu durumda saf python programımın gnu wc derlenmiş C programının hızıyla eşleştiğini görebilirsiniz. Python yorumlanır, ancak C derlenir, bu yüzden bu oldukça ilginç bir hız başarısıdır, bence kabul edersiniz. Tabii ki, wc'nin gerçekten paralel bir programa değiştirilmesi gerekiyor ve daha sonra çorapları python programımdan gerçekten yenecekti. Ancak bugün olduğu gibi, gnu wc sadece sıralı bir programdır. Yapabileceğinizi yaparsınız ve python bugün paralel yapabilir. Cython derlemesi bana yardımcı olabilir (başka bir süre için). Ayrıca bellek eşlemeli dosyalar henüz araştırılmadı.

HP-Z820:/mnt/fastssd$ time wc -l all_bin.csv
2367496 all_bin.csv

real    0m8.807s
user    0m1.168s
sys 0m7.636s


HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=16 --balanceFactor=2
11000000

real    0m2.257s
user    0m12.088s
sys 0m20.512s

HP-Z820:/mnt/fastssd/fast_file_reader$ time wc -l HIGGS.csv
11000000 HIGGS.csv

real    0m1.820s
user    0m0.364s
sys 0m1.456s

Sonuç: Hız, saf bir python programı için C programına kıyasla iyidir. Bununla birlikte, saf python programını en azından satır sayımı amacıyla C programı üzerinde kullanmak yeterli değildir. Genellikle teknik diğer dosya işleme için kullanılabilir, bu nedenle bu python kodu hala iyidir.

Soru: Normal ifadeyi bir kez derlemek ve tüm işçilere aktarmak hızı artıracak mı? Yanıt: Regex ön derlemesi bu uygulamada YARDIMCI OLMAZ. Bunun nedeni, tüm çalışanlar için süreç serileştirme ve yaratma yükünün baskın olmasıdır.

Bir şey daha. Paralel CSV dosyası okuması bile yardımcı olur mu? Disk darboğaz mı yoksa CPU mu? Stackoverflow üzerinde birçok üst düzey cevaplar, bir dosyayı okumak için sadece bir iş parçacığına ihtiyacınız olan ortak geliştirme bilgisini içerir, en iyi yapabileceğinizi söylüyorlar. Yine de eminler mi?

Hadi bulalım:

HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=16 --balanceFactor=2
11000000

real    0m2.256s
user    0m10.696s
sys 0m19.952s

HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=1 --balanceFactor=1
11000000

real    0m17.380s
user    0m11.124s
sys 0m6.272s

Oh evet, evet öyle. Paralel dosya okuma oldukça iyi çalışır. İyi gidiyorsun!

Ps. Bazılarınızın bilmek istediği durumlarda, tek bir çalışan işlemi kullanırken balanceFactor 2 olsaydı? Korkunç:

HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=1 --balanceFactor=2
11000000

real    1m37.077s
user    0m12.432s
sys 1m24.700s

Fastread.py python programının önemli bölümleri:

fileBytes = stat(fileName).st_size  # Read quickly from OS how many bytes are in a text file
startByte, endByte = PartitionDataToWorkers(workers=numProcesses, items=fileBytes, balanceFactor=balanceFactor)
p = Pool(numProcesses)
partialSum = p.starmap(ReadFileSegment, zip(startByte, endByte, repeat(fileName))) # startByte is already a list. fileName is made into a same-length list of duplicates values.
globalSum = sum(partialSum)
print(globalSum)


def ReadFileSegment(startByte, endByte, fileName, searchChar='\n'):  # counts number of searchChar appearing in the byte range
    with open(fileName, 'r') as f:
        f.seek(startByte-1)  # seek is initially at byte 0 and then moves forward the specified amount, so seek(5) points at the 6th byte.
        bytes = f.read(endByte - startByte + 1)
        cnt = len(re.findall(searchChar, bytes)) # findall with implicit compiling runs just as fast here as re.compile once + re.finditer many times.
    return cnt

PartitionDataToWorkers için def sıradan bir sıralı koddur. Bir başkasının paralel programlamanın nasıl olduğu konusunda biraz pratik yapmak istemesi durumunda bunu bıraktım. Daha zor kısımları ücretsiz olarak verdim: öğrenme yararınız için test edilmiş ve çalışan paralel kod.

Teşekkürler: Arno ve Cliff ve H2O personeli tarafından, yukarıda gösterildiği gibi bu saf python yüksek performanslı paralel bayt ofset okuyucu için ilham veren harika yazılım ve eğitim videoları için açık kaynaklı H2O projesi. H2O, java kullanarak paralel dosya okuması yapar, python ve R programları tarafından çağrılabilir ve büyük CSV dosyalarını okurken gezegendeki her şeyden daha hızlıdır.

Katrielalex bir dosyayı açma ve okuma yolu sağladı.

Ancak algoritmanızın ilerleyiş şekli, dosyanın her satırı için dosyanın tamamını okur. Bu , dosyadaki satırların miktarı ise, bir dosyayı okuma ve Levenshtein mesafesini hesaplamanın toplam miktarının N * N yapılacağı anlamına gelir . Dosya boyutu konusunda endişelendiğiniz ve bellekte tutmak istemediğiniz için, sonuçta ortaya çıkan ikinci dereceden çalışma zamanı hakkında endişeliyim . Algoritmanız uzmanlık ile geliştirilebilen O (n ^ 2) algoritma sınıfındadır.

Burada bellek ve çalışma zamanının dengesini zaten bildiğinizden şüpheleniyorum, ancak belki birden fazla Levenshtein mesafesini paralel olarak hesaplamanın etkili bir yolu olup olmadığını araştırmak istersiniz. Öyleyse, çözümünüzü burada paylaşmak ilginç olacaktır.

Dosyalarınızda kaç satır var ve algoritmanızın ne tür bir makinede (mem & cpu gücü) çalışması gerekiyor ve tolere edilen çalışma süresi nedir?

Kod şöyle görünecektir:

with f_outer as open(input_file, 'r'):
    for line_outer in f_outer:
        with f_inner as open(input_file, 'r'):
            for line_inner in f_inner:
                compute_distance(line_outer, line_inner)

Ancak sorular, mesafeleri (matris?) Nasıl sakladığınızdır ve örneğin, işleme yönelik dış_ satırını hazırlamak veya yeniden kullanmak için bazı ara sonuçları önbelleğe almak gibi bir avantaj elde edebilirsiniz.

#Using a text file for the example
with open("yourFile.txt","r") as f:
    text = f.readlines()
for line in text:
    print line

• Dosyanızı okumak için açın (r)
• Dosyanın tamamını okuyun ve her satırı bir listeye kaydedin (metin)
• Her satırı yazdırarak listede dolaşın.

Örneğin, belirli bir satırı 10'dan daha uzun bir uzunluk için kontrol etmek istiyorsanız, zaten mevcut olanınızla çalışın.

for line in text:
    if len(line) > 10:
        print line

Fileinput .input () için python belgelerinden :

Bu , listenin boş olup olmadığını sys.argv[1:]varsayılan olarak listeleyen tüm dosyaların satırları üzerinden tekrarlarsys.stdin

ayrıca, fonksiyonun tanımı:

fileinput.FileInput([files[, inplace[, backup[, mode[, openhook]]]]])

satırlar arasında okuma, bu filesbir liste olabileceğini söyler, böylece şöyle bir şey olabilir:

for each_line in fileinput.input([input_file, input_file]):
  do_something(each_line)

Daha fazla bilgi için buraya bakın

Çok yavaş olduğu için varsayılan dosya yüklemeyi kullanmamanızı şiddetle tavsiye ederim. Numpy işlevlerine ve IOpro işlevlerine (örn. Numpy.loadtxt ()) bakmalısınız.

http://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html

https://store.continuum.io/cshop/iopro/

Sonra ikili işleminizi parçalara ayırabilirsiniz:

import numpy as np
import math

lines_total = n    
similarity = np.zeros(n,n)
lines_per_chunk = m
n_chunks = math.ceil(float(n)/m)
for i in xrange(n_chunks):
    for j in xrange(n_chunks):
        chunk_i = (function of your choice to read lines i*lines_per_chunk to (i+1)*lines_per_chunk)
        chunk_j = (function of your choice to read lines j*lines_per_chunk to (j+1)*lines_per_chunk)
        similarity[i*lines_per_chunk:(i+1)*lines_per_chunk,
                   j*lines_per_chunk:(j+1)*lines_per_chunk] = fast_operation(chunk_i, chunk_j) 

Parçalara veri yüklemek ve daha sonra üzerinde matris işlemleri yapmak her zaman çok daha hızlıdır !!

Son pozisyon okumasından sık sık büyük bir dosya mı okumanız gerekiyor?

Günde birkaç kez bir Apache access.log dosyasını kesmek için kullanılan bir komut dosyası oluşturdum. Bu yüzden , son yürütme sırasında ayrıştırılan son satırda bir konum imleci ayarlamam gerekiyordu . Bu amaçla kullandım file.seek()vefile.seek() imlecin dosyada saklanmasını sağlayan yöntemler yöntemler .

Kodum:

ENCODING = "utf8"
CURRENT_FILE_DIR = os.path.dirname(os.path.abspath(__file__))

# This file is used to store the last cursor position
cursor_position = os.path.join(CURRENT_FILE_DIR, "access_cursor_position.log")

# Log file with new lines
log_file_to_cut = os.path.join(CURRENT_FILE_DIR, "access.log")
cut_file = os.path.join(CURRENT_FILE_DIR, "cut_access", "cut.log")

# Set in from_line 
from_position = 0
try:
    with open(cursor_position, "r", encoding=ENCODING) as f:
        from_position = int(f.read())
except Exception as e:
    pass

# We read log_file_to_cut to put new lines in cut_file
with open(log_file_to_cut, "r", encoding=ENCODING) as f:
    with open(cut_file, "w", encoding=ENCODING) as fw:
        # We set cursor to the last position used (during last run of script)
        f.seek(from_position)
        for line in f:
            fw.write("%s" % (line))

    # We save the last position of cursor for next usage
    with open(cursor_position, "w", encoding=ENCODING) as fw:
        fw.write(str(f.tell()))

Büyük dosyayı okumanın en iyi yolu, satır satır python numaralandırma işlevini kullanmaktır

with open(file_name, "rU") as read_file:
    for i, row in enumerate(read_file, 1):
        #do something
        #i in line of that line
        #row containts all data of that line