Como obter a contagem de linhas de um arquivo grande mais barato em Python?

Eu preciso obter uma contagem de linhas de um arquivo grande (centenas de milhares de linhas) em python. Qual é a maneira mais eficiente em termos de memória e tempo?

No momento eu faço:

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

é possível fazer melhor?

Você não pode ficar melhor do que isso.

Afinal, qualquer solução precisará ler o arquivo inteiro, descobrir quantas \nvocê possui e retornar esse resultado.

Você tem uma maneira melhor de fazer isso sem ler o arquivo inteiro? Não tenho certeza ... A melhor solução será sempre ligada à E / S, o melhor que você pode fazer é garantir que você não use memória desnecessária, mas parece que você a cobriu.

Uma linha, provavelmente bem rápida:

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

Acredito que um arquivo mapeado de memória será a solução mais rápida. Eu tentei quatro funções: a função postada pelo OP ( opcount); uma iteração simples sobre as linhas no arquivo ( simplecount); readline com um arquivo mapeado na memória (mmap) ( mapcount); e a solução de leitura de buffer oferecida por Mykola Kharechko ( bufcount).

Executei cada função cinco vezes e calculei o tempo médio de execução para um arquivo de texto de 1,2 milhão de linhas.

Windows XP, Python 2.5, 2 GB de RAM, processador AMD de 2 GHz

Aqui estão os meus resultados:

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

Edit : números para Python 2.6:

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

Portanto, a estratégia de leitura de buffer parece ser a mais rápida para Windows / Python 2.6

Aqui está o código:

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

Eu tive que postar isso em uma pergunta semelhante até que minha pontuação de reputação subisse um pouco (graças a quem me bateu!).

Todas essas soluções ignoram uma maneira de tornar essa execução consideravelmente mais rápida, usando a interface não armazenada em buffer (bruta), usando bytearrays e fazendo seu próprio buffer. (Isso só se aplica no Python 3. No Python 2, a interface bruta pode ou não ser usada por padrão, mas no Python 3, você usará o Unicode como padrão.)

Usando uma versão modificada da ferramenta de temporização, acredito que o código a seguir é mais rápido (e marginalmente mais pitônico) do que qualquer uma das soluções oferecidas:

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

Usando uma função de gerador separada, isso executa um smidge mais rápido:

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 )

Isso pode ser feito completamente com expressões de geradores in-line usando itertools, mas fica muito estranho:

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 )

Aqui estão os meus horários:

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

Você pode executar um subprocesso e executar 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])

Aqui está um programa python para usar a biblioteca de multiprocessamento para distribuir a contagem de linhas entre máquinas / núcleos. Meu teste melhora a contagem de um arquivo de linha de 20 milhões de 26 segundos para 7 segundos usando um servidor Windows 64 de 8 núcleos. Nota: não usar o mapeamento de memória torna as coisas muito mais lentas.

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

Uma solução bash de uma linha semelhante a esta resposta , usando a subprocess.check_outputfunção moderna :

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

Eu usaria o método de objeto de arquivo do Python readlines, da seguinte maneira:

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

Isso abre o arquivo, cria uma lista de linhas no arquivo, conta o comprimento da lista, salva isso em uma variável e fecha o arquivo novamente.

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

Aqui está o que eu uso, parece bastante limpo:

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

ATUALIZAÇÃO: Isso é marginalmente mais rápido do que usar python puro, mas ao custo do uso de memória. O subprocesso bifurcará um novo processo com o mesmo espaço de memória que o processo pai enquanto ele executa seu comando.

Esta é a coisa mais rápida que eu encontrei usando python puro. Você pode usar a quantidade de memória desejada configurando o buffer, embora 2 ** 16 pareça ser um ponto ideal no meu computador.

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

Encontrei a resposta aqui Por que a leitura de linhas do stdin é muito mais lenta em C ++ que no Python? e ajustou um pouquinho. É uma leitura muito boa para entender como contar linhas rapidamente, embora wc -lainda seja 75% mais rápido do que qualquer outra coisa.

Eu obtive uma pequena melhoria (4-8%) com esta versão que reutiliza um buffer constante para evitar qualquer sobrecarga de memória ou GC:

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

Você pode brincar com o tamanho do buffer e talvez ver uma pequena melhoria.

Resposta de Kyle

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

provavelmente é o melhor, uma alternativa para isso é

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

Aqui está a comparação do desempenho de ambos

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

Solução de uma linha:

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

Meu trecho:

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

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

Apenas para concluir os métodos acima, tentei uma variante com o módulo fileinput:

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

E passou um arquivo de linhas de 60mil para todos os métodos acima mencionados:

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

É uma pequena surpresa para mim que a entrada de arquivo seja tão ruim e tenha uma escala muito pior do que todos os outros métodos ...

Quanto a mim, essa variante será a mais rápida:

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

razões: armazenar em buffer mais rapidamente do que ler linha por linha e string.counttambém é muito rápido

Este código é mais curto e mais claro. Provavelmente é a melhor maneira:

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

Eu modifiquei o caso do buffer assim:

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

Agora também os arquivos vazios e a última linha (sem \ n) são contados.

Que tal isso

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 alguém quiser obter a contagem de linhas mais barata no Python no Linux, recomendo este método:

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

file_path pode ser o caminho abstrato do arquivo ou o caminho relativo. Espero que isso possa ajudar.

Que tal agora?

import fileinput
import sys

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

fileinput.close()
print counter

Que tal esse one-liner:

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

Demora 0,003 segundos usando esse método para cronometrar em um arquivo de linha 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

Método simples:

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

o resultado da abertura de um arquivo é um iterador, que pode ser convertido em uma sequência com um comprimento:

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

isso é mais conciso do que seu loop explícito e evita o enumerate.

Você pode usar o os.pathmódulo da seguinte maneira:

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

, onde Filenameé o caminho absoluto do arquivo.

Se o arquivo puder caber na memória,

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