Die groß / Kleinschreibung bei regulären Ausdrucks ohne re.zusammenstellen?

In Python, kann ich kompilieren eines regulären Ausdrucks-groß-und Kleinschreibung mit re.compile:

>>> s = 'TeSt'
>>> casesensitive = re.compile('test')
>>> ignorecase = re.compile('test', re.IGNORECASE)
>>> 
>>> print casesensitive.match(s)
None
>>> print ignorecase.match(s)
<_sre.SRE_Match object at 0x02F0B608>

Gibt es eine Möglichkeit, das gleiche zu tun, aber ohne Verwendung re.compile. Ich kann nichts finden, wie Perl - i - suffix (z.B. m/test/i) in der Dokumentation.

Sie finden eine hervorragende Einführung zu regulären experssoins unter: python-course.eu/re.php

InformationsquelleAutor Mat | 2009-02-01

449

Pass re.IGNORECASE zu den flags param von die search, match, oder sub:
```
re.search('test', 'TeSt', re.IGNORECASE)
re.match('test', 'TeSt', re.IGNORECASE)
re.sub('test', 'xxxx', 'Testing', flags=re.IGNORECASE)
```
- Weg ist gut. und seine einfache und arbeiten
- re.match('test', 'TeSt', re.IGNORECASE) könnte TypeError wenn entweder das Attribut None. Mit try & except zu fangen TypeError Abstimmung durch first_string == second_string. Beispiel-Code def equal_ignore_case(first_string, second_string): try: return re.match(first_string, second_string, re.IGNORECASE) is not None except (AttributeError, TypeError): return first_string == second_string Demo-Code
InformationsquelleAutor Michael Haren
78

Können Sie auch eine case-insensitive Suche über search/match ohne die IGNORECASE-flag (getestet mit Python 2.7.3):
```
re.search(r'(?i)test', 'TeSt').group()    ## returns 'TeSt'
re.match(r'(?i)test', 'TeSt').group()     ## returns 'TeSt'
```
- Die Dokumentation erwähnt nicht die Funktion Hinzugefügt wird, die in einer bestimmten version (im Gegensatz zu, sagen (?(condition)yes|no) was Sie sagt, wurde in 2.4), so erwarte ich es schon immer seit der ersten version des re Modul, was ich denke, wurde in 1.5. Im Grunde seit dem Beginn der Zeit für alle Absichten und Zwecke, wenn es um Python. Es ist dokumentiert, etwa auf halbem Weg durch den ersten Abschnitt dieser Seite: docs.python.org/2/library/re.html#regular-expression-syntax
- Hier gehen wir - ich sah durch die Dokumentation für 1,5 und fand es dokumentiert die über 60% des Weges auf diese Seite: docs.python.org/release/1.5/lib/... ich habe auch überprüft die 1.4 Dokumentation, die keine Erwähnung von diesem feature. Also ich denke, es wurde Hinzugefügt, 1.5, wenn die regex Modul war veraltet, zu Gunsten der re Modul.
- Funktioniert dies in python 3?
- Dies ist eine schöne Lösung, da Sie nicht verlangen, eine fahne. In meinem Fall bin ich die Speicherung von such-strings in Redis und das ist wirklich hilfreich.
- Es funktioniert auf python 3
- Zum Beispiel [st for st in filter(lambda x: not search(r'(?i)Mac', x), ['macintosh','tomato','MacMahon', 'and', 'maCaroni', 'pasta'])] filtert alle diejenigen, die [Mm][Aa][Cc] entspricht und nur lassen Sie uns mit ['tomato', 'and', 'pasta']
- konzeptionell ist es erlaubt das bestimmen der re.Ich Flagge auf der ganzen regex - nicht nur die Erfassung der Gruppe, der es vorangeht. Werden Sie sich bewusst, dass re.match(r'''A ((?i)B) C''', "a b c").group(0) Ursachen case-insensitive matching auf alles (A und C), nicht einfach auf B! Wenn Sie nur wollen, Fall-insens matching auf eine bestimmte capture-Gruppe, dies ist nicht die Droiden, die Sie suchen.
- wow, ist das beabsichtigtes Verhalten?
- ja Total. Mein Punkt ist aber vom Konzept her ist es das gleiche, wie das setzen einer Flagge. Auf der gesamten regex. Auch die Gruppen, die vorangehen, die es(!). Es gibt keine syntax, um zu sagen "groß- / Kleinschreibung auf die folgenden Gruppen erfassen nur".
- Ich denke, das sollte so bearbeitet werden, dass die Antwort von selbst.
InformationsquelleAutor aem999
39

Die groß- /Kleinschreibung marker (?i) integriert werden können, direkt in die regex-Muster:
```
>>> import re
>>> s = 'This is one Test, another TEST, and another test.'
>>> re.findall('(?i)test', s)
['Test', 'TEST', 'test']
```
- Eine bessere option ist, macht die regex portabel über Plattformen und Absicht ist klar, bei der Deklaration
InformationsquelleAutor Raymond Hettinger
9

Können Sie auch definieren, groß-und Kleinschreibung während der pattern kompilieren:
```
pattern = re.compile('FIle:/+(.*)', re.IGNORECASE)
```
- In der Frage OP nutzt dies und fragt, ob es eine andere Möglichkeit, es zu tun.
- Hilfreich für das schnell-scrollen lieben.
InformationsquelleAutor panofish

#'re.IGNORECASE' for case insensitive results short form re.I
#'re.match' returns the first match located from the start of the string. 
#'re.search' returns location of the where the match is found 
#'re.compile' creates a regex object that can be used for multiple matches

 >>> s = r'TeSt'   
 >>> print (re.match(s, r'test123', re.I))
 <_sre.SRE_Match object; span=(0, 4), match='test'>
 # OR
 >>> pattern = re.compile(s, re.I)
 >>> print(pattern.match(r'test123'))
 <_sre.SRE_Match object; span=(0, 4), match='test'>

InformationsquelleAutor jackotonye

3

Einfuhren
```
import re
```
Im run-time-Verarbeitung:
```
RE_TEST = r'test'
if re.match(RE_TEST, 'TeSt', re.IGNORECASE):
```
Sollte erwähnt werden, dass nicht mit re.compile zu aufwendig ist. Jedes mal, wenn die oben genannten match-Methode aufgerufen wird, wird der reguläre Ausdruck kompiliert werden. Dies ist auch die fehlerhafte Praxis, die in anderen Programmiersprachen. Die unten ist die bessere Praxis.

In-app-Initialisierung:
```
self.RE_TEST = re.compile('test', re.IGNORECASE)
```
Im run-time-Verarbeitung:
```
if self.RE_TEST.match('TeSt'):
```
- Danke!!! Niemand spricht darüber, kompilieren, noch ist es das Klügste option!
- Der OP buchstäblich bittet um eine Lösung, die nicht verwenden re.compile()....
- Guter Punkt. Behoben.
InformationsquelleAutor Douglas Daseeco

Zur Durchführung von groß-und Kleinschreibung operations, supply re.IGNORECASE

>>> import re
>>> test = 'UPPER TEXT, lower text, Mixed Text'
>>> re.findall('text', test, flags=re.IGNORECASE)
['TEXT', 'text', 'Text']

und wenn wir wollen, ersetzen Sie text matching der Fall ist...

>>> def matchcase(word):
        def replace(m):
            text = m.group()
            if text.isupper():
                return word.upper()
            elif text.islower():
                return word.lower()
            elif text[0].isupper():
                return word.capitalize()
            else:
                return word
        return replace

>>> re.sub('text', matchcase('word'), test, flags=re.IGNORECASE)
'UPPER WORD, lower word, Mixed Word'

InformationsquelleAutor Srivastava

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.