python - regulares - ¿Cómo puedo eliminar texto entre paréntesis con una expresión regular?

python separar string por caracter

Question

Estoy tratando de manejar un montón de archivos, y necesito modificarlos para eliminar información extraña en los nombres de los archivos; en particular, estoy tratando de eliminar el texto entre paréntesis. Por ejemplo:

filename = "Example_file_(extra_descriptor).ext"

y quiero regexar un montón de archivos donde la expresión entre paréntesis podría estar en el medio o al final, y de longitud variable.

¿Cómo se vería la expresión regular? Sería preferible la sintaxis de Perl o Python.

Answer 1

Código Java:

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

Answer 2

El patrón que coincide con subcadenas en parentesis que no tienen otros ( y ) caracteres entre (como (xyz 123) en Text (abc(xyz 123) ) es

/([^()]*/)

Detalles :

• /( - un corchete de ronda de apertura (tenga en cuenta que en POSIX BRE, ( debería usarse, vea el ejemplo de sed continuación)
• [^()]* - cero o más (debido al * quantificador de estrellas Kleene ) caracteres distintos a los definidos en la clase de caracteres negados / expresión de corchetes POSIX , es decir, cualquier carácter que no sea ( y )
• /) - un corchete de cierre (no se permite el escape en POSIX BRE)

Eliminar fragmentos de código:

• 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''
• regsub -all {/([^()]*/)} $s "" result Tcl : regsub -all {/([^()]*/)} $s "" result
• C ++ std::regex : std::regex_replace(s, std::regex(R"(/([^()]*/))"), "")
• Objective-C :
  NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"//([^()]*//)" options:NSRegularExpressionCaseInsensitive error:&error]; NSString *modifiedString = [regex stringByReplacingMatchesInString:string options:0 range:NSMakeRange(0, [string length]) withTemplate:@""];

Answer 3

Para aquellos que quieren usar Python, aquí hay una rutina simple que elimina subcadenas entre paréntesis, incluidas las que tienen paréntesis anidados. De acuerdo, no es una expresión regular, ¡pero hará el trabajo!

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'')

Answer 4

Si no necesita usar una expresión regular, considere usar Perl''s Text::Balanced para eliminar el paréntesis.

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;
}

Usted puede estar pensando, "¿Por qué hacer todo esto cuando una expresión regular hace el truco en una línea?"

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

Text :: Handles equilibrados anidados paréntesis. Entonces $filename = ''foo_(bar(baz)buz)).foo'' se extraerá correctamente. Las soluciones basadas en expresiones regulares que se ofrecen aquí fallarán en esta cadena. El uno se detendrá en la primera reunión de padres, y el otro se los comerá a todos.

$ filename = ~ s / ([^}] *) //; # devuelve ''foo_buz)). foo''

$ filename = ~ s /(.*)//; # devuelve ''foo_.foo''

# text balanced example devuelve ''foo _). foo''

Si cualquiera de los comportamientos de expresiones regulares es aceptable, use una expresión regular, pero documente las limitaciones y las suposiciones que se realizan.

Answer 5

Si puede soportar usar sed (posiblemente ejecutar desde dentro de su programa, sería tan simple como:

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

Answer 6

Si una ruta puede contener paréntesis, la expresión regular r''/(.*?/)'' No es suficiente:

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)

De forma predeterminada, la función conserva los fragmentos entre paréntesis en el directorio y las partes de extensión de la ruta.

Ejemplo:

>>> 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''

Answer 7

Yo usaría:

/([^)]*/)

Answer 8

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

Answer 9

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

Entonces en Python, harías:

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