¿Cómo escapar de las llamadas os.system ()?

Cuando se usa os.system () a menudo es necesario escapar de los nombres de archivo y otros argumentos pasados ​​como parámetros a los comandos. ¿Cómo puedo hacer esto? Preferiblemente algo que funcione en múltiples sistemas operativos / shells pero en particular para bash.

Actualmente estoy haciendo lo siguiente, pero estoy seguro de que debe haber una función de biblioteca para esto, o al menos una opción más elegante / robusta / eficiente:

def sh_escape(s):
   return s.replace("(","\\(").replace(")","\\)").replace(" ","\\ ")

os.system("cat %s | grep something | sort > %s" 
          % (sh_escape(in_filename), 
             sh_escape(out_filename)))

Editar: he aceptado la respuesta simple de usar comillas, no sé por qué no pensé en eso; Supongo que porque vine de Windows donde 'y "se comportan un poco diferente.

Con respecto a la seguridad, entiendo la preocupación, pero, en este caso, estoy interesado en una solución rápida y fácil que os.system () proporcione, y la fuente de las cadenas no es generada por el usuario o al menos ingresada por un usuario de confianza (yo).

Esto es lo que uso:

def shellquote(s):
    return "'" + s.replace("'", "'\\''") + "'"

El shell siempre aceptará un nombre de archivo entre comillas y eliminará las comillas circundantes antes de pasarlo al programa en cuestión. En particular, esto evita problemas con los nombres de archivo que contienen espacios o cualquier otro tipo de metacarácter de shell desagradable.

Actualización : si está utilizando Python 3.3 o posterior, use shlex.quote en lugar de rodar el suyo.

shlex.quote() hace lo que quieres desde python 3.

(Úselo pipes.quotepara admitir python 2 y python 3)

Quizás tenga una razón específica para usar os.system(). Pero si no, probablemente deberías estar usando el subprocessmódulo . Puede especificar las tuberías directamente y evitar usar el shell.

Lo siguiente es de PEP324 :

Replacing shell pipe line
-------------------------

output=`dmesg | grep hda`
==>
p1 = Popen(["dmesg"], stdout=PIPE)
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
output = p2.communicate()[0]

Tal vez subprocess.list2cmdlinees una mejor oportunidad?

Tenga en cuenta que pipes.quote en realidad está roto en Python 2.5 y Python 3.1 y no es seguro de usar: no maneja argumentos de longitud cero.

>>> from pipes import quote
>>> args = ['arg1', '', 'arg3']
>>> print 'mycommand %s' % (' '.join(quote(arg) for arg in args))
mycommand arg1  arg3

Ver Python número 7476 ; Se ha corregido en Python 2.6 y 3.2 y posteriores.

Aviso : esta es una respuesta para Python 2.7.x.

Según la fuente , pipes.quote()es una forma de " Citar una cadena de forma confiable como un argumento único para / bin / sh ". (Aunque está en desuso desde la versión 2.7 y finalmente se expone públicamente en Python 3.3 como la shlex.quote()función).

Por otro lado , subprocess.list2cmdline()es una forma de " Traducir una secuencia de argumentos a una cadena de línea de comando, utilizando las mismas reglas que el tiempo de ejecución de MS C ".

Aquí estamos, la forma independiente de la plataforma de citar cadenas para líneas de comando.

import sys
mswindows = (sys.platform == "win32")

if mswindows:
    from subprocess import list2cmdline
    quote_args = list2cmdline
else:
    # POSIX
    from pipes import quote

    def quote_args(seq):
        return ' '.join(quote(arg) for arg in seq)

Uso:

# Quote a single argument
print quote_args(['my argument'])

# Quote multiple arguments
my_args = ['This', 'is', 'my arguments']
print quote_args(my_args)

Creo que os.system solo invoca cualquier shell de comandos configurado para el usuario, por lo que no creo que pueda hacerlo de forma independiente de la plataforma. Mi shell de comandos podría ser cualquier cosa, desde bash, emacs, ruby ​​o incluso quake3. Algunos de estos programas no esperan el tipo de argumentos que les está pasando e incluso si lo hicieran, no hay garantía de que escapen de la misma manera.

La función que uso es:

def quote_argument(argument):
    return '"%s"' % (
        argument
        .replace('\\', '\\\\')
        .replace('"', '\\"')
        .replace('$', '\\$')
        .replace('`', '\\`')
    )

es decir: siempre incluyo el argumento entre comillas dobles, y luego la barra invertida entre comillas los únicos caracteres especiales dentro de las comillas dobles.

Si utiliza el comando del sistema, intentaría incluir en la lista blanca lo que se incluye en la llamada os.system (). Por ejemplo ...

clean_user_input re.sub("[^a-zA-Z]", "", user_input)
os.system("ls %s" % (clean_user_input))

El módulo de subproceso es una mejor opción, y recomendaría intentar evitar usar algo como os.system / subprocess siempre que sea posible.

La verdadera respuesta es: no utilizar os.system()en primer lugar. Utilice en su subprocess.calllugar y proporcione los argumentos sin escape.