Probleme mit regulären Ausdrücken

[cime]

Hallo, ich habe - wie sollte es anders sein - ein Problem.

ich habe eine txt-Datei der Form:

Code: Alles auswählen

<gruppe name="A">
Feld1
Feld2
...
</gruppe>
<gruppe name="B">
...
</gruppe>
etc.

die jeweilige Gruppen mit ihren Einträgen möchte ich nun mithilfe von regex auslesen
ABER: mein regex klappt einfach nicht und ich weiß nicht warum:

Code: Alles auswählen

re_gruppe=re.compile(r'<(gruppe) name="(.*?)>(?:\r?\n?([a-zA-Z \-]+))+\r?\n?</gruppe>',re.I|re.S)
s=re_gruppe.search(txt)

kann mir jemand helfen????

btw: ich habe ein kleines REGEX-Testprog geschrieben ... ihr könnt es ja mal auf Fehler überprüfen, danach würde ich es mit in die Codesnippets setzen .... (Achtung funktioniert mit WxPython)

Code: Alles auswählen

import wx,re

class app(wx.App):
    def OnInit(self):
        frame = myframe(None)
        self.SetTopWindow(frame)
        frame.Show(True)
        return True

class myframe(wx.Frame):
    def __init__(self,parent):
        wx.Frame.__init__(self,parent,-1,'Mein Regex-Tester',(-1,-1),(900,700))
        panel=mypanel(self)

class mypanel(wx.Panel):
    def __init__(self,parent):
        wx.Panel.__init__(self, parent, -1)
        tregex=wx.StaticText(self,-1,"REGEX-Befehl")
        self.regex= wx.TextCtrl(self, -1,"",size=(600, -1))
        tinp=wx.StaticText(self,-1,"auszuwertender Text:")
        self.inp = wx.TextCtrl(self, -1,"",size=(600, 300), style=wx.TE_MULTILINE)
        toutp = wx.StaticText(self,-1,"Ausgabe:")
        self.outp = wx.TextCtrl(self, -1,"",size=(600, 300), style=wx.TE_MULTILINE)
        bt= wx.Button(self, -1, "compile & search")
        self.Bind(wx.EVT_BUTTON, self.work, bt)
        space=4
        self.ig = wx.CheckBox(self, -1, "IGNORECASE (I)")
        self.lo = wx.CheckBox(self, -1, "LOCALE (L)")
        self.mu = wx.CheckBox(self, -1, "MULTILINE (M)")
        self.do = wx.CheckBox(self, -1, "DOTALL (S)")
        self.un = wx.CheckBox(self, -1, "UNICODE (U)")
        self.ve = wx.CheckBox(self, -1, "VERBOSE (X)")
        sizercheck = wx.FlexGridSizer(cols=1, hgap=space, vgap=space)
        sizercheck.AddMany([self.ig,self.lo,self.mu,self.do,self.un,self.ve])
        sizer = wx.FlexGridSizer(cols=3, hgap=space, vgap=space)
        sizer.AddMany([ tregex, self.regex,bt,
                        tinp, self.inp,sizercheck,
                        toutp, self.outp,(0,0)
                        ])
        border = wx.BoxSizer(wx.VERTICAL)
        border.Add(sizer, 0, wx.ALL, 25)
        self.SetSizer(border)
        self.SetAutoLayout(True)
    def work(self,event=None):
        if not self.regex.GetValue() or not self.inp.GetValue():
            dlg = wx.MessageDialog(self,'fehlerhafte Eingabe',
                            'MUAHAHAHAHA', wx.OK) # <-- ein wenig Spass wird ja wohl erlaubt sein ;-)
            dlg.ShowModal()
            dlg.Destroy()
            return
        flags=0
        if self.ig.IsChecked():
            flags|=re.I
        if self.lo.IsChecked():
            flags|=re.L
        if self.mu.IsChecked():
            flags|=re.M
        if self.do.IsChecked():
            flags|=re.S
        if self.un.IsChecked():
            flags|=re.U
        if self.ve.IsChecked():
            flags|=re.X
        print self.regex.GetValue().__repr__()
        regex=re.compile(self.regex.GetValue())
        s=regex.search(self.inp.GetValue())
        if not s:
            dlg = wx.MessageDialog(self,'kein Matches',
                            'MUAHAHAHAHA', wx.OK) # <-- ein wenig Spass wird ja wohl erlaubt sein ;-)
            dlg.ShowModal()
            dlg.Destroy()
            return
        self.outp.Clear()
        for i in s.groups():
            self.outp.AppendText(i+'\n#################\n')
        
        
            

        
        
if __name__=='__main__':
    main=app()
    main.MainLoop()

[modelnine]

Folgende Regex sollte für Dich funktionieren:

Code: Alles auswählen

from re import compile, S, I

GRUPPE_RE = compile("<gruppe name=\"([^\"]*)\">(.*?)</gruppe>",S|I)
for m in GRUPPE_RE.finditer(<daten>):
    print "Name:", m.group(1)
    print "Felder:", m.group(2).rstrip().split("\n")

[Leonidas]

Ich hab sowas:

Code: Alles auswählen

#!/usr/bin/env python
# -*- encoding: latin-1 -*- 

import re

s = """<gruppe name="A">
Feld1
Feld2
...
</gruppe>
<gruppe name="B">
...
</gruppe>"""

rexsplitter = re.compile(r'<gruppe name="(.*?)">(.*?)</gruppe>',
    re.IGNORECASE|re.DOTALL)

splitted = rexsplitter.findall(s)
structure = {}

for group in splitted:
    structure[group[0]] = [entry for entry in group[1].splitlines() if entry != '']

print structure

Und setze Visual Regexp drauf

[cime]

Danke für die Hilfe ...


PS: Mist, da kann ich mein lächerliches Testprog ja gleich wieder wegwerfen ....

mfg cime

[jens]

Wenn deine Datei wirklich so einfach aufgebaut ist, warum machst du das dann nicht komplett ohne RE? Einfach zeilenweise verarbeiten mit ein paar IFs...

[Leonidas]

warum machst du das dann nicht komplett ohne RE?

Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems.

Sorry, aber des musste jetzt einfach sein - einfach das obligatorische Quote zu dem Thema

Zu dem Thema habe ich noch ein paar Folien gefunden - der Vortarg war sicher interessant.

[modelnine]

Mastering regular expression programming is hard. Mastering programming without regular expressions is harder.

Ich hab keine Ahnung von wem das Zitat stammt, aber REs sind bei wohlgeformter Eingabe, und ein bisschen Hintergrundwissen was eine RE eigentlich ist (sprich, was sie leisten kann und was nicht), ein wunderbares Werkzeug.

Jamie Zawinski hat sicherlich recht dass man REs mit bedacht benutzen sollte. Nur: er hat unrecht dass man automatisch durch eine RE ein Problem bekommt (was als Konnotation in seiner Aussage mitschwingt). Und jemand der was anderes sagt hat einfach die schwarze Magie hinter regulären Ausdrücken nicht verstanden.

[Leonidas]

Jamie Zawinski hat sicherlich recht dass man REs mit bedacht benutzen sollte. Nur: er hat unrecht dass man automatisch durch eine RE ein Problem bekommt (was als Konnotation in seiner Aussage mitschwingt). Und jemand der was anderes sagt hat einfach die schwarze Magie hinter regulären Ausdrücken nicht verstanden.

Ich finde nicht dass es mitschwingt. Ich finde es schwing mit dass wenn man irgendwas mit Texten machen will sich dann an dieses tolle fast-Buzzword "Regular Expression" erinnert und unbedigt damit was machen wull, unabhängig davon ob's Sinn macht oder nicht.
Damit meine ich auch nicht, dass REs schlecht sind, ich finds schön, dass es ein RE-Modul gibt und so. Aber nicht für alles sind REs eben sinnvoll. Für vieles reichen Sachen wie .split() & Co vollkommen aus.
Ähnlich sieht es auch mit XML aus, wie PJE schrieb (und auch JWZ zitiert): es ist manchmal praktisch, aber bevor man es verwendet, sollte man überlegen, ob es sinn macht. Darüber gab es auch einige Diskussionen in der Newsgruppe, die siehe "XML Dateien auslesen" und die vielen Nachfolgenden Threads.

[cime]

Wenn deine Datei wirklich so einfach aufgebaut ist, warum machst du das dann nicht komplett ohne RE? Einfach zeilenweise verarbeiten mit ein paar IFs...

weil ich erstens auch noch kontrolliere musste, ob sie syntaktisch korrekt aufgebaut ist, zweitens ich zwischendurch auch immer noch ein paar Dinge ignorieren muss und drittens ich mich einfach mal mit regulären Ausdrücken beschäftigen wollte ...

mfg cime