I o operation on closed file python ошибка

The i/o operations in Python are performed when the file is in an open state. So if we are trying to read or write into a file that is already closed state Python interpreter will raise the ValueError: I/O operation on closed file.

In this article, we will look at what is ValueError: I/O operation on closed file and how to resolve this error with examples.

The best practice during file operations is to close the file as soon as we perform the operations with the file. It helps to free the resources such as memory and computing and also helps improve the overall performance. Once the file is closed, you can no longer access the file and perform read/write operations on that file.

There are three main common reasons why we face the ValueError: I/O operation on closed file.

• First, when you try, forget to indent the code in the with statement.
• Second, when you try to read/write to a file in a closed state.
• Third, when you close the file inside a for loop, accidentally

Let us look at an example where we can reproduce the issue.

Scenario 1 – Improper Indentation

We have a simple code to read the CSV file, which consists of employee data. First, we have imported the CSV library, and then we used a with statement to open the CSV file in a read mode,

Once the file is opened, we call the method csv.reader() to read the file contents and assign the contents into the read_csv variable.

Later, using the for loop, we iterated the file contents and printed each file row.

Let us run this code and see what happens.

import csv

# Open the file in read mode
with open("employee.csv", "r") as employees:
    read_csv = csv.reader(employees)

# iterate and print the rows of csv
for row in read_csv:
    print("Rows: ", row)

Traceback (most recent call last):
  File "c:PersonalIJSCodeprgm.py", line 8, in <module>
    for row in read_csv:
ValueError: I/O operation on closed file.

Solution

The above code has returned ValueError because we tried to iterate the read_csv outside the with statement. The with statement acts as a file context, and once it’s executed, it will automatically close the file. Hence any file operation outside the with statement will lead to this error.

We can resolve the code by properly indenting our code and placing it inside the with statement context. But, first, let us look at the revised code.

import csv

# Open the file in read mode
with open("employee.csv", "r") as employees:
    read_csv = csv.reader(employees)

    # iterate and print the rows of csv
    for row in read_csv:
        print("Rows: ", row)

Output

Rows:  ['EmpID', 'Name', 'Age']
Rows:  ['1', 'Chandler Bing', ' 22']
Rows:  ['2', 'Jack', '21']
Rows:  ['3', 'Monica', '33']

Scenario 2 – Accessing the closed file

It is the most common and best practice to use with statements for accessing the files. We can also access the file without using the with statement by just using the open() method as shown below.

Once the file is open, using the csv.reader() method we have read the contents of the file and assigned it to a variable read_csv.

Then, we closed the file as the contents are read and stored to a variable. Next, we iterate the read_csv variable using a for loop and print each row of the CSV file.

Let us execute the code and see what happens.

import csv

# open file in read mode
employees = open("employee.csv", "r")
read_csv = csv.reader(employees)
employees.close()

# iterate and print the eac row
for row in read_csv:
    print("Rows: ", row)

Output

Traceback (most recent call last):
  File "c:PersonalIJSCodeprgm.py", line 9, in <module>
    for row in read_csv:
ValueError: I/O operation 

Solution

The fix here is straightforward; we need to ensure that the file is closed after the for loop. The read_csv file holds a reference of the file object, and if we close the file, it will not be able to access the file and perform any I/O operations.

Let us fix the issue and execute the code.

import csv

# open file in read mode
employees = open("employee.csv", "r")
read_csv = csv.reader(employees)

# iterate and print the eac row
for row in read_csv:
    print("Rows: ", row)

# close the file after iteraating and printing
employees.close()

Output

Rows:  ['EmpID', 'Name', 'Age']
Rows:  ['1', 'Chandler Bing', ' 22']
Rows:  ['2', 'Jack', '21']
Rows:  ['3', 'Monica', '33']

Scenario 3 – Closing the file inside a for loop

There could be another scenario where we do not correctly indent the code, which can lead to this issue.

For example, in the below code, we are opening the file and reading the file contents using csv.reader() method.

Next, using the for loop, we are iterating the CSV rows and printing each row. We have placed the file close() method inside the for loop accidentally, which will lead to an issue.

The loop executes and prints the first record successfully, and after that, it will close the file, and it won’t be able to access any other rows in the CSV.

import csv

# open file in read mode
employees = open("employee.csv", "r")
read_csv = csv.reader(employees)

# iterate and print the eac row
for row in read_csv:
    print("Rows: ", row)
    employees.close()

Output

Rows:  ['EmpID', 'Name', 'Age']
Traceback (most recent call last):
  File "c:PersonalIJSCodeprgm.py", line 8, in <module>
    for row in read_csv:
ValueError: I/O operation on closed file.

Solution

We can resolve the issue by placing the close() statement outside the for loop. This will ensure that file contents are iterated and printed correctly, and after that, the file is closed.

Let us revise our code and execute it.

import csv

# open file in read mode
employees = open("employee.csv", "r")
read_csv = csv.reader(employees)

# iterate and print the eac row
for row in read_csv:
    print("Rows: ", row)

employees.close()

Output

Rows:  ['EmpID', 'Name', 'Age']
Rows:  ['1', 'Chandler Bing', ' 22']
Rows:  ['2', 'Jack', '21']
Rows:  ['3', 'Monica', '33']

Conclusion

The ValueError: I/O operation on closed file occurs if we are trying to perform the read or write operations on the file when it’s already in a closed state.

We can resolve the error by ensuring that read and write operations are performed when the file is open. If we use the with statement to open the file, we must ensure the code is indented correctly. Once the with statement is executed, the file is closed automatically. Hence any I/O operation performed outside the with statement will lead to a ValueError.

If you try to access a closed file, you will raise the ValueError: I/O operation on closed file. I/O means Input/Output and refers to the read and write operations in Python.

To solve this error, ensure you put all writing operations before closing the file.

This tutorial will go through how to solve this error with code examples.

ValueError: I/O operation on closed file

In Python, a value is information stored within a particular object. You will encounter a ValueError in Python when you use a built-in operation or function that receives an argument with the right type but an inappropriate value.

A file is suitable for I/O operations, but a closed file is not suitable for I/O operations.

Why Close Files in Python?

• File operations is a resource in programming. If you have multiple files open, you are using more resources, which will impact performance.
• If you are making editions to files, they often do not go into effect until after the file is closed.
• Windows treats open files as locked; you will not be able to access an open file with another Python script.

Let’s look at examples of the ValueError occurring in code and solve it.

Example #1: Accessing a Closed File

Consider the following CSV file called particles.csv that contains the name, charge and mass of three particles:

electron,-1, 0.511
muon,-1,105.7
tau,-1,1776.9

Next, we will write a program that will read the information from the CSV file and print it to the console. We will import the csv library to read the CSV file. Let’s look at the code:

import csv

particles = open("particles.csv", "r")

read_file = csv.reader(particles)

particles.close()

for p in read_file:

    print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

We create a TextIOWrapper object called particles. This object is a buffered text stream containing the file’s text. We then access each line in particles using a for loop. Let’s run the code to see what happens:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
      7 particles.close()
      8 
----≻ 9 for p in read_file:
     10 
     11     print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

ValueError: I/O operation on closed file.

The error occurs because we close the file before we iterate over it.

Solution

To solve this error, we need to place the close() after the for loop. Let’s look at the revised code:

import csv

particles = open("particles.csv", "r")

read_file = csv.reader(particles)

for p in read_file:

    print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

particles.close()

Particle: electron, Charge: -1, Mass:  0.511 MeV
Particle: muon, Charge: -1, Mass: 105.7 MeV
Particle: tau, Charge: -1, Mass: 1776.9 MeV

The code successfully prints the particle information to the console.

Example #2: Placing Writing Outside of with Statment

The best practice to open a file is to use a with keyword. This pattern is also known as a context manager, which facilitates the proper handling of resources. Let’s look at an example of using the with keyword to open our particles.csv file:

import csv

with open("particles.csv", "r") as particles:

    read_file = csv.reader(particles)

for p in read_file:

    print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

Let’s run the code to see what happens:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
      5     read_file = csv.reader(particles)
      6 
----≻ 7 for p in read_file:
      8 
      9     print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

ValueError: I/O operation on closed file.

The error occurs because the loop over the file is outside of the with open() statement. Once we place code outside of with statement code block, the file closes. Therefore the for loop is over a closed file.

Solution

We need to place the for loop within the with statement to solve this error. Let’s look at the revised code:

import csv

with open("particles.csv", "r") as particles:

    read_file = csv.reader(particles)

    for p in read_file:

        print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')


Let’s run the code to see the result:

Particle: electron, Charge: -1, Mass:  0.511 MeV
Particle: muon, Charge: -1, Mass: 105.7 MeV
Particle: tau, Charge: -1, Mass: 1776.9 MeV

The code successfully prints the particle information to the console. For further reading on ensuring correct indentation in Python, go to the article: How to Solve Python IndentationError: unindent does not match any outer indentation level.

Example #3: Closing the File Within a for loop

Let’s look at an example where we open the file and print the file’s contents, but we put a close() statement in the for loop.

import csv

particles = open("particles.csv", "r")

read_file = csv.reader(particles)

for p in read_file:

    print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

    particles.close()

Let’s run the code to see what happens:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
      5 read_file = csv.reader(particles)
      6 
----≻ 7 for p in read_file:
      8 
      9     print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

ValueError: I/O operation on closed file.

The error occurs because we close the file before iterating over every line in the file. The first iteration closes the file.

Solution

To solve this error, we need to place the close() statement outside of the for loop. Let’s run the code to get the result:

import csv

particles = open("particles.csv", "r")

read_file = csv.reader(particles)

for p in read_file:

    print(f'Particle: {p[0]}, Charge: {p[1]}, Mass: {p[2]} MeV')

particles.close()

Let’s run the code to see the result:

Particle: electron, Charge: -1, Mass:  0.511 MeV
Particle: muon, Charge: -1, Mass: 105.7 MeV
Particle: tau, Charge: -1, Mass: 1776.9 MeV

The code successfully prints the particle information to the console.

Summary

Congratulations on reading to the end of this tutorial! The error ValueError: I/O operation on a closed file occurs when you try to access a closed file during an I/O operation. To solve this error, ensure that you indent the code that follows if you are using the with statement. Also, only close the file after you have completed all iterations in a for loop by placing the filename.close() outside of the loop.

For further reading on ValueErrors, go to the article: How to Solve Python ValueError: could not convert string to float.

For further reading on errors involving reading or writing to files in Python, go to the article: How to Solve Python AttributeError: ‘str’ object has no attribute ‘write’

To learn more about Python for data science and machine learning, go to the online courses page on Python for the most comprehensive courses available.

Have fun and happy researching!

The “ValueError: I/O operation on closed file” error in Python is a common error related to the file i/o operation. You can read the explanations below to have more knowledge about this error including cause and solutions.

How does the “ValueError: I/O operation on closed file” error in Python happen?

This error happens due to the many following reasons:

Firstly, it might be because you are working on a closed file. If a file is open, you might not get the error. But if the file is closed and you are trying to write or read that file, you will get this error. For example:

with open("file0", "w") as file0:
    if file0.closed:
        print("File closed")
    else: 
        print("File not closed")

print("Out of with statement:")        

if file0.closed:
    print("File closed")
else: 
    print("File not closed")

file0.write("You cannot write to file after closed")

Secondly, after working with long lines of code, you make the mistake of reading two files but assigning the same name to the two file handles, such as in the below example. Attention to the nested “with open” statement.

with open("file0", "w") as f:
    f.write("Write to file0")
    with open("file1", "w") as f:
        f.write("Write to file1")

    f.write("Cannot write to file0 because it is closed")

How to solve the error?

Solution 1: Checking indent of coding

This error often occurs when the coder type a wrong code and cannot indent code correctly, resulting in the system automatically closing the file. Hence, they cannot do any I/O operation on that file. To solve it, you should recheck your indent of the write or read commands to ensure it is inside the with statement.

with open("file0", "w") as file0:
    file0.write("Writing in the with statement")

Another way to avoid this error is to have an if statement to check if the file is closed before we try any I/O operations. For instance:

with open("file0", "w") as file0:
    if file0.closed is False:
        file0.write("Writing in the with statement")

print("Out of with statement:")        

if file0.closed is False:
    file0.write("You cannot write to file after closed")

Solution 2: Handling two files with different names

Remember that in Python, you can redeclare a variable with an already name. This would lead to some of your file handles being possible to have the same names. However, we do not recommend this as it is difficult to manage and use. Instead, you should have a different name for each file handle, such as:

with open("file0", "w") as f:
    f.write("Write to file0")
    with open("file1", "w") as f1:
        f1.write("Write to file1")
        
    f.write("The file0 is still open, so you can write to it") 

As we have recommended in the first solution, you should have an if statement to make sure the file is opening before approaching it:

with open("file0", "w") as f:
    f.write("Write to file0")
    with open("file1", "w") as f1:
        if f1.closed is False:
            f1.write("Write to file1")

if f.closed is False: f.write("Cannot write to file0 because it is closed") 

Summary

We have learned how to deal with the “ValueError: I/O operation on closed file” error in Python. By checking the indent of the statements and changing names for different file handles as guided in our tutorial, you can easily solve it.

Maybe you are interested:

• ValueError: invalid literal for int() with base 10 in Python
• ValueError: object too deep for desired array

You can only read from and write to a Python file if the file is open. If you try to access or manipulate a file that has been closed, the “ValueError : I/O operation on closed file” appears in your code.

In this guide, we talk about what this error means and why it is raised. We walk through two examples of this error so you can learn how to solve it.

ValueError : I/O operation on closed file

It has become good practice in Python to close a file as soon as you have finished working with the file. This helps you clean up your code in the Python interpreter. Once a file has been closed in a Python program, you can no longer read from or write to that file directly.

There are two common scenarios where the “ValueError : I/O operation on closed file” is encountered:

• When you forget to indent your code correctly in a “with” statement
• When you try to read a file after it has been closed using the close() statement

Let’s walk through each of these scenarios and discuss them in detail.

Cause #1: Improper Indentation

Let’s write a program that reads a list of student grades from a CSV file. Our CSV file is called students.csv. It currently stores the following data:

Andrew,73,84,92
Linda,76,77,72
Samantha,64,63,75

To start, we import the csv library in our code so we can read our CSV file. We then use a with statement to open our file:

import csv

with open("students.csv", "r") as students:
	read_file = csv.reader(students)

This code opens the file “students.csv” in read (“r”) mode. We assign the contents of the file to the variable “read_file”.

Let’s print each student’s record to the console:

for s in read_file:
		 print("Name: " + s[0])
		 print("Test 1 Score: " + s[1])
		 print("Test 2 Score: " + s[2])
		 print("Unit Assessment Score: " + s[3])

We use a “for” loop to iterate over every item in the “read_file” variable. This variable stores our CSV file in a list. Next, we use indexing to access each value from each student record. We print each of these values to the console.

Run our code:

Traceback (most recent call last):
  File "main.py", line 6, in <module>
	for s in read_file:
ValueError: I/O operation on closed file.

Our code returns an error. This is because we’ve tried to iterate over “read_file” outside of our with statement. The “read_file” variable can only read inside the with statement. After the with statement is executed, the file is closed.

To solve this problem, we need to indent our for loop so that it is within our with statement:

import csv

with open("students.csv", "r") as students:
	read_file = csv.reader(students)

	for s in range(1, read_file):
			 print("Name: " + s[0])
			 print("Test 1 Score: " + s[1])
			 print("Test 2 Score: " + s[2])
			 print("Unit Assessment Score: " + s[3])

Run this revised code:

Name: Andrew
Test 1 Score: 73
Test 2 Score: 84
Unit Assessment Score: 92
Name: Linda
Test 1 Score: 76
Test 2 Score: 77
Unit Assessment Score: 72
Name: Samantha
Test 1 Score: 64
Test 2 Score: 63
Unit Assessment Score: 75

Our code successfully executes.

Cause #2: Accessing a Closed File

While with statements are the most common way of accessing a file, you can use an open() statement without a with statement to access a file.

Read the contents of our “students.csv” file:

students = open("students.csv", "r")
read_file = csv.reader(students)
students.close()

We use the open() method to open the “students.csv” file in read mode. We then use the csv.reader() method to read our CSV file. We then close our file because we have read its contents into a variable.

Next, print each record from our file to the console using a for loop:

for s in read_file:
		 print("Name: " + s[0])
		 print("Test 1 Score: " + s[1])
		 print("Test 2 Score: " + s[2])
		 print("Unit Assessment Score: " + s[3])

This for loop is the same as the one from our last example. The loop prints out all the information about each record in our CSV file. Let’s test out our code:

Traceback (most recent call last):
  File "main.py", line 7, in <module>
	for s in read_file:
ValueError: I/O operation on closed file.

Our code raises an error. This is because we try to iterate over “read_file” after we have closed our file. To solve this error, we should close our file after we have iterated over “read_file”:

students = open("students.csv", "r")
read_file = csv.reader(students)

for s in read_file:
		 print("Name: " + s[0])
		 print("Test 1 Score: " + s[1])
		 print("Test 2 Score: " + s[2])
		 print("Unit Assessment Score: " + s[3])

students.close()

Let’s run our code again:

Name: Andrew
Test 1 Score: 73
Test 2 Score: 84
Unit Assessment Score: 92
Name: Linda
Test 1 Score: 76
Test 2 Score: 77
Unit Assessment Score: 72
Name: Samantha
Test 1 Score: 64
Test 2 Score: 63
Unit Assessment Score: 75

Our code executes successfully. The values in “read_file” are accessible until we close our file. Because we’ve used our for loop before our close() statement, our code executes without an error. Once we print each student record to the console, we close our file.

Conclusion

The “ValueError : I/O operation on closed file” error is raised when you try to read from or write to a file that has been closed.

If you are using a with statement, check to make sure that your code is properly indented. If you are not using a with statement, make sure that you do not close your file before you read its contents.

Now you’re ready to solve this error like a Python expert!

1. Solve the ValueError: I/O operation on closed file Due to Improper Indentation in Python
2. Solve the ValueError: I/O operation on closed file Due to Closing File Inside the for Loop in Python
3. Solve the ValueError: I/O operation on closed file Due to Performing a Write Operation on a Closed File
4. Conclusion

Resource management is an important factor in programming. But often, programmers unknowingly leave a memory block open, which can cause memory overflows.

This article, however, looks upon an error in Python: ValueError: I/O operation on closed file. This happens when the programmer tries to perform operations on a file that gets somehow closed in between operations.

There are mainly three cases where the ValueError: I/O operation on closed file can occur:

Solve the ValueError: I/O operation on closed file Due to Improper Indentation in Python

Suppose a programmer has a .csv file that she tries to load into the memory using a Python compiler. In Python, an object variable must be created to load the file’s contents to read or write on a file.

Let’s understand this through the below program:

import csv

# Open the file in Read mode
with open("sample_submission.csv", "r") as employees:
    read_csv = csv.reader(employees)

This program imports the library package csv to read .csv files. In the second line of code, the program uses the with statement to create an exception handling block and stores the .csv file, sample_submission.csv, inside object employees as a readable entity by using the keyword r.

We need to allocate some memory to read the entity employees'. Line 3 of the code allocates a memory block to read_csvto store the contents fromemployees`.

If the programmer wants to display the rows from the .csv file, she needs to print the rows from the object read_csv inside a for loop, just like in the code below:

import csv

# Open the file in Read mode
with open("sample_submission.csv", "r") as employees:
    read_csv = csv.reader(employees)

# iterate and print the rows of csv
for row in read_csv:
    print("Rows: ", row)

But when the programmer tries to compile this piece of code, she receives an error:

"C:UsersWin 10main.py"
Traceback (most recent call last):
  File "C:UsersWin 10main.py", line 8, in <module>
    for row in read_csv:
ValueError: I/O operation on closed file.

Process finished with exit code 1

The ValueError: I/O operation on closed file happened because of the exception handling statement with. As said earlier, the with statement creates an exception handling block, and any operation initiated inside will terminate as soon as the compiler gets out of this block.

In the above program, an indention mistake caused the error. Python compilers do not use a semi-colon to identify the end of a line; instead, it uses space.

In the code, the for loop was created outside the with block, thus closing the file. Even though the for loop was written just below with, improper indention made the compiler think that the for loop is outside the with block.

A solution to this problem is identifying the proper indents like the following:

import csv

with open("sample_submission.csv", "r") as employees:
    read_csv = csv.reader(employees)

    # for loop is now inside the with block
    for row in read_csv:
        print("Rows: ", row)

Output:

"C:UsersWin 10main.py"
Rows:  ['Employee ID', 'Burn Rate']
Rows:  ['fffe32003000360033003200', '0.16']
Rows:  ['fffe3700360033003500', '0.36']
Rows:  ['fffe31003300320037003900', '0.49']
Rows:  ['fffe32003400380032003900', '0.2']
Rows:  ['fffe31003900340031003600', '0.52']

Process finished with exit code 0

Solve the ValueError: I/O operation on closed file Due to Closing File Inside the for Loop in Python

This example shows how the ValueError: I/O operation on closed file can occur without using the with statement. When a Python script opens a file and writes something on it inside a loop, it must be closed at the end of the program.

But the ValueError: I/O operation on closed file can arise due to an explicit file closing inside the loop. As explained above, the with block closes whatever has been initiated inside it.

But in cases where for loops, etc., have been used, the ValueError: I/O operation on closed file occurs when the file gets closed midway in the loop. Let’s see how this happens through the program below:

a = 0
b = open("sample.txt", "r")
c = 5

f = open("out"+str(c)+".txt", "w")
for line in b:
    a += 1
    f.writelines(line)
    if a == c:
        a = 0
    f.close()
f.close()

The above code reads contents from the file sample.txt and then writes those contents in a new file with the name out(value of c).txt.

The variable b is loaded with the sample.txt file, while the variable f is used to write on a new file. The for loop runs for the number of lines inside the file loaded inside b.

Each iteration increases a, while at the iteration when a=5, the value of a is reset to zero.

After completing the process, f.close() is used twice. The first f.close clears f, while the second one clears b.

But the program had to run more iterations before the file got closed. When the program is compiled, it gives the following output:

"C:UsersWin 10main.py"
Traceback (most recent call last):
  File "C:UsersWin 10main.py", line 8, in <module>
    f.writelines(line)
ValueError: I/O operation on closed file.

Process finished with exit code 1

This happens because the file is closed inside the for loop, which makes it unable to read the file for subsequent iterations.

As this error is caused accidentally, solving it requires going back to the code and rechecking where the file gets closed. If it is a for loop, then a file should be closed outside the indent of the loop, which allows the loop to complete all its iterations, and then release the memory.

a = 0
b = open("sample.txt", "r")
c = 5

f = open("out"+str(c)+".txt", "w")
for line in b:
    a += 1
    f.writelines(line)
    if a == c:
        a = 0

f.close()

Here, the file is closed outside the for loop’s indent, so the compiler closes the file after completing all the iterations.

When the code is compiled, it throws no errors while creating a file named out5.txt:

"C:UsersWin 10main.py"

Process finished with exit code 0

Solve the ValueError: I/O operation on closed file Due to Performing a Write Operation on a Closed File

This is a case scenario where the programmer gives written instructions to a file that has been closed before, and compiling it produces the ValueError: I/O operation on closed file error.

Let’s look at an example:

with open("gh.txt", 'w') as b:
    b.write("Applen")
    b.write("Orange n")
    b.write("Guava n")
    b.close()
    b.write("grapes")

The program loads a .txt file as object b. Then this object variable b is used to perform write operations inside the .txt file.

When this code is compiled, the ValueError: I/O operation on closed file occurs.

"C:UsersWin 10main.py"
Traceback (most recent call last):
  File "C:UsersWin 10main.py", line 6, in <module>
    b.write("grapes")
ValueError: I/O operation on closed file.

Process finished with exit code 1

This was caused by the b.close() statement, which was written over a written statement. The compiler does not let the file be written anymore, even inside the with block.

To solve this issue, either the program should be re-written without the with statement if adding b.close is required:

b = open("gh.txt", 'w')
b.write("Applen")
b.write("Orange n")
b.write("Guava n")
b.write("grapes")
b.close()

Or the b.close() statement must be removed from the with statement to make it run:

with open("gh.txt", 'w') as b:
    b.write("Applen")
    b.write("Orange n")
    b.write("Guava n")
    b.write("grapes")

Both the code blocks execute the same work, but using the with statement adds exception handling and clears up the code.

Conclusion

This article has explained the various reasons that can cause the ValueError: I/O operation on closed file. The reader should understand the with statements and use them correctly in the future.