.. c:function:: int PyErr_CheckSignals()
.. index::
- module: signal
+ pair: module; signal
single: SIGINT
single: KeyboardInterrupt (built-in exception)
.. c:function:: void PyErr_SetInterrupt()
.. index::
- module: signal
+ pair: module; signal
single: SIGINT
single: KeyboardInterrupt (built-in exception)
.. c:function:: int PyErr_SetInterruptEx(int signum)
.. index::
- module: signal
+ pair: module; signal
single: KeyboardInterrupt (built-in exception)
Simulate the effect of a signal arriving. The next time
single: PyEval_InitThreads()
single: modules (in module sys)
single: path (in module sys)
- module: builtins
- module: __main__
- module: sys
+ pair: module; builtins
+ pair: module; __main__
+ pair: module; sys
triple: module; search; path
single: PySys_SetArgv()
single: PySys_SetArgvEx()
.. deprecated:: 3.9
- .. index:: module: _thread
+ .. index:: pair: module; _thread
.. c:function:: int PyEval_ThreadsInitialized()
.. c:function:: PyThreadState* Py_NewInterpreter()
.. index::
- module: builtins
- module: __main__
- module: sys
+ pair: module; builtins
+ pair: module; __main__
+ pair: module; sys
single: stdout (in module sys)
single: stderr (in module sys)
single: stdin (in module sys)
.. index::
single: Py_Initialize()
- module: builtins
- module: __main__
- module: sys
+ pair: module; builtins
+ pair: module; __main__
+ pair: module; sys
triple: module; search; path
single: path (in module sys)
**Caveats:**
- .. index:: module: signal
+ .. index:: pair: module; signal
* Threads interact strangely with interrupts: the :exc:`KeyboardInterrupt`
exception will be received by an arbitrary thread. (When the :mod:`signal`
representations.
.. index::
- module: uu
- module: base64
+ pair: module; uu
+ pair: module; base64
--------------
.. versionadded:: 3.6
-.. index:: module: math
+.. index:: pair: module; math
Note that the selection of functions is similar, but not identical, to that in
module :mod:`math`. The reason for having two modules is that some users aren't
of lists by assigning a slice of the entire list, for example,
``copied_list = original_list[:]``.
-.. index:: module: pickle
+.. index:: pair: module; pickle
Classes can use the same interfaces to control copying that they use to control
pickling. See the description of module :mod:`pickle` for information on these
**Source code:** :source:`Lib/copyreg.py`
.. index::
- module: pickle
- module: copy
+ pair: module; pickle
+ pair: module; copy
--------------
.. exception:: OSError([arg])
OSError(errno, strerror[, filename[, winerror[, filename2]]])
- .. index:: module: errno
+ .. index:: pair: module; errno
This exception is raised when a system function returns a system-related
error, including I/O failures such as "file not found" or "disk full"
.. index:: single: filenames; wildcard expansion
-.. index:: module: re
+.. index:: pair: module; re
--------------
For a literal match, wrap the meta-characters in brackets.
For example, ``'[?]'`` matches the character ``'?'``.
-.. index:: module: glob
+.. index:: pair: module; glob
Note that the filename separator (``'/'`` on Unix) is *not* special to this
module. See module :mod:`glob` for pathname expansion (:mod:`glob` uses
single: I/O control; buffering
single: binary mode
single: text mode
- module: sys
+ pair: module; sys
See also the file handling modules, such as :mod:`fileinput`, :mod:`io`
(where :func:`open` is declared), :mod:`os`, :mod:`os.path`, :mod:`tempfile`,
.. index::
statement: import
- module: builtins
+ pair: module; builtins
.. note::
pair: HTTP; protocol
single: HTTP; http.client (standard module)
-.. index:: module: urllib.request
+.. index:: pair: module; urllib.request
--------------
single: Internet
single: World Wide Web
-.. index:: module: socket
+.. index:: pair: module; socket
The modules described in this chapter implement internet protocols and support
for related technology. They are all implemented in Python. Most of these
certain cultural issues in an application, without requiring the programmer to
know all the specifics of each country where the software is executed.
-.. index:: module: _locale
+.. index:: pair: module; _locale
The :mod:`locale` module is implemented on top of the :mod:`_locale` module,
which in turn uses an ANSI C locale implementation if available.
.. data:: LC_CTYPE
- .. index:: module: string
+ .. index:: pair: module; string
Locale category for the character type functions. Depending on the settings of
this category, the functions of module :mod:`string` dealing with case change
rarely does). [#]_
.. index::
- module: pickle
- module: shelve
+ pair: module; pickle
+ pair: module; shelve
This is not a general "persistence" module. For general persistence and
transfer of Python objects through RPC calls, see the modules :mod:`pickle` and
On Unix and Windows, return the argument with an initial component of ``~`` or
``~user`` replaced by that *user*'s home directory.
- .. index:: module: pwd
+ .. index:: pair: module; pwd
On Unix, an initial ``~`` is replaced by the environment variable :envvar:`HOME`
if it is set; otherwise the current user's home directory is looked up in the
.. function:: openpty()
- .. index:: module: pty
+ .. index:: pair: module; pty
Open a new pseudo-terminal pair. Return a pair of file descriptors
``(master, slave)`` for the pty and the tty, respectively. The new file
possible and call :func:`lstat` on the result. This does not apply to
dangling symlinks or junction points, which will raise the usual exceptions.
- .. index:: module: stat
+ .. index:: pair: module; stat
Example::
.. index::
single: Pdb (class in pdb)
- module: bdb
- module: cmd
+ pair: module; bdb
+ pair: module; cmd
The debugger is extensible -- it is actually defined as the class :class:`Pdb`.
This is currently undocumented but easily understood by reading the source. The
standardized by the C Standard and the POSIX standard (a thinly disguised Unix
interface).
-.. index:: module: os
+.. index:: pair: module; os
**Do not import this module directly.** Instead, import the module :mod:`os`,
which provides a *portable* version of this interface. On Unix, the :mod:`os`
.. note::
- .. index:: module: crypt
+ .. index:: pair: module; crypt
In traditional Unix the field ``pw_passwd`` usually contains a password
encrypted with a DES derived algorithm (see module :mod:`crypt`). However most
parser, the handler functions are called for the character data and markup in
the XML document.
-.. index:: module: pyexpat
+.. index:: pair: module; pyexpat
This module uses the :mod:`pyexpat` module to provide access to the Expat
parser. Direct use of the :mod:`pyexpat` module is deprecated.
.. function:: run_module(mod_name, init_globals=None, run_name=None, alter_sys=False)
.. index::
- module: __main__
+ pair: module; __main__
Execute the code of the specified module and return the resulting module
globals dictionary. The module's code is first located using the standard
.. function:: run_path(path_name, init_globals=None, run_name=None)
.. index::
- module: __main__
+ pair: module; __main__
Execute the code at the named filesystem location and return the resulting
module globals dictionary. As with a script name supplied to the CPython
**Source code:** :source:`Lib/shelve.py`
-.. index:: module: pickle
+.. index:: pair: module; pickle
--------------
------------
.. index::
- module: dbm.ndbm
- module: dbm.gnu
+ pair: module; dbm.ndbm
+ pair: module; dbm.gnu
* The choice of which database package will be used (such as :mod:`dbm.ndbm` or
:mod:`dbm.gnu`) depends on which interface is available. Therefore it is not
alphabetically before :file:`foo.pth`; and :file:`spam` is omitted because it is
not mentioned in either path configuration file.
-.. index:: module: sitecustomize
+.. index:: pair: module; sitecustomize
After these path manipulations, an attempt is made to import a module named
:mod:`sitecustomize`, which can perform arbitrary site-specific customizations.
attempted output from :mod:`sitecustomize` is ignored. Any other exception
causes a silent and perhaps mysterious failure of the process.
-.. index:: module: usercustomize
+.. index:: pair: module; usercustomize
After this, an attempt is made to import a module named :mod:`usercustomize`,
which can perform arbitrary user-specific customizations, if
.. method:: socket.setsockopt(level, optname, None, optlen: int)
:noindex:
- .. index:: module: struct
+ .. index:: pair: module; struct
Set the value of the given socket option (see the Unix manual page
:manpage:`setsockopt(2)`). The needed symbolic constants are defined in the
(3)
.. index::
- module: math
+ pair: module; math
single: floor() (in module math)
single: ceil() (in module math)
single: trunc() (in module math)
--------------
.. index::
- module: re
+ pair: module; re
Strings implement all of the :ref:`common <typesseq-common>` sequence
operations, along with the additional methods described below.
object: bytes
object: bytearray
object: memoryview
- module: array
+ pair: module; array
The core built-in types for manipulating binary data are :class:`bytes` and
:class:`bytearray`. They are supported by :class:`memoryview` which uses
.. index::
builtin: type
- module: types
+ pair: module; types
Type objects represent the various object types. An object's type is accessed
by the built-in function :func:`type`. There are no special operations on
keeping all locals in that frame alive until the next garbage collection occurs.
.. index::
- module: sys
+ pair: module; sys
object: traceback
Before an :keyword:`!except` clause's suite is executed,
(and hence unhashable), byte arrays otherwise provide the same interface
and functionality as immutable :class:`bytes` objects.
- .. index:: module: array
+ .. index:: pair: module; array
The extension module :mod:`array` provides an additional example of a
mutable sequence type, as does the :mod:`collections` module.
section :ref:`dict`).
.. index::
- module: dbm.ndbm
- module: dbm.gnu
+ pair: module; dbm.ndbm
+ pair: module; dbm.gnu
The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide
additional examples of mapping types, as does the :mod:`collections`
I/O objects (also known as file objects)
.. index::
builtin: open
- module: io
+ pair: module; io
single: popen() (in module os)
single: makefile() (socket method)
single: sys.stdin
:exc:`SyntaxError` is raised at compile time if the given name does not
exist in any enclosing function scope.
-.. index:: module: __main__
+.. index:: pair: module; __main__
The namespace for a module is automatically created the first time a module is
imported. The main module for a script is always called :mod:`__main__`.
.. index:: single: program
.. index::
- module: sys
- module: __main__
- module: builtins
+ pair: module; sys
+ pair: module; __main__
+ pair: module; builtins
While a language specification need not prescribe how the language interpreter
is invoked, it is useful to have a notion of a complete Python program. A
.. index::
single: interactive mode
- module: __main__
+ pair: module; __main__
The interpreter may also be invoked in interactive mode; in this case, it does
not read and execute a complete program but reads and executes one statement
# away from this, we need Sphinx to believe that these values don't
# exist, by deleting them when using the gettext builder.
- # pairindextypes.pop('module', None)
+ pairindextypes.pop('module', None)
# pairindextypes.pop('keyword', None)
# pairindextypes.pop('operator', None)
# pairindextypes.pop('object', None)
# pairindextypes.pop('statement', None)
# pairindextypes.pop('builtin', None)
- # there needs to be at least one statement in this block, will be
- # removed when the first of the below is uncommented.
- pass
-
def setup(app):
app.add_role('issue', issue_role)
Saving structured data with :mod:`json`
---------------------------------------
-.. index:: module: json
+.. index:: pair: module; json
Strings can easily be written to and read from a file. Numbers take a bit more
effort, since the :meth:`read` method only returns strings, which will have to
Standard Modules
================
-.. index:: module: sys
+.. index:: pair: module; sys
Python comes with a library of standard modules, described in a separate
document, the Python Library Reference ("Library Reference" hereafter). Some
Note that it lists all types of names: variables, modules, functions, etc.
-.. index:: module: builtins
+.. index:: pair: module; builtins
:func:`dir` does not list the names of built-in functions and variables. If you
want a list of those, they are defined in the standard module