Aquí podría ser tu PUBLICIDAD


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

votos
45

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.

Publicado el 12/03/2009 a las 19:56
fuente por usuario Technical Bard
En otros idiomas...        العربية       

9 respuestas

votos
76

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

Entonces en Python, harías:

re.sub(r'\([^)]*\)', '', filename)
Respondida el 12/03/2009 a las 07:59
fuente por usuario Can Berk Güder


Aquí podría ser tu PUBLICIDAD


votos
19

Yo usaría:

\([^)]*\)
Respondida el 12/03/2009 a las 08:08
fuente por usuario Gumbo

votos
12

El patrón que coincida con subcadenas en paretheses que no tienen otro (y )caracteres en entre (como (xyz 123)en Text (abc(xyz 123)) es

\([^()]*\)

detalles :

Extracción de 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("\\([^()]*\\)", "")
  • rubí :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"(\([^()]*\))"), "")
  • Objective-C :
    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"\\([^()]*\\)" options:NSRegularExpressionCaseInsensitive error:&error]; NSString *modifiedString = [regex stringByReplacingMatchesInString:string options:0 range:NSMakeRange(0, [string length]) withTemplate:@""];
Respondida el 15/11/2016 a las 08:07
fuente por usuario Wiktor Stribiżew

votos
5

Si no lo hace absolutamente necesario utilizar una expresión regular, utilizar considerar el uso de Perl Texto :: equilibrado para eliminar los 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'será extraído 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.

Respondida el 12/03/2009 a las 11:55
fuente por usuario daotoad

votos
3

Si una ruta puede contener paréntesis, la r'\(.*?\)'expresión regular 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'
Respondida el 12/03/2009 a las 09:03
fuente por usuario jfs

votos
2

Si puedes usarlo sed(posiblemente ejecutar desde dentro de tu programa, sería tan simple como:

sed 's/(.*)//g'
Respondida el 12/03/2009 a las 08:03
fuente por usuario samoz

votos
0

Para aquellos que quieran utilizar Python, he aquí una rutina simple que elimina las subcadenas entre paréntesis, incluyendo aquellos con paréntesis anidados. Está bien, no es una expresión regular, pero que va a hacer 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')
Respondida el 14/12/2017 a las 07:30
fuente por usuario Andrew Basile

votos
0

código Java:

Pattern pattern1 = Pattern.compile("(\\_\\(.*?\\))");
System.out.println(fileName.replace(matcher1.group(1), ""));
Respondida el 03/08/2012 a las 10:30
fuente por usuario Peer Mohamed

votos
0
>>> import re
>>> filename = "Example_file_(extra_descriptor).ext"
>>> p = re.compile(r'\([^)]*\)')
>>> re.sub(p, '', filename)
'Example_file_.ext'
Respondida el 12/03/2009 a las 10:48
fuente por usuario riza