Python поток ошибок - Не ошибается лишь тот, кто ничего не делает!

Прежде чем читать эту статью, давайте разберемся, что такое термины stdin , stdout и stderr .

Стандартный ввод — это дескриптор файла, который пользовательская программа читает, чтобы получить информацию от пользователя. Мы передаем ввод на стандартный ввод (stdin).

Стандартный вывод — программа пользователя записывает обычную информацию в этот дескриптор файла. Вывод возвращается через стандартный вывод (stdout).

Стандартная ошибка — программа пользователя записывает информацию об ошибке в этот дескриптор файла. Ошибки возвращаются через стандартную ошибку (stderr).

Python предоставляет нам файловые объекты, представляющие stdin, stdout и stderr. Давайте посмотрим, как мы могли бы работать с этими объектами, чтобы использовать ввод и вывод программы.

1. sys.stdin

Модуль Python sys предоставляет нам все три файловых объекта для stdin, stdout и stderr. В качестве объекта входного файла мы используем sys.stdin . Это похоже на файл, где вы можете открывать и закрывать его, как и любые другие файлы в Python.

Давайте разберемся на простом примере:

import sys

stdin_fileno = sys.stdin

# Keeps reading from stdin and quits only if the word 'exit' is there
# This loop, by default does not terminate, since stdin is open
for line in stdin_fileno:
    # Remove trailing newline characters using strip()
    if 'exit' == line.strip():
        print('Found exit. Terminating the program')
        exit(0)
    else:
        print('Message from sys.stdin: ---> {} <---'.format(line))

Вывод

Hi
Message from sys.stdin: ---> Hi
 <---
Hello from AskPython
Message from sys.stdin: ---> Hello from AskPython
 <---
exit
Found exit. Terminating the program

Выше фрагмент кода продолжает чтение входных данных из stdin и выводит сообщение на консоли ( stdout ) до тех пор , слово exit не встречаются.

Примечание. Обычно мы не закрываем объект файла stdin по умолчанию, хотя это разрешено. Итак, stdin_fileno.close() — допустимый код Python.

Теперь, когда мы немного знаем о stdin , перейдем к stdout .

2. sys.stdout

В качестве объекта выходного файла мы используем sys.stdout . Он похож на sys.stdin , но напрямую отображает все, что написано в нем, в консоли.

В приведенном ниже фрагменте показано, что мы получаем вывод в консоль, если пишем в sys.stdout .

import sys

stdout_fileno = sys.stdout

sample_input = ['Hi', 'Hello from AskPython', 'exit']

for ip in sample_input:
    # Prints to stdout
    stdout_fileno.write(ip + 'n')

Выход

Hi
Hello from AskPython
exit

3. sys.stderr

Это похоже на sys.stdout потому что он также sys.stdout непосредственно выводит в консоль. Но разница в том, что он печатает только сообщения об исключениях и ошибках. (Вот почему он называется стандартной ошибкой).

Проиллюстрируем это на примере.

import sys

stdout_fileno = sys.stdout
stderr_fileno = sys.stderr

sample_input = ['Hi', 'Hello from AskPython', 'exit']

for ip in sample_input:
    # Prints to stdout
    stdout_fileno.write(ip + 'n')
    # Tries to add an Integer with string. Raises an exception
    try:
        ip = ip + 100
    # Catch all exceptions
    except:
        stderr_fileno.write('Exception Occurred!n')

Выход

Hi
Exception Occurred!
Hello from AskPython
Exception Occurred!
exit
Exception Occurred!

Как вы можете заметить, для всех входных строк мы пытаемся добавить к Integer, что вызовет исключение. Мы перехватываем все такие исключения и печатаем еще одно сообщение отладки с помощью sys.stderr .

Перенаправление в файл

Мы можем перенаправить дескрипторы файлов stdin , stdout и stderr в любой другой файл (дескриптор файла). Это может быть полезно, если вы хотите регистрировать события в файле без использования какого-либо другого модуля, такого как Logging.

Приведенный ниже фрагмент перенаправляет вывод ( stdout ) в файл с именем Output.txt .

Итак, мы не увидим ничего, напечатанного в консоли, потому что теперь это печатается в самом файле! В этом суть перенаправления вывода. Вы «перенаправляете» вывод в другое место. (На этот раз в Output.txt , а не в консоль)

import sys

# Save the current stdout so that we can revert sys.stdou after we complete
# our redirection
stdout_fileno = sys.stdout

sample_input = ['Hi', 'Hello from AskPython', 'exit']

# Redirect sys.stdout to the file
sys.stdout = open('Output.txt', 'w')

for ip in sample_input:
    # Prints to the redirected stdout (Output.txt)
    sys.stdout.write(ip + 'n')
    # Prints to the actual saved stdout handler
    stdout_fileno.write(ip + 'n')

# Close the file
sys.stdout.close()
# Restore sys.stdout to our old saved file handler
sys.stdout = stdout_fileno

Выход

root@ubuntu:~# python3 output_redirection.py
Hi
Hello from AskPython
exit
root@ubuntu:~# cat Output.txt
Hi
Hello from AskPython
exit

Как видите, мы распечатали вывод как в консоль, так и в Output.txt .

Сначала мы сохраняем исходный sys.stdout обработчик файла sys.stdout в другую переменную. Нам это нужно не только для восстановления sys.stdout в старом обработчике (указывающем на консоль), но мы также можем печатать на консоль, используя эту переменную!

Обратите внимание, что после записи в файл мы закрываем его, аналогично тому, как мы закрываем файл, потому что этот файл все еще был открыт.

Наконец, мы восстанавливаем обработчик sys.stdout в консоли, используя переменную stdout_fileno .

Аналогичный процесс можно выполнить для перенаправления ввода и ошибок, заменив sys.stdout на sys.stdin или sys.stderr и работая с sys.stderr и исключениями вместо вывода.

Источник

Объекты стандартного ввода, вывода и ошибки.

Синтаксис:

import sys

sys.stdin
sys.stdout
sys.stderr

Описание:

Файловые объекты sys.stdin, sys.stdout и sys.stderr используются интерпретатором для стандартного ввода, вывода и ошибок:

sys.stdin — используется для всех интерактивных входных данных, включая вызовы input();
sys.stdout — используется для вывода оператором print() и выражений, которые возвращают значение, а также для подсказок в функции input();
sys.stderr — сообщения об ошибках и собственные запросы переводчика.

Эти потоки являются обычными текстовыми файлами, такими же, как и те, которые возвращаются функцией open().

Их параметры выбираются следующим образом:

Кодировка символов зависит от платформы. Не-Windows платформы используют кодировку локали locale.getpreferredencoding().
В Windows UTF-8 используется для консольного устройства. Не символьные устройства, такие как дисковые файлы и каналы, используют кодировку языкового стандарта системы, то есть кодовую страницу ANSI. Не консольные символьные устройства, такие как NUL, т.е. где метод isatty() возвращает True, используют значение кодовых страниц ввода и вывода консоли при запуске соответственно для sys.stdin и sys.stdout/sys.stderr. По умолчанию используется системная кодировка локали, если процесс изначально не подключен к консоли.

Особое поведение консоли можно изменить, установив переменную окружения PYTHONLEGACYWINDOWSSTDIO перед запуском Python. В этом случае кодовые страницы консоли используются как для любого другого символьного устройства.

На всех платформах можно переопределить кодировку символов, установив переменную среды PYTHONIOENCODING перед запуском Python или используя новый параметр командной строки — X utf8 и переменную среды PYTHONUTF8. Однако для консоли Windows это применимо только в том случае, если также установлено PYTHONLEGACYWINDOWSSTDIO.

В интерактивном режиме потоки stdout и stderr буферизуются по строкам. В противном случае они буферизируются как обычные текстовые файлы. Вы можете переопределить это значение с помощью параметра командной строки -u.

Примечание. Для записи или чтения двоичных данных из/в стандартные потоки используйте базовый объект двоичного буфера. Например, чтобы записать байты в sys.stdout используйте sys.stdout.buffer.write(b'abc').

Однако, если вы пишете модуль или библиотеку и не контролируете, в каком контексте будет выполняться ее код, помните, что стандартные потоки могут быть заменены файловыми объектами, такими как io.StringIO, которые не поддерживают атрибут буфера.

Изменено в Python 3.9: не интерактивный sys.stderr теперь буферизуется по строкам, а не полностью.

`sys.stdin`,
`sys.stdout`,
`sys.stderr`:

Эти объекты содержат исходные значения sys.stdin, sys.stderr и sys.stdout. Они используются во время финализации и могут быть полезны для печати в реальном стандартном потоке, независимо от того, был ли перенаправлен объект sys.std*.

Его также можно использовать для восстановления реальных файлов в известные рабочие файловые объекты, если они были перезаписаны поврежденным объектом. Однако предпочтительный способ сделать это — явно сохранить предыдущий поток перед его заменой и восстановить сохраненный объект.

Примечание. При некоторых условиях sys.stdin, sys.stderr и sys.stdout, а также исходные значения sys.__stdin__, sys.__stdout__ и sys.__stderr__ могут быть None. Обычно это относится к приложениям с графическим интерфейсом Windows, которые не подключены к консоли, а приложения Python запускаются с pythonw.exe⁽¹⁾.

Примеры использования `sys.stdout`, `sys.stderr`:

Сохранение вывода stdout и/или stderr в файл;
Сохранение вывода stdout и/или stderr в переменную в Python;
Перенаправление вывода stdout и/или stderr при помощи contextlib.redirect_std*();
Печать в консоль с задержкой (как телетекст…).

Сохранение вывода `stdout` и/или `stderr` в файл.

Этот код ничего не выводит на консоль, но записывает «Hello World» в текстовый файл с именем file.txt.

stdout = sys.stdout

try:
    sys.stdout = open('file.txt', 'w')
    print('Hello World')
finally:
    # Закрываем file.txt
    sys.stdout.close()
    sys.stdout = stdout

Чтобы сделать такие вещи менее подверженными ошибкам, Python предоставляет sys.__stdin__, sys.__stdout__ и sys.__stderr__ которые всегда содержат исходные значения sys.stdin, sys.stdout и sys.stderr. Приведенный выше код можно было бы сделать проще, используя sys.__stdout__:

try:
    sys.stdout = open('file.txt', 'w')
    print('blah')
finally:
    # Закрываем file.txt
    sys.stdout.close()  
    sys.stdout = sys.__stdout__

Причина, по которой Python имеет как sys.stdout , так и sys.__stdout__ в основном заключается в удобстве, поэтому вам не нужно создавать переменную для копирования stdout = sys.stdout

Сохранение `stdout` и/или `stderr` в переменную в Python.

Чтобы сохранить stdout в переменную нужно подменить sys.stdout собственным объектом io.StringIO, сделав что-то вроде:

from io import StringIO
import sys
 
# сохраняем ссылку, чтобы потом 
# снова отобразить вывод в консоли.
tmp_stdout = sys.stdout
 
# В переменной `result` будет храниться все, 
# что отправляется на стандартный вывод
result = StringIO()
sys.stdout = result
 
# Здесь все, что отправляется на стандартный вывод, 
# будет сохранено в переменную `result`.
do_fancy_stuff()
 
# Снова перенаправляем вывод `sys.stdout` на консоль
 sys.stdout = tmp_stdout
 
# Получаем стандартный вывод как строку!
result_string = result.getvalue()
# далее что-нибудь делаем с переменной стандартного вывода
process_string(result_string)

Перенаправление вывода `stdout` и/или `stderr` при помощи `contextlib.redirect_std*()`.

Например, вывод функции help() обычно отправляется в sys.stdout. Можно записать этот вывод в строку, перенаправив вывод в объект io.StringIO, а затем использовать контекстные менеджеры contextlib.redirect_stdout() и contextlib.redirect_stderr():

import contextlib, io

s = io.StringIO()
with contextlib.redirect_stdout(s):
    help(pow)

>>> s.getvalue()[:50]
# 'Help on built-in function pow in module builtins:n'

Чтобы отправить вывод функции help() в файл на диске, нужно перенаправить вывод в обычный файл:

with open('help.txt', 'w') as fp:
    with contextlib.redirect_stdout(fp):
        help(pow)

Чтобы отправить вывод help() в sys.stderr:

import contextlib, sys

with redirect_stdout(sys.stderr):
    help(pow)

Пример печати текста в консоль с задержкой.

Определим функцию печати в консоль с задержкой так, что бы ее можно было использовать вместо встроенной функции print().

import sys, time
def teleprint(*args, delay=0.05, str_join=' '):
    text = str_join.join(str(x) for x in args)
    n = len(text)
    for i, char in enumerate(text, 1):
        if i == n:
            char = f'{char}n'
        sys.stdout.write(char)
        sys.stdout.flush()
        time.sleep(delay) 

# Строка будет печататься с задержкой, как в телетексте...
>>> teleprint('Печать с задержкой!', 10, 12.5, 'Super!!!', delay=0.07)
# Печать с задержкой!, 10, 12.5, Super!!

Сноски

Если вы не хотите, чтобы при запуске вашей программы открывалось окно терминала, используйте pythonw.exe, в противном случае используйте python.exe

Источник

In this python tutorial, you will learn about python print – stderr, stdin, and stdout with examples.

Python provides us with file-like objects that represent stdin, stdout, and stderr. So first we need to import the sys module in python. Here we will see how we can work with these objects.

Python print to stderr

Python stderr is known as a standard error stream. It is similar to stdout because it also directly prints to the console but the main difference is that it only prints error messages.

Example:

import sys
sys.stderr.write("This is error msg")

After writing the above code (python print to stderr), you can observe that it print debug message using sys.stderr. Stderr always used for printing errors and it is beneficial if you want to separate warning and error message from the actual output.

You can refer to the below screenshot for python print to stderr.

Python print to stderr

Python take input from stdin

Python stdin is used for standard input as it internally calls the input function and the input string is appended with a newline character in the end. So, use rstrip() function to remove it.

Example:

import sys
for line in sys.stdin:
if 'E' == line.rstrip():
break
print(f"Message : {line}')
print("End")

After writing the above code (python take input from stdin), the program reads the user message from standard input and processes it accordingly. The program will terminate when the user will input the “E” message and it prints “End”.

You can refer to the below screenshot for python take input from stdin.

Python take input from stdin

Python stdout is known as standard output. Here, the write function will print directly whatever string you will give.

Example:

import sys
s = sys.stdout
my_input = ['Welcome', 'to', 'python']
for a in my_input:
s.write(a + 'n')

After writing the above code (python stdout), the output will be ” Welcome to python”. We get the output to the console as we write sys.stdout. So, whatever input is given we will see on the console.

You can refer to the below screenshot for python stdout.

Python stdout

Read from stdin in python

To read an input from stdin we can call read() and readlines() function in Python, for reading everything.

Example:

from sys import stdin
my_input = stdin.read(1)
my_input2 = stdin.readline()
total = int(my_input2)
print("my_input = {}".format(my_input))
print("my_input2 = {}".format(my_input2))
print("total = {}".format(total))

After writing the above code (read from stdin in python), the stdin will read input and prints the input for each.

You can refer to the below screenshot for read from stdin in python.

Read from stdin in python

You may like the following Python tutorials:

Increment and Decrement operators in Python
Object oriented programming python
Constructor in Python
Python access modifiers + Examples
Python Anonymous Function
Python Read CSV File and Write CSV File
Python Array with Examples
Python get filename from the path

In this Python Tutorial, we learned – Python print to stderr, Python takes input from stdin, Python stdout, and Read from stdin in python with example.

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.

Источник

Introduction

Among the popular operating systems, they have all standardized on using standard input, standard output, and standard error
with file desciptors 0, 1, and 2 respectively. This allows you to pipe the inputs and outputs to different locations.
Let’s look at how to utilize standard input, output, and error in Python.

To learn more about piping, redirection, stdin, stdout, and stderr in general, see my tutorial
STDIN, STDOUT, STDERR, Piping, and Redirecting.

Basic usage

In Python, the sys.stdin, sys.stdout, and sys.stderr are file-like objects that can perform
expected operations like read() and write(). Let’s look at how to use these objects.
Refer to the official sys package documentation for full information.

Standard output

print(x) is basically a shortcut for sys.stdout.write(x + 'n')

import sys

# Standard output - sys.stdout
print(type(sys.stdout))
sys.stdout.write('Hellon')

sys.stdout is a io.TextIOWrapper objects so you can read and write to them like a regular file.
See https://docs.python.org/3/library/io.html#io.TextIOWrapper for more details about the io.TextIOWrapper class.

To pipe the output of your Python program to a file, you can do it from the shell like this:

python myapp.py > output.txt

Standard error

Standard error works just like standard output and can be used the same way. Standard error has file descriptor 2 where standard output has file descriptor 1. This is beneficial if you want to separate warning and error messages from the actual output of your application. For example, if your program outputs an XML file, you don’t want error strings injected in the middle of your XML file.

# Standard error - sys.stderr
print(type(sys.stderr))
sys.stderr.write("Error messages can go heren")

To pipe standard error from the shell to a file while leaving standard output going to the terminal:

python myapp.py 2>errors.txt

To pipe standard error in to standard output, you can do:

python myapp.py 2>&1

Standard input

Standard input defaults to your keyboard in the terminal, but you can also pipe in files
or the output from a previous program to your standard input. Here is a basic example
of reading one byte from standard input:

# Standard input - sys.stdin
print(type(sys.stdin))
letter = sys.stdin.read(1)  # Read 1 byte
print(letter)
# Can also do things like `sys.stdin.readlines()`

If you want interactive input from the user, it is better to use input() instead of sys.stdin.read() when asking for user input,
but sys.stdin.readlines() can be useful for reading a file that was piped in from the shell like this:

# Feed `input_file.txt` to `sys.stdin` of the Python script
python my_script.py < input_file.txt

To pipe the standard output of one program to the standard input of your Python program,
you can do it like this:

cat data.txt | python myapp.py

Dunder properties: sys.stdin, sys.stdout, sys.stderr

The dunder properties sys.__stdin__, sys.__stdout__ and sys.__stderr__ always contain references
to the original streams. If you re-assign sys.stdout to point somewhere else like a StringIO object,
you can always assign it back to the original value with the following.

Changing sys.stdout to a StringIO object can be useful especially when unit testing.
Check out my tutorial Python Use StringIO to Capture STDOUT and STDERR.

from io import StringIO
import sys

temp_output = StringIO()

# Replace stdout with the StringIO object
sys.stdout = temp_output
# Now, if you print() or use sys.stdout.write
# it goes to the string objc
print('This is going to the StringIO obecjt.')
sys.stdout.write('This is not going to the "real" stdout, yet')

# Then we can restore original stdout
sys.stdout = sys.__stdout__
print("Contents of the StringIO object")
print("===============================")
print(temp_output.getvalue())

fileinput.input() shortcut

This function will return standard input separated by line, or if file names
were provided as command-line arguments, it will provide all the lines from
the files provided. It is similar to ARGF in Ruby. This gives you the option
to pipe in a file from the shell or to provide a list of file paths for input.

For example, you can either pipe in files via standard input or provide a list of filenames as arguments to the application:

python my_app.py < file1.txt
python my_app.py file1.txt file2.txt file3.txt

Here is an example of it in a script:

# fileinput_example.py
import fileinput

lines_of_data = fileinput.input()
print(type(lines_of_data))  # fileinput.FileInput

# One option: Join each line together to one long string
print(''.join(lines_of_data))

# Another option: Iterate through each line
# for line in lines_of_data:
#     print(line.strip())

Here is how you can run the program to pipe in files or provide file names:

# Pipe file in via stdin
python fileinput_example.py < file1.txt

# Provide list of files as arguments
python fileinput_example.py file1.txt file2.txt file3.txt

Conclusion

After reading this guide, you should know how to access and read/write from standard input, standard output, and standard error in Python. You should also know how to use a StringIO object to capture output, and use the fileinput.input() function to get data.

References

sys documentation
Python io.TextIOWrapper documentation
STDIN, STDOUT, STDERR, Piping, and Redirecting
Python Use StringIO to Capture STDOUT and STDERR
fileinput.input()

Источник

This module provides access to some variables used or maintained by the
interpreter and to functions that interact strongly with the interpreter. It is
always available.

sys.abiflags¶

On POSIX systems where Python was built with the standard configure
script, this contains the ABI flags as specified by PEP 3149.

New in version 3.2.

sys.argv¶

The list of command line arguments passed to a Python script. argv[0] is the
script name (it is operating system dependent whether this is a full pathname or
not). If the command was executed using the -c command line option to
the interpreter, argv[0] is set to the string '-c'. If no script name
was passed to the Python interpreter, argv[0] is the empty string.

To loop over the standard input, or the list of files given on the
command line, see the fileinput module.

sys.base_exec_prefix¶

Set during Python startup, before site.py is run, to the same value as
exec_prefix. If not running in a
virtual environment, the values will stay the same; if
site.py finds that a virtual environment is in use, the values of
prefix and exec_prefix will be changed to point to the
virtual environment, whereas base_prefix and
base_exec_prefix will remain pointing to the base Python
installation (the one which the virtual environment was created from).

New in version 3.3.

sys.base_prefix¶

Set during Python startup, before site.py is run, to the same value as
prefix. If not running in a virtual environment, the values
will stay the same; if site.py finds that a virtual environment is in
use, the values of prefix and exec_prefix will be changed to
point to the virtual environment, whereas base_prefix and
base_exec_prefix will remain pointing to the base Python
installation (the one which the virtual environment was created from).

New in version 3.3.

sys.byteorder¶: An indicator of the native byte order. This will have the value 'big' on
big-endian (most-significant byte first) platforms, and 'little' on
little-endian (least-significant byte first) platforms.

sys.builtin_module_names¶: A tuple of strings giving the names of all modules that are compiled into this
Python interpreter. (This information is not available in any other way —
modules.keys() only lists the imported modules.)

sys.call_tracing(func, args)¶: Call func(*args), while tracing is enabled. The tracing state is saved,
and restored afterwards. This is intended to be called from a debugger from
a checkpoint, to recursively debug some other code.

sys.copyright¶: A string containing the copyright pertaining to the Python interpreter.

sys._clear_type_cache()¶

Clear the internal type cache. The type cache is used to speed up attribute
and method lookups. Use the function only to drop unnecessary references
during reference leak debugging.

This function should be used for internal and specialized purposes only.

sys._current_frames()¶

Return a dictionary mapping each thread’s identifier to the topmost stack frame
currently active in that thread at the time the function is called. Note that
functions in the traceback module can build the call stack given such a
frame.

This is most useful for debugging deadlock: this function does not require the
deadlocked threads’ cooperation, and such threads’ call stacks are frozen for as
long as they remain deadlocked. The frame returned for a non-deadlocked thread
may bear no relationship to that thread’s current activity by the time calling
code examines the frame.

This function should be used for internal and specialized purposes only.

sys._debugmallocstats()¶

Print low-level information to stderr about the state of CPython’s memory
allocator.

If Python is configured –with-pydebug, it also performs some expensive
internal consistency checks.

New in version 3.3.

CPython implementation detail: This function is specific to CPython. The exact output format is not
defined here, and may change.

sys.dllhandle¶: Integer specifying the handle of the Python DLL. Availability: Windows.

sys.displayhook(value)¶

If value is not None, this function prints repr(value) to
sys.stdout, and saves value in builtins._. If repr(value) is
not encodable to sys.stdout.encoding with sys.stdout.errors error
handler (which is probably 'strict'), encode it to
sys.stdout.encoding with 'backslashreplace' error handler.

sys.displayhook is called on the result of evaluating an expression
entered in an interactive Python session. The display of these values can be
customized by assigning another one-argument function to sys.displayhook.

Pseudo-code:

def displayhook(value):
    if value is None:
        return
    # Set '_' to None to avoid recursion
    builtins._ = None
    text = repr(value)
    try:
        sys.stdout.write(text)
    except UnicodeEncodeError:
        bytes = text.encode(sys.stdout.encoding, 'backslashreplace')
        if hasattr(sys.stdout, 'buffer'):
            sys.stdout.buffer.write(bytes)
        else:
            text = bytes.decode(sys.stdout.encoding, 'strict')
            sys.stdout.write(text)
    sys.stdout.write("n")
    builtins._ = value

Changed in version 3.2: Use 'backslashreplace' error handler on UnicodeEncodeError.

sys.dont_write_bytecode¶: If this is true, Python won’t try to write .pyc files on the
import of source modules. This value is initially set to True or
False depending on the -B command line option and the
PYTHONDONTWRITEBYTECODE environment variable, but you can set it
yourself to control bytecode file generation.

sys.excepthook(type, value, traceback)¶

This function prints out a given traceback and exception to sys.stderr.

When an exception is raised and uncaught, the interpreter calls
sys.excepthook with three arguments, the exception class, exception
instance, and a traceback object. In an interactive session this happens just
before control is returned to the prompt; in a Python program this happens just
before the program exits. The handling of such top-level exceptions can be
customized by assigning another three-argument function to sys.excepthook.

sys.__displayhook__¶
sys.__excepthook__¶: These objects contain the original values of displayhook and excepthook
at the start of the program. They are saved so that displayhook and
excepthook can be restored in case they happen to get replaced with broken
objects.

sys.exc_info()¶

This function returns a tuple of three values that give information about the
exception that is currently being handled. The information returned is specific
both to the current thread and to the current stack frame. If the current stack
frame is not handling an exception, the information is taken from the calling
stack frame, or its caller, and so on until a stack frame is found that is
handling an exception. Here, “handling an exception” is defined as “executing
an except clause.” For any stack frame, only information about the exception
being currently handled is accessible.

If no exception is being handled anywhere on the stack, a tuple containing
three None values is returned. Otherwise, the values returned are
(type, value, traceback). Their meaning is: type gets the type of the
exception being handled (a subclass of BaseException); value gets
the exception instance (an instance of the exception type); traceback gets
a traceback object (see the Reference Manual) which encapsulates the call
stack at the point where the exception originally occurred.

sys.exec_prefix¶: A string giving the site-specific directory prefix where the platform-dependent
Python files are installed; by default, this is also '/usr/local'. This can
be set at build time with the --exec-prefix argument to the
configure script. Specifically, all configuration files (e.g. the
pyconfig.h header file) are installed in the directory
exec_prefix/lib/pythonX.Y/config, and shared library modules are
installed in exec_prefix/lib/pythonX.Y/lib-dynload, where X.Y
is the version number of Python, for example 3.2.

Note

If a virtual environment is in effect, this
value will be changed in site.py to point to the virtual environment.
The value for the Python installation will still be available, via
base_exec_prefix.

sys.executable¶: A string giving the absolute path of the executable binary for the Python
interpreter, on systems where this makes sense. If Python is unable to retrieve
the real path to its executable, sys.executable will be an empty string
or None.

sys.exit([arg])¶

Exit from Python. This is implemented by raising the SystemExit
exception, so cleanup actions specified by finally clauses of try
statements are honored, and it is possible to intercept the exit attempt at
an outer level.

The optional argument arg can be an integer giving the exit status
(defaulting to zero), or another type of object. If it is an integer, zero
is considered “successful termination” and any nonzero value is considered
“abnormal termination” by shells and the like. Most systems require it to be
in the range 0–127, and produce undefined results otherwise. Some systems
have a convention for assigning specific meanings to specific exit codes, but
these are generally underdeveloped; Unix programs generally use 2 for command
line syntax errors and 1 for all other kind of errors. If another type of
object is passed, None is equivalent to passing zero, and any other
object is printed to stderr and results in an exit code of 1. In
particular, sys.exit("some error message") is a quick way to exit a
program when an error occurs.

Since exit() ultimately “only” raises an exception, it will only exit
the process when called from the main thread, and the exception is not
intercepted.

Changed in version 3.6: If an error occurs in the cleanup after the Python interpreter
has caught SystemExit (such as an error flushing buffered data
in the standard streams), the exit status is changed to 120.

sys.flags¶

The struct sequence flags exposes the status of command line
flags. The attributes are read only.

attribute	flag
`debug`	`-d`
`inspect`	`-i`
`interactive`	`-i`
`optimize`	`-O` or `-OO`
`dont_write_bytecode`	`-B`
`no_user_site`	`-s`
`no_site`	`-S`
`ignore_environment`	`-E`
`verbose`	`-v`
`bytes_warning`	`-b`
`quiet`	`-q`
`hash_randomization`	`-R`

Changed in version 3.2: Added quiet attribute for the new -q flag.

New in version 3.2.3: The hash_randomization attribute.

Changed in version 3.3: Removed obsolete division_warning attribute.

sys.float_info¶

A struct sequence holding information about the float type. It
contains low level information about the precision and internal
representation. The values correspond to the various floating-point
constants defined in the standard header file float.h for the ‘C’
programming language; see section 5.2.4.2.2 of the 1999 ISO/IEC C standard
[C99], ‘Characteristics of floating types’, for details.

attribute	float.h macro	explanation
`epsilon`	DBL_EPSILON	difference between 1 and the least value greater than 1 that is representable as a float
`dig`	DBL_DIG	maximum number of decimal digits that can be faithfully represented in a float; see below
`mant_dig`	DBL_MANT_DIG	float precision: the number of base-`radix` digits in the significand of a float
`max`	DBL_MAX	maximum representable finite float
`max_exp`	DBL_MAX_EXP	maximum integer e such that `radix**(e-1)` is a representable finite float
`max_10_exp`	DBL_MAX_10_EXP	maximum integer e such that `10**e` is in the range of representable finite floats
`min`	DBL_MIN	minimum positive normalized float
`min_exp`	DBL_MIN_EXP	minimum integer e such that `radix**(e-1)` is a normalized float
`min_10_exp`	DBL_MIN_10_EXP	minimum integer e such that `10**e` is a normalized float
`radix`	FLT_RADIX	radix of exponent representation
`rounds`	FLT_ROUNDS	integer constant representing the rounding mode used for arithmetic operations. This reflects the value of the system FLT_ROUNDS macro at interpreter startup time. See section 5.2.4.2.2 of the C99 standard for an explanation of the possible values and their meanings.

The attribute sys.float_info.dig needs further explanation. If
s is any string representing a decimal number with at most
sys.float_info.dig significant digits, then converting s to a
float and back again will recover a string representing the same decimal
value:

>>> import sys
>>> sys.float_info.dig
15
>>> s = '3.14159265358979'    # decimal string with 15 significant digits
>>> format(float(s), '.15g')  # convert to float and back -> same value
'3.14159265358979'

But for strings with more than sys.float_info.dig significant digits,
this isn’t always true:

>>> s = '9876543211234567'    # 16 significant digits is too many!
>>> format(float(s), '.16g')  # conversion changes value
'9876543211234568'

sys.float_repr_style¶

A string indicating how the repr() function behaves for
floats. If the string has value 'short' then for a finite
float x, repr(x) aims to produce a short string with the
property that float(repr(x)) == x. This is the usual behaviour
in Python 3.1 and later. Otherwise, float_repr_style has value
'legacy' and repr(x) behaves in the same way as it did in
versions of Python prior to 3.1.

New in version 3.1.

sys.getallocatedblocks()¶

Return the number of memory blocks currently allocated by the interpreter,
regardless of their size. This function is mainly useful for tracking
and debugging memory leaks. Because of the interpreter’s internal
caches, the result can vary from call to call; you may have to call
_clear_type_cache() and gc.collect() to get more
predictable results.

If a Python build or implementation cannot reasonably compute this
information, getallocatedblocks() is allowed to return 0 instead.

New in version 3.4.

sys.getcheckinterval()¶

Return the interpreter’s “check interval”; see setcheckinterval().

Deprecated since version 3.2: Use getswitchinterval() instead.

sys.getdefaultencoding()¶: Return the name of the current default string encoding used by the Unicode
implementation.

sys.getdlopenflags()¶: Return the current value of the flags that are used for
dlopen() calls. Symbolic names for the flag values can be
found in the os module (RTLD_xxx constants, e.g.
os.RTLD_LAZY). Availability: Unix.

sys.getfilesystemencoding()¶

Return the name of the encoding used to convert between Unicode
filenames and bytes filenames. For best compatibility, str should be
used for filenames in all cases, although representing filenames as bytes
is also supported. Functions accepting or returning filenames should support
either str or bytes and internally convert to the system’s preferred
representation.

This encoding is always ASCII-compatible.

os.fsencode() and os.fsdecode() should be used to ensure that
the correct encoding and errors mode are used.

On Mac OS X, the encoding is 'utf-8'.
On Unix, the encoding is the locale encoding.
On Windows, the encoding may be 'utf-8' or 'mbcs', depending
on user configuration.

Changed in version 3.2: getfilesystemencoding() result cannot be None anymore.

Changed in version 3.6: Windows is no longer guaranteed to return 'mbcs'. See PEP 529
and _enablelegacywindowsfsencoding() for more information.

sys.getfilesystemencodeerrors()¶

Return the name of the error mode used to convert between Unicode filenames
and bytes filenames. The encoding name is returned from
getfilesystemencoding().

os.fsencode() and os.fsdecode() should be used to ensure that
the correct encoding and errors mode are used.

New in version 3.6.

sys.getrefcount(object)¶: Return the reference count of the object. The count returned is generally one
higher than you might expect, because it includes the (temporary) reference as
an argument to getrefcount().

sys.getrecursionlimit()¶: Return the current value of the recursion limit, the maximum depth of the Python
interpreter stack. This limit prevents infinite recursion from causing an
overflow of the C stack and crashing Python. It can be set by
setrecursionlimit().

sys.getsizeof(object[, default])¶

Return the size of an object in bytes. The object can be any type of
object. All built-in objects will return correct results, but this
does not have to hold true for third-party extensions as it is implementation
specific.

Only the memory consumption directly attributed to the object is
accounted for, not the memory consumption of objects it refers to.

If given, default will be returned if the object does not provide means to
retrieve the size. Otherwise a TypeError will be raised.

getsizeof() calls the object’s __sizeof__ method and adds an
additional garbage collector overhead if the object is managed by the garbage
collector.

See recursive sizeof recipe
for an example of using getsizeof() recursively to find the size of
containers and all their contents.

sys.getswitchinterval()¶

Return the interpreter’s “thread switch interval”; see
setswitchinterval().

New in version 3.2.

sys._getframe([depth])¶

Return a frame object from the call stack. If optional integer depth is
given, return the frame object that many calls below the top of the stack. If
that is deeper than the call stack, ValueError is raised. The default
for depth is zero, returning the frame at the top of the call stack.

CPython implementation detail: This function should be used for internal and specialized purposes only.
It is not guaranteed to exist in all implementations of Python.

sys.getprofile()¶: Get the profiler function as set by setprofile().

sys.gettrace()¶

Get the trace function as set by settrace().

CPython implementation detail: The gettrace() function is intended only for implementing debuggers,
profilers, coverage tools and the like. Its behavior is part of the
implementation platform, rather than part of the language definition, and
thus may not be available in all Python implementations.

sys.getwindowsversion()¶

Return a named tuple describing the Windows version
currently running. The named elements are major, minor,
build, platform, service_pack, service_pack_minor,
service_pack_major, suite_mask, product_type and
platform_version. service_pack contains a string,
platform_version a 3-tuple and all other values are
integers. The components can also be accessed by name, so
sys.getwindowsversion()[0] is equivalent to
sys.getwindowsversion().major. For compatibility with prior
versions, only the first 5 elements are retrievable by indexing.

platform will be 2 (VER_PLATFORM_WIN32_NT).

product_type may be one of the following values:

Constant	Meaning
`1 (VER_NT_WORKSTATION)`	The system is a workstation.
`2 (VER_NT_DOMAIN_CONTROLLER)`	The system is a domain controller.
`3 (VER_NT_SERVER)`	The system is a server, but not a domain controller.

This function wraps the Win32 GetVersionEx() function; see the
Microsoft documentation on OSVERSIONINFOEX() for more information
about these fields.

platform_version returns the accurate major version, minor version and
build number of the current operating system, rather than the version that
is being emulated for the process. It is intended for use in logging rather
than for feature detection.

Availability: Windows.

Changed in version 3.2: Changed to a named tuple and added service_pack_minor,
service_pack_major, suite_mask, and product_type.

Changed in version 3.6: Added platform_version

sys.get_asyncgen_hooks()¶

Returns an asyncgen_hooks object, which is similar to a
namedtuple of the form (firstiter, finalizer),
where firstiter and finalizer are expected to be either None or
functions which take an asynchronous generator iterator as an
argument, and are used to schedule finalization of an asychronous
generator by an event loop.

New in version 3.6: See PEP 525 for more details.

Note

This function has been added on a provisional basis (see PEP 411
for details.)

sys.get_coroutine_wrapper()¶

Returns None, or a wrapper set by set_coroutine_wrapper().

New in version 3.5: See PEP 492 for more details.

Note

This function has been added on a provisional basis (see PEP 411
for details.) Use it only for debugging purposes.

sys.hash_info¶

A struct sequence giving parameters of the numeric hash
implementation. For more details about hashing of numeric types, see
Hashing of numeric types.

attribute	explanation
`width`	width in bits used for hash values
`modulus`	prime modulus P used for numeric hash scheme
`inf`	hash value returned for a positive infinity
`nan`	hash value returned for a nan
`imag`	multiplier used for the imaginary part of a complex number
`algorithm`	name of the algorithm for hashing of str, bytes, and memoryview
`hash_bits`	internal output size of the hash algorithm
`seed_bits`	size of the seed key of the hash algorithm

New in version 3.2.

Changed in version 3.4: Added algorithm, hash_bits and seed_bits

sys.hexversion¶

The version number encoded as a single integer. This is guaranteed to increase
with each version, including proper support for non-production releases. For
example, to test that the Python interpreter is at least version 1.5.2, use:

if sys.hexversion >= 0x010502F0:
    # use some advanced feature
    ...
else:
    # use an alternative implementation or warn the user
    ...

This is called hexversion since it only really looks meaningful when viewed
as the result of passing it to the built-in hex() function. The
struct sequence sys.version_info may be used for a more
human-friendly encoding of the same information.

More details of hexversion can be found at API and ABI Versioning.

sys.implementation¶

An object containing information about the implementation of the
currently running Python interpreter. The following attributes are
required to exist in all Python implementations.

name is the implementation’s identifier, e.g. 'cpython'. The actual
string is defined by the Python implementation, but it is guaranteed to be
lower case.

version is a named tuple, in the same format as
sys.version_info. It represents the version of the Python
implementation. This has a distinct meaning from the specific
version of the Python language to which the currently running
interpreter conforms, which sys.version_info represents. For
example, for PyPy 1.8 sys.implementation.version might be
sys.version_info(1, 8, 0, 'final', 0), whereas sys.version_info
would be sys.version_info(2, 7, 2, 'final', 0). For CPython they
are the same value, since it is the reference implementation.

hexversion is the implementation version in hexadecimal format, like
sys.hexversion.

cache_tag is the tag used by the import machinery in the filenames of
cached modules. By convention, it would be a composite of the
implementation’s name and version, like 'cpython-33'. However, a
Python implementation may use some other value if appropriate. If
cache_tag is set to None, it indicates that module caching should
be disabled.

sys.implementation may contain additional attributes specific to
the Python implementation. These non-standard attributes must start with
an underscore, and are not described here. Regardless of its contents,
sys.implementation will not change during a run of the interpreter,
nor between implementation versions. (It may change between Python
language versions, however.) See PEP 421 for more information.

New in version 3.3.

sys.int_info¶

A struct sequence that holds information about Python’s internal
representation of integers. The attributes are read only.

Attribute	Explanation
`bits_per_digit`	number of bits held in each digit. Python integers are stored internally in base `2**int_info.bits_per_digit`
`sizeof_digit`	size in bytes of the C type used to represent a digit

New in version 3.1.

sys.__interactivehook__¶

When this attribute exists, its value is automatically called (with no
arguments) when the interpreter is launched in interactive mode. This is done after the PYTHONSTARTUP file is
read, so that you can set this hook there. The site module
sets this.

New in version 3.4.

sys.intern(string)¶

Enter string in the table of “interned” strings and return the interned string
– which is string itself or a copy. Interning strings is useful to gain a
little performance on dictionary lookup – if the keys in a dictionary are
interned, and the lookup key is interned, the key comparisons (after hashing)
can be done by a pointer compare instead of a string compare. Normally, the
names used in Python programs are automatically interned, and the dictionaries
used to hold module, class or instance attributes have interned keys.

Interned strings are not immortal; you must keep a reference to the return
value of intern() around to benefit from it.

sys.is_finalizing()¶

Return True if the Python interpreter is
shutting down, False otherwise.

New in version 3.5.

sys.last_type¶

sys.last_value¶

sys.last_traceback¶

These three variables are not always defined; they are set when an exception is
not handled and the interpreter prints an error message and a stack traceback.
Their intended use is to allow an interactive user to import a debugger module
and engage in post-mortem debugging without having to re-execute the command
that caused the error. (Typical use is import pdb; pdb.pm() to enter the
post-mortem debugger; see pdb module for
more information.)

The meaning of the variables is the same as that of the return values from
exc_info() above.

sys.maxsize¶: An integer giving the maximum value a variable of type Py_ssize_t can
take. It’s usually 2**31 - 1 on a 32-bit platform and 2**63 - 1 on a
64-bit platform.

sys.maxunicode¶

An integer giving the value of the largest Unicode code point,
i.e. 1114111 (0x10FFFF in hexadecimal).

Changed in version 3.3: Before PEP 393, sys.maxunicode used to be either 0xFFFF
or 0x10FFFF, depending on the configuration option that specified
whether Unicode characters were stored as UCS-2 or UCS-4.

sys.meta_path¶

A list of meta path finder objects that have their
find_spec() methods called to see if one
of the objects can find the module to be imported. The
find_spec() method is called with at
least the absolute name of the module being imported. If the module to be
imported is contained in a package, then the parent package’s __path__
attribute is passed in as a second argument. The method returns a
module spec, or None if the module cannot be found.

Changed in version 3.4: Module specs were introduced in Python 3.4, by
PEP 451. Earlier versions of Python looked for a method called
find_module().
This is still called as a fallback if a meta_path entry doesn’t
have a find_spec() method.

sys.modules¶: This is a dictionary that maps module names to modules which have already been
loaded. This can be manipulated to force reloading of modules and other tricks.
However, replacing the dictionary will not necessarily work as expected and
deleting essential items from the dictionary may cause Python to fail.

sys.path¶

A list of strings that specifies the search path for modules. Initialized from
the environment variable PYTHONPATH, plus an installation-dependent
default.

As initialized upon program startup, the first item of this list, path[0],
is the directory containing the script that was used to invoke the Python
interpreter. If the script directory is not available (e.g. if the interpreter
is invoked interactively or if the script is read from standard input),
path[0] is the empty string, which directs Python to search modules in the
current directory first. Notice that the script directory is inserted before
the entries inserted as a result of PYTHONPATH.

A program is free to modify this list for its own purposes. Only strings
and bytes should be added to sys.path; all other data types are
ignored during import.

System	`platform` value
Linux	`'linux'`
Windows	`'win32'`
Windows/Cygwin	`'cygwin'`
Mac OS X	`'darwin'`

1. sys.stdin

2. sys.stdout

3. sys.stderr

Перенаправление в файл

Объекты стандартного ввода, вывода и ошибки.

Синтаксис:

Описание:

sys.__stdin__, sys.__stdout__, sys.__stderr__:

Примеры использования sys.stdout, sys.stderr:

Сохранение вывода stdout и/или stderr в файл.

Сохранение stdout и/или stderr в переменную в Python.

Перенаправление вывода stdout и/или stderr при помощи contextlib.redirect_std*().

Пример печати текста в консоль с задержкой.

Сноски

Python print to stderr

Python take input from stdin

Read from stdin in python

Introduction

Basic usage

Standard output

Standard error

Standard input

Dunder properties: sys.__stdin__, sys.__stdout__, sys.__stderr__

fileinput.input() shortcut

Conclusion

References

`sys.stdin`,
`sys.stdout`,
`sys.stderr`:

Примеры использования `sys.stdout`, `sys.stderr`:

Сохранение вывода `stdout` и/или `stderr` в файл.

Сохранение `stdout` и/или `stderr` в переменную в Python.

Перенаправление вывода `stdout` и/или `stderr` при помощи `contextlib.redirect_std*()`.

Dunder properties: sys.stdin, sys.stdout, sys.stderr