පයිතන් සහ සී ++ භාවිතා කරමින් ස්ටැඩින් වෙතින් කියවීමේ රේඛා කියවීම සැසඳීමට මට අවශ්ය වූ අතර මගේ සී ++ කේතය සමාන පයිතන් කේතයට වඩා විශාල අනුපිළිවෙලක් ධාවනය වන බව දැක කම්පනයට පත් විය. මගේ C ++ මලකඩ නිසා සහ මම තවමත් පයිතොනිස්ටා විශේෂ expert යෙකු නොවන බැවින්, කරුණාකර මට කියන්න මම යම්කිසි වැරැද්දක් කරන්නේ නම් හෝ මම යමක් වරදවා වටහාගෙන ඇත්නම්.
(TLDR පිළිතුර: ප්‍රකාශය ඇතුළත් කරන්න: cin.sync_with_stdio(false)නැතහොත් fgetsඒ වෙනුවට භාවිතා කරන්න.
ටීඑල්ඩීආර් ප්‍රති results ල: මගේ ප්‍රශ්නයේ පහළට පහළට අනුචලනය කර මේසය දෙස බලන්න.)
සී ++ කේතය:
#include <iostream>
#include <time.h>
using namespace std;
int main() {
string input_line;
long line_count = 0;
time_t start = time(NULL);
int sec;
int lps;
while (cin) {
getline(cin, input_line);
if (!cin.eof())
line_count++;
};
sec = (int) time(NULL) - start;
cerr << "Read " << line_count << " lines in " << sec << " seconds.";
if (sec > 0) {
lps = line_count / sec;
cerr << " LPS: " << lps << endl;
} else
cerr << endl;
return 0;
}
// Compiled with:
// g++ -O3 -o readline_test_cpp foo.cpp
පයිතන් සමාන:
#!/usr/bin/env python
import time
import sys
count = 0
start = time.time()
for line in sys.stdin:
count += 1
delta_sec = int(time.time() - start_time)
if delta_sec >= 0:
lines_per_sec = int(round(count/delta_sec))
print("Read {0} lines in {1} seconds. LPS: {2}".format(count, delta_sec,
lines_per_sec))
මෙන්න මගේ ප්‍රති results ල:
$ cat test_lines | ./readline_test_cpp
Read 5570000 lines in 9 seconds. LPS: 618889
$cat test_lines | ./readline_test.py
Read 5570000 lines in 1 seconds. LPS: 5570000
මැක් ඕඑස් එක්ස් වී 10.6.8 (හිම දිවියා) සහ ලිනක්ස් 2.6.32 (රෙඩ් හැට් ලිනක්ස් 6.2) යටතේ මම මෙය උත්සාහ කළ බව සැලකිල්ලට ගත යුතුය. පළමුවැන්න මැක්බුක් ප්‍රෝ එකක් වන අතර දෙවැන්න ඉතා මී මැසි සේවාදායකයකි, මෙය එතරම් අදාළ නොවේ.
$ for i in {1..5}; do echo "Test run $i at `date`"; echo -n "CPP:"; cat test_lines | ./readline_test_cpp ; echo -n "Python:"; cat test_lines | ./readline_test.py ; done
Test run 1 at Mon Feb 20 21:29:28 EST 2012
CPP: Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 2 at Mon Feb 20 21:29:39 EST 2012
CPP: Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 3 at Mon Feb 20 21:29:50 EST 2012
CPP: Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 4 at Mon Feb 20 21:30:01 EST 2012
CPP: Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 5 at Mon Feb 20 21:30:11 EST 2012
CPP: Read 5570001 lines in 10 seconds. LPS: 557000
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
කුඩා මිණුම් දණ්ඩ එකතු කිරීම සහ නැවත සකස් කිරීම
සම්පූර්ණත්වය සඳහා, මුල් (සමමුහුර්ත) C ++ කේතය සමඟ එකම කොටුවේ එකම ගොනුව සඳහා කියවීමේ වේගය යාවත්කාලීන කිරීමට මම සිතුවෙමි. නැවතත්, මෙය වේගවත් තැටියක 100M රේඛා ගොනුවක් සඳහා වේ. විසඳුම් / ප්‍රවේශයන් කිහිපයක් සමඟ සංසන්දනය මෙන්න:
Implementation Lines per second
python (default) 3,571,428
cin (default/naive) 819,672
cin (no sync) 12,500,000
fgets 14,285,714
wc (not fair comparison) 54,644,808
<iostream>කාර්ය සාධනය උරා ගනී. එය සිදු වූ පළමු අවස්ථාව නොවේ. 2) පයිතන් ඔබ ලූපය සඳහා දත්ත පිටපත් නොකිරීමට තරම් දක්ෂය. ඔබ භාවිතා කිරීමට උත්සාහ යළි හැකි scanfසහ char[]. විකල්පයක් ලෙස ඔබට ලූපය නැවත ලිවීමට උත්සාහ කළ හැකිය, එවිට යමක් නූල් සමඟ කළ හැකිය (උදා: 5 වන අකුර තබාගෙන ප්‍රති result ලයක් ලෙස එය සංයුක්ත කරන්න).
cin.eof()!! මෙම දාන්න getlineඇති 'if` ප්රකාශයක් බවට ඇමතුමක්.
wc -lඑය වේගවත් වන්නේ එය වරකට එක පේළියකට වඩා ධාරාව කියවන බැවිනි (එය fread(stdin)/memchr('\n')සංයෝජනය විය හැකිය ). පයිතන් wc-l.py