Il modo migliore per saltare un'intestazione durante la lettura da un file di testo in Perl?

Question

Sto catturando alcune colonne da un file delimitato da tabulazioni in Perl. La prima riga del file è completamente diversa dalle altre righe, quindi vorrei saltare quella linea il più velocemente ed efficacemente possibile.

Questo è quello che ho finora.

my $firstLine = 1; 

while (<INFILE>){ 
    if($firstLine){ 
     $firstLine = 0; 
    } 
    else{ 
     my @columns = split (/\t+/); 
     print OUTFILE "$columns[0]\t\t$columns[1]\t$columns[2]\t$columns[3]\t$columns[11]\t$columns[12]\t$columns[15]\t$columns[20]\t$columns[21]\n"; 
    } 
} 

C'è un modo migliore per farlo, forse senza $ firstLine? O c'è un modo per iniziare a leggere INFILE dalla linea 2 direttamente?

Grazie in anticipo!

Answer 1

Prendiamo alcuni dati su questo. I benchmark tecniche di tutti ...

#!/usr/bin/env perl 

sub flag_in_loop { 
    my $file = shift; 

    open my $fh, $file; 

    my $first = 1; 
    while(<$fh>) { 
     if($first) { 
      $first = 0; 
     } 
     else { 
      my $line = $_; 
     } 
    } 

    return; 
} 

sub strip_before_loop { 
    my $file = shift; 

    open my $fh, $file; 

    my $header = <$fh>; 
    while(<$fh>) { 
     my $line = $_; 
    } 

    return; 
} 

sub line_number_in_loop { 
    my $file = shift; 

    open my $fh, $file; 

    while(<$fh>) { 
     next if $. < 2; 

     my $line = $_; 
    } 

    return; 
} 

sub inc_in_loop { 
    my $file = shift; 

    open my $fh, $file; 

    my $first; 
    while(<$fh>) { 
     $first++ or next; 

     my $line = $_; 
    } 

    return; 
} 

sub slurp_to_array { 
    my $file = shift; 

    open my $fh, $file; 

    my @array = <$fh>; 
    shift @array; 

    return; 
} 


my $Test_File = "/usr/share/dict/words"; 
print `wc $Test_File`; 

use Benchmark; 

timethese shift || -10, { 
    flag_in_loop  => sub { flag_in_loop($Test_File); }, 
    strip_before_loop => sub { strip_before_loop($Test_File); }, 
    line_number_in_loop => sub { line_number_in_loop($Test_File); }, 
    inc_in_loop   => sub { inc_in_loop($Test_File); }, 
    slurp_to_array  => sub { slurp_to_array($Test_File); }, 
}; 

Poiché si tratta di I/O che può essere influenzato da forze al di là della capacità di Benchmark.pm per regolare, mi sono imbattuto più volte ed ho controllato ho ottenuto gli stessi risultati.

/usr/share/dict/words è un file da 2,4 megapixel con circa 240 k linee molto brevi. Poiché non stiamo elaborando le linee, la lunghezza della linea non dovrebbe avere importanza.

Ho fatto solo una piccola quantità di lavoro in ciascuna routine per enfatizzare la differenza tra le tecniche. Volevo fare un po 'di in modo da produrre un limite superiore realistico su quanto prestazioni andresti a guadagnare o perdere cambiando il modo in cui leggi i file.

L'ho fatto su un laptop con un SSD, ma è ancora un laptop. Con l'aumentare della velocità di I/O, il tempo della CPU diventa più significativo. La tecnica è ancora più importante su una macchina con I/O veloce.

Ecco quante volte ogni routine legge il file al secondo.

slurp_to_array:  4.5/s 
line_number_in_loop: 13.0/s 
inc_in_loop:   15.5/s 
flag_in_loop:  15.8/s 
strip_before_loop: 19.9/s 

Sono scioccato di scoprire che my @array = <$fh> è il più lento con un margine enorme. Avrei pensato che sarebbe stato il più veloce dato che tutto il lavoro sta accadendo all'interno dell'interprete perl. Tuttavia, è l'unico che alloca la memoria per contenere tutte le linee e che probabilmente rappresenta il ritardo delle prestazioni.

L'utilizzo di $. è un'altra sorpresa.Forse è il costo di accedere a una magia globale, o forse sta facendo un confronto numerico.

E, come previsto dall'analisi algoritmica, il codice di controllo dell'intestazione all'esterno del ciclo è il più veloce. Ma non di molto. Probabilmente non abbastanza da preoccuparti se stai usando i prossimi due tempi.

Answer 2

Si può solo assegnare una variabile dummy per la 1a volta:

#!/usr/bin/perl 
use strict; 
use warnings; 

open my $fh, '<','a.txt' or die $!; 

my $dummy=<$fh>; #First line is read here 
while(<$fh>){ 
     print ; 
} 
close($fh); 

Answer 3

Si può leggere un file in un handle di file e quindi può usare sia array o while per iterare su linee. per il ciclo while, @Guru ha la soluzione per te. per array, sarebbe come di seguito:

#!/usr/bin/perl 
use strict; 
use warnings; 

open (my $fh, '<','a.txt') or die "cant open the file: $! \n"; 
my @array = <$fh>; 

my $dummy = shift (@array); << this is where the headers are stored. 

foreach (@array) 
{ 
    print $_."\n"; 
} 
close ($fh); 

Answer 4

Io uso sempre $. (numero di riga corrente) per raggiungere questo obiettivo:

#!/usr/bin/perl 
use strict; 
use warnings; 

open my $fh, '<', 'myfile.txt' or die "$!\n"; 

while (<$fh>) { 
    next if $. < 2; # Skip first line 

    # Do stuff with subsequent lines 
} 

Answer 5

Il tuo codice sarebbe probabilmente più elegante in questa forma:

my $first; 
while (...) { 
    $first++ or next; 

    # do whatever you want 
}; 

Ma va ancora bene. @ La risposta di Guru è migliore in termini di cicli della CPU, ma di solito l'I/O consuma ordini di grandezza più di un singolo se.

Answer 6

Ho avuto una domanda/problema simile. La mia soluzione è stata la seguente - sia per file decompressi o gzip:

print STDERR "\nReading input file...\n"; 
if ($file =~ /.gz$/) { 
    open(IN, "gunzip -c $file | grep -v '##' |") or die " *** ERROR ***  Cannot open pipe to [ $file ]!\n"; 
    } else { 
     open(IN, "cat $file | grep -v '##' |") or die " *** ERROR ***  Cannot open [ $file ]!\n"; 
} 

Non so su di benchmarking, ma funziona bene per me.

migliore,

Sander