Jak tanio uzyskać liczbę wierszy dużego pliku w Pythonie?

Potrzebuję uzyskać liczbę wierszy dużego pliku (setki tysięcy linii) w pythonie. Jaki jest najbardziej efektywny sposób pod względem pamięci i czasu?

W tej chwili robię:

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

czy można zrobić coś lepszego?

Nie ma nic lepszego niż to.

W końcu każde rozwiązanie będzie musiało przeczytać cały plik, dowiedzieć się, ile \nmasz i zwrócić ten wynik.

Czy masz lepszy sposób, aby to zrobić bez czytania całego pliku? Nie jestem pewien ... Najlepszym rozwiązaniem zawsze będzie I / O, najlepiej, abyś nie używał niepotrzebnej pamięci, ale wygląda na to, że ją masz.

Jedna linia, prawdopodobnie dość szybka:

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

Wierzę, że plik odwzorowany w pamięci będzie najszybszym rozwiązaniem. Próbowałem czterech funkcji: funkcja wysłana przez OP ( opcount); prosta iteracja po liniach w pliku ( simplecount); readline z plikiem zmapowanym w pamięci (mmap) ( mapcount); oraz rozwiązanie odczytu bufora oferowane przez Mykola Kharechko ( bufcount).

Uruchomiłem każdą funkcję pięć razy i obliczyłem średni czas działania dla pliku tekstowego o wielkości 1,2 miliona wierszy.

Windows XP, Python 2.5, 2 GB pamięci RAM, procesor AMD 2 GHz

Oto moje wyniki:

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

Edycja : liczby dla Python 2.6:

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

Tak więc strategia odczytu buforów wydaje się być najszybsza dla Windows / Python 2.6

Oto kod:

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

Musiałem napisać to na podobne pytanie, dopóki moja ocena reputacji nieco nie podskoczyła (dzięki temu, kto mnie uderzył!).

Wszystkie te rozwiązania ignorują jeden ze sposobów na przyspieszenie tego działania, a mianowicie użycie niebuforowanego (surowego) interfejsu, używanie bajtów i tworzenie własnego bufora. (Dotyczy to tylko Pythona 3. W Pythonie 2 domyślny interfejs może, ale nie musi być używany, ale w Pythonie 3 domyślnie zostanie ustawiony Unicode.)

Korzystając ze zmodyfikowanej wersji narzędzia do pomiaru czasu, uważam, że następujący kod jest szybszy (i nieznacznie bardziej pythoniczny) niż którekolwiek z oferowanych rozwiązań:

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

Korzystanie z osobnej funkcji generatora przyspiesza smidge:

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 )

Można to zrobić całkowicie za pomocą wyrażeń generatorów wbudowanych za pomocą itertools, ale robi się dość dziwnie:

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 )

Oto moje czasy:

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

Możesz wykonać podproces i uruchomić 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])

Oto program w języku Python, który wykorzystuje bibliotekę wieloprocesową do dystrybucji liczenia linii między maszynami / rdzeniami. Mój test poprawia liczenie 20-milionowego pliku linii od 26 sekund do 7 sekund przy użyciu 8-rdzeniowego serwera Windows 64. Uwaga: nieużywanie mapowania pamięci znacznie spowalnia działanie.

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

Jednowierszowe rozwiązanie bashowe podobne do tej odpowiedzi , wykorzystujące nowoczesną subprocess.check_outputfunkcję:

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

Chciałbym użyć metody obiektu pliku Pythona w readlinesnastępujący sposób:

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

To otwiera plik, tworzy listę linii w pliku, liczy długość listy, zapisuje ją w zmiennej i ponownie zamyka plik.

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

Oto, czego używam, wydaje się całkiem czysty:

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

AKTUALIZACJA: Jest to nieznacznie szybsze niż używanie czystego Pythona, ale kosztem użycia pamięci. Podproces rozwidli nowy proces z takim samym obszarem pamięci, jak proces nadrzędny podczas wykonywania polecenia.

Jest to najszybsza rzecz, jaką znalazłem, używając czystego pytona. Możesz użyć dowolnej ilości pamięci, ustawiając bufor, chociaż 2 ** 16 wydaje się być dobrym miejscem na moim komputerze.

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

Znalazłem odpowiedź tutaj Dlaczego czytanie linii ze standardowego wejścia w C ++ jest znacznie wolniejsze niż w Pythonie? i trochę poprawiłem. To bardzo dobra lektura, aby zrozumieć, jak szybko liczyć wiersze, choć wc -lnadal jest o 75% szybsza niż cokolwiek innego.

Uzyskałem niewielką (4-8%) poprawę w tej wersji, która ponownie wykorzystuje stały bufor, więc powinna unikać jakiegokolwiek narzutu pamięci lub GC:

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

Możesz bawić się z rozmiarem bufora i być może zauważyć niewielką poprawę.

Odpowiedź Kyle'a

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

jest prawdopodobnie najlepsza, alternatywą jest

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

Oto porównanie wydajności obu

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

Rozwiązanie jednoliniowe:

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

Mój fragment:

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

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

Aby wykonać powyższe metody, wypróbowałem wariant z modułem fileinput:

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

I przekazałem plik linii 60 mil do wszystkich wyżej wymienionych metod:

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

To dla mnie małe zaskoczenie, że dane wejściowe są tak złe i skalują się znacznie gorzej niż wszystkie inne metody ...

Jak dla mnie ten wariant będzie najszybszy:

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

Powody: buforowanie jest szybsze niż czytanie linia po linii, a string.counttakże bardzo szybkie

Ten kod jest krótszy i bardziej przejrzysty. To chyba najlepszy sposób:

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

Zmodyfikowałem przypadek bufora w następujący sposób:

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

Teraz liczone są także puste pliki i ostatni wiersz (bez \ n).

A co z tym

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

Jeśli chcesz taniej uzyskać liczbę wierszy w Pythonie w Linuksie, polecam tę metodę:

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

ścieżka_pliku może być zarówno ścieżką abstrakcyjną, jak i ścieżką względną. Mam nadzieję, że to może pomóc.

Co powiesz na to?

import fileinput
import sys

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

fileinput.close()
print counter

Co powiesz na ten liniowiec:

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

Zastosowanie tej metody zajmuje 0,003 s, aby zmierzyć czas w pliku linii 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

Prosta metoda:

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

wynikiem otwarcia pliku jest iterator, który można przekonwertować na sekwencję o długości:

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

jest to bardziej zwięzłe niż twoja wyraźna pętla i pozwala uniknąć enumerate.

Możesz użyć os.pathmodułu w następujący sposób:

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

, gdzie Filenamejest bezwzględna ścieżka do pliku.

Jeśli plik zmieści się w pamięci, to

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