วิธีรับจำนวนบรรทัดของไฟล์ขนาดใหญ่ใน Python อย่างถูกต้อง?

ฉันต้องได้รับการนับบรรทัดของไฟล์ขนาดใหญ่ (หลายร้อยหลายพันบรรทัด) ในหลาม อะไรคือวิธีที่มีประสิทธิภาพมากที่สุดทั้งในเรื่องของความจำและเวลา?

ในขณะนี้ฉันทำ:

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

เป็นไปได้ไหมที่จะทำได้ดีกว่านี้?

คุณไม่สามารถรับได้ดีไปกว่านี้อีกแล้ว

ท้ายที่สุดโซลูชันใด ๆ จะต้องอ่านไฟล์ทั้งหมดหาจำนวนที่\nคุณมีและส่งคืนผลลัพธ์นั้น

คุณมีวิธีที่ดีกว่าในการทำเช่นนั้นโดยไม่ต้องอ่านไฟล์ทั้งหมดหรือไม่? ไม่แน่ใจ ... ทางออกที่ดีที่สุดจะเป็น I / O-bound ที่ดีที่สุดที่คุณสามารถทำได้คือให้แน่ใจว่าคุณไม่ได้ใช้หน่วยความจำที่ไม่จำเป็น แต่ดูเหมือนว่าคุณจะได้รับการคุ้มครอง

หนึ่งบรรทัดอาจจะค่อนข้างเร็ว:

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

ฉันเชื่อว่าไฟล์ที่แมปหน่วยความจำจะเป็นวิธีแก้ปัญหาที่เร็วที่สุด ฉันลองสี่ฟังก์ชั่น: ฟังก์ชั่นที่โพสต์โดย OP ( opcount); การทำซ้ำแบบง่ายเหนือบรรทัดในไฟล์ ( simplecount); readline พร้อมหน่วยความจำที่แมปยื่น (mmap) ( mapcount); และโซลูชันการอ่านบัฟเฟอร์ที่นำเสนอโดย Mykola Kharechko ( bufcount)

ฉันวิ่งแต่ละฟังก์ชั่นห้าครั้งและคำนวณเวลาทำงานเฉลี่ยสำหรับไฟล์ข้อความ 1.2 ล้านบรรทัด

Windows XP, Python 2.5, 2GB RAM, โปรเซสเซอร์ 2 GHz AMD

นี่คือผลลัพธ์ของฉัน:

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

แก้ไข : หมายเลขสำหรับ Python 2.6:

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

ดังนั้นกลยุทธ์การอ่านบัฟเฟอร์จึงเป็นวิธีที่เร็วที่สุดสำหรับ Windows / Python 2.6

นี่คือรหัส:

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

ฉันต้องโพสต์คำถามนี้ด้วยคำถามที่คล้ายกันจนกระทั่งคะแนนชื่อเสียงของฉันเพิ่มขึ้นเล็กน้อย (ขอบคุณผู้ที่กระแทกฉัน!)

โซลูชันทั้งหมดเหล่านี้ไม่สนใจวิธีหนึ่งในการทำให้การดำเนินการนี้เร็วขึ้นอย่างมากนั่นคือโดยใช้อินเทอร์เฟซที่ไม่มีบัฟเฟอร์ (ดิบ) ใช้การทดสอบแบบไบต์และการบัฟเฟอร์ของคุณเอง (สิ่งนี้ใช้ได้เฉพาะใน Python 3 เท่านั้นใน Python 2 อินเทอร์เฟซแบบดิบอาจใช้หรือไม่ใช้เป็นค่าเริ่มต้น แต่ใน Python 3 คุณจะเริ่มต้นเป็น Unicode)

การใช้เครื่องมือกำหนดเวลาเวอร์ชันที่แก้ไขแล้วฉันเชื่อว่ารหัสต่อไปนี้เร็วกว่า (และ pythonic เล็กน้อย) มากกว่าโซลูชันที่เสนอ:

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

การใช้ฟังก์ชั่นเครื่องกำเนิดไฟฟ้าแยกต่างหากจะทำให้ smidge ทำงานได้เร็วขึ้น:

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 )

สามารถทำได้อย่างสมบูรณ์ด้วยนิพจน์กำเนิดในบรรทัดโดยใช้ itertools แต่มันก็ดูแปลก ๆ :

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 )

นี่คือการกำหนดเวลาของฉัน:

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

คุณสามารถดำเนินการกระบวนการย่อยและเรียกใช้ 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])

นี่คือโปรแกรมไพ ธ อนที่ใช้ไลบรารีมัลติโพรเซสซิงเพื่อกระจายการนับบรรทัดในเครื่อง / แกนหลัก การทดสอบของฉันปรับปรุงการนับไฟล์บรรทัด 20 ล้านจาก 26 วินาทีเป็น 7 วินาทีโดยใช้เซิร์ฟเวอร์ 8 core windows 64 หมายเหตุ: การไม่ใช้การจับคู่หน่วยความจำทำให้ช้าลงมาก

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

โซลูชันทุบตีแบบบรรทัดเดียวคล้ายกับคำตอบนี้โดยใช้subprocess.check_outputฟังก์ชั่นที่ทันสมัย:

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

ฉันจะใช้วิธีการวัตถุไฟล์ของงูreadlinesใหญ่ดังนี้

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

สิ่งนี้จะเปิดไฟล์สร้างรายการของบรรทัดในไฟล์นับความยาวของรายการบันทึกลงในตัวแปรและปิดไฟล์อีกครั้ง

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

นี่คือสิ่งที่ฉันใช้ดูเหมือนสะอาดดี:

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

UPDATE: สิ่งนี้เร็วกว่าการใช้ python แท้ แต่มีค่าใช้จ่ายในการใช้หน่วยความจำ กระบวนการย่อยจะแยกกระบวนการใหม่โดยมีหน่วยความจำรอยเดียวกับกระบวนการหลักในขณะที่ประมวลผลคำสั่งของคุณ

นี่คือสิ่งที่เร็วที่สุดที่ฉันพบโดยใช้งูหลามบริสุทธิ์ คุณสามารถใช้หน่วยความจำจำนวนเท่าใดก็ได้ที่คุณต้องการโดยการตั้งค่าบัฟเฟอร์แม้ว่า 2 ** 16 จะเป็นจุดที่น่าสนใจในคอมพิวเตอร์ของฉัน

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), ''))

ฉันพบคำตอบที่นี่ทำไมการอ่านบรรทัดจาก stdin ช้ากว่ามากใน C ++ มากกว่า Python? และปรับแต่งมันเล็กน้อย มันเป็นการอ่านที่ดีมากที่จะเข้าใจวิธีการนับจำนวนบรรทัดอย่างรวดเร็วแม้ว่าwc -lจะยังเร็วกว่าสิ่งอื่นประมาณ 75%

ฉันได้รับการปรับปรุงเล็กน้อย (4-8%) กับรุ่นนี้ซึ่งใช้บัฟเฟอร์คงที่อีกครั้งดังนั้นจึงควรหลีกเลี่ยงหน่วยความจำหรือค่าใช้จ่าย GC:

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

คุณสามารถเล่นกับขนาดบัฟเฟอร์และอาจเห็นการปรับปรุงเล็กน้อย

คำตอบของไคล์

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

น่าจะเป็นทางเลือกที่ดีที่สุดสำหรับสิ่งนี้คือ

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

นี่คือการเปรียบเทียบประสิทธิภาพของทั้งคู่

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

โซลูชันเดียว:

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

ตัวอย่างของฉัน:

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

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

เพียงเพื่อทำวิธีการด้านบนฉันลองตัวแปรกับโมดูล fileinput:

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

และผ่านไฟล์ 60mil ไปยังวิธีการที่ระบุข้างต้นทั้งหมด:

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

มันเป็นเรื่องแปลกใจเล็กน้อยสำหรับฉันว่าการป้อนข้อมูลไฟล์นั้นแย่มากและแย่กว่าวิธีอื่น ๆ ทั้งหมด ...

สำหรับฉันตัวแปรนี้จะเร็วที่สุด:

#!/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()

เหตุผล: การบัฟเฟอร์เร็วกว่าการอ่านทีละบรรทัดและstring.countเร็วมาก

รหัสนี้สั้นกว่าและชัดเจนกว่า มันอาจเป็นวิธีที่ดีที่สุด:

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

ฉันได้แก้ไขกรณีบัฟเฟอร์เช่นนี้

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

ตอนนี้ยังมีไฟล์ว่างและบรรทัดสุดท้าย (ไม่มี \ n) ถูกนับ

เกี่ยวกับสิ่งนี้

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

หากต้องการได้รับจำนวนบรรทัดอย่างถูกต้องใน Python ใน Linux ฉันแนะนำวิธีนี้:

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

file_path สามารถเป็นได้ทั้งเส้นทางไฟล์นามธรรมหรือเส้นทางสัมพัทธ์ หวังว่ามันจะช่วยได้

แล้วเรื่องนี้ล่ะ

import fileinput
import sys

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

fileinput.close()
print counter

วิธีการหนึ่งซับนี้:

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

ใช้เวลา 0.003 วินาทีโดยใช้วิธีนี้กับเวลาบนไฟล์บรรทัด 3900

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

วิธีง่าย ๆ :

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

ผลลัพธ์ของการเปิดไฟล์คือตัววนซ้ำซึ่งสามารถแปลงเป็นลำดับซึ่งมีความยาว:

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

enumerateนี้คือการที่รัดกุมมากกว่าห่วงอย่างชัดเจนของคุณและหลีกเลี่ยงการ

คุณสามารถใช้os.pathโมดูลด้วยวิธีต่อไปนี้:

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

Filenameคือตำแหน่งที่แน่นอนของไฟล์

หากไฟล์สามารถใส่ลงในหน่วยความจำได้แล้ว

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