Python ucuz bir büyük dosya satır sayısını almak için?

Python büyük bir dosya (yüz binlerce satır) bir satır sayısı almak gerekiyor. Hem bellek hem de zaman açısından en etkili yol nedir?

Şu anda yapıyorum:

def file_len(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1

daha iyisini yapmak mümkün mü?

Bundan daha iyisi olamaz.

Sonuçta, herhangi bir çözüm tüm dosyayı okumak, kaç tane \nsahip olduğunuzu bulmak ve bu sonucu döndürmek zorunda kalacak .

Tüm dosyayı okumadan bunu yapmanın daha iyi bir yolu var mı? Emin değilim ... En iyi çözüm her zaman G / Ç'ye bağlı olacaktır, yapabileceğiniz en iyi şey gereksiz belleği kullanmadığınızdan emin olmaktır, ancak görünüşe göre bu kapsamdadır.

Bir satır, muhtemelen oldukça hızlı:

num_lines = sum(1 for line in open('myfile.txt'))

Bellek eşlemeli bir dosyanın en hızlı çözüm olacağına inanıyorum. Dört işlevi denedim: OP ( opcount) tarafından gönderilen işlev ; dosyadaki ( simplecount) satırlar üzerinden basit bir yineleme ; bellek eşlemeli dosyalanmış okuma çizgisi (mmap) ( mapcount); ve Mykola Kharechko ( bufcount) tarafından sunulan tampon okuma çözeltisi .

Her işlevi beş kez çalıştırdım ve 1,2 milyon satırlık bir metin dosyası için ortalama çalışma süresini hesapladım.

Windows XP, Python 2.5, 2GB RAM, 2 GHz AMD işlemci

İşte sonuçlarım:

mapcount : 0.465599966049
simplecount : 0.756399965286
bufcount : 0.546800041199
opcount : 0.718600034714

Düzenleme : Python 2.6 için numaralar:

mapcount : 0.471799945831
simplecount : 0.634400033951
bufcount : 0.468800067902
opcount : 0.602999973297

Bu nedenle, tampon okuma stratejisi Windows / Python 2.6 için en hızlı gibi görünüyor

İşte kod:

from __future__ import with_statement
import time
import mmap
import random
from collections import defaultdict

def mapcount(filename):
    f = open(filename, "r+")
    buf = mmap.mmap(f.fileno(), 0)
    lines = 0
    readline = buf.readline
    while readline():
        lines += 1
    return lines

def simplecount(filename):
    lines = 0
    for line in open(filename):
        lines += 1
    return lines

def bufcount(filename):
    f = open(filename)                  
    lines = 0
    buf_size = 1024 * 1024
    read_f = f.read # loop optimization

    buf = read_f(buf_size)
    while buf:
        lines += buf.count('\n')
        buf = read_f(buf_size)

    return lines

def opcount(fname):
    with open(fname) as f:
        for i, l in enumerate(f):
            pass
    return i + 1


counts = defaultdict(list)

for i in range(5):
    for func in [mapcount, simplecount, bufcount, opcount]:
        start_time = time.time()
        assert func("big_file.txt") == 1209138
        counts[func].append(time.time() - start_time)

for key, vals in counts.items():
    print key.__name__, ":", sum(vals) / float(len(vals))

İtibar puanım biraz atlayana kadar benzer bir soruyu yayınlamam gerekiyordu (kim beni çarptıysa!).

Tüm bu çözümler, arabelleksiz (ham) arabirimi kullanarak, bytearrays kullanarak ve kendi arabelleklemenizi yaparak, bu işlemi önemli ölçüde daha hızlı yapmanın bir yolunu yok sayar. (Bu yalnızca Python 3 için geçerlidir. Python 2'de, ham arabirim varsayılan olarak kullanılabilir veya kullanılmayabilir, ancak Python 3'te varsayılan olarak Unicode'u kullanırsınız.)

Zamanlama aracının değiştirilmiş bir sürümünü kullanarak, aşağıdaki kodun sunulan çözümlerden daha hızlı (ve marjinal olarak daha pythonic) olduğuna inanıyorum:

def rawcount(filename):
    f = open(filename, 'rb')
    lines = 0
    buf_size = 1024 * 1024
    read_f = f.raw.read

    buf = read_f(buf_size)
    while buf:
        lines += buf.count(b'\n')
        buf = read_f(buf_size)

    return lines

Ayrı bir jeneratör işlevi kullanarak, bu daha hızlı bir görüntü sağlar:

def _make_gen(reader):
    b = reader(1024 * 1024)
    while b:
        yield b
        b = reader(1024*1024)

def rawgencount(filename):
    f = open(filename, 'rb')
    f_gen = _make_gen(f.raw.read)
    return sum( buf.count(b'\n') for buf in f_gen )

Bu tamamen itertools kullanarak satır içi jeneratör ifadeleri ile yapılabilir, ancak oldukça garip görünüyor:

from itertools import (takewhile,repeat)

def rawincount(filename):
    f = open(filename, 'rb')
    bufgen = takewhile(lambda x: x, (f.raw.read(1024*1024) for _ in repeat(None)))
    return sum( buf.count(b'\n') for buf in bufgen )

İşte zamanlamalarım:

function      average, s  min, s   ratio
rawincount        0.0043  0.0041   1.00
rawgencount       0.0044  0.0042   1.01
rawcount          0.0048  0.0045   1.09
bufcount          0.008   0.0068   1.64
wccount           0.01    0.0097   2.35
itercount         0.014   0.014    3.41
opcount           0.02    0.02     4.83
kylecount         0.021   0.021    5.05
simplecount       0.022   0.022    5.25
mapcount          0.037   0.031    7.46

Bir alt işlem yürütebilir ve çalıştırabilirsiniz. wc -l filename

import subprocess

def file_len(fname):
    p = subprocess.Popen(['wc', '-l', fname], stdout=subprocess.PIPE, 
                                              stderr=subprocess.PIPE)
    result, err = p.communicate()
    if p.returncode != 0:
        raise IOError(err)
    return int(result.strip().split()[0])

Satır sayımını makineler / çekirdekler arasında dağıtmak için çoklu işlem kütüphanesini kullanmak için bir python programı. Testim, 8 çekirdekli bir Windows 64 sunucusu kullanarak 26 milyondan 7 saniyeye kadar 20 milyon satırlık bir dosya saymayı geliştiriyor. Not: bellek eşleme kullanılmaması işleri daha yavaş hale getirir.

import multiprocessing, sys, time, os, mmap
import logging, logging.handlers

def init_logger(pid):
    console_format = 'P{0} %(levelname)s %(message)s'.format(pid)
    logger = logging.getLogger()  # New logger at root level
    logger.setLevel( logging.INFO )
    logger.handlers.append( logging.StreamHandler() )
    logger.handlers[0].setFormatter( logging.Formatter( console_format, '%d/%m/%y %H:%M:%S' ) )

def getFileLineCount( queues, pid, processes, file1 ):
    init_logger(pid)
    logging.info( 'start' )

    physical_file = open(file1, "r")
    #  mmap.mmap(fileno, length[, tagname[, access[, offset]]]

    m1 = mmap.mmap( physical_file.fileno(), 0, access=mmap.ACCESS_READ )

    #work out file size to divide up line counting

    fSize = os.stat(file1).st_size
    chunk = (fSize / processes) + 1

    lines = 0

    #get where I start and stop
    _seedStart = chunk * (pid)
    _seekEnd = chunk * (pid+1)
    seekStart = int(_seedStart)
    seekEnd = int(_seekEnd)

    if seekEnd < int(_seekEnd + 1):
        seekEnd += 1

    if _seedStart < int(seekStart + 1):
        seekStart += 1

    if seekEnd > fSize:
        seekEnd = fSize

    #find where to start
    if pid > 0:
        m1.seek( seekStart )
        #read next line
        l1 = m1.readline()  # need to use readline with memory mapped files
        seekStart = m1.tell()

    #tell previous rank my seek start to make their seek end

    if pid > 0:
        queues[pid-1].put( seekStart )
    if pid < processes-1:
        seekEnd = queues[pid].get()

    m1.seek( seekStart )
    l1 = m1.readline()

    while len(l1) > 0:
        lines += 1
        l1 = m1.readline()
        if m1.tell() > seekEnd or len(l1) == 0:
            break

    logging.info( 'done' )
    # add up the results
    if pid == 0:
        for p in range(1,processes):
            lines += queues[0].get()
        queues[0].put(lines) # the total lines counted
    else:
        queues[0].put(lines)

    m1.close()
    physical_file.close()

if __name__ == '__main__':
    init_logger( 'main' )
    if len(sys.argv) > 1:
        file_name = sys.argv[1]
    else:
        logging.fatal( 'parameters required: file-name [processes]' )
        exit()

    t = time.time()
    processes = multiprocessing.cpu_count()
    if len(sys.argv) > 2:
        processes = int(sys.argv[2])
    queues=[] # a queue for each process
    for pid in range(processes):
        queues.append( multiprocessing.Queue() )
    jobs=[]
    prev_pipe = 0
    for pid in range(processes):
        p = multiprocessing.Process( target = getFileLineCount, args=(queues, pid, processes, file_name,) )
        p.start()
        jobs.append(p)

    jobs[0].join() #wait for counting to finish
    lines = queues[0].get()

    logging.info( 'finished {} Lines:{}'.format( time.time() - t, lines ) )

Modern işlevi kullanarak bu cevaba benzer tek satırlık bir bash çözümü subprocess.check_output:

def line_count(filename):
    return int(subprocess.check_output(['wc', '-l', filename]).split()[0])

Python'un dosya nesnesi yöntemini readlinesaşağıdaki gibi kullanırdım:

with open(input_file) as foo:
    lines = len(foo.readlines())

Bu dosyayı açar, dosyada bir satır listesi oluşturur, listenin uzunluğunu sayar, bunu bir değişkene kaydeder ve dosyayı tekrar kapatır.

def file_len(full_path):
  """ Count number of lines in a file."""
  f = open(full_path)
  nr_of_lines = sum(1 for line in f)
  f.close()
  return nr_of_lines

İşte kullandığım, oldukça temiz görünüyor:

import subprocess

def count_file_lines(file_path):
    """
    Counts the number of lines in a file using wc utility.
    :param file_path: path to file
    :return: int, no of lines
    """
    num = subprocess.check_output(['wc', '-l', file_path])
    num = num.split(' ')
    return int(num[0])

GÜNCELLEME: Bu, saf python kullanmaktan biraz daha hızlıdır, ancak bellek kullanımı pahalıdır. Alt işlem, komutunuzu yürütürken üst işlemle aynı bellek kapladığı yeni bir işlemi keser.

Bu saf python kullanarak bulduğum en hızlı şey. Arabelleği ayarlayarak istediğiniz bellek miktarını kullanabilirsiniz, ancak 2 ** 16 bilgisayarımda tatlı bir nokta gibi görünüyor.

from functools import partial

buffer=2**16
with open(myfile) as f:
        print sum(x.count('\n') for x in iter(partial(f.read,buffer), ''))

Cevabı burada buldum Neden stdin'den satırları okumak C ++ 'da Python'dan çok daha yavaş? ve küçük bir değişiklik yaptım. Çizgileri hızlı bir şekilde nasıl sayacağınızı anlamak için çok iyi bir okuma wc -l, yine de her şeyden yaklaşık% 75 daha hızlı.

Herhangi bir bellek veya GC yükünü önlemek gerekir sabit bir tampon yeniden kullanır bu sürümü ile küçük (% 4-8) bir gelişme var:

lines = 0
buffer = bytearray(2048)
with open(filename) as f:
  while f.readinto(buffer) > 0:
      lines += buffer.count('\n')

Arabellek boyutu ile oynayabilir ve belki biraz iyileşme görebilirsiniz.

Kyle'nin cevabı

num_lines = sum(1 for line in open('my_file.txt'))

muhtemelen en iyisi, bunun için bir alternatif

num_lines =  len(open('my_file.txt').read().splitlines())

İşte her ikisinin performans karşılaştırması

In [20]: timeit sum(1 for line in open('Charts.ipynb'))
100000 loops, best of 3: 9.79 µs per loop

In [21]: timeit len(open('Charts.ipynb').read().splitlines())
100000 loops, best of 3: 12 µs per loop

Tek hat çözümü:

import os
os.system("wc -l  filename")  

Snippet'im:

>>> os.system('wc -l *.txt')

0 bar.txt
1000 command.txt
3 test_file.txt
1003 total

Sadece yukarıdaki yöntemleri tamamlamak için fileinput modülü ile bir varyant denedim:

import fileinput as fi   
def filecount(fname):
        for line in fi.input(fname):
            pass
        return fi.lineno()

Ve yukarıda belirtilen yöntemlerin tümüne bir 60mil satır dosyasını geçti:

mapcount : 6.1331050396
simplecount : 4.588793993
opcount : 4.42918205261
filecount : 43.2780818939
bufcount : 0.170812129974

Dosya girişinin o kadar kötü ve ölçeklendirilmesinin diğer tüm yöntemlerden çok daha kötü olması benim için biraz sürpriz ...

Bana göre bu varyant en hızlı olacak:

#!/usr/bin/env python

def main():
    f = open('filename')                  
    lines = 0
    buf_size = 1024 * 1024
    read_f = f.read # loop optimization

    buf = read_f(buf_size)
    while buf:
        lines += buf.count('\n')
        buf = read_f(buf_size)

    print lines

if __name__ == '__main__':
    main()

nedenleri: satır satır okumaktan daha hızlı arabelleğe alma ve string.countaynı zamanda çok hızlı

Bu kod daha kısa ve açıktır. Muhtemelen en iyi yol:

num_lines = open('yourfile.ext').read().count('\n')

Arabellek kasasını şu şekilde değiştirdim:

def CountLines(filename):
    f = open(filename)
    try:
        lines = 1
        buf_size = 1024 * 1024
        read_f = f.read # loop optimization
        buf = read_f(buf_size)

        # Empty file
        if not buf:
            return 0

        while buf:
            lines += buf.count('\n')
            buf = read_f(buf_size)

        return lines
    finally:
        f.close()

Şimdi boş dosyalar ve son satır (\ n olmadan) sayılır.

Peki buna ne dersin

def file_len(fname):
  counts = itertools.count()
  with open(fname) as f: 
    for _ in f: counts.next()
  return counts.next()

count = max(enumerate(open(filename)))[0]

print open('file.txt', 'r').read().count("\n") + 1

def line_count(path):
    count = 0
    with open(path) as lines:
        for count, l in enumerate(lines, start=1):
            pass
    return count

Biri Linux'ta Python'da ucuza satır sayısını almak istiyorsa, bu yöntemi öneririm:

import os
print os.popen("wc -l file_path").readline().split()[0]

file_path hem soyut dosya yolu hem de göreli yol olabilir. Umarım bu yardımcı olabilir.

Buna ne dersin?

import fileinput
import sys

counter=0
for line in fileinput.input([sys.argv[1]]):
    counter+=1

fileinput.close()
print counter

Peki bu tek astarlı:

file_length = len(open('myfile.txt','r').read().split('\n'))

3900 satır dosyasında zamanlamak için bu yöntemi kullanarak 0.003 saniye sürer

def c():
  import time
  s = time.time()
  file_length = len(open('myfile.txt','r').read().split('\n'))
  print time.time() - s

def count_text_file_lines(path):
    with open(path, 'rt') as file:
        line_count = sum(1 for _line in file)
    return line_count

Basit yöntem:

1)

>>> f = len(open("myfile.txt").readlines())
>>> f

430

2)

>>> f = open("myfile.txt").read().count('\n')
>>> f
430
>>>

3)

num_lines = len(list(open('myfile.txt')))

bir dosyayı açmanın sonucu, uzunluğu olan bir diziye dönüştürülebilen bir yineleyicidir:

with open(filename) as f:
   return len(list(f))

bu, açık döngünüzden daha özlüdür ve enumerate.

Sen kullanabilirsiniz os.pathşu şekilde modülü:

import os
import subprocess
Number_lines = int( (subprocess.Popen( 'wc -l {0}'.format( Filename ), shell=True, stdout=subprocess.PIPE).stdout).readlines()[0].split()[0] )

, Filenamedosyanın mutlak yolu nerede .

Dosya belleğe sığabiliyorsa,

with open(fname) as f:
    count = len(f.read().split(b'\n')) - 1