Come ottenere il conteggio delle righe di un file di grandi dimensioni in modo economico in Python?

Devo ottenere un conteggio delle righe di un file di grandi dimensioni (centinaia di migliaia di righe) in Python. Qual è il modo più efficiente sia in termini di memoria che di tempo?

Al momento faccio:

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

è possibile fare di meglio?

Non puoi fare di meglio.

Dopotutto, qualsiasi soluzione dovrà leggere l'intero file, capire quanti \n ne hai e restituire quel risultato.

Hai un modo migliore per farlo senza leggere l'intero file? Non sono sicuro ... La migliore soluzione sarà sempre legata all'I / O, la cosa migliore che puoi fare è assicurarti di non usare memoria non necessaria, ma sembra che tu ne abbia coperto.

Una riga, probabilmente abbastanza veloce:

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

Credo che un file mappato in memoria sarà la soluzione più veloce. Ho provato quattro funzioni: la funzione pubblicata dall'OP ( opcount); una semplice iterazione sopra le righe nel file ( simplecount); readline con un file mappato in memoria (mmap) ( mapcount); e la soluzione di lettura del buffer offerta da Mykola Kharechko (bufcount ).

Ho eseguito ciascuna funzione cinque volte e ho calcolato il tempo di esecuzione medio per un file di testo di 1,2 milioni di righe.

Windows XP, Python 2.5, 2 GB di RAM, processore AMD da 2 GHz

Ecco i miei risultati:

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

Modifica : numeri per Python 2.6:

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

Quindi la strategia di lettura del buffer sembra essere la più veloce per Windows / Python 2.6

Ecco il codice:

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

Ho dovuto postare questo su una domanda simile fino a quando il mio punteggio di reputazione è saltato un po '(grazie a chiunque mi abbia urtato!).

Tutte queste soluzioni ignorano un modo per rendere questa corsa considerevolmente più veloce, vale a dire usando l'interfaccia senza buffer (raw), usando i bytearrays e facendo il tuo buffering. (Ciò si applica solo in Python 3. In Python 2, l'interfaccia non elaborata può essere utilizzata o meno per impostazione predefinita, ma in Python 3, verrà impostato automaticamente Unicode.)

Utilizzando una versione modificata dello strumento di cronometraggio, credo che il seguente codice sia più veloce (e marginalmente più pitonico) di qualsiasi delle soluzioni offerte:

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

Utilizzando una funzione di generatore separata, questo fa funzionare un fumo più velocemente:

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 )

Questo può essere fatto completamente con le espressioni dei generatori in linea usando itertools, ma diventa piuttosto strano:

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 )

Ecco i miei tempi:

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

È possibile eseguire un sottoprocesso ed eseguire 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])

Ecco un programma Python per usare la libreria multiprocessing per distribuire il conteggio delle linee su macchine / core. Il mio test migliora il conteggio di un file di 20 milioni di righe da 26 secondi a 7 secondi utilizzando un server Windows 64 a 8 core. Nota: non usare la mappatura della memoria rende le cose molto più lente.

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

Una soluzione bash a una riga simile a questa risposta , utilizzando la subprocess.check_outputfunzione moderna :

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

Vorrei utilizzare il metodo oggetto file di Python readlines, come segue:

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

Questo apre il file, crea un elenco di righe nel file, conta la lunghezza dell'elenco, lo salva in una variabile e chiude nuovamente il file.

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

Ecco quello che uso, sembra abbastanza pulito:

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

AGGIORNAMENTO: Questo è leggermente più veloce rispetto all'utilizzo di Python puro ma a costo dell'uso della memoria. Il sottoprocesso eseguirà il fork di un nuovo processo con lo stesso footprint di memoria del processo parent mentre esegue il comando.

Questa è la cosa più veloce che ho trovato usando il puro pitone. È possibile utilizzare la quantità di memoria desiderata impostando il buffer, anche se 2 ** 16 sembra essere un punto debole sul mio computer.

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

Ho trovato la risposta qui Perché la lettura di righe da stdin è molto più lenta in C ++ di Python? e lo ha modificato solo leggermente. È un'ottima lettura per capire come contare rapidamente le linee, anche se wc -lè ancora circa il 75% più veloce di ogni altra cosa.

Ho ottenuto un piccolo miglioramento (4-8%) con questa versione che riutilizza un buffer costante in modo da evitare qualsiasi sovraccarico di memoria o GC:

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

Puoi giocare con la dimensione del buffer e forse vedere un piccolo miglioramento.

La risposta di Kyle

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

è probabilmente il migliore, un'alternativa per questo è

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

Ecco il confronto delle prestazioni di entrambi

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

Una soluzione di linea:

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

Il mio frammento:

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

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

Solo per completare i metodi sopra ho provato una variante con il modulo fileinput:

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

E ha passato un file di linee 60mil a tutti i metodi sopra indicati:

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

È una piccola sorpresa per me che fileinput sia così male e ridimensiona molto peggio di tutti gli altri metodi ...

Quanto a me questa variante sarà la più veloce:

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

motivi: buffering più veloce della lettura riga per riga ed string.countè anche molto veloce

Questo codice è più breve e più chiaro. È probabilmente il modo migliore:

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

Ho modificato il buffer case in questo modo:

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

Ora vengono contati anche i file vuoti e l'ultima riga (senza \ n).

Che dire di questo

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

Se si desidera ottenere il conteggio delle righe a buon mercato in Python in Linux, consiglio questo metodo:

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

file_path può essere sia percorso file astratto che percorso relativo. Spero che questo possa aiutare.

Cosa ne pensi di questo?

import fileinput
import sys

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

fileinput.close()
print counter

Che ne dici di questo one-liner:

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

Impiega 0,003 secondi usando questo metodo per cronometrarlo su un file di 3900 righe

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

Metodo semplice:

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

il risultato dell'apertura di un file è un iteratore, che può essere convertito in una sequenza, che ha una lunghezza:

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

questo è più conciso del tuo ciclo esplicito ed evita il enumerate.

È possibile utilizzare il os.pathmodulo nel modo seguente:

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

, dove si Filenametrova il percorso assoluto del file.

Se il file può adattarsi alla memoria, quindi

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