python对象缓存

‘壹’ python如何管理内存

Python中的内存管理是从三个方面来进行的,一对象的引用计数机制,二垃圾回收机制,三内存池机制
一、对象的引用计数机制
Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。
引用计数增加的情况：
1，一个对象分配一个新名称
2，将其放入一个容器中(如列表、元组或字典)
引用计数减少的情况：
1，使用del语句对对象别名显示的销毁
2，引用超出作用域或被重新赋值
sys.getrefcount( )函数可以获得对象的当前引用计数
多数情况下，引用计数比你猜测得要大得多。对于不可变数据(如数字和字符串)，解释器会在程序的不同部分共享内存，以便节约内存。
二、垃圾回收
1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。(从而导致内存泄露)。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。
三、内存池机制
Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

‘贰’ 软件测试中,python中的 ==和 is 之间的区别

在Python中一切都是对象。
Python中对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。对象之间比较是否相等可以用==，也可以用is。
is和==都是对对象进行比较判断作用的，但对对象比较判断的内容并不相同。下面来看看具体区别在哪?
is比较的是两个对象的id值是否相等，也就是比较两个对象是否为同一个实例对象，是否指向同一个内存地址。
==比较的是两个对象的内容是否相等，默认会调用对象的__eq__()方法。

以下代码在Python3.5下测试通过。
==比较操作符和is同一性运算符区别
==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等。
代码1：
>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

解释一下为什么？is也被叫做同一性运算符，也就是id是否相同。看下面代码， a和b变量的id不同， 所以b==a是True， b is a 是False.
代码2：
>>> id(a)
4364243328
>>>
>>> id(b)
4364202696

哪些情况下is和==结果是完全相同的？
代码3：
>>> a = 256
>>> b = 256
>>> a is b
True
>>> a == b
True
>>>
>>> a = 1000
>>> b = 10**3
>>> a == b
True
>>> a is b
False
>>>

结论：数字类型不完全相同。

为什么256时相同， 而1000时不同？
因为出于对性能的考虑，Python内部做了很多的优化工作，对于整数对象，Python把一些频繁使用的整数对象缓存起来，保存到一个叫small_ints的链表中，在Python的整个生命周期内，任何需要引用这些整数对象的地方，都不再重新创建新的对象，而是直接引用缓存中的对象。Python把这些可能频繁使用的整数对象规定在范围[-5, 256]之间的小对象放在small_ints中，但凡是需要用些小整数时，就从这里面取，不再去临时创建新的对象。

代码4：
>>> c = 'pythontab.com'
>>> d = 'pythontab.com'
>>> c is d
False
>>> c == d
True
>>> c = 'pythontabcom'
>>> d = 'pythontabcom'
>>> c is c
True
>>> c == d
True

结论：字符串类型不完全相同。这个和解释器实现有关。

代码5：
>>> a = (1,2,3) #a和b为元组类型
>>> b = (1,2,3)
>>> a is b
False
>>> a = [1,2,3] #a和b为list类型
>>> b = [1,2,3]
>>> a is b
False
>>> a = {'python':100,'com':1} #a和b为dict类型
>>> b = {'python':100,'com':1}
>>> a is b
False
>>> a = set([1,2,3])#a和b为set类型
>>> b = set([1,2,3])
>>> a is b
False

结论
当变量是数字、字符串、元组，列表，字典时，is和==都不相同， 不能互换使用！当比较值时，要使用==，比较是否是同一个内存地址时应该使用is。当然，开发中比较值的情况比较多。

‘叁’ python 如何释放缓存

我觉得可能是因为你的py文件在第一次启动后，已经编译成pyc文件了，再次启动的时候都是加载pyc，省去了编译的阶段，所以速度很快。
你可以试着把程序目录下的所有pyc或者你的代码文件对应的pyc文件删除，看看是不是可以和第一次加载速度相同

‘肆’ python从数据库读取数据后会缓存数据吗

python并不具有数据存储的功能，所以的查询结果都会在内存中保留，程序执行完毕数据就消失，不会有缓存的问题。

‘伍’ 如何给轻量python程序，脚本制作缓存

1, 首先下载并安装Python 2.7 2, 写一个简单地Python源文件,比如test.py,内容如下: import sys, os def test(arg1, arg2): print "begin test..." fun1('1', '2') print arg1 print arg2 def fun1(arg1, arg2): print arg1 print arg2 if __name...

‘陆’ python requests 会缓存，吗

你好 python 并不会自动缓存数据， 极度怀疑你数据没插入成功，或者插入操作不在那个2秒SLEEP的时间里面。

‘柒’ 如何在python中使用时间限制进行缓存

可以试试装饰器

defcache(fn=None,time_to_live=3600*24):#oneDAYdefault(orwhatever)
ifnotfn:returnfunctools.partial(cache,time_to_live=time_to_live)
my_cache={}
def_inner_fn(*args,**kwargs)
kws=sorted(kwargs.items())#inpython3.6+youdontneedsorted
key=tuple(args)+tuple(kw)
ifkeynotinmy_cacheortime.time()>my_cache[key]['expires']:
my_cache[key]={"value":fn(*args,**kwargs),"expires":time.time()+time_to_live}
returnmy_cache[key]
return__inner_fn

@cache(time_to_live=3600)#anhour
defmy_sqrt(x):
returnx**0.5@cache(time_to_live=60*30)#30mins
defget_new_emails():
returnmy_stmp.get_email_count()

‘捌’ Python如何进行内存管理

Python是如何进行内存管理的？

答:从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制。

一、对象的引用计数机制

Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。

引用计数增加的情况：

1，一个对象分配一个新名称

2，将其放入一个容器中（如列表、元组或字典）

引用计数减少的情况：

1，使用del语句对对象别名显示的销毁

2，引用超出作用域或被重新赋值

Sys.getrefcount( )函数可以获得对象的当前引用计数

多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。

相关推荐：《Python视频教程》

二、垃圾回收

1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。

2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

三、内存池机制

Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。

1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。

2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。

3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

‘玖’ python产生10个[100~200]之间的随机数,找出这10个随机数中的中间值

在8000到2000之间产生10个随机数，用到random包。

random.random()用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成随机数。

n <= b。如果 a <b， 则 b <= n <= a。用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，Python生成随机数。

(9)python对象缓存扩展阅读：

注意事项：

1、range (10000000)后，内存不释放的原因：python对整数对象做了缓存，新创建出来的整数对象的内存不会被释放，而是留着以后再次创建整数对象时继续使用。这样可以减少new操作，提高效率。

2、局部变量的访问速度，比全局变量、内建变量都要快，如果函数中，需要频繁使用某个全局变量或内建函数时，那么可以考虑先将这个全局变量或内建函数赋值给一个局部变量，后面代码直接访问这个局部变量、

3、虽然python是动态语言，但是在执行python代码前，也有编译的过程。平时看到的pyc文件就是python编译后的结果。

‘拾’ 是否有Python缓存库

从Python 3.2开始，可以使用functools库中的装饰器@lru_cache。这是最近使用过的缓存，所以其中的项目没有到期时间，但作为快速入侵，它非常有用。
from functools import lru_cache

@lru_cache(maxsize=256)def f(x):
return x*xfor x in range(20):
print f(x)for x in range(20):
print f(x)