先看列表是如何創建的： 同樣有兩種創建方式，但一般用第一種。 列表和元祖最大的不同就是列表是可以修改的。 老規矩，使用 help(list) ,真的是 help() 大法好呀。 好，來人，上代碼。 Help on class list in module __builtin__: class lis ...
先看列表是如何創建的：
a = ['scolia', 123] b = list('scolia',123)
同樣有兩種創建方式，但一般用第一種。
列表和元祖最大的不同就是列表是可以修改的。
老規矩，使用 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 Tlist
按照其功能可以將內置方法分為以下幾類：
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
