Er det en rolig versjon av subprocess.call?

stemmer
40

Er det en variant av subprocess.callsom kan kjøre kommandoen uten å skrive til standard ut, eller en måte å blokkere ut det er standard ut meldinger?

Publisert på 16/12/2011 klokken 00:23
kilden bruker
På andre språk...                            


5 svar

stemmer
49

Ja. Omdirigere sin stdouttil /dev/null.

process = subprocess.call(["my", "command"], stdout=open(os.devnull, 'wb'))
Svarte 16/12/2011 kl. 00:27
kilden bruker

stemmer
21

Ofte den slags skravling er på stderr, så det kan være lurt å slå det også. Her er mitt eksempel:

from subprocess import call, DEVNULL
return_code = call(args, stderr=DEVNULL, stdout=DEVNULL)

Merk: subprocess.DEVNULL er tilgjengelig siden Python 3.3. Hvis du fortsatt er på Python 2:

import os

with open(os.devnull, 'w') as shutup:
    return_code = call(args, stdout=shutup, stderr=shutup)
Svarte 16/12/2011 kl. 00:57
kilden bruker

stemmer
10

subprocess.call også godta stdin / stdout / stderr omadresseringer:

process = subprocess.call(["my", "command"], stdout=open(os.devnull, 'wb'))
Svarte 16/12/2011 kl. 01:04
kilden bruker

stemmer
1

Dette er en oppskrift jeg bruker mye: ring subprocessog samle produksjonen, og når kommandoen lykkes forkaste utgang, men når det ikke klarer å skrive ut resultatet.

import subprocess as sp
import sys

if "print" in __builtins__.__dict__:
    prn = __builtins__.__dict__["print"]
else:
    def prn(*args, **kwargs):
        """
        prn(value, ..., sep=' ', end='\\n', file=sys.stdout)
        Works just like the print function in Python 3.x but can be used in 2.x.

        Prints the values to a stream, or to sys.stdout by default.
        Optional keyword arguments:
        file: a file-like object (stream); defaults to the current sys.stdout.
        sep:  string inserted between values, default a space.
        end:  string appended after the last value, default a newline.
        """
        sep = kwargs.get("sep", ' ')
        end = kwargs.get("end", '\n')
        file = kwargs.get("file", sys.stdout)

        s = sep.join(str(x) for x in args) + end
        file.write(s)


def rc_run_cmd_basic(lst_cmd, verbose=False, silent=False):
    if silent and verbose:
        raise ValueError("cannot specify both verbose and silent as true")

    p = sp.Popen(lst_cmd, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE)
    tup_output = p.communicate()

    s_cmd = ' '.join(lst_cmd)
    if verbose:
        prn()
        prn("command: '%s'\n" % s_cmd)

        if 0 != p.returncode:
            prn()
            prn("Command failed with code %d:" % p.returncode)
        else:
            prn("Command succeeded!  code %d" % p.returncode)
    if verbose:
        prn("Output for: " + s_cmd)
        prn(tup_output[0])
        prn()
    if not silent and 0 != p.returncode:
        prn("Error output for: " + s_cmd)
        prn(tup_output[1])
        prn()

    return p.returncode
Svarte 08/05/2013 kl. 00:05
kilden bruker

stemmer
0

Jeg bruker subprocess.check_output i slike tilfeller og slippe returverdien. Du vil kanskje legge til en kommentar koden din sier at du bruker check_output istedenfor check_call. check_output er også bedre når det oppstår en feil, og du er interessert i feil utgang. Eksempel koden under. Utgangen er sett bare når du uncomment utskriftslinje. Hvis kommandoen mislykkes, er et unntak kastes.

import subprocess
ret = subprocess.check_output(["cat", "/tmp/1"])
#print ret
Svarte 29/03/2015 kl. 14:14
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more