Python List列表对象内置方法实例详解
作者：范桂飓
本文实例讲述了Python List列表对象内置方法。分享给大家供大家参考，具体如下：
前言
在上一篇中介绍了Python的序列和String类型的内置方法，本篇继续学习作为序列类型成员之一的List类型的内置方法。
软件环境
- 系统
- UbuntuKylin 14.04
- 软件
- Python 2.7.3
- IPython 4.0.0
列表List
列表是一种容器，存放内存对象的引用。即是任意内存对象的有序集合，不同的类型对象可以存放在同一个列表中。通过索引来访问其中的元素。可以任意的嵌套、伸长、异构、为可变数据类型，支持原处修改列表内部元素的引用。
修改列表的元素
In [130]: li = ['my','name','is','Jmilk'] In [131]: li[3] = 'new' In [132]: li Out[132]: ['my', 'name', 'is', 'new']
插入列表元素
插入的元素也可以是序列等任意类型
In [133]: li.append('list')
In [134]: li
Out[134]: ['my', 'name', 'is', 'new', 'list']
extend() 将序列中的元素迭代的附加到list中
L.extend(iterable) – extend list by appending elements from the iterable
注意：是将iterable中的元素迭代的添加到List中，成为List的元素，而不是将整个iterable成为List中的一个元素。这与append()方法是有本质的区别的。
extend():
In [157]: li.extend(tp) In [158]: li Out[158]: ['my', 'name', 'is', 'Jmilk', 'a', 'b', 'c']
append():
In [166]: li = ['my','name','is','Jmilk'] In [167]: li2 Out[167]: ['hey', 'chocolate'] In [168]: li.append(li2) In [169]: li Out[169]: ['my', 'name', 'is', 'Jmilk', ['hey', 'chocolate']]
insert() 在指定的索引号中插入一个元素
L.insert(index, object) – insert object before index
在指定的原index之前插入一个元素
In [172]: li.insert(4,'and') In [173]: li Out[173]: ['my', 'name', 'is', 'Jmilk', 'and', ['hey', 'chocolate']]
可以插入任意类型对象，但只会插入一个元素，index后的元素依次后挪一位。
删除列表元素
同时结合切片操作符。
注意：这中删除元素的方法只有列表类型适用
In [135]: li[3:] = [] In [136]: li Out[136]: ['my', 'name', 'is']
del() 删除List中的元素
In [146]: li Out[146]: ['my', 'name', 'is'] In [147]: del(li[1:]) In [148]: li Out[148]: ['my']
pop() 弹出List中的一个元素
L.pop([index]) -> item – remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
将List中的一个指定index的元素弹出(默认为最后一个元素)，并返回一个value，可以赋值给变量。当List为空或指定的索引超出List长度时，会触发一个indexError。
In [183]: li Out[183]: ['My', 'name', 'is', 'Jmilk'] In [184]: name = li.pop() In [185]: name Out[185]: 'Jmilk'
remove() 删除List中一个指定Value的元素
L.remove(value) – remove first occurrence of value.
Raises ValueError if the value is not present.
删除List中第一个指定的Value的元素，不会返回一个Value。与del()的使用方法不同，remove()是通过value来决定删除的元素，而不是通过index来决定。
In [192]: li
Out[192]: ['My', 'name', 'is', 'Jmilk', 'Jmilk']
In [193]: li.remove('Jmilk')
In [194]: li
Out[194]: ['My', 'name', 'is', 'Jmilk']
排序列表元素
sort() 正向排序
L.sort(cmp=None, key=None, reverse=False) – stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
List内建爱呢的sort()函数，跟序列类型的内建爱呢函数sorted()有着非常相似的地方。
一样拥有key()、cmp()函数和reverse缺省参数，用法也基本相同。但是两者之间还是有着本质的差别，如下：
1. L.sort()函数只支持List类型对象，而sorted()函数支持所有的iterable迭代器类型。
2. L.sort()会改变原始的List对象，返回值为None。而sotred()函数不会修改原始iterable，会返回一个新的List。
在上一篇中有sorted()函数的详细介绍，传送门：https://www.jb51.net/article/172487.htm
In [231]: li
Out[231]: [('a', 3), ('b', 2), ('c', 1)]
In [232]: li.sort(key = lambda x:x[1])
In [233]: li
Out[233]: [('c', 1), ('b', 2), ('a', 3)]
Operator Module支持排序
Operator模块中的itemgetter, attrgetter两个方法可以有效的支持L.sort()、sorted()两种排序方法。
itemgetter：
itemgetter(item, …) –> itemgetter object
Return a callable object that fetches the given item(s) from its operand.
After f = itemgetter(2), the call f(r) returns r[2].
After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
从操作数中获取一个由index索引指定的item，并返回一个可被调用的对象。
attrgetter：与itemgetter的用法类似，区别在于使用指定的value来指定要获取的attribute。
下面做一个比较：
sorted()：
In [239]: li
Out[239]: [('c', 1), ('b', 2), ('a', 3)]
In [240]: sorted(li,key = lambda x:x[1])
Out[240]: [('c', 1), ('b', 2), ('a', 3)]
L.sort()：
In [241]: li.sort(key = lambda x:x[1])
In [242]: li
Out[242]: [('c', 1), ('b', 2), ('a', 3)]
operator.itemgetter()：
In [251]: li
Out[251]: [('a', 3), ('b', 2), ('c', 1)]
In [252]: sorted(li,key = itemgetter(1))
Out[252]: [('c', 1), ('b', 2), ('a', 3)]
除此之外operator模块能够实现多级排序：
In [256]: sorted(li,key = itemgetter(0,1))
Out[256]: [('a', 3), ('b', 2), ('c', 1)]
In [257]: sorted(li,key = itemgetter(0,1))
Out[257]: [('a', 3), ('b', 2), ('c', 1)]
In [258]: li = [('a', 3), ('a', 2), ('a', 1)]
In [259]: sorted(li,key = itemgetter(0,1))
Out[259]: [('a', 1), ('a', 2), ('a', 3)]
在以tuple_index=0作为关键字无法实现排序后，会自动的使用tuple_index=1作为关键字排序。
另一种多级排序的方法：
In [327]: li = [('a', 3), ('b', 2), ('c', 1)]
In [328]: li.sort(key = lambda x:(x[0],x[1]))
In [329]: li
Out[329]: [('a', 3), ('b', 2), ('c', 1)]
In [330]: li = [('a', 3), ('a', 2), ('a', 1)]
In [331]: li.sort(key = lambda x:(x[0],x[1]))
In [332]: li
Out[332]: [('a', 1), ('a', 2), ('a', 3)]
reverse() 逆向排序
始终与当前顺序逆向，默认tuple_index=0为优先排序。
In [263]: li.reverse()
In [264]: li
Out[264]: [('c', 1), ('b', 2), ('a', 3)]
In [265]: li.reverse()
In [266]: li
Out[266]: [('a', 3), ('b', 2), ('c', 1)]
count() 统计元素在list中出现的次数
L.count(value) -> integer – return number of occurrences of value
In [151]: li
Out[151]: ['my', 'name', 'is', 'Jmilk']
In [153]: li.count('my')
Out[153]: 1
List的深Copy和浅Copy
下面先看一个例子：
In [299]: li1 = [1,2,3,4] In [300]: li2 = li1 In [301]: li1.append(5) In [302]: li1,li2 Out[302]: ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5])
可以看出，对li1的操作会影响到li2。实际上 li1 = li2 语句只是将li1的引用对象Copy给了li2，而没有将li1的内存对象Copy给li2。这就是List类型的浅Copy，相对的就是深Copy。
进行List的深Copy的方法有下面两种：
方法一：将li1的内存对象Copy给li2，生成一个新的List对象。
In [305]: li1 = [1,2,3,4] In [306]: li2 = li1[:] In [307]: li1.append(5) In [308]: li1,li2 Out[308]: ([1, 2, 3, 4, 5], [1, 2, 3, 4])
比较两次赋值的区别：
In [312]: li2 = li1 In [313]: id(li1),id(li2) Out[313]: (139950315013328, 139950315013328) In [314]: li2 = li1[:] In [315]: id(li1),id(li2) Out[315]: (139950315013328, 139950314662440)
方法二：使用copy.deepcopy() 函数
deepcopy(x, memo=None, _nil=[])
Deep copy operation on arbitrary Python objects.
深Copy方法deepcopy()只对可变类型有效，所以Tuple、String不能使用。
In [321]: import copy In [322]: li1 = [1,2,3,4] In [323]: li2 = copy.deepcopy(li1) In [324]: li1.append(5) In [325]: li1,li2 Out[325]: ([1, 2, 3, 4, 5], [1, 2, 3, 4])
最后
因为工作原因最近新开了Linux、和powershell主题的版块。希望可以做到即学即用，以博客来推动学习。但是Python仍然是我最喜欢的一种语言，他还有些非常多有意思的地方等待我们去发现。继续努力！:)
更多关于Python相关内容可查看本站专题：《Python列表(list)操作技巧总结》、《Python字符串操作技巧汇总》、《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python入门与进阶经典教程》及《Python文件与目录操作技巧汇总》
希望本文所述对大家Python程序设计有所帮助。