关于python释放函数内存的信息

python面试题总结1-内存管理机制

（1）.引用计数

网站制作、网站建设的开发，更需要了解用户，从用户角度来建设网站，获得较好的用户体验。创新互联多年互联网经验，见的多，沟通容易、能帮助客户提出的运营建议。作为成都一家网络公司，打造的就是网站建设产品直销的概念。选择创新互联，不只是建站，我们把建站作为产品，不断的更新、完善，让每位来访用户感受到浩方产品的价值服务。

（2）. 垃圾回收

(3）. 内存池机制

在python中每创建一个对象，对应的会有一个引用计数，当发生赋值操作如a=b，对应的b的引用计数会自动加1，当引用的对象被清除或者函数结束时，引用计数会自动减1。

在python中使用引用计数，标记清楚，分代回收三种方式进行垃圾回收。

其中，引用计数当对象的引用计数归0时，对象会自动被清除。标记清除机制是首先遍历所有对象，如果对象可达，就说明有变量引用它，则标记其为可达的。如果不可达，则对其进行清除。分代回收是当对象创建时被标记为第0代，经过一次垃圾回收之后，余下的对象被标记为第1代，最高为第2代。其原理是，对象的生存期越长，月可能不是垃越。

ython语言虽然提供了对内存的垃圾收集机制，但实际上它将不用的内存放到内存池而不是返回给操作系统，所以就有了以下：

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

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

3 对于Python对象，比如整数、浮点数和List这些，都有自己独立的内存池，对象间并不共享他们的内存池。换句话说就是，假设你分配并且释放了大量的整数，那么用于缓存这些整数的内存就不能再分配给浮点数。

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中flask如何降低内存？

Dict

在小型程序中，特别是在脚本中，使用Python自带的dict来表示结构信息非常简单方便：

ob = {'x':1, 'y':2, 'z':3}

x = ob['x']

ob['y'] = y

由于在Python 3.6中dict的实现采用了一组有序键，因此其结构更为紧凑，更深得人心。但是，让我们看看dict在内容中占用的空间大小：

print(sys.getsizeof(ob))

240

如上所示，dict占用了大量内存，尤其是如果突然虚需要创建大量实例时：

实例数

对象大小

1 000 000

240 Mb

10 000 000

2.40 Gb

100 000 000

24 Gb

类实例

有些人希望将所有东西都封装到类中，他们更喜欢将结构定义为可以通过属性名访问的类：

class Point:

#

def __init__(self, x, y, z):

self.x = x

self.y = y

self.z = z

ob = Point(1,2,3)

x = ob.x

ob.y = y

类实例的结构很有趣：

字段

大小(比特)

PyGC_Head

24

PyObject_HEAD

16

__weakref__

8

__dict__

8

合计：

56

在上表中，__weakref__是该列表的引用，称之为到该对象的弱引用(weak reference)；字段__dict__是该类的实例字典的引用，其中包含实例属性的值(注意在64-bit引用平台中占用8字节)。从Python3.3开始，所有类实例的字典的键都存储在共享空间中。这样就减少了内存中实例的大小：

print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__))

56 112

因此，大量类实例在内存中占用的空间少于常规字典(dict)：

实例数

大小

1 000 000

168 Mb

10 000 000

1.68 Gb

100 000 000

16.8 Gb

不难看出，由于实例的字典很大，所以实例依然占用了大量内存。

带有__slots__的类实例

为了大幅降低内存中类实例的大小，我们可以考虑干掉__dict__和__weakref__。为此，我们可以借助 __slots__：

class Point:

__slots__ = 'x', 'y', 'z'

def __init__(self, x, y, z):

self.x = x

self.y = y

self.z = z

ob = Point(1,2,3)

print(sys.getsizeof(ob))

64

如此一来，内存中的对象就明显变小了：

字段

大小(比特)

PyGC_Head

24

PyObject_HEAD

16

x

8

y

8

z

8

总计：

64

在类的定义中使用了__slots__以后，大量实例占据的内存就明显减少了：

实例数

大小

1 000 000

64 Mb

10 000 000

640 Mb

100 000 000

6.4 Gb

目前，这是降低类实例占用内存的主要方式。

这种方式减少内存的原理为：在内存中，对象的标题后面存储的是对象的引用(即属性值)，访问这些属性值可以使用类字典中的特殊描述符：

pprint(Point.__dict__)

mappingproxy(

....................................

'x': ,

'y': ,

'z': })

为了自动化使用__slots__创建类的过程，你可以使用库namedlist()。namedlist.namedlist函数可以创建带有__slots__的类：

Point = namedlist('Point', ('x', 'y', 'z'))

还有一个包attrs()，无论使用或不使用__slots__都可以利用这个包自动创建类。

元组

Python还有一个自带的元组(tuple)类型，代表不可修改的数据结构。元组是固定的结构或记录，但它不包含字段名称。你可以利用字段索引访问元组的字段。在创建元组实例时，元组的字段会一次性关联到值对象：

ob = (1,2,3)

x = ob[0]

ob[1] = y # ERROR

元组实例非常紧凑：

print(sys.getsizeof(ob))

72

由于内存中的元组还包含字段数，因此需要占据内存的8个字节，多于带有__slots__的类：

字段

大小(字节)

PyGC_Head

24

PyObject_HEAD

16

ob_size

8

[0]

8

[1]

8

[2]

8

总计：

72

命名元组

由于元组的使用非常广泛，所以终有一天你需要通过名称访问元组。为了满足这种需求，你可以使用模块collections.namedtuple。

namedtuple函数可以自动生成这种类：

Point = namedtuple('Point', ('x', 'y', 'z'))

如上代码创建了元组的子类，其中还定义了通过名称访问字段的描述符。对于上述示例，访问方式如下：

class Point(tuple):

#

@property

def _get_x(self):

return self[0]

@property

def _get_y(self):

return self[1]

@property

def _get_z(self):

return self[2]

#

def __new__(cls, x, y, z):

return tuple.__new__(cls, (x, y, z))

这种类所有的实例所占用的内存与元组完全相同。但大量的实例占用的内存也会稍稍多一些：

实例数

大小

1 000 000

72 Mb

10 000 000

720 Mb

100 000 000

7.2 Gb

记录类：不带循环GC的可变更命名元组

由于元组及其相应的命名元组类能够生成不可修改的对象，因此类似于ob.x的对象值不能再被赋予其他值，所以有时还需要可修改的命名元组。由于Python没有相当于元组且支持赋值的内置类型，因此人们想了许多办法。在这里我们讨论一下记录类(recordclass，)，它在StackoverFlow上广受好评()。

此外，它还可以将对象占用的内存量减少到与元组对象差不多的水平。

recordclass包引入了类型recordclass.mutabletuple，它几乎等价于元组，但它支持赋值。它会创建几乎与namedtuple完全一致的子类，但支持给属性赋新值(而不需要创建新的实例)。recordclass函数与namedtuple函数类似，可以自动创建这些类：

Point = recordclass('Point', ('x', 'y', 'z'))

ob = Point(1, 2, 3)

类实例的结构也类似于tuple，但没有PyGC_Head：

字段

大小(字节)

PyObject_HEAD

16

ob_size

8

x

8

y

8

z

8

总计：

48

在默认情况下，recordclass函数会创建一个类，该类不参与垃圾回收机制。一般来说，namedtuple和recordclass都可以生成表示记录或简单数据结构(即非递归结构)的类。在Python中正确使用这二者不会造成循环引用。因此，recordclass生成的类实例默认情况下不包含PyGC_Head片段(这个片段是支持循环垃圾回收机制的必需字段，或者更准确地说，在创建类的PyTypeObject结构中，flags字段默认情况下不会设置Py_TPFLAGS_HAVE_GC标志)。

大量实例占用的内存量要小于带有__slots__的类实例：

实例数

大小

1 000 000

48 Mb10 000 000

480 Mb

100 000 000

4.8 Gb

dataobject

recordclass库提出的另一个解决方案的基本想法为：内存结构采用与带__slots__的类实例同样的结构，但不参与循环垃圾回收机制。这种类可以通过recordclass.make_dataclass函数生成：

Point = make_dataclass('Point', ('x', 'y', 'z'))

这种方式创建的类默认会生成可修改的实例。

另一种方法是从recordclass.dataobject继承：

class Point(dataobject):

x:int

y:int

z:int

这种方法创建的类实例不会参与循环垃圾回收机制。内存中实例的结构与带有__slots__的类相同，但没有PyGC_Head：

字段

大小(字节)

PyObject_HEAD

16

ob_size

8

x

8

y

8

z

8

总计：

48

ob = Point(1,2,3)

print(sys.getsizeof(ob))

40

如果想访问字段，则需要使用特殊的描述符来表示从对象开头算起的偏移量，其位置位于类字典内：

mappingproxy({'__new__': ,

.......................................

'x': ,

'y': ,

'z': })

大量实例占用的内存量在CPython实现中是最小的：

实例数

大小

1 000 000

40 Mb

10 000 000

400 Mb

100 000 000

4.0 Gb

Cython

还有一个基于Cython()的方案。该方案的优点是字段可以使用C语言的原子类型。访问字段的描述符可以通过纯Python创建。例如：

cdef class Python:

cdef public int x, y, z

def __init__(self, x, y, z):

self.x = x

self.y = y

self.z = z

本例中实例占用的内存更小：

ob = Point(1,2,3)

print(sys.getsizeof(ob))

32

内存结构如下：

字段

大小(字节)

如何释放Python占用的内存

我觉得可能是因为你的py文件在第一次启动后，已经编译成pyc文件了，再次启动的时候都是加载pyc，省去了编译的阶段，所以速度很快。

你可以试着把程序目录下的所有pyc或者你的代码文件对应的pyc文件删除，看看是不是可以和第一次加载速度相同

退出python程序释放占用内存

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

python 怎么在循环中释放内存

python 怎么在循环中释放内存

#include"stdio.h"

main()

{

char st[15];

printf("input string:\n");

gets(st);

puts(st);

}

可以看出当输入的字符串中含有空格时，输出仍为全部字符串。说明gets函数并不以空格作为字符串输入结束的标志，而只以回车作为输入结束。这是与scanf函数不同的。

3. 字符串连接函数strcat

格式： strcat (字符数组名1，字符数组名2)

功能：把字符数组2中的字符串连接到字符数组1 中字符串的后面，并删去字符串1后的串标志“\0”。本函数返回值是字符数组1的首地址。

【例7.14】