锐客网

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

包含python释放空间函数的词条

函数IT技术

python中的delete函数是如何使用的？我要纠正推荐答案中的说法！
del并不是用来“删除引用指向的内存空间” ， python中的del和c中的delete是完全两个概念，不要误人子弟 。。
一般来讲，del是用来删除变量的引用的，例如a = 1; del a，这里a是对1这个值的引用（python中所有的变量都可视作引用） ， 而del a就是删除这一引用关系，也就是说，1不再被a这个变量引用了，同时a这个变量名也从变量表中剔除了 。
如果还是不太清楚，我举这个例子你就明白了：
a = object()
b = a
del a
print b
print a# 该句会报a未定义的异常
这段代码中，a引用了一个新对象object()，而b=a使得b也引用了这个对象，a和b虽然是两个变量，但它们引用的是同一个对象，有点类似于c中的两个指针指向同一个对象 。
而后面del a仅仅只是把a这个变量对object()的引用删掉了 ， 同时a的变量名也失效了，但并不表示object()这个对象被删除了 ， 它还在，并且b还引用着它呢 。从后面print b能正常输出就可以看出这一点 。
python的内存释放采用的是引用计数机制，也就是当一个对象没有任何引用它的变量了，那么它就会自动被释放，无需人工干预 。
此外，del对于不同的对象也会有不同的功能 ， 这取决于对象本身对__del__系统方法的实现 。例如一个列表a = [1,2,3]，del a[0]表示将列表的首项删除 ， 此时a就变成[2,3]了 。如果是自定义的对象，那del的功能更是可以定义成你想要的任何样子，详情请参考python帮助中的__del__词条 。
如何用Python封装C语言的字符串处理函数【包含python释放空间函数的词条】在C语言中python释放空间函数，字符串处理是每天都要面对的问题 。我们都知道C语言中其实并没有一种原生的字符串类型python释放空间函数，‘字符串’在C语言里只是一种特殊的以''结尾的字符数组 。因此，如何将C语言与更高层次的Python语言在‘字符串’处理这个问题上对接是一个有难度的问题 。所幸有swig这种强大的工具 。
如何封装一个函数 ， 它修改参数字符串的内容
假如有这样一个C语言的函数，
!-- lang: cpp --
void FillZero(char* pc,size_t * piLen)
{
size_t i=0;
while(i*piLen/2 )
*pc= '0';
*pc = 0;
*piLen = i 1;
}
这个函数的功能是把字符串变成n个0 。不过我们更关注函数的形式 。这样的函数，表面上看char* pc是函数的参数 ， 可是实际上它才是函数的返回值和执行的结果 。piLen这个参数既是pc的最大长度，也是新的字符串的长度 。我们直接用python封装，看看运行结果 。
Type "help", "copyright", "credits" or "license" for more information.
import cchar
s='123456'
cchar.FillZero(s,6)
Traceback (most recent call last):
File "stdin", line 1, in module
TypeError: in method 'FillZero', argument 2 of type 'size_t *'
结果差强人意，不是我们想要得到的结果 。函数的第二个参数为size_t* 我们很难用python来表示，而且python中也不存在既是输入 ， 也是输出的参数 。
swig有一个标准库，其中有一个cstring.i文件就是用来解决C语言字符串类型的问题 。
我们在.i文件中加入这样几行
!-- lang: cpp --
%include "cstring.i"
%cstring_output_withsize(char* pc,size_t* pi)
void FillZero(char* pc, size_t* pi);
然后运行看结果
Type "help", "copyright", "credits" or "license" for more information.
import cchar
cchar.FillZero(10)
'00000\x00'
s=cchar.FillZero(10)
print s
00000
我们看函数的变化 。首先在python里 ， FillZero变成python释放空间函数了只有一个参数的函数 。然后函数的返回值变成了一个字符串 。其实cstring_output_size其实是一个宏，通过这个宏的定义改变了函数的形式，直接在Python中得到我们想要的结果 。
其实类似cstring_output_size的宏还有好几个，我列举一下:
cstring_output_allocate(char *s,free($1));
第一个参数是指向字符串地址的指针 ， 第二个参数为释放空间的方法 。
大家考虑这一下这样的函数：
void foo(char*s)
{
s = (char*)malloc(10);
memcpy(s,"123456789",9);
}
s这个参数表面上看是输入，实际上是函数真正的输出 。函数中真正改变的东西是chars指向的字符串的值 。而且char这个类型,
python或者其他脚本语言里应该都没有对应的类型 。那么我们用cstring_output_allocate将这个函数转换成另外一个形式的python或者其他脚本语言的函数 。转换后的函数其实是这样的，以python为例str
foo() 。
!-- lang: cpp --
%module a
%include "cstring.i"
%{
void foo(char* s);
%}
%cstring_output_allocate(char *s, free(*$1));
void foo(char *s);
在python中的调用：
!-- lang: python --
import a
a.foo()
'123456789'
cstring_output_maxsize(char *path, int maxpath);
第一个参数也是可以改变的字符串首地址，第二个参数为字符串的最大长度 。在Python中调用的时候，只有maxpath这个参数，返回字符串 。
cstring_output_allocate(char *s, free($1));
第一个参数为指向字符串首地址的指针，第二个参数为释放指针的方法 。这个宏主要是封装一种直接在函数内部malloc空间的函数 。在Python中调用时没有参数 ， 直接返回字符串 。
cstring_output_allocate_size(char *s, int slen, free(*$1));
这个相当于前面两个函数的组合 。在函数内部malloc空间，然后将字符串长度通过slen返回 。其实在调用的时候非常简单，没有参数，直接返回字符串 。
如何处理c的std::string
std::string是C标准类库STL中常见的类 。在平时工作中大家肯定是没少用 。在python中如何封装std::string? swig提供了标准库
例如函数:
!-- lang: cpp --
string Repeat(const string s)
{
return s s;
}
只要在swig中加入这样几行：
!-- lang: cpp --
%include "std_string.i"
using namespace std;
string Repeat(const string s);
运行结果：
Python 2.6.6 (r266:84292, Dec 27 2010, 00:02:40)
[GCC 4.4.5] on linux2
Type "help", "copyright", "credits" or "license" for more information.
import cchar
cchar.Repeat('123')
'123123'
使用起来很方便，但需要注意的是，假如函数的参数的内容是可以被修改，就不能用这种方式封装 。
例如:
!-- lang: cpp --
void repeat(string s)
{
s =s;
}
这样的函数直接使用 'std_string.i' 就是无效的 。遇到这种函数，只能用C语言封装成 void repeat(chars, int maxsize), 再用swig调用 'cstring_output_withsize' 这个宏再封装一次了 。
面试必备 - Python 垃圾回收机制众所周知 ， Python 是一门面向对象语言，在 Python 的世界一切皆对象 。所以一切变量的本质都是对象的一个指针而已 。
Python 运行过程中会不停的创建各种变量，而这些变量是需要存储在内存中的，随着程序的不断运行，变量数量越来越多 ， 所占用的空间势必越来越大 ， 如果对变量所占用的内存空间管理不当的话，那么肯定会出现 out of memory 。程序大概率会被异常终止 。
因此，对于内存空间的有效合理管理变得尤为重要，那么 Python 是怎么解决这个问题的呢 。其实很简单 ， 对不不可能再使用到的内存进行回收即可，像 C 语言中需要程序员手动释放内存就是这个道理 。但问题是如何确定哪些内存不再会被使用到呢python释放空间函数？这就是我们今天要说的垃圾回收python释放空间函数了 。
目前垃圾回收比较通用的解决办法有三种，引用计数，标记清除以及分代回收 。
引用计数也是一种最直观，最简单的垃圾收集技术 。在 Python 中，大多数对象的生命周期都是通过对象的引用计数来管理的 。其原理非常简单 ， 我们为每个对象维护一个 ref 的字段用来记录对象被引用的次数 ， 每当对象被创建或者被引用时将该对象的引用次数加一，当对象的引用被销毁时该对象的引用次数减一，当对象的引用次数减到零时说明程序中已经没有任何对象持有该对象的引用 ， 换言之就是在以后的程序运行中不会再次使用到该对象了，那么其所占用的空间也就可以被释放了了 。
我们来看看下面的例子 。
函数 print_memory_info 用来获取程序占用的内存空间大小 ， 在 foo 函数中创建一个包含一百万个整数的列表 。从打印结果我们可以看出，创建完列表之后程序耗用的内存空间上升到了 55 MB 。而当函数 foo 调用完毕之后内存消耗又恢复正常 。
这是因为我们在函数 foo 中创建的 list 变量是局部变量 ， 其作用域是当前函数内部，一旦函数执行完毕，局部变量的引用会被自动销毁，即其引用次数会变为零，所占用的内存空间也会被回收 。
为了验证我们的想法，我们对函数 foo 稍加改造 。代码如下python释放空间函数：
稍加改造之后，即使 foo 函数调用结束其所消耗的内存也未被释放 。
主要是因为我们将函数 foo 内部产生的列表返回并在主程序中接收之后，这样就会导致该列表的引用依然存在，该对象后续仍有可能被使用到，垃圾回收便不会回收该对象 。
那么，什么时候对象的引用次数才会增加呢 。下面四种情况都会导致对象引用次数加一 。
同理，对象引用次数减一的情况也有四种 。
引用计数看起来非常简单 ， 实现起来也不复杂，只需要维护一个字段保存对象被引用的次数即可，那么是不是就代表这种算法没有缺点了呢 。实则不然，我们知道引用次数为零的对象所占用的内存空间肯定是需要被回收的 。那引用次数不为零的对象呢，是不是就一定不能回收呢？
我们来看看下面的例子，只是对函数 foo 进行了改造，其余未做更改 。
我们看到 ， 在函数 foo 内部生成了两个列表 list_a 和 list_b，然后将两个列表分别添加到另外一个中 。由结果可以看出，即使 foo 函数结束之后其所占用的内存空间依然未被释放 。这是因为对于 list_a 和 list_b 来说虽然没有被任何外部对象引用，但因为二者之间交叉引用，以至于每个对象的引用计数都不为零，这也就造成了其所占用的空间永远不会被回收的尴尬局面 。这个缺点是致命的 。
为了解决交叉引用的问题，Python 引入了标记清除算法和分代回收算法 。
显然 ， 可以包含其python释放空间函数他对象引用的容器对象都有可能产生交叉引用问题，而标记清除算法就是为了解决交叉引用的问题的 。
标记清除算法是一种基于对象可达性分析的回收算法，该算法分为两个步骤，分别是标记和清除 。标记阶段，将所有活动对象进行标记 ， 清除阶段将所有未进行标记的对象进行回收即可 。那么现在的为问题变为了 GC 是如何判定哪些是活动对象的？
事实上 GC 会从根结点出发，与根结点直接相连或者间接相连的对象我们将其标记为活动对象（该对象可达），之后进行回收阶段 ， 将未标记的对象（不可达对象）进行清除 。前面所说的根结点可以是全局变量，也可以是调用栈 。
标记清除算法主要用来处理一些容器对象 ， 虽说该方法完全可以做到不误杀不遗漏 ， 但 GC 时必须扫描整个堆内存，即使只有少量的非可达对象需要回收也需要扫描全部对象 。这是一种巨大的性能浪费 。
由于标记清除算法需要扫描整个堆的所有对象导致其性能有所损耗 ， 而且当可以回收的对象越少时性能损耗越高 。因此 Python 引入了分代回收算法，将系统中存活时间不同的对象划分到不同的内存区域 ， 共三代 ， 分别是 0 代，1 代 和 2 代 。新生成的对象是 0 代，经过一次垃圾回收之后，还存活的对象将会升级到 1 代，以此类推，2 代中的对象是存活最久的对象 。
那么什么时候触发进行垃圾回收算法呢 。事实上随着程序的运行会不断的创建新的对象，同时也会因为引用计数为零而销毁大部分对象，Python 会保持对这些对象的跟踪，由于交叉引用的存在，以及程序中使用了长时间存活的对象，这就造成了新生成的对象的数量会大于被回收的对象数量，一旦二者之间的差值达到某个阈值就会启动垃圾回收机制，使用标记清除算法将死亡对象进行清除，同时将存活对象移动到 1 代 。以此类推，当二者的差值再次达到阈值时又触发垃圾回收机制，将存活对象移动到 2 代 。
这样通过对不同代的阈值做不同的设置，就可以做到在不同代使用不同的时间间隔进行垃圾回收，以追求性能最大 。
事实上，所有的程序都有一个相识的现象 ， 那就是大部分的对象生存周期都是相当短的，只有少量对象生命周期比较长，甚至会常驻内存 ， 从程序开始运行持续到程序结束 。而通过分代回收算法，做到了针对不同的区域采取不同的回收频率，节约了大量的计算从而提高 Python 的性能 。
除了上面所说的差值达到一定阈值会触发垃圾回收之外 ， 我们还可以显示的调用 gc.collect() 来触发垃圾回收，最后当程序退出时也会进行垃圾回收 。
本文介绍了 Python 的垃圾回收机制 ， 垃圾回收是 Python 自带的功能，并不需要程序员去手动管理内存 。
其中引用计数法是最简单直接的，但是需要维护一个字段且针对交叉引用无能为力 。
标记清除算法主要是为了解决引用计数的交叉引用问题，该算法的缺点就是需要扫描整个堆的所有对象，有点浪费性能 。
而分代回收算法的引入则完美解决了标记清除算法需要扫描整个堆对象的性能浪费问题 。该算法也是建立在标记清除基础之上的 。
最后我们可以通过 gc.collect() 手动触发 GC 的操作 。
题外话，如果python释放空间函数你看过 JVM 的垃圾回收算法之后会发现 Python 的垃圾回收算法与其是如出一辙的，事实再次证明，程序语言设计时是会相互参考的 。
python函数和方法区别python中函数和方法的区别：
首先 ， 从分类的角度来分析 。
（1）函数的分类：
内置函数：python内嵌的一些函数 。
匿名函数：一行代码实现一个函数功能 。
递归函数
自定义函数：根据自己的需求，来进行定义函数 。
（2）方法的分类：
普通方法：直接用self调用的方法 。
私有方法：__函数名 ， 只能在类中被调用的方法 。
属性方法：@property，将方法伪装成为属性，让代码看起来更合理 。
特殊方法(双下划线方法)：以__init__为例，是用来封装实例化对象的属性 ， 只要是实例化对象就一定会执行__init方法，如果对象子类中没有则会寻找父类（超类） ， 如果父类（超类）也没有，则直接继承object（python 3.x）类 ， 执行类中的__init__方法 。
类方法：通过类名的调用去操作公共模板中的属性和方法 。
静态方法：不用传入类空间、对象的方法， 作用是保证代码的一致性，规范性 ， 可以完全独立类外的一个方法，但是为了代码的一致性统一的放到某个模块（py文件）中 。
其次 ， 从作用域的角度来分析：
（1）函数作用域：从函数调用开始至函数执行完成，返回给调用者后，在执行过程中开辟的空间会自动释放，也就是说函数执行完成后，函数体内部通过赋值等方式修改变量的值不会保留，会随着返回给调用者后，开辟的空间会自动释放 。
（2）方法作用域：通过实例化的对象进行方法的调用，调用后开辟的空间不会释放，也就是说调用方法中对变量的修改值会一直保留 。
最后，调用的方式不同 。
（1）函数：通过“函数名（）”的方式进行调用 。
（2）方法：通过“对象.方法名”的方式进行调用 。
class Foo(object):def func(self):pass#实例化obj = Foo()# 执行方式一:调用的func是方法obj.func() #func 方法# 执行方式二：调用的func是函数Foo.func(123) # 函数
python释放空间函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、python释放空间函数的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：包含postgremysql数据库的词条

    下一篇：如何为联想服务器工作站安装操作系统？ 联想服务器工作站怎么系统