Fred Drake | 295da24 | 1998-08-10 19:42:37 +0000 | [diff] [blame] | 1 | \section{\module{sys} --- |
Fred Drake | ffbe687 | 1999-04-22 21:23:22 +0000 | [diff] [blame] | 2 | System-specific parameters and functions} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 3 | |
Fred Drake | ffbe687 | 1999-04-22 21:23:22 +0000 | [diff] [blame] | 4 | \declaremodule{builtin}{sys} |
Fred Drake | 295da24 | 1998-08-10 19:42:37 +0000 | [diff] [blame] | 5 | \modulesynopsis{Access system-specific parameters and functions.} |
Fred Drake | b91e934 | 1998-07-23 17:59:49 +0000 | [diff] [blame] | 6 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 7 | This module provides access to some variables used or maintained by the |
| 8 | interpreter and to functions that interact strongly with the interpreter. |
| 9 | It is always available. |
| 10 | |
Guido van Rossum | 470be14 | 1995-03-17 16:07:09 +0000 | [diff] [blame] | 11 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 12 | \begin{datadesc}{argv} |
| 13 | The list of command line arguments passed to a Python script. |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 14 | \code{argv[0]} is the script name (it is operating system dependent |
| 15 | whether this is a full pathname or not). If the command was |
| 16 | executed using the \programopt{-c} command line option to the |
| 17 | interpreter, \code{argv[0]} is set to the string \code{'-c'}. If no |
| 18 | script name was passed to the Python interpreter, \code{argv} has |
| 19 | zero length. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 20 | \end{datadesc} |
| 21 | |
Fred Drake | a2b6ad6 | 2000-08-15 04:24:43 +0000 | [diff] [blame] | 22 | \begin{datadesc}{byteorder} |
Fred Drake | 68e2915 | 2000-08-14 15:47:30 +0000 | [diff] [blame] | 23 | An indicator of the native byte order. This will have the value |
| 24 | \code{'big'} on big-endian (most-signigicant byte first) platforms, |
| 25 | and \code{'little'} on little-endian (least-significant byte first) |
| 26 | platforms. |
| 27 | \versionadded{2.0} |
| 28 | \end{datadesc} |
| 29 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 30 | \begin{datadesc}{builtin_module_names} |
Guido van Rossum | 0d2971b | 1997-01-06 23:01:02 +0000 | [diff] [blame] | 31 | A tuple of strings giving the names of all modules that are compiled |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 32 | into this Python interpreter. (This information is not available in |
Fred Drake | 0fd72ee | 1998-03-08 05:43:51 +0000 | [diff] [blame] | 33 | any other way --- \code{modules.keys()} only lists the imported |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 34 | modules.) |
| 35 | \end{datadesc} |
| 36 | |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 37 | \begin{datadesc}{copyright} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 38 | A string containing the copyright pertaining to the Python |
| 39 | interpreter. |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 40 | \end{datadesc} |
| 41 | |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 42 | \begin{datadesc}{dllhandle} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 43 | Integer specifying the handle of the Python DLL. |
| 44 | Availability: Windows. |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 45 | \end{datadesc} |
| 46 | |
Moshe Zadka | f68f2fe | 2001-01-11 05:41:27 +0000 | [diff] [blame] | 47 | \begin{funcdesc}{displayhook}{\var{value}} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 48 | If \var{value} is not \code{None}, this function prints it to |
| 49 | \code{sys.stdout}, and saves it in \code{__builtin__._}. |
Moshe Zadka | f68f2fe | 2001-01-11 05:41:27 +0000 | [diff] [blame] | 50 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 51 | \code{sys.displayhook} is called on the result of evaluating an |
| 52 | expression entered in an interactive Python session. The display of |
| 53 | these values can be customized by assigning another one-argument |
| 54 | function to \code{sys.displayhook}. |
Moshe Zadka | f68f2fe | 2001-01-11 05:41:27 +0000 | [diff] [blame] | 55 | \end{funcdesc} |
| 56 | |
Ka-Ping Yee | b5c5132 | 2001-03-23 02:46:52 +0000 | [diff] [blame] | 57 | \begin{funcdesc}{excepthook}{\var{type}, \var{value}, \var{traceback}} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 58 | This function prints out a given traceback and exception to |
| 59 | \code{sys.stderr}. |
Ka-Ping Yee | b5c5132 | 2001-03-23 02:46:52 +0000 | [diff] [blame] | 60 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 61 | When an exception is raised and uncaught, the interpreter calls |
| 62 | \code{sys.excepthook} with three arguments, the exception class, |
| 63 | exception instance, and a traceback object. In an interactive |
| 64 | session this happens just before control is returned to the prompt; |
| 65 | in a Python program this happens just before the program exits. The |
| 66 | handling of such top-level exceptions can be customized by assigning |
| 67 | another three-argument function to \code{sys.excepthook}. |
Ka-Ping Yee | b5c5132 | 2001-03-23 02:46:52 +0000 | [diff] [blame] | 68 | \end{funcdesc} |
| 69 | |
| 70 | \begin{datadesc}{__displayhook__} |
| 71 | \dataline{__excepthook__} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 72 | These objects contain the original values of \code{displayhook} and |
| 73 | \code{excepthook} at the start of the program. They are saved so |
| 74 | that \code{displayhook} and \code{excepthook} can be restored in |
| 75 | case they happen to get replaced with broken objects. |
Ka-Ping Yee | b5c5132 | 2001-03-23 02:46:52 +0000 | [diff] [blame] | 76 | \end{datadesc} |
| 77 | |
Guido van Rossum | 871cf16 | 1997-10-20 22:38:43 +0000 | [diff] [blame] | 78 | \begin{funcdesc}{exc_info}{} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 79 | This function returns a tuple of three values that give information |
| 80 | about the exception that is currently being handled. The |
| 81 | information returned is specific both to the current thread and to |
| 82 | the current stack frame. If the current stack frame is not handling |
| 83 | an exception, the information is taken from the calling stack frame, |
| 84 | or its caller, and so on until a stack frame is found that is |
| 85 | handling an exception. Here, ``handling an exception'' is defined |
| 86 | as ``executing or having executed an except clause.'' For any stack |
| 87 | frame, only information about the most recently handled exception is |
| 88 | accessible. |
Guido van Rossum | 871cf16 | 1997-10-20 22:38:43 +0000 | [diff] [blame] | 89 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 90 | If no exception is being handled anywhere on the stack, a tuple |
| 91 | containing three \code{None} values is returned. Otherwise, the |
| 92 | values returned are \code{(\var{type}, \var{value}, |
| 93 | \var{traceback})}. Their meaning is: \var{type} gets the exception |
Neal Norwitz | 847207a | 2003-05-29 02:17:23 +0000 | [diff] [blame] | 94 | type of the exception being handled (a class object); |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 95 | \var{value} gets the exception parameter (its \dfn{associated value} |
| 96 | or the second argument to \keyword{raise}, which is always a class |
| 97 | instance if the exception type is a class object); \var{traceback} |
| 98 | gets a traceback object (see the Reference Manual) which |
| 99 | encapsulates the call stack at the point where the exception |
| 100 | originally occurred. \obindex{traceback} |
Guido van Rossum | 871cf16 | 1997-10-20 22:38:43 +0000 | [diff] [blame] | 101 | |
Guido van Rossum | 46d3dc3 | 2003-03-01 03:20:41 +0000 | [diff] [blame] | 102 | If \function{exc_clear()} is called, this function will return three |
| 103 | \code{None} values until either another exception is raised in the |
| 104 | current thread or the execution stack returns to a frame where |
| 105 | another exception is being handled. |
| 106 | |
Fred Drake | 0aa811c | 2001-10-20 04:24:09 +0000 | [diff] [blame] | 107 | \warning{Assigning the \var{traceback} return value to a |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 108 | local variable in a function that is handling an exception will |
| 109 | cause a circular reference. This will prevent anything referenced |
| 110 | by a local variable in the same function or by the traceback from |
| 111 | being garbage collected. Since most functions don't need access to |
| 112 | the traceback, the best solution is to use something like |
Fred Drake | 7731ed4 | 2002-01-05 04:00:03 +0000 | [diff] [blame] | 113 | \code{exctype, value = sys.exc_info()[:2]} to extract only the |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 114 | exception type and value. If you do need the traceback, make sure |
| 115 | to delete it after use (best done with a \keyword{try} |
| 116 | ... \keyword{finally} statement) or to call \function{exc_info()} in |
Tim Peters | 98791af | 2001-10-23 01:59:54 +0000 | [diff] [blame] | 117 | a function that does not itself handle an exception.} \note{Beginning |
| 118 | with Python 2.2, such cycles are automatically reclaimed when garbage |
| 119 | collection is enabled and they become unreachable, but it remains more |
| 120 | efficient to avoid creating cycles.} |
Guido van Rossum | 871cf16 | 1997-10-20 22:38:43 +0000 | [diff] [blame] | 121 | \end{funcdesc} |
| 122 | |
Guido van Rossum | 46d3dc3 | 2003-03-01 03:20:41 +0000 | [diff] [blame] | 123 | \begin{funcdesc}{exc_clear}{} |
| 124 | This function clears all information relating to the current or last |
| 125 | exception that occured in the current thread. After calling this |
| 126 | function, \function{exc_info()} will return three \code{None} values until |
| 127 | another exception is raised in the current thread or the execution stack |
| 128 | returns to a frame where another exception is being handled. |
| 129 | |
| 130 | This function is only needed in only a few obscure situations. These |
| 131 | include logging and error handling systems that report information on the |
| 132 | last or current exception. This function can also be used to try to free |
| 133 | resources and trigger object finalization, though no guarantee is made as |
| 134 | to what objects will be freed, if any. |
| 135 | \versionadded{2.3} |
| 136 | \end{funcdesc} |
| 137 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 138 | \begin{datadesc}{exc_type} |
| 139 | \dataline{exc_value} |
| 140 | \dataline{exc_traceback} |
Fred Drake | 0fd72ee | 1998-03-08 05:43:51 +0000 | [diff] [blame] | 141 | \deprecated {1.5} |
| 142 | {Use \function{exc_info()} instead.} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 143 | Since they are global variables, they are not specific to the |
| 144 | current thread, so their use is not safe in a multi-threaded |
| 145 | program. When no exception is being handled, \code{exc_type} is set |
| 146 | to \code{None} and the other two are undefined. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 147 | \end{datadesc} |
| 148 | |
Guido van Rossum | 0a3c753 | 1997-06-02 17:32:41 +0000 | [diff] [blame] | 149 | \begin{datadesc}{exec_prefix} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 150 | A string giving the site-specific directory prefix where the |
| 151 | platform-dependent Python files are installed; by default, this is |
| 152 | also \code{'/usr/local'}. This can be set at build time with the |
| 153 | \longprogramopt{exec-prefix} argument to the \program{configure} |
| 154 | script. Specifically, all configuration files (e.g. the |
Martin v. Löwis | 4f1cd8b | 2001-07-26 13:41:06 +0000 | [diff] [blame] | 155 | \file{pyconfig.h} header file) are installed in the directory |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 156 | \code{exec_prefix + '/lib/python\var{version}/config'}, and shared |
| 157 | library modules are installed in \code{exec_prefix + |
| 158 | '/lib/python\var{version}/lib-dynload'}, where \var{version} is |
| 159 | equal to \code{version[:3]}. |
Guido van Rossum | 0a3c753 | 1997-06-02 17:32:41 +0000 | [diff] [blame] | 160 | \end{datadesc} |
| 161 | |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 162 | \begin{datadesc}{executable} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 163 | A string giving the name of the executable binary for the Python |
| 164 | interpreter, on systems where this makes sense. |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 165 | \end{datadesc} |
| 166 | |
Guido van Rossum | 04307ce | 1998-11-23 17:49:53 +0000 | [diff] [blame] | 167 | \begin{funcdesc}{exit}{\optional{arg}} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 168 | Exit from Python. This is implemented by raising the |
| 169 | \exception{SystemExit} exception, so cleanup actions specified by |
| 170 | finally clauses of \keyword{try} statements are honored, and it is |
| 171 | possible to intercept the exit attempt at an outer level. The |
| 172 | optional argument \var{arg} can be an integer giving the exit status |
| 173 | (defaulting to zero), or another type of object. If it is an |
| 174 | integer, zero is considered ``successful termination'' and any |
| 175 | nonzero value is considered ``abnormal termination'' by shells and |
| 176 | the like. Most systems require it to be in the range 0-127, and |
| 177 | produce undefined results otherwise. Some systems have a convention |
| 178 | for assigning specific meanings to specific exit codes, but these |
Fred Drake | c37b65e | 2001-11-28 07:26:15 +0000 | [diff] [blame] | 179 | are generally underdeveloped; \UNIX{} programs generally use 2 for |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 180 | command line syntax errors and 1 for all other kind of errors. If |
| 181 | another type of object is passed, \code{None} is equivalent to |
| 182 | passing zero, and any other object is printed to \code{sys.stderr} |
| 183 | and results in an exit code of 1. In particular, |
| 184 | \code{sys.exit("some error message")} is a quick way to exit a |
| 185 | program when an error occurs. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 186 | \end{funcdesc} |
| 187 | |
| 188 | \begin{datadesc}{exitfunc} |
| 189 | This value is not actually defined by the module, but can be set by |
| 190 | the user (or by a program) to specify a clean-up action at program |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 191 | exit. When set, it should be a parameterless function. This |
| 192 | function will be called when the interpreter exits. Only one |
| 193 | function may be installed in this way; to allow multiple functions |
| 194 | which will be called at termination, use the \refmodule{atexit} |
Fred Drake | 0aa811c | 2001-10-20 04:24:09 +0000 | [diff] [blame] | 195 | module. \note{The exit function is not called when the program is |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 196 | killed by a signal, when a Python fatal internal error is detected, |
Fred Drake | 0aa811c | 2001-10-20 04:24:09 +0000 | [diff] [blame] | 197 | or when \code{os._exit()} is called.} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 198 | \end{datadesc} |
| 199 | |
Tim Peters | e5e065b | 2003-07-06 18:36:54 +0000 | [diff] [blame] | 200 | \begin{funcdesc}{getcheckinterval}{} |
| 201 | Return the interpreter's ``check interval''; |
| 202 | see \function{setcheckinterval()}. |
Neal Norwitz | 7cb229d | 2003-07-07 14:11:53 +0000 | [diff] [blame] | 203 | \versionadded{2.3} |
Tim Peters | e5e065b | 2003-07-06 18:36:54 +0000 | [diff] [blame] | 204 | \end{funcdesc} |
| 205 | |
Fred Drake | 8940faf | 2000-10-25 21:02:55 +0000 | [diff] [blame] | 206 | \begin{funcdesc}{getdefaultencoding}{} |
| 207 | Return the name of the current default string encoding used by the |
| 208 | Unicode implementation. |
| 209 | \versionadded{2.0} |
| 210 | \end{funcdesc} |
| 211 | |
Martin v. Löwis | f0473d5 | 2001-07-18 16:17:16 +0000 | [diff] [blame] | 212 | \begin{funcdesc}{getdlopenflags}{} |
Fred Drake | 5d808fb | 2001-07-18 16:35:05 +0000 | [diff] [blame] | 213 | Return the current value of the flags that are used for |
| 214 | \cfunction{dlopen()} calls. The flag constants are defined in the |
| 215 | \refmodule{dl} and \module{DLFCN} modules. |
| 216 | Availability: \UNIX. |
| 217 | \versionadded{2.2} |
Martin v. Löwis | f0473d5 | 2001-07-18 16:17:16 +0000 | [diff] [blame] | 218 | \end{funcdesc} |
| 219 | |
Martin v. Löwis | 73d538b | 2003-03-05 15:13:47 +0000 | [diff] [blame] | 220 | \begin{funcdesc}{getfilesystemencoding}{} |
| 221 | Return the name of the encoding used to convert Unicode filenames |
| 222 | into system file names, or \code{None} if the system default encoding |
| 223 | is used. The result value depends on the operating system: |
| 224 | \begin{itemize} |
| 225 | \item On Windows 9x, the encoding is ``mbcs''. |
| 226 | \item On Mac OS X, the encoding is ``utf-8''. |
| 227 | \item On Unix, the encoding is the user's preference |
| 228 | according to the result of nl_langinfo(CODESET), or None if |
| 229 | the nl_langinfo(CODESET) failed. |
| 230 | \item On Windows NT+, file names are Unicode natively, so no conversion |
Martin v. Löwis | 64af6c5 | 2004-06-16 04:53:46 +0000 | [diff] [blame] | 231 | is performed. \code{getfilesystemencoding} still returns ``mbcs'', |
| 232 | as this is the encoding that applications should use when they |
| 233 | explicitly want to convert Unicode strings to byte strings that |
| 234 | are equivalent when used as file names. |
Martin v. Löwis | 73d538b | 2003-03-05 15:13:47 +0000 | [diff] [blame] | 235 | \end{itemize} |
| 236 | \versionadded{2.3} |
| 237 | \end{funcdesc} |
| 238 | |
Guido van Rossum | 6e91c6a | 1998-02-07 21:17:05 +0000 | [diff] [blame] | 239 | \begin{funcdesc}{getrefcount}{object} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 240 | Return the reference count of the \var{object}. The count returned |
| 241 | is generally one higher than you might expect, because it includes |
| 242 | the (temporary) reference as an argument to |
| 243 | \function{getrefcount()}. |
Guido van Rossum | 6e91c6a | 1998-02-07 21:17:05 +0000 | [diff] [blame] | 244 | \end{funcdesc} |
| 245 | |
Jeremy Hylton | ee5adfb | 2000-08-31 19:23:01 +0000 | [diff] [blame] | 246 | \begin{funcdesc}{getrecursionlimit}{} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 247 | Return the current value of the recursion limit, the maximum depth |
| 248 | of the Python interpreter stack. This limit prevents infinite |
| 249 | recursion from causing an overflow of the C stack and crashing |
| 250 | Python. It can be set by \function{setrecursionlimit()}. |
Jeremy Hylton | ee5adfb | 2000-08-31 19:23:01 +0000 | [diff] [blame] | 251 | \end{funcdesc} |
| 252 | |
Barry Warsaw | b6a54d2 | 2000-12-06 21:47:46 +0000 | [diff] [blame] | 253 | \begin{funcdesc}{_getframe}{\optional{depth}} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 254 | Return a frame object from the call stack. If optional integer |
| 255 | \var{depth} is given, return the frame object that many calls below |
| 256 | the top of the stack. If that is deeper than the call stack, |
| 257 | \exception{ValueError} is raised. The default for \var{depth} is |
| 258 | zero, returning the frame at the top of the call stack. |
Barry Warsaw | b6a54d2 | 2000-12-06 21:47:46 +0000 | [diff] [blame] | 259 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 260 | This function should be used for internal and specialized purposes |
| 261 | only. |
Barry Warsaw | b6a54d2 | 2000-12-06 21:47:46 +0000 | [diff] [blame] | 262 | \end{funcdesc} |
| 263 | |
Mark Hammond | 8696ebc | 2002-10-08 02:44:31 +0000 | [diff] [blame] | 264 | \begin{funcdesc}{getwindowsversion}{} |
| 265 | Return a tuple containing five components, describing the Windows |
| 266 | version currently running. The elements are \var{major}, \var{minor}, |
| 267 | \var{build}, \var{platform}, and \var{text}. \var{text} contains |
| 268 | a string while all other values are integers. |
| 269 | |
| 270 | \var{platform} may be one of the following values: |
| 271 | \begin{list}{}{\leftmargin 0.7in \labelwidth 0.65in} |
| 272 | \item[0 (\constant{VER_PLATFORM_WIN32s})] |
| 273 | Win32s on Windows 3.1. |
| 274 | \item[1 (\constant{VER_PLATFORM_WIN32_WINDOWS})] |
| 275 | Windows 95/98/ME |
| 276 | \item[2 (\constant{VER_PLATFORM_WIN32_NT})] |
| 277 | Windows NT/2000/XP |
| 278 | \item[3 (\constant{VER_PLATFORM_WIN32_CE})] |
| 279 | Windows CE. |
| 280 | \end{list} |
| 281 | |
| 282 | This function wraps the Win32 \function{GetVersionEx()} function; |
| 283 | see the Microsoft Documentation for more information about these |
| 284 | fields. |
| 285 | |
| 286 | Availability: Windows. |
| 287 | \versionadded{2.3} |
| 288 | \end{funcdesc} |
| 289 | |
Fred Drake | 4d65d73 | 2000-04-13 16:54:17 +0000 | [diff] [blame] | 290 | \begin{datadesc}{hexversion} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 291 | The version number encoded as a single integer. This is guaranteed |
| 292 | to increase with each version, including proper support for |
| 293 | non-production releases. For example, to test that the Python |
| 294 | interpreter is at least version 1.5.2, use: |
Fred Drake | 4d65d73 | 2000-04-13 16:54:17 +0000 | [diff] [blame] | 295 | |
| 296 | \begin{verbatim} |
| 297 | if sys.hexversion >= 0x010502F0: |
| 298 | # use some advanced feature |
| 299 | ... |
| 300 | else: |
| 301 | # use an alternative implementation or warn the user |
| 302 | ... |
| 303 | \end{verbatim} |
| 304 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 305 | This is called \samp{hexversion} since it only really looks |
| 306 | meaningful when viewed as the result of passing it to the built-in |
| 307 | \function{hex()} function. The \code{version_info} value may be |
| 308 | used for a more human-friendly encoding of the same information. |
| 309 | \versionadded{1.5.2} |
Fred Drake | 4d65d73 | 2000-04-13 16:54:17 +0000 | [diff] [blame] | 310 | \end{datadesc} |
| 311 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 312 | \begin{datadesc}{last_type} |
| 313 | \dataline{last_value} |
| 314 | \dataline{last_traceback} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 315 | These three variables are not always defined; they are set when an |
| 316 | exception is not handled and the interpreter prints an error message |
| 317 | and a stack traceback. Their intended use is to allow an |
| 318 | interactive user to import a debugger module and engage in |
| 319 | post-mortem debugging without having to re-execute the command that |
| 320 | caused the error. (Typical use is \samp{import pdb; pdb.pm()} to |
| 321 | enter the post-mortem debugger; see chapter \ref{debugger}, ``The |
| 322 | Python Debugger,'' for more information.) |
Guido van Rossum | 871cf16 | 1997-10-20 22:38:43 +0000 | [diff] [blame] | 323 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 324 | The meaning of the variables is the same as that of the return |
| 325 | values from \function{exc_info()} above. (Since there is only one |
| 326 | interactive thread, thread-safety is not a concern for these |
| 327 | variables, unlike for \code{exc_type} etc.) |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 328 | \end{datadesc} |
| 329 | |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 330 | \begin{datadesc}{maxint} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 331 | The largest positive integer supported by Python's regular integer |
| 332 | type. This is at least 2**31-1. The largest negative integer is |
Fred Drake | c05fc7d | 2001-09-04 18:18:36 +0000 | [diff] [blame] | 333 | \code{-maxint-1} --- the asymmetry results from the use of 2's |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 334 | complement binary arithmetic. |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 335 | \end{datadesc} |
| 336 | |
Fred Drake | c05fc7d | 2001-09-04 18:18:36 +0000 | [diff] [blame] | 337 | \begin{datadesc}{maxunicode} |
| 338 | An integer giving the largest supported code point for a Unicode |
| 339 | character. The value of this depends on the configuration option |
| 340 | that specifies whether Unicode characters are stored as UCS-2 or |
| 341 | UCS-4. |
| 342 | \end{datadesc} |
| 343 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 344 | \begin{datadesc}{modules} |
Fred Drake | 0fd72ee | 1998-03-08 05:43:51 +0000 | [diff] [blame] | 345 | This is a dictionary that maps module names to modules which have |
| 346 | already been loaded. This can be manipulated to force reloading of |
| 347 | modules and other tricks. Note that removing a module from this |
| 348 | dictionary is \emph{not} the same as calling |
| 349 | \function{reload()}\bifuncindex{reload} on the corresponding module |
| 350 | object. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 351 | \end{datadesc} |
| 352 | |
| 353 | \begin{datadesc}{path} |
Fred Drake | 2b67bee | 1998-01-13 18:35:51 +0000 | [diff] [blame] | 354 | \indexiii{module}{search}{path} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 355 | A list of strings that specifies the search path for modules. |
Guido van Rossum | 54ed2d3 | 2002-07-15 16:08:10 +0000 | [diff] [blame] | 356 | Initialized from the environment variable \envvar{PYTHONPATH}, plus an |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 357 | installation-dependent default. |
Guido van Rossum | 0a3c753 | 1997-06-02 17:32:41 +0000 | [diff] [blame] | 358 | |
Guido van Rossum | 54ed2d3 | 2002-07-15 16:08:10 +0000 | [diff] [blame] | 359 | As initialized upon program startup, |
| 360 | the first item of this list, \code{path[0]}, is the directory |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 361 | containing the script that was used to invoke the Python |
| 362 | interpreter. If the script directory is not available (e.g. if the |
| 363 | interpreter is invoked interactively or if the script is read from |
| 364 | standard input), \code{path[0]} is the empty string, which directs |
| 365 | Python to search modules in the current directory first. Notice |
| 366 | that the script directory is inserted \emph{before} the entries |
| 367 | inserted as a result of \envvar{PYTHONPATH}. |
Guido van Rossum | 54ed2d3 | 2002-07-15 16:08:10 +0000 | [diff] [blame] | 368 | |
| 369 | A program is free to modify this list for its own purposes. |
Fred Drake | 38d7c1b | 2003-07-17 04:22:44 +0000 | [diff] [blame] | 370 | |
Brett Cannon | 8b6cc2e | 2004-03-21 14:10:18 +0000 | [diff] [blame] | 371 | \versionchanged[Unicode strings are no longer ignored]{2.3} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 372 | \end{datadesc} |
| 373 | |
Guido van Rossum | 6b686e9 | 1995-07-07 23:00:35 +0000 | [diff] [blame] | 374 | \begin{datadesc}{platform} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 375 | This string contains a platform identifier, e.g. \code{'sunos5'} or |
| 376 | \code{'linux1'}. This can be used to append platform-specific |
| 377 | components to \code{path}, for instance. |
Guido van Rossum | 0a3c753 | 1997-06-02 17:32:41 +0000 | [diff] [blame] | 378 | \end{datadesc} |
| 379 | |
| 380 | \begin{datadesc}{prefix} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 381 | A string giving the site-specific directory prefix where the |
| 382 | platform independent Python files are installed; by default, this is |
| 383 | the string \code{'/usr/local'}. This can be set at build time with |
| 384 | the \longprogramopt{prefix} argument to the \program{configure} |
| 385 | script. The main collection of Python library modules is installed |
| 386 | in the directory \code{prefix + '/lib/python\var{version}'} while |
Martin v. Löwis | 4f1cd8b | 2001-07-26 13:41:06 +0000 | [diff] [blame] | 387 | the platform independent header files (all except \file{pyconfig.h}) |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 388 | are stored in \code{prefix + '/include/python\var{version}'}, where |
| 389 | \var{version} is equal to \code{version[:3]}. |
Guido van Rossum | 6b686e9 | 1995-07-07 23:00:35 +0000 | [diff] [blame] | 390 | \end{datadesc} |
| 391 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 392 | \begin{datadesc}{ps1} |
| 393 | \dataline{ps2} |
Fred Drake | e6cedb3 | 1998-04-03 07:05:16 +0000 | [diff] [blame] | 394 | \index{interpreter prompts} |
| 395 | \index{prompts, interpreter} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 396 | Strings specifying the primary and secondary prompt of the |
| 397 | interpreter. These are only defined if the interpreter is in |
| 398 | interactive mode. Their initial values in this case are |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 399 | \code{'>\code{>}> '} and \code{'... '}. If a non-string object is |
| 400 | assigned to either variable, its \function{str()} is re-evaluated |
| 401 | each time the interpreter prepares to read a new interactive |
| 402 | command; this can be used to implement a dynamic prompt. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 403 | \end{datadesc} |
| 404 | |
Guido van Rossum | 9c51e41 | 1995-01-10 10:50:58 +0000 | [diff] [blame] | 405 | \begin{funcdesc}{setcheckinterval}{interval} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 406 | Set the interpreter's ``check interval''. This integer value |
| 407 | determines how often the interpreter checks for periodic things such |
Skip Montanaro | eec26f9 | 2003-07-02 21:38:34 +0000 | [diff] [blame] | 408 | as thread switches and signal handlers. The default is \code{100}, |
| 409 | meaning the check is performed every 100 Python virtual instructions. |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 410 | Setting it to a larger value may increase performance for programs |
| 411 | using threads. Setting it to a value \code{<=} 0 checks every |
| 412 | virtual instruction, maximizing responsiveness as well as overhead. |
Guido van Rossum | 7f49b7a | 1995-01-12 12:38:46 +0000 | [diff] [blame] | 413 | \end{funcdesc} |
Guido van Rossum | 9c51e41 | 1995-01-10 10:50:58 +0000 | [diff] [blame] | 414 | |
Fred Drake | 8940faf | 2000-10-25 21:02:55 +0000 | [diff] [blame] | 415 | \begin{funcdesc}{setdefaultencoding}{name} |
| 416 | Set the current default string encoding used by the Unicode |
| 417 | implementation. If \var{name} does not match any available |
| 418 | encoding, \exception{LookupError} is raised. This function is only |
| 419 | intended to be used by the \refmodule{site} module implementation |
| 420 | and, where needed, by \module{sitecustomize}. Once used by the |
| 421 | \refmodule{site} module, it is removed from the \module{sys} |
| 422 | module's namespace. |
| 423 | % Note that \refmodule{site} is not imported if |
| 424 | % the \programopt{-S} option is passed to the interpreter, in which |
| 425 | % case this function will remain available. |
| 426 | \versionadded{2.0} |
| 427 | \end{funcdesc} |
| 428 | |
Andrew M. Kuchling | 28bafb8 | 2001-07-19 01:17:15 +0000 | [diff] [blame] | 429 | \begin{funcdesc}{setdlopenflags}{n} |
Fred Drake | 5d808fb | 2001-07-18 16:35:05 +0000 | [diff] [blame] | 430 | Set the flags used by the interpreter for \cfunction{dlopen()} |
| 431 | calls, such as when the interpreter loads extension modules. Among |
| 432 | other things, this will enable a lazy resolving of symbols when |
Andrew M. Kuchling | 28bafb8 | 2001-07-19 01:17:15 +0000 | [diff] [blame] | 433 | importing a module, if called as \code{sys.setdlopenflags(0)}. To |
| 434 | share symbols across extension modules, call as |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 435 | \code{sys.setdlopenflags(dl.RTLD_NOW | dl.RTLD_GLOBAL)}. Symbolic |
Fred Drake | 5d808fb | 2001-07-18 16:35:05 +0000 | [diff] [blame] | 436 | names for the flag modules can be either found in the \refmodule{dl} |
| 437 | module, or in the \module{DLFCN} module. If \module{DLFCN} is not |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 438 | available, it can be generated from \file{/usr/include/dlfcn.h} |
| 439 | using the \program{h2py} script. |
Fred Drake | 5d808fb | 2001-07-18 16:35:05 +0000 | [diff] [blame] | 440 | Availability: \UNIX. |
| 441 | \versionadded{2.2} |
Martin v. Löwis | f0473d5 | 2001-07-18 16:17:16 +0000 | [diff] [blame] | 442 | \end{funcdesc} |
| 443 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 444 | \begin{funcdesc}{setprofile}{profilefunc} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 445 | Set the system's profile function,\index{profile function} which |
| 446 | allows you to implement a Python source code profiler in |
| 447 | Python.\index{profiler} See chapter \ref{profile} for more |
| 448 | information on the Python profiler. The system's profile function |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 449 | is called similarly to the system's trace function (see |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 450 | \function{settrace()}), but it isn't called for each executed line |
Fred Drake | 64d7863 | 2001-10-16 14:54:22 +0000 | [diff] [blame] | 451 | of code (only on call and return, but the return event is reported |
| 452 | even when an exception has been set). The function is |
| 453 | thread-specific, but there is no way for the profiler to know about |
| 454 | context switches between threads, so it does not make sense to use |
| 455 | this in the presence of multiple threads. |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 456 | Also, its return value is not used, so it can simply return |
| 457 | \code{None}. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 458 | \end{funcdesc} |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 459 | |
Jeremy Hylton | ee5adfb | 2000-08-31 19:23:01 +0000 | [diff] [blame] | 460 | \begin{funcdesc}{setrecursionlimit}{limit} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 461 | Set the maximum depth of the Python interpreter stack to |
| 462 | \var{limit}. This limit prevents infinite recursion from causing an |
| 463 | overflow of the C stack and crashing Python. |
Jeremy Hylton | ee5adfb | 2000-08-31 19:23:01 +0000 | [diff] [blame] | 464 | |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 465 | The highest possible limit is platform-dependent. A user may need |
| 466 | to set the limit higher when she has a program that requires deep |
| 467 | recursion and a platform that supports a higher limit. This should |
| 468 | be done with care, because a too-high limit can lead to a crash. |
Fred Drake | 65faf11 | 2000-08-31 19:35:56 +0000 | [diff] [blame] | 469 | \end{funcdesc} |
Jeremy Hylton | ee5adfb | 2000-08-31 19:23:01 +0000 | [diff] [blame] | 470 | |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 471 | \begin{funcdesc}{settrace}{tracefunc} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 472 | Set the system's trace function,\index{trace function} which allows |
| 473 | you to implement a Python source code debugger in Python. See |
| 474 | section \ref{debugger-hooks}, ``How It Works,'' in the chapter on |
Fred Drake | 64d7863 | 2001-10-16 14:54:22 +0000 | [diff] [blame] | 475 | the Python debugger.\index{debugger} The function is |
| 476 | thread-specific; for a debugger to support multiple threads, it must |
| 477 | be registered using \function{settrace()} for each thread being |
| 478 | debugged. |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 479 | \end{funcdesc} |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 480 | |
Martin v. Löwis | f30d60e | 2004-06-08 08:17:44 +0000 | [diff] [blame] | 481 | \begin{funcdesc}{settscdump}{on_flag} |
| 482 | Activate dumping of VM measurements using the Pentium timestamp |
| 483 | counter, if \var{on_flag} is true. Deactivate these dumps if |
| 484 | \var{on_flag} is off. The function is available only if Python |
Fred Drake | 7f35404 | 2004-06-08 14:01:27 +0000 | [diff] [blame] | 485 | was compiled with \longprogramopt{with-tsc}. To understand the |
| 486 | output of this dump, read \file{Python/ceval.c} in the Python |
| 487 | sources. |
Martin v. Löwis | f30d60e | 2004-06-08 08:17:44 +0000 | [diff] [blame] | 488 | \versionadded{2.4} |
| 489 | \end{funcdesc} |
| 490 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 491 | \begin{datadesc}{stdin} |
| 492 | \dataline{stdout} |
| 493 | \dataline{stderr} |
| 494 | File objects corresponding to the interpreter's standard input, |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 495 | output and error streams. \code{stdin} is used for all interpreter |
| 496 | input except for scripts but including calls to |
Fred Drake | 0fd72ee | 1998-03-08 05:43:51 +0000 | [diff] [blame] | 497 | \function{input()}\bifuncindex{input} and |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 498 | \function{raw_input()}\bifuncindex{raw_input}. \code{stdout} is |
| 499 | used for the output of \keyword{print} and expression statements and |
| 500 | for the prompts of \function{input()} and \function{raw_input()}. |
| 501 | The interpreter's own prompts and (almost all of) its error messages |
| 502 | go to \code{stderr}. \code{stdout} and \code{stderr} needn't be |
| 503 | built-in file objects: any object is acceptable as long as it has a |
| 504 | \method{write()} method that takes a string argument. (Changing |
| 505 | these objects doesn't affect the standard I/O streams of processes |
Fred Drake | 0fd72ee | 1998-03-08 05:43:51 +0000 | [diff] [blame] | 506 | executed by \function{os.popen()}, \function{os.system()} or the |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 507 | \function{exec*()} family of functions in the \refmodule{os} |
| 508 | module.) |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 509 | \end{datadesc} |
| 510 | |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 511 | \begin{datadesc}{__stdin__} |
| 512 | \dataline{__stdout__} |
| 513 | \dataline{__stderr__} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 514 | These objects contain the original values of \code{stdin}, |
| 515 | \code{stderr} and \code{stdout} at the start of the program. They |
| 516 | are used during finalization, and could be useful to restore the |
| 517 | actual files to known working file objects in case they have been |
| 518 | overwritten with a broken object. |
Guido van Rossum | 3e5fe42 | 1998-06-10 17:57:44 +0000 | [diff] [blame] | 519 | \end{datadesc} |
| 520 | |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 521 | \begin{datadesc}{tracebacklimit} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 522 | When this variable is set to an integer value, it determines the |
| 523 | maximum number of levels of traceback information printed when an |
| 524 | unhandled exception occurs. The default is \code{1000}. When set |
| 525 | to \code{0} or less, all traceback information is suppressed and |
| 526 | only the exception type and value are printed. |
Guido van Rossum | 5fdeeea | 1994-01-02 01:22:07 +0000 | [diff] [blame] | 527 | \end{datadesc} |
Guido van Rossum | 0a3c753 | 1997-06-02 17:32:41 +0000 | [diff] [blame] | 528 | |
| 529 | \begin{datadesc}{version} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 530 | A string containing the version number of the Python interpreter |
| 531 | plus additional information on the build number and compiler used. |
| 532 | It has a value of the form \code{'\var{version} |
| 533 | (\#\var{build_number}, \var{build_date}, \var{build_time}) |
| 534 | [\var{compiler}]'}. The first three characters are used to identify |
| 535 | the version in the installation directories (where appropriate on |
| 536 | each platform). An example: |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 537 | |
| 538 | \begin{verbatim} |
| 539 | >>> import sys |
| 540 | >>> sys.version |
| 541 | '1.5.2 (#0 Apr 13 1999, 10:51:12) [MSC 32 bit (Intel)]' |
| 542 | \end{verbatim} |
| 543 | \end{datadesc} |
| 544 | |
Skip Montanaro | 8e790e7 | 2002-09-03 13:25:17 +0000 | [diff] [blame] | 545 | \begin{datadesc}{api_version} |
| 546 | The C API version for this interpreter. Programmers may find this useful |
| 547 | when debugging version conflicts between Python and extension |
| 548 | modules. \versionadded{2.3} |
| 549 | \end{datadesc} |
| 550 | |
Fred Drake | 4d65d73 | 2000-04-13 16:54:17 +0000 | [diff] [blame] | 551 | \begin{datadesc}{version_info} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 552 | A tuple containing the five components of the version number: |
| 553 | \var{major}, \var{minor}, \var{micro}, \var{releaselevel}, and |
| 554 | \var{serial}. All values except \var{releaselevel} are integers; |
| 555 | the release level is \code{'alpha'}, \code{'beta'}, |
| 556 | \code{'candidate'}, or \code{'final'}. The \code{version_info} |
| 557 | value corresponding to the Python version 2.0 is \code{(2, 0, 0, |
| 558 | 'final', 0)}. |
| 559 | \versionadded{2.0} |
Fred Drake | 4d65d73 | 2000-04-13 16:54:17 +0000 | [diff] [blame] | 560 | \end{datadesc} |
| 561 | |
Fred Drake | c05fc7d | 2001-09-04 18:18:36 +0000 | [diff] [blame] | 562 | \begin{datadesc}{warnoptions} |
| 563 | This is an implementation detail of the warnings framework; do not |
| 564 | modify this value. Refer to the \refmodule{warnings} module for |
| 565 | more information on the warnings framework. |
| 566 | \end{datadesc} |
| 567 | |
Fred Drake | 38e5d27 | 2000-04-03 20:13:55 +0000 | [diff] [blame] | 568 | \begin{datadesc}{winver} |
Fred Drake | 7218202 | 2001-07-18 17:52:58 +0000 | [diff] [blame] | 569 | The version number used to form registry keys on Windows platforms. |
| 570 | This is stored as string resource 1000 in the Python DLL. The value |
| 571 | is normally the first three characters of \constant{version}. It is |
| 572 | provided in the \module{sys} module for informational purposes; |
| 573 | modifying this value has no effect on the registry keys used by |
| 574 | Python. |
| 575 | Availability: Windows. |
Guido van Rossum | 0a3c753 | 1997-06-02 17:32:41 +0000 | [diff] [blame] | 576 | \end{datadesc} |
Skip Montanaro | 8a79727 | 2002-03-27 17:29:50 +0000 | [diff] [blame] | 577 | |
| 578 | |
| 579 | \begin{seealso} |
| 580 | \seemodule{site} |
| 581 | {This describes how to use .pth files to extend \code{sys.path}.} |
| 582 | \end{seealso} |