栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Python

python 内存管理机制和深拷贝浅拷贝(看完解决面试题)

Python 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

python 内存管理机制和深拷贝浅拷贝(看完解决面试题)

内存管理

面试问题:python的内存管理机制
以引用计数为主,分代回收、标记清除为辅的垃圾回收机制

以及对小整形进行缓存和简单字符串驻留的内存池机制

接下来详细介绍Python的内存管理机制

一、引用计数

引用计数
python中的每个对象都维护一个引用计数 ob_ref字段
当有新的引用指向该对象的时候,引用计数+1
当有无效的引用的发生的时候,引用计数-1
最后引用计数为0的时候,销毁对象,该对象可以被回收,对象占用的内存空间将被释放

优点

简单 实时性

缺点:

它的缺点是需要额外的空间维护引用计数,这个问题是其次的
最主要的问题是它不能解决对象的“循环引用”

1.1 循环引用

根据引用计数的规律,出现循环引用的情况,内存是无法通过引用计数来释放
这种情况就会造成内存泄漏
内存泄漏: 有一部分内存被占用无法释放,进程无又法访问(占着茅坑不拉屎)
内存溢出(oom – out of memory):内存不够。程序需要的内存大于系统的空闲内存

getrefcount

当使用某个引用作为参数,传递给getrefcount()时,参数实际上创建了一个临时的引用。因此,getrefcount()所得到的结果,会比期望的多1。

>>> x = [1]
>>> y = [2]
>>> x.append(y)
>>> y.append(x)
>>> getrefcount(x)  
3
# 实际的引用计数比getrefcount得到的值小1,实际的引用计数为 2
>>> getrefcount(y)
3
>>> del x
>>> del y
>>> getrefcount(x)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'x' is not defined
二、垃圾回收机制 2.1 python采用的垃圾回收机制:

分代回收: 启动垃圾回收的时候确定回收哪些对象的

标记清除: 主要解决循环引用

三种情况触发垃圾回收

  1. 调用gc.collect()
  2. GC达到阀值时
  3. 程序退出时
2.2 内存池 2.2.1 小整形的缓存池
# 预先创建好了一个小整形池[-5,256]
>>> a = 1
>>> getrefcount(a)
801
>>> a = 3
>>> getrefcount(a)
48
>>> a = 300
>>> getrefcount(a)
2
# 测试边界
>>> a = 256
>>> getrefcount(a)
3
>>> a = 257
>>> getrefcount(a)
2
>>> a = -6
>>> getrefcount(a)
2
>>> a = -5
>>> getrefcount(a)
3
2.2.2 字符串驻留区

单个字符创建之后会存放在字符串驻留区
多个字符,创建之后如果没有特殊字符,就会存放在字符串驻留区

# 多个字符
>>> str1 = 'abcxyz'
>>> getrefcount(str1)
2
>>> str2 = 'abcxyz'
>>> getrefcount(str2)
3
>>> id(str1)
140181150973544
>>> id(str2)
140181150973544

# 多个字符有特殊字符
>>> str1 = 'abc xyz'
>>> str2 = 'abc xyz'
>>> id(str1)
140181150486688
>>> id(str2)
140181150486744
# 多个字符没有特殊字符
>>> str1 = 'abc123'
>>> str2 = 'abc123'
>>> id(str1)
140181150973544
>>> id(str2)
140181150973544
# 单个字符
>>> str1 = '#'
>>> str2 = '#'
>>> id(str1)
140181152088560
>>> id(str2)
140181152088560
深拷贝与浅拷贝

数字和字符串、元组,不能改变对象本身,只能改变引用的指向,称为不可变数据对象(immutable object)。
列表、字典、集合可以通过引用其元素,改变对象自身(in-place change)。这种对象类型,称为可变数据对象(mutable object)

深拷贝,浅拷贝 只会发生在容器类型里面包含其他可变容器类型的情况

面试题:深拷贝和浅拷贝的区别?

浅拷贝:是将对象的引用复制给另一个对象,因此如果我们在副本中进行修改时会影响原对象。

深拷贝:是将对象本身复制给另一个对象,这意味着如果对对象的副本进行更改时不会影响原对象。

扩展:只有一种场景有深浅拷贝的区别: 容器类型里面包含其他可变容器类型的情况。
浅拷贝可能会造成修改拷贝之后的值,会改变原来的值——浅拷贝是拷贝的容器里面第一层数据的地址
深拷贝不会发生这个情况,使用copy模块的deepcopy()函数才是深拷贝——深拷贝是拷贝容器里面每一层数据

1.浅拷贝

浅拷贝只会拷贝第一层的地址
浅拷贝当改变原来的值的时候,可能会造成修改拷贝之后的值
除了copy.deepcopy是深拷贝,其他都是浅拷贝

>>> a = {"name":'sc',"score":[80,90,100]}
>>> b = a.copy()
>>> a
{'name': 'sc', 'score': [80, 90, 100]}
>>> b
{'name': 'sc', 'score': [80, 90, 100]}
>>> b["score"].append(110)
>>> b
{'name': 'sc', 'score': [80, 90, 100, 110]}
>>> a
{'name': 'sc', 'score': [80, 90, 100, 110]}

# 除了copy.deepcopy是深拷贝,其他都是浅拷贝
>>> lst = [[]]*3
>>> lst
[[], [], []]
>>> lst[0].append(1)
>>> lst
[[1], [1], [1]]
>>> id(lst[0])
140181150989000
>>> id(lst[1])
140181150989000
>>> id(lst[2])
140181150989000
2.深拷贝

深拷贝不会发生改变拷贝之后改变值的情况
深拷贝就是拷贝每一层数据
使用copy模块的deepcopy函数进行的拷贝就是深拷贝

>>> import copy
>>> b = copy.deepcopy(a)  #进行深拷贝
>>> a
{'name': 'sc', 'score': [80, 90, 100, 110]}
>>> b
{'name': 'sc', 'score': [80, 90, 100, 110]}
>>> id(a)
140181150994008
>>> id(b)
140181150993504
>>> id(a['score'])
140181150989000
>>> id(b['score'])
140181018248520
>>> b['score'].append(120)
>>> b
{'name': 'sc', 'score': [80, 90, 100, 110, 120]}
>>> a
{'name': 'sc', 'score': [80, 90, 100, 110]}
练习
mylist = []
for i in range(3):
    mylist.append([0,0])
print(mylist)
mylist[0][0] = 1
print(mylist)
# [[0, 0], [0, 0], [0, 0]]
# [[1, 0], [0, 0], [0, 0]]

mylist = [[0]*2]*3
print(mylist)
mylist[0][0] = 1
print(mylist)
# [[0, 0], [0, 0], [0, 0]]
# [[1, 0], [1, 0], [1, 0]]

# 两者是初始化列表是不一样的
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/889642.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号