Comment obtenir le nombre de lignes d'un gros fichier à moindre coût en Python?

J'ai besoin d'obtenir le nombre de lignes d'un gros fichier (des centaines de milliers de lignes) en python. Quelle est la manière la plus efficace à la fois en termes de mémoire et de temps?

En ce moment je fais:

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

est-il possible de faire mieux?

Vous ne pouvez pas faire mieux que ça.

Après tout, toute solution devra lire l'intégralité du fichier, déterminer combien \nvous en avez et retourner ce résultat.

Avez-vous une meilleure façon de procéder sans lire l'intégralité du fichier? Pas sûr ... La meilleure solution sera toujours liée aux E / S, le mieux que vous puissiez faire est de vous assurer que vous n'utilisez pas de mémoire inutile, mais il semble que vous ayez couvert cela.

Une ligne, probablement assez rapide:

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

Je pense qu'un fichier mappé en mémoire sera la solution la plus rapide. J'ai essayé quatre fonctions: la fonction publiée par l'OP ( opcount); une simple itération sur les lignes du fichier ( simplecount); readline avec un fichier mappé en mémoire (mmap) ( mapcount); et la solution de lecture tampon proposée par Mykola Kharechko (bufcount ).

J'ai exécuté chaque fonction cinq fois et calculé la durée d'exécution moyenne d'un fichier texte de 1,2 million de lignes.

Windows XP, Python 2.5, 2 Go de RAM, processeur AMD 2 GHz

Voici mes résultats:

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

Edit : nombres pour Python 2.6:

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

La stratégie de lecture du tampon semble donc être la plus rapide pour Windows / Python 2.6

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

J'ai dû poster ceci sur une question similaire jusqu'à ce que mon score de réputation ait un peu augmenté (merci à celui qui m'a cogné!).

Toutes ces solutions ignorent une façon d'accélérer considérablement l'exécution, à savoir en utilisant l'interface non tamponnée (brute), en utilisant des tableaux de bord et en effectuant votre propre mise en mémoire tampon. (Cela ne s'applique qu'à Python 3. Dans Python 2, l'interface brute peut ou non être utilisée par défaut, mais dans Python 3, vous utiliserez par défaut Unicode.)

En utilisant une version modifiée de l'outil de synchronisation, je pense que le code suivant est plus rapide (et légèrement plus pythonique) que toutes les solutions proposées:

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

En utilisant une fonction de générateur séparée, cela fonctionne plus rapidement:

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 )

Cela peut être fait complètement avec des expressions de générateurs en ligne à l'aide d'itertools, mais cela devient assez étrange:

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 )

Voici mes horaires:

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

Vous pouvez exécuter un sous-processus et exécuter 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])

Voici un programme python pour utiliser la bibliothèque multiprocesseurs pour distribuer le comptage de lignes sur les machines / cœurs. Mon test améliore le comptage d'un fichier de 20 millions de lignes de 26 secondes à 7 secondes en utilisant un serveur Windows 64 à 8 cœurs. Remarque: ne pas utiliser le mappage de mémoire rend les choses beaucoup plus lentes.

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

Une solution bash d'une ligne similaire à cette réponse , utilisant la subprocess.check_outputfonction moderne :

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

J'utiliserais la méthode d'objet fichier de Python readlines, comme suit:

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

Cela ouvre le fichier, crée une liste de lignes dans le fichier, compte la longueur de la liste, l'enregistre dans une variable et ferme à nouveau le fichier.

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

Voici ce que j'utilise, semble assez propre:

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

MISE À JOUR: C'est légèrement plus rapide que l'utilisation de python pur, mais au détriment de l'utilisation de la mémoire. Le sous-processus va générer un nouveau processus avec la même empreinte mémoire que le processus parent pendant qu'il exécute votre commande.

C'est la chose la plus rapide que j'ai trouvée en utilisant du python pur. Vous pouvez utiliser la quantité de mémoire que vous souhaitez en définissant un tampon, bien que 2 ** 16 semble être un point idéal sur mon ordinateur.

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

J'ai trouvé la réponse ici Pourquoi la lecture des lignes de stdin est-elle beaucoup plus lente en C ++ qu'en Python? et l'ajusté juste un tout petit peu. C'est une très bonne lecture pour comprendre comment compter les lignes rapidement, bien qu'il wc -lsoit toujours environ 75% plus rapide qu'autre chose.

J'ai obtenu une petite amélioration (4-8%) avec cette version qui réutilise un tampon constant afin d'éviter toute surcharge mémoire ou GC:

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

Vous pouvez jouer avec la taille du tampon et peut-être voir une petite amélioration.

La réponse de Kyle

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

est probablement le meilleur, une alternative pour cela est

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

Voici la comparaison des performances des deux

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

Solution en une ligne:

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

Mon extrait:

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

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

Juste pour compléter les méthodes ci-dessus, j'ai essayé une variante avec le module fileinput:

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

Et passé un fichier de lignes de 60mil à toutes les méthodes indiquées ci-dessus:

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

C'est une petite surprise pour moi que l'entrée de fichier soit si mauvaise et évolue bien pire que toutes les autres méthodes ...

Quant à moi, cette variante sera la plus rapide:

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

raisons: tampon plus rapide que la lecture ligne par ligne et string.countest également très rapide

Ce code est plus court et plus clair. C'est probablement le meilleur moyen:

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

J'ai modifié le boîtier tampon comme ceci:

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

Désormais, les fichiers vides et la dernière ligne (sans \ n) sont également comptés.

Et ça

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

Si l'on veut obtenir le nombre de lignes à moindre coût en Python sous Linux, je recommande cette méthode:

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

file_path peut être à la fois un chemin de fichier abstrait ou un chemin relatif. J'espère que cela peut vous aider.

Que dis-tu de ça?

import fileinput
import sys

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

fileinput.close()
print counter

Que diriez-vous de ce one-liner:

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

Prend 0,003 s en utilisant cette méthode pour le chronométrer sur un fichier de 3900 lignes

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éthode simple:

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

le résultat de l'ouverture d'un fichier est un itérateur, qui peut être converti en une séquence, qui a une longueur:

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

c'est plus concis que votre boucle explicite et évite le enumerate.

Vous pouvez utiliser le os.pathmodule de la manière suivante:

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

, où Filenameest le chemin absolu du fichier.

Si le fichier peut tenir en mémoire, alors

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