1878 lines
69 KiB
TeX
1878 lines
69 KiB
TeX
\section{\module{os} ---
|
|
Miscellaneous operating system interfaces}
|
|
|
|
\declaremodule{standard}{os}
|
|
\modulesynopsis{Miscellaneous operating system interfaces.}
|
|
|
|
|
|
This module provides a more portable way of using operating system
|
|
dependent functionality than importing a operating system dependent
|
|
built-in module like \refmodule{posix} or \module{nt}.
|
|
|
|
This module searches for an operating system dependent built-in module like
|
|
\module{mac} or \refmodule{posix} and exports the same functions and data
|
|
as found there. The design of all Python's built-in operating system dependent
|
|
modules is such that as long as the same functionality is available,
|
|
it uses the same interface; for example, the function
|
|
\code{os.stat(\var{path})} returns stat information about \var{path} in
|
|
the same format (which happens to have originated with the
|
|
\POSIX{} interface).
|
|
|
|
Extensions peculiar to a particular operating system are also
|
|
available through the \module{os} module, but using them is of course a
|
|
threat to portability!
|
|
|
|
Note that after the first time \module{os} is imported, there is
|
|
\emph{no} performance penalty in using functions from \module{os}
|
|
instead of directly from the operating system dependent built-in module,
|
|
so there should be \emph{no} reason not to use \module{os}!
|
|
|
|
|
|
% Frank Stajano <fstajano@uk.research.att.com> complained that it
|
|
% wasn't clear that the entries described in the subsections were all
|
|
% available at the module level (most uses of subsections are
|
|
% different); I think this is only a problem for the HTML version,
|
|
% where the relationship may not be as clear.
|
|
%
|
|
\ifhtml
|
|
The \module{os} module contains many functions and data values.
|
|
The items below and in the following sub-sections are all available
|
|
directly from the \module{os} module.
|
|
\fi
|
|
|
|
|
|
\begin{excdesc}{error}
|
|
This exception is raised when a function returns a system-related
|
|
error (not for illegal argument types or other incidental errors).
|
|
This is also known as the built-in exception \exception{OSError}. The
|
|
accompanying value is a pair containing the numeric error code from
|
|
\cdata{errno} and the corresponding string, as would be printed by the
|
|
C function \cfunction{perror()}. See the module
|
|
\refmodule{errno}\refbimodindex{errno}, which contains names for the
|
|
error codes defined by the underlying operating system.
|
|
|
|
When exceptions are classes, this exception carries two attributes,
|
|
\member{errno} and \member{strerror}. The first holds the value of
|
|
the C \cdata{errno} variable, and the latter holds the corresponding
|
|
error message from \cfunction{strerror()}. For exceptions that
|
|
involve a file system path (such as \function{chdir()} or
|
|
\function{unlink()}), the exception instance will contain a third
|
|
attribute, \member{filename}, which is the file name passed to the
|
|
function.
|
|
\end{excdesc}
|
|
|
|
\begin{datadesc}{name}
|
|
The name of the operating system dependent module imported. The
|
|
following names have currently been registered: \code{'posix'},
|
|
\code{'nt'}, \code{'mac'}, \code{'os2'}, \code{'ce'},
|
|
\code{'java'}, \code{'riscos'}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{path}
|
|
The corresponding operating system dependent standard module for pathname
|
|
operations, such as \module{posixpath} or \module{macpath}. Thus,
|
|
given the proper imports, \code{os.path.split(\var{file})} is
|
|
equivalent to but more portable than
|
|
\code{posixpath.split(\var{file})}. Note that this is also an
|
|
importable module: it may be imported directly as
|
|
\refmodule{os.path}.
|
|
\end{datadesc}
|
|
|
|
|
|
|
|
\subsection{Process Parameters \label{os-procinfo}}
|
|
|
|
These functions and data items provide information and operate on the
|
|
current process and user.
|
|
|
|
\begin{datadesc}{environ}
|
|
A mapping object representing the string environment. For example,
|
|
\code{environ['HOME']} is the pathname of your home directory (on some
|
|
platforms), and is equivalent to \code{getenv("HOME")} in C.
|
|
|
|
This mapping is captured the first time the \module{os} module is
|
|
imported, typically during Python startup as part of processing
|
|
\file{site.py}. Changes to the environment made after this time are
|
|
not reflected in \code{os.environ}, except for changes made by modifying
|
|
\code{os.environ} directly.
|
|
|
|
If the platform supports the \function{putenv()} function, this
|
|
mapping may be used to modify the environment as well as query the
|
|
environment. \function{putenv()} will be called automatically when
|
|
the mapping is modified.
|
|
\note{Calling \function{putenv()} directly does not change
|
|
\code{os.environ}, so it's better to modify \code{os.environ}.}
|
|
\note{On some platforms, including FreeBSD and Mac OS X, setting
|
|
\code{environ} may cause memory leaks. Refer to the system documentation
|
|
for \cfunction{putenv()}.}
|
|
|
|
If \function{putenv()} is not provided, this mapping may be passed to
|
|
the appropriate process-creation functions to cause child processes to
|
|
use a modified environment.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdescni}{chdir}{path}
|
|
\funclineni{fchdir}{fd}
|
|
\funclineni{getcwd}{}
|
|
These functions are described in ``Files and Directories'' (section
|
|
\ref{os-file-dir}).
|
|
\end{funcdescni}
|
|
|
|
\begin{funcdesc}{ctermid}{}
|
|
Return the filename corresponding to the controlling terminal of the
|
|
process.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getegid}{}
|
|
Return the effective group id of the current process. This
|
|
corresponds to the `set id' bit on the file being executed in the
|
|
current process.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{geteuid}{}
|
|
\index{user!effective id}
|
|
Return the current process' effective user id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getgid}{}
|
|
\index{process!group}
|
|
Return the real group id of the current process.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getgroups}{}
|
|
Return list of supplemental group ids associated with the current
|
|
process.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getlogin}{}
|
|
Return the name of the user logged in on the controlling terminal of
|
|
the process. For most purposes, it is more useful to use the
|
|
environment variable \envvar{LOGNAME} to find out who the user is,
|
|
or \code{pwd.getpwuid(os.getuid())[0]} to get the login name
|
|
of the currently effective user ID.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getpgid}{pid}
|
|
Return the process group id of the process with process id \var{pid}.
|
|
If \var{pid} is 0, the process group id of the current process is
|
|
returned. Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getpgrp}{}
|
|
\index{process!group}
|
|
Return the id of the current process group.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getpid}{}
|
|
\index{process!id}
|
|
Return the current process id.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getppid}{}
|
|
\index{process!id of parent}
|
|
Return the parent's process id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getuid}{}
|
|
\index{user!id}
|
|
Return the current process' user id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getenv}{varname\optional{, value}}
|
|
Return the value of the environment variable \var{varname} if it
|
|
exists, or \var{value} if it doesn't. \var{value} defaults to
|
|
\code{None}.
|
|
Availability: most flavors of \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{putenv}{varname, value}
|
|
\index{environment variables!setting}
|
|
Set the environment variable named \var{varname} to the string
|
|
\var{value}. Such changes to the environment affect subprocesses
|
|
started with \function{os.system()}, \function{popen()} or
|
|
\function{fork()} and \function{execv()}.
|
|
Availability: most flavors of \UNIX, Windows.
|
|
|
|
\note{On some platforms, including FreeBSD and Mac OS X,
|
|
setting \code{environ} may cause memory leaks.
|
|
Refer to the system documentation for putenv.}
|
|
|
|
When \function{putenv()} is
|
|
supported, assignments to items in \code{os.environ} are automatically
|
|
translated into corresponding calls to \function{putenv()}; however,
|
|
calls to \function{putenv()} don't update \code{os.environ}, so it is
|
|
actually preferable to assign to items of \code{os.environ}.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setegid}{egid}
|
|
Set the current process's effective group id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{seteuid}{euid}
|
|
Set the current process's effective user id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setgid}{gid}
|
|
Set the current process' group id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setgroups}{groups}
|
|
Set the list of supplemental group ids associated with the current
|
|
process to \var{groups}. \var{groups} must be a sequence, and each
|
|
element must be an integer identifying a group. This operation is
|
|
typical available only to the superuser.
|
|
Availability: \UNIX.
|
|
\versionadded{2.2}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setpgrp}{}
|
|
Calls the system call \cfunction{setpgrp()} or \cfunction{setpgrp(0,
|
|
0)} depending on which version is implemented (if any). See the
|
|
\UNIX{} manual for the semantics.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setpgid}{pid, pgrp} Calls the system call
|
|
\cfunction{setpgid()} to set the process group id of the process with
|
|
id \var{pid} to the process group with id \var{pgrp}. See the \UNIX{}
|
|
manual for the semantics.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setreuid}{ruid, euid}
|
|
Set the current process's real and effective user ids.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setregid}{rgid, egid}
|
|
Set the current process's real and effective group ids.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getsid}{pid}
|
|
Calls the system call \cfunction{getsid()}. See the \UNIX{} manual
|
|
for the semantics.
|
|
Availability: \UNIX. \versionadded{2.4}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setsid}{}
|
|
Calls the system call \cfunction{setsid()}. See the \UNIX{} manual
|
|
for the semantics.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{setuid}{uid}
|
|
\index{user!id, setting}
|
|
Set the current process' user id.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
% placed in this section since it relates to errno.... a little weak
|
|
\begin{funcdesc}{strerror}{code}
|
|
Return the error message corresponding to the error code in
|
|
\var{code}.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{umask}{mask}
|
|
Set the current numeric umask and returns the previous umask.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{uname}{}
|
|
Return a 5-tuple containing information identifying the current
|
|
operating system. The tuple contains 5 strings:
|
|
\code{(\var{sysname}, \var{nodename}, \var{release}, \var{version},
|
|
\var{machine})}. Some systems truncate the nodename to 8
|
|
characters or to the leading component; a better way to get the
|
|
hostname is \function{socket.gethostname()}
|
|
\withsubitem{(in module socket)}{\ttindex{gethostname()}}
|
|
or even
|
|
\withsubitem{(in module socket)}{\ttindex{gethostbyaddr()}}
|
|
\code{socket.gethostbyaddr(socket.gethostname())}.
|
|
Availability: recent flavors of \UNIX.
|
|
\end{funcdesc}
|
|
|
|
|
|
|
|
\subsection{File Object Creation \label{os-newstreams}}
|
|
|
|
These functions create new file objects.
|
|
|
|
|
|
\begin{funcdesc}{fdopen}{fd\optional{, mode\optional{, bufsize}}}
|
|
Return an open file object connected to the file descriptor \var{fd}.
|
|
\index{I/O control!buffering}
|
|
The \var{mode} and \var{bufsize} arguments have the same meaning as
|
|
the corresponding arguments to the built-in \function{open()}
|
|
function.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
\versionchanged[When specified, the \var{mode} argument must now start
|
|
with one of the letters \character{r}, \character{w}, or \character{a},
|
|
otherwise a \exception{ValueError} is raised]{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{popen}{command\optional{, mode\optional{, bufsize}}}
|
|
Open a pipe to or from \var{command}. The return value is an open
|
|
file object connected to the pipe, which can be read or written
|
|
depending on whether \var{mode} is \code{'r'} (default) or \code{'w'}.
|
|
The \var{bufsize} argument has the same meaning as the corresponding
|
|
argument to the built-in \function{open()} function. The exit status of
|
|
the command (encoded in the format specified for \function{wait()}) is
|
|
available as the return value of the \method{close()} method of the file
|
|
object, except that when the exit status is zero (termination without
|
|
errors), \code{None} is returned.
|
|
Availability: \UNIX, Windows.
|
|
|
|
\versionchanged[This function worked unreliably under Windows in
|
|
earlier versions of Python. This was due to the use of the
|
|
\cfunction{_popen()} function from the libraries provided with
|
|
Windows. Newer versions of Python do not use the broken
|
|
implementation from the Windows libraries]{2.0}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{tmpfile}{}
|
|
Return a new file object opened in update mode (\samp{w+b}). The file
|
|
has no directory entries associated with it and will be automatically
|
|
deleted once there are no file descriptors for the file.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
|
|
For each of these \function{popen()} variants, if \var{bufsize} is
|
|
specified, it specifies the buffer size for the I/O pipes.
|
|
\var{mode}, if provided, should be the string \code{'b'} or
|
|
\code{'t'}; on Windows this is needed to determine whether the file
|
|
objects should be opened in binary or text mode. The default value
|
|
for \var{mode} is \code{'t'}.
|
|
|
|
Also, for each of these variants, on \UNIX, \var{cmd} may be a sequence, in
|
|
which case arguments will be passed directly to the program without shell
|
|
intervention (as with \function{os.spawnv()}). If \var{cmd} is a string it will
|
|
be passed to the shell (as with \function{os.system()}).
|
|
|
|
These methods do not make it possible to retrieve the return code from
|
|
the child processes. The only way to control the input and output
|
|
streams and also retrieve the return codes is to use the
|
|
\class{Popen3} and \class{Popen4} classes from the \refmodule{popen2}
|
|
module; these are only available on \UNIX.
|
|
|
|
For a discussion of possible deadlock conditions related to the use
|
|
of these functions, see ``\ulink{Flow Control
|
|
Issues}{popen2-flow-control.html}''
|
|
(section~\ref{popen2-flow-control}).
|
|
|
|
\begin{funcdesc}{popen2}{cmd\optional{, mode\optional{, bufsize}}}
|
|
Executes \var{cmd} as a sub-process. Returns the file objects
|
|
\code{(\var{child_stdin}, \var{child_stdout})}.
|
|
Availability: \UNIX, Windows.
|
|
\versionadded{2.0}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{popen3}{cmd\optional{, mode\optional{, bufsize}}}
|
|
Executes \var{cmd} as a sub-process. Returns the file objects
|
|
\code{(\var{child_stdin}, \var{child_stdout}, \var{child_stderr})}.
|
|
Availability: \UNIX, Windows.
|
|
\versionadded{2.0}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{popen4}{cmd\optional{, mode\optional{, bufsize}}}
|
|
Executes \var{cmd} as a sub-process. Returns the file objects
|
|
\code{(\var{child_stdin}, \var{child_stdout_and_stderr})}.
|
|
Availability: \UNIX, Windows.
|
|
\versionadded{2.0}
|
|
\end{funcdesc}
|
|
|
|
(Note that \code{\var{child_stdin}, \var{child_stdout}, and
|
|
\var{child_stderr}} are named from the point of view of the child
|
|
process, i.e. \var{child_stdin} is the child's standard input.)
|
|
|
|
This functionality is also available in the \refmodule{popen2} module
|
|
using functions of the same names, but the return values of those
|
|
functions have a different order.
|
|
|
|
|
|
\subsection{File Descriptor Operations \label{os-fd-ops}}
|
|
|
|
These functions operate on I/O streams referred to
|
|
using file descriptors.
|
|
|
|
|
|
\begin{funcdesc}{close}{fd}
|
|
Close file descriptor \var{fd}.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
\begin{notice}
|
|
This function is intended for low-level I/O and must be applied
|
|
to a file descriptor as returned by \function{open()} or
|
|
\function{pipe()}. To close a ``file object'' returned by the
|
|
built-in function \function{open()} or by \function{popen()} or
|
|
\function{fdopen()}, use its \method{close()} method.
|
|
\end{notice}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{dup}{fd}
|
|
Return a duplicate of file descriptor \var{fd}.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{dup2}{fd, fd2}
|
|
Duplicate file descriptor \var{fd} to \var{fd2}, closing the latter
|
|
first if necessary.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{fdatasync}{fd}
|
|
Force write of file with filedescriptor \var{fd} to disk.
|
|
Does not force update of metadata.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{fpathconf}{fd, name}
|
|
Return system configuration information relevant to an open file.
|
|
\var{name} specifies the configuration value to retrieve; it may be a
|
|
string which is the name of a defined system value; these names are
|
|
specified in a number of standards (\POSIX.1, \UNIX{} 95, \UNIX{} 98, and
|
|
others). Some platforms define additional names as well. The names
|
|
known to the host operating system are given in the
|
|
\code{pathconf_names} dictionary. For configuration variables not
|
|
included in that mapping, passing an integer for \var{name} is also
|
|
accepted.
|
|
Availability: \UNIX.
|
|
|
|
If \var{name} is a string and is not known, \exception{ValueError} is
|
|
raised. If a specific value for \var{name} is not supported by the
|
|
host system, even if it is included in \code{pathconf_names}, an
|
|
\exception{OSError} is raised with \constant{errno.EINVAL} for the
|
|
error number.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{fstat}{fd}
|
|
Return status for file descriptor \var{fd}, like \function{stat()}.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{fstatvfs}{fd}
|
|
Return information about the filesystem containing the file associated
|
|
with file descriptor \var{fd}, like \function{statvfs()}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{fsync}{fd}
|
|
Force write of file with filedescriptor \var{fd} to disk. On \UNIX,
|
|
this calls the native \cfunction{fsync()} function; on Windows, the
|
|
MS \cfunction{_commit()} function.
|
|
|
|
If you're starting with a Python file object \var{f}, first do
|
|
\code{\var{f}.flush()}, and then do \code{os.fsync(\var{f}.fileno())},
|
|
to ensure that all internal buffers associated with \var{f} are written
|
|
to disk.
|
|
Availability: \UNIX, and Windows starting in 2.2.3.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{ftruncate}{fd, length}
|
|
Truncate the file corresponding to file descriptor \var{fd},
|
|
so that it is at most \var{length} bytes in size.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{isatty}{fd}
|
|
Return \code{True} if the file descriptor \var{fd} is open and
|
|
connected to a tty(-like) device, else \code{False}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{lseek}{fd, pos, how}
|
|
Set the current position of file descriptor \var{fd} to position
|
|
\var{pos}, modified by \var{how}: \code{0} to set the position
|
|
relative to the beginning of the file; \code{1} to set it relative to
|
|
the current position; \code{2} to set it relative to the end of the
|
|
file.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{open}{file, flags\optional{, mode}}
|
|
Open the file \var{file} and set various flags according to
|
|
\var{flags} and possibly its mode according to \var{mode}.
|
|
The default \var{mode} is \code{0777} (octal), and the current umask
|
|
value is first masked out. Return the file descriptor for the newly
|
|
opened file.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
For a description of the flag and mode values, see the C run-time
|
|
documentation; flag constants (like \constant{O_RDONLY} and
|
|
\constant{O_WRONLY}) are defined in this module too (see below).
|
|
|
|
\begin{notice}
|
|
This function is intended for low-level I/O. For normal usage,
|
|
use the built-in function \function{open()}, which returns a ``file
|
|
object'' with \method{read()} and \method{write()} methods (and many
|
|
more).
|
|
\end{notice}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{openpty}{}
|
|
Open a new pseudo-terminal pair. Return a pair of file descriptors
|
|
\code{(\var{master}, \var{slave})} for the pty and the tty,
|
|
respectively. For a (slightly) more portable approach, use the
|
|
\refmodule{pty}\refstmodindex{pty} module.
|
|
Availability: Some flavors of \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{pipe}{}
|
|
Create a pipe. Return a pair of file descriptors \code{(\var{r},
|
|
\var{w})} usable for reading and writing, respectively.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{read}{fd, n}
|
|
Read at most \var{n} bytes from file descriptor \var{fd}.
|
|
Return a string containing the bytes read. If the end of the file
|
|
referred to by \var{fd} has been reached, an empty string is
|
|
returned.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
\begin{notice}
|
|
This function is intended for low-level I/O and must be applied
|
|
to a file descriptor as returned by \function{open()} or
|
|
\function{pipe()}. To read a ``file object'' returned by the
|
|
built-in function \function{open()} or by \function{popen()} or
|
|
\function{fdopen()}, or \code{sys.stdin}, use its
|
|
\method{read()} or \method{readline()} methods.
|
|
\end{notice}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{tcgetpgrp}{fd}
|
|
Return the process group associated with the terminal given by
|
|
\var{fd} (an open file descriptor as returned by \function{open()}).
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{tcsetpgrp}{fd, pg}
|
|
Set the process group associated with the terminal given by
|
|
\var{fd} (an open file descriptor as returned by \function{open()})
|
|
to \var{pg}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{ttyname}{fd}
|
|
Return a string which specifies the terminal device associated with
|
|
file-descriptor \var{fd}. If \var{fd} is not associated with a terminal
|
|
device, an exception is raised.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{write}{fd, str}
|
|
Write the string \var{str} to file descriptor \var{fd}.
|
|
Return the number of bytes actually written.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
\begin{notice}
|
|
This function is intended for low-level I/O and must be applied
|
|
to a file descriptor as returned by \function{open()} or
|
|
\function{pipe()}. To write a ``file object'' returned by the
|
|
built-in function \function{open()} or by \function{popen()} or
|
|
\function{fdopen()}, or \code{sys.stdout} or \code{sys.stderr}, use
|
|
its \method{write()} method.
|
|
\end{notice}
|
|
\end{funcdesc}
|
|
|
|
|
|
The following data items are available for use in constructing the
|
|
\var{flags} parameter to the \function{open()} function.
|
|
|
|
\begin{datadesc}{O_RDONLY}
|
|
\dataline{O_WRONLY}
|
|
\dataline{O_RDWR}
|
|
\dataline{O_APPEND}
|
|
\dataline{O_CREAT}
|
|
\dataline{O_EXCL}
|
|
\dataline{O_TRUNC}
|
|
Options for the \var{flag} argument to the \function{open()} function.
|
|
These can be bit-wise OR'd together.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{O_DSYNC}
|
|
\dataline{O_RSYNC}
|
|
\dataline{O_SYNC}
|
|
\dataline{O_NDELAY}
|
|
\dataline{O_NONBLOCK}
|
|
\dataline{O_NOCTTY}
|
|
More options for the \var{flag} argument to the \function{open()} function.
|
|
Availability: Macintosh, \UNIX.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{O_BINARY}
|
|
Option for the \var{flag} argument to the \function{open()} function.
|
|
This can be bit-wise OR'd together with those listed above.
|
|
Availability: Macintosh, Windows.
|
|
% XXX need to check on the availability of this one.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{O_NOINHERIT}
|
|
\dataline{O_SHORT_LIVED}
|
|
\dataline{O_TEMPORARY}
|
|
\dataline{O_RANDOM}
|
|
\dataline{O_SEQUENTIAL}
|
|
\dataline{O_TEXT}
|
|
Options for the \var{flag} argument to the \function{open()} function.
|
|
These can be bit-wise OR'd together.
|
|
Availability: Windows.
|
|
\end{datadesc}
|
|
|
|
\subsection{Files and Directories \label{os-file-dir}}
|
|
|
|
\begin{funcdesc}{access}{path, mode}
|
|
Use the real uid/gid to test for access to \var{path}. Note that most
|
|
operations will use the effective uid/gid, therefore this routine can
|
|
be used in a suid/sgid environment to test if the invoking user has the
|
|
specified access to \var{path}. \var{mode} should be \constant{F_OK}
|
|
to test the existence of \var{path}, or it can be the inclusive OR of
|
|
one or more of \constant{R_OK}, \constant{W_OK}, and \constant{X_OK} to
|
|
test permissions. Return \constant{True} if access is allowed,
|
|
\constant{False} if not.
|
|
See the \UNIX{} man page \manpage{access}{2} for more information.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{F_OK}
|
|
Value to pass as the \var{mode} parameter of \function{access()} to
|
|
test the existence of \var{path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{R_OK}
|
|
Value to include in the \var{mode} parameter of \function{access()}
|
|
to test the readability of \var{path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{W_OK}
|
|
Value to include in the \var{mode} parameter of \function{access()}
|
|
to test the writability of \var{path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{X_OK}
|
|
Value to include in the \var{mode} parameter of \function{access()}
|
|
to determine if \var{path} can be executed.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{chdir}{path}
|
|
\index{directory!changing}
|
|
Change the current working directory to \var{path}.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{fchdir}{fd}
|
|
Change the current working directory to the directory represented by
|
|
the file descriptor \var{fd}. The descriptor must refer to an opened
|
|
directory, not an open file.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getcwd}{}
|
|
Return a string representing the current working directory.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{getcwdu}{}
|
|
Return a Unicode object representing the current working directory.
|
|
Availability: \UNIX, Windows.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{chroot}{path}
|
|
Change the root directory of the current process to \var{path}.
|
|
Availability: \UNIX.
|
|
\versionadded{2.2}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{chmod}{path, mode}
|
|
Change the mode of \var{path} to the numeric \var{mode}.
|
|
\var{mode} may take one of the following values
|
|
(as defined in the \module{stat} module):
|
|
\begin{itemize}
|
|
\item \code{S_ISUID}
|
|
\item \code{S_ISGID}
|
|
\item \code{S_ENFMT}
|
|
\item \code{S_ISVTX}
|
|
\item \code{S_IREAD}
|
|
\item \code{S_IWRITE}
|
|
\item \code{S_IEXEC}
|
|
\item \code{S_IRWXU}
|
|
\item \code{S_IRUSR}
|
|
\item \code{S_IWUSR}
|
|
\item \code{S_IXUSR}
|
|
\item \code{S_IRWXG}
|
|
\item \code{S_IRGRP}
|
|
\item \code{S_IWGRP}
|
|
\item \code{S_IXGRP}
|
|
\item \code{S_IRWXO}
|
|
\item \code{S_IROTH}
|
|
\item \code{S_IWOTH}
|
|
\item \code{S_IXOTH}
|
|
\end{itemize}
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{chown}{path, uid, gid}
|
|
Change the owner and group id of \var{path} to the numeric \var{uid}
|
|
and \var{gid}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{lchown}{path, uid, gid}
|
|
Change the owner and group id of \var{path} to the numeric \var{uid}
|
|
and gid. This function will not follow symbolic links.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{link}{src, dst}
|
|
Create a hard link pointing to \var{src} named \var{dst}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{listdir}{path}
|
|
Return a list containing the names of the entries in the directory.
|
|
The list is in arbitrary order. It does not include the special
|
|
entries \code{'.'} and \code{'..'} even if they are present in the
|
|
directory.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
\versionchanged[On Windows NT/2k/XP and Unix, if \var{path} is a Unicode
|
|
object, the result will be a list of Unicode objects.]{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{lstat}{path}
|
|
Like \function{stat()}, but do not follow symbolic links.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{mkfifo}{path\optional{, mode}}
|
|
Create a FIFO (a named pipe) named \var{path} with numeric mode
|
|
\var{mode}. The default \var{mode} is \code{0666} (octal). The current
|
|
umask value is first masked out from the mode.
|
|
Availability: \UNIX.
|
|
|
|
FIFOs are pipes that can be accessed like regular files. FIFOs exist
|
|
until they are deleted (for example with \function{os.unlink()}).
|
|
Generally, FIFOs are used as rendezvous between ``client'' and
|
|
``server'' type processes: the server opens the FIFO for reading, and
|
|
the client opens it for writing. Note that \function{mkfifo()}
|
|
doesn't open the FIFO --- it just creates the rendezvous point.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{mknod}{path\optional{, mode=0600, device}}
|
|
Create a filesystem node (file, device special file or named pipe)
|
|
named filename. \var{mode} specifies both the permissions to use and
|
|
the type of node to be created, being combined (bitwise OR) with one
|
|
of S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO (those constants are
|
|
available in \module{stat}). For S_IFCHR and S_IFBLK, \var{device}
|
|
defines the newly created device special file (probably using
|
|
\function{os.makedev()}), otherwise it is ignored.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{major}{device}
|
|
Extracts a device major number from a raw device number.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{minor}{device}
|
|
Extracts a device minor number from a raw device number.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{makedev}{major, minor}
|
|
Composes a raw device number from the major and minor device numbers.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{mkdir}{path\optional{, mode}}
|
|
Create a directory named \var{path} with numeric mode \var{mode}.
|
|
The default \var{mode} is \code{0777} (octal). On some systems,
|
|
\var{mode} is ignored. Where it is used, the current umask value is
|
|
first masked out.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{makedirs}{path\optional{, mode}}
|
|
Recursive directory creation function.\index{directory!creating}
|
|
\index{UNC paths!and \function{os.makedirs()}}
|
|
Like \function{mkdir()},
|
|
but makes all intermediate-level directories needed to contain the
|
|
leaf directory. Throws an \exception{error} exception if the leaf
|
|
directory already exists or cannot be created. The default \var{mode}
|
|
is \code{0777} (octal). This function does not properly handle UNC
|
|
paths (only relevant on Windows systems; Universal Naming Convention
|
|
paths are those that use the `\code{\e\e host\e path}' syntax).
|
|
\versionadded{1.5.2}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{pathconf}{path, name}
|
|
Return system configuration information relevant to a named file.
|
|
\var{name} specifies the configuration value to retrieve; it may be a
|
|
string which is the name of a defined system value; these names are
|
|
specified in a number of standards (\POSIX.1, \UNIX{} 95, \UNIX{} 98, and
|
|
others). Some platforms define additional names as well. The names
|
|
known to the host operating system are given in the
|
|
\code{pathconf_names} dictionary. For configuration variables not
|
|
included in that mapping, passing an integer for \var{name} is also
|
|
accepted.
|
|
Availability: \UNIX.
|
|
|
|
If \var{name} is a string and is not known, \exception{ValueError} is
|
|
raised. If a specific value for \var{name} is not supported by the
|
|
host system, even if it is included in \code{pathconf_names}, an
|
|
\exception{OSError} is raised with \constant{errno.EINVAL} for the
|
|
error number.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{pathconf_names}
|
|
Dictionary mapping names accepted by \function{pathconf()} and
|
|
\function{fpathconf()} to the integer values defined for those names
|
|
by the host operating system. This can be used to determine the set
|
|
of names known to the system.
|
|
Availability: \UNIX.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{readlink}{path}
|
|
Return a string representing the path to which the symbolic link
|
|
points. The result may be either an absolute or relative pathname; if
|
|
it is relative, it may be converted to an absolute pathname using
|
|
\code{os.path.join(os.path.dirname(\var{path}), \var{result})}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{remove}{path}
|
|
Remove the file \var{path}. If \var{path} is a directory,
|
|
\exception{OSError} is raised; see \function{rmdir()} below to remove
|
|
a directory. This is identical to the \function{unlink()} function
|
|
documented below. On Windows, attempting to remove a file that is in
|
|
use causes an exception to be raised; on \UNIX, the directory entry is
|
|
removed but the storage allocated to the file is not made available
|
|
until the original file is no longer in use.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{removedirs}{path}
|
|
\index{directory!deleting}
|
|
Removes directories recursively. Works like
|
|
\function{rmdir()} except that, if the leaf directory is
|
|
successfully removed, directories corresponding to rightmost path
|
|
segments will be pruned way until either the whole path is consumed or
|
|
an error is raised (which is ignored, because it generally means that
|
|
a parent directory is not empty). Throws an \exception{error}
|
|
exception if the leaf directory could not be successfully removed.
|
|
\versionadded{1.5.2}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{rename}{src, dst}
|
|
Rename the file or directory \var{src} to \var{dst}. If \var{dst} is
|
|
a directory, \exception{OSError} will be raised. On \UNIX, if
|
|
\var{dst} exists and is a file, it will be removed silently if the
|
|
user has permission. The operation may fail on some \UNIX{} flavors
|
|
if \var{src} and \var{dst} are on different filesystems. If
|
|
successful, the renaming will be an atomic operation (this is a
|
|
\POSIX{} requirement). On Windows, if \var{dst} already exists,
|
|
\exception{OSError} will be raised even if it is a file; there may be
|
|
no way to implement an atomic rename when \var{dst} names an existing
|
|
file.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{renames}{old, new}
|
|
Recursive directory or file renaming function.
|
|
Works like \function{rename()}, except creation of any intermediate
|
|
directories needed to make the new pathname good is attempted first.
|
|
After the rename, directories corresponding to rightmost path segments
|
|
of the old name will be pruned away using \function{removedirs()}.
|
|
\versionadded{1.5.2}
|
|
|
|
\begin{notice}
|
|
This function can fail with the new directory structure made if
|
|
you lack permissions needed to remove the leaf directory or file.
|
|
\end{notice}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{rmdir}{path}
|
|
Remove the directory \var{path}.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{stat}{path}
|
|
Perform a \cfunction{stat()} system call on the given path. The
|
|
return value is an object whose attributes correspond to the members of
|
|
the \ctype{stat} structure, namely:
|
|
\member{st_mode} (protection bits),
|
|
\member{st_ino} (inode number),
|
|
\member{st_dev} (device),
|
|
\member{st_nlink} (number of hard links),
|
|
\member{st_uid} (user ID of owner),
|
|
\member{st_gid} (group ID of owner),
|
|
\member{st_size} (size of file, in bytes),
|
|
\member{st_atime} (time of most recent access),
|
|
\member{st_mtime} (time of most recent content modification),
|
|
\member{st_ctime}
|
|
(platform dependent; time of most recent metadata change on \UNIX, or
|
|
the time of creation on Windows):
|
|
|
|
\begin{verbatim}
|
|
>>> import os
|
|
>>> statinfo = os.stat('somefile.txt')
|
|
>>> statinfo
|
|
(33188, 422511L, 769L, 1, 1032, 100, 926L, 1105022698,1105022732, 1105022732)
|
|
>>> statinfo.st_size
|
|
926L
|
|
>>>
|
|
\end{verbatim}
|
|
|
|
\versionchanged [If \function{stat_float_times} returns true, the time
|
|
values are floats, measuring seconds. Fractions of a second may be
|
|
reported if the system supports that. On Mac OS, the times are always
|
|
floats. See \function{stat_float_times} for further discussion. ]{2.3}
|
|
|
|
On some Unix systems (such as Linux), the following attributes may
|
|
also be available:
|
|
\member{st_blocks} (number of blocks allocated for file),
|
|
\member{st_blksize} (filesystem blocksize),
|
|
\member{st_rdev} (type of device if an inode device).
|
|
|
|
On Mac OS systems, the following attributes may also be available:
|
|
\member{st_rsize},
|
|
\member{st_creator},
|
|
\member{st_type}.
|
|
|
|
On RISCOS systems, the following attributes are also available:
|
|
\member{st_ftype} (file type),
|
|
\member{st_attrs} (attributes),
|
|
\member{st_obtype} (object type).
|
|
|
|
For backward compatibility, the return value of \function{stat()} is
|
|
also accessible as a tuple of at least 10 integers giving the most
|
|
important (and portable) members of the \ctype{stat} structure, in the
|
|
order
|
|
\member{st_mode},
|
|
\member{st_ino},
|
|
\member{st_dev},
|
|
\member{st_nlink},
|
|
\member{st_uid},
|
|
\member{st_gid},
|
|
\member{st_size},
|
|
\member{st_atime},
|
|
\member{st_mtime},
|
|
\member{st_ctime}.
|
|
More items may be added at the end by some implementations.
|
|
The standard module \refmodule{stat}\refstmodindex{stat} defines
|
|
functions and constants that are useful for extracting information
|
|
from a \ctype{stat} structure.
|
|
(On Windows, some items are filled with dummy values.)
|
|
|
|
\note{The exact meaning and resolution of the \member{st_atime},
|
|
\member{st_mtime}, and \member{st_ctime} members depends on the
|
|
operating system and the file system. For example, on Windows systems
|
|
using the FAT or FAT32 file systems, \member{st_mtime} has 2-second
|
|
resolution, and \member{st_atime} has only 1-day resolution. See
|
|
your operating system documentation for details.}
|
|
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
|
|
\versionchanged
|
|
[Added access to values as attributes of the returned object]{2.2}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{stat_float_times}{\optional{newvalue}}
|
|
Determine whether \class{stat_result} represents time stamps as float
|
|
objects. If newval is True, future calls to stat() return floats, if
|
|
it is False, future calls return ints. If newval is omitted, return
|
|
the current setting.
|
|
|
|
For compatibility with older Python versions, accessing
|
|
\class{stat_result} as a tuple always returns integers. For
|
|
compatibility with Python 2.2, accessing the time stamps by field name
|
|
also returns integers. Applications that want to determine the
|
|
fractions of a second in a time stamp can use this function to have
|
|
time stamps represented as floats. Whether they will actually observe
|
|
non-zero fractions depends on the system.
|
|
|
|
Future Python releases will change the default of this setting;
|
|
applications that cannot deal with floating point time stamps can then
|
|
use this function to turn the feature off.
|
|
|
|
It is recommended that this setting is only changed at program startup
|
|
time in the \var{__main__} module; libraries should never change this
|
|
setting. If an application uses a library that works incorrectly if
|
|
floating point time stamps are processed, this application should turn
|
|
the feature off until the library has been corrected.
|
|
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{statvfs}{path}
|
|
Perform a \cfunction{statvfs()} system call on the given path. The
|
|
return value is an object whose attributes describe the filesystem on
|
|
the given path, and correspond to the members of the
|
|
\ctype{statvfs} structure, namely:
|
|
\member{f_frsize},
|
|
\member{f_blocks},
|
|
\member{f_bfree},
|
|
\member{f_bavail},
|
|
\member{f_files},
|
|
\member{f_ffree},
|
|
\member{f_favail},
|
|
\member{f_flag},
|
|
\member{f_namemax}.
|
|
Availability: \UNIX.
|
|
|
|
For backward compatibility, the return value is also accessible as a
|
|
tuple whose values correspond to the attributes, in the order given above.
|
|
The standard module \refmodule{statvfs}\refstmodindex{statvfs}
|
|
defines constants that are useful for extracting information
|
|
from a \ctype{statvfs} structure when accessing it as a sequence; this
|
|
remains useful when writing code that needs to work with versions of
|
|
Python that don't support accessing the fields as attributes.
|
|
|
|
\versionchanged
|
|
[Added access to values as attributes of the returned object]{2.2}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{symlink}{src, dst}
|
|
Create a symbolic link pointing to \var{src} named \var{dst}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{tempnam}{\optional{dir\optional{, prefix}}}
|
|
Return a unique path name that is reasonable for creating a temporary
|
|
file. This will be an absolute path that names a potential directory
|
|
entry in the directory \var{dir} or a common location for temporary
|
|
files if \var{dir} is omitted or \code{None}. If given and not
|
|
\code{None}, \var{prefix} is used to provide a short prefix to the
|
|
filename. Applications are responsible for properly creating and
|
|
managing files created using paths returned by \function{tempnam()};
|
|
no automatic cleanup is provided.
|
|
On \UNIX, the environment variable \envvar{TMPDIR} overrides
|
|
\var{dir}, while on Windows the \envvar{TMP} is used. The specific
|
|
behavior of this function depends on the C library implementation;
|
|
some aspects are underspecified in system documentation.
|
|
\warning{Use of \function{tempnam()} is vulnerable to symlink attacks;
|
|
consider using \function{tmpfile()} instead.}
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{tmpnam}{}
|
|
Return a unique path name that is reasonable for creating a temporary
|
|
file. This will be an absolute path that names a potential directory
|
|
entry in a common location for temporary files. Applications are
|
|
responsible for properly creating and managing files created using
|
|
paths returned by \function{tmpnam()}; no automatic cleanup is
|
|
provided.
|
|
\warning{Use of \function{tmpnam()} is vulnerable to symlink attacks;
|
|
consider using \function{tmpfile()} instead.}
|
|
Availability: \UNIX, Windows. This function probably shouldn't be used
|
|
on Windows, though: Microsoft's implementation of \function{tmpnam()}
|
|
always creates a name in the root directory of the current drive, and
|
|
that's generally a poor location for a temp file (depending on
|
|
privileges, you may not even be able to open a file using this name).
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{TMP_MAX}
|
|
The maximum number of unique names that \function{tmpnam()} will
|
|
generate before reusing names.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{unlink}{path}
|
|
Remove the file \var{path}. This is the same function as
|
|
\function{remove()}; the \function{unlink()} name is its traditional
|
|
\UNIX{} name.
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{utime}{path, times}
|
|
Set the access and modified times of the file specified by \var{path}.
|
|
If \var{times} is \code{None}, then the file's access and modified
|
|
times are set to the current time. Otherwise, \var{times} must be a
|
|
2-tuple of numbers, of the form \code{(\var{atime}, \var{mtime})}
|
|
which is used to set the access and modified times, respectively.
|
|
Whether a directory can be given for \var{path} depends on whether the
|
|
operating system implements directories as files (for example, Windows
|
|
does not). Note that the exact times you set here may not be returned
|
|
by a subsequent \function{stat()} call, depending on the resolution
|
|
with which your operating system records access and modification times;
|
|
see \function{stat()}.
|
|
\versionchanged[Added support for \code{None} for \var{times}]{2.0}
|
|
Availability: Macintosh, \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{walk}{top\optional{, topdown\code{=True}
|
|
\optional{, onerror\code{=None}}}}
|
|
\index{directory!walking}
|
|
\index{directory!traversal}
|
|
\function{walk()} generates the file names in a directory tree, by
|
|
walking the tree either top down or bottom up.
|
|
For each directory in the tree rooted at directory \var{top} (including
|
|
\var{top} itself), it yields a 3-tuple
|
|
\code{(\var{dirpath}, \var{dirnames}, \var{filenames})}.
|
|
|
|
\var{dirpath} is a string, the path to the directory. \var{dirnames} is
|
|
a list of the names of the subdirectories in \var{dirpath}
|
|
(excluding \code{'.'} and \code{'..'}). \var{filenames} is a list of
|
|
the names of the non-directory files in \var{dirpath}. Note that the
|
|
names in the lists contain no path components. To get a full
|
|
path (which begins with \var{top}) to a file or directory in
|
|
\var{dirpath}, do \code{os.path.join(\var{dirpath}, \var{name})}.
|
|
|
|
If optional argument \var{topdown} is true or not specified, the triple
|
|
for a directory is generated before the triples for any of its
|
|
subdirectories (directories are generated top down). If \var{topdown} is
|
|
false, the triple for a directory is generated after the triples for all
|
|
of its subdirectories (directories are generated bottom up).
|
|
|
|
When \var{topdown} is true, the caller can modify the \var{dirnames} list
|
|
in-place (perhaps using \keyword{del} or slice assignment), and
|
|
\function{walk()} will only recurse into the subdirectories whose names
|
|
remain in \var{dirnames}; this can be used to prune the search,
|
|
impose a specific order of visiting, or even to inform \function{walk()}
|
|
about directories the caller creates or renames before it resumes
|
|
\function{walk()} again. Modifying \var{dirnames} when \var{topdown} is
|
|
false is ineffective, because in bottom-up mode the directories in
|
|
\var{dirnames} are generated before \var{dirnames} itself is generated.
|
|
|
|
By default errors from the \code{os.listdir()} call are ignored. If
|
|
optional argument \var{onerror} is specified, it should be a function;
|
|
it will be called with one argument, an os.error instance. It can
|
|
report the error to continue with the walk, or raise the exception
|
|
to abort the walk. Note that the filename is available as the
|
|
\code{filename} attribute of the exception object.
|
|
|
|
\begin{notice}
|
|
If you pass a relative pathname, don't change the current working
|
|
directory between resumptions of \function{walk()}. \function{walk()}
|
|
never changes the current directory, and assumes that its caller
|
|
doesn't either.
|
|
\end{notice}
|
|
|
|
\begin{notice}
|
|
On systems that support symbolic links, links to subdirectories appear
|
|
in \var{dirnames} lists, but \function{walk()} will not visit them
|
|
(infinite loops are hard to avoid when following symbolic links).
|
|
To visit linked directories, you can identify them with
|
|
\code{os.path.islink(\var{path})}, and invoke \code{walk(\var{path})}
|
|
on each directly.
|
|
\end{notice}
|
|
|
|
This example displays the number of bytes taken by non-directory files
|
|
in each directory under the starting directory, except that it doesn't
|
|
look under any CVS subdirectory:
|
|
|
|
\begin{verbatim}
|
|
import os
|
|
from os.path import join, getsize
|
|
for root, dirs, files in os.walk('python/Lib/email'):
|
|
print root, "consumes",
|
|
print sum(getsize(join(root, name)) for name in files),
|
|
print "bytes in", len(files), "non-directory files"
|
|
if 'CVS' in dirs:
|
|
dirs.remove('CVS') # don't visit CVS directories
|
|
\end{verbatim}
|
|
|
|
In the next example, walking the tree bottom up is essential:
|
|
\function{rmdir()} doesn't allow deleting a directory before the
|
|
directory is empty:
|
|
|
|
\begin{verbatim}
|
|
# Delete everything reachable from the directory named in 'top',
|
|
# assuming there are no symbolic links.
|
|
# CAUTION: This is dangerous! For example, if top == '/', it
|
|
# could delete all your disk files.
|
|
import os
|
|
for root, dirs, files in os.walk(top, topdown=False):
|
|
for name in files:
|
|
os.remove(os.path.join(root, name))
|
|
for name in dirs:
|
|
os.rmdir(os.path.join(root, name))
|
|
\end{verbatim}
|
|
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\subsection{Process Management \label{os-process}}
|
|
|
|
These functions may be used to create and manage processes.
|
|
|
|
The various \function{exec*()} functions take a list of arguments for
|
|
the new program loaded into the process. In each case, the first of
|
|
these arguments is passed to the new program as its own name rather
|
|
than as an argument a user may have typed on a command line. For the
|
|
C programmer, this is the \code{argv[0]} passed to a program's
|
|
\cfunction{main()}. For example, \samp{os.execv('/bin/echo', ['foo',
|
|
'bar'])} will only print \samp{bar} on standard output; \samp{foo}
|
|
will seem to be ignored.
|
|
|
|
|
|
\begin{funcdesc}{abort}{}
|
|
Generate a \constant{SIGABRT} signal to the current process. On
|
|
\UNIX, the default behavior is to produce a core dump; on Windows, the
|
|
process immediately returns an exit code of \code{3}. Be aware that
|
|
programs which use \function{signal.signal()} to register a handler
|
|
for \constant{SIGABRT} will behave differently.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{execl}{path, arg0, arg1, \moreargs}
|
|
\funcline{execle}{path, arg0, arg1, \moreargs, env}
|
|
\funcline{execlp}{file, arg0, arg1, \moreargs}
|
|
\funcline{execlpe}{file, arg0, arg1, \moreargs, env}
|
|
\funcline{execv}{path, args}
|
|
\funcline{execve}{path, args, env}
|
|
\funcline{execvp}{file, args}
|
|
\funcline{execvpe}{file, args, env}
|
|
These functions all execute a new program, replacing the current
|
|
process; they do not return. On \UNIX, the new executable is loaded
|
|
into the current process, and will have the same process ID as the
|
|
caller. Errors will be reported as \exception{OSError} exceptions.
|
|
|
|
The \character{l} and \character{v} variants of the
|
|
\function{exec*()} functions differ in how command-line arguments are
|
|
passed. The \character{l} variants are perhaps the easiest to work
|
|
with if the number of parameters is fixed when the code is written;
|
|
the individual parameters simply become additional parameters to the
|
|
\function{execl*()} functions. The \character{v} variants are good
|
|
when the number of parameters is variable, with the arguments being
|
|
passed in a list or tuple as the \var{args} parameter. In either
|
|
case, the arguments to the child process should start with the name of
|
|
the command being run, but this is not enforced.
|
|
|
|
The variants which include a \character{p} near the end
|
|
(\function{execlp()}, \function{execlpe()}, \function{execvp()},
|
|
and \function{execvpe()}) will use the \envvar{PATH} environment
|
|
variable to locate the program \var{file}. When the environment is
|
|
being replaced (using one of the \function{exec*e()} variants,
|
|
discussed in the next paragraph), the
|
|
new environment is used as the source of the \envvar{PATH} variable.
|
|
The other variants, \function{execl()}, \function{execle()},
|
|
\function{execv()}, and \function{execve()}, will not use the
|
|
\envvar{PATH} variable to locate the executable; \var{path} must
|
|
contain an appropriate absolute or relative path.
|
|
|
|
For \function{execle()}, \function{execlpe()}, \function{execve()},
|
|
and \function{execvpe()} (note that these all end in \character{e}),
|
|
the \var{env} parameter must be a mapping which is used to define the
|
|
environment variables for the new process; the \function{execl()},
|
|
\function{execlp()}, \function{execv()}, and \function{execvp()}
|
|
all cause the new process to inherit the environment of the current
|
|
process.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{_exit}{n}
|
|
Exit to the system with status \var{n}, without calling cleanup
|
|
handlers, flushing stdio buffers, etc.
|
|
Availability: \UNIX, Windows.
|
|
|
|
\begin{notice}
|
|
The standard way to exit is \code{sys.exit(\var{n})}.
|
|
\function{_exit()} should normally only be used in the child process
|
|
after a \function{fork()}.
|
|
\end{notice}
|
|
\end{funcdesc}
|
|
|
|
The following exit codes are a defined, and can be used with
|
|
\function{_exit()}, although they are not required. These are
|
|
typically used for system programs written in Python, such as a
|
|
mail server's external command delivery program.
|
|
|
|
\begin{datadesc}{EX_OK}
|
|
Exit code that means no error occurred.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_USAGE}
|
|
Exit code that means the command was used incorrectly, such as when
|
|
the wrong number of arguments are given.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_DATAERR}
|
|
Exit code that means the input data was incorrect.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_NOINPUT}
|
|
Exit code that means an input file did not exist or was not readable.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_NOUSER}
|
|
Exit code that means a specified user did not exist.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_NOHOST}
|
|
Exit code that means a specified host did not exist.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_UNAVAILABLE}
|
|
Exit code that means that a required service is unavailable.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_SOFTWARE}
|
|
Exit code that means an internal software error was detected.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_OSERR}
|
|
Exit code that means an operating system error was detected, such as
|
|
the inability to fork or create a pipe.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_OSFILE}
|
|
Exit code that means some system file did not exist, could not be
|
|
opened, or had some other kind of error.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_CANTCREAT}
|
|
Exit code that means a user specified output file could not be created.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_IOERR}
|
|
Exit code that means that an error occurred while doing I/O on some file.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_TEMPFAIL}
|
|
Exit code that means a temporary failure occurred. This indicates
|
|
something that may not really be an error, such as a network
|
|
connection that couldn't be made during a retryable operation.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_PROTOCOL}
|
|
Exit code that means that a protocol exchange was illegal, invalid, or
|
|
not understood.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_NOPERM}
|
|
Exit code that means that there were insufficient permissions to
|
|
perform the operation (but not intended for file system problems).
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_CONFIG}
|
|
Exit code that means that some kind of configuration error occurred.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{EX_NOTFOUND}
|
|
Exit code that means something like ``an entry was not found''.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{fork}{}
|
|
Fork a child process. Return \code{0} in the child, the child's
|
|
process id in the parent.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{forkpty}{}
|
|
Fork a child process, using a new pseudo-terminal as the child's
|
|
controlling terminal. Return a pair of \code{(\var{pid}, \var{fd})},
|
|
where \var{pid} is \code{0} in the child, the new child's process id
|
|
in the parent, and \var{fd} is the file descriptor of the master end
|
|
of the pseudo-terminal. For a more portable approach, use the
|
|
\refmodule{pty} module.
|
|
Availability: Some flavors of \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{kill}{pid, sig}
|
|
\index{process!killing}
|
|
\index{process!signalling}
|
|
Kill the process \var{pid} with signal \var{sig}. Constants for the
|
|
specific signals available on the host platform are defined in the
|
|
\refmodule{signal} module.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{killpg}{pgid, sig}
|
|
\index{process!killing}
|
|
\index{process!signalling}
|
|
Kill the process group \var{pgid} with the signal \var{sig}.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{nice}{increment}
|
|
Add \var{increment} to the process's ``niceness''. Return the new
|
|
niceness.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{plock}{op}
|
|
Lock program segments into memory. The value of \var{op}
|
|
(defined in \code{<sys/lock.h>}) determines which segments are locked.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdescni}{popen}{\unspecified}
|
|
\funclineni{popen2}{\unspecified}
|
|
\funclineni{popen3}{\unspecified}
|
|
\funclineni{popen4}{\unspecified}
|
|
Run child processes, returning opened pipes for communications. These
|
|
functions are described in section \ref{os-newstreams}.
|
|
\end{funcdescni}
|
|
|
|
\begin{funcdesc}{spawnl}{mode, path, \moreargs}
|
|
\funcline{spawnle}{mode, path, \moreargs, env}
|
|
\funcline{spawnlp}{mode, file, \moreargs}
|
|
\funcline{spawnlpe}{mode, file, \moreargs, env}
|
|
\funcline{spawnv}{mode, path, args}
|
|
\funcline{spawnve}{mode, path, args, env}
|
|
\funcline{spawnvp}{mode, file, args}
|
|
\funcline{spawnvpe}{mode, file, args, env}
|
|
Execute the program \var{path} in a new process. If \var{mode} is
|
|
\constant{P_NOWAIT}, this function returns the process ID of the new
|
|
process; if \var{mode} is \constant{P_WAIT}, returns the process's
|
|
exit code if it exits normally, or \code{-\var{signal}}, where
|
|
\var{signal} is the signal that killed the process. On Windows, the
|
|
process ID will actually be the process handle, so can be used with
|
|
the \function{waitpid()} function.
|
|
|
|
The \character{l} and \character{v} variants of the
|
|
\function{spawn*()} functions differ in how command-line arguments are
|
|
passed. The \character{l} variants are perhaps the easiest to work
|
|
with if the number of parameters is fixed when the code is written;
|
|
the individual parameters simply become additional parameters to the
|
|
\function{spawnl*()} functions. The \character{v} variants are good
|
|
when the number of parameters is variable, with the arguments being
|
|
passed in a list or tuple as the \var{args} parameter. In either
|
|
case, the arguments to the child process must start with the name of
|
|
the command being run.
|
|
|
|
The variants which include a second \character{p} near the end
|
|
(\function{spawnlp()}, \function{spawnlpe()}, \function{spawnvp()},
|
|
and \function{spawnvpe()}) will use the \envvar{PATH} environment
|
|
variable to locate the program \var{file}. When the environment is
|
|
being replaced (using one of the \function{spawn*e()} variants,
|
|
discussed in the next paragraph), the new environment is used as the
|
|
source of the \envvar{PATH} variable. The other variants,
|
|
\function{spawnl()}, \function{spawnle()}, \function{spawnv()}, and
|
|
\function{spawnve()}, will not use the \envvar{PATH} variable to
|
|
locate the executable; \var{path} must contain an appropriate absolute
|
|
or relative path.
|
|
|
|
For \function{spawnle()}, \function{spawnlpe()}, \function{spawnve()},
|
|
and \function{spawnvpe()} (note that these all end in \character{e}),
|
|
the \var{env} parameter must be a mapping which is used to define the
|
|
environment variables for the new process; the \function{spawnl()},
|
|
\function{spawnlp()}, \function{spawnv()}, and \function{spawnvp()}
|
|
all cause the new process to inherit the environment of the current
|
|
process.
|
|
|
|
As an example, the following calls to \function{spawnlp()} and
|
|
\function{spawnvpe()} are equivalent:
|
|
|
|
\begin{verbatim}
|
|
import os
|
|
os.spawnlp(os.P_WAIT, 'cp', 'cp', 'index.html', '/dev/null')
|
|
|
|
L = ['cp', 'index.html', '/dev/null']
|
|
os.spawnvpe(os.P_WAIT, 'cp', L, os.environ)
|
|
\end{verbatim}
|
|
|
|
Availability: \UNIX, Windows. \function{spawnlp()},
|
|
\function{spawnlpe()}, \function{spawnvp()} and \function{spawnvpe()}
|
|
are not available on Windows.
|
|
\versionadded{1.6}
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{P_NOWAIT}
|
|
\dataline{P_NOWAITO}
|
|
Possible values for the \var{mode} parameter to the \function{spawn*()}
|
|
family of functions. If either of these values is given, the
|
|
\function{spawn*()} functions will return as soon as the new process
|
|
has been created, with the process ID as the return value.
|
|
Availability: \UNIX, Windows.
|
|
\versionadded{1.6}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{P_WAIT}
|
|
Possible value for the \var{mode} parameter to the \function{spawn*()}
|
|
family of functions. If this is given as \var{mode}, the
|
|
\function{spawn*()} functions will not return until the new process
|
|
has run to completion and will return the exit code of the process the
|
|
run is successful, or \code{-\var{signal}} if a signal kills the
|
|
process.
|
|
Availability: \UNIX, Windows.
|
|
\versionadded{1.6}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{P_DETACH}
|
|
\dataline{P_OVERLAY}
|
|
Possible values for the \var{mode} parameter to the
|
|
\function{spawn*()} family of functions. These are less portable than
|
|
those listed above.
|
|
\constant{P_DETACH} is similar to \constant{P_NOWAIT}, but the new
|
|
process is detached from the console of the calling process.
|
|
If \constant{P_OVERLAY} is used, the current process will be replaced;
|
|
the \function{spawn*()} function will not return.
|
|
Availability: Windows.
|
|
\versionadded{1.6}
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{startfile}{path}
|
|
Start a file with its associated application. This acts like
|
|
double-clicking the file in Windows Explorer, or giving the file name
|
|
as an argument to the \program{start} command from the interactive
|
|
command shell: the file is opened with whatever application (if any)
|
|
its extension is associated.
|
|
|
|
\function{startfile()} returns as soon as the associated application
|
|
is launched. There is no option to wait for the application to close,
|
|
and no way to retrieve the application's exit status. The \var{path}
|
|
parameter is relative to the current directory. If you want to use an
|
|
absolute path, make sure the first character is not a slash
|
|
(\character{/}); the underlying Win32 \cfunction{ShellExecute()}
|
|
function doesn't work if it is. Use the \function{os.path.normpath()}
|
|
function to ensure that the path is properly encoded for Win32.
|
|
Availability: Windows.
|
|
\versionadded{2.0}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{system}{command}
|
|
Execute the command (a string) in a subshell. This is implemented by
|
|
calling the Standard C function \cfunction{system()}, and has the
|
|
same limitations. Changes to \code{posix.environ}, \code{sys.stdin},
|
|
etc.\ are not reflected in the environment of the executed command.
|
|
|
|
On \UNIX, the return value is the exit status of the process encoded in the
|
|
format specified for \function{wait()}. Note that \POSIX{} does not
|
|
specify the meaning of the return value of the C \cfunction{system()}
|
|
function, so the return value of the Python function is system-dependent.
|
|
|
|
On Windows, the return value is that returned by the system shell after
|
|
running \var{command}, given by the Windows environment variable
|
|
\envvar{COMSPEC}: on \program{command.com} systems (Windows 95, 98 and ME)
|
|
this is always \code{0}; on \program{cmd.exe} systems (Windows NT, 2000
|
|
and XP) this is the exit status of the command run; on systems using
|
|
a non-native shell, consult your shell documentation.
|
|
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{times}{}
|
|
Return a 5-tuple of floating point numbers indicating accumulated
|
|
(processor or other)
|
|
times, in seconds. The items are: user time, system time, children's
|
|
user time, children's system time, and elapsed real time since a fixed
|
|
point in the past, in that order. See the \UNIX{} manual page
|
|
\manpage{times}{2} or the corresponding Windows Platform API
|
|
documentation.
|
|
Availability: \UNIX, Windows.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{wait}{}
|
|
Wait for completion of a child process, and return a tuple containing
|
|
its pid and exit status indication: a 16-bit number, whose low byte is
|
|
the signal number that killed the process, and whose high byte is the
|
|
exit status (if the signal number is zero); the high bit of the low
|
|
byte is set if a core file was produced.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{waitpid}{pid, options}
|
|
The details of this function differ on \UNIX{} and Windows.
|
|
|
|
On \UNIX:
|
|
Wait for completion of a child process given by process id \var{pid},
|
|
and return a tuple containing its process id and exit status
|
|
indication (encoded as for \function{wait()}). The semantics of the
|
|
call are affected by the value of the integer \var{options}, which
|
|
should be \code{0} for normal operation.
|
|
|
|
If \var{pid} is greater than \code{0}, \function{waitpid()} requests
|
|
status information for that specific process. If \var{pid} is
|
|
\code{0}, the request is for the status of any child in the process
|
|
group of the current process. If \var{pid} is \code{-1}, the request
|
|
pertains to any child of the current process. If \var{pid} is less
|
|
than \code{-1}, status is requested for any process in the process
|
|
group \code{-\var{pid}} (the absolute value of \var{pid}).
|
|
|
|
On Windows:
|
|
Wait for completion of a process given by process handle \var{pid},
|
|
and return a tuple containing \var{pid},
|
|
and its exit status shifted left by 8 bits (shifting makes cross-platform
|
|
use of the function easier).
|
|
A \var{pid} less than or equal to \code{0} has no special meaning on
|
|
Windows, and raises an exception.
|
|
The value of integer \var{options} has no effect.
|
|
\var{pid} can refer to any process whose id is known, not necessarily a
|
|
child process.
|
|
The \function{spawn()} functions called with \constant{P_NOWAIT}
|
|
return suitable process handles.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{WNOHANG}
|
|
The option for \function{waitpid()} to avoid hanging if no child
|
|
process status is available immediately.
|
|
Availability: \UNIX.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{WCONTINUED}
|
|
This option causes child processes to be reported if they have been
|
|
continued from a job control stop since their status was last
|
|
reported.
|
|
Availability: Some \UNIX{} systems.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{WUNTRACED}
|
|
This option causes child processes to be reported if they have been
|
|
stopped but their current state has not been reported since they were
|
|
stopped.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{datadesc}
|
|
|
|
The following functions take a process status code as returned by
|
|
\function{system()}, \function{wait()}, or \function{waitpid()} as a
|
|
parameter. They may be used to determine the disposition of a
|
|
process.
|
|
|
|
\begin{funcdesc}{WCOREDUMP}{status}
|
|
Returns \code{True} if a core dump was generated for the process,
|
|
otherwise it returns \code{False}.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WIFCONTINUED}{status}
|
|
Returns \code{True} if the process has been continued from a job
|
|
control stop, otherwise it returns \code{False}.
|
|
Availability: \UNIX.
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WIFSTOPPED}{status}
|
|
Returns \code{True} if the process has been stopped, otherwise it
|
|
returns \code{False}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WIFSIGNALED}{status}
|
|
Returns \code{True} if the process exited due to a signal, otherwise
|
|
it returns \code{False}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WIFEXITED}{status}
|
|
Returns \code{True} if the process exited using the \manpage{exit}{2}
|
|
system call, otherwise it returns \code{False}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WEXITSTATUS}{status}
|
|
If \code{WIFEXITED(\var{status})} is true, return the integer
|
|
parameter to the \manpage{exit}{2} system call. Otherwise, the return
|
|
value is meaningless.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WSTOPSIG}{status}
|
|
Return the signal which caused the process to stop.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{WTERMSIG}{status}
|
|
Return the signal which caused the process to exit.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
|
|
\subsection{Miscellaneous System Information \label{os-path}}
|
|
|
|
|
|
\begin{funcdesc}{confstr}{name}
|
|
Return string-valued system configuration values.
|
|
\var{name} specifies the configuration value to retrieve; it may be a
|
|
string which is the name of a defined system value; these names are
|
|
specified in a number of standards (\POSIX, \UNIX{} 95, \UNIX{} 98, and
|
|
others). Some platforms define additional names as well. The names
|
|
known to the host operating system are given in the
|
|
\code{confstr_names} dictionary. For configuration variables not
|
|
included in that mapping, passing an integer for \var{name} is also
|
|
accepted.
|
|
Availability: \UNIX.
|
|
|
|
If the configuration value specified by \var{name} isn't defined, the
|
|
empty string is returned.
|
|
|
|
If \var{name} is a string and is not known, \exception{ValueError} is
|
|
raised. If a specific value for \var{name} is not supported by the
|
|
host system, even if it is included in \code{confstr_names}, an
|
|
\exception{OSError} is raised with \constant{errno.EINVAL} for the
|
|
error number.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{confstr_names}
|
|
Dictionary mapping names accepted by \function{confstr()} to the
|
|
integer values defined for those names by the host operating system.
|
|
This can be used to determine the set of names known to the system.
|
|
Availability: \UNIX.
|
|
\end{datadesc}
|
|
|
|
\begin{funcdesc}{getloadavg}{}
|
|
Return the number of processes in the system run queue averaged over
|
|
the last 1, 5, and 15 minutes or raises OSError if the load average
|
|
was unobtainable.
|
|
|
|
\versionadded{2.3}
|
|
\end{funcdesc}
|
|
|
|
\begin{funcdesc}{sysconf}{name}
|
|
Return integer-valued system configuration values.
|
|
If the configuration value specified by \var{name} isn't defined,
|
|
\code{-1} is returned. The comments regarding the \var{name}
|
|
parameter for \function{confstr()} apply here as well; the dictionary
|
|
that provides information on the known names is given by
|
|
\code{sysconf_names}.
|
|
Availability: \UNIX.
|
|
\end{funcdesc}
|
|
|
|
\begin{datadesc}{sysconf_names}
|
|
Dictionary mapping names accepted by \function{sysconf()} to the
|
|
integer values defined for those names by the host operating system.
|
|
This can be used to determine the set of names known to the system.
|
|
Availability: \UNIX.
|
|
\end{datadesc}
|
|
|
|
|
|
The follow data values are used to support path manipulation
|
|
operations. These are defined for all platforms.
|
|
|
|
Higher-level operations on pathnames are defined in the
|
|
\refmodule{os.path} module.
|
|
|
|
|
|
\begin{datadesc}{curdir}
|
|
The constant string used by the operating system to refer to the current
|
|
directory.
|
|
For example: \code{'.'} for \POSIX{} or \code{':'} for the Macintosh.
|
|
Also available via \module{os.path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{pardir}
|
|
The constant string used by the operating system to refer to the parent
|
|
directory.
|
|
For example: \code{'..'} for \POSIX{} or \code{'::'} for the Macintosh.
|
|
Also available via \module{os.path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{sep}
|
|
The character used by the operating system to separate pathname components,
|
|
for example, \character{/} for \POSIX{} or \character{:} for the
|
|
Macintosh. Note that knowing this is not sufficient to be able to
|
|
parse or concatenate pathnames --- use \function{os.path.split()} and
|
|
\function{os.path.join()} --- but it is occasionally useful.
|
|
Also available via \module{os.path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{altsep}
|
|
An alternative character used by the operating system to separate pathname
|
|
components, or \code{None} if only one separator character exists. This is
|
|
set to \character{/} on Windows systems where \code{sep} is a
|
|
backslash.
|
|
Also available via \module{os.path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{extsep}
|
|
The character which separates the base filename from the extension;
|
|
for example, the \character{.} in \file{os.py}.
|
|
Also available via \module{os.path}.
|
|
\versionadded{2.2}
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{pathsep}
|
|
The character conventionally used by the operating system to separate
|
|
search path components (as in \envvar{PATH}), such as \character{:} for
|
|
\POSIX{} or \character{;} for Windows.
|
|
Also available via \module{os.path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{defpath}
|
|
The default search path used by \function{exec*p*()} and
|
|
\function{spawn*p*()} if the environment doesn't have a \code{'PATH'}
|
|
key.
|
|
Also available via \module{os.path}.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{linesep}
|
|
The string used to separate (or, rather, terminate) lines on the
|
|
current platform. This may be a single character, such as \code{'\e
|
|
n'} for \POSIX{} or \code{'\e r'} for Mac OS, or multiple characters,
|
|
for example, \code{'\e r\e n'} for Windows.
|
|
\end{datadesc}
|
|
|
|
\begin{datadesc}{devnull}
|
|
The file path of the null device.
|
|
For example: \code{'/dev/null'} for \POSIX{} or \code{'Dev:Nul'} for the
|
|
Macintosh.
|
|
Also available via \module{os.path}.
|
|
\versionadded{2.4}
|
|
\end{datadesc}
|
|
|
|
|
|
\subsection{Miscellaneous Functions \label{os-miscfunc}}
|
|
|
|
\begin{funcdesc}{urandom}{n}
|
|
Return a string of \var{n} random bytes suitable for cryptographic use.
|
|
|
|
This function returns random bytes from an OS-specific
|
|
randomness source. The returned data should be unpredictable enough for
|
|
cryptographic applications, though its exact quality depends on the OS
|
|
implementation. On a UNIX-like system this will query /dev/urandom, and
|
|
on Windows it will use CryptGenRandom. If a randomness source is not
|
|
found, \exception{NotImplementedError} will be raised.
|
|
\versionadded{2.4}
|
|
\end{funcdesc}
|
|
|
|
|
|
|
|
|