Std error python

In this article, we will discuss how you can print to stderr in Python. Stderr is a standard error stream that we use when we want to print error messages. Therefore if you want to output or print error messages, you can print them to stderr. There are many ways you can print to stderr, and we will discuss those methods in this article one after the other.

Using Logging Module

The logging module in Python keeps a log of messages. Further, we can use this module to print to stderr in Python by configuring some settings of the module. To print to stderr using logging module eventually you will need to use some functions of logging module they are as follows:

• ‘logging.basicConfig()’ function, this function takes the format of the message as an input parameter.
• ‘logging.getLogger()’ this function is used for returning objects from logging module.
• ‘log.warning()’ this function takes the warning message text and prints it to the standard output.

However, you need to use these functions in combination with each other to print your desired error message. Let’s understand with the help of an example.

import logging

logging.basicConfig(format = '%(messages)s')
log = logging.getLogger()

log.warning('ERROR!')

Output:

You can also use an alternative way by using the sys module and logging module both and in addition to that by using the ‘print()’ function and setting the parameter in the ‘print()’ function.

import logging
import sys

logging.basicConfig(format = '%(messages)s')
log = logging.getLogger()
print(log, file = sys.stderr)

Print To Stderr Using Sys Module

The sys module provides many functions, and one of them is ‘sys.stderr.write()’, which we can use to print error messages. To print to stderr in Python using the ‘sys.stderr.write()’ function, you have to follow its syntax usage. To understand the syntax and usage of this function, let us see an example.

import sys
sys.stderr.write("ERROR!")

Output:

As you can see, using the sys module to print to standard error is pretty simple and straightforward.

And to learn more about libraries in Python, check this post.

Print To Stderr Using Print() Function

We can also use the ‘print()’ function to print to stderr in Python. Although for printing to standard error using the ‘print()’ function, first we need to set this function’s parameter. To change the parameter, we will use the sys module, which offers many functions. Eventually, we will use sys.stderr to change the parameter of the ‘print()’ function.

Let’s see an example.

import sys
print("ERROR", file = sys.stderr)

Output:

You can also ‘print()’ function to print string variables to stderr in Python. In order to do that, first, you need to assign a variable to a string you want to print to standard error and then print the following variable.

import sys
x = "ERROR MESSAGE"
print(x, file = sys.stderr)

Output:

Further, you can also print a string which you take from user input and print to stderr in Python.

import sys
x = input("Enter the string you want to print to stderr: ")
print(x, file = sys)

Output:

Enter the string you want to print to stderr: ERROR MESSAGE
ERROR MESSAGE

In addition to this, you can also print a variable containing a list to standard error. Let us take an example to furthermore understand how.

import sys
x = ["This", "Is", "Error"]
print(x, file = sys.stderr)

Output:

[“This”, “Is”, “Error”]

Print To Stderr Using Special Function

You can also create a function that prints to standard error. The advantage of creating a special function is that if you want to print to standard error frequently, you will not need to use the ‘print()’ and ‘write()’ functions again and again. Nonetheless, the special function will do that for you. In order to understand better, let us use an example.

import sys

def error(error_message):
   print(error_message, file=sys.stderr)

As you can see in this special function, too, we use the ‘print()’ function and sys module and its corresponding ‘sys.stderr’ function. We call the function to print to stderr in Python. Further, you can also use this function to print strings and lists by calling this function.

Output:

Similarly, we can use this function to print a variable that contains the string. Again let us take an example to understand.

x = "ERROR MESSAGE!"
error(x)

Output:

Further you can also use this function to print a variable that contains list. The function will print that list to stderr in Python.

x = ["ERROR MESSAGE!", "THIS IS EXAMPLE"]
error(x)

Output:

["ERROR MESSAGE!", "THIS IS EXAMPLE"]

And even furthermore, you can use this function to print to stderr in Python the inputs you take from the user. To do the following, you first need to store the input in a variable and then print that variable through the function we have made.

x = input("Enter the message you want to print to stderr: ")
error(x)

Output:

Enter the message you want to print to stderr: ERROR MESSAGE!
ERROR MESSAGE!

Write Stderr To File

We can also write standard errors to a file in Python. In order to do the following, we need to again use the sys module. Firstly we will assign the path of the file to a variable and then use the ‘sys.stderr’ function to open that path and the ‘print()’ function to write the error message or string in that file. Let us see an example of this method.

import sys
 
pathvariable = 'path/to/yourfile.txt'
sys.stderr = open(path, 'w')
print("ERROR MESSAGE")

in the above code, we use the ‘open()’ function and give ‘w’ as a parameter to write in that file.

Exit After Printing To Stderr

Sometimes you might want to exit the program after printing to stderr. In order to do that, you need to import the sys module and use the ‘sys.exit()’ function after printing to stderr in Python. Eventually, let’s understand better with the help of an example.

import sys
print("ERROR", file = sys.stderr)
sys.exit(1)

Although there is also an alternative method you can use to exit the program after printing to stderr in Python.

import sys
print("ERROR MESSAGE", file = sys.stderr)
raise SystemExit(1)

In the latter method, we raise an exception called ‘SystemExit.’ When we raise this exception, the top-level interpreter in the compiler senses this special class exception and follows the exit routine of this exception. If you notice, we have written ‘(1)’ as a parameter in this special class exception. The reason for this is that ‘SystemExit’ takes integers as a parameter for exiting the code. Therefore we use an integer as a parameter to exit the code.

FAQs

Conclusion

To summarize this article, we can say that there are many methods you can use to print to stderr in Python, which includes many functions like ‘write()’, ‘print()’. Furthermore, we have also discussed how we can create our own function to print to stderr in Python. You can use the following functions as per your needs of the code and how your code allows you to use them.

In Python, whenever we use print() the text is written to Python’s sys.stdout, whenever input() is used, it comes from sys.stdin, and whenever exceptions occur it is written to sys.stderr. 

We can redirect the output of our code to a file other than stdout. But you may be wondering why one should do this? The reason can be to keep a log of your code’s output or to make your code shut up i.e. not sending any output to the stdout. Let’s see how to do it with the below examples.

 What is Python stderr?

This file handle receives error information from the user program. The Standard error returns errors stderr. we will see different examples of using stderr.

Method 1: Using Python stderr

It is comparable to stdout in that it likewise prints straight to the console, but the key distinction is that it prints only Exceptions and Error messages which is why it is called Standard Error in Python.

Output:

Method 2:  Using Python sys.stderr.write() function

When used in interactive mode, sys.stderr.write() accomplishes the same task as the object it stands for, with the exception that it also prints the text’s letter count.

Output:

Method 3: Using Python logging.warning  function

A built-in Python package tool called logging.warning enables publishing status messages to files or other output streams. The file may provide details about which portion of the code is run and any issues that have come up.

Output:

Error: Hello World
GeeksforGeeks

What is Python stdout?

This file handle receives regular information from the user program. The output is made available through the standard output stdout from sys module.

Method 1: Using Python  sys.stdout method

stdout in Python is similar to sys.stdin, but it directly displays anything written to it to the Console.

Output:

Method 2: Using Python print() function

Python print() function prints the message to the screen or any other standard output device. In the print() function, it requires an empty parenthesis at the end that tells Python to execute the function rather than calling it by name. 

Output:

Hello GeeksforGeeks

Method 3: Using Python sys.stdout.write() function

The sys.stdout.write() serves the same purpose as the object stands for except it prints the number of letters within the text too when used in interactive mode

Output:

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

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()

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 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 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.

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.

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.

The standard error or stderr is used to output errors and error messages in Linux systems. It is especially used in the bash shell to redirect errors and separate the errors from informational messages. Python provides different methods in order to print specific messages into the stderr. The most popular and easy way is using the print() method and provides the stderr as the output.

Print Standard Output or stdout with print() Method

First, start with a standard example where we will print to the standard output. Actually, the print() method prints the given data into the standard output or stdout.

print("This is standard output")

Even the print() method redirects or prints to the standard output or stdout we can also explicitly specify the standard output or stdout with the file parameter of the print() method.

import sys

print("This is standard output",file=sys.stdout)

Print Standard Error or stderr with print() Method

The print() method can be used to standard error or stderr. The file parameter should be set with the sys.stderr which is provided via the sys module. In the following examples, we will print the given string value or string variable into the stderr.

import sys

#Print string value to stderr
print("This is standard error",file=sys.stderr)

#Print string variable to stderr
errmessage = "This is standard error"
print(errmessage ,file=sys.stderr)

#Print list variable to stderr
errmessage = ["Error","Number",123]
print(errmessage ,file=sys.stderr)

The biggest advantage of using the print() method to print into standard error or stderr the print() method can convert provided data into the string. The data can be an integer, list, tuple, etc.

Print Standard Error or stderr with sys.write() Method

Python also provides the sys.stderr.write() method which can be used to print into the standard error or stderr. The write() method is less flexible than print() method in order to print into stderr because the write() method does not converts provided data automatically into the string type. So the provided data should be string type if not it should be converted properly. Also, the write() does not add a new line at the end of the data automatically. If we need the end of the line should be added explicitly with the “n” characters.

import sys

#Print string value to stderr
sys.stderr.write("This is standard errorn")


#Print string variable to stderr
errmessage = "This is standard errorn"
sys.stderr.write(errmessage)

Create Special Print Function To Print Standard Error or stderr

If we will print messages and data into the stderr frequently and do not want to write related print() or write() method again and again with parameters we can create a special function which will use the print() or write() method in order to print into stderr. The special Error Printing Function named as print_err() but you can change it into whatever you want.

import sys

def print_err(err_message):
   print(err_message,file=sys.stderr)


#Print string value to stderr
print_err("This is standard error")


#Print string variable to stderr
errmessage = "This is standard error"
print_err(errmessage)


#Print list variable to stderr
errmessage = ["Error","Number",123]
print_err(errmessage)

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

Синтаксис:

import sys

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*().

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!!

Сноски

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