python使内存消耗

‘壹’ 7种检测python程序运行时间、CPU和内存占用的方法

1. 使用装饰器来衡量函数执行时间

有一个简单方法，那就是定义一个装饰器来测量函数的执行时间，并输出结果：

import time

from functoolsimport wraps

import random

def fn_timer(function):

  @wraps(function)

  def function_timer(*args, **kwargs):

      t0= time.time()

      result= function(*args, **kwargs)

      t1= time.time()

      print("Total time running %s: %s seconds" %

          (function.__name__, str(t1- t0))

)

      return result

return function_timer

@fn_timer

def random_sort(n):

  return sorted([random.random() for i in range(n)])

if __name__== "__main__":

  random_sort(2000000)

输出：Total time running random_sort: 0.6598007678985596 seconds

使用方式的话，就是在要监控的函数定义上面加上 @fn_timer 就行了

或者

# 可监控程序运行时间

import time

import random

def clock(func):

    def wrapper(*args, **kwargs):

        start_time= time.time()

        result= func(*args, **kwargs)

        end_time= time.time()

        print("共耗时: %s秒" % round(end_time- start_time, 5))

        return result

return wrapper

@clock

def random_sort(n):

  return sorted([random.random() for i in range(n)])

if __name__== "__main__":

  random_sort(2000000)

输出结果：共耗时: 0.65634秒

2. 使用timeit模块

另一种方法是使用timeit模块，用来计算平均时间消耗。

执行下面的脚本可以运行该模块。

这里的timing_functions是Python脚本文件名称。

在输出的末尾，可以看到以下结果：4 loops, best of 5: 2.08 sec per loop

这表示测试了4次，平均每次测试重复5次，最好的测试结果是2.08秒。

如果不指定测试或重复次数，默认值为10次测试，每次重复5次。

3. 使用Unix系统中的time命令

然而，装饰器和timeit都是基于Python的。在外部环境测试Python时，unix time实用工具就非常有用。

运行time实用工具：

输出结果为：

Total time running random_sort: 1.3931210041 seconds

real 1.49

user 1.40

sys 0.08

第一行来自预定义的装饰器，其他三行为：

    real表示的是执行脚本的总时间

    user表示的是执行脚本消耗的CPU时间。

    sys表示的是执行内核函数消耗的时间。

注意：根据维基网络的定义，内核是一个计算机程序，用来管理软件的输入输出，并将其翻译成CPU和其他计算机中的电子设备能够执行的数据处理指令。

因此，Real执行时间和User+Sys执行时间的差就是消耗在输入/输出和系统执行其他任务时消耗的时间。

4. 使用cProfile模块

5. 使用line_profiler模块

6. 使用memory_profiler模块

7. 使用guppy包

‘贰’ python 内存占用分析工具

pip install memory_profiler
pip install psutil
pip install matplotlib

使用方法
from memory_profiler import profile

@profile(precision=4, stream=open('test.log', 'w+'))
def test(args: List):
...

运行：
python3 test.py

Mem usage:表示执行该行后Python解释器的内存使用情况
Increment:表示当前行的内存相对于上一行的差异，即自己本身增长了多少，如果减少了则不显示.

‘叁’ 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知识请关注Python视频教程栏目。

‘肆’ 如何释放Python占用的内存

在上文的优化中，对每500个用户，会进行一些计算并记录结果在磁盘文件中。原本以为这么做，这些结果就在磁盘文件中了，而不会再继续占用内存；但实际上，python的大坑就是Python不会自动清理这些内存。这是由其本身实现决定的。具体原因网上多有文章介绍，这里就不了。
本篇博客将贴一个笔者的实验脚本，用以说明Python确实存在这么一个不释放内存的现象，另外也提出一个解决方案，即：先del，再显式调用gc.collect(). 脚本和具体效果见下。

实验环境一：Win 7， Python 2.7

[python] view plain
from time import sleep, time
import gc

def mem(way=1):
print time()
for i in range(10000000):
if way == 1:
pass
else: # way 2, 3
del i

print time()
if way == 1 or way == 2:
pass
else: # way 3
gc.collect()
print time()

if __name__ == "__main__":
print "Test way 1: just pass"
mem(way=1)
sleep(20)
print "Test way 2: just del"
mem(way=2)
sleep(20)
print "Test way 3: del, and then gc.collect()"
mem(way=3)
sleep(20)

运行结果如下：

[plain] view plain
Test way 1: just pass
1426688589.47
1426688590.25
1426688590.25
Test way 2: just del
1426688610.25
1426688611.05
1426688611.05
Test way 3: del, and then gc.collect()
1426688631.05
1426688631.85
1426688631.95

对于way 1和way 2，结果是完全一样的，程序内存消耗峰值是326772KB，在sleep 20秒时，内存实时消耗是244820KB；
对于way 3，程序内存消耗峰值同上，但是sleep时内存实时消耗就只有6336KB了。

实验环境二： Ubuntu 14.10， Python 2.7.3

运行结果：

[plain] view plain
Test way 1: just pass
1426689577.46
1426689579.41
1426689579.41
Test way 2: just del
1426689599.43
1426689601.1
1426689601.1
Test way 3: del, and then gc.collect()
1426689621.12
1426689622.8
1426689623.11

[plain] view plain
ubuntu@my_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 10.0 6.0 270916 245564 pts/1 S+ 14:39 0:03 python test_mem.py
ubuntu 9134 0.0 0.0 8104 924 pts/2 S+ 14:40 0:00 grep --color=auto test_mem
ubuntu@my_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 10.0 6.0 270916 245564 pts/1 S+ 14:39 0:03 python test_mem.py
ubuntu 9134 0.0 0.0 8104 924 pts/2 S+ 14:40 0:00 grep --color=auto test_mem
ubuntu@my_machine:~$ ps -aux | grep test_mem
Warning: bad ps syntax, perhaps a bogus '-'? See
ubuntu 9122 11.6 0.1 30956 5608 pts/1 S+ 14:39 0:05 python test_mem.py

结论：
以上说明，当调用del时，其实Python并不会真正release内存，而是将其继续放在其内存池中；只有在显式调用gc.collect()时，才会真正release内存。

进一步：
其实回到上一篇博客的脚本中，也让其引入gc.collect()，然后写个监控脚本监测内存消耗情况：

[plain] view plain
while ((1)); do ps -aux | sort -n -k5,6 | grep my_script; free; sleep 5; done

结果发现：内存并不会在每500个用户一组执行完后恢复，而是一直持续消耗到仅存约70MB时，gc才好像起作用。本环境中，机器使用的是Cloud instance，总内存2G，可用内存约为1G，本脚本内存常用消耗是900M - 1G。换句话说，对于这个脚本来说，gc并没有立即起作用，而是在系统可用内存从1 - 1.2G下降到只剩70M左右时，gc才开始发挥作用。这点确实比较奇怪，不知道和该脚本是在Thread中使用的gc.collect()是否有关，或者是gc发挥作用原本就不是可控的。笔者尚未做相关实验，可能在下篇博客中继续探讨。

但是，可以肯定的是，若不使用gc.collect(), 原脚本将会将系统内存耗尽而被杀死。这一点从syslog中可以明显看出。

‘伍’ 如何释放Python占用的内存

1.充分利用内存
任何一种图像处理软件对内存的要求都很高，Photoshop也一样。如果你在使用Photoshop时，没有使用其它的一些大软件，这时你就可以将Photoshop占用内存资源的比例提高。方法是：进行Photoshop，选择菜单下File\Preference\Memory & Image Cache命令，将Used by Photoshop的比例提高到80%~90%即可。
2.指定虚拟内存
在处理Photoshop时，内存被用完是很正常的，到时会大大影响Photoshop处理图像的时间，哪将怎么解决呢？方法是：你可以用硬盘来作为内存来使用，也就是常说的虚拟内存。请选择菜单下“File\Preference\Plug-Ins & Scratch Disks”命令。在这里的Scratch Disks下，你可以在硬盘上指定四个驱动器来作为虚拟内存，软件默认的虚拟内存是在Windows\temp之下。当第一个虚拟内存被使用光之后，Photoshop会自动去使用第二个Scratch Dsik，这样就提高了执行速度。
3.释放内存与硬盘空间
在进行图像处理时，你所进行的所有操作将会记录在Photoshop的History（历史记录）工作板中。这些操作包括：复制到Clipboard（粘贴板）、Undo（恢复）、Pattern（填充物）、Histories（记录）等几种，选择菜单下“Edit\Purge”命令。
进行这些操作之后，Photoshop会将这些图像和数据保存在内存里，使用该命令后，即将这些被占用的内存空间释放出来（RAM：Oh! Freeden）这样就让Photoshop有更多的Resource（资源）可用，自然就提高了效率。但注意，如果这些操作占用的内存比较少时，就没有必要使用啦！
除此之外，在处理大型图片时，Photoshop会自动产生一些临时文件，一般都很大，如果你处理的是一个20MB大小的宣传画时，那么临时文件可能就是100~150MB。请在Windows\temp或在你设定虚拟内存的驱动器里，将产生的Photoshop临时文件*.tmp删除掉。

‘陆’ 退出python程序释放占用内存

一般情况下不会占内存，而且Python的内存需要的很小。如果用模拟器的话需要退出一下，输入close就可以了。请采纳，谢谢。

‘柒’ pythontimer占用内存

python程序在运行过程之中会单独开辟出一个进程来执行，而很多小伙伴都发现程序在运行过程之中所占用的内存会越来越大，但是不知道是什么原因以及如何解决。那么下文会来讲解一下python程序内存占用过大的原因和解决方法，感兴趣的和有需要的话就往下看看吧。



一、原因

首先需要知道的一点就是，python是面向对象编程的语言，那么就表示在其程序之中一切皆为对象。而每一个对象在创建是都会在内存中开辟空间来占用位置，这样就会造成一开始的内存占用。

虽然说python中有自己的内存管理机制和垃圾处理方式，但是它对于一些占用内存过多的对象不会马上释放，只有当这个对象不处于引用状态时才会处理它。

二、解决方法

既然知道了python程序内存都是因为有对象才将其占用的，那么正确的解决方法就是将对象在调用完毕之后马上删除掉。该方法需要用到关键字del和gc模块，使用del关键字删除变量之后，调用gc模块来马上启动python垃圾处理机制就可以直接将其彻底从内存空间清除，代码示例如下所示：

‘捌’ Python 多进程内存占用问题

当我们有一个很长很长的任务队列(mission_list)和阈值对应的一个处理函数(missionFunction)时，我们一般采用如下的方式进行处理：

但是，如果这任务列表很长很长，处理函数很复杂(占用cpu)时，单核往往需要很长的时间进行处理，此时，Multiprocess便可以极大的提高我们程序的运行速度，相关内容请借鉴 multiprocessing --- 基于进程的并行 — Python 3.10.4 文档。

以上这种场景下，推荐大家采用最简单的进程池+map的方法进行处理，标准的写法， chunksize要借鉴官方的说法，最好大一点 ：

但是！！！！ 如果我们的任务列表非常的长，这会导致多进程还没跑起来之前，内存已经撑爆了，任务自然没法完成，此时我们有几种办法进行优化：

进程的启动方法有三种，可参考官方文档：

[图片上传失败...(image-48cd3c-1650511153989)]

在linux环境下，使用forkserver可以节省很多的内存空间， 因为进程启动的是一个服务，不会把主进程的数据全部复制

采用imap会极大的节省空间，它返回的是一个迭代器，也就是结果列表：

但注意，以上写法中，你写的结果迭代部分必须写在with下面。或者采用另一种写法：

还有最后一种，当你的mission list实在太大了，导致你在生成 mission list的时候已经把内存撑爆了，这个时候就得优化 mission_list了，如果你的mission_list是通过一个for循环生成的，你可以使用yield字段，将其封装为一个迭代器，传入进程池：

这样子，我们就封装好了mission_list，它是一个可迭代对象，在取数据的时候才会将数据拉到内存

我在项目中结合了后两种方法，原本256G的内存都不够用，但在修改后内存只占用了不到10G。希望能够帮助到你

‘玖’ 如何使用Python动态控制Linux系统的内存占用百分比

如何使用Python动态控制Linux系统的内存占用百分比?

近期有网上朋友寻求帮助：如何通过脚本动态控制Linux系统的内存占用百分比？经过一番网络+编写调试，终于初步完成了动态控制Linux系统内存占用百分比。现写出来以帮助更多的朋友。
1 前言
根据需求是动态控制Linux系统内存占用百分比，比如当前内存占用30%，如果设置内存占用为70%，则需要申请内存使达到占用70%；如果再降低到40%，则需要释放部分申请的内存。其实脚本的本质是内存动态申请与释放。
注意：因为Python脚本运行之前内存有一定占用，故设定内存占用不能低于该百分比。
2 内存动态申请
通过查询资料，使用Python动态申请内存块，可以使用ctypes包中的函数，导入包及代码如下所示：
>>> from ctypes import *
>>> mem=create_string_buffer(1024)
说明：内存申请使用create_string_buffer()函数，上面申请了1024字节的内存块。
下面演示申请100MB内存前后变化
申请前如下图所示：

使用代码如下：
>>>mem=create_string_buffer(104857600)
申请后如下图所示：

从上述两幅图中可以看出，申请内存前内存占用295MB，申请后内存占用397MB，增加了约100MB内存占用。
3 内存动态释放
由于Python对内存是有垃圾回收机制的，采用对象引用计数方式。当对象的引用计数为0时，启动垃圾回收GC。此处内存动态释放就是使用该原理。
代码如下：
>>> mem=None
释放后内存占用如下图所示：

内存占用由397MB降低到297MB，释放了100MB内存占用。
说明：将None赋值给对象mem后，mem对象的引用计数即为0，此时垃圾回收启动，释放mem对象占用的内存。
4 系统总内存、占用内存检测
由于需要设定内存占用百分比，故需要获取系统总物理内存和占用内存。本文使用的方法是读取系统文件“/proc/meminfo”，从中解析出总内存大小以及当前内存占用大小等内存相关的信息。该文件内容格式如下图所示：

代码片段如下所示：
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)< 2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
说明：按行读取meminfo文件内容，创建字典对象mem，将meminfo文件第一列设置为mem对象的键值，将meminfo文件第二列数字设置为mem对象的值。
5 获取用户输入百分比
通过读取键盘输入字符串，然后转换为数字实现接收用户输入的百分比，代码如下所示：
input_str=raw_input("Input UsedMemory`s Rate or q to exit:")
rate=float(input_str)
注意：此处键盘输入的都是字符串，需要进行字符串转换为数字，使用float()或long()函数进行转换。
6 动态设置内存占用百分比测试
测试使用两个Python脚本文件，分别是test.py和mem_rate.py，其功能分别是查看当前内存占用和动态设定内存占用百分比。如下图所示：

注意：上述两个文件需要使用“chmod +x *.py”修改为可执行属性。
6.1 查看当前内存占用
查看当前内存占用百分比，使用上述test.py文件，运行命令为“./test.py”，运行结果如下图所示：

当前使用内存为320MB，占用百分比为17%。
6.2 动态设置内存占用百分比
动态设置内存占用百分比使用上述mem_rate.py脚本，注意该脚本文件第一行代码为“#!/usr/bin/python2.6”，表示该脚本使用python2.6程序运行。该行需要修改为待运行Linux系统中Python实际的安装程序路径。
动态内存百分比设置界面如下图所示：

处于待输入状态。另外显示了当前内存占用（321MB），总内存大小（1869MB）以及内存占用百分比（17%）。
如果此时设置内存占用百分比为80%，则脚本会每次申请10MB空间，直至内存占用接近或等于80%为止。如下图所示：

内存申请过程如下图所示：

内存申请过程中占用百分比变化为：35%，45%，56%，70%，…
mem_rate.py运行过程如下图所示：

内存申请过程中占用变化为：1461MB，1471MB，1481MB，1491MB。
此时如果内存占用百分比设置为20%，则需要释放一部分内存。
test.py脚本运行过程如下图所示：
由于释放内存运行较快，抓取到最后结果

内存占用为20%。
mem_rate.py脚本运行过程如下图所示：

内存释放过程中内存占用为：413MB，403MB，393MB，383MB，最后内存占用稳定在20%，383MB。
输入“q”或“Q”退出内存占用百分比设定过程，如下图所示：

此时内存占用如下图所示：

内存占用恢复到运行mem_rate.py脚本之前状态，17%，321MB。

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※
附：完整Python脚本代码
test.py
------------------------------------------------------------------------------------------------
#!/usr/bin/python2.6
def memory_stat():
mem = {}
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)< 2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
# - mem['Buffers']- mem['Cached']
return mem

mem=memory_stat()
print("Used(MB):%d"%(long(mem['MemUsed'])/1024/1024))
print("Rate:%d%%"%(100*long(mem['MemUsed'])/float(mem['MemTotal'])))

§§§§§§§§§§§§§§§§§§§§§§§§§§
mem_rate.py
---------------------------------------------------
#!/usr/bin/python2.6

from ctypes import *

# Get Memory Info(Total, Used... Byte)
def get_memory_stat():
mem = {}
f = open("/proc/meminfo")
lines = f.readlines()
f.close()
for line in lines:
if len(line)< 2:continue
name = line.split(':')[0]
var = line.split(':')[1].split()[0]
mem[name]= long(var)* 1024.0
mem['MemUsed']= mem['MemTotal']- mem['MemFree']
# Return MemroyInfo Object
return mem

# Get Simple Memory Info
def get_memory_info(mem):
# Byte -> MB
n=1024* 1024
used=float(mem['MemUsed'])/ n
total=float(mem['MemTotal'])/ n
rate=used/total* 100
smp={'used':used,'total':total,'rate':rate}
return smp

# Display Current Memory Info
def print_memory_info(mem):
# Get SimpleMemory Info
smp=get_memory_info(mem)
print("Used(MB):%d\tTotal(MB):%d\tUsedRate:%d%%"%(smp['used'], smp['total'], smp['rate']))

# Get Rate Of Memory Used To Be Setted(Integer Formate)
def input_memory_used_rate(org_rate):
# Byte -> MB
n=1024* 1024
while(True):
mem=get_memory_stat()
print_memory_info(mem)

input_str=raw_input("Input UsedMemory`s Rate or q to exit:")
if(len(input_str)== 0):
continue
if("q"== input_str):
info={'rate':0,'used':mem['MemUsed']/ n}
return info
if("Q"== input_str):
info={'rate':0,'used':mem['MemUsed']/ n}
return info
try:
rate=float(input_str)
if((rate>=org_rate)and (rate<=95)):
info={'rate':rate,'used':mem['MemUsed']/ n}
return info
else:
print("Please inputa valid number(%d%%~95%%)."%(org_rate))
except:
print("Please inputa valid number(%d%%~95%%)."%(org_rate))

# Set Rate Of Memory Used
def set_memory_used_rate(new_rate, total, pre_used,list):
if(new_rate==0):
return None
dest_mem=total* new_rate /100.0
# 10MB
mb10=10485760
n_chg=10
# Free Memory OrAllocate Memory ?
is_new=dest_mem>pre_used
cur_used=pre_used
while(True):
# To Calc FreeMemory Or Allocate Memory ?
need_new=dest_mem-n_chg>=pre_used
need_del=dest_mem+n_chg<=pre_used

# Need To AllocateMemory
if(is_new):
if(need_new):
p=create_string_buffer(mb10)
list.append(p)
dest_mem=dest_mem-n_chg
cur_used=cur_used+n_chg
else:
return"end"
# Need To FreeMemory
else:
idx=len(list)-1
if(need_deland (idx>=0)):
p=list[idx]
del list[idx]
p=None
dest_mem=dest_mem+n_chg
cur_used=cur_used-n_chg
else:
return"end"
print("****** MemoryUsed(MB):%d"%(cur_used))

# Entry Of Program

# List Of Memory Object, 10MB Of One Object
list=[]
# Get Current Memory Info
mem=get_memory_stat()
# Get Simple Memory Info
smp=get_memory_info(mem)
org_rate=smp['rate']
total=smp['total']

while(True):
# Get Rate OfMemory To Be Used
info=input_memory_used_rate(org_rate)
new_rate=float(info['rate'])
pre_used=float(info['used'])
# Set Rate OfMemory To Be Used
rtn=set_memory_used_rate(new_rate, total, pre_used, list)
if(not rtn):
print("bye!")
exit()

‘拾’ 如何释放Python占用的内存

释放Python占用的内存
象的引用计数减少；
函数运行结束，所有局部变量都被销毁，对象的引用计数也就随之减少。例如 foo(x) 运行结束，x 被销毁；
当变量被赋值给另一个对象时，原对象的引用计数也会减少。例如 x = 4，这时候 3 这个对象的引用计数就减 1 了；
使用 del 删除一个变量也会导致对象引用减少。例如 del x；
对象从集合对象中移除。例如 lst.remove(x)；
包含对象的集合对象被销毁。例如 del lst；
这些操作都可能使对象变成垃圾回收对象，由垃圾收集器负责收集，当然垃圾收集器也负责处理循环引用对象。
要立即释放，可以使用下面的代码
import gc
gc.collect()