列表類型簡介
列表類型是一個容器，它里面可以存放任意數量、任意類型的數據。
例如下面的幾個列表中，有存儲數值的、字符串的、內嵌列表的。不僅如此，還可以存儲其他任意類型。
>>> L = [1, 2, 3, 4]
>>> L = ["a", "b", "c", "d"]
>>> L = [1, 2, "c", "d"]
>>> L = [[1, 2, 3], "a", "b", [4, "c"]]
python中的列表是一個序列，其內元素是按索引順序進行存儲的，可以進行索引取值、切片等操作。
列表結構
列表是可變對象，可以原處修改列表中的元素而不會讓列表有任何元數據的變動。
>>> L = ["a", "b", "c"]
>>> id(L), id(L[0])
(57028736, 55712192)
>>> L[0] = "aa"
>>> id(L), id(L[0])
(57028736, 56954784)
從id的變動上看，修改列表的第一個元素時，列表本身的id沒有改變，但列表的第一個元素的id已經改變。
看了下面列表的內存圖示就很容易理解了。
上面是L = ["a", "b", "c"]列表的圖示。變量名L存儲了列表的內存地址，列表內部包含了類型聲明、列表長度等元數據，還保存了屬於列表的3個元素的內存地址。需要注意的是，列表元素不是直接存在列表范圍內的，而是以地址的形式保存在列表中。
所以，修改列表中的元素時，新建一個元素"aa"(之所以新建，是因為字符串是不可變類型)，列表本身並沒有改變，只是將列表中指向第一個元素的地址改為新數據"aa"的地址。
因為修改列表數據不會改變列表本身屬性，這種行為稱為"原處修改"。
所以，列表有幾個主要的的特性：
- 列表中可以存放、嵌套任意類型的數據
- 列表中存放的是元素的引用，也就是各元素的地址，因此是列表可變對象
- 列表是可變序列。所以各元素是有位置順序的，可以通過索引取值，可以通過切片取子列表
構造列表
有兩種常用的構造列表方式：
- 使用中括號
[] - 使用list()構造方法
使用(中)括號構建列表時，列表的元素可以跨行書寫，這是python語法中各種括號類型的特性。
例如：
>>> [] # 空列表
>>> [1,2,3]
[1, 2, 3]
>>> L = [
1,
2,
3
]
>>> list('abcde')
['a', 'b', 'c', 'd', 'e']
>>> list(range(0, 4))
[0, 1, 2, 3]
上面range()用於生成一系列數值，就像Linux下的seq命令一樣。但是range()不會直接將數據生成出來，它返回的是一個可迭代對象，表示可以一個一個地生成這些數據，所以這里使用list()將range()的數據全部生成出來並形成列表。
中括號方式構造列表有一個很重要的特性：列表解析，很多地方也稱為"列表推到"。例如：
>>> [x for x in 'abcdef']
['a', 'b', 'c', 'd', 'e', 'f']
list()是直接將所給定的數據一次性全部構造出來，直接在內存中存放整個列表對象。列表推導方式構造列表比list()要快，且性能差距還挺大的。
列表基本操作
列表支持+ *符號操作：
>>> L = [1,2,3,4]
>>> L1 = ['a','b','c']
>>> L + L1
[1, 2, 3, 4, 'a', 'b', 'c']
>>> [1,2] + list("34")
[1, 2, '3', '4']
>>> L * 2
[1, 2, 3, 4, 1, 2, 3, 4]
>>> 2 * L
[1, 2, 3, 4, 1, 2, 3, 4]
可以通過+=的方式進行二元賦值：
>>> L1 = [1,2,3,4]
>>> L2= [5,6,7,8]
>>> L1 += L2
>>> L1
[1, 2, 3, 4, 5, 6, 7, 8]
L1 += L2的賦值方式對於可變序列來說(比如這里的列表)，性能要好於L1 = L1 + L2的方式。前者直接在L1的原始地址內進行修改，后者新創建一個列表對象並拷貝原始L1列表。但實際上，性能的差距是微乎其微的，前面說過列表中保存的是元素的引用，所以拷貝也僅僅只是拷貝一些引用，而非實際數據對象。
列表是序列，序列類型的每個元素都是按索引位置進行存放的，所以可以通過索引的方式取得列表元素：
>>> L = [1,2,3,4,5]
>>> L[0]
1
>>> L = [
... [1,2,3,4],
... [11,22,33,44],
... [111,222,333,444]
... ]
>>> L[0][2]
3
>>> L[1][2]
33
>>> L[2][2]
333
當然，也可以按索引的方式給給定元素賦值，從而修改列表：
>>> L = [1,2,3,4,5]
>>> L[0] = 11
通過賦值方式修改列表元素時，不僅可以單元素賦值修改，還可以多元素切片賦值。
>>> L[1:3] = [22,33,44,55]
>>> L
[11, 22, 33, 44, 55, 4, 5]
上面對列表的切片進行賦值時，實際上是先取得這些元素，刪除它們，並插入新數據的過程。所以上面是先刪除[1:3]的元素，再在這個位置處插入新的列表數據。
所以，如果將某個切片賦值為空列表，則表示直接刪除這個元素或這段范圍的元素。
>>> L
[11, 22, 33, 44]
>>> L[1:3] = []
>>> L
[11, 44]
但如果是將空列表賦值給單個索引元素，這不是表示刪除元素，而是表示將空列表作為元素嵌套在列表中。
>>> L = [1,2,3,4]
>>> L[0] = []
>>> L
[[], 2, 3, 4]
這兩種列表賦值的區別，在理解了前文所說的列表結構之后應該不難理順。
列表其它操作
列表是一種序列，所以關於序列的操作，列表都可以用，比如索引、切片、各種序列可用的函數(比如append()、extend()、remove()、del、copy()、pop()、reverse())等。詳細內容參見：python序列操作
除了這些序列通用操作，列表還有一個專門的列表方法sort，用於給列表排序。
列表排序sort()和sorted()
sort()是列表類型的方法，只適用於列表；sorted()是內置函數，支持各種容器類型。它們都可以排序，且用法類似，但sort()是在原地排序的，不會返回排序后的列表，而sorted()是返回新的排序列表。
>>> help(list.sort)
Help on method_descriptor:
sort(...)
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
>>> help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
本文僅簡單介紹排序用法。
例如列表L：
>>> L = ['python', 'shell', 'Perl', 'Go', 'PHP']
使用sort()和sorted()排序L，注意sort()是對L直接原地排序的，不是通過返回值來體現排序結果的，所以無需賦值給變量。而sorted()則是返回排序后的新結果，需要賦值給變量才能保存排序結果。
>>> sorted(L)
['Go', 'PHP', 'Perl', 'python', 'shell']
>>> L
['python', 'shell', 'Perl', 'Go', 'PHP']
>>> L.sort()
>>> L
['Go', 'PHP', 'Perl', 'python', 'shell']
不難發現，sort()和sorted()默認都是升序排序的(A<B<...<Z<a<b<...<z)。它們都可以指定參數reverse=True來表示順序反轉，也就是默認得到降序：
>>> L.sort(reverse=True)
>>> L
['shell', 'python', 'Perl', 'PHP', 'Go']
在python 3.x中，sort()和sorted()不允許對包含不同數據類型的列表進行排序。也就是說，如果列表中既有數值，又有字符串，則排序操作報錯。
sort()和sorted()的另一個參數是key，它默認為key=None，該參數用來指定自定義的排序函數，從而實現自己需要的排序規則。
例如，上面的列表不再按照默認的字符順序排序，而是想要按照字符串的長度進行排序。所以，自定義這個排序函數：
>>> def sortByLen(s):
... return len(s)
然后通過指定key = sortByLen的參數方式調用sort()或sorted()，在此期間還可以指定reverse = True：
>>> L = ['shell', 'python', 'Perl', 'PHP', 'Go']
>>> sorted(L,key=sortByLen)
['Go', 'PHP', 'Perl', 'shell', 'python']
>>> L.sort(key=sortByLen,reverse=True)
>>> L
['python', 'shell', 'Perl', 'PHP', 'Go']
再例如，按照列表每個元素的第二個字符來排序。
def f(e):
return e[1]
L = ['shell', 'python', 'Perl', 'PHP', 'Go']
sorted(L, key=f)
L.sort(key=f)
更多的排序方式，參見：sorting HOWTO。比如指定兩個排序依據，一個按字符串長度升序排，長度相同的按第2個字符降序排。用法其實很簡單，不過稍占篇幅，所以本文不解釋了。
列表迭代和解析
列表是一個序列，可以使用in測試，使用for迭代。
例如：
>>> L = ["a","b","c","d"]
>>> 'c' in L
True
>>> for i in L:
... print(i)
...
a
b
c
d
再說列表解析，它指的是對序列中(如這里的列表)的每一項元素應用一個表達式，並將表達式計算后的結果作為新的序列元素(如這里的列表)。
通俗一點的解釋，以列表序列為例，首先取列表各元素，對每次取的元素都做一番操作，並將操作后得到的結果放進一個新的列表中。
因為解析操作是一個元素一個元素追加到新列表中的，所以也稱為"列表推導"，表示根據元素推導列表。
最簡單的，將字符串序列中的各字符取出來放進列表中：
>>> [ i for i in "abcdef" ]
['a', 'b', 'c', 'd', 'e', 'f']
這里是列表解析，因為它外面使用的是中括號[]，表示將操作后的元素放進新的列表中。可以將中括號替換成大括號，就變成了集合解析，甚至字典解析。但注意，沒有直接的元組解析，因為元組的括號是特殊的，它會被認為是表達式的優先級包圍括號，而不是元組構造符號。
取出元素對各元素做一番操作：
>>> [ i * 2 for i in "abcdef" ]
['aa', 'bb', 'cc', 'dd', 'ee', 'ff']
>>> L = [1,2,3,4]
>>> [ i * 2 for i in L ]
[2, 4, 6, 8]
>>> [ (i * 2, i * 3) for i in L ]
[(2, 3), (4, 6), (6, 9), (8, 12)]
解析操作和for息息相關，且都能改寫成for循環。例如，下面兩個語句得到的結果是一致的：
[ i * 2 for i in "abcdef" ]
L = []
for i in "abcdef":
L.append(i * 2)
但是解析操作的性能比for循環要更好，正符合越簡單越高效的理念。
學過其他語言的人，估計已經想到了，解析過程中對各元素的表達式操作類似於回調函數。其實在python中有一個專門的map()函數，它以第一個參數作為回調函數，並返回一個可迭代對象。也就是說，也能達到和解析一樣的結果。例如：
>>> def f(x):return x * 2
...
>>> list(map(f,[1,2,3,4]))
[2, 4, 6, 8]
map()函數在后面的文章會詳細解釋。