python内存管理机制

由于python中万物皆对象，所以python的存储问题是对象的存储问题。实际上，对于每个对象，python会分配一块内存空间去存储它。

创新互联成立与2013年，先为南安等服务建站，南安等地企业，进行企业商务咨询服务。为南安企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

那么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程序的时候，解释器会专门分配一块空白的内存，用来存放纯单词字符组成的字符串（数字，字母，下划线）

字符串赋值时，会先去查找要赋值的字符串是否已存在于内存区域，已存在，则指向已存在的内存，不存在，则会在大整数池中分配一块内存存放此字符串

python3--内置函数

python的常用内置函数

1.abs() 函数返回数字的绝对值

abs(-40)=40

2. dict() 函数用于创建一个字典

dict()

{}      #创建一个空字典类似于u={},字典的存取方式一般为key-value

例如u = {"username":"tom",  "age":18}

3. help() 函数用于查看函数或模块用途的详细说明

help('math')查看math模块的用处

a=[1,2,3,4]

help(a)查看列表list帮助信息

4.dir()获得当前模块的属性列表

dir(help)

['__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

5.min() 方法返回给定参数的最小值 /参数可以为序列

a=  min(10,20,30,40)

a

10

6. next() 返回迭代器的下一个项目

it = iter([1, 2, 3, 4, 5])

next(it)

1

next(it)

2

7. id() 函数用于获取对象的内存地址

a=12

id(a)

1550569552

8.enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

a=["tom","marry","leblan"]

list(enumerate(a))

[(0, 'tom'), (1, 'marry'), (2, 'leblan')]

9. oct() 函数将一个整数转换成8进制字符串

oct(15)

'0o17'

oct(10)

'0o12'

10. bin() 返回一个整数 int 或者长整数 long int 的二进制表示

bin(10)

'0b1010'

bin(15)

'0b1111'

11.eval() 函数用来执行一个字符串表达式，并返回表达式的值

eval('2+2')

4

12.int() 函数用于将一个字符串会数字转换为整型

int(3)

3

int(3.6)

3

int(3.9)

3

int(4.0)

4

13.open() 函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写

f=open('test.txt')

14.str() 函数将对象转化为适于人阅读的形式

str(3)

'3'

15. bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False

bool()

False

bool(1)

True

bool(10)

True

bool(10.0)

True

16.isinstance() 函数来判断一个对象是否是一个已知的类型

a=5

isinstance(a,int)

True

isinstance(a,str)

False

17. sum() 方法对系列进行求和计算

sum([1,2,3],5)

11

sum([1,2,3])

6

18. super() 函数用于调用下一个父类(超类)并返回该父类实例的方法。super 是用来解决多重继承问题的，直接用类名调用父类方法

class   User(object):

  def__init__(self):

class Persons(User):

        super(Persons,self).__init__()

19. float() 函数用于将整数和字符串转换成浮点数

float(1)

1.0

float(10)

10.0

20. iter() 函数用来生成迭代器

a=[1,2,3,4,5,6]

iter(a)

for i in iter(a):

...         print(i)

...

1

2

3

4

5

6

21.tuple 函数将列表转换为元组

a=[1,2,3,4,5,6]

tuple(a)

(1, 2, 3, 4, 5, 6)

22.len() 方法返回对象（字符、列表、元组等）长度或项目个数

s = "playbasketball"

len(s)

14

a=[1,2,3,4,5,6]

len(a)

6

23. property() 函数的作用是在新式类中返回属性值

class User(object):

 def __init__(self,name):

          self.name = name

def get_name(self):

          return self.get_name

@property

 def name(self):

         return self_name

24.type() 函数返回对象的类型

25.list() 方法用于将元组转换为列表

b=(1,2,3,4,5,6)

list(b)

[1, 2, 3, 4, 5, 6]

26.range() 函数可创建一个整数列表，一般用在 for 循环中

range(10)

range(0, 10)

range(10,20)

range(10, 20)

27. getattr() 函数用于返回一个对象属性值

class w(object):

...             s=5

...

a = w()

getattr(a,'s')

5

28. complex() 函数用于创建一个复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

complex(1,2)

(1+2j)

complex(1)

(1+0j)

complex("1")

(1+0j)

29.max() 方法返回给定参数的最大值，参数可以为序列

b=(1,2,3,4,5,6)

max(b)

6

30. round() 方法返回浮点数x的四舍五入值

round(10.56)

11

round(10.45)

10

round(10.45,1)

10.4

round(10.56,1)

10.6

round(10.565,2)

10.56

31. delattr 函数用于删除属性

class Num(object):

...    a=1

...    b=2

...    c=3.

.. print1 = Num()

print('a=',print1.a)

a= 1

print('b=',print1.b)

b= 2

print('c=',print1.c)

c= 3

delattr(Num,'b')

print('b=',print1.b)

Traceback (most recent call last):  File "", line 1, inAttributeError: 'Num' object has no attribute 'b'

32. hash() 用于获取取一个对象（字符串或者数值等）的哈希值

hash(2)

2

hash("tom")

-1675102375494872622

33. set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

a= set("tom")

b = set("marrt")

a,b

({'t', 'm', 'o'}, {'m', 't', 'a', 'r'})

ab#交集

{'t', 'm'}

a|b#并集

{'t', 'm', 'r', 'o', 'a'}

a-b#差集

{'o'}

python的内存驻留机制（小数据池）

python的内存驻留机制，是一种节省内存的方案，它将int, str, bool类型的数据做成小数据池。当程序要创建字符串等对象前会先检查池中是否有满足的字符串。

驻留机制节省大量的重复内存。在内部，小数据池是由一个全局的dict 维护，该字典中的对象成了单例模式，从而节省内存。

变量 interned 就是全局存放字符串池的字典的变量名 interned = PyDict_New() ，为了让 intern 机制中的字符串不被回收，设置字典时 PyDict_SetDefault(interned, s, s); 将字符串作为键同时也作为值进行设置，这样对于字符串对象的引用计数就会进行两次 +1 操作，这样存于字典中的对象在程序结束前永远不会为 0，这也是 y_REFCNT(s) -= 2; 将计数减 2 的原因。

从函数参数中可以看到其实字符串对象还是被创建了，内部其实始终会为字符串创建对象，但经过 inter 机制检查后，临时创建的字符串会因引用计数为 0 而被销毁，临时变量在内存中昙花一现然后迅速消失。

指定要驻留的字符串：

为什么要进行字符串驻留呢？

总结：

系统维护一个interned全局字典，记录已被驻留的字符串对象，当新字符串a对象需要驻留时，先在interned中查找是否存在，若存在则指向已存在的字符串对象，a对象的引用计数减1，若不存在，则记录a对象到interned中。

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内存驻留机制

字符串驻留机制在许多面向对象编程语言中都支持，比如Java、python、Ruby、PHP等，它是一种数据缓存机制，对不可变数据类型使用同一个内存地址，有效的节省了空间，本文主要介绍Python的内存驻留机制。

字符串驻留就是每个字符串只有一个副本，多个对象共享该副本，驻留只针对不可变数据类型，比如字符串，布尔值，数字等。在这些固定数据类型处理中，使用驻留可以有效节省时间和空间，当然在驻留池中创建或者插入新的内容会消耗一定的时间。

下面举例介绍python中的驻留机制。

在Python对象及内存管理机制一文中介绍了python的参数传递以及以及内存管理机制，来看下面一段代码：

知道结果是什么吗？下面是执行结果：

l1和l2内容相同，却指向了不同的内存地址，l2和l3之间使用等号赋值，所以指向了同一个对象。因为列表是可变对象，每创建一个列表，都会重新分配内存，列表对象是没有“内存驻留”机制的。下面来看不可变数据类型的驻留机制。

在 Jupyter或者控制台交互环境 中执行下面代码：

执行结果：

可以发现a1和b1指向了不同的地址，a2和b2指向了相同的地址，这是为什么呢？

因为启动时，Python 将一个 -5~256 之间整数列表预加载（缓存）到内存中，我们在这个范围内创建一个整数对象时，python会自动引用缓存的对象，不会创建新的整数对象。

浮点型不支持：

如果上面的代码在非交互环境，也就是将代码作为python脚本运行的结果是什么呢？（运行环境为python3.7）

全为True，没有明确的限定临界值，都进行了驻留操作。这是因为使用不同的环境时，代码的优化方式不同。

在 Jupyter或者控制台交互环境 中：

满足标识符命名规范的字符：

结果：

乘法获取字符串（运行环境为python3.7）

结果：

在非交互环境中：

注意： 字符串是在编译时进行驻留 ，也就是说，如果字符串的值不能在编译时进行计算，将不会驻留。比如下面的例子：

在交互环境执行结果如下：

都指向不同的内存。

python 3.7 非交互环境执行结果：

发现d和e指向不同的内存，因为d和e不是在编译时计算的，而是在运行时计算的。前面的 a = 'aa'*50 是在编译时计算的。

除了上面介绍的python默认的驻留外，可以使用sys模块中的intern()函数来指定驻留内容

结果：

使用intern()后，都指向了相同的地址。

本文主要介绍了python的内存驻留，内存驻留是python优化的一种策略，注意不同运行环境下优化策略不一样，不同的python版本也不相同。注意字符串是在编译时进行驻留。

--THE END--

Python内置函数range

range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。

range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 __index__ 特殊方法的对象）。 如果省略 step 参数，其默认值为 1 。 如果省略 start 参数，其默认值为 0 ，如果 step 为零则会引发 ValueError。

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i = 0 且 r[i] stop 。

如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i ，但限制条件改为 i = 0 且 r[i] stop .

如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。

元素绝对值大于 sys.maxsize 的 range 对象是被允许的，但某些特性 (例如 len()) 可能引发 OverflowError。

一些 range 对象的例子:

range 对象实现了 一般 序列的所有操作，但拼接和重复除外（这是由于 range 对象只能表示符合严格模式的序列，而重复和拼接通常都会违反这样的模式）。

start

start 形参的值 (如果该形参未提供则为 0 )

stop

stop 形参的值

step

step 形参的值 (如果该形参未提供则为 1 )

range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start , stop 和 step 值，并会根据需要计算具体单项或子范围的值）。

range 对象实现了 collections.abc.Sequence ABC，提供如包含检测、元素索引查找、切片等特性，并支持负索引

使用 == 和 != 检测 range 对象是否相等是将其作为序列来比较。 也就是说，如果两个 range 对象表示相同的值序列就认为它们是相等的。 （请注意比较结果相等的两个 range 对象可能会具有不同的 start, stop 和 step 属性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2) 。）

在 3.2 版更改: 实现 Sequence ABC。 支持切片和负数索引。 使用 int 对象在固定时间内进行成员检测，而不是逐一迭代所有项。

在 3.3 版更改: 定义 '==' 和 '!=' 以根据 range 对象所定义的值序列来进行比较（而不是根据对象的标识）。

3.3 新版功能: start, stop 和 step 属性。

文章标题：python函数参数内存 Python内存
地址分享：http://scyanting.com/article/hihghi.html