Variable de caducidad automática.

¿Cómo implementar una variable que expira automáticamente en python? Por ejemplo, deje que el progtwig se ejecute durante una hora. Quiero implementar una matriz de 6 variables, cada variable en la matriz se eliminará automáticamente después de 10 minutos. Y después de 1 hora, no habrá ninguna variable en la matriz.

puede crear un proceso en segundo plano que verifique cuánto tiempo se ha pasado y eliminar el elemento correcto … o si desea crear una subclase de la lista que elimina su contenido después de un cierto tiempo, puede hacer lo mismo, simplemente llamándolo en init

def __init__(self, time): #run subprocess to chek_espired elements 

editar:

Escribí un ejemplo, pero se puede hacer mucho mejor!

 class MyList(list): def __init__(self,elems, expires_time): list.__init__(self, elems) self.created = time.time() self.expires_time = expires_time def __getitem__(self, index): t = time.time() print t - self.created if t - self.created > self.expires_time: self.created += self.expires_time self.pop(index) self.__getitem__(index) return list.__getitem__(self, index) 

por supuesto, puede generar fácilmente un error personal si el progtwig intenta obtener el índice de una lista vacía

Hmmm, parece raro, pero posible.

Parece que necesita una clase que registra la hora en que se llama a __init__ . Luego, implemente __getitem__ para verificar la hora en que se llama, y ​​solo devuelva el elemento si no es demasiado tarde. (Probablemente sea más fácil hacer esto que tener un proceso “ejecutándose en segundo plano” que elimine activamente los elementos incluso cuando no los solicite).

En realidad tuve que hacer esto para los diccionarios. Tal vez encuentre el código útil:

 """Cache which has data that expires after a given period of time.""" from datetime import datetime, timedelta class KeyExpiredError(KeyError): pass def __hax(): class NoArg: pass return NoArg() NoArg = __hax() class DataCache(object): def __init__(self, defaultExpireTime=timedelta(1, 0, 0), dbg=True): self.defaultExpireTime = defaultExpireTime self.cache = {} self.dbg = dbg self.processExpires = True def setProcessExpires(self, b): self.processExpires = b def __getitem__(self, key): c = self.cache[key] n = datetime.now() if (n - c['timestamp']) < c['expireTime'] or not self.processExpires: return c['data'] del self.cache[key] if self.dbg: print "DataCache: Key %s expired" % repr(key) raise KeyExpiredError(key) def __contains__(self, key): try: self[key] return True except KeyError: return False def __setitem__(self, key, val): self.cache[key] = { 'data': val, 'timestamp': datetime.now(), 'expireTime': self.defaultExpireTime, } def items(self): keys = list(self.cache) for k in keys: try: val = self[k] yield (k, val) except: pass def get(self, key, default=NoArg, expired=NoArg): try: return self[key] except KeyExpiredError: if expired is NoArg and default is not NoArg: return default if expired is NoArg: return None return expired except KeyError: if default is NoArg: return None return default def set(self, key, val, expireTime=None): if expireTime is None: expireTime = self.defaultExpireTime self.cache[key] = { 'data': val, 'timestamp': datetime.now(), 'expireTime': expireTime, } def tryremove(self, key): if key in self.cache: del self.cache[key] return True return False #the following you can call without triggering any expirations def getTotalExpireTime(self, key): """Get the total amount of time the key will be in the cache for""" c = self.cache[key] return c['expireTime'] def getExpirationTime(self, key): """Return the datetime when the given key will expire""" c = self.cache[key] return c['timestamp'] + c['expireTime'] def getTimeRemaining(self, key): """Get the time left until the item will expire""" return self.getExpirationTime(key) - datetime.now() def getTimestamp(self, key): return self.cache[key]['timestamp'] def __len__(self): return len(self.cache) 

Uso:

 >>> dc = DataCache(timedelta(0, 5, 0)) #expire in 5 seconds >>> dc[4] = 3 >>> dc[4] 3 >>> import time >>> time.sleep(5) >>> dc[4] DataCache: Key 4 expired Traceback (most recent call last): File "", line 1, in  dc[4] File "datacache.py", line 35, in __getitem__ raise KeyExpiredError(key) KeyExpiredError: 4 >>> 

Suena como si los elementos de su matriz se conocieran entre sí, porque de lo contrario, todos expirarán al mismo tiempo.

Creo que quieres crear una subclase de lista que borre su contenido después de un cierto tiempo.

 import sched import time import threading a = [1, 2, 3, 4, 5, 6] scheduler = sched.scheduler(time.time, time.sleep) def delete(_list): del _list[0] for i in range(len(a)): scheduler.enter(60*10*i, 1, delete, (a,)) t = threading.Thread(target=scheduler.run) t.start() 

Puede usar el módulo de time para borrar la “matriz” cada 10 minutos, marcando el intervalo de tiempo desde el inicio de la secuencia de comandos.

El último ejemplo en http://effbot.org/librarybook/time.htm le indica la dirección correcta.