玩蛇网提供最新Python编程技术信息以及Python资源下载!
您现在的位置: 玩蛇网首页 > Python源码实例_Python程序源代码_网站项目下载 > 正文内容

Python近期使用较少算法实现方法

Python入门佳作 经典教程的全新修订 10个项目引人入胜
玩蛇网推荐图文教程:python黑客多线程扫描器

这是一个简单python最近比较少使用的算法,python最近最少使用算法代码会涉及到Python字典、文件系统的访问数据、Python类、Python for循环控制语句等等相关知识。

代码中有些英文注释,需要这个python实现的最近最少使用算法代码的朋友们,可以自行去翻译一下,python 注释还是很好用的。

下面我们一起来看下正式的代码段:

""" 

from __future__ import generators 
import time 
from heapq import heappush, heappop, heapify 

# the suffix after the hyphen denotes modifications by the 
#  ftputil project with respect to the original version 

__version__ = "0.2-1" 
__all__ = ['CacheKeyError', 'LRUCache', 'DEFAULT_SIZE'] 
__docformat__ = 'reStructuredText en' 

DEFAULT_SIZE = 16 
"""Default size of a new LRUCache object, if no 'size' argument is given.""" 

class CacheKeyError(KeyError): 
    """Error raised when cache requests fail 

    When a cache record is accessed which no longer exists (or never did), 
    this error is raised. To avoid it, you may want to check for the existence 
    of a cache record before reading or deleting it.""" 
    pass 

class LRUCache(object): 
    """Least-Recently-Used (LRU) cache. 

    Instances of this class provide a least-recently-used (LRU) cache. They 
    emulate a Python mapping type. You can use an LRU cache more or less like 
    a Python dictionary, with the exception that objects you put into the 
    cache may be discarded before you take them out. 

    Some example usage:: 

    cache = LRUCache(32) # new cache 
    cache['foo'] = get_file_contents('foo') # or whatever 

    if 'foo' in cache: # if it's still in cache... 
        # use cached version 
        contents = cache['foo'] 
    else: 
        # recalculate 
        contents = get_file_contents('foo') 
        # store in cache for next time 
        cache['foo'] = contents 

    print cache.size # Maximum size 

    print len(cache) # 0 <= len(cache) <= cache.size 

    cache.size = 10 # Auto-shrink on size assignment 

    for i in range(50): # note: larger than cache size 
        cache[i] = i 

    if 0 not in cache: print 'Zero was discarded.' 

    if 42 in cache: 
        del cache[42] # Manual deletion 

    for j in cache:   # iterate (in LRU order) 
        print j, cache[j] # iterator produces keys, not values 
    """ 

    class __Node(object): 
        """Record of a cached value. Not for public consumption.""" 

        def __init__(self, key, obj, timestamp, sort_key): 
            object.__init__(self) 
            self.key = key 
            self.obj = obj 
            self.atime = timestamp 
            self.mtime = sel

#www.iplaypython.com

f.atime 
            self._sort_key = sort_key 

        def __cmp__(self, other): 
            return cmp(self._sort_key, other._sort_key) 

        def __repr__(self): 
            return "<%s %s => %s (%s)>" % \ 
                   (self.__class__, self.key, self.obj, \ 
                    time.asctime(time.localtime(self.atime))) 

    def __init__(self, size=DEFAULT_SIZE): 
        # Check arguments 
        if size <= 0: 
            raise ValueError, size 
        elif type(size) is not type(0): 
            raise TypeError, size 
        object.__init__(self) 
        self.__heap = [] 
        self.__dict = {} 
        
        """Maximum size of the cache. 
        If more than 'size' elements are added to the cache, 
        the least-recently-used ones will be discarded.""" 
        
        self.size = size 
        self.__counter = 0 

    def _sort_key(self): 
        """Return a new integer value upon every call. 
        
        Cache nodes need a monotonically increasing time indicator. 
        time.time() and time.clock() don't guarantee this in a 
        platform-independent way. 
        """ 
        self.__counter += 1 
        return self.__counter 

    def __len__(self): 
        return len(self.__heap) 

    def __contains__(self, key): 
        return self.__dict.has_key(key) 

    def __setitem__(self, key, obj): 
        if self.__dict.has_key(key): 
            node = self.__dict[key] 
            # update node object in-place 
            node.obj = obj 
            node.atime = time.time() 
            node.mtime = node.atime 
            node._sort_key = self._sort_key() 
            heapify(self.__heap) 
        else: 
            # size may have been reset, so we loop 
            while len(self.__heap) >= self.size: 
                lru = heappop(self.__heap) 
                del self.__dict[lru.key] 
            node = self.__Node(key, obj, time.time(), self._sort_key()) 
            self.__dict[key] = node 
            heappush(self.__heap, node) 

    def __getitem__(self, key): 
        if not self.__dict.has_key(key): 
            raise CacheKeyError(key) 
        else: 
            node = self.__dict[key] 
            # update node object in-place 
            node.atime = time.time() 
            node._sort_key = self._sort_key() 
            heapify(self.__heap) 
            return node.obj 

    def __delitem__(self, key): 
        if not self.__dict.has_key(key): 
            raise CacheKeyError(key) 
        else: 
            node = self.__dict[key] 
            del self.__dict[key] 
            self.__heap.remove(node) 
            heapify(self.__heap) 
            return node.obj 

    def __iter__(self): 
        copy = self.__heap[:] 
        while len(copy) > 0: 
            node = heappop(copy) 
            yield node.key 
        raise StopIteration 

    def __setattr__(self, name, value): 
        object.__setattr__(self, name, value) 
        # automagically shrink heap on resize 
        if name == 'size': 
            while len(self.__heap) > value: 
                lru = heappop(self.__heap) 
                del self.__dict[lru.key] 

    def __repr__(self): 
        return "<%s (%d elements)>" % (str(self.__class__), len(self.__heap)) 

    def mtime(self, key): 
        """Return the last modification time for the cache record with key. 
        May be useful for cache instances where the stored values can get 
        'stale', such as caching file or network resource contents.""" 
        if not self.__dict.has_key(key): 
            raise CacheKeyError(key) 
        else: 
            node = self.__dict[key] 
            return node.mtime 

if __name__ == "__main__": 
    cache = LRUCache(25) 
    print cache 
    for i in range(50): 
        cache[i] = str(i) 
    print cache 
    if 46 in cache: 
        print "46 in cache" 
        del cache[46] 
    print cache 
    cache.size = 10 
    print cache 
    cache[46] = '46' 
    print cache 
    print len(cache) 
    for c in cache: 
        print c 
    print cache 
    print cache.mtime(46) 
    for c in cache: 
        print c 

浏览此文章用户还在关注:python from import使用方法。

玩蛇网文章,转载请注明出处和来源网址:http://www.iplaypython.com/code/c2710.html



微信公众号搜索"玩蛇网Python之家"加关注,每日最新的Python资讯、图文视频教程可以让你一手全掌握。强烈推荐关注!

微信扫描下图可直接关注

玩蛇网PythonQQ群,欢迎加入: ① 240764603 玩蛇网Python新手群
出炉日期:2016-01-31 19:53 玩蛇网 www.iplaypython.com

我要分享到:
评论列表(网友评论仅供网友表达个人看法,并不表明本站同意其观点或证实其描述)

必知PYTHON教程 Must Know PYTHON Tutorials

必知PYTHON模块 Must Know PYTHON Modules