Estrarre da file

Mi scuso per la banalità della domanda ma sono fuso ed è una cosa
abbastanza urgente.
Mi trovo nella situazione di avere un file con un contenuto tipo:

riga intestazione 1
riga intestazione x
= da qui =
bla bla bla
blu blu blu
bli bli bli
= a qui =
riga fondo pagina 1
riga fondo pagina 2

Vorrei riuscire a estrarre le righe comprese tra “= da qui =” e “= a
qui =” (ovviamente le stringhe sono più complesse ma identificabili
univocamente), estremi esclusi.

Sapete consigliarmi ?

Mi scuso per il ritardo e ringrazio tutti quanti per le soluzioni e
gli ottimi spunti.
Mi metterò ad approfondire le strade che mi avete indicato per trovare
la soluzione migliore per le mie
necessità.Grazie ancora.

Il 09/03/07, Paolo Donà[email protected] ha scritto:

Per prima cosa grazie per la velocissima risposta ma …
l’ho già anticipato che sono fuso ma cercando di far funzionare da irb
il tuo esempio non sono riuscito a cavare un ragno dal buco …
ho dovuto anche definire prima del ciclo start=stop=false o mi beccavo
un undefined, ciò non ostante:

irb(main):007:0> start=stop=false
=> false
irb(main):008:0> File.new(“prova.txt”).each_line do |line|
irb(main):009:1* the_goodies << line if start and not stop
irb(main):010:1> start = true if “= da qui =” == line
irb(main):011:1> stop = true if “= a qui =” == line
irb(main):012:1> end
=> #<File:prova.txt>
irb(main):013:0> the_goodies
=> []

per paura di aver sbagliato file ho provato ad aggiungere un puts line
come prima istruzione del ciclo e così mi stampa tutte le righe del
file (come file di prova ho usato quello che ho postato prima) ma
the_goodies rimane vuota :frowning:

Il 09/03/07, chiaro scuro[email protected] ha scritto:

in genere ignoro le performance in favore della leggibilità. ottimizzo
dopo
dove serve, se serve.
detto questo capita che in certi casi le regexp siano la soluzione più
leggibile. davvero!

Una domanda che non c’entra molto forse: ma secondo voi, nella scelta
tra una soluzione brute-force, come quella di chiaro-scuro e una
basata sui regexp, come quella di daniele, qual è la più performante?
Qualche volta mi fermo prima di usare le regexp perché penso che sono
meno veloci di un’iterazione + comparazione diretta, ma non so
realmente se è così… in fondo le regexp sono in giro da trent’anni
e
saranno mooooolto ottimizzate ormai.
Boh.
Come fate voialtri? regexp all the way o un po’ qua e là e solo
quando
non è conveniente fare altrimenti?
Daniele A. wrote:

 On 3/9/07, Federico G. [1]<[email protected]> wrote:

 Per prima cosa grazie per la velocissima risposta ma ...

 chiaro scuro ti ha dato una risposta che funziona con gli
 aggiustamenti già 
 segnalati, ma giusto per non dimenticare l'esistenza delle
 espressioni
 regolari (bastarde ma utilissime, ecco tutorial secondo me ottimo
 per
 iniziare: [2]http://fido.altervista.org/RegExp/regex.html) potresti
 usare uno
 snippet del genere:
 START, STOP  =  "= da qui =", "= a qui ="
 dati_filtrati = File.read('dati.txt
 ').scan(/#{START}[\r\n](.*?)[\n\r]#{STOP}/m)[0]
 NB: occorre solo attenzione nell'effettuare l'escape dei caratteri
 considerati speciali nelle espressioni regolari nel caso di
 sostituzione dei
 valori di START e STOP.
_______________________________________________________________________

Ml mailing list
[3][email protected]
[4]http://lists.ruby-it.org/mailman/listinfo/ml


“Notre malheur n’atteint son plus haut point que lorsque a été
envisagée, suffi
samment proche, la possibilité pratique du bonheur.” - Michel
Houellebecq

References

  1. mailto:[email protected]
  2. http://fido.altervista.org/RegExp/regex.html
  3. mailto:[email protected]
  4. http://lists.ruby-it.org/mailman/listinfo/ml

On 3/9/07, Federico G. [email protected] wrote:

Per prima cosa grazie per la velocissima risposta ma …

chiaro scuro ti ha dato una risposta che funziona con gli aggiustamenti
giÃ
segnalati, ma giusto per non dimenticare l’esistenza delle espressioni
regolari (bastarde ma utilissime, ecco tutorial secondo me ottimo per
iniziare: http://fido.altervista.org/RegExp/regex.html) potresti usare
uno
snippet del genere:

START, STOP = “= da qui =”, “= a qui =”
dati_filtrati = File.read('dati.txt
').scan(/#{START}\r\n[\n\r]#{STOP}/m)[0]

NB: occorre solo attenzione nell’effettuare l’escape dei caratteri
considerati speciali nelle espressioni regolari nel caso di sostituzione
dei
valori di START e STOP.

On 3/9/07, david [email protected] wrote:

Una domanda che non c’entra molto forse: ma secondo voi, nella scelta
tra una soluzione brute-force, come quella di chiaro-scuro e una
basata sui regexp, come quella di daniele, qual è la più performante?

Ovviamente dipende dalla complessità dell’espressione regolare o
dell’algoritmo custom scelto per analizzare lo stesso testo, ma in
generale la soluzione con le regexp può risultare più performante in
moltissimi casi e ciò vale ancor di più per Ruby visto che le
espressioni
regolari sono processate a livello di libreria interna all’interprete,
dando
un’ulteriore spinta alla performance.

Allego un breve script realizzato con il modulo Benchmark per testare le
due
soluzioni. Le ho solo leggermente sistemate: nel caso della regexp ho
eliminato la concatenazione con le costanti visto che rallenta in
maniera
allucinante, ho aggiustato la soluzione di chiaro scuro visto che mi
sono
accorto che includeva nel risultato anche “= a qui =” e infine ho fatto
sì
che entrambe producessero come risultato finale una stringa. Il
risultato
sul mio computer (P4 3.0 GHz - Ruby 1.8.5 - WinXP) è questo:

  user     system      total        real

Regexp:
1.937000 0.047000 1.984000 ( 1.985000)
Custom:
3.078000 0.016000 3.094000 ( 3.094000)

Come fate voialtri? regexp all the way o un po’ qua e là e solo quando

non è conveniente fare altrimenti?

Per quanto mi riguarda, regexp all the way e soluzione “custom” solo
quando
non è conveniente fare altrimenti. Ne guadagno in velocità di sviluppo e
anche in mantenibilità del codice (almeno per me, che sono abituato) e,
spesso, ci si guadagna anche in performance.

On 3/9/07, Federico G. [email protected] wrote:

Per prima cosa grazie per la velocissima risposta ma …
l’ho già anticipato che sono fuso ma cercando di far funzionare da irb
il tuo esempio non sono riuscito a cavare un ragno dal buco …
ho dovuto anche definire prima del ciclo start=stop=false o mi beccavo
un undefined, ciò non ostante:

sorry, devi mettere line.chomp! subito dopo |line|
devi togliere il fastidioso \n a fine riga

Okkio al virtuosismo…
uso i range per fare da switch on/off alla collezione di righe:

lines = ‘’
da, a = “= da qui =”, “= a qui =”

File.new(‘test.txt’).each_line do |line|
lines << line if line.match(da)…line.match(a)
end
lines.gsub!(da,’’).gsub!(a,’’)
puts lines

L’unica cosa è che alla fine devo togliere dal risultato le righe che mi
fanno da delimitatore.

My 0.2$, Paolo

On 3/9/07, Daniele A. [email protected] wrote:

dell’algoritmo custom scelto per analizzare lo stesso testo, ma in
allucinante, ho aggiustato la soluzione di chiaro scuro visto che mi sono

non è conveniente fare altrimenti?
http://www.clorophilla.net/blog/


Ml mailing list
[email protected]
http://lists.ruby-it.org/mailman/listinfo/ml


Paolo D.’
SeeSaw | Another point of view


[email protected]
personal http://paolodona.blogspot.com

the_goodies = []

File.new(…).each_line do |line|
the_goodies << line if start and not stop

start = true if “= da qui =” == line
stop = true if “= a qui =” == line
end

brutale ma funziona

On 3/9/07, Federico G. [email protected] wrote:

bli bli bli
Ml mailing list
[email protected]
http://lists.ruby-it.org/mailman/listinfo/ml


– Kia

therubymine.com | be a miner

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs