Dotaz: Filtr noveho radku

[bizi]

Dobry den, chtel bych se zeptat, jakym zpusobem je mozne odfiltrovat novy radek v souboru na radcich, na kterych se vyskytuje urcity vyraz. Priklad:
text1
text2
text3
klic_slovo
text4
text5
...
Potreboval bych vysledek asi takto:
text1
text2
text3
klic_slovo text4
text5
...
Zkousel jsem to pomoci sedu, awk i grepu, ale k touzenemu vysledku jsem se bohuzel nedostal.. Honza.

Odpovědi

[Fuky]

Dle UZITEČNÉ JEDNOŘÁDKOVÉ SKRIPTY PRO SED je řešení např. toto:
cat file.txt |sed -e :a -e '/klic_slovo$/N; s/\n/ /; ta'

[Jan Martinek]

Tady je taková malá interaktivní verze. Spusť tohle a zkus editovat text v levé části okna.
Následující zdroják označ myší a prostředním tlačítkem zkopíruj do terminálu:

python << EOF
import gtk

class TwoTexts:
    def __init__(self, buff, klic_slovo):
        self.klic_slovo = klic_slovo

        txtv1 = gtk.TextView()
        buff1 = txtv1.get_buffer()
        buff1.set_text(buff)

        sep = gtk.VSeparator()

        txtv2 = gtk.TextView()
        txtv2.set_editable(False)
        buff2 = txtv2.get_buffer()

        self.buffer_changed(buff1, buff2)
        buff1.connect('changed', self.buffer_changed, buff2)

        hbox = gtk.HBox(False, 0)
        hbox.pack_start(txtv1, True, True, 0)
        hbox.pack_start(sep, False, True, 0)
        hbox.pack_start(txtv2, True, True, 0)
        hbox.show_all()

        w = gtk.Window(gtk.WINDOW_TOPLEVEL)
        w.set_position(gtk.WIN_POS_CENTER)
        w.connect('destroy', gtk.main_quit)
        w.connect('delete_event', self.delete_event)
        w.add(hbox)
        w.show_all()

    def delete_event(self, widget, data = None):
        return False

    def buffer_changed(self, buff1, buff2):
        start, end = buff1.get_bounds()
        text = buff1.get_text(start, end)
        newtext = text.replace(self.klic_slovo + '\n',
                               self.klic_slovo + ' ')
        buff2.set_text(newtext)

    def runapp(self):
        gtk.main()

buff = '''text1
text2
text3
klic_slovo
text4
text5'''

twotexts = TwoTexts(buff, 'klic_slovo')
twotexts.runapp()
EOF

[ajikdpoe]

Hmm... docela peky rozdiel napisat sed "oneliner" a 30 riadkov pythonieho kodu... Ale toto je priklad jednoznacne na sed

[Fuky]

cat file.txt |python -c 'import re; import sys; print re.sub(r"(klic_slovo)\n", "\\1 ", sys.stdin.read())'

Na malý soubor je celkem jedno co použijete, ale jakmile bude soubor stejně velký jako vaše RAM, tak jste na tomto příkladu v pythonu skončili (jasný šlo by to vyřešit, ale to by bylo proti Unixové filozofii, proč znovu vymýšlet kolo). Zkuste se podívat na top, když pracuje python a když sed. Všimněte si, že sed nežere žádnou paměť a v tom je jeho síla, je to starý dobrý Unixový nástroj. BTW: sort a další sofistikované nástroje jsou na tom stejně, je jim jedno kolik máte paměti a přece dokončí svojí činost Zkuste se podívat do /tmp při použití sort na velký soubor a uvidíte proč...

[Jan Martinek]

Prosím, nepište v pythonu onelinery. Není k tomu důvod a špatně se to čte. Následující program zpracovává soubor po řádcích, takže paměť nesežere. Běží o 30% pomaleji než varianta v sedu.
Netvrdím, že něco je lepší a něco horší - v tom už má stejně každý jasno. Řešení uvádím pro ty, kteří už v pythonu píšou a náhodou by řešili stejný problém.

#!/usr/bin/env python
import sys
k1 = 'klic_slovo\n'
k2 = 'klic_slovo '
for line in sys.stdin:
    if line == k1: line = k2
    sys.stdout.write(line)

[Fuky]

Sorry, verze na jednom řádku byla jen pro rýpaly a jak jsem se to snažil nahečmat na jeden řádek, tak jsem udělal tu blbost, že jsem nejprve načetl komplet celý vstup do paměti což je moje chyba a ne Pythonu

Nechci tvrdit, že je něco lepší nebo horší, Python mám rád, jen si chci ujasnit na co je lepší se mu vyhnout. Na menší množství dat je bez diskuze pohodlnější po všech stránkách, pokud to není věc, která se jednou napíše přímo do příkazové řádky, již nikdy se nepoužuje a dotyčný zvládá sed, gawk atp.

Myslím, že když chceš srovnávat rychlost, bylo by férové použít i v Pythonu regulární výrazy. Přeci jenom není to vždy takovéto jednoduché porovnávání.

~12x pomalejší:

for line in sys.stdin:
  sys.stdout.write(re.sub(r"(klic_slovo)\n", "\\1 ", line))

~6x pomalejší:

pattern1 = re.compile(r"klic_slovo\n")
pattern2 = re.compile(r"(klic_slovo)\n")
  
for line in sys.stdin:
  if (re.search(pattern1, line) == None):
    sys.stdout.write(line)
  else:
    sys.stdout.write(re.sub(pattern2, "\\1 ", line))

Napadá Tě jak to v Pythonu ještě urychlit? Podmínka je samozřejmě zachovat možnost využití regulárních výrazů

Jinak u sedu si můžeme v tomto případě odpustit skákání na značku a, pak je to ještě krapet (opravdu zanedbatelně) rychlejší:

cat file.txt |sed '/klic_slovo$/N; s/\n/ /;'

[Jan Martinek]

Myslím, že máme stejný pohled na věc.
A co se týče těch regulárních výrazů, máš pravdu, jsou fakt pomalé. Zajímalo by mě, kde je úzké hrdlo, jestli to souvisí s pythonem jako takovým, jeho dynamičností, function call overheadem (jak se to safra řekne česky?), s algoritmem, který používá pro vyhodnocení nebo jestli je to vším dohromady.
Srovnával jsem rychlost načítání souboru a tisk řádků v pythonu, perlu a sedu a rozdíly jsou celkem malé. Ale přidáním regulárních výrazů začne python výrazně zaostávat. Přitom soudě podle tohoto
http://swtch.com/~rsc/regexp/regexp1.html
By se od perlu moc lišit nemusel. Divné ...

[Messa]

Dalo by se to urychlit předkompilováním těch regulárních výrazů. Sice to tam máš, ale místo re.search(pattern1, line) je podle mých pokusů rychlejší pattern1.search (line).

[Jan Martinek]

Tohle je to nejrychlejší, co dokážu vymyslet:

#!/usr/bin/env python
import sys, re

def run():
    search = re.compile(r'(klic_slovo)\n').search
    write = sys.stdout.write
    for line in sys.stdin:
        s = search(line)
        if s: line = s.groups()[0] + ' '
        write(line)
run()

Ale je to pořád o cca 70% pomalejší než sed nebo perl.