පයිතන් හි විශාල ගොනුවක පේළි ගණන ලාභදායී ලෙස ලබා ගන්නේ කෙසේද?

මට විශාල ගොනුවක (පේළි සිය දහස් ගණනක්) පයිතන්වල රේඛා ගණනක් ලබා ගැනීමට අවශ්‍යයි. මතකය හා වේලාව අනුව වඩාත් කාර්යක්ෂම ක්‍රමය කුමක්ද?

මේ මොහොතේ මම කරන්නේ:

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

මීට වඩා හොඳ දෙයක් කළ හැකිද?

ඔබට ඊට වඩා හොඳක් ලබා ගත නොහැක.

සියල්ලට පසු, ඕනෑම විසඳුමකට සම්පූර්ණ ගොනුව කියවීමට, \nඔබ සතුව කොපමණ ප්‍රමාණයක් තිබේදැයි සොයා බලා එම ප්‍රති .ලය ලබා දිය යුතුය.

සම්පූර්ණ ගොනුව කියවීමෙන් තොරව ඔබට එය කිරීමට වඩා හොඳ ක්‍රමයක් තිබේද? විශ්වාස නැත ... හොඳම විසඳුම සැමවිටම I / O- බැඳී ඇත, ඔබට කළ හැකි හොඳම දෙය නම් ඔබ අනවශ්‍ය මතකය භාවිතා නොකරන බවට වග බලා ගැනීමයි, නමුත් එය ඔබ ආවරණය කර ඇති බව පෙනේ.

එක් පේළියක්, බොහෝ විට ඉතා වේගවත්:

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

මතක සිතියම්ගත කළ ගොනුවක් වේගවත්ම විසඳුම වනු ඇතැයි මම විශ්වාස කරමි. මම කාර්යයන් හතරක් උත්සාහ කළෙමි: OP ( opcount) විසින් පළ කරන ලද ශ්‍රිතය ; ( simplecount) ගොනුවේ ඇති රේඛාවලට වඩා සරල පුනරාවර්තනයක් ; මතක සිතියම්ගත කර ඇති කියවීම් රේඛාව (mmap) ( mapcount); සහ මයිකොලා කරෙච්කෝ ( bufcount) විසින් පිරිනමන බෆරය කියවීමේ විසඳුම .

මම එක් එක් ශ්‍රිතය පස් වතාවක් ධාවනය කළ අතර, පේළි මිලියන 1.2 ක පෙළ ගොනුවක් සඳහා සාමාන්‍ය ධාවන කාලය ගණනය කළෙමි.

වින්ඩෝස් එක්ස්පී, පයිතන් 2.5, 2 ජීබී RAM, 2 GHz AMD ප්‍රොසෙසරය

මෙන්න මගේ ප්‍රති results ල:

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

සංස්කරණය කරන්න : පයිතන් 2.6 සඳහා අංක:

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

එබැවින් බෆර් කියවීමේ උපාය වින්ඩෝස් / පයිතන් 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))

මගේ කීර්ති නාමය මඳක් ඉහළ යන තෙක් මට මෙය සමාන ප්‍රශ්නයක පළ කිරීමට සිදු විය (මට ගැසූ ඕනෑම කෙනෙකුට ස්තූතියි!).

මෙම සියලු විසඳුම් සැලකිය යුතු වේගයකින් ධාවනය කිරීම සඳහා එක් ක්‍රමයක් නොසලකා හරියි, එනම් නොනවතින (අමු) අතුරුමුහුණත භාවිතා කිරීම, බයිට්රේ භාවිතා කිරීම සහ ඔබේම බෆරින් කිරීම. (මෙය අදාළ වන්නේ පයිතන් 3 හි පමණි. පයිතන් 2 හි, අමු අතුරු මුහුණත පෙරනිමියෙන් භාවිතා කිරීමට හෝ භාවිතා කිරීමට ඉඩ ඇත, නමුත් පයිතන් 3 හි, ඔබ පෙරනිමියෙන් යුනිකෝඩ් වෙත පිවිසෙනු ඇත.)

කාල මෙවලමෙහි නවීකරණය කරන ලද අනුවාදයක් භාවිතා කරමින්, පහත දැක්වෙන කේතය ඉදිරිපත් කරන ඕනෑම විසඳුමකට වඩා වේගවත් (හා සුළු වශයෙන් පයිතොනික්) යැයි මම විශ්වාස කරමි:

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 )

ඉටර්ටූල් භාවිතා කරමින් පේළියේ උත්පාදක ප්‍රකාශන සමඟ මෙය සම්පූර්ණයෙන්ම කළ හැකිය, නමුත් එය අමුතු පෙනුමක් ලබා ගනී:

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

යන්ත්‍ර / හර හරහා රේඛා ගණනය කිරීම බෙදා හැරීම සඳහා බහු සැකසුම් පුස්තකාලය භාවිතා කිරීම සඳහා පයිතන් වැඩසටහනක් මෙන්න. මගේ පරීක්ෂණය මගින් මූලික වින්ඩෝස් 64 සේවාදායකයක් භාවිතා කරමින් තත්පර 26 සිට තත්පර 7 දක්වා මිලියන 20 ක රේඛීය ගොනුවක් ගණනය කිරීම වැඩි දියුණු කරයි. සටහන: මතක සිතියම්කරණය භාවිතා නොකිරීම දේවල් මන්දගාමී කරයි.

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

මම readlinesපහත පරිදි පයිතන්ගේ ගොනු වස්තු ක්‍රමය භාවිතා කරමි :

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

මෙය ගොනුව විවෘත කරයි, ගොනුවේ පේළි ලැයිස්තුවක් සාදයි, ලැයිස්තුවේ දිග ගණනය කරයි, එය විචල්‍යයකට ඉතිරි කර ගොනුව නැවත වසා දමයි.

පිරිසිදු පයිතන් භාවිතයෙන් මා සොයාගත් වේගවත්ම දේ මෙයයි. 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), ''))

මට මෙහි පිළිතුර හමු විය පයිතන්ට වඩා C ++ හි stdin වෙතින් රේඛා කියවීම මන්දගාමී වන්නේ ඇයි? එය ඉතා සුළු වශයෙන් වෙනස් කළා. පේළි ඉක්මණින් ගණනය කරන්නේ කෙසේද යන්න තේරුම් ගැනීමට එය ඉතා හොඳ කියවීමකි, නමුත් wc -lසියල්ලටම වඩා 75% ක් පමණ වේගවත්ය.

මෙන්න මම භාවිතා කරන දේ, පිරිසිදු බව පෙනේ:

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

යාවත්කාලීන කිරීම: මෙය පිරිසිදු පයිතන් භාවිතා කිරීමට වඩා සුළු වේගයකින් සිදු වන නමුත් මතක භාවිතය සඳහා වන වියදමෙන්. උප ක්‍රියාවලිය මඟින් ඔබේ විධානය ක්‍රියාත්මක කරන අතරම මව් ක්‍රියාවලියට සමාන මතක සටහන් සහිත නව ක්‍රියාවලියක් සිදු කරයි.

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

මෙම අනුවාදය සමඟ මට කුඩා (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

ඉහත ක්‍රම සම්පූර්ණ කිරීම සඳහා මම ගොනු ආදාන මොඩියුලය සමඟ ප්‍රභේදයක් උත්සාහ කළෙමි:

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

ඉහත සඳහන් සියලු ක්‍රම සඳහා මිලි 60 රේඛා ගොනුවක් සම්මත කළේය:

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

දැන් හිස් ලිපිගොනු සහ අවසාන පේළිය (without n නොමැතිව) ගණනය කෙරේ.

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

යමෙකුට ලිනක්ස් හි පයිතන් හි රේඛීය ගණන ලාභදායී ලෙස ලබා ගැනීමට අවශ්‍ය නම්, මම මෙම ක්‍රමය නිර්දේශ කරමි:

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

file_path වියුක්ත ගොනු මාර්ගය හෝ සාපේක්ෂ මාර්ගය විය හැකිය. මෙය උපකාරී වේ යැයි සිතමි.

මේ ගැන කුමක් කිව හැකිද?

def file_len(fname):
  counts = itertools.count()
  with open(fname) as f: 
    for _ in f: counts.next()
  return counts.next()

කොහොමද මේ?

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

පේළි 3900 ක ගොනුවක වේලාව සැකසීමට තත්පර 0.003 ක් ගතවේ

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

ගොනුවක් විවෘත කිරීමේ ප්‍රති result ලය අනුකාරකයක් වන අතර එය අනුක්‍රමයකට පරිවර්තනය කළ හැකිය, එහි දිග ඇත:

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