Wie kann man die Zeilenanzahl einer großen Datei in Python billig ermitteln?

Ich muss eine Zeilenanzahl einer großen Datei (Hunderttausende von Zeilen) in Python erhalten. Was ist der effizienteste Weg sowohl in Bezug auf das Gedächtnis als auch in Bezug auf die Zeit?

Im Moment mache ich:

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

ist es möglich, es besser zu machen?

Besser geht es nicht.

Schließlich muss jede Lösung die gesamte Datei lesen, herausfinden, wie viele \nSie haben, und dieses Ergebnis zurückgeben.

Haben Sie eine bessere Möglichkeit, dies zu tun, ohne die gesamte Datei zu lesen? Nicht sicher ... Die beste Lösung ist immer E / A-gebunden. Das Beste, was Sie tun können, ist sicherzustellen, dass Sie keinen unnötigen Speicher verwenden, aber es sieht so aus, als hätten Sie diesen abgedeckt.

Eine Zeile, wahrscheinlich ziemlich schnell:

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

Ich glaube, dass eine Speicherzuordnungsdatei die schnellste Lösung sein wird. Ich habe vier Funktionen ausprobiert: die vom OP ( opcount) gepostete Funktion ; eine einfache Iteration über die Zeilen in der Datei ( simplecount); readline mit einem speicherabgebildeten Feld (mmap) ( mapcount); und die von Mykola Kharechko ( bufcount) angebotene Pufferleselösung .

Ich habe jede Funktion fünf Mal ausgeführt und die durchschnittliche Laufzeit für eine Textdatei mit 1,2 Millionen Zeilen berechnet.

Windows XP, Python 2.5, 2 GB RAM, 2 GHz AMD-Prozessor

Hier sind meine Ergebnisse:

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

Edit : Zahlen für Python 2.6:

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

Daher scheint die Pufferlesestrategie für Windows / Python 2.6 die schnellste zu sein

Hier ist der Code:

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

Ich musste dies auf eine ähnliche Frage posten, bis mein Reputationswert ein wenig sprang (danke an jeden, der mich gestoßen hat!).

Alle diese Lösungen ignorieren eine Möglichkeit, diesen Lauf erheblich zu beschleunigen, nämlich die Verwendung der ungepufferten (Roh-) Schnittstelle, die Verwendung von Bytearrays und die eigene Pufferung. (Dies gilt nur in Python 3. In Python 2 wird die Rohschnittstelle möglicherweise standardmäßig verwendet oder nicht, in Python 3 wird jedoch standardmäßig Unicode verwendet.)

Unter Verwendung einer modifizierten Version des Timing-Tools ist der folgende Code meiner Meinung nach schneller (und geringfügig pythonischer) als jede der angebotenen Lösungen:

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

Mit einer separaten Generatorfunktion wird ein Smidge schneller ausgeführt:

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 )

Dies kann vollständig mit Generatorausdrücken inline unter Verwendung von itertools durchgeführt werden, aber es sieht ziemlich seltsam aus:

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 )

Hier sind meine Timings:

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

Sie können einen Unterprozess ausführen und ausführen 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])

Hier ist ein Python-Programm, mit dem die Multiprozessor-Bibliothek verwendet wird, um die Zeilenzählung auf Maschinen / Kerne zu verteilen. Mein Test verbessert das Zählen einer 20-Millionen-Zeilendatei von 26 Sekunden auf 7 Sekunden unter Verwendung eines 8-Kern-Windows 64-Servers. Hinweis: Wenn Sie keine Speicherzuordnung verwenden, werden die Dinge viel langsamer.

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

Eine einzeilige Bash-Lösung ähnlich dieser Antwort unter Verwendung der modernen subprocess.check_outputFunktion:

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

Ich würde Pythons Dateiobjektmethode readlineswie folgt verwenden:

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

Dies öffnet die Datei, erstellt eine Liste von Zeilen in der Datei, zählt die Länge der Liste, speichert diese in einer Variablen und schließt die Datei erneut.

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

Folgendes benutze ich, scheint ziemlich sauber zu sein:

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: Dies ist geringfügig schneller als die Verwendung von reinem Python, jedoch auf Kosten der Speichernutzung. Der Unterprozess gibt einen neuen Prozess mit dem gleichen Speicherbedarf wie der übergeordnete Prozess aus, während er Ihren Befehl ausführt.

Dies ist das schnellste, was ich mit reinem Python gefunden habe. Sie können beliebig viel Speicher verwenden, indem Sie den Puffer einstellen, obwohl 2 ** 16 ein Sweet Spot auf meinem Computer zu sein scheint.

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

Ich habe die Antwort hier gefunden. Warum ist das Lesen von Zeilen aus stdin in C ++ viel langsamer als in Python? und optimierte es nur ein kleines bisschen. Es ist eine sehr gute Lektüre, um zu verstehen, wie man Zeilen schnell zählt, obwohl wc -les immer noch etwa 75% schneller ist als alles andere.

Ich habe mit dieser Version eine kleine Verbesserung (4-8%) erzielt, bei der ein konstanter Puffer wiederverwendet wird, um Speicher- oder GC-Overhead zu vermeiden:

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

Sie können mit der Puffergröße herumspielen und vielleicht eine kleine Verbesserung feststellen.

Kyles Antwort

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

ist wohl am besten, eine alternative dafür ist

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

Hier ist der Vergleich der Leistung von beiden

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

Einzeilige Lösung:

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

Mein Ausschnitt:

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

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

Um die oben genannten Methoden zu vervollständigen, habe ich eine Variante mit dem Dateieingabemodul ausprobiert:

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

Und eine 60-mil-Zeilendatei an alle oben genannten Methoden übergeben:

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

Es ist eine kleine Überraschung für mich, dass der Dateieingang so schlecht ist und weitaus schlechter skaliert als alle anderen Methoden ...

Für mich wird diese Variante die schnellste sein:

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

Gründe: Pufferung schneller als zeilenweises Lesen und string.countauch sehr schnell

Dieser Code ist kürzer und klarer. Es ist wahrscheinlich der beste Weg:

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

Ich habe den Pufferfall folgendermaßen geändert:

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

Jetzt werden auch leere Dateien und die letzte Zeile (ohne \ n) gezählt.

Was ist damit?

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

Wenn man die Zeilenanzahl in Python unter Linux billig erhalten möchte, empfehle ich diese Methode:

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

Dateipfad kann sowohl ein abstrakter Dateipfad als auch ein relativer Pfad sein. Hoffe das kann helfen.

Wie wäre es damit?

import fileinput
import sys

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

fileinput.close()
print counter

Wie wäre es mit diesem Einzeiler:

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

Mit dieser Methode dauert es 0,003 Sekunden, um die Zeit in einer 3900-Zeilendatei zu messen

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

Einfache Methode:

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

Das Ergebnis des Öffnens einer Datei ist ein Iterator, der in eine Sequenz konvertiert werden kann, die eine Länge hat:

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

Dies ist prägnanter als Ihre explizite Schleife und vermeidet das enumerate.

Sie können das os.pathModul folgendermaßen verwenden:

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

, wo Filenameist der absolute Pfad der Datei.

Wenn die Datei in den Speicher passt, dann

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