这篇文章介绍了Python中list是如何实现的。在Python中list特别有用。让我们来看下list的内部是如何实现的。来看下面简单的程序，在list中添加一些整数并将他们打印出来。
&&& L = []
&&& L.append(1)
&&& L.append(2)
&&& L.append(3)
&&& for e in L:
正如你所看到的，list是可以迭代的。
List对象的C结构
Python中list是用下边的C语言的结构来表示的。ob_item是用来保存元素的指针数组，allocated是ob_item预先分配的内存总容量
typedef struct {
PyObject_VAR_HEAD
PyObject **ob_
List的初始化
让我们来看下当初始化一个空list的时候发生了什么 L = []
arguments: size of the list = 0
returns: list object = []
PyListNew:
nbytes = size * size of global Python object = 0
allocate new list object
allocate list of pointers (ob_item) of size nbytes = 0
clear ob_item
set list's allocated var to 0 = 0 slots
return list object
非常重要的是知道list申请内存空间的大小（后文用allocated代替）的大小和list实际存储元素所占空间的大小(ob_size)之间的关系，ob_size的大小和len(L)是一样的，而allocated的大小是在内存中已经申请空间大小。通常你会看到allocated的值要比ob_size的值要大。这是为了避免每次有新元素加入list时都要调用realloc进行内存分配。接下来我们会看到更多关于这些的内容。
我们在list中追加一个整数:L.append(1)。发生了什么？调用了内部的C函数app1()
arguments: list object, new element
returns: 0 if OK, -1 if not
n = size of list
call list_resize() to resize the list to size n+1 = 0 + 1 = 1
list[n] = list[0] = new element
来让我们看下list_resize(),list_resize()会申请多余的空间以避免调用多次list_resize()函数，list增长的模型是:0, 4, 8, 16, 25, 35, 46, 58, 72, 88, &
arguments: list object, new size
returns: 0 if OK, -1 if not
list_resize:
new_allocated = (newsize && 3) + (newsize & 9 ? 3 : 6) = 3
new_allocated += newsize = 3 + 1 = 4
resize ob_item (list of pointers) to size new_allocated
开辟了四个内存空间来存放list中的元素，存放的第一个元素是1。你可以从下图中看到L[0]指向了我们刚刚加进去的元素。虚线的框代表了申请了但是还没有使用(存储元素)的内存空间我们继续加入一个元素：L.append(2)。调用list_resize,同时n+1=2。但是因为allocated（译者注：已经申请的空间大小）是4。所以没有必要去申请新的内存空间。相同的事情发生在再次在list中添加两个元素的时候: L.append(3),L.append(4)。下图展示了到目前为止我们做了什么。
现在我们在列表的第一个位置插入一个整数5:L.insert(1, 5),看看内部发生了什么。调用了ins1()
arguments: list object, where, new element
returns: 0 if OK, -1 if not
resize list to size n+1 = 5 -& 4 more slots will be allocated
starting at the last element up to the offset where, right shift each element
set new element at offset where
虚线框表示已经申请但是没有使用的内存。申请了8个内存空间但是list实际用来存储元素只使用了其中5个内存空间insert的时间复杂度是O(n)
当你弹出list的最后一个元素：L.pop()。调用listpop()，list_resize在函数listpop()内部被调用，如果这时ob_size（译者注：弹出元素后）小于allocated（译者注：已经申请的内存空间）的一半。这时申请的内存空间将会缩小。
arguments: list object
returns: element popped
if list empty:
return null
resize list with size 5 - 1 = 4. 4 is not less than 8/2 so no shrinkage
set list object size to 4
return last element
Pop的时间复杂度是O(1)你可以发现4号内存空间指向还指向那个数值（译者注：弹出去的那个数值），但是很重要的是ob_size现在却成了4.让我们再弹出一个元素。在list_resize内部，size & 1 = 4 & 1 = 3 比allocated（已经申请的空间）的一半还要小。所以list的申请空间缩小到6个，list的实际使用空间现在是3个(译者注：根据(newsize && 3) + (newsize & 9 ? 3 : 6) = 3在文章最后有详述)你可以发现（下图）3号和4号内存空间还存储着一些整数，但是list的实际使用(存储元素)空间却只有3个了。
Python list对象有一个方法可以移除一个指定的元素。调用listremove()。
arguments: list object, element to remove
returns none if OK, null if not
listremove:
loop through each list element:
if correct element:
slice list between element's slot and element's slot + 1
return none
return null
切开list和删除元素，调用了list_ass_slice()（译者注：在上文slice list between element's slot and element's slot + 1被调用），来看下list_ass_slice()是如何工作的。在这里，低位为1 高位为2（译者注：传入的参数），我们移除在1号内存空间存储的数据5
arguments: list object, low offset, high offset
returns: 0 if OK
list_ass_slice:
copy integer 5 to recycle list to dereference it
shift elements from slot 2 to slot 1
resize list to 5 slots
Remove的时间复杂度为O(n)
文中list的sort部分没有进行翻译核心部分
我们能看到 Python 设计者的苦心。在需要的时候扩容,但又不允许过度的浪费,适当的内存回收是非常必要的。
这个确定调整后的空间大小算法很有意思。
调整后大小 (new_allocated) = 新元素数量 (newsize) + 预留空间 (new_allocated)
调整后的空间肯定能存储 newsize 个元素。要关注的是预留空间的增长状况。
将预留算法改成 Python 版就更清楚了:(newsize
引自《深入Python编程》
阅读(...) 评论()1、Python彻底分离了对象和引用，可以认为内存中的对象都是不可修改的，每次修改引用，相当于在堆上重新创建一个对象，引用指向新对象。
2、对于数值和字符串，修改意味着引用指向一个新对象。
3、集合中的元素都是引用。考虑元组，元组中的引用不能增加删除，也不能修改引用的指向。但是元组本身也是个引用，可以指向另一个元组。
4、考虑列表，列表中的引用可以增加删除，也可以修改引用的指向。列表本身也是个引用，也可以指向另一个列表。
5、考虑字典，字典的key不能修改指向，value可以修改指向。字典本身也是个引用，也可以指向另一个字典。
6、考虑下面的情况，listB = listA, listB 与 listA 指向同一个列表，listB修改元素也会影响到listA，如果不想受到影响怎么办？
　　进行深拷贝，listB = deepcopy(listA), 这种情况下，listB只是对listA中的元素(引用)做了copy，对应的元素还是指向同一个对象。当listB修改元素的指向时，listA不受影响。
　　在Python中，深拷贝也只是拷贝引用，不会对内容拷贝。因此，对于包含引用的引用（也就是集合），深拷贝才有意义。
7、为什么设计出元组？毕竟列表可以完全取代元素。
　　这体现了&最小特权原则&，也就是尽量限制别人不该有的权利。元组是一种弱化了的列表，不允许对其中的引用增加删除，也不允许修改引用的指向。
阅读(...) 评论()python中list循环语句用法实例
投稿：shichen2014
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了python中list循环语句用法,以实例形式详细介绍了Python针对list的解析,包含各种常见的遍历操作及原理分析,需要的朋友可以参考下
本文实例讲述了python中list循环语句用法。分享给大家供大家参考。具体用法分析如下：
Python 的强大特性之一就是其对 list 的解析，它提供一种紧凑的方法，可以通过对 list 中的每个元素应用一个函数，从而将一个 list 映射为另一个 list。
代码如下:a = ['cat', 'window', 'defenestrate']
for x in a:
&&&& print x, len(x)
for x in [1, 2, 3]: print x,&&&&& # iteration Loop through a list: for in
a = ['cat', 'window', 'defenestrate']
for x in a[:]: # make a slice copy of the entire list
&&& if len(x) & 6: a.insert(0, x)
运行结果：
defenestrate 12
1 2 3 ['defenestrate', 'cat', 'window', 'defenestrate']
根据数组长度来操作：
代码如下:a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
&&&& print i, a[i]
运行结果：
代码如下:words = ['A', 'B', 'C', 'D', 'E']
for word in words:
&&& print word
运行结果：
List 解析介绍：
代码如下:&&& li = [1, 9, 8, 4]
&&& [elem*2 for elem in li]&&&&&
[2, 18, 16, 8]
&&& li&&&&&&&&&&&&&&&&&&&&&&&&&&
[1, 9, 8, 4]
&&& li = [elem*2 for elem in li]
[2, 18, 16, 8]
为了便于理解它，让我们从右向左看。li 是一个将要映射的 list。Python 循环遍历 li 中的每个元素。对每个元素均执行如下操作：首先临时将其值赋给变量 elem，然后 Python 应用函数 elem*2 进行计算，最后将计算结果追加到要返回的 list 中。
需要注意是，对 list 的解析并不改变原始的 list。
将一个 list 的解析结果赋值给对其映射的变量是安全的。不用担心存在竞争情况或任何古怪事情的发生。Python 会在内存中创建新的 list，当对 list 的解析完成时，Python 将结果赋给变量。
希望本文所述对大家的Python程序设计有所帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具浅谈Python 对象内存占用
投稿：jingxian
字体：[ ] 类型：转载 时间：
下面小编就为大家带来一篇浅谈Python 对象内存占用。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
一切皆是对象
在 Python 一切皆是对象，包括所有类型的常量与变量，整型，布尔型，甚至函数。 参见stackoverflow上的一个问题 Is everything an object in python like ruby
代码中即可以验证：
# everythin in python is object def fuction(): return print isinstance(True, object) print isinstance(0, object) print isinstance('a', object) print isinstance(fuction, object)
Python 在 sys 模块中提供函数 getsizeof 来计算 Python 对象的大小。
sys.getsizeof(object[, default])
以字节（byte）为单位返回对象大小。 这个对象可以是任何类型的对象。 所以内置对象都能返回正确的结果 但不保证对第三方扩展有效，因为和具体实现相关。
getsizeof() 调用对象的 __sizeof__ 方法， 如果对象由垃圾收集器管理， 则会加上额外的垃圾收集器开销。
当然，对象内存占用与 Python 版本以及操作系统版本关系密切， 本文的代码和测试结果都是基于 windows7 32位操作系统。
import sys print sys.version
2.7.2 (default, Jun 24 :10) [MSC v.1500 32 bit (Intel)]
•布尔型
print 'size of True: %d' % (sys.getsizeof(True)) print 'size of False: %d' % (sys.getsizeof(False))
size of True: 12 size of False: 12
•整型
# normal integer print 'size of integer: %d' % (sys.getsizeof(1)) # long print 'size of long integer: %d' % (sys.getsizeof(1L)) print 'size of big long integer: %d' % (sys.getsizeof(100000L)) 输出：
size of integer: 12x size of long integer 1L: 14 size of long integer 100000L: 16
可以看出整型占用12字节，长整型最少占用14字节，且占用空间会随着位数的增多而变大。 在2.x版本，如果整型类型的值超出sys.maxint，则自动会扩展为长整型。而 Python 3.0 之后，整型和长整型统一为一种类型。
•浮点型
print 'size of float: %d' % (sys.getsizeof(1.0))
size of float: 16
浮点型占用16个字节。超过一定精度后会四舍五入。
参考如下代码：
print 1. print 1.
•字符串
# size of string type print '\r\n'.join(["size of string with %d chars: %d" % (len(elem), sys.getsizeof(elem)) for elem in ["", "a", "ab"]]) # size of unicode string print '\r\n'.join(["size of unicode string with %d chars: %d" % (len(elem), sys.getsizeof(elem)) for elem in [u"", u"a", u"ab"]])
size of string with 0 chars: 21 size of string with 1 chars: 22 size of string with 2 chars: 23 size of unicode string with 0 chars: 26 size of unicode string with 1 chars: 28 size of unicode string with 2 chars: 30
普通空字符串占21个字节，每增加一个字符，多占用1个字节。Unicode字符串最少占用26个字节，每增加一个字符，多占用2个字节。
•列表
# size of list type print '\r\n'.join(["size of list with %d elements: %d" % (len(elem), sys.getsizeof(elem)) for elem in [[], [0], [0,2], [0,1,2]]])
size of list with 0 elements: 36 size of list with 1 elements: 40 size of list with 2 elements: 44 size of list with 3 elements: 48
可见列表最少占用36个字节，每增加一个元素，增加4个字节。但要注意，sys.getsizeof&函数并不计算容器类型的元素大小。比如：
print 'size of list with 3 integers %d' % (sys.getsizeof([0,1,2])) print 'size of list with 3 strings %d' % (sys.getsizeof(['0','1','2']))
size of list with 3 integers 48 size of list with 3 strings 48
容器中保存的应该是对元素的引用。如果要准确计算容器，可以参考。使用其给出的&total_size&函数：
print 'total size of list with 3 integers %d' % (total_size([0,1,2])) print 'total size of list with 3 strings %d' % (total_size(['0','1','2']))
total size of list with 3 integers 84 total size of list with 3 strings 114
可以看出列表的空间占用为 基本空间 36 + (对象引用 4 + 对象大小) * 元素个数。
另外还需注意如果声明一个列表变量，则其会预先分配一些空间，以便添加元素时增加效率：
li = [] for i in range(0, 101): print 'list with %d integers size: %d, total_size: %d' % (i, getsizeof(li), total_size(li)) li.append(i)
•元组
基本与列表类似，但其最少占用为28个字节。
•字典
字典的情况相对复杂很多，具体当然要， 另外 非常值得仔细阅读。
基本情况可以参考[stackoverflow] 的问题 中的一些回答：
•字典最小拥有8个条目的空间(PyDict_MINSIZE);
•条目数小于50,000时，每次增长4倍;
•条目数大于50,000时，每次增长2倍;
•键的hash值缓存在字典中，字典调整大小后不会重新计算;
每接近2/3时，字典会调整大小。
以上这篇浅谈Python 对象内存占用就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具python期中考试试卷_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
python期中考试试卷
阅读已结束，下载文档到电脑
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，方便使用
还剩1页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢