Io unsupportedoperation not writable python ошибка

The write operation comes under file handling in Python. File handling is an integral part of Python. It includes performing various file-related operations. One of the most commonly used are the read and write operations, and one of the most widely occuring errors is the ‘io.unsupportedoperation: not writable’ error.

Many things can cause an error in Python, but one of the most common errors that Python programmers face is an IO operation (input/output) that is not supported.

Have you ever wondered what will happen in case you write to a file opened in read mode? Well, the title explains it well. Let us understand the ‘io.unsupportedoperation: not writable’ error in detail. In this article, we will go over the different ways to fix this error and why it happens.

What are IO operations?

In Python, io.supported_operations is a dictionary of the supported operations for each I/O operation.

The difference between these two operations is that I/O is used to read or write data from or to a file, while supported_operations indicates whether or not an operation is supported by the interpreter.

Also, IO operations are used to read and write data from a file or device. They are supported only for files. This statement means that if you want to read from or write to some other destination, you will need to use other methods.

These operations can be classified as text I/O, binary I/O, and raw I/O. There is a device error, also. Due to this, windows are not allowed to perform any read or write operation and extract data.

Understanding the io.unsupportedoperation: not writable error

When we don’t specify any mode, the file opens in read mode by default. Now, look at the following piece of code:

with open('pythonfile.txt', 'r') as f:
    f.write('FIRST WORD')

Here, a programmer has opened file in read mode. In the next statement, he is trying to write a string to the file. This will result in the given error i.e. IO unsupported error.

Also, this can happen if you have a directory in your path that has spaces in it, or if you try to write to an existing file.

See also: [Solved] ValueError: I/O operation on closed file. (Opens in a new browser tab)

Solution of the io.unsupportedoperation: not writable error

In order to solve the error, you need to change the mode or read the file only. The mode can be changed into either write or append. The write mode deletes previously added data while append mode will add the string to the location where end of line character is present. Corrected code will look like this:

with open('pythonfile.txt', 'a') as f:
    f.write('FIRST WORD')

Otherwise we can perform read and write together using r+b mode. utf-8 implies encoding the byte since you want to open file in binary mode.

with open('pythonfile.txt', 'r+b') as f:
    f.write(bytes('FIRST WORD', 'utf-8'))

The simplest way to fix an IO operation that isn’t supported is simply by using another method of input or output: print(“hello world”) or io.open(“/etc/passwd”, “r”).read().

However, this isn’t always ideal: if your code relies on input being available through the open() call and it fails, then it’s going to fail at runtime too! The best way to handle these situations is by checking whether your function supports IO operations before trying to use them. The easiest way to do this is via a try/except block: try: print(“hello world”) except NotSupportedError as e: print(“error”, e)

To sum it up, this error occurs when trying to write a file in the directory without having permission. The solution is simple: either add the necessary permission or change the directory name.

io.unsupportedoperation with json files

In case you are encountering the same error in a json file, the reason is the same. By default, open() method will open file in read mode. Hence, you need to change it to write mode to fix the error. Example:

#with error
with open("myfile.txt") as jsonfile:
        json.dump(hero, jsonfile)

Initially, no mode was given so it couldn’t write. Now,after altering the code will become error free.

#without error
with open("myfile.txt", "w") as jsonfile:
    json.dump(hero, jsonfile)

Python’s writable method for file handling

IObase class contains writable function in Python. It gives TRUE or FALSE output showing whether the file is writable or not. Example:

a = open("abc.txt", "r")
print(a.writable())
b = open("abc.txt", "a+")
print(b.writable())

So the output will be:

FALSETRUE
#because opening the file in write or append mode will only make it writable. #otherwise we will get the ans as FALSE

io.unsupportedoperation with try and except block

You can also throw an exception yourself using try-except block in Python. The io module consists of this file handling error. So with the help of this module you can raise this exception. Follow the given code to get an understanding.

import io
try:
    with open("myfile.txt", "w") as f:
        print(f.read())
except io.UnsupportedOperation as e:
    print(e)

Use the I/O tool to see if the data is writeable. This will let you know whether or not it can be written to. Or you can check that your data is comma-separated values (CSV) and not a fixed-width file (like a text file) by using I/O again and seeing if it says “UTF-8 encoded string.”

io.unsupportedoperation: not writable yaml dump

It seems that your yaml dump is not writable, which means it’s not a valid YAML dump. io.unsupportedoperation: not writable yaml dump. Also, the io.unsupportedoperation error occurs when you try to write a yaml dump file, but you’re not running in the correct environment and/or you don’t have the necessary permissions.

To fix this problem, please run the following command: sudo shutdown -h now

You can also try changing the working directory of your YAML dump file from /tmp/yaml_dump to your home directory. This is done by using the chmod command with no arguments. If that doesn’t work, try using sudo to run your command as root or using su to become root. You can do this by adding a sudo prefix before any commands that need root privileges.

See Also: [Fixed] “io.unsupportedoperation not readable” error

FAQs

Conclusion

We discussed the meaning of IO operations in Python and their classifications. You must have learned how to fix the io.unsupportedoperation: not writable error. Apart from this, we have discussed the alternatives you can approach to make the code error free while handling files in Python and using writable keywords while performing file-handling operations.

1. Fix the io.UnsupportedOperation: not writable Error in Python
2. Conclusion

Python is very efficient in reading and writing data from files. It has a variety of functions to help in file handling.

The basics of file handling involve opening a file using the open() function and reading or writing data based on the file mode.

The open() opens a given file and creates a file object that can be used to perform reading and writing operations on a file.

The file can be opened in different types of modes. By default, it opens the file in read mode.

This tutorial will discuss the io.UnsupportedOperation: not writable error in Python and ways to fix it.

Fix the io.UnsupportedOperation: not writable Error in Python

This error is caused when we try to perform the write operation on a file opened in reading mode. A file opened in read mode can only read the contents.

For example:

with open('sample.txt', 'r') as f:
    f.write('Text')

Output:

io.UnsupportedOperation: not writable

Note that in the above example, we open the file in r mode (read) and try to write some data to this file using the write() function, which causes the error.

Remember to open the file in modes that support this operation to solve this. The write (w) or append (a) modes are used to write some data to a file.

The previous contents are truncated if we open the file in w mode. The a mode adds content to the end of the file and preserves the previous data.

For example:

with open('sample.txt', 'w') as f:
    f.write('Text')

In the above example, we successfully avoid errors and can write data to the file.

If we want to simultaneously read and write data from a file, we can use the r+b mode. We can perform reading and writing operations in binary mode when the file is opened in this mode.

For example:

with open('sample.txt', 'r+b') as f:
    f.write(bytes('Text', 'utf-8'))

Note that we write data as bytes since the file is opened in binary mode. The text is encoded as bytes in the utf-8 encoding in the above example.

Alternatively, we can also use the writable() function to check whether we can perform writing operations using the file handle or not. It returns True or False.

See the code below.

with open('sample.txt', 'r') as f:
    print(f.writable())

with open('sample.txt', 'a') as f:
    print(f.writable())

Output:

The above example shows that the writable function returns False when the file is opened in r mode and returns True when the file is opened in a mode.

Conclusion

To conclude, we discussed the cause behind the io.UnsupportedOperation: not writable error and how to fix it. We discussed how opening the file in the wrong mode can cause this and what file modes support writing operations.

We also demonstrated the use of the writable function that can be used to check whether a file object can perform writing operations or not.