Wie kann ich Text in Klammern mit einem regulären Ausdruck entfernen?

Ich versuche, eine Reihe von Dateien zu verarbeiten, und ich muss sie dann ändern, um überflüssige Informationen in den Dateinamen zu entfernen. Insbesondere versuche ich, Text in Klammern zu entfernen. Zum Beispiel:

filename = "Example_file_(extra_descriptor).ext"

und ich möchte eine ganze Reihe von Dateien neu ausdrücken, wobei der Ausdruck in Klammern in der Mitte oder am Ende stehen kann und von variabler Länge ist.

Wie würde der Regex aussehen? Perl- oder Python-Syntax wäre bevorzugt.

s/\([^)]*\)//

In Python würden Sie also Folgendes tun:

re.sub(r'\([^)]*\)', '', filename)

Das Muster, das Teilzeichenfolgen in Klammern ohne andere (und )dazwischen liegende Zeichen (wie (xyz 123)in Text (abc(xyz 123)) entspricht, ist

\([^()]*\)

Details :

• \(- eine öffnende runde Halterung (beachten Sie, dass in POSIX BRE verwendet werden (sollte, siehe sedBeispiel unten)
• [^()]*- Null oder mehr Zeichen (aufgrund des * Kleene-Sternquantifizierers ) als die im Ausdruck der negierten Zeichenklasse / POSIX-Klammer definierten Zeichen , dh alle anderen Zeichen als (und)
• \) - eine schließende runde Klammer (kein Entweichen in POSIX BRE erlaubt)

Codefragmente entfernen:

• JavaScript :string.replace(/\([^()]*\)/g, '')
• PHP :preg_replace('~\([^()]*\)~', '', $string)
• Perl :$s =~ s/\([^()]*\)//g
• Python :re.sub(r'\([^()]*\)', '', s)
• C # :Regex.Replace(str, @"\([^()]*\)", string.Empty)
• VB.NET :Regex.Replace(str, "\([^()]*\)", "")
• Java :s.replaceAll("\\([^()]*\\)", "")
• Ruby :s.gsub(/\([^()]*\)/, '')
• R :gsub("\\([^()]*\\)", "", x)
• Lua :string.gsub(s, "%([^()]*%)", "")
• Bash / sed :sed 's/([^()]*)//g'
• Tcl :regsub -all {\([^()]*\)} $s "" result
• C ++std::regex :std::regex_replace(s, std::regex(R"(\([^()]*\))"), "")
• Ziel-C :
  NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"\\([^()]*\\)" options:NSRegularExpressionCaseInsensitive error:&error]; NSString *modifiedString = [regex stringByReplacingMatchesInString:string options:0 range:NSMakeRange(0, [string length]) withTemplate:@""];
• Swift :s.replacingOccurrences(of: "\\([^()]*\\)", with: "", options: [.regularExpression])

Ich würde ... benutzen:

\([^)]*\)

Wenn Sie nicht unbedingt einen regulären Ausdruck verwenden müssen, sollten Sie Perls Text :: Balanced verwenden , um die Klammern zu entfernen.

use Text::Balanced qw(extract_bracketed);

my ($extracted, $remainder, $prefix) = extract_bracketed( $filename, '()', '[^(]*' );

{   no warnings 'uninitialized';

    $filename = (defined $prefix or defined $remainder)
                ? $prefix . $remainder
                : $extracted;
}

Sie denken vielleicht: "Warum das alles, wenn ein Regex den Trick in einer Zeile macht?"

$filename =~ s/\([^}]*\)//;

Text :: Balanced behandelt verschachtelte Klammern. Also $filename = 'foo_(bar(baz)buz)).foo'wird richtig extrahiert. Die hier angebotenen Regex-basierten Lösungen schlagen bei dieser Zeichenfolge fehl. Der eine wird beim ersten schließenden Paren anhalten und der andere wird sie alle essen.

$ filename = ~ s / ([^}] *) //; # gibt 'foo_buz)) zurück. foo'

$ filename = ~ s /(.*)//; # gibt 'foo_.foo' zurück

# text balanciertes Beispiel gibt 'foo _) zurück. foo'

Wenn eines der Regex-Verhaltensweisen akzeptabel ist, verwenden Sie einen Regex - dokumentieren Sie jedoch die Einschränkungen und die getroffenen Annahmen.

Wenn ein Pfad Klammern enthalten kann, reicht der r'\(.*?\)'reguläre Ausdruck nicht aus:

import os, re

def remove_parenthesized_chunks(path, safeext=True, safedir=True):
    dirpath, basename = os.path.split(path) if safedir else ('', path)
    name, ext = os.path.splitext(basename) if safeext else (basename, '')
    name = re.sub(r'\(.*?\)', '', name)
    return os.path.join(dirpath, name+ext)

Standardmäßig behält die Funktion Klammern in Klammern in Verzeichnis- und Erweiterungsteilen des Pfads bei.

Beispiel:

>>> f = remove_parenthesized_chunks
>>> f("Example_file_(extra_descriptor).ext")
'Example_file_.ext'
>>> path = r"c:\dir_(important)\example(extra).ext(untouchable)"
>>> f(path)
'c:\\dir_(important)\\example.ext(untouchable)'
>>> f(path, safeext=False)
'c:\\dir_(important)\\example.ext'
>>> f(path, safedir=False)
'c:\\dir_\\example.ext(untouchable)'
>>> f(path, False, False)
'c:\\dir_\\example.ext'
>>> f(r"c:\(extra)\example(extra).ext", safedir=False)
'c:\\\\example.ext'

Für diejenigen, die Python verwenden möchten, ist hier eine einfache Routine, die in Klammern gesetzte Teilzeichenfolgen entfernt, einschließlich solcher mit verschachtelten Klammern. Okay, es ist kein regulärer Ausdruck, aber es wird den Job machen!

def remove_nested_parens(input_str):
    """Returns a copy of 'input_str' with any parenthesized text removed. Nested parentheses are handled."""
    result = ''
    paren_level = 0
    for ch in input_str:
        if ch == '(':
            paren_level += 1
        elif (ch == ')') and paren_level:
            paren_level -= 1
        elif not paren_level:
            result += ch
    return result

remove_nested_parens('example_(extra(qualifier)_text)_test(more_parens).ext')

Wenn Sie es verwenden können sed(möglicherweise aus Ihrem Programm heraus ausführen), ist dies so einfach wie:

sed 's/(.*)//g'

>>> import re
>>> filename = "Example_file_(extra_descriptor).ext"
>>> p = re.compile(r'\([^)]*\)')
>>> re.sub(p, '', filename)
'Example_file_.ext'

Java-Code:

Pattern pattern1 = Pattern.compile("(\\_\\(.*?\\))");
System.out.println(fileName.replace(matcher1.group(1), ""));