标签：
列表和元祖最大的不同就是列表是可以修改的。
老规矩，先使用 help(list) ,真的是 help() 大法好呀。
好，来人，上代码。
Help on class list in module __builtin__: class list(object) | list() -> new empty list | list(iterable) -> new list initialized from iterable‘s items | | Methods defined here: | | __add__(...) | x.__add__(y) <==> x+y | | __contains__(...) | x.__contains__(y) <==> y in x | | __delitem__(...) | x.__delitem__(y) <==> del x[y] | | __delslice__(...) | x.__delslice__(i, j) <==> del x[i:j] | | Use of negative indices is not supported. | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getattribute__(...) | x.__getattribute__(‘name‘) <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __gt__(...) | x.__gt__(y) <==> x>y | | __iadd__(...) | x.__iadd__(y) <==> x+=y | | __imul__(...) | x.__imul__(y) <==> x*=y | | __init__(...) | x.__init__(...) initializes x; see help(type(x)) for signature | | __iter__(...) | x.__iter__() <==> iter(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __len__(...) | x.__len__() <==> len(x) | | __lt__(...) | x.__lt__(y) <==> x<y | | __mul__(...) | x.__mul__(n) <==> x*n | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __reversed__(...) | L.__reversed__() -- return a reverse iterator over the list | | __rmul__(...) | x.__rmul__(n) <==> n*x | | __setitem__(...) | x.__setitem__(i, y) <==> x[i]=y | | __setslice__(...) | x.__setslice__(i, j, y) <==> x[i:j]=y | | Use of negative indices is not supported. | | __sizeof__(...) | L.__sizeof__() -- size of L in memory, in bytes | | append(...) | L.append(object) -- append object to end | | count(...) | L.count(value) -> integer -- return number of occurrences of value | | extend(...) | L.extend(iterable) -- extend list by appending elements from the iterable | | index(...) | L.index(value, [start, [stop]]) -> integer -- return first index of value. | Raises ValueError if the value is not present. | | insert(...) | L.insert(index, object) -- insert object before index | | pop(...) | L.pop([index]) -> item -- remove and return item at index (default last). | Raises IndexError if list is empty or index is out of range. | | remove(...) | L.remove(value) -- remove first occurrence of value. | Raises ValueError if the value is not present. | | reverse(...) | L.reverse() -- reverse *IN PLACE* | | sort(...) | L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; | cmp(x, y) -> -1, 0, 1 | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T
按照其功能可以将内置方法分为以下几类：
1.序列相关方法，如索引，切片，加法，乘法，成员判断（这些都在python的序列中讲过，不再重复）
2.内置函数相关（同样将放在python的内置函数中总结）
3.普通的内置方法。
我在上篇python的元祖中分享了自己关于元祖的理解，并把其比喻成是一个菜单，而列表其实和元祖是类似的。
只不过元祖就像是守旧派，菜式坚持传统，所以其菜单也不会改变。但列表则像是革新派，要靠层出不穷的菜式来吸引顾客，所以其菜单会经常修改。
那为什么要分开两种呢，直接都用列表不就好了，我不改就是，这样不更方便吗？
虽然说列表支持更多的操作，但是元祖相较于列表还是有以下优点的：
1.数据更安全
正是因为元祖是不可修改的，所以可以防止一些误操作。例如我有些参数非常重要，我将其放在列表里面，我在取的时候可能会出现误操作修改掉里面的参数，从而导致各种错误。而将这些重要的，确认不用修改的数据放在元祖里，我的数据就会更加安全。
2.性能更高
列表既然可以修改，肯定要对内存进行更多的操作，而这些操作肯定会消耗更多的资源。而元祖是不可变的，一旦在内存中创建以后，就不会有多余的内存操作了。所以进行查询的时候，元祖的效率会比列表更高。
两种各有特色，可以根据需求选用。
列表相较元祖的最大不同就是其是可修改的，而修改的核心操作为：增删改查。
一.增
1.1 L.append(object) -- append object to end
往列表的最后插入一个元素。
a = [‘scolia‘,‘中文‘] a.append(123) print a a.append([‘新列表‘,]) print a print a[1] print
这里有一个几个问题要注意一下：
1.列表中的中文在存储的时候，存的是中文的编码（具体的编码是文件开头声明的），元祖也是一样。
但是使用 print 的时候两者的行为又不同。
元祖能正确打印，而列表不能。
当然在用索引取到对象后则没有这些问题了。
2.[‘新列表‘,] 的写法
是不是列表中只有一个元素的时候就要这样写？不是的，这样写是为了提高代码的可读性，是让程序员能快速看出这是一个列表，元祖也可以这样写。当然不加逗号也不会报错。
3.a[3][0] 写法的含义
这个写法其实充分地体现出一个元素就是一个独立的对象。首先 a 是一个列表，我们可以用索引的方法取到一个对象 a[3] ，但a[3]取到的还是一个列表，那我是不是可以继续对这个取到的列表进行索引取元素。
所谓的连缀其原理也是这样的，到时候会继续分析。
2. L.insert(index, object) -- insert object before index
在特定的索引位置插入一个新元素，原来的元素都向后移一个位置。
a = [‘scolia‘, 123] a.insert(1, ‘good‘) print a a.insert(10, 456) print a
对于超出的索引值python会优雅地将其放在最后，此时相当于 append 。
但如果是负值的超出索引：
a = [‘scolia‘, 123] a.insert(-10, 456) print a
会放在最头，这也是python优雅的地方
3. L.extend(iterable) -- extend list by appending elements from the iterable
将一个可迭代的对象的所有元素逐一添加到列表的最后，关于迭代器我们以后会说明。
这里先记着比较常用的：
a = [‘scolia‘] b = [‘good‘,123,456] a.extend(b) print a print b
可以将两个列表合并成一个，当然 b 这里是元祖也可以，只要是可迭代的对象。另外还有注意并没有影响到b对象本身。
二、删
1. L.pop([index]) -> item -- remove and return item at index (default last)
删除给定索引对应的元素，并将其返回，不给索引时默认删除并返回列表的最后一个。当列表为空或给定的索引超出范围时抛出IndexError错误。
注意，这里的返回意味着我可以用变量去承接返回的这个元素（对象）。
a = [‘scolia‘, ‘good‘, 123, 456] b = a.pop() c = a.pop(0) print a print b print c
2. L.remove(value) -- remove first occurrence of value.
给定一个元素，将找到的第一个删除，注意和上面的不同，这里不会返回被删除的对象，只会返回一个空对象 None。
a = [‘scolia‘, 123, 123, 123, 456] print id(a[1]), id(a[2]), id(a[3]) b = 123 print id(b) a.remove(b) print a
关于这里的 123 为什么会是同一个对象我在python的序列中已经讲过了，这里写出了只是为了说明这里的删除在本质上只是删除一个引用对象而已，而何为引用我在python的赋值操作中讲过。
3.del 关键字
python中del这个关键字是专门用来删除对象的，而我们说过元素即是对象，所以我们可以通过索引，或者切片的方式取到对象，然后用del关键字删除掉。
a = [‘scolia‘, 456, 123, 123, 123] del a[1] print a del a[1:4] print a
注意：每次进行列表的修改都会刷新列表，在仅仅是修改的时候体现不明显，但在增删操作的时候，元素的添加或删除是会刷新整个列表的索引值的。
如这里，本来a[1]是456，但其被删掉了，后面元素的索引值就向前一位，所以我们a[1:4]得到的是剩下的三个123。
三、改
1.x[i]=y
修改一个元素。
a = [‘scolia‘, ‘good‘, 123, 456] a[1] = ‘very good‘ print a
注意：这里的索引一旦超过是会报错的，要求的是精准操作。
2.x[i:j]=y
修改多个元素
当数量是对应时：
a = [‘scolia‘, ‘good‘, 123, 456] a[1:4] = ‘very good‘, 111, 999 print a
数量不对应时：
a = [‘scolia‘, ‘good‘, 123, 456] b = [‘scolia‘, ‘good‘, 123, 456] a[1:4] = ‘very good‘, 111, 999, 888 b[1:4] = ‘very good‘, 111 print a print b
数量不对应且只有一个时：
a = [‘scolia‘, ‘good‘, 123, 456] b = [‘scolia‘, ‘good‘, 123, 456] a[1:4] = ‘very good‘ print a b[1:4] = 111 print b
是数字等非序列时，直接报错，字符串则逐个字符拆分后填充。
当新修改的是字典时：
a = [‘scolia‘, ‘good‘, 123, 456] b = [‘scolia‘, ‘good‘, 123, 456] a[1:4] = {‘abc‘:111} b[1:4] = {‘abc‘:111,‘cdf‘:123} print a print b
得到的键名，多于和少于是和上面的一样，但只有一个的时候，不会拆分。
这里的情况比较多，不过一般很少出现这些特殊情况，我这里只是尽量列举特殊情况而已，记不住也不要钻牛角尖。
3. L.sort(cmp=None, key=None, reverse=False) -- stable sort
将列表从小到大排序。
a = [‘scolia‘, 123, 123, 456] a.sort() print a
不同类型的大小比较问题，我在python中的数字里关于比较运算符的总结。
4. L.reverse() -- reverse
翻转列表的顺序，注意这里不是从大到小
a = [‘scolia‘, 123, 123, 456, ‘good‘] a.reverse() print a
5. L.__reversed__() -- return a reverse iterator over the list
翻转列表后，并将其生成可迭代对象。
a = [‘scolia‘, 123, 123, 456, ‘good‘] print type(a.__reversed__()) for x in a: print x
可迭代对象一般用于迭代循环，我们以后会讲。
四、查
关于索引、切片和成员判断也算是查的操作，不过已经讲过就不讲了。
1. L.count(value) -> integer -- return number of occurrences of value
返回元素在列表中出现的次数（计数器）。和元祖里的差不多，就不多讲了。
a = [‘scolia‘, 123, 123, 456] print a.count(123)
2. L.index(value, [start, [stop]]) -> integer -- return first index of value.
在列表中寻找给定元素的第一次出现的索引值，也和元祖里的一样。返回的是索引值，不是出现次数。
a = [‘scolia‘, 123, 123, 456] print a.index(123)
3. L.__sizeof__() -- size of L in memory, in bytes
返回列表在内存中大小，单位是字节。
关于列表就先讲到这里了，以后有需要会继续补充。
标签：
原文地址：http://www.cnblogs.com/scolia/p/5538305.html
