subprocess.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-05-06 00:15+0000\n"
"PO-Revision-Date: 2018-05-23 16:11+0000\n"
"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/subprocess.rst:2
msgid ":mod:`!subprocess` --- Subprocess management"
msgstr ":mod:`!subprocess` --- 子行程管理"

#: ../../library/subprocess.rst:10
msgid "**Source code:** :source:`Lib/subprocess.py`"
msgstr "**原始碼：**:source:`Lib/subprocess.py`"

#: ../../library/subprocess.rst:14
msgid ""
"The :mod:`subprocess` module allows you to spawn new processes, connect to "
"their input/output/error pipes, and obtain their return codes.  This module "
"intends to replace several older modules and functions::"
msgstr ""

#: ../../library/subprocess.rst:18
msgid ""
"os.system\n"
"os.spawn*"
msgstr ""
"os.system\n"
"os.spawn*"

#: ../../library/subprocess.rst:21
msgid ""
"Information about how the :mod:`subprocess` module can be used to replace "
"these modules and functions can be found in the following sections."
msgstr ""

#: ../../library/subprocess.rst:26
msgid ":pep:`324` -- PEP proposing the subprocess module"
msgstr ":pep:`324` -- 提議 subprocess 模組的 PEP"

#: ../../library/subprocess.rst:598 ../../library/subprocess.rst:605
#: ../../library/subprocess.rst:615 ../../library/subprocess.rst:624
#: ../../library/subprocess.rst:633 ../../library/subprocess.rst:639
#: ../../library/subprocess.rst:1560 ../../library/subprocess.rst:1582
#: ../../includes/wasm-mobile-notavail.rst:3
msgid "Availability"
msgstr ""

#: ../../includes/wasm-mobile-notavail.rst:5
msgid ""
"This module is not supported on :ref:`mobile platforms <mobile-"
"availability>` or :ref:`WebAssembly platforms <wasm-availability>`."
msgstr ""
"此模組在\\ :ref:`行動平台 <mobile-availability>`\\ 或\\ :ref:`WebAssembly 平"
"台 <wasm-availability>`\\ 上不支援。"

#: ../../library/subprocess.rst:31
msgid "Using the :mod:`subprocess` Module"
msgstr ""

#: ../../library/subprocess.rst:33
msgid ""
"The recommended approach to invoking subprocesses is to use the :func:`run` "
"function for all use cases it can handle. For more advanced use cases, the "
"underlying :class:`Popen` interface can be used directly."
msgstr ""

#: ../../library/subprocess.rst:43
msgid ""
"Run the command described by *args*.  Wait for command to complete, then "
"return a :class:`CompletedProcess` instance."
msgstr ""

#: ../../library/subprocess.rst:46
msgid ""
"The arguments shown above are merely the most common ones, described below "
"in :ref:`frequently-used-arguments` (hence the use of keyword-only notation "
"in the abbreviated signature). The full function signature is largely the "
"same as that of the :class:`Popen` constructor - most of the arguments to "
"this function are passed through to that interface. (*timeout*,  *input*, "
"*check*, and *capture_output* are not.)"
msgstr ""

#: ../../library/subprocess.rst:53
msgid ""
"If *capture_output* is true, stdout and stderr will be captured. When used, "
"the internal :class:`Popen` object is automatically created with *stdout* "
"and *stderr* both set to :data:`~subprocess.PIPE`. The *stdout* and *stderr* "
"arguments may not be supplied at the same time as *capture_output*. If you "
"wish to capture and combine both streams into one, set *stdout* to :data:"
"`~subprocess.PIPE` and *stderr* to :data:`~subprocess.STDOUT`, instead of "
"using *capture_output*."
msgstr ""

#: ../../library/subprocess.rst:62
msgid ""
"A *timeout* may be specified in seconds, it is internally passed on to :meth:"
"`Popen.communicate`. If the timeout expires, the child process will be "
"killed and waited for. The :exc:`TimeoutExpired` exception will be re-raised "
"after the child process has terminated. The initial process creation itself "
"cannot be interrupted on many platform APIs so you are not guaranteed to see "
"a timeout exception until at least after however long process creation takes."
msgstr ""

#: ../../library/subprocess.rst:70
msgid ""
"The *input* argument is passed to :meth:`Popen.communicate` and thus to the "
"subprocess's stdin.  If used it must be a byte sequence, or a string if "
"*encoding* or *errors* is specified or *text* is true.  When used, the "
"internal :class:`Popen` object is automatically created with *stdin* set to :"
"data:`~subprocess.PIPE`, and the *stdin* argument may not be used as well."
msgstr ""

#: ../../library/subprocess.rst:77
msgid ""
"If *check* is true, and the process exits with a non-zero exit code, a :exc:"
"`CalledProcessError` exception will be raised. Attributes of that exception "
"hold the arguments, the exit code, and stdout and stderr if they were "
"captured."
msgstr ""

#: ../../library/subprocess.rst:82
msgid ""
"If *encoding* or *errors* are specified, or *text* is true, file objects for "
"stdin, stdout and stderr are opened in text mode using the specified "
"*encoding* and *errors* or the :class:`io.TextIOWrapper` default. The "
"*universal_newlines* argument is equivalent  to *text* and is provided for "
"backwards compatibility. By default, file objects are opened in binary mode."
msgstr ""

#: ../../library/subprocess.rst:88
msgid ""
"If *env* is not ``None``, it must be a mapping that defines the environment "
"variables for the new process; these are used instead of the default "
"behavior of inheriting the current process' environment. It is passed "
"directly to :class:`Popen`. This mapping can be str to str on any platform "
"or bytes to bytes on POSIX platforms much like :data:`os.environ` or :data:"
"`os.environb`."
msgstr ""

#: ../../library/subprocess.rst:95
msgid "Examples::"
msgstr "範例： ::"

#: ../../library/subprocess.rst:97
msgid ""
">>> subprocess.run([\"ls\", \"-l\"])  # doesn't capture output\n"
"CompletedProcess(args=['ls', '-l'], returncode=0)\n"
"\n"
">>> subprocess.run(\"exit 1\", shell=True, check=True)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit "
"status 1\n"
"\n"
">>> subprocess.run([\"ls\", \"-l\", \"/dev/null\"], capture_output=True)\n"
"CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,\n"
"stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\\n', stderr=b'')"
msgstr ""
">>> subprocess.run([\"ls\", \"-l\"])  # 不捕捉輸出\n"
"CompletedProcess(args=['ls', '-l'], returncode=0)\n"
"\n"
">>> subprocess.run(\"exit 1\", shell=True, check=True)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit "
"status 1\n"
"\n"
">>> subprocess.run([\"ls\", \"-l\", \"/dev/null\"], capture_output=True)\n"
"CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,\n"
"stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\\n', stderr=b'')"

#: ../../library/subprocess.rst:113
msgid "Added *encoding* and *errors* parameters"
msgstr "新增 *encoding* 與 *errors* 參數。"

#: ../../library/subprocess.rst:117
msgid ""
"Added the *text* parameter, as a more understandable alias of "
"*universal_newlines*. Added the *capture_output* parameter."
msgstr ""

#: ../../library/subprocess.rst:122 ../../library/subprocess.rst:506
#: ../../library/subprocess.rst:1214 ../../library/subprocess.rst:1254
#: ../../library/subprocess.rst:1317
msgid ""
"Changed Windows shell search order for ``shell=True``. The current directory "
"and ``%PATH%`` are replaced with ``%COMSPEC%`` and ``%SystemRoot%"
"\\System32\\cmd.exe``. As a result, dropping a malicious program named ``cmd."
"exe`` into a current directory no longer works."
msgstr ""

#: ../../library/subprocess.rst:130
msgid ""
"The return value from :func:`run`, representing a process that has finished."
msgstr ""

#: ../../library/subprocess.rst:134
msgid ""
"The arguments used to launch the process. This may be a list or a string."
msgstr ""

#: ../../library/subprocess.rst:138
msgid ""
"Exit status of the child process. Typically, an exit status of 0 indicates "
"that it ran successfully."
msgstr ""

#: ../../library/subprocess.rst:141 ../../library/subprocess.rst:945
msgid ""
"A negative value ``-N`` indicates that the child was terminated by signal "
"``N`` (POSIX only)."
msgstr ""

#: ../../library/subprocess.rst:146
msgid ""
"Captured stdout from the child process. A bytes sequence, or a string if :"
"func:`run` was called with an encoding, errors, or text=True. ``None`` if "
"stdout was not captured."
msgstr ""

#: ../../library/subprocess.rst:150
msgid ""
"If you ran the process with ``stderr=subprocess.STDOUT``, stdout and stderr "
"will be combined in this attribute, and :attr:`stderr` will be ``None``."
msgstr ""

#: ../../library/subprocess.rst:156
msgid ""
"Captured stderr from the child process. A bytes sequence, or a string if :"
"func:`run` was called with an encoding, errors, or text=True. ``None`` if "
"stderr was not captured."
msgstr ""

#: ../../library/subprocess.rst:162
msgid "If :attr:`returncode` is non-zero, raise a :exc:`CalledProcessError`."
msgstr ""

#: ../../library/subprocess.rst:168
msgid ""
"Special value that can be used as the *stdin*, *stdout* or *stderr* argument "
"to :class:`Popen` and indicates that the special file :data:`os.devnull` "
"will be used."
msgstr ""

#: ../../library/subprocess.rst:177
msgid ""
"Special value that can be used as the *stdin*, *stdout* or *stderr* argument "
"to :class:`Popen` and indicates that a pipe to the standard stream should be "
"opened.  Most useful with :meth:`Popen.communicate`."
msgstr ""

#: ../../library/subprocess.rst:184
msgid ""
"Special value that can be used as the *stderr* argument to :class:`Popen` "
"and indicates that standard error should go into the same handle as standard "
"output."
msgstr ""

#: ../../library/subprocess.rst:191
msgid "Base class for all other exceptions from this module."
msgstr ""

#: ../../library/subprocess.rst:198
msgid ""
"Subclass of :exc:`SubprocessError`, raised when a timeout expires while "
"waiting for a child process."
msgstr ""

#: ../../library/subprocess.rst:203 ../../library/subprocess.rst:247
msgid "Command that was used to spawn the child process."
msgstr ""

#: ../../library/subprocess.rst:207
msgid "Timeout in seconds."
msgstr ""

#: ../../library/subprocess.rst:211
msgid ""
"Output of the child process if it was captured by :func:`run` or :func:"
"`check_output`.  Otherwise, ``None``.  This is always :class:`bytes` when "
"any output was captured regardless of the ``text=True`` setting.  It may "
"remain ``None`` instead of ``b''`` when no output was observed."
msgstr ""

#: ../../library/subprocess.rst:219 ../../library/subprocess.rst:256
msgid "Alias for output, for symmetry with :attr:`stderr`."
msgstr ""

#: ../../library/subprocess.rst:223
msgid ""
"Stderr output of the child process if it was captured by :func:`run`. "
"Otherwise, ``None``.  This is always :class:`bytes` when stderr output was "
"captured regardless of the ``text=True`` setting.  It may remain ``None`` "
"instead of ``b''`` when no stderr output was observed."
msgstr ""

#: ../../library/subprocess.rst:230 ../../library/subprocess.rst:263
msgid "*stdout* and *stderr* attributes added"
msgstr ""

#: ../../library/subprocess.rst:235
msgid ""
"Subclass of :exc:`SubprocessError`, raised when a process run by :func:"
"`check_call`, :func:`check_output`, or :func:`run` (with ``check=True``) "
"returns a non-zero exit status."
msgstr ""

#: ../../library/subprocess.rst:242
msgid ""
"Exit status of the child process.  If the process exited due to a signal, "
"this will be the negative signal number."
msgstr ""

#: ../../library/subprocess.rst:251
msgid ""
"Output of the child process if it was captured by :func:`run` or :func:"
"`check_output`.  Otherwise, ``None``."
msgstr ""

#: ../../library/subprocess.rst:260
msgid ""
"Stderr output of the child process if it was captured by :func:`run`. "
"Otherwise, ``None``."
msgstr ""

#: ../../library/subprocess.rst:270
msgid "Frequently Used Arguments"
msgstr ""

#: ../../library/subprocess.rst:272
msgid ""
"To support a wide variety of use cases, the :class:`Popen` constructor (and "
"the convenience functions) accept a large number of optional arguments. For "
"most typical use cases, many of these arguments can be safely left at their "
"default values. The arguments that are most commonly needed are:"
msgstr ""

#: ../../library/subprocess.rst:277
msgid ""
"*args* is required for all calls and should be a string, or a sequence of "
"program arguments. Providing a sequence of arguments is generally preferred, "
"as it allows the module to take care of any required escaping and quoting of "
"arguments (e.g. to permit spaces in file names). If passing a single string, "
"either *shell* must be :const:`True` (see below) or else the string must "
"simply name the program to be executed without specifying any arguments."
msgstr ""

#: ../../library/subprocess.rst:285
msgid ""
"*stdin*, *stdout* and *stderr* specify the executed program's standard "
"input, standard output and standard error file handles, respectively.  Valid "
"values are ``None``, :data:`PIPE`, :data:`DEVNULL`, an existing file "
"descriptor (a positive integer), and an existing :term:`file object` with a "
"valid file descriptor.  With the default settings of ``None``, no "
"redirection will occur.  :data:`PIPE` indicates that a new pipe to the child "
"should be created.  :data:`DEVNULL` indicates that the special file :data:"
"`os.devnull` will be used.  Additionally, *stderr* can be :data:`STDOUT`, "
"which indicates that the stderr data from the child process should be "
"captured into the same file handle as for *stdout*."
msgstr ""

#: ../../library/subprocess.rst:299
msgid ""
"If *encoding* or *errors* are specified, or *text* (also known as "
"*universal_newlines*) is true, the file objects *stdin*, *stdout* and "
"*stderr* will be opened in text mode using the *encoding* and *errors* "
"specified in the call or the defaults for :class:`io.TextIOWrapper`."
msgstr ""

#: ../../library/subprocess.rst:305
msgid ""
"For *stdin*, line ending characters ``'\\n'`` in the input will be converted "
"to the default line separator :data:`os.linesep`. For *stdout* and *stderr*, "
"all line endings in the output will be converted to ``'\\n'``.  For more "
"information see the documentation of the :class:`io.TextIOWrapper` class "
"when the *newline* argument to its constructor is ``None``."
msgstr ""

#: ../../library/subprocess.rst:311
msgid ""
"If text mode is not used, *stdin*, *stdout* and *stderr* will be opened as "
"binary streams. No encoding or line ending conversion is performed."
msgstr ""

#: ../../library/subprocess.rst:314 ../../library/subprocess.rst:1569
#: ../../library/subprocess.rst:1587
msgid "Added the *encoding* and *errors* parameters."
msgstr "新增 *encoding* 與 *errors* 參數。"

#: ../../library/subprocess.rst:317
msgid "Added the *text* parameter as an alias for *universal_newlines*."
msgstr ""

#: ../../library/subprocess.rst:322
msgid ""
"The newlines attribute of the file objects :attr:`Popen.stdin`, :attr:`Popen."
"stdout` and :attr:`Popen.stderr` are not updated by the :meth:`Popen."
"communicate` method."
msgstr ""

#: ../../library/subprocess.rst:326
msgid ""
"If *shell* is ``True``, the specified command will be executed through the "
"shell.  This can be useful if you are using Python primarily for the "
"enhanced control flow it offers over most system shells and still want "
"convenient access to other shell features such as shell pipes, filename "
"wildcards, environment variable expansion, and expansion of ``~`` to a "
"user's home directory.  However, note that Python itself offers "
"implementations of many shell-like features (in particular, :mod:`glob`, :"
"mod:`fnmatch`, :func:`os.walk`, :func:`os.path.expandvars`, :func:`os.path."
"expanduser`, and :mod:`shutil`)."
msgstr ""

#: ../../library/subprocess.rst:336
msgid ""
"When *universal_newlines* is ``True``, the class uses the encoding :func:"
"`locale.getpreferredencoding(False) <locale.getpreferredencoding>` instead "
"of ``locale.getpreferredencoding()``.  See the :class:`io.TextIOWrapper` "
"class for more information on this change."
msgstr ""

#: ../../library/subprocess.rst:344 ../../library/subprocess.rst:465
msgid ""
"Read the `Security Considerations`_ section before using ``shell=True``."
msgstr ""

#: ../../library/subprocess.rst:346
msgid ""
"These options, along with all of the other options, are described in more "
"detail in the :class:`Popen` constructor documentation."
msgstr ""

#: ../../library/subprocess.rst:351
msgid "Popen Constructor"
msgstr ""

#: ../../library/subprocess.rst:353
msgid ""
"The underlying process creation and management in this module is handled by "
"the :class:`Popen` class. It offers a lot of flexibility so that developers "
"are able to handle the less common cases not covered by the convenience "
"functions."
msgstr ""

#: ../../library/subprocess.rst:368
msgid ""
"Execute a child program in a new process.  On POSIX, the class uses :meth:"
"`os.execvpe`-like behavior to execute the child program.  On Windows, the "
"class uses the Windows ``CreateProcess()`` function.  The arguments to :"
"class:`Popen` are as follows."
msgstr ""

#: ../../library/subprocess.rst:373
msgid ""
"*args* should be a sequence of program arguments or else a single string or :"
"term:`path-like object`. By default, the program to execute is the first "
"item in *args* if *args* is a sequence.  If *args* is a string, the "
"interpretation is platform-dependent and described below.  See the *shell* "
"and *executable* arguments for additional differences from the default "
"behavior.  Unless otherwise stated, it is recommended to pass *args* as a "
"sequence."
msgstr ""

#: ../../library/subprocess.rst:383
msgid ""
"For maximum reliability, use a fully qualified path for the executable. To "
"search for an unqualified name on :envvar:`PATH`, use :meth:`shutil.which`. "
"On all platforms, passing :data:`sys.executable` is the recommended way to "
"launch the current Python interpreter again, and use the ``-m`` command-line "
"format to launch an installed module."
msgstr ""

#: ../../library/subprocess.rst:389
msgid ""
"Resolving the path of *executable* (or the first item of *args*) is platform "
"dependent. For POSIX, see :meth:`os.execvpe`, and note that when resolving "
"or searching for the executable path, *cwd* overrides the current working "
"directory and *env* can override the ``PATH`` environment variable. For "
"Windows, see the documentation of the ``lpApplicationName`` and "
"``lpCommandLine`` parameters of WinAPI ``CreateProcess``, and note that when "
"resolving or searching for the executable path with ``shell=False``, *cwd* "
"does not override the current working directory and *env* cannot override "
"the ``PATH`` environment variable. Using a full path avoids all of these "
"variations."
msgstr ""

#: ../../library/subprocess.rst:400
msgid ""
"An example of passing some arguments to an external program as a sequence "
"is::"
msgstr ""

#: ../../library/subprocess.rst:403
msgid "Popen([\"/usr/bin/git\", \"commit\", \"-m\", \"Fixes a bug.\"])"
msgstr "Popen([\"/usr/bin/git\", \"commit\", \"-m\", \"Fixes a bug.\"])"

#: ../../library/subprocess.rst:405
msgid ""
"On POSIX, if *args* is a string, the string is interpreted as the name or "
"path of the program to execute.  However, this can only be done if not "
"passing arguments to the program."
msgstr ""

#: ../../library/subprocess.rst:411
msgid ""
"It may not be obvious how to break a shell command into a sequence of "
"arguments, especially in complex cases. :meth:`shlex.split` can illustrate "
"how to determine the correct tokenization for *args*::"
msgstr ""

#: ../../library/subprocess.rst:415
msgid ""
">>> import shlex, subprocess\n"
">>> command_line = input()\n"
"/bin/vikings -input eggs.txt -output \"spam spam.txt\" -cmd \"echo "
"'$MONEY'\"\n"
">>> args = shlex.split(command_line)\n"
">>> print(args)\n"
"['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "
"\"echo '$MONEY'\"]\n"
">>> p = subprocess.Popen(args) # Success!"
msgstr ""
">>> import shlex, subprocess\n"
">>> command_line = input()\n"
"/bin/vikings -input eggs.txt -output \"spam spam.txt\" -cmd \"echo "
"'$MONEY'\"\n"
">>> args = shlex.split(command_line)\n"
">>> print(args)\n"
"['/bin/vikings', '-input', 'eggs.txt', '-output', 'spam spam.txt', '-cmd', "
"\"echo '$MONEY'\"]\n"
">>> p = subprocess.Popen(args) # 成功！"

#: ../../library/subprocess.rst:423
msgid ""
"Note in particular that options (such as *-input*) and arguments (such as "
"*eggs.txt*) that are separated by whitespace in the shell go in separate "
"list elements, while arguments that need quoting or backslash escaping when "
"used in the shell (such as filenames containing spaces or the *echo* command "
"shown above) are single list elements."
msgstr ""

#: ../../library/subprocess.rst:429
msgid ""
"On Windows, if *args* is a sequence, it will be converted to a string in a "
"manner described in :ref:`converting-argument-sequence`.  This is because "
"the underlying ``CreateProcess()`` operates on strings."
msgstr ""

#: ../../library/subprocess.rst:433
msgid ""
"*args* parameter accepts a :term:`path-like object` if *shell* is ``False`` "
"and a sequence containing path-like objects on POSIX."
msgstr ""

#: ../../library/subprocess.rst:437
msgid ""
"*args* parameter accepts a :term:`path-like object` if *shell* is ``False`` "
"and a sequence containing bytes and path-like objects on Windows."
msgstr ""

#: ../../library/subprocess.rst:442
msgid ""
"The *shell* argument (which defaults to ``False``) specifies whether to use "
"the shell as the program to execute.  If *shell* is ``True``, it is "
"recommended to pass *args* as a string rather than as a sequence."
msgstr ""

#: ../../library/subprocess.rst:446
msgid ""
"On POSIX with ``shell=True``, the shell defaults to :file:`/bin/sh`.  If "
"*args* is a string, the string specifies the command to execute through the "
"shell.  This means that the string must be formatted exactly as it would be "
"when typed at the shell prompt.  This includes, for example, quoting or "
"backslash escaping filenames with spaces in them.  If *args* is a sequence, "
"the first item specifies the command string, and any additional items will "
"be treated as additional arguments to the shell itself.  That is to say, :"
"class:`Popen` does the equivalent of::"
msgstr ""

#: ../../library/subprocess.rst:455
msgid "Popen(['/bin/sh', '-c', args[0], args[1], ...])"
msgstr "Popen(['/bin/sh', '-c', args[0], args[1], ...])"

#: ../../library/subprocess.rst:457
msgid ""
"On Windows with ``shell=True``, the :envvar:`COMSPEC` environment variable "
"specifies the default shell.  The only time you need to specify "
"``shell=True`` on Windows is when the command you wish to execute is built "
"into the shell (e.g. :command:`dir` or :command:`copy`).  You do not need "
"``shell=True`` to run a batch file or console-based executable."
msgstr ""

#: ../../library/subprocess.rst:467
msgid ""
"*bufsize* will be supplied as the corresponding argument to the :func:`open` "
"function when creating the stdin/stdout/stderr pipe file objects:"
msgstr ""

#: ../../library/subprocess.rst:471
msgid ""
"``0`` means unbuffered (read and write are one system call and can return "
"short)"
msgstr ""

#: ../../library/subprocess.rst:473
msgid ""
"``1`` means line buffered (only usable if ``text=True`` or "
"``universal_newlines=True``)"
msgstr ""

#: ../../library/subprocess.rst:475
msgid "any other positive value means use a buffer of approximately that size"
msgstr ""

#: ../../library/subprocess.rst:477
msgid ""
"negative bufsize (the default) means the system default of io."
"DEFAULT_BUFFER_SIZE will be used."
msgstr ""

#: ../../library/subprocess.rst:480
msgid ""
"*bufsize* now defaults to -1 to enable buffering by default to match the "
"behavior that most code expects.  In versions prior to Python 3.2.4 and "
"3.3.1 it incorrectly defaulted to ``0`` which was unbuffered and allowed "
"short reads.  This was unintentional and did not match the behavior of "
"Python 2 as most code expected."
msgstr ""

#: ../../library/subprocess.rst:487
msgid ""
"The *executable* argument specifies a replacement program to execute.   It "
"is very seldom needed.  When ``shell=False``, *executable* replaces the "
"program to execute specified by *args*.  However, the original *args* is "
"still passed to the program.  Most programs treat the program specified by "
"*args* as the command name, which can then be different from the program "
"actually executed.  On POSIX, the *args* name becomes the display name for "
"the executable in utilities such as :program:`ps`.  If ``shell=True``, on "
"POSIX the *executable* argument specifies a replacement shell for the "
"default :file:`/bin/sh`."
msgstr ""

#: ../../library/subprocess.rst:497
msgid "*executable* parameter accepts a :term:`path-like object` on POSIX."
msgstr ""

#: ../../library/subprocess.rst:500
msgid ""
"*executable* parameter accepts a bytes and :term:`path-like object` on "
"Windows."
msgstr ""

#: ../../library/subprocess.rst:512
msgid ""
"*stdin*, *stdout* and *stderr* specify the executed program's standard "
"input, standard output and standard error file handles, respectively.  Valid "
"values are ``None``, :data:`PIPE`, :data:`DEVNULL`, an existing file "
"descriptor (a positive integer), and an existing :term:`file object` with a "
"valid file descriptor.  With the default settings of ``None``, no "
"redirection will occur.  :data:`PIPE` indicates that a new pipe to the child "
"should be created.  :data:`DEVNULL` indicates that the special file :data:"
"`os.devnull` will be used.  Additionally, *stderr* can be :data:`STDOUT`, "
"which indicates that the stderr data from the applications should be "
"captured into the same file handle as for *stdout*."
msgstr ""

#: ../../library/subprocess.rst:523
msgid ""
"If *preexec_fn* is set to a callable object, this object will be called in "
"the child process just before the child is executed. (POSIX only)"
msgstr ""

#: ../../library/subprocess.rst:529
msgid ""
"The *preexec_fn* parameter is NOT SAFE to use in the presence of threads in "
"your application.  The child process could deadlock before exec is called."
msgstr ""

#: ../../library/subprocess.rst:535
msgid ""
"If you need to modify the environment for the child use the *env* parameter "
"rather than doing it in a *preexec_fn*. The *start_new_session* and "
"*process_group* parameters should take the place of code using *preexec_fn* "
"to call :func:`os.setsid` or :func:`os.setpgid` in the child."
msgstr ""

#: ../../library/subprocess.rst:542
msgid ""
"The *preexec_fn* parameter is no longer supported in subinterpreters. The "
"use of the parameter in a subinterpreter raises :exc:`RuntimeError`. The new "
"restriction may affect applications that are deployed in mod_wsgi, uWSGI, "
"and other embedded environments."
msgstr ""

#: ../../library/subprocess.rst:547
msgid ""
"If *close_fds* is true, all file descriptors except ``0``, ``1`` and ``2`` "
"will be closed before the child process is executed.  Otherwise when "
"*close_fds* is false, file descriptors obey their inheritable flag as "
"described in :ref:`fd_inheritance`."
msgstr ""

#: ../../library/subprocess.rst:552
msgid ""
"On Windows, if *close_fds* is true then no handles will be inherited by the "
"child process unless explicitly passed in the ``handle_list`` element of :"
"attr:`STARTUPINFO.lpAttributeList`, or by standard handle redirection."
msgstr ""

#: ../../library/subprocess.rst:556
msgid ""
"The default for *close_fds* was changed from :const:`False` to what is "
"described above."
msgstr ""

#: ../../library/subprocess.rst:560
msgid ""
"On Windows the default for *close_fds* was changed from :const:`False` to :"
"const:`True` when redirecting the standard handles. It's now possible to set "
"*close_fds* to :const:`True` when redirecting the standard handles."
msgstr ""

#: ../../library/subprocess.rst:565
msgid ""
"*pass_fds* is an optional sequence of file descriptors to keep open between "
"the parent and child.  Providing any *pass_fds* forces *close_fds* to be :"
"const:`True`.  (POSIX only)"
msgstr ""

#: ../../library/subprocess.rst:569
msgid "The *pass_fds* parameter was added."
msgstr "新增 *pass_fds* 參數。"

#: ../../library/subprocess.rst:572
msgid ""
"If *cwd* is not ``None``, the function changes the working directory to "
"*cwd* before executing the child.  *cwd* can be a string, bytes or :term:"
"`path-like <path-like object>` object.  On POSIX, the function looks for "
"*executable* (or for the first item in *args*) relative to *cwd* if the "
"executable path is a relative path."
msgstr ""

#: ../../library/subprocess.rst:578
msgid "*cwd* parameter accepts a :term:`path-like object` on POSIX."
msgstr ""

#: ../../library/subprocess.rst:581
msgid "*cwd* parameter accepts a :term:`path-like object` on Windows."
msgstr ""

#: ../../library/subprocess.rst:584
msgid "*cwd* parameter accepts a bytes object on Windows."
msgstr ""

#: ../../library/subprocess.rst:587
msgid ""
"If *restore_signals* is true (the default) all signals that Python has set "
"to SIG_IGN are restored to SIG_DFL in the child process before the exec. "
"Currently this includes the SIGPIPE, SIGXFZ and SIGXFSZ signals. (POSIX only)"
msgstr ""

#: ../../library/subprocess.rst:592
msgid "*restore_signals* was added."
msgstr "新增 *restore_signals*。"

#: ../../library/subprocess.rst:595
msgid ""
"If *start_new_session* is true the ``setsid()`` system call will be made in "
"the child process prior to the execution of the subprocess."
msgstr ""

#: ../../library/subprocess.rst:599
msgid "*start_new_session* was added."
msgstr "新增 *start_new_session*。"

#: ../../library/subprocess.rst:602
msgid ""
"If *process_group* is a non-negative integer, the ``setpgid(0, value)`` "
"system call will be made in the child process prior to the execution of the "
"subprocess."
msgstr ""

#: ../../library/subprocess.rst:606
msgid "*process_group* was added."
msgstr "新增 *process_group*。"

#: ../../library/subprocess.rst:609
msgid ""
"If *group* is not ``None``, the setregid() system call will be made in the "
"child process prior to the execution of the subprocess. If the provided "
"value is a string, it will be looked up via :func:`grp.getgrnam` and the "
"value in ``gr_gid`` will be used. If the value is an integer, it will be "
"passed verbatim. (POSIX only)"
msgstr ""

#: ../../library/subprocess.rst:618
msgid ""
"If *extra_groups* is not ``None``, the setgroups() system call will be made "
"in the child process prior to the execution of the subprocess. Strings "
"provided in *extra_groups* will be looked up via :func:`grp.getgrnam` and "
"the values in ``gr_gid`` will be used. Integer values will be passed "
"verbatim. (POSIX only)"
msgstr ""

#: ../../library/subprocess.rst:627
msgid ""
"If *user* is not ``None``, the setreuid() system call will be made in the "
"child process prior to the execution of the subprocess. If the provided "
"value is a string, it will be looked up via :func:`pwd.getpwnam` and the "
"value in ``pw_uid`` will be used. If the value is an integer, it will be "
"passed verbatim. (POSIX only)"
msgstr ""

#: ../../library/subprocess.rst:636
msgid ""
"If *umask* is not negative, the umask() system call will be made in the "
"child process prior to the execution of the subprocess."
msgstr ""

#: ../../library/subprocess.rst:642
msgid ""
"If *env* is not ``None``, it must be a mapping that defines the environment "
"variables for the new process; these are used instead of the default "
"behavior of inheriting the current process' environment. This mapping can be "
"str to str on any platform or bytes to bytes on POSIX platforms much like :"
"data:`os.environ` or :data:`os.environb`."
msgstr ""

#: ../../library/subprocess.rst:650
msgid ""
"If specified, *env* must provide any variables required for the program to "
"execute.  On Windows, in order to run a `side-by-side assembly`_ the "
"specified *env* **must** include a valid :envvar:`SystemRoot`."
msgstr ""

#: ../../library/subprocess.rst:656
msgid ""
"If *encoding* or *errors* are specified, or *text* is true, the file objects "
"*stdin*, *stdout* and *stderr* are opened in text mode with the specified "
"*encoding* and *errors*, as described above in :ref:`frequently-used-"
"arguments`. The *universal_newlines* argument is equivalent  to *text* and "
"is provided for backwards compatibility. By default, file objects are opened "
"in binary mode."
msgstr ""

#: ../../library/subprocess.rst:662
msgid "*encoding* and *errors* were added."
msgstr "新增 *encoding* 與 *errors*。"

#: ../../library/subprocess.rst:665 ../../library/subprocess.rst:1312
msgid "*text* was added as a more readable alias for *universal_newlines*."
msgstr ""

#: ../../library/subprocess.rst:668
msgid ""
"If given, *startupinfo* will be a :class:`STARTUPINFO` object, which is "
"passed to the underlying ``CreateProcess`` function."
msgstr ""

#: ../../library/subprocess.rst:671
msgid "If given, *creationflags*, can be one or more of the following flags:"
msgstr ""

#: ../../library/subprocess.rst:673
msgid ":data:`CREATE_NEW_CONSOLE`"
msgstr ":data:`CREATE_NEW_CONSOLE`"

#: ../../library/subprocess.rst:674
msgid ":data:`CREATE_NEW_PROCESS_GROUP`"
msgstr ":data:`CREATE_NEW_PROCESS_GROUP`"

#: ../../library/subprocess.rst:675
msgid ":data:`ABOVE_NORMAL_PRIORITY_CLASS`"
msgstr ":data:`ABOVE_NORMAL_PRIORITY_CLASS`"

#: ../../library/subprocess.rst:676
msgid ":data:`BELOW_NORMAL_PRIORITY_CLASS`"
msgstr ":data:`BELOW_NORMAL_PRIORITY_CLASS`"

#: ../../library/subprocess.rst:677
msgid ":data:`HIGH_PRIORITY_CLASS`"
msgstr ":data:`HIGH_PRIORITY_CLASS`"

#: ../../library/subprocess.rst:678
msgid ":data:`IDLE_PRIORITY_CLASS`"
msgstr ":data:`IDLE_PRIORITY_CLASS`"

#: ../../library/subprocess.rst:679
msgid ":data:`NORMAL_PRIORITY_CLASS`"
msgstr ":data:`NORMAL_PRIORITY_CLASS`"

#: ../../library/subprocess.rst:680
msgid ":data:`REALTIME_PRIORITY_CLASS`"
msgstr ":data:`REALTIME_PRIORITY_CLASS`"

#: ../../library/subprocess.rst:681
msgid ":data:`CREATE_NO_WINDOW`"
msgstr ":data:`CREATE_NO_WINDOW`"

#: ../../library/subprocess.rst:682
msgid ":data:`DETACHED_PROCESS`"
msgstr ":data:`DETACHED_PROCESS`"

#: ../../library/subprocess.rst:683
msgid ":data:`CREATE_DEFAULT_ERROR_MODE`"
msgstr ":data:`CREATE_DEFAULT_ERROR_MODE`"

#: ../../library/subprocess.rst:684
msgid ":data:`CREATE_BREAKAWAY_FROM_JOB`"
msgstr ":data:`CREATE_BREAKAWAY_FROM_JOB`"

#: ../../library/subprocess.rst:686
msgid ""
"*pipesize* can be used to change the size of the pipe when :data:`PIPE` is "
"used for *stdin*, *stdout* or *stderr*. The size of the pipe is only changed "
"on platforms that support this (only Linux at this time of writing). Other "
"platforms will ignore this parameter."
msgstr ""

#: ../../library/subprocess.rst:691
msgid "Added the *pipesize* parameter."
msgstr "新增 ``pipesize`` 參數。"

#: ../../library/subprocess.rst:694
msgid ""
"Popen objects are supported as context managers via the :keyword:`with` "
"statement: on exit, standard file descriptors are closed, and the process is "
"waited for. ::"
msgstr ""

#: ../../library/subprocess.rst:698
msgid ""
"with Popen([\"ifconfig\"], stdout=PIPE) as proc:\n"
"    log.write(proc.stdout.read())"
msgstr ""
"with Popen([\"ifconfig\"], stdout=PIPE) as proc:\n"
"    log.write(proc.stdout.read())"

#: ../../library/subprocess.rst:701 ../../library/subprocess.rst:703
msgid ""
"Popen and the other functions in this module that use it raise an :ref:"
"`auditing event <auditing>` ``subprocess.Popen`` with arguments "
"``executable``, ``args``, ``cwd``, and ``env``. The value for ``args`` may "
"be a single string or a list of strings, depending on platform."
msgstr ""

#: ../../library/subprocess.rst:708
msgid "Added context manager support."
msgstr "新增情境管理器的支援。"

#: ../../library/subprocess.rst:711
msgid ""
"Popen destructor now emits a :exc:`ResourceWarning` warning if the child "
"process is still running."
msgstr ""

#: ../../library/subprocess.rst:715
msgid ""
"Popen can use :func:`os.posix_spawn` in some cases for better performance. "
"On Windows Subsystem for Linux and QEMU User Emulation, Popen constructor "
"using :func:`os.posix_spawn` no longer raise an exception on errors like "
"missing program, but the child process fails with a non-zero :attr:`~Popen."
"returncode`."
msgstr ""

#: ../../library/subprocess.rst:724
msgid "Exceptions"
msgstr "例外"

#: ../../library/subprocess.rst:726
msgid ""
"Exceptions raised in the child process, before the new program has started "
"to execute, will be re-raised in the parent."
msgstr ""

#: ../../library/subprocess.rst:729
msgid ""
"The most common exception raised is :exc:`OSError`.  This occurs, for "
"example, when trying to execute a non-existent file.  Applications should "
"prepare for :exc:`OSError` exceptions. Note that, when ``shell=True``, :exc:"
"`OSError` will be raised by the child only if the selected shell itself was "
"not found. To determine if the shell failed to find the requested "
"application, it is necessary to check the return code or output from the "
"subprocess."
msgstr ""

#: ../../library/subprocess.rst:736
msgid ""
"A :exc:`ValueError` will be raised if :class:`Popen` is called with invalid "
"arguments."
msgstr ""

#: ../../library/subprocess.rst:739
msgid ""
":func:`check_call` and :func:`check_output` will raise :exc:"
"`CalledProcessError` if the called process returns a non-zero return code."
msgstr ""

#: ../../library/subprocess.rst:743
msgid ""
"All of the functions and methods that accept a *timeout* parameter, such as :"
"func:`run` and :meth:`Popen.communicate` will raise :exc:`TimeoutExpired` if "
"the timeout expires before the process exits."
msgstr ""

#: ../../library/subprocess.rst:747
msgid ""
"Exceptions defined in this module all inherit from :exc:`SubprocessError`."
msgstr ""

#: ../../library/subprocess.rst:749
msgid "The :exc:`SubprocessError` base class was added."
msgstr ""

#: ../../library/subprocess.rst:755
msgid "Security Considerations"
msgstr "安全性注意事項"

#: ../../library/subprocess.rst:757
msgid ""
"Unlike some other popen functions, this library will not implicitly choose "
"to call a system shell.  This means that all characters, including shell "
"metacharacters, can safely be passed to child processes. If the shell is "
"invoked explicitly, via ``shell=True``, it is the application's "
"responsibility to ensure that all whitespace and metacharacters are quoted "
"appropriately to avoid `shell injection <https://en.wikipedia.org/wiki/"
"Shell_injection#Shell_injection>`_ vulnerabilities. On :ref:`some platforms "
"<shlex-quote-warning>`, it is possible to use :func:`shlex.quote` for this "
"escaping."
msgstr ""

#: ../../library/subprocess.rst:767
msgid ""
"On Windows, batch files (:file:`*.bat` or :file:`*.cmd`) may be launched by "
"the operating system in a system shell regardless of the arguments passed to "
"this library. This could result in arguments being parsed according to shell "
"rules, but without any escaping added by Python. If you are intentionally "
"launching a batch file with arguments from untrusted sources, consider "
"passing ``shell=True`` to allow Python to escape special characters. See :gh:"
"`114539` for additional discussion."
msgstr ""

#: ../../library/subprocess.rst:777
msgid "Popen Objects"
msgstr ""

#: ../../library/subprocess.rst:779
msgid "Instances of the :class:`Popen` class have the following methods:"
msgstr ""

#: ../../library/subprocess.rst:784
msgid ""
"Check if child process has terminated.  Set and return :attr:`~Popen."
"returncode` attribute. Otherwise, returns ``None``."
msgstr ""

#: ../../library/subprocess.rst:790
msgid ""
"Wait for child process to terminate.  Set and return :attr:`~Popen."
"returncode` attribute."
msgstr ""

#: ../../library/subprocess.rst:793
msgid ""
"If the process does not terminate after *timeout* seconds, raise a :exc:"
"`TimeoutExpired` exception.  It is safe to catch this exception and retry "
"the wait."
msgstr ""

#: ../../library/subprocess.rst:799
msgid ""
"This will deadlock when using ``stdout=PIPE`` or ``stderr=PIPE`` and the "
"child process generates enough output to a pipe such that it blocks waiting "
"for the OS pipe buffer to accept more data. Use :meth:`Popen.communicate` "
"when using pipes to avoid that."
msgstr ""

#: ../../library/subprocess.rst:806
msgid ""
"When the ``timeout`` parameter is not ``None``, then (on POSIX) the function "
"is implemented using a busy loop (non-blocking call and short sleeps). Use "
"the :mod:`asyncio` module for an asynchronous wait: see :class:`asyncio."
"create_subprocess_exec`."
msgstr ""

#: ../../library/subprocess.rst:811 ../../library/subprocess.rst:852
#: ../../library/subprocess.rst:1209 ../../library/subprocess.rst:1249
#: ../../library/subprocess.rst:1303
msgid "*timeout* was added."
msgstr "新增 *timeout*。"

#: ../../library/subprocess.rst:816
msgid ""
"Interact with process: Send data to stdin.  Read data from stdout and "
"stderr, until end-of-file is reached.  Wait for process to terminate and set "
"the :attr:`~Popen.returncode` attribute.  The optional *input* argument "
"should be data to be sent to the child process, or ``None``, if no data "
"should be sent to the child.  If streams were opened in text mode, *input* "
"must be a string. Otherwise, it must be bytes."
msgstr ""

#: ../../library/subprocess.rst:823
msgid ""
":meth:`communicate` returns a tuple ``(stdout_data, stderr_data)``. The data "
"will be strings if streams were opened in text mode; otherwise, bytes."
msgstr ""

#: ../../library/subprocess.rst:827
msgid ""
"Note that if you want to send data to the process's stdin, you need to "
"create the Popen object with ``stdin=PIPE``.  Similarly, to get anything "
"other than ``None`` in the result tuple, you need to give ``stdout=PIPE`` "
"and/or ``stderr=PIPE`` too."
msgstr ""

#: ../../library/subprocess.rst:832
msgid ""
"If the process does not terminate after *timeout* seconds, a :exc:"
"`TimeoutExpired` exception will be raised.  Catching this exception and "
"retrying communication will not lose any output."
msgstr ""

#: ../../library/subprocess.rst:836
msgid ""
"The child process is not killed if the timeout expires, so in order to "
"cleanup properly a well-behaved application should kill the child process "
"and finish communication::"
msgstr ""

#: ../../library/subprocess.rst:840
msgid ""
"proc = subprocess.Popen(...)\n"
"try:\n"
"    outs, errs = proc.communicate(timeout=15)\n"
"except TimeoutExpired:\n"
"    proc.kill()\n"
"    outs, errs = proc.communicate()"
msgstr ""
"proc = subprocess.Popen(...)\n"
"try:\n"
"    outs, errs = proc.communicate(timeout=15)\n"
"except TimeoutExpired:\n"
"    proc.kill()\n"
"    outs, errs = proc.communicate()"

#: ../../library/subprocess.rst:849
msgid ""
"The data read is buffered in memory, so do not use this method if the data "
"size is large or unlimited."
msgstr ""

#: ../../library/subprocess.rst:858
msgid "Sends the signal *signal* to the child."
msgstr ""

#: ../../library/subprocess.rst:860
msgid "Do nothing if the process completed."
msgstr ""

#: ../../library/subprocess.rst:864
msgid ""
"On Windows, SIGTERM is an alias for :meth:`terminate`. CTRL_C_EVENT and "
"CTRL_BREAK_EVENT can be sent to processes started with a *creationflags* "
"parameter which includes ``CREATE_NEW_PROCESS_GROUP``."
msgstr ""

#: ../../library/subprocess.rst:871
msgid ""
"Stop the child. On POSIX OSs the method sends :py:const:`~signal.SIGTERM` to "
"the child. On Windows the Win32 API function :c:func:`!TerminateProcess` is "
"called to stop the child."
msgstr ""

#: ../../library/subprocess.rst:878
msgid ""
"Kills the child. On POSIX OSs the function sends SIGKILL to the child. On "
"Windows :meth:`kill` is an alias for :meth:`terminate`."
msgstr ""

#: ../../library/subprocess.rst:882
msgid ""
"The following attributes are also set by the class for you to access. "
"Reassigning them to new values is unsupported:"
msgstr ""

#: ../../library/subprocess.rst:887
msgid ""
"The *args* argument as it was passed to :class:`Popen` -- a sequence of "
"program arguments or else a single string."
msgstr ""

#: ../../library/subprocess.rst:894
msgid ""
"If the *stdin* argument was :data:`PIPE`, this attribute is a writeable "
"stream object as returned by :func:`open`. If the *encoding* or *errors* "
"arguments were specified or the *text* or *universal_newlines* argument was "
"``True``, the stream is a text stream, otherwise it is a byte stream. If the "
"*stdin* argument was not :data:`PIPE`, this attribute is ``None``."
msgstr ""

#: ../../library/subprocess.rst:903
msgid ""
"If the *stdout* argument was :data:`PIPE`, this attribute is a readable "
"stream object as returned by :func:`open`. Reading from the stream provides "
"output from the child process. If the *encoding* or *errors* arguments were "
"specified or the *text* or *universal_newlines* argument was ``True``, the "
"stream is a text stream, otherwise it is a byte stream. If the *stdout* "
"argument was not :data:`PIPE`, this attribute is ``None``."
msgstr ""

#: ../../library/subprocess.rst:913
msgid ""
"If the *stderr* argument was :data:`PIPE`, this attribute is a readable "
"stream object as returned by :func:`open`. Reading from the stream provides "
"error output from the child process. If the *encoding* or *errors* arguments "
"were specified or the *text* or *universal_newlines* argument was ``True``, "
"the stream is a text stream, otherwise it is a byte stream. If the *stderr* "
"argument was not :data:`PIPE`, this attribute is ``None``."
msgstr ""

#: ../../library/subprocess.rst:922
msgid ""
"Use :meth:`~Popen.communicate` rather than :attr:`.stdin.write <Popen."
"stdin>`, :attr:`.stdout.read <Popen.stdout>` or :attr:`.stderr.read <Popen."
"stderr>` to avoid deadlocks due to any of the other OS pipe buffers filling "
"up and blocking the child process."
msgstr ""

#: ../../library/subprocess.rst:930
msgid "The process ID of the child process."
msgstr ""

#: ../../library/subprocess.rst:932
msgid ""
"Note that if you set the *shell* argument to ``True``, this is the process "
"ID of the spawned shell."
msgstr ""

#: ../../library/subprocess.rst:938
msgid ""
"The child return code. Initially ``None``, :attr:`returncode` is set by a "
"call to the :meth:`poll`, :meth:`wait`, or :meth:`communicate` methods if "
"they detect that the process has terminated."
msgstr ""

#: ../../library/subprocess.rst:942
msgid ""
"A ``None`` value indicates that the process hadn't yet terminated at the "
"time of the last method call."
msgstr ""

#: ../../library/subprocess.rst:950
msgid "Windows Popen Helpers"
msgstr ""

#: ../../library/subprocess.rst:952
msgid ""
"The :class:`STARTUPINFO` class and following constants are only available on "
"Windows."
msgstr ""

#: ../../library/subprocess.rst:958
msgid ""
"Partial support of the Windows `STARTUPINFO <https://msdn.microsoft.com/en-"
"us/library/ms686331(v=vs.85).aspx>`__ structure is used for :class:`Popen` "
"creation.  The following attributes can be set by passing them as keyword-"
"only arguments."
msgstr ""

#: ../../library/subprocess.rst:963
msgid "Keyword-only argument support was added."
msgstr ""

#: ../../library/subprocess.rst:968
msgid ""
"A bit field that determines whether certain :class:`STARTUPINFO` attributes "
"are used when the process creates a window. ::"
msgstr ""

#: ../../library/subprocess.rst:971
msgid ""
"si = subprocess.STARTUPINFO()\n"
"si.dwFlags = subprocess.STARTF_USESTDHANDLES | subprocess."
"STARTF_USESHOWWINDOW"
msgstr ""
"si = subprocess.STARTUPINFO()\n"
"si.dwFlags = subprocess.STARTF_USESTDHANDLES | subprocess."
"STARTF_USESHOWWINDOW"

#: ../../library/subprocess.rst:976
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESTDHANDLES`, this attribute is "
"the standard input handle for the process. If :data:`STARTF_USESTDHANDLES` "
"is not specified, the default for standard input is the keyboard buffer."
msgstr ""

#: ../../library/subprocess.rst:983
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESTDHANDLES`, this attribute is "
"the standard output handle for the process. Otherwise, this attribute is "
"ignored and the default for standard output is the console window's buffer."
msgstr ""

#: ../../library/subprocess.rst:990
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESTDHANDLES`, this attribute is "
"the standard error handle for the process. Otherwise, this attribute is "
"ignored and the default for standard error is the console window's buffer."
msgstr ""

#: ../../library/subprocess.rst:996
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESHOWWINDOW`, this attribute "
"can be any of the values that can be specified in the ``nCmdShow`` parameter "
"for the `ShowWindow <https://msdn.microsoft.com/en-us/library/"
"ms633548(v=vs.85).aspx>`__ function, except for ``SW_SHOWDEFAULT``. "
"Otherwise, this attribute is ignored."
msgstr ""

#: ../../library/subprocess.rst:1003
msgid ""
":data:`SW_HIDE` is provided for this attribute. It is used when :class:"
"`Popen` is called with ``shell=True``."
msgstr ""

#: ../../library/subprocess.rst:1008
msgid ""
"A dictionary of additional attributes for process creation as given in "
"``STARTUPINFOEX``, see `UpdateProcThreadAttribute <https://msdn.microsoft."
"com/en-us/library/windows/desktop/ms686880(v=vs.85).aspx>`__."
msgstr ""

#: ../../library/subprocess.rst:1012
msgid "Supported attributes:"
msgstr ""

#: ../../library/subprocess.rst:1014
msgid "**handle_list**"
msgstr "**handle_list**"

#: ../../library/subprocess.rst:1015
msgid ""
"Sequence of handles that will be inherited. *close_fds* must be true if non-"
"empty."
msgstr ""

#: ../../library/subprocess.rst:1018
msgid ""
"The handles must be temporarily made inheritable by :func:`os."
"set_handle_inheritable` when passed to the :class:`Popen` constructor, else :"
"class:`OSError` will be raised with Windows error "
"``ERROR_INVALID_PARAMETER`` (87)."
msgstr ""

#: ../../library/subprocess.rst:1025
msgid ""
"In a multithreaded process, use caution to avoid leaking handles that are "
"marked inheritable when combining this feature with concurrent calls to "
"other process creation functions that inherit all handles such as :func:`os."
"system`.  This also applies to standard handle redirection, which "
"temporarily creates inheritable handles."
msgstr ""

#: ../../library/subprocess.rst:1035
msgid "Windows Constants"
msgstr ""

#: ../../library/subprocess.rst:1037
msgid "The :mod:`subprocess` module exposes the following constants."
msgstr ""

#: ../../library/subprocess.rst:1041
msgid ""
"The standard input device. Initially, this is the console input buffer, "
"``CONIN$``."
msgstr ""

#: ../../library/subprocess.rst:1046
msgid ""
"The standard output device. Initially, this is the active console screen "
"buffer, ``CONOUT$``."
msgstr ""

#: ../../library/subprocess.rst:1051
msgid ""
"The standard error device. Initially, this is the active console screen "
"buffer, ``CONOUT$``."
msgstr ""

#: ../../library/subprocess.rst:1056
msgid "Hides the window. Another window will be activated."
msgstr ""

#: ../../library/subprocess.rst:1060
msgid ""
"Specifies that the :attr:`STARTUPINFO.hStdInput`, :attr:`STARTUPINFO."
"hStdOutput`, and :attr:`STARTUPINFO.hStdError` attributes contain additional "
"information."
msgstr ""

#: ../../library/subprocess.rst:1066
msgid ""
"Specifies that the :attr:`STARTUPINFO.wShowWindow` attribute contains "
"additional information."
msgstr ""

#: ../../library/subprocess.rst:1071
msgid ""
"A :attr:`STARTUPINFO.dwFlags` parameter to specify that the *Working in "
"Background* mouse cursor will be displayed while a process is launching. "
"This is the default behavior for GUI processes."
msgstr ""

#: ../../library/subprocess.rst:1080
msgid ""
"A :attr:`STARTUPINFO.dwFlags` parameter to specify that the mouse cursor "
"will not be changed when launching a process."
msgstr ""

#: ../../library/subprocess.rst:1087
msgid ""
"The new process has a new console, instead of inheriting its parent's "
"console (the default)."
msgstr ""

#: ../../library/subprocess.rst:1092
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"group will be created. This flag is necessary for using :func:`os.kill` on "
"the subprocess."
msgstr ""

#: ../../library/subprocess.rst:1096
msgid "This flag is ignored if :data:`CREATE_NEW_CONSOLE` is specified."
msgstr ""

#: ../../library/subprocess.rst:1100
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have an above average priority."
msgstr ""

#: ../../library/subprocess.rst:1107
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have a below average priority."
msgstr ""

#: ../../library/subprocess.rst:1114
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have a high priority."
msgstr ""

#: ../../library/subprocess.rst:1121
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have an idle (lowest) priority."
msgstr ""

#: ../../library/subprocess.rst:1128
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have a normal priority. (default)"
msgstr ""

#: ../../library/subprocess.rst:1135
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have realtime priority. You should almost never use "
"REALTIME_PRIORITY_CLASS, because this interrupts system threads that manage "
"mouse input, keyboard input, and background disk flushing. This class can be "
"appropriate for applications that \"talk\" directly to hardware or that "
"perform brief tasks that should have limited interruptions."
msgstr ""

#: ../../library/subprocess.rst:1146
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will not create a window."
msgstr ""

#: ../../library/subprocess.rst:1153
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will not inherit its parent's console. This value cannot be used with "
"CREATE_NEW_CONSOLE."
msgstr ""

#: ../../library/subprocess.rst:1161
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"does not inherit the error mode of the calling process. Instead, the new "
"process gets the default error mode. This feature is particularly useful for "
"multithreaded shell applications that run with hard errors disabled."
msgstr ""

#: ../../library/subprocess.rst:1171
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"is not associated with the job."
msgstr ""

#: ../../library/subprocess.rst:1179
msgid "Older high-level API"
msgstr ""

#: ../../library/subprocess.rst:1181
msgid ""
"Prior to Python 3.5, these three functions comprised the high level API to "
"subprocess. You can now use :func:`run` in many cases, but lots of existing "
"code calls these functions."
msgstr ""

#: ../../library/subprocess.rst:1188
msgid ""
"Run the command described by *args*.  Wait for command to complete, then "
"return the :attr:`~Popen.returncode` attribute."
msgstr ""

#: ../../library/subprocess.rst:1191 ../../library/subprocess.rst:1231
msgid ""
"Code needing to capture stdout or stderr should use :func:`run` instead::"
msgstr ""

#: ../../library/subprocess.rst:1193
msgid "run(...).returncode"
msgstr "run(...).returncode"

#: ../../library/subprocess.rst:1195 ../../library/subprocess.rst:1235
msgid "To suppress stdout or stderr, supply a value of :data:`DEVNULL`."
msgstr ""

#: ../../library/subprocess.rst:1197 ../../library/subprocess.rst:1237
msgid ""
"The arguments shown above are merely some common ones. The full function "
"signature is the same as that of the :class:`Popen` constructor - this "
"function passes all supplied arguments other than *timeout* directly through "
"to that interface."
msgstr ""

#: ../../library/subprocess.rst:1204 ../../library/subprocess.rst:1244
msgid ""
"Do not use ``stdout=PIPE`` or ``stderr=PIPE`` with this function.  The child "
"process will block if it generates enough output to a pipe to fill up the OS "
"pipe buffer as the pipes are not being read from."
msgstr ""

#: ../../library/subprocess.rst:1224
msgid ""
"Run command with arguments.  Wait for command to complete. If the return "
"code was zero then return, otherwise raise :exc:`CalledProcessError`. The :"
"exc:`CalledProcessError` object will have the return code in the :attr:"
"`~CalledProcessError.returncode` attribute. If :func:`check_call` was unable "
"to start the process it will propagate the exception that was raised."
msgstr ""

#: ../../library/subprocess.rst:1233
msgid "run(..., check=True)"
msgstr "run(..., check=True)"

#: ../../library/subprocess.rst:1266
msgid "Run command with arguments and return its output."
msgstr ""

#: ../../library/subprocess.rst:1268
msgid ""
"If the return code was non-zero it raises a :exc:`CalledProcessError`. The :"
"exc:`CalledProcessError` object will have the return code in the :attr:"
"`~CalledProcessError.returncode` attribute and any output in the :attr:"
"`~CalledProcessError.output` attribute."
msgstr ""

#: ../../library/subprocess.rst:1273
msgid "This is equivalent to::"
msgstr "這等同於： ::"

#: ../../library/subprocess.rst:1275
msgid "run(..., check=True, stdout=PIPE).stdout"
msgstr "run(..., check=True, stdout=PIPE).stdout"

#: ../../library/subprocess.rst:1277
msgid ""
"The arguments shown above are merely some common ones. The full function "
"signature is largely the same as that of :func:`run` - most arguments are "
"passed directly through to that interface. One API deviation from :func:"
"`run` behavior exists: passing ``input=None`` will behave the same as "
"``input=b''`` (or ``input=''``, depending on other arguments) rather than "
"using the parent's standard input file handle."
msgstr ""

#: ../../library/subprocess.rst:1284
msgid ""
"By default, this function will return the data as encoded bytes. The actual "
"encoding of the output data may depend on the command being invoked, so the "
"decoding to text will often need to be handled at the application level."
msgstr ""

#: ../../library/subprocess.rst:1288
msgid ""
"This behaviour may be overridden by setting *text*, *encoding*, *errors*, or "
"*universal_newlines* to ``True`` as described in :ref:`frequently-used-"
"arguments` and :func:`run`."
msgstr ""

#: ../../library/subprocess.rst:1292
msgid ""
"To also capture standard error in the result, use ``stderr=subprocess."
"STDOUT``::"
msgstr ""

#: ../../library/subprocess.rst:1295
msgid ""
">>> subprocess.check_output(\n"
"...     \"ls non_existent_file; exit 0\",\n"
"...     stderr=subprocess.STDOUT,\n"
"...     shell=True)\n"
"'ls: non_existent_file: No such file or directory\\n'"
msgstr ""
">>> subprocess.check_output(\n"
"...     \"ls non_existent_file; exit 0\",\n"
"...     stderr=subprocess.STDOUT,\n"
"...     shell=True)\n"
"'ls: non_existent_file: No such file or directory\\n'"

#: ../../library/subprocess.rst:1306
msgid "Support for the *input* keyword argument was added."
msgstr "新增 *input* 關鍵字引數的支援。"

#: ../../library/subprocess.rst:1309
msgid "*encoding* and *errors* were added.  See :func:`run` for details."
msgstr "新增 *encoding* 與 *errors*。細節請見 :func:`run`。"

#: ../../library/subprocess.rst:1327
msgid "Replacing Older Functions with the :mod:`subprocess` Module"
msgstr ""

#: ../../library/subprocess.rst:1329
msgid ""
"In this section, \"a becomes b\" means that b can be used as a replacement "
"for a."
msgstr ""

#: ../../library/subprocess.rst:1333
msgid ""
"All \"a\" functions in this section fail (more or less) silently if the "
"executed program cannot be found; the \"b\" replacements raise :exc:"
"`OSError` instead."
msgstr ""

#: ../../library/subprocess.rst:1337
msgid ""
"In addition, the replacements using :func:`check_output` will fail with a :"
"exc:`CalledProcessError` if the requested operation produces a non-zero "
"return code. The output is still available as the :attr:`~CalledProcessError."
"output` attribute of the raised exception."
msgstr ""

#: ../../library/subprocess.rst:1342
msgid ""
"In the following examples, we assume that the relevant functions have "
"already been imported from the :mod:`subprocess` module."
msgstr ""

#: ../../library/subprocess.rst:1347
msgid "Replacing :program:`/bin/sh` shell command substitution"
msgstr ""

#: ../../library/subprocess.rst:1349
msgid "output=$(mycmd myarg)"
msgstr "output=$(mycmd myarg)"

#: ../../library/subprocess.rst:1353 ../../library/subprocess.rst:1364
#: ../../library/subprocess.rst:1381
msgid "becomes::"
msgstr "變成： ::"

#: ../../library/subprocess.rst:1355
msgid "output = check_output([\"mycmd\", \"myarg\"])"
msgstr "output = check_output([\"mycmd\", \"myarg\"])"

#: ../../library/subprocess.rst:1358
msgid "Replacing shell pipeline"
msgstr ""

#: ../../library/subprocess.rst:1360 ../../library/subprocess.rst:1377
msgid "output=$(dmesg | grep hda)"
msgstr "output=$(dmesg | grep hda)"

#: ../../library/subprocess.rst:1366
msgid ""
"p1 = Popen([\"dmesg\"], stdout=PIPE)\n"
"p2 = Popen([\"grep\", \"hda\"], stdin=p1.stdout, stdout=PIPE)\n"
"p1.stdout.close()  # Allow p1 to receive a SIGPIPE if p2 exits.\n"
"output = p2.communicate()[0]"
msgstr ""

#: ../../library/subprocess.rst:1371
msgid ""
"The ``p1.stdout.close()`` call after starting the p2 is important in order "
"for p1 to receive a SIGPIPE if p2 exits before p1."
msgstr ""

#: ../../library/subprocess.rst:1374
msgid ""
"Alternatively, for trusted input, the shell's own pipeline support may still "
"be used directly:"
msgstr ""

#: ../../library/subprocess.rst:1383
msgid "output = check_output(\"dmesg | grep hda\", shell=True)"
msgstr "output = check_output(\"dmesg | grep hda\", shell=True)"

#: ../../library/subprocess.rst:1387
msgid "Replacing :func:`os.system`"
msgstr ""

#: ../../library/subprocess.rst:1391
msgid ""
"sts = os.system(\"mycmd\" + \" myarg\")\n"
"# becomes\n"
"retcode = call(\"mycmd\" + \" myarg\", shell=True)"
msgstr ""
"sts = os.system(\"mycmd\" + \" myarg\")\n"
"# 變成\n"
"retcode = call(\"mycmd\" + \" myarg\", shell=True)"

#: ../../library/subprocess.rst:1395
msgid "Notes:"
msgstr "註解："

#: ../../library/subprocess.rst:1397
msgid "Calling the program through the shell is usually not required."
msgstr ""

#: ../../library/subprocess.rst:1398
msgid ""
"The :func:`call` return value is encoded differently to that of :func:`os."
"system`."
msgstr ""

#: ../../library/subprocess.rst:1401
msgid ""
"The :func:`os.system` function ignores SIGINT and SIGQUIT signals while the "
"command is running, but the caller must do this separately when using the :"
"mod:`subprocess` module."
msgstr ""

#: ../../library/subprocess.rst:1405
msgid "A more realistic example would look like this::"
msgstr ""

#: ../../library/subprocess.rst:1407
msgid ""
"try:\n"
"    retcode = call(\"mycmd\" + \" myarg\", shell=True)\n"
"    if retcode < 0:\n"
"        print(\"Child was terminated by signal\", -retcode, file=sys."
"stderr)\n"
"    else:\n"
"        print(\"Child returned\", retcode, file=sys.stderr)\n"
"except OSError as e:\n"
"    print(\"Execution failed:\", e, file=sys.stderr)"
msgstr ""
"try:\n"
"    retcode = call(\"mycmd\" + \" myarg\", shell=True)\n"
"    if retcode < 0:\n"
"        print(\"Child was terminated by signal\", -retcode, file=sys."
"stderr)\n"
"    else:\n"
"        print(\"Child returned\", retcode, file=sys.stderr)\n"
"except OSError as e:\n"
"    print(\"Execution failed:\", e, file=sys.stderr)"

#: ../../library/subprocess.rst:1418
msgid "Replacing the :func:`os.spawn <os.spawnl>` family"
msgstr ""

#: ../../library/subprocess.rst:1420
msgid "P_NOWAIT example::"
msgstr "P_NOWAIT 範例： ::"

#: ../../library/subprocess.rst:1422
msgid ""
"pid = os.spawnlp(os.P_NOWAIT, \"/bin/mycmd\", \"mycmd\", \"myarg\")\n"
"==>\n"
"pid = Popen([\"/bin/mycmd\", \"myarg\"]).pid"
msgstr ""
"pid = os.spawnlp(os.P_NOWAIT, \"/bin/mycmd\", \"mycmd\", \"myarg\")\n"
"==>\n"
"pid = Popen([\"/bin/mycmd\", \"myarg\"]).pid"

#: ../../library/subprocess.rst:1426
msgid "P_WAIT example::"
msgstr "P_WAIT 範例： ::"

#: ../../library/subprocess.rst:1428
msgid ""
"retcode = os.spawnlp(os.P_WAIT, \"/bin/mycmd\", \"mycmd\", \"myarg\")\n"
"==>\n"
"retcode = call([\"/bin/mycmd\", \"myarg\"])"
msgstr ""
"retcode = os.spawnlp(os.P_WAIT, \"/bin/mycmd\", \"mycmd\", \"myarg\")\n"
"==>\n"
"retcode = call([\"/bin/mycmd\", \"myarg\"])"

#: ../../library/subprocess.rst:1432
msgid "Vector example::"
msgstr ""

#: ../../library/subprocess.rst:1434
msgid ""
"os.spawnvp(os.P_NOWAIT, path, args)\n"
"==>\n"
"Popen([path] + args[1:])"
msgstr ""
"os.spawnvp(os.P_NOWAIT, path, args)\n"
"==>\n"
"Popen([path] + args[1:])"

#: ../../library/subprocess.rst:1438
msgid "Environment example::"
msgstr ""

#: ../../library/subprocess.rst:1440
msgid ""
"os.spawnlpe(os.P_NOWAIT, \"/bin/mycmd\", \"mycmd\", \"myarg\", env)\n"
"==>\n"
"Popen([\"/bin/mycmd\", \"myarg\"], env={\"PATH\": \"/usr/bin\"})"
msgstr ""
"os.spawnlpe(os.P_NOWAIT, \"/bin/mycmd\", \"mycmd\", \"myarg\", env)\n"
"==>\n"
"Popen([\"/bin/mycmd\", \"myarg\"], env={\"PATH\": \"/usr/bin\"})"

#: ../../library/subprocess.rst:1447
msgid "Replacing :func:`os.popen`, :func:`os.popen2`, :func:`os.popen3`"
msgstr ""

#: ../../library/subprocess.rst:1451
msgid ""
"(child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize)\n"
"==>\n"
"p = Popen(cmd, shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, close_fds=True)\n"
"(child_stdin, child_stdout) = (p.stdin, p.stdout)"
msgstr ""
"(child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize)\n"
"==>\n"
"p = Popen(cmd, shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, close_fds=True)\n"
"(child_stdin, child_stdout) = (p.stdin, p.stdout)"

#: ../../library/subprocess.rst:1459
msgid ""
"(child_stdin,\n"
" child_stdout,\n"
" child_stderr) = os.popen3(cmd, mode, bufsize)\n"
"==>\n"
"p = Popen(cmd, shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)\n"
"(child_stdin,\n"
" child_stdout,\n"
" child_stderr) = (p.stdin, p.stdout, p.stderr)"
msgstr ""
"(child_stdin,\n"
" child_stdout,\n"
" child_stderr) = os.popen3(cmd, mode, bufsize)\n"
"==>\n"
"p = Popen(cmd, shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)\n"
"(child_stdin,\n"
" child_stdout,\n"
" child_stderr) = (p.stdin, p.stdout, p.stderr)"

#: ../../library/subprocess.rst:1471
msgid ""
"(child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize)\n"
"==>\n"
"p = Popen(cmd, shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)\n"
"(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)"
msgstr ""
"(child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize)\n"
"==>\n"
"p = Popen(cmd, shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)\n"
"(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)"

#: ../../library/subprocess.rst:1477
msgid "Return code handling translates as follows::"
msgstr ""

#: ../../library/subprocess.rst:1479
msgid ""
"pipe = os.popen(cmd, 'w')\n"
"...\n"
"rc = pipe.close()\n"
"if rc is not None and rc >> 8:\n"
"    print(\"There were some errors\")\n"
"==>\n"
"process = Popen(cmd, stdin=PIPE)\n"
"...\n"
"process.stdin.close()\n"
"if process.wait() != 0:\n"
"    print(\"There were some errors\")"
msgstr ""
"pipe = os.popen(cmd, 'w')\n"
"...\n"
"rc = pipe.close()\n"
"if rc is not None and rc >> 8:\n"
"    print(\"There were some errors\")\n"
"==>\n"
"process = Popen(cmd, stdin=PIPE)\n"
"...\n"
"process.stdin.close()\n"
"if process.wait() != 0:\n"
"    print(\"There were some errors\")"

#: ../../library/subprocess.rst:1493
msgid "Replacing functions from the :mod:`!popen2` module"
msgstr ""

#: ../../library/subprocess.rst:1497
msgid ""
"If the cmd argument to popen2 functions is a string, the command is executed "
"through /bin/sh.  If it is a list, the command is directly executed."
msgstr ""

#: ../../library/subprocess.rst:1502
msgid ""
"(child_stdout, child_stdin) = popen2.popen2(\"somestring\", bufsize, mode)\n"
"==>\n"
"p = Popen(\"somestring\", shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, close_fds=True)\n"
"(child_stdout, child_stdin) = (p.stdout, p.stdin)"
msgstr ""
"(child_stdout, child_stdin) = popen2.popen2(\"somestring\", bufsize, mode)\n"
"==>\n"
"p = Popen(\"somestring\", shell=True, bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, close_fds=True)\n"
"(child_stdout, child_stdin) = (p.stdout, p.stdin)"

#: ../../library/subprocess.rst:1510
msgid ""
"(child_stdout, child_stdin) = popen2.popen2([\"mycmd\", \"myarg\"], bufsize, "
"mode)\n"
"==>\n"
"p = Popen([\"mycmd\", \"myarg\"], bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, close_fds=True)\n"
"(child_stdout, child_stdin) = (p.stdout, p.stdin)"
msgstr ""
"(child_stdout, child_stdin) = popen2.popen2([\"mycmd\", \"myarg\"], bufsize, "
"mode)\n"
"==>\n"
"p = Popen([\"mycmd\", \"myarg\"], bufsize=bufsize,\n"
"          stdin=PIPE, stdout=PIPE, close_fds=True)\n"
"(child_stdout, child_stdin) = (p.stdout, p.stdin)"

#: ../../library/subprocess.rst:1516
msgid ""
":class:`popen2.Popen3` and :class:`popen2.Popen4` basically work as :class:"
"`subprocess.Popen`, except that:"
msgstr ""

#: ../../library/subprocess.rst:1519
msgid ":class:`Popen` raises an exception if the execution fails."
msgstr ""

#: ../../library/subprocess.rst:1521
msgid "The *capturestderr* argument is replaced with the *stderr* argument."
msgstr ""

#: ../../library/subprocess.rst:1523
msgid "``stdin=PIPE`` and ``stdout=PIPE`` must be specified."
msgstr ""

#: ../../library/subprocess.rst:1525
msgid ""
"popen2 closes all file descriptors by default, but you have to specify "
"``close_fds=True`` with :class:`Popen` to guarantee this behavior on all "
"platforms or past Python versions."
msgstr ""

#: ../../library/subprocess.rst:1531
msgid "Legacy Shell Invocation Functions"
msgstr ""

#: ../../library/subprocess.rst:1533
msgid ""
"This module also provides the following legacy functions from the 2.x "
"``commands`` module. These operations implicitly invoke the system shell and "
"none of the guarantees described above regarding security and exception "
"handling consistency are valid for these functions."
msgstr ""

#: ../../library/subprocess.rst:1540
msgid "Return ``(exitcode, output)`` of executing *cmd* in a shell."
msgstr ""

#: ../../library/subprocess.rst:1542
msgid ""
"Execute the string *cmd* in a shell with :meth:`Popen.check_output` and "
"return a 2-tuple ``(exitcode, output)``. *encoding* and *errors* are used to "
"decode output; see the notes on :ref:`frequently-used-arguments` for more "
"details."
msgstr ""

#: ../../library/subprocess.rst:1547
msgid ""
"A trailing newline is stripped from the output. The exit code for the "
"command can be interpreted as the return code of subprocess.  Example::"
msgstr ""

#: ../../library/subprocess.rst:1551
msgid ""
">>> subprocess.getstatusoutput('ls /bin/ls')\n"
"(0, '/bin/ls')\n"
">>> subprocess.getstatusoutput('cat /bin/junk')\n"
"(1, 'cat: /bin/junk: No such file or directory')\n"
">>> subprocess.getstatusoutput('/bin/junk')\n"
"(127, 'sh: /bin/junk: not found')\n"
">>> subprocess.getstatusoutput('/bin/kill $$')\n"
"(-15, '')"
msgstr ""
">>> subprocess.getstatusoutput('ls /bin/ls')\n"
"(0, '/bin/ls')\n"
">>> subprocess.getstatusoutput('cat /bin/junk')\n"
"(1, 'cat: /bin/junk: No such file or directory')\n"
">>> subprocess.getstatusoutput('/bin/junk')\n"
"(127, 'sh: /bin/junk: not found')\n"
">>> subprocess.getstatusoutput('/bin/kill $$')\n"
"(-15, '')"

#: ../../library/subprocess.rst:1562
msgid "Windows support was added."
msgstr "新增對 Windows 的支援。"

#: ../../library/subprocess.rst:1565
msgid ""
"The function now returns (exitcode, output) instead of (status, output) as "
"it did in Python 3.3.3 and earlier.  exitcode has the same value as :attr:"
"`~Popen.returncode`."
msgstr ""

#: ../../library/subprocess.rst:1574
msgid "Return output (stdout and stderr) of executing *cmd* in a shell."
msgstr ""

#: ../../library/subprocess.rst:1576
msgid ""
"Like :func:`getstatusoutput`, except the exit code is ignored and the return "
"value is a string containing the command's output.  Example::"
msgstr ""

#: ../../library/subprocess.rst:1579
msgid ""
">>> subprocess.getoutput('ls /bin/ls')\n"
"'/bin/ls'"
msgstr ""
">>> subprocess.getoutput('ls /bin/ls')\n"
"'/bin/ls'"

#: ../../library/subprocess.rst:1584
msgid "Windows support added"
msgstr "新增對 Windows 的支援"

#: ../../library/subprocess.rst:1592
msgid "Notes"
msgstr "註解"

#: ../../library/subprocess.rst:1597
msgid "Timeout Behavior"
msgstr ""

#: ../../library/subprocess.rst:1599
msgid ""
"When using the ``timeout`` parameter in functions like :func:`run`, :meth:"
"`Popen.wait`, or :meth:`Popen.communicate`, users should be aware of the "
"following behaviors:"
msgstr ""

#: ../../library/subprocess.rst:1603
msgid ""
"**Process Creation Delay**: The initial process creation itself cannot be "
"interrupted on many platform APIs. This means that even when specifying a "
"timeout, you are not guaranteed to see a timeout exception until at least "
"after however long process creation takes."
msgstr ""

#: ../../library/subprocess.rst:1608
msgid ""
"**Extremely Small Timeout Values**: Setting very small timeout values (such "
"as a few milliseconds) may result in almost immediate :exc:`TimeoutExpired` "
"exceptions because process creation and system scheduling inherently require "
"time."
msgstr ""

#: ../../library/subprocess.rst:1615
msgid "Converting an argument sequence to a string on Windows"
msgstr ""

#: ../../library/subprocess.rst:1617
msgid ""
"On Windows, an *args* sequence is converted to a string that can be parsed "
"using the following rules (which correspond to the rules used by the MS C "
"runtime):"
msgstr ""

#: ../../library/subprocess.rst:1621
msgid ""
"Arguments are delimited by white space, which is either a space or a tab."
msgstr ""

#: ../../library/subprocess.rst:1624
msgid ""
"A string surrounded by double quotation marks is interpreted as a single "
"argument, regardless of white space contained within.  A quoted string can "
"be embedded in an argument."
msgstr ""

#: ../../library/subprocess.rst:1629
msgid ""
"A double quotation mark preceded by a backslash is interpreted as a literal "
"double quotation mark."
msgstr ""

#: ../../library/subprocess.rst:1632
msgid ""
"Backslashes are interpreted literally, unless they immediately precede a "
"double quotation mark."
msgstr ""

#: ../../library/subprocess.rst:1635
msgid ""
"If backslashes immediately precede a double quotation mark, every pair of "
"backslashes is interpreted as a literal backslash.  If the number of "
"backslashes is odd, the last backslash escapes the next double quotation "
"mark as described in rule 3."
msgstr ""

#: ../../library/subprocess.rst:1644
msgid ":mod:`shlex`"
msgstr ":mod:`shlex`"

#: ../../library/subprocess.rst:1645
msgid "Module which provides function to parse and escape command lines."
msgstr ""

#: ../../library/subprocess.rst:1652
msgid "Disabling use of ``vfork()`` or ``posix_spawn()``"
msgstr "停用 ``vfork()`` 或 ``posix_spawn()``"

#: ../../library/subprocess.rst:1654
msgid ""
"On Linux, :mod:`subprocess` defaults to using the ``vfork()`` system call "
"internally when it is safe to do so rather than ``fork()``. This greatly "
"improves performance."
msgstr ""
"在 Linux 上，:mod:`subprocess` 在安全的情況下預設會在內部使用 ``vfork()`` 系"
"統呼叫，而不是 ``fork()``，這顯著地提高了性能。"

#: ../../library/subprocess.rst:1658
msgid ""
"If you ever encounter a presumed highly unusual situation where you need to "
"prevent ``vfork()`` from being used by Python, you can set the :const:"
"`subprocess._USE_VFORK` attribute to a false value."
msgstr ""
"如果你遇到了一個推定為極異常的情況，需要防止 Python 使用 ``vfork()``，你可以"
"將 :const:`subprocess._USE_VFORK` 屬性設為 false 值。"

#: ../../library/subprocess.rst:1664
msgid "subprocess._USE_VFORK = False  # See CPython issue gh-NNNNNN."
msgstr "subprocess._USE_VFORK = False  # 見 CPython 問題 gh-NNNNNN."

#: ../../library/subprocess.rst:1666
msgid ""
"Setting this has no impact on use of ``posix_spawn()`` which could use "
"``vfork()`` internally within its libc implementation.  There is a similar :"
"const:`subprocess._USE_POSIX_SPAWN` attribute if you need to prevent use of "
"that."
msgstr ""
"設定它並不會影響 ``posix_spawn()`` 的使用，它可以在其 libc 實作內部使用 "
"``vfork()``。如果你需要封鎖該屬性的使用，則有一個類似的 :const:`subprocess."
"_USE_POSIX_SPAWN` 屬性。"

#: ../../library/subprocess.rst:1673
msgid "subprocess._USE_POSIX_SPAWN = False  # See CPython issue gh-NNNNNN."
msgstr "subprocess._USE_POSIX_SPAWN = False  # 見 CPython 問題 gh-NNNNNN."

#: ../../library/subprocess.rst:1675
msgid ""
"It is safe to set these to false on any Python version. They will have no "
"effect on older versions when unsupported. Do not assume the attributes are "
"available to read. Despite their names, a true value does not indicate that "
"the corresponding function will be used, only that it may be."
msgstr ""
"在任何 Python 版本上將這些設定為 false 都是安全的。當不受支援時，它們對舊版本"
"沒有影響。不要假設屬性可供讀取。儘管有它們的名稱，真實值並不表示將使用相應的"
"函式，而只是表示可能會使用。"

#: ../../library/subprocess.rst:1680
msgid ""
"Please file issues any time you have to use these private knobs with a way "
"to reproduce the issue you were seeing. Link to that issue from a comment in "
"your code."
msgstr ""
"每當你需要使用這些私有開關以重現你所看到的問題時，請隨時提出問題 (file "
"issues)。從程式碼中的註解連結到該問題。"

#: ../../library/subprocess.rst:1684
msgid "``_USE_POSIX_SPAWN``"
msgstr "``_USE_POSIX_SPAWN``"

#: ../../library/subprocess.rst:1685
msgid "``_USE_VFORK``"
msgstr "``_USE_VFORK``"

#: ../../library/subprocess.rst:296
msgid "universal newlines"
msgstr "universal newlines"

#: ../../library/subprocess.rst:296
msgid "subprocess module"
msgstr "subprocess 模組"