Làm cách nào để có được số lượng dòng của một tệp lớn với giá rẻ trong Python?

Tôi cần lấy số lượng dòng của một tệp lớn (hàng trăm ngàn dòng) trong python. Cách hiệu quả nhất cả về trí nhớ và thời gian là gì?

Hiện tại tôi làm:

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

Có thể làm tốt hơn?

Bạn không thể nhận được bất kỳ tốt hơn thế.

Rốt cuộc, bất kỳ giải pháp nào cũng sẽ phải đọc toàn bộ tệp, tính xem \nbạn có bao nhiêu và trả về kết quả đó.

Bạn có cách nào tốt hơn để làm điều đó mà không cần đọc toàn bộ tập tin không? Không chắc chắn ... Giải pháp tốt nhất sẽ luôn là ràng buộc I / O, tốt nhất bạn có thể làm là đảm bảo rằng bạn không sử dụng bộ nhớ không cần thiết, nhưng có vẻ như bạn có điều đó.

Một dòng, có lẽ khá nhanh:

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

Tôi tin rằng một tập tin ánh xạ bộ nhớ sẽ là giải pháp nhanh nhất. Tôi đã thử bốn chức năng: chức năng được đăng bởi OP ( opcount); một phép lặp đơn giản trên các dòng trong tệp ( simplecount); đường dẫn với một tập tin ánh xạ bộ nhớ (mmap) ( mapcount); và giải pháp đọc bộ đệm được cung cấp bởi Mykola Kharechko ( bufcount).

Tôi đã chạy từng chức năng năm lần và tính thời gian chạy trung bình cho tệp văn bản 1,2 triệu dòng.

Windows XP, Python 2.5, RAM 2GB, bộ xử lý AMD 2 GHz

Đây là kết quả của tôi:

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

Chỉnh sửa : số cho Python 2.6:

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

Vì vậy, chiến lược đọc bộ đệm dường như là nhanh nhất cho Windows / Python 2.6

Đây là mã:

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

Tôi đã phải đăng bài này lên một câu hỏi tương tự cho đến khi điểm danh tiếng của tôi tăng lên một chút (nhờ bất cứ ai làm tôi bực mình!).

Tất cả các giải pháp này đều bỏ qua một cách để làm cho việc này chạy nhanh hơn đáng kể, cụ thể là bằng cách sử dụng giao diện không có bộ đệm (thô), sử dụng phụ, và thực hiện bộ đệm của riêng bạn. (Điều này chỉ áp dụng trong Python 3. Trong Python 2, giao diện thô có thể được sử dụng theo mặc định, nhưng trong Python 3, bạn sẽ mặc định thành Unicode.)

Sử dụng một phiên bản sửa đổi của công cụ thời gian, tôi tin rằng đoạn mã sau nhanh hơn (và hơi nhiều pythonic) hơn bất kỳ giải pháp nào được cung cấp:

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

Sử dụng một chức năng tạo riêng biệt, điều này sẽ chạy nhanh hơn:

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 )

Điều này có thể được thực hiện hoàn toàn với các biểu thức trình tạo nội tuyến bằng itertools, nhưng nó trông khá kỳ lạ:

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 )

Dưới đây là thời gian của tôi:

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

Bạn có thể thực thi một quy trình con và chạy 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])

Đây là một chương trình python để sử dụng thư viện đa xử lý để phân phối dòng đếm trên các máy / lõi. Thử nghiệm của tôi cải thiện việc đếm tệp dòng 20 triệu từ 26 giây đến 7 giây bằng máy chủ windows 64 lõi 8. Lưu ý: không sử dụng ánh xạ bộ nhớ làm cho mọi thứ chậm hơn nhiều.

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

Một giải pháp bash một dòng tương tự như câu trả lời này , sử dụng subprocess.check_outputchức năng hiện đại :

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

Tôi sẽ sử dụng phương thức đối tượng tệp của Python readlines, như sau:

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

Thao tác này sẽ mở tệp, tạo danh sách các dòng trong tệp, đếm độ dài của danh sách, lưu tệp đó vào một biến và đóng tệp lại.

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

Đây là những gì tôi sử dụng, có vẻ khá sạch sẽ:

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

CẬP NHẬT: Điều này nhanh hơn một chút so với sử dụng python thuần nhưng với chi phí sử dụng bộ nhớ. Quá trình con sẽ phân nhánh một tiến trình mới có cùng dấu chân bộ nhớ với tiến trình cha trong khi nó thực thi lệnh của bạn.

Đây là điều nhanh nhất tôi đã tìm thấy bằng cách sử dụng trăn nguyên chất. Bạn có thể sử dụng bất kỳ dung lượng bộ nhớ nào bạn muốn bằng cách đặt bộ đệm, mặc dù 2 ** 16 dường như là một điểm ngọt trên máy tính của tôi.

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

Tôi đã tìm thấy câu trả lời ở đây Tại sao việc đọc các dòng từ stdin chậm hơn nhiều so với Python? và điều chỉnh nó chỉ là một chút nhỏ. Đây là một bài đọc rất tốt để hiểu cách đếm các dòng một cách nhanh chóng, mặc dù vậy wc -lvẫn nhanh hơn khoảng 75% so với bất kỳ thứ gì khác.

Tôi đã có một cải tiến nhỏ (4-8%) với phiên bản này sử dụng lại bộ đệm liên tục để nó tránh mọi bộ nhớ hoặc chi phí hoạt động của GC:

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

Bạn có thể chơi xung quanh với kích thước bộ đệm và có thể thấy một chút cải thiện.

Câu trả lời của Kyle

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

có lẽ là tốt nhất, một sự thay thế cho điều này là

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

Dưới đây là so sánh hiệu suất của cả hai

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

Giải pháp một dòng:

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

Đoạn trích của tôi:

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

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

Chỉ để hoàn thành các phương pháp trên, tôi đã thử một biến thể với mô-đun fileinput:

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

Và đã chuyển một tệp 60 triệu cho tất cả các phương pháp đã nêu ở trên:

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

Đối với tôi, điều hơi ngạc nhiên là fileinput rất tệ và quy mô tệ hơn nhiều so với tất cả các phương pháp khác ...

Đối với tôi, biến thể này sẽ là nhanh nhất:

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

Lý do: đệm nhanh hơn đọc từng dòng và string.countcũng rất nhanh

Mã này ngắn hơn và rõ ràng hơn. Đây có lẽ là cách tốt nhất:

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

Tôi đã sửa đổi trường hợp bộ đệm như thế này:

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

Bây giờ cũng có các tệp trống và dòng cuối cùng (không có \ n) được tính.

Cái này thì sao

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

Nếu ai đó muốn có được số lượng dòng giá rẻ trong Python trong Linux, tôi khuyên bạn nên sử dụng phương pháp này:

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

file_path có thể là cả đường dẫn tệp trừu tượng hoặc đường dẫn tương đối. Hy vọng điều này có thể giúp đỡ.

Còn cái này thì sao?

import fileinput
import sys

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

fileinput.close()
print counter

Làm thế nào về điều này một lót:

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

Mất 0,003 giây bằng cách sử dụng phương pháp này để hẹn giờ trên tệp dòng 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

Phương pháp đơn giản:

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

kết quả của việc mở tệp là một trình vòng lặp, có thể được chuyển đổi thành một chuỗi, có độ dài:

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

điều này ngắn gọn hơn vòng lặp rõ ràng của bạn và tránh enumerate.

Bạn có thể sử dụng os.pathmô-đun theo cách sau:

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

, đâu Filenamelà đường dẫn tuyệt đối của tập tin.

Nếu tập tin có thể vừa với bộ nhớ, thì

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