Як дешево отримати лінійку великого файлу в Python?

Мені потрібно отримати кількість рядків великого файлу (сотні тисяч рядків) у python. Що є найбільш ефективним способом пам'яті та часу?

На даний момент я:

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

чи можна зробити щось краще?

Ти не можеш стати кращим за це.

Зрештою, будь-яке рішення доведеться прочитати весь файл, з'ясувати, скільки у \nвас є, і повернути цей результат.

Чи є у вас кращий спосіб зробити це, не читаючи весь файл? Не впевнений ... Найкращим рішенням завжди буде зв’язок вводу / виводу. Найкраще, що ви можете зробити, це переконайтеся, що ви не використовуєте зайву пам'ять, але схоже, що у вас є це.

Один рядок, напевно, досить швидко:

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

Я вірю, що файл, який відображається на пам'ять, буде найшвидшим рішенням. Я спробував чотири функції: функцію, розміщену OP ( opcount); проста ітерація рядків у файлі ( simplecount); читальна лінія з поданим на карту пам'яті файлом (mmap) ( mapcount); і рішення для читання буфера, яке пропонував Микола Харечко ( bufcount).

Я виконував кожну функцію п'ять разів і обчислював середній час виконання для 1,2-мільйонного текстового файлу.

Windows XP, Python 2.5, 2 Гб оперативної пам’яті, процесор AMD 2 ГГц

Ось мої результати:

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

Редагувати : числа для Python 2.6:

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

Тому стратегія зчитування буфера здається найшвидшою для Windows / Python 2.6

Ось код:

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

Мені довелося розмістити це на подібному питанні, поки мій показник репутації трохи не підскочив (дякую тому, хто мене натрапив!).

Усі ці рішення ігнорують один із способів зробити цей запуск значно швидшим, а саме за допомогою розблокованого (необробленого) інтерфейсу, використання байтарейних масивів та власного буферизації. (Це стосується лише Python 3. У Python 2 необроблений інтерфейс може використовуватися або не використовуватись за замовчуванням, але в Python 3 ти будеш типово встановлений у Unicode.)

Використовуючи модифіковану версію інструменту синхронізації, я вважаю, що наступний код швидший (і дещо пітонічніший), ніж будь-яке із запропонованих рішень:

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

Використовуючи окрему функцію генератора, цей запуск швидше:

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 )

Це можна зробити повністю з вбудованими виразами генераторів, використовуючи itertools, але він виглядає досить дивно:

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 )

Ось мої таймінги:

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

Ви можете виконати підпроцес і запустити 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])

Ось програма python для використання багатопроцесорної бібліотеки для розподілу підрахунку рядків по машинам / ядрам. Мій тест покращує підрахунок 20-мільйонного файлу рядків від 26 секунд до 7 секунд за допомогою 8-ядерного сервера Windows 64. Примітка: не використання карти пам'яті робить ситуацію набагато повільнішою.

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

Однорядковий баш-рішення, подібний до цієї відповіді , використовуючи сучасну subprocess.check_outputфункцію:

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

Я б використовував метод файлового об'єкта Python readlinesтаким чином:

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

Це відкриває файл, створює список рядків у файлі, підраховує довжину списку, зберігає його до змінної і знову закриває файл.

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

Ось те, що я використовую, здається досить чистим:

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

ОНОВЛЕННЯ: Це незначно швидше, ніж використання чистого пітона, але ціною використання пам'яті. Підпроцес розкладе новий процес з тим самим слідом пам’яті, що і батьківський процес, поки він виконує вашу команду.

Це найшвидше, що я знайшов, використовуючи чистий пітон. Ви можете використовувати будь-який обсяг пам’яті, який хочете, встановивши буфер, хоча 2 ** 16 здається милим місцем на моєму комп’ютері.

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

Тут я знайшов відповідь Чому читання рядків із stdin набагато повільніше в C ++, ніж у Python? і переробили це просто крихітним шматочком. Це дуже добре читати, щоб зрозуміти, як швидко рахувати рядки, хоча wc -lце все-таки на 75% швидше, ніж все інше.

Я отримав невелике (4-8%) поліпшення в цій версії, яка повторно використовує постійний буфер, тому він повинен уникати будь-якої пам'яті або GC накладних витрат:

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

Ви можете пограти з розміром буфера і, можливо, побачити трохи покращення.

Відповідь Кайла

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

Мабуть, найкраща, альтернатива цьому є

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

Ось порівняння продуктивності обох

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

Рішення з однієї лінії:

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

Мій фрагмент:

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

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

Просто для виконання вищевказаних методів я спробував варіант із модулем fileinput:

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

І передав файл рядків 60mil до всіх вищезазначених методів:

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

Для мене трохи несподівано, що введення файлів - це погано і масштабується набагато гірше, ніж усі інші методи ...

Як на мене, цей варіант буде найшвидшим:

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

причини: буферизація швидше, ніж читання рядка за рядком, а string.countтакож дуже швидке

Цей код коротший і чіткіший. Це, мабуть, найкращий спосіб:

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

Я змінив корпус буфера так:

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

Тепер також рахуються порожні файли та останній рядок (без \ n).

Як що до цього

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

Якщо ви хочете отримати дешевий підрахунок рядків у Python в Linux, я рекомендую такий спосіб:

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

file_path може бути як абстрактним шляхом до файлу, так і відносним шляхом. Сподіваюся, це може допомогти.

Як щодо цього?

import fileinput
import sys

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

fileinput.close()
print counter

Як щодо цього однолінійного:

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

За допомогою цього методу потрібно 0,003 сек, щоб розмістити його у файлі 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

Простий метод:

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

Результатом відкриття файлу є ітератор, який можна перетворити на послідовність, що має довжину:

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

це більш стисло, ніж ваш явний цикл, і уникає enumerate.

Ви можете використовувати os.pathмодуль наступним чином:

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

, де Filenameабсолютний шлях до файлу.

Якщо файл може вміститись у пам'яті, то

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