प्रति सेकंड लाइनों की विशेष गति से टर्मिनल में कैट फ़ाइल

Question

मैं आलसी हूं और मैं ऐसा करने के लिए एक स्क्रिप्ट लिख सकता हूं, लेकिन मैं यह सोचने के लिए बहुत आलसी हूं कि यह कैसे किया जाए।

मैं अक्सर ऐसी चीजें करता हूं:

cris$ python runexperiment.py > output.txt
cris$ cat output.txt

कभी-कभी किसी प्रयोग के लंबे आउटपुट को देखते हुए मैं पृष्ठ को केवल स्क्रॉल करना चाहता हूं और क्रमिक पैटर्न को देखना और फैलाना चाहता हूं। लेकिन 1 मिलियन लाइनों वाली फ़ाइल पर बिल्ली का उपयोग करना शायद 5 सेकंड में खत्म हो जाए। यह मेरे लिए भी बहुत जल्दी है।

क्या कोई तरीका है कि मैं फ़ाइल को देखने की गति को धीमा कर सकता हूं, 'स्क्रॉल उपयोगिता' जैसा कुछ? मैं तेजी से चाहता हूं, लेकिन 200k लाइनें एक सेकंड (सभी जिनमें संभवतः प्रदर्शन कभी भी पंजीकृत नहीं होगा)।

कुछ इस तरह

cris$ scroll -lps=300 output.txt

और फिर वापस बैठकर प्रति सेकंड रोल 300 लाइनों को देखना आदर्श होगा, मैं कल्पना करता हूं।

Comments

कुछ ऐसा आजमाएं cat FILENAME | pv -l -L 900 -q। सीमा प्रति सेकंड बाइट्स में है, प्रति सेकंड लाइनें नहीं है, इसलिए मैं यह एक टिप्पणी कर रहा हूं जवाब नहीं।

— डेविड श्वार्ट्ज

ठीक है कि एक अच्छी उपयोगिता है, और यह भाग में काम करता है। लेकिन हां, यह थोड़ा तड़का हुआ है क्योंकि यह बीपीएस के बाद जाता है।

— संकट स्ट्रींगफेलो

Answer 1

कई उपयोगिताओं हैं जो आपको एक दर निर्दिष्ट करते हैं, जैसे pv, लेकिन यह प्रति सेकंड बाइट्स में दर है, प्रति सेकंड लाइनें नहीं।

लेकिन अगर आप वास्तव में lps का उपयोग करना चाहते हैं, तो आप ऐसा कर सकते हैं:

perl -e 'print && select undef,undef,undef,.00333 while <>;'

पर्ल के तहत, स्विच print while <>द्वारा प्रतिस्थापित किया जा सकता है -p:

perl -pe 'select undef,undef,undef,.00333'

कोशिश करते हैं:

time /bin/ls -l /usr/bin | perl -pe 'select undef,undef,undef,.00333' | wc
   2667   24902  171131

real    0m9.173s
user    0m0.056s
sys     0m0.048s

bc -l < <(echo 2667/9.173)
290.74457647443584432573

स्पष्टीकरण:

• 300 लाइनों / सेकंड का मतलब 1 लाइन 0.0033333333 सेकंड्स से है।

• printबिना तर्क प्रिंट $_जो डिफ़ॉल्ट इनपुट स्पेस है ।

• जैसा कि कहा जाता है ... | perl -e, ... | perl -neया ... | perl -pe, मानक इनपुट को स्वचालित रूप से असाइन किया जाएगा *STDINजिसे डिफ़ॉल्ट फ़ाइल डिस्क्रिप्टर को सौंपा गया है , इसलिए <>वही <STDIN>करेगा जो मानक इनपुट से पढ़ेगा जब तक $/( इनपुट रिकॉर्ड विभाजक जो डिफ़ॉल्ट रूप से एक नई रेखा है ) तक पहुंच जाएगा। अंग्रेजी में, डिफ़ॉल्ट रूप से मानक इनपुट से एक पंक्ति <>पढ़ेंगे और सामग्री को चर में असाइन करेंगे ।$_

• &&एक है और एक शर्त है, लेकिन वहाँ एक श्रृंखला कमांड विभाजक के रूप में प्रयोग किया जाता है ताकि (सफलतापूर्वक) एक पंक्ति प्रिंट, अगले आदेश कर रही है।

• selectउपयोग नहीं करने के लिएsleep एक प्रोग्रामर की चाल है । यह कमांड फ़ाइल डिस्क्रिप्टर (इनपुट और / या आउटपुट, फाइल, सॉकेट और / या नेट सॉकेट) पर घटनाओं को फंसाने के लिए बनाया गया है । इस आदेश के साथ, एक कार्यक्रम 3 तरह की घटनाओं की प्रतीक्षा कर सकता है , पढ़ने के लिए तैयार फ़ीड , लिखने के लिए तैयार फ़ीड और कुछ घटना फ़ीड पर हुई । चौथा तर्क सेकंड में टाइमआउट है, इसलिए वाक्यविन्यास है select <feeds where wait for input>, <feeds where having to write>, <feed where something could happen>, <timeout>।

अधिक सटीकता के लिए, आप Time::Hiresपर्ल मॉड्यूल का उपयोग कर सकते हैं :

perl -MTime::HiRes -pe 'BEGIN{$start=Time::HiRes::time;$sleepPerLine=1/300};select undef,undef,undef,($start + $sleepPerLine*$. - Time::HiRes::time)'

नोट: $.है वर्तमान इनपुट लाइन नंबर ।

के रूप में बेहतर लिखा है cat >catLps.pl

#!/usr/bin/perl -w

use strict;
use Time::HiRes qw|time|;

my $start=time;
my $lps=300;

$lps=shift @ARGV if @ARGV && $ARGV[0]=~/^(\d+)$/;
my $sleepPerLine=1/$lps;

print &&
    select undef,undef,undef,($start + $sleepPerLine*$. - Time::HiRes::time)
    while <>

उपयोग:

catLps.pl [lps] [file] [file]...

पहला तर्क lpsप्रति सेकंड संख्यात्मक लाइन के लिए वैकल्पिक लाइन है (डिफ़ॉल्ट: 300)

नोट: यदि फ़ाइल नाम केवल संख्यात्मक है, तो आपको उन्हें पथ के साथ निर्दिष्ट करना पड़ सकता है ./3:।

जैसे catयह तर्क और / या मानक इनपुट के रूप में दी गई फ़ाइलों को पारित कर सकता है

तो हम कर सकते हैं:

TIMEFORMAT='%R' 
time seq 1 100 | ./catLps.pl 100 >/dev/null 
1.040

time seq 1 10000 | ./catLps.pl 10000 >/dev/null  
1.042

मजे के लिए:

export TIMEFORMAT='%R' ;clear ;time seq 1 $((LINES-2)) | ./catLps.pl $((LINES-2))

Comments

ऐसा लगता है कि कुछ गंभीर वूडू आप वहां कर रहे हैं। यह बहुत अच्छा है, मैंने इसे आज़माया और यह काम करता है। मुझे नहीं पता कि आपने ऐसा कैसे किया। perl का चयन क्या है? undef? मैं इसे देख सकता हूँ। गजब का।

— संकट स्ट्रींगफेलो

@ क्रिसट्रेलफेलो ओके, मैंने कुछ स्पष्टीकरण और पूर्ण स्क्रिप्ट का उपयोग करके Time::HiResअधिक सटीकता के लिए पर्ल मॉड्यूल का उपयोग किया है

— F. Hauri

हे भगवान। यह एक कमाल का जवाब है। धन्यवाद। मैंने दूसरी बार इसे उभारने की कोशिश की। मैं आपकी अद्भुत व्याख्या पढ़कर कुछ सीख रहा हूं।

— क्रिस स्ट्रींगफेलो

आप मेरी टिप्पणियों को भी बढ़ा सकते हैं ;-)

— F. Hauri

@ क्राइस्ट्रिंगफेलो उत्तर संपादित: -pस्विच द्वारा पर्ल कमांड के उपयोग से स्क्रिप्ट को हल्का किया गया!

— एफ। होरी

Answer 2

बस नींद के साथ जाग का उपयोग करें:

awk '{print $0; system("sleep .1");}' log.txt

Comments

यह मेरे लिए और मेरी स्थिति के लिए ऊपर दिए गए स्क्रिप्ट विकल्पों के बजाय सबसे अच्छा विकल्प था। यह उत्तर न दें कि यह वोट डाउन क्यों है।

— सिटीजन केपलर

पर्ल समाधान के विपरीत यह काफी पठनीय है।

— Gunslinger

@Gunslinger: सिंटेक्स system(*sleep .1")10 कांटे / सेकंड उत्पन्न करेगा! यह लिखा जा सकता है perl -pe 'system "sleep .1"' log.txt: पठनीय भी, लेकिन बहुत महंगा (सिस्टम के अनुकूल नहीं!)

— एफ। होरी

मैं भी इस पठनीय जवाब को पसंद करता हूं। केवल एक चीज यह है कि यह हर आउटपुट के लिए शेल स्लीप कमांड को फायर करेगा। लेकिन एक आदर्श पठनीय होने के नाते मुझे परवाह नहीं है।

— इसका जफर

Answer 3

मुझे पार्टी के लिए देर हो रही है, लेकिन मैंने पाया कि यह अजगर में कोशिश करने के लिए एक उपयोगी सीखने का अभ्यास होगा, इसलिए मैं इसे डालूंगा:

#!/usr/bin/env python3

import argparse
from time import sleep

parser = argparse.ArgumentParser(description='Echo a file slowly')
parser.add_argument('-i',
                    '--input-file',
                    type=argparse.FileType('r'),
                    default='-')
parser.add_argument('-d',
                    '--delay-in-ms',
                    type=int,
                    default='100')
args = parser.parse_args()

for line in args.input_file:
    print(line.rstrip())
    sleep(args.delay_in_ms/1000.0)

यह स्टड से इनपुट या एक तर्क (-i) के रूप में स्वीकार करता है और डिफ़ॉल्ट रूप से प्रति सेकंड 1/10 वीं एक पंक्ति लिखता है, लेकिन इसे दूसरे तर्क (-d) के साथ बदला जा सकता है।