There are two questions indeed. Updated to make this clearer.
I have:
t = {
'fd': open("filename", 'r')
}
I understand that del t['fd'] removes the key and closes the file. Is that correct?
Does del t call del on contained objects (fd in this case)?
The behavior of what you want to do is nondeterministic. Depending on the implementation and internal functioning of Python (CPython, PyPi, ...), this can be work or not:
Working example:
t = {
'fd': open('data.txt', 'r')
}
def hook_close_fd():
print('del dictionary, close the file')
t['fd'].close = hook_close_fd
del t
Output:
del dictionary, close the file
In this case, the close function is called on delete
Non working example:
t = {
'fd': open('data.txt', 'r')
}
def hook_close_fd():
print('del dictionary, close the file')
t['fd'].close = hook_close_fd
3 / 0
Output of 1st run:
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-211-2d81419599a9> in <module>
10 t['fd'].close = hook_close_fd
11
---> 12 3 / 0
ZeroDivisionError: division by zero
Output of 2nd run:
del dictionary, close the file
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-212-2d81419599a9> in <module>
10 t['fd'].close = hook_close_fd
11
---> 12 3 / 0
ZeroDivisionError: division by zero
As you can see, when an exception is raised, you can't be sure if your file descriptor will be closed properly (especially if you don't catch exception yourself).
The two parts of your question have completely different answers.
Deleting a variable to close file is not reliable; sometimes it works, sometimes it doesn't, or it works but in a surprising way. Occasionally it may lose data. It will definitely fail to report file errors in a useful way.
The correct ways to close a file are (a) using a with statement, or (b) using the .close() method.
Deleting an object indeed deletes all contained objects, with a couple of caveats:
if (some of) those objects are also in another variable, they will continue to exist until that other variable is also deleted;
if those objects refer to each other, they may continue to exist for some time afterwards and get deleted later; and
for immutable objects (strings, integers), Python may decide to keep them around as an optimisation, but this mostly won't be visible to us and will in any case differ between versions.
No. You must close the files you open (see note).
Or, but it may not fit your project, in a more safer way open it in a context manager.
with open("filename", 'r') as fd:
...
If you are opening simultaneously a unknown number of files, you may need to write you own context manager or more simply use contextlib.ExitStack
Note: From : "3.10.0 Documentation / The Python Tutorial / 7. Input and Output / 7.2. Reading and Writing Files https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files": Warning Calling f.write() without using the with keyword or calling f.close() might result in the arguments of f.write() not being completely written to the disk, even if the program exits successfully.
Your question is less trivial than you think. But deep down it all comes down to understanding what a pointer is and how the garbage collector works.
Indeed, by doing t['fd'], you delete that entry in the dictionary. What you do is delete the pointer that points to that entry. If you have a dictionary as follows:
t = { 'a':3, 'b':4 }
Then when you do del t you delete the pointer to the dictionary t. As there is therefore no further reference to the dictionary keys, the garbage collector deletes these as well, thus freeing up all the dictionary memory.
However, as long as you have a file descriptor, you can delete it but it is not desirable to do so since the file descriptor (fd, pointer to a file and much more ) is the way the programmer interacts with a file, if the descriptor is deleted abruptly, the state of the file can get corrupted by being in an inconsistent state.
Therefore, it is a good idea to call the close function before you stop working with a file. This function takes care of all those things for you.
Yes, deleting the variable t closes the file (using psutil to show open files per process):
import psutil
def find_open_files():
for proc in psutil.process_iter():
if proc.name() == 'python3.9':
print(proc.open_files())
filename = '/tmp/test.txt'
t = {'fd': open(filename, 'r')}
find_open_files()
del t
find_open_files()
Out:
[popenfile(path='/private/tmp/test.txt', fd=3)]
[]
