c737cde947
Anywhere a module is mentioned, use its "non-u" name for consistency. The "import module" vs "import umodule" is something of a FAQ, and this commit intends to help clear that up. As a first approximation MicroPython is Python, and so imports should work the same as Python and use the same name, to a first approximation. The u-version of a module is a detail that can be learned later on, when the user wants to understand more and have finer control over importing. Existing Python code should just work, as much as it is possible to do that within the constraints of embedded systems, and the MicroPython documentation should match the idiomatic way to write Python code. With universal weak links for modules (via MICROPY_MODULE_WEAK_LINKS) users can consistently use "import foo" across all ports (with the exception of the minimal ports). And the ability to override/extend via "foo.py" continues to work well. Signed-off-by: Jim Mussared <jim.mussared@gmail.com>
143 lines
4.3 KiB
ReStructuredText
143 lines
4.3 KiB
ReStructuredText
:mod:`sys` -- system specific functions
|
|
=======================================
|
|
|
|
.. module:: sys
|
|
:synopsis: system specific functions
|
|
|
|
|see_cpython_module| :mod:`python:sys`.
|
|
|
|
Functions
|
|
---------
|
|
|
|
.. function:: exit(retval=0, /)
|
|
|
|
Terminate current program with a given exit code. Underlyingly, this
|
|
function raise as `SystemExit` exception. If an argument is given, its
|
|
value given as an argument to `SystemExit`.
|
|
|
|
.. function:: atexit(func)
|
|
|
|
Register *func* to be called upon termination. *func* must be a callable
|
|
that takes no arguments, or ``None`` to disable the call. The ``atexit``
|
|
function will return the previous value set by this function, which is
|
|
initially ``None``.
|
|
|
|
.. admonition:: Difference to CPython
|
|
:class: attention
|
|
|
|
This function is a MicroPython extension intended to provide similar
|
|
functionality to the :mod:`atexit` module in CPython.
|
|
|
|
.. function:: print_exception(exc, file=sys.stdout, /)
|
|
|
|
Print exception with a traceback to a file-like object *file* (or
|
|
`sys.stdout` by default).
|
|
|
|
.. admonition:: Difference to CPython
|
|
:class: attention
|
|
|
|
This is simplified version of a function which appears in the
|
|
``traceback`` module in CPython. Unlike ``traceback.print_exception()``,
|
|
this function takes just exception value instead of exception type,
|
|
exception value, and traceback object; *file* argument should be
|
|
positional; further arguments are not supported. CPython-compatible
|
|
``traceback`` module can be found in `micropython-lib`.
|
|
|
|
Constants
|
|
---------
|
|
|
|
.. data:: argv
|
|
|
|
A mutable list of arguments the current program was started with.
|
|
|
|
.. data:: byteorder
|
|
|
|
The byte order of the system (``"little"`` or ``"big"``).
|
|
|
|
.. data:: implementation
|
|
|
|
Object with information about the current Python implementation. For
|
|
MicroPython, it has following attributes:
|
|
|
|
* *name* - string "micropython"
|
|
* *version* - tuple (major, minor, micro), e.g. (1, 7, 0)
|
|
|
|
This object is the recommended way to distinguish MicroPython from other
|
|
Python implementations (note that it still may not exist in the very
|
|
minimal ports).
|
|
|
|
.. admonition:: Difference to CPython
|
|
:class: attention
|
|
|
|
CPython mandates more attributes for this object, but the actual useful
|
|
bare minimum is implemented in MicroPython.
|
|
|
|
.. data:: maxsize
|
|
|
|
Maximum value which a native integer type can hold on the current platform,
|
|
or maximum value representable by MicroPython integer type, if it's smaller
|
|
than platform max value (that is the case for MicroPython ports without
|
|
long int support).
|
|
|
|
This attribute is useful for detecting "bitness" of a platform (32-bit vs
|
|
64-bit, etc.). It's recommended to not compare this attribute to some
|
|
value directly, but instead count number of bits in it::
|
|
|
|
bits = 0
|
|
v = sys.maxsize
|
|
while v:
|
|
bits += 1
|
|
v >>= 1
|
|
if bits > 32:
|
|
# 64-bit (or more) platform
|
|
...
|
|
else:
|
|
# 32-bit (or less) platform
|
|
# Note that on 32-bit platform, value of bits may be less than 32
|
|
# (e.g. 31) due to peculiarities described above, so use "> 16",
|
|
# "> 32", "> 64" style of comparisons.
|
|
|
|
.. data:: modules
|
|
|
|
Dictionary of loaded modules. On some ports, it may not include builtin
|
|
modules.
|
|
|
|
.. data:: path
|
|
|
|
A mutable list of directories to search for imported modules.
|
|
|
|
.. data:: platform
|
|
|
|
The platform that MicroPython is running on. For OS/RTOS ports, this is
|
|
usually an identifier of the OS, e.g. ``"linux"``. For baremetal ports it
|
|
is an identifier of a board, e.g. ``"pyboard"`` for the original MicroPython
|
|
reference board. It thus can be used to distinguish one board from another.
|
|
If you need to check whether your program runs on MicroPython (vs other
|
|
Python implementation), use `sys.implementation` instead.
|
|
|
|
.. data:: stderr
|
|
|
|
Standard error `stream`.
|
|
|
|
.. data:: stdin
|
|
|
|
Standard input `stream`.
|
|
|
|
.. data:: stdout
|
|
|
|
Standard output `stream`.
|
|
|
|
.. data:: version
|
|
|
|
Python language version that this implementation conforms to, as a string.
|
|
|
|
.. data:: version_info
|
|
|
|
Python language version that this implementation conforms to, as a tuple of ints.
|
|
|
|
.. admonition:: Difference to CPython
|
|
:class: attention
|
|
|
|
Only the first three version numbers (major, minor, micro) are supported and
|
|
they can be referenced only by index, not by name.
|