Schrift
Wiki:Tipp zum Debugging: use Data::Dumper; local $Data::Dumper::Useqq = 1; print Dumper \@var;
Start · Board · Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl
[thread]6022[/thread]

Datei lesen und in Hash schreiben? (Seite 3)

Leser: 2


<< |< 1 2 3 4 5 >| >> 46 Einträge, 5 Seiten
kabel
 2004-01-19 21:58
#79262 #79262
User since
2003-08-04
704 Artikel
BenutzerIn
[default_avatar]
bullshit. wen interessiert die effizienz einer routine, die genau 1mal
ausgeführt wird und deren aufgabe als überschaubar zu bezeichnen einer untertreibung gleicht.
(an dem satz hab ich jetzt glatte 5 minuten gebastelt - DAS ist ineffizient! ;) )

das format der zu parsenden datei ist wieder mal ***, aber naja.
-- stefan
eisbeer
 2004-01-19 22:40
#79263 #79263
User since
2003-08-29
347 Artikel
BenutzerIn
[Homepage] [default_avatar]
Ich bin verwirrt. :rock: :0
Die meisten PC Probleme befinden sich zwischen Bildschirm und Stuhl...
kabel
 2004-01-19 22:59
#79264 #79264
User since
2003-08-04
704 Artikel
BenutzerIn
[default_avatar]
selbst ein typ2-parser (Parse::RecDescent und konsorten) ist schnell genug für die aufgabe :)
das einzige problem ist das format der datei.
benchmarks sind (fast) nie sinnvoll für einzelne codefragmente.
(ok, das ist eine behauptung, klingt aber verdammt plausibel)
-- stefan
eisbeer
 2004-01-20 07:35
#79265 #79265
User since
2003-08-29
347 Artikel
BenutzerIn
[Homepage] [default_avatar]
Ja, genau, meine Meinung ;)
Die meisten PC Probleme befinden sich zwischen Bildschirm und Stuhl...
Patrick
 2004-01-20 09:28
#79266 #79266
User since
2004-01-07
56 Artikel
BenutzerIn
[default_avatar]
@Crain
[quote=Crian,19.01.2004, 20:47]@Patrick: Antworte doch bitte mal auf meine Frage

> Ist es immer so, dass die Zeilen mit Listenelementen auf Backslach enden (bis auf die Zeile mit dem letzten Wert)?

Wenn ja, kann man da noch was löten, wenn nein, kann man etwas machen, falls die Werte auf keinen Fall Whitespace enthalten.

Also sag mal näheres dazu :)[/quote]

Sorry,

bin gestern etwas früher weg gewesen.

Antwort:
Ja, aber manchmal liegt ein Kommentar dazwischen und manchmal nicht. Das Ganze ist etwas kompliziert aufgebaut!

Hier nochmal ein Auszug:
Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#
# Kommentar
#

TOKSINGLE      = :Wa                  # Kommentar
TOKWORDS       = :W                   # Kommentar
TOKDELIMITER   = :Wd                  # Kommentar
TOKDESCRIPTION = :WND
TOKFILLER      = :WF
TOKMODIFIER    = :WMN

SPECTOKEN      =                      # -z /Path/xy.txt

PHRASES    = IllegalSyn               # Kommentar classes \
             Question                                               \
             Sure                                                   \
             NoPerm                                                 \
             AsIs                                                   \
             NewSentence                                            \
             NoNewSentence                                          \

#
# Kommentar
#

GENLIST    =  Array2.genlist                   # Kommentar
TERMLIST  =  02_IrgendeineListe             # Kommentar      \
           03_IrgendeineListe             # Kommentar,    \
                                                        # Kommentar
STARTLIST    = dateiname.ids                 # Kommentar
OUTPUTNAME =                                    # Kommentar
CROSSLIST    = 01_XY                          # Kommentar
ADDFILTER  =                                      # Kommentar


Das ganze ist etwas schwer einzulesen!

Ich befürchte auch, das ein Hash für die Listenelemente nicht unbedingt geeignet
Mfg
Paddy

Perl ist göttlich, die Kunst besteht darin Perl anwenden zu können.
Patrick
 2004-01-20 10:28
#79267 #79267
User since
2004-01-07
56 Artikel
BenutzerIn
[default_avatar]
Ich versuche es am besten mit einem Array, da das Hash bei den Listen wohl streiken wird!

Von der Theorie der Ablauf dann so:
1.) Zeilenweises einlesen in ein Array
2.) Splitten auf Wert vor dem "=", den Wert zwischen "=" und "#" und dem Wert nach dem "#"
3.) Gesplitteten Werte in ein neues Array schreiben

Das neue Array soll wie folgt aussehen:

1. Element = @Array[GENLIST][wert][Kommentar]
2. Element = @array[STARTLIST][wert][Kommentar]
.
.
.
usw.
Mfg
Paddy

Perl ist göttlich, die Kunst besteht darin Perl anwenden zu können.
Crian
 2004-01-20 12:40
#79268 #79268
User since
2003-08-04
5866 Artikel
ModeratorIn
[Homepage]
user image
Aha, danke :)

Hash ist schon ok, aber die Werte werden dann halt manchmal Skalare und manchmal Arrayreferenzen sein müssen.

Ich nehme mal an, dass die Backslashes die letzten Zeichen in ihrer jeweiligen Zeile sind.

Die passende Vorgehensweise beim Einlesen ist dann folgende:

Vor Einleseschleife:

- leeres Arbeitsarray anlegen.

In der Einleseschleife (while (<IN>) { ... }):

- Aktuelle Zeile in Arbeitsarray kopieren.

- Wenn das letzte Zeichen der aktuellen Zeile nicht ein Backslash ist: Arbeitsarray auswerten, Hasheintrag erstellen, Arbeitsarray leeren. (Das Auswerten muss dann abhängig davon, ob das Arbeitsarray eine oder mehrere Zeilen enthält unterschiedlich erfolgen.)

HTH

Wenn Du bei der Umsetzung Probleme hast, frag ruhig wieder nach.\n\n

<!--EDIT|Crian|1074595791-->
s--Pevna-;s.([a-z]).chr((ord($1)-84)%26+97).gee; s^([A-Z])^chr((ord($1)-52)%26+65)^gee;print;

use strict; use warnings; Link zu meiner Perlseite
Dubu
 2004-01-20 13:00
#79269 #79269
User since
2003-08-04
2145 Artikel
ModeratorIn + EditorIn

user image
Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#!/usr/bin/perl
use strict;
use warnings;

my %params;

open PARAM, "param.dat" or die $!;

my $buffer = '';
while (<PARAM>) {
    # Kommentare loeschen
    s/\s*#.*?(\\?\n)/$1/;

    # Leerzeichen an Anfang und Ende loeschen
    s/^\s+//;
    s/\s+$//;

    # Zeile jetzt leer?
    unless (length) {
        # vorhandenen Buffer bearbeiten
        insert_keys (\$buffer, \%params);
        next;
    }

    # Zeile merken
    $buffer .= $_;
    if ($buffer =~ /\\$/) {    # Fortsetzung folgt?
        # Fortsetzungszeichen durch Leerzeichen ersetzen
        chop $buffer; $buffer .= " ";
        next;
    }

    # Ein Satz zusammen => eintragen
    insert_keys (\$buffer, \%params);

}
# Falls die letzte Zeile noch ein Fortsetzungszeichen hatte ...
insert_keys (\$buffer, \%params);


use Data::Dumper;
print Dumper \%params;

#############################################
sub insert_keys {
    my ($bufferp, $paramp) = @_;
    return unless defined $$bufferp && length $$bufferp;

    die "Syntaxfehler in Zeile $." unless index ($$bufferp, '=') >= 0;
    my ($key, $val) = split /\s*=\s*/, $$bufferp, 2;


    unless (defined $val) {
        $paramp->{$key} = undef;
        return;
    }
    if ($val =~ /\s/) { # Leerzeichen zwischen Woertern? => Liste
        my @vals = split " ", $val;
        $paramp->{$key} = \@vals;
    } else {
        $paramp->{$key} = $val;
    }
    $$bufferp = "";
}

#############################################

_ _ END _ _
$VAR1 = {
          'TOKDELIMITER' => ':Wd',
          'ADDFILTER' => '',
          'CROSSLIST' => '01_XY',
          'TERMLIST' => [
                          '02_IrgendeineListe',
                          '03_IrgendeineListe'
                        ],
          'TOKMODIFIER' => ':WMN',
          'TOKWORDS' => ':W',
          'SPECTOKEN' => '',
          'TOKSINGLE' => ':Wa',
          'PHRASES' => [
                         'IllegalSyn',
                         'Question',
                         'Sure',
                         'NoPerm',
                         'AsIs',
                         'NewSentence',
                         'NoNewSentence'
                       ],
          'TOKFILLER' => ':WF',
          'OUTPUTNAME' => '',
          'STARTLIST' => 'dateiname.ids',
          'GENLIST' => 'Array2.genlist',
          'TOKDESCRIPTION' => ':WND'
        };

param.dat enthielt die Daten aus dem letzten Beispiel.
Crian
 2004-01-20 13:13
#79270 #79270
User since
2003-08-04
5866 Artikel
ModeratorIn
[Homepage]
user image
Nö, der Kommentar wird gebraucht, siehe meinen Ansatz von oben, bevor wir wussten, dass es komplizierter ist:

Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

my %hash;
my @array = ('KEYWORD      =   wert # Kommentar',
             'KEYWORD2     =   wert2 # Kommentar2',
             'KEYWORD3=wert3#Kommentar3',
             'KEYWORD4  =wert4 #                 Kommentar4',
            );

for (@array) {
    my ($key, $val, $com) = m~^(.+?)\s*=\s*(.+?)\s*#\s*(.*)$~;
    $hash{$key} = { wert => $val, kommentar => $com };
}

print Dumper(\%hash);
s--Pevna-;s.([a-z]).chr((ord($1)-84)%26+97).gee; s^([A-Z])^chr((ord($1)-52)%26+65)^gee;print;

use strict; use warnings; Link zu meiner Perlseite
Patrick
 2004-01-20 13:26
#79271 #79271
User since
2004-01-07
56 Artikel
BenutzerIn
[default_avatar]
[quote=Crian,20.01.2004, 12:13]Nö, der Kommentar wird gebraucht, siehe meinen Ansatz von oben, bevor wir wussten, dass es komplizierter ist:

Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

my %hash;
my @array = ('KEYWORD      =   wert # Kommentar',
             'KEYWORD2     =   wert2 # Kommentar2',
             'KEYWORD3=wert3#Kommentar3',
             'KEYWORD4  =wert4 #                 Kommentar4',
            );

for (@array) {
    my ($key, $val, $com) = m~^(.+?)\s*=\s*(.+?)\s*#\s*(.*)$~;
    $hash{$key} = { wert => $val, kommentar => $com };
}

print Dumper(\%hash);
[/quote]
Die Datei, die ich auslesen soll dient sozusagen als Vorlage.
Die darin enthaltenen Werte müssen von mir übernommen werden.
Leerzeichen werden wenigen Problematisch sein.

Was mir wie gesagt Kopfzerbrechen bereitet, ist die Frage:
Wie erkenne ich wann eine "Liste" an Parametern kommt.
Bsp.:
Code: (dl )
1
2
3
4
5
6
7
8
9
DESCSCR    =  10    # Score Descriptor (%)
TOKEN      = ./Single                 # Computed single word list    \
             Words                    		# List of known token classes  \
             Delimiter                                               \
             Description                                           \
             Filler                                                     \
             Modifier                                               \

MIXEDSCR   = 100   # Score Alpha/num (%)
Mfg
Paddy

Perl ist göttlich, die Kunst besteht darin Perl anwenden zu können.
<< |< 1 2 3 4 5 >| >> 46 Einträge, 5 Seiten



View all threads created 2004-01-18 22:12.