python清除函数占用的内存方法
转载 &更新时间：日 15:38:02 & 作者：田有权
今天小编就为大家分享一篇python清除函数占用的内存方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
python升级到2.7.13
函数执行的结尾加上这个即可
for x in locals().keys():
del locals()[x]
gc.collect()
原理是，locals()会列出当前所有局部变量，手动的把当前函数生成的开销都给清空掉即可释放掉内存。
以上这篇python清除函数占用的内存方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具如果你不知道Python怎么进行内存优化！那么你的Python会超级卡！如果你不知道Python怎么进行内存优化！那么你的Python会超级卡！未来机甲百家号Slots默认情况下，自定义的对象都使用dict来存储属性（通过obj.__dict__查看），而python中的dict大小一般比实际存储的元素个数要大（以此降低hash冲突概率），因此会浪费一定的空间。在新式类中使用__slots__，就是告诉Python虚拟机，这种类型的对象只会用到这些属性，因此虚拟机预留足够的空间就行了，如果声明了__slots__，那么对象就不会再有__dict__属性。使用slots到底能带来多少内存优化呢，首先看看这篇文章，对于一个只有三个属性的Image类，使用__slots__之后内存从25.5G下降到16.2G，节省了9G的空间！百分比为内存优化百分比，计算公式为(b – a) / b， 其中b为没有使用__slots__时分配的内存， a为使用了__slots__时分配的内存。注意事项关于__slots__，Python文档有非常详尽的介绍，这里只强调几点注意事项第一：基类和子类都必须__slots__，即使基类或者子类没有属性从定义可以看出，除了固定的部分（几个Py_ssize_t），PyDictObject中主要是PyDictEntry对象，PyDictEntrty包含一个Py_ssize_t（int）和两个指针。上面源码中的注释（第26行）指出，当dict的元素比较少时，ma_table指向ma_smalltable，当元素增多时，ma_table会指向新申请的空间。ma_smalltable的作用在于Python（不管是源码还是代码）都大量使用dict，一般来说，存储的元素也不会太多，因此Python就先开辟好PyDict_MINSIZE(默认为8)个空间。为什么说PyDictObject存在浪费呢，PyDictEntry在32位下也有12个字节，那么即使在ma_smalltable（ma_table）中大量的位置没有被使用时，也要占用这么多字节。用这篇文章中的例子：假设有这么一个dict：总结本文中介绍了Python内存优化的Profile工具，最有效的优化方法：使用slots，也介绍了在python3.6中新的dict实现。当然，还有一些良好的编码习惯。比如尽量使用immutable而不是mutable对象：使用tuple而不是list，使用frozenset而不是set；另外，就是尽量使用迭代器，比如python2.7中，使用xrange而不是range，dict的iterxx版本.谢谢阅读！如有侵权请联系小编删除哦！本文由百家号作者上传并发布，百家号仅提供信息发布平台。文章仅代表作者个人观点，不代表百度立场。未经作者许可，不得转载。未来机甲百家号最近更新：简介:推动科技新闻的日常新鲜走向。作者最新文章相关文章关于 python 内存释放问题的一个疑惑
08:34:57 +08:00 · 2619 次点击
python 刚运行时只占用 3M 内存
mt.setdefualt(i, i)
这么时候我机器占用了 450MB 内存
然后我执行:
内存占用 230MB,内存再也不是刚开始执行时候的 3MB 了，这个是为什么呢？
15 回复 &| &直到
00:26:25 +08:00
& & 08:53:37 +08:00
gc.collect()
& & 08:54:02 +08:00 via iPad
大部分的 malloc 实现和 Python 的对象分配都有用内存池， Python 对象回收不一定会调用 free ，即使调用 free 一些 malloc 实现也不会将内存还给操作系统。
& & 09:22:13 +08:00
@ GC 对象返回的是 0 哦
& & 10:09:21 +08:00
整数缓存，每个整个只分配一次内存，但一旦分配了内存一般是不回收的，即使不使用了
& & 10:14:35 +08:00
我比较喜欢这个回答
It ’ s that you ’ ve created 5 million integers simultaneously alive, and each int object consumes 12 bytes. “ For speed ”, Python maintains an internal free list for integer objects. Unfortunately, that free list is both immortal and unbounded in size. floats also use an immortal & unbounded free list.
意思就是 python 内部为了速度有一个整数缓存列表,添加了进去之后不知道怎么删除。。。。
& & 10:16:23 +08:00 via Android
学习了。 Python 的 GC 大部分时候都工作得很好。
& & 10:49:32 +08:00
@ 你这么说还是有问题，为什么我删除了对象后内存少了很多，我再次跑清单 1 的时候，内存又变多了
& & 12:11:15 +08:00
@ dict 对象不是还要占内存么？你删除了 dict 对象内存当然会释放一部分了
& & 12:18:40 +08:00
@ 对象开始申请没占用那么大，删除后占用就变大了？ 而且你说的是缓存啊，就是内存的数据应该还是存在的啊，为什么我继续添加整形数据的时候又变大了呢？（执行一样的语句）
& & 12:38:22 +08:00
Python3 解决了这个问题。
& & 12:41:13 +08:00 via Android
@ @ 原来是版本不一样
& & 17:21:03 +08:00
这里涉及到整数对象池概念：
python 的 VM 实现中，有大整数和小整数对象池的概念。
首次使用大整数（&257 ）时会分配大量内存块， PyIntObject 对象被销毁时，它所占有的内存并不会被释放，归还给系统，而是继续被 Python 保留着
& & 17:24:28 +08:00
对象池不是复用那些整数们，而是为了复用占据的内存空间，避免频繁创建和释放带来很大的性能开销
& & 19:48:14 +08:00
& & 00:26:25 +08:00
这种方法很讨巧， Python multiprocessing 模块 fork 一个 child process 开销很大的，估摸至少十几个到几十个 us 的时间就没了，如果是在 linux 平台可以使用 vfork 撸一个进程出来，降低 os.fork 调用的开销，让 child process 计算部分先行
& · & 1866 人在线 & 最高记录 3541 & · &
创意工作者们的社区
World is powered by solitude
VERSION: 3.9.8.1 · 19ms · UTC 02:59 · PVG 10:59 · LAX 19:59 · JFK 22:59? Do have faith in what you're doing.Stay hungry, stay foolish.
Python的内存管理以及垃圾回收
参考：http://www.cnblogs.com/CBDoctor/p/3781078.html
先从较浅的层面来说，Python的内存管理机制可以从三个方面来讲
（1）垃圾回收
（2）引用计数
（3）内存池机制
一、垃圾回收：
python不像C++，Java等语言一样，他们可以不用事先声明变量类型而直接对变量进行赋值。对Python语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称Python语言为动态类型的原因（这里我们把动态类型可以简单的归结为对变量内存地址的分配是在运行时自动判断变量类型并对变量进行赋值）。
二、引用计数：
Python采用了类似Windows内核对象一样的方式来对内存进行管理。每一个对象，都维护这一个对指向该对对象的引用的计数。如图所示（图片来自Python核心编程）
我们首先创建了一个对象3.14， 然后将这个浮点数对象的引用赋值给x，因为x是第一个引用，因此，这个浮点数对象的引用计数为1. 语句y = x创建了一个指向同一个对象的引用别名y，我们发现，并没有为Y创建一个新的对象，而是将Y也指向了x指向的浮点数对象，使其引用计数为2.
我们可以很容易就证明上述的观点：
变量a 和 变量b的id一致(我们可以将id值想象为C中变量的指针).
我们援引另一个网址的图片来说明问题：对于C语言来讲，我们创建一个变量A时就会为为该变量申请一个内存空间，并将变量值 放入该空间中,当将该变量赋给另一变量B时会为B申请一个新的内存空间，并将变量值放入到B的内存空间中，这也是为什么A和B的指针不一致的原因。如图：
而Python的情况却不一样，实际上，Python的处理方式和Javascript有点类似，如图所示，变量更像是附在对象上的标签(和引用的定义类似)。当变量被绑定在一个对象上的时候，该变量的引用计数就是1，(还有另外一些情况也会导致变量引用计数的增加),系统会自动维护这些标签，并定时扫描，当某标签的引用计数变为0的时候，该对就会被回收。
三、内存池机制
Python的内存机制以金字塔行，-1，-2层主要有操作系统进行操作，
　　第0层是C中的malloc，free等内存分配和释放函数进行操作；
　　第1层和第2层是内存池，有Python的接口函数PyMem_Malloc函数实现，当对象小于256K时有该层直接分配内存；
　　第3层是最上层，也就是我们对Python对象的直接操作；
在 C 中如果频繁的调用 malloc 与 free 时,是会产生性能问题的.再加上频繁的分配与释放小块的内存会产生内存碎片. Python 在这里主要干的工作有:
　　如果请求分配的内存在1~256字节之间就使用自己的内存管理系统,否则直接使用 malloc.
　　这里还是会调用 malloc 分配内存,但每次会分配一块大小为256k的大块内存.
　　经由内存池登记的内存到最后还是会回收到内存池,并不会调用 C 的 free 释放掉.以便下次使用.对于简单的Python对象，例如数值、字符串，元组（tuple不允许被更改)采用的是复制的方式(深拷贝?)，也就是说当将另一个变量B赋值给变量A时，虽然A和B的内存空间仍然相同，但当A的值发生变化时，会重新给A分配空间，A和B的地址变得不再相同
而对于像字典(dict)，列表(List)等，改变一个就会引起另一个的改变，也称之为浅拷贝
引用计数增加
1.对象被创建：x=4
2.另外的别人被创建：y=x
3.被作为参数传递给函数：foo(x)
4.作为容器对象的一个元素：a=[1,x,'33']
引用计数减少
1.一个本地引用离开了它的作用域。比如上面的foo(x)函数结束时，x指向的对象引用减1。
2.对象的别名被显式的销毁：del x ；或者del y
3.对象的一个别名被赋值给其他对象：x=789
4.对象从一个窗口对象中移除：myList.remove(x)
5.窗口对象本身被销毁：del myList，或者窗口对象本身离开了作用域。
1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。
2、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0)。
以下摘自vamei：http://www.cnblogs.com/vamei/p/3232088.html
在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。
print(id(a))
print(id(b))
上面程序返回
可见a和b实际上是指向同一个对象的两个引用。
为了检验两个引用指向同一个对象，我们可以用is关键字。is用于判断两个引用所指的对象是否相同。
print(a is b)
a = "good"
b = "good"
print(a is b)
a = "very good morning"
b = "very good morning"
print(a is b)
print(a is b)
上面的注释为相应的运行结果。可以看到，由于Python缓存了整数和短字符串，因此每个对象只存有一份。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。
在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。
我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。
from sys import getrefcount
a = [1, 2, 3]
print(getrefcount(a))b = aprint(getrefcount(b))
由于上述原因，两个getrefcount将返回2和3，而不是期望的1和2。
对象引用对象
Python的一个容器对象(container)，比如表、词典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。
我们也可以自定义一个对象，并引用其它对象:
class from_obj(object):
def __init__(self, to_obj):
self.to_obj = to_obj
b = [1,2,3]
a = from_obj(b)
print(id(a.to_obj))
print(id(b))
可以看到，a引用了对象b。
对象引用对象，是Python最基本的构成方式。即使是a = 1这一赋值方式，实际上是让词典的一个键值"a"的元素引用整数对象1。该词典对象用于记录所有的全局引用。该词典引用了整数对象1。我们可以通过内置函数globals()来查看该词典。
当一个对象A被另一个对象B引用时，A的引用计数将增加1。
from sys import getrefcount
a = [1, 2, 3]
print(getrefcount(a))
b = [a, a]
print(getrefcount(a))
由于对象b引用了两次a，a的引用计数增加了2。
当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object
allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
我们可以通过gc模块的get_threshold()方法，查看该阈值:
print(gc.get_threshold())
返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。
我们也可以手动启动垃圾回收，即使用gc.collect()。
Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。
小家伙要多检查
Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。
这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。
同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。
gc.set_threshold(700, 10, 5)
没有更多推荐了，在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
在项目中遇到这样一个问题，代码流程大致就是 先开始A方法，A方法调用B方法。B方法执行结束后再次调用A方法，这样需要执行大概2w次后跳出，但是执行大概2000次的时候，内存就满了，线程就被杀死了。请教大家，如何在循环中释放掉内存。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
这种递归方式，内存没占满也是会栈溢出的。递归过程中，上一层的函数实际并没有运行完，因此也别指望垃圾回收过来清理。强烈建议改程序，可以类似这样：
while True:
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
我举个例子吧，读取了一个几百兆文件内容保存在fc变量里，你可以看下电脑内存也是增长的，如果一个文件不明显能就多读几个文件。然后确定不再用的时候，直接del fc就可以释放内存了。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
本想在每层递归结尾调用gc.collect()，但好像并没有什么用，del也不会生效。看来是递归真的不释放内存。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
你这个就是递归。改，没商量。要么改不耗资源的递归，要么改递归为能控制的循环。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
我考虑采用 实现 上下文管理协议， 然后你的对象在相互调用的时候，利用 __enter__ 和 __exit__ 自动释放不使用的资源。请参考：
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
把公用的变量改成全局变量，不公用的局部变量，用完后立即del掉
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。