Save state in file on cleanup using __del__?

I have a class that looks like this:

class A:
    def __init__(self, filename, sources)开发者_运维百科:
        # gather info from file
        # info is updated during lifetime of the object

    def close(self):
        # save info back to file

Now, this is in a server program, so it might be shutdown without prior notice by a signal. Is it safe to define this to make sure the class saves it's info, if possible?

def __del__(self):
    self.close()

If not, what would you suggest as a solution instead?

Waiting until later is just not the strategy to making something reliable. In fact, you have to go the complete opposite direction. As soon as you know something that should be persistent, you need to take action to persist it. In fact, if you want to make it reliable, you need to first write to disk the steps needed to recover from the failure that might happen while you are trying to commit the change. pseudopython:

class A:
    def __init__(self, filename, sources):
        self.recover()
        # gather info from file
        # info is updated during lifetime of the object

    def update_info(self, info):
        # append 'info' to recovery_log
        # recovery_log.flush()
        # write 'info' to file
        # file.flush()
        # append 'info-SUCCESS' to recover_log
        # recovery_log.flush()

    def recover(self):
        # open recovery_log
        # skip to last 'info-SUCCESS'
        # read 'info' from recover_log
        # write 'info' to file
        # file.flush()
        # append 'info-SUCCESS' to recover_log
        # recovery_log.flush()

The important bit is that recover() happens every time, and that every step is followed by a flush() to make sure data makes it out to disk before the next step occurs. another important thing is that only appends ever occur on the recover log itself. nothing is overwritten in such a way that the data in the log can become corrupted.

No. You are NEVER safe.

If the opearting system wants to kill you without prior notice, it will. You can do nothing about it. Your program can stop running after any instruction, at any time, and have no opportunity to execute any additional code.

There is just no way of protecting your server from a killing signal.

You can, if you want, trap lesser signals and manually delete your objects, forcing the calls to close().

For orderly cleanup you can use the sys.atexit hooks. Register a function there that calls your close method. The destructor of on object may not be called at exit.

The __del__ method is not guaranteed to ever be called for objects that still exist when the interpreter exits.

Even if __del__ is called, it can be called too late. In particular, it can occur after modules it wants to call have been unloaded. As pointed out by Keith, sys.atexit is much safer.