锐客网

  1. 首页 > 睿知 > it技术 > >

python函数调用内存 python函数内调用函数

IT技术对象

怎么让python在内存中运行对象的内存使用
赋值语句是语言最常见的功能了 。但即使是最简单的赋值语句 ， 也可以很有内涵 。Python的赋值语句就很值得研究 。
a = 1
整数1为一个对象 。而a是一个引用 。利用赋值语句，引用a指向对象1 。Python是动态类型的语言(参考动态类型)，对象与引用分离 。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象 。
引用和对象
为了探索对象在内存的存储，我们可以求助于Python的内置函数id() 。它用于返回对象的身份(identity) 。其实，这里所谓的身份 ， 就是该对象的内存地址 。
a = 1
print(id(a))
print(hex(id(a)))
在我的计算机上，它们返回的是:
11246696
'0xab9c68'
分别为内存地址的十进制和十六进制表示 。
在Python中，整数和短小的字符 ， Python都会缓存这些对象 ， 以便重复使用 。当我们创建多个等于1的引用时 ， 实际上是让所有这些引用指向同一个对象 。
a = 1
b = 1
print(id(a))
print(id(b))
上面程序返回
11246696
11246696
可见a和b实际上是指向同一个对象的两个引用 。
为了检验两个引用指向同一个对象，我们可以用is关键字 。is用于判断两个引用所指的对象是否相同 。
# True
a = 1
b = 1
print(a is b)
# True
a = "good"
b = "good"
print(a is b)
# False
a = "very good morning"
b = "very good morning"
print(a is b)
# False
a = []
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 = a
print(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 。
容器对象的引用可能构成很复杂的拓扑结构 。我们可以用objgraph包来绘制其引用关系，比如
x = [1, 2, 3]
y = [x, dict(key1=x)]
z = [y, (x, y)]
import objgraph
objgraph.show_refs([z], filename='ref_topo.png')
objgraph是Python的一个第三方包 。安装之前需要安装xdot 。
【python函数调用内存 python函数内调用函数】sudo apt-get install xdot
sudo pip install objgraph
objgraph官网
两个对象可能相互引用，从而构成所谓的引用环(reference cycle) 。
a = []
b = [a]
a.append(b)
即使是一个对象，只需要自己引用自己 ， 也能构成引用环 。
a = []
a.append(a)
print(getrefcount(a))
引用环会给垃圾回收机制带来很大的麻烦，我将在后面详细叙述这一点 。
引用减少
某个对象的引用计数可能减少 。比如 ， 可以使用del关键字删除某个引用:
from sys import getrefcount
a = [1, 2, 3]
b = a
print(getrefcount(b))
del a
print(getrefcount(b))
del也可以用于删除容器元素中的元素，比如:
a = [1,2,3]
del a[0]
print(a)
如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少:
from sys import getrefcount
a = [1, 2, 3]
b = a
print(getrefcount(b))
a = 1
print(getrefcount(b))
垃圾回收
吃太多，总会变胖，Python也是这样 。当Python中的对象越来越多 ， 它们将占据越来越大的内存 。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥” ， 启动垃圾回收(garbage collection)，将没用的对象清除 。在许多语言中都有垃圾回收机制，比如Java和Ruby 。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收
) 。
从基本原理上 ， 当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了 。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1 。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收 。比如下面的表:
a = [1, 2, 3]
del a
del a后 ， 已经没有任何引用指向之前建立的[1, 2, 3]这个表 。用户不可能通过任何方式接触或者动用这个对象 。这个对象如果继续待在内存里，就成了不健康的脂肪 。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空 。
然而，减肥是个昂贵而费力的事情 。垃圾回收时，Python不能进行其它的任务 。频繁的垃圾回收将大大降低Python的工作效率 。如果内存中的对象不多 ， 就没有必要总启动垃圾回收 。所以，Python只会在特定条件下，自动启动垃圾回收 。当Python运行时 ， 会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数 。当两者的差值高于某个阈值时，垃圾回收才会启动 。
我们可以通过gc模块的get_threshold()方法，查看该阈值:
import gc
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代对象进行更频繁的扫描 。
import gc
gc.set_threshold(700, 10, 5)
孤立的引用环
引用环的存在会给上面的垃圾回收机制带来很大的困难 。这些引用环可能构成无法使用，但引用计数不为0的一些对象 。
a = []
b = [a]
a.append(b)
del a
del b
上面我们先创建了两个表对象，并引用对方，构成一个引用环 。删除了a ， b引用之后 ， 这两个对象不可能再从程序中调用，就没有什么用处了 。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收 。
孤立的引用环
为了回收这样的引用环 ， Python复制每个对象的引用计数 ， 可以记为gc_ref 。假设，每个对象i，该计数为gc_ref_i 。Python会遍历所有的对象i 。对于每个对象i引用的对象j，将相应的gc_ref_j减1 。
遍历后的结果
在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留 。而其它的对象则被垃圾回收 。
Python 外部函数调用库ctypes简介一直对不同语言间python函数调用内存的交互感兴趣python函数调用内存，python和C语言又深有渊源，所以对python和c语言交互产生了兴趣 。
最近了解了python提供的一个外部函数库ctypes , 它提供了C语言兼容的几种数据类型，并且可以允许调用C编译好的库 。
这里是阅读相关资料的一个记录，内容大部分来自 官方文档。
ctypes提供了一些原始的C语言兼容的数据类型，参见下表,其中第一列是在ctypes库中定义的变量类型，第二列是C语言定义的变量类型，第三列是Python语言在不使用ctypes时定义的变量类型 。
创建简单的ctypes类型如下:
使用.value访问和改变值:
改变指针类型的变量值:
如果需要直接操作内存地址的数据类型：
下面的例子演示了使用C的数组和结构体:
创建指针实例
使用cast()类型转换
类似于C语言定义函数时，会先定义返回类型，然后具体实现再定义，当遇到下面这种情况时 ， 也需要这么干:
可以简单地将"so"和"dll"理解成Linux和windows上动态链接库的指代，这里我们以Linux为例 。注意，ctypes提供的接口会在不同系统上有出入，比如为了加载动态链接库 ， 在Linux上提供的是cdll , 而在Windows上提供的是windll和oledll。
ctypes会寻找_as_paramter_属性来用作调用函数的参数传入 ， 这样就可以传入自己定义的类作为参数，示例如下:
用argtypes和restype来指定调用的函数返回类型 。
这里我只是列出了ctypes最基础的部分 ， 还有很多细节请参考官方文档 。
这两天文章没有写 ， 先是早出晚归出去玩了一整天，然后加班到凌晨3点左右，一天一篇计划划水得严重啊…
python的内存管理机制论坛
活动
招聘
专题
打开CSDN APP
Copyright ? 1999-2020, CSDN.NET, All Rights Reserved
登录
XCCS_澍
关注
Python 的内存管理机制及调优手段？ 原创
2018-08-05 06:50:53
XCCS_澍
码龄7年
关注
内存管理机制：引用计数、垃圾回收、内存池 。
一、引用计数：
引用计数是一种非常高效的内存管理手段，当一个 Python 对象被引用时其引用计数增加 1，当其不再被一个变量引用时则计数减 1. 当引用计数等于 0 时对象被删除 。
二、垃圾回收 ：
1. 引用计数
引用计数也是一种垃圾收集机制，而且也是一种最直观，最简单的垃圾收集技术 。当 Python 的某个对象的引用计数降为 0 时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了 。比如某个新建对象，它被分配给某个引用，对象的引用计数变为 1 。如果引用被删除，对象的引用计数为 0 ， 那么该对象就可以被垃圾回收 。不过如果出现循环引用的话，引用计数机制就不再起有效的作用了
2. 标记清除
如果两个对象的引用计数都为 1，但是仅仅存在他们之间的循环引用，那么这两个对象都是需要被回收的，也就是说，它们的引用计数虽然表现为非 0，但实际上有效的引用计数为 0 。所以先将循环引用摘掉，就会得出这两个对象的有效计数 。
3. 分代回收
从前面“标记-清除”这样的垃圾收集机制来看，这种垃圾收集机制所带来的额外操作实际上与系统中总的内存块的数量是相关的，当需要回收的内存块越多时，垃圾检测带来的额外操作就越多，而垃圾回收带来的额外操作就越少；反之 ， 当需回收的内存块越少时，垃圾检测就将比垃圾回收带来更少的额外操作 。
Python如何进行内存管理Python的内存管理，一般从以下三个方面来说：
1)对象的引用计数机制(四增五减)
2)垃圾回收机制(手动自动 ， 分代回收)
3)内存池机制(大m小p)
1)对象的引用计数机制
要保持追踪内存中的对象，Python使用了引用计数这一简单的技术 。sys.getrefcount(a)可以查看a对象的引用计数，但是比正常计数大1，因为调用函数的时候传入a，这会让a的引用计数 1
2)垃圾回收机制
吃太多，总会变胖，Python也是这样 。当Python中的对象越来越多，它们将占据越来越大的内存 。不过你不用太担心Python的体形，它会在适当的时候“减肥”，启动垃圾回收(garbage
collection)，将没用的对象清除
从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了
比如某个新建对象，它被分配给某个引用，对象的引用计数变为1 。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收 。
然而，减肥是个昂贵而费力的事情 。垃圾回收时 ， Python不能进行其它的任务 。频繁的垃圾回收将大大降低Python的工作效率 。如果内存中的对象不多，就没有必要总启动垃圾回收 。
所以，Python只会在特定条件下 ， 自动启动垃圾回收 。当Python运行时，会记录其中分配对象(object
allocation)和取消分配对象(object deallocation)的次数 。当两者的差值高于某个阈值时，垃圾回收才会启动 。
我们可以通过gc模块的get_threshold()方法，查看该阈值 。
3)内存池机制
Python中有分为大内存和小内存：(256K为界限分大小内存)
1、大内存使用malloc进行分配
2、小内存使用内存池进行分配
python中的内存管理机制都有两套实现，一套是针对小对象，就是大小小于256K时，pymalloc会在内存池中申请内存空间;当大于256K时 ， 则会直接执行系统的malloc的行为来申请内存空间 。
python内存管理机制由于python中万物皆对象，所以python的存储问题是对象的存储问题 。实际上，对于每个对象，python会分配一块内存空间去存储它 。
那么python是如何进行内存分配，如何进行内存管理 ， 又是如何释放内存的呢？
总结起来有一下几个方面：引用计数，垃圾回收，内存池机制
python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数
1、对象被创建a= 'abc'
2、对象被引用b =a
3、对象被其他的对象引用li = [1,2,a]
4、对象被作为参数传递给函数：foo(x)
1、变量被删除del a 或者 del b
2、变量引用了其他对象b = c或者 a = c
3、变量离开了所在的作用域（函数调用结束）比如上面的foo(x)函数结束时，x指向的对象引用减1 。
4、在其他的引用对象中被删除（移除）li.remove(a)
5、窗口对象本身被销毁：del li，或者窗口对象本身离开了作用域 。
即对象p中的属性引用d，而对象d中属性同时来引用p，从而造成仅仅删除p和d对象，也无法释放其内存空间 ， 因为他们依然在被引用 。深入解释就是，循环引用后，p和d被引用个数为2，删除p和d对象后 ， 两者被引用个数变为1，并不是0，而python只有在检查到一个对象的被引用个数为0时，才会自动释放其内存 ， 所以这里无法释放p和d的内存空间
垃圾回收机制: ① 引用计数 , ②标记清除 , ③分带回收
引用计数也是一种垃圾收集机制, 而且也是一种最直观, 最简单的垃圾收集技术.当python某个对象的引用计数降为 0 时, 说明没有任何引用指向该对象, 该对象就成为要被回收的垃圾了.(如果出现循环引用的话, 引用计数机制就不再起作用了)
优点:简单实时性，缺点：维护引用计数消耗资源，且无法解决循环引用 。
如果两个对象的引用计数都为 1 , 但是仅仅存在他们之间的循环引用,那么这两个对象都是需要被回收的, 也就是说 它们的引用计数虽然表现为非 0 , 但实际上有效的引用计数为 0 ,.所以先将循环引用摘掉, 就会得出这两个对象的有效计数.
标记清除算法也有明显的缺点：清除非活动的对象前它必须顺序扫描整个堆内存，哪怕只剩下小部分活动对象也要扫描所有对象 。
为了提高效率，有很多对象 ， 清理了很多次他依然存在，可以认为 ， 这样的对象不需要经常回收 ， 可以把它分到不同的集合，每个集合回收的时间间隔不同 。简单的说这就是python的分代回收 。
具体来说，python中的垃圾分为1，2 ， 3代，在1代里的对象每次回收都会去清理，当清理后有引用的对象依然存在 ， 此时他会进入2代集合，同理2代集合清理的时候存在的对象会进入3代集合 。
每个集合的清理时间如何分配：会先清理1代垃圾，当清理10次一代垃圾后会清理一次2代垃圾 ， 当清理10次2代垃圾后会清理3代垃圾 。
在Python中，许多时候申请的内存都是小块的内存，这些小块内存在申请后 ， 很快又会被释放，当创建大量消耗小内存的对象时 ， 频繁调用new/malloc会导致大量的内存碎片，致使效率降低 。
内存池的概念就是预先在内存中申请一定数量的 ， 大小相等的内存块留作备用，当有新的内存需求时 ， 就先从内存池中分配内存给这个需求，不够了之后再申请新的内存 。这样做最显著的优势就是能够减少内存碎片，提升效率 。
Python中有分为大内存和小内存：（256K为界限分大小内存）
大小小于256kb时，pymalloc会在内存池中申请内存空间 ， 当大于256kb，则会直接执行 new/malloc 的行为来申请新的内存空间
在python中 -5到256之间的数据，系统会默认给每个数字分配一个内存区域，其后有赋值时都会指向固定的已分配的内存区域
在运行py程序的时候，解释器会专门分配一块空白的内存，用来存放纯单词字符组成的字符串（数字，字母，下划线）
字符串赋值时，会先去查找要赋值的字符串是否已存在于内存区域，已存在，则指向已存在的内存，不存在，则会在大整数池中分配一块内存存放此字符串
python如何进行内存管理Python的内存管理主要有三种机制：引用计数机制，垃圾回收机制和内存池机制 。
引用计数机制
简介
python内部使用引用计数，来保持追踪内存中的对象 ， Python内部记录了对象有多少个引用 ， 即引用计数 ， 当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收 。
特性
1.当给一个对象分配一个新名称或者将一个对象放入一个容器(列表、元组或字典)时 ， 该对象的引用计数都会增加 。
2.当使用del对对象显示销毁或者引用超出作用于或者被重新赋值时，该对象的引用计数就会减少 。
3.可以使用sys.getrefcount()函数来获取对象的当前引用计数 。多数情况下，引用计数要比我们猜测的大的多 。对于不可变数据(数字和字符串)，解释器会在程序的不同部分共享内存 ， 以便节约内存 。
垃圾回收机制
特性
1.当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉 。它会去检查那些引用计数为0的对象，然后清除其在内存的空间 。当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时 ， 他们本身其他的引用已经为0了 。
2.垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0) 。
内存池机制
简介
在Python中，许多时候申请的内存都是小块的内存，这些小块内存在申请后，很快又会被释放，由于这些内存的申请并不是为了创建对象 ， 所以并没有对象一级的内存池机制 。这就意味着Python在运行期间会大量地执行malloc和free的操作，频繁地在用户态和核心态之间进行切换，这将严重影响Python的执行效率 。为了加速Python的执行效率 ， Python引入了一个内存池机制，用于管理对小块内存的申请和释放 。
内存池概念
内存池的概念就是预先在内存中申请一定数量的 ， 大小相等的内存块留作备用 ， 当有新的内存需求时，就先从内存池中分配内存给这个需求，不够了之后再申请新的内存 。这样做最显著的优势就是能够减少内存碎片，提升效率 。内存池的实现方式有很多 ， 性能和适用范围也不一样 。
特性
1.Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统 。
2.Pymalloc机制 。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放 。
3.Python中所有小于256个字节的对象都使用pymalloc实现的分配器 ， 而大的对象则使用系统的 malloc 。
4.对于Python对象，如整数，浮点数和List，都有其独立的私有内存池 ， 对象间不共享他们的内存池 。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数 。
python函数调用内存的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python函数内调用函数、python函数调用内存的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：如何修改服务器硬盘的命名？ 怎么改服务器的硬盘名称

    下一篇：虚拟大师安卓6.0rom，虚拟大师安卓12版本