列表特性總結

列表的一些特點：

1. 列表是最常用的線性資料結構
2. list是一系列元素的有序組合
3. list是可變的

列表的操作，

1. 增：append、extend、insert
2. 刪：clear、pop、remove
3. 改：reverse、sort
4. 查：count、index
5. 其他：copy

>>> [a for a in dir(list) if not a.startswith('__')]
['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
 

定義與初始化列表

lst = list() # 使用list函式定義空列表
lst = []     # 使用中括號定義空列表
a = [1, 2, 3] # 使用中括號定義帶初始值的列表
lst = list(range(1, 10)) # 使用list函式把可迭代物件轉化為列表
a_ref = aa[2] = 100

列表的訪問

可以通過下標訪問列表中的元素，下標從0開始。當下標超出範圍時，會丟擲IndexError異常。下標可以是負數，負數下標從右開始，與正數下標剛好相反。負數下標從-1開始。不管是正數的下標還是負數的下標，只要超出範圍，就會丟擲異常。

lst = [1, 2, 3]
print(lst[0])
print(lst[2])
# print(lst[3])
 

列表常用操作

我們可以通過列表的下標（或索引）找到相應的元素，也可以通過列表元素找到其相應的索引。列表提供了index方法可以實現此需求，接下來我們就看一下如何使用列表的index方法。

lst = [1, 2, 3, 2, 5]help(lst.index)
 : Help on built-in function index:
 : 
 : index(...) method of builtins.list instance
 :     L.index(value, [start, [stop]]) -> integer -- return first index of value.
 :     Raises ValueError if the value is not present.
 : 
 

index可以有其他兩個引數，start，stop可以為負數，但是總是從左往右查詢。

index方法根據值返回第一個索引。

a_copy = a[:]
a.append(300) # 在列表的末尾增加一個元素
a.insert(1, 50) # 在指定位置增加一個元素，如果索引超出範圍，如果是正索
                # 引，等效於append，如果索引為負數，等效於insert(0, object)。
a.pop() # 預設從列表最後移除一個元素，可以指定索引；索引不能超出範圍
a.sort() # 排序方法a.reverse() # 反轉方法
a.remove(value) # 移除列表中第一次出現的value，如果value不存在，則丟擲ValueError異常
del a[1]

列表的count方法用於返回列表裡出現元素的個數，如果沒有就返回0。

lst = [1, 2, 3, 2, 3, 5]
print(lst.count(2))
print(lst.count(5))
# there was no element 0
print(lst.count(0))

count方法的原型：

def count(lst, value):
    c = 0
    for x in lst:
        if x == value:
            c += 1
    return c

index和count的時間複雜度是O(n)線性複雜度（效率與資料規模成線性相關）。

由於列是可變的資料結構，因此可以對列表的元素可以進行修改。修改列表的元素直接使用下標操作取出元素並對其賦值即可。

lst = [1, 2, 3, 2, 4, 3, 5]
print(lst[2])
lst[2] = 5
print(lst[2])
# 對超出範圍的索引修改元素，會丟擲IndexError異常
# lst[7] = 7

增加列表元素，使用修改列表元素的方法不能增加列表元素。可以使用append方法來增加列表的元素，

lst = [1, 3, 5, 7]
lst.append(9)
print(lst)
lst.extend([1, 2, 3])
print(lst)
lst.extend(range(3))
print(lst)

# remove
# 根據值來刪除
# 從左到右刪除第一次出現的元素
lst.remove(1)
print(lst)
# 刪除一個不存在的值時，會丟擲ValueError異常
# lst.remove(10)# pop
# 預設返回並刪除最後一個元素
lst.pop()
print(lst)
# pop可以有引數
# 返回並刪除索引所在位置的元素
lst.pop(1)
print(lst)
# 當pop不存在的索引時，丟擲IndexError異常
# lst.pop(100)

執行結果為：

 : [1, 3, 5, 7, 9]
 : [1, 3, 5, 7, 9, 1, 2, 3]
 : [1, 3, 5, 7, 9, 1, 2, 3, 0, 1, 2]
 : [3, 5, 7, 9, 1, 2, 3, 0, 1, 2]
 : [3, 5, 7, 9, 1, 2, 3, 0, 1]
 : [3, 7, 9, 1, 2, 3, 0, 1]

append與extend的對比：

• append原地修改列表，返回None
• extend原地修改，返回None
• append操作單個元素
• extend操作可迭代物件

pop與remove的對比：

• pop是彈出索引對應的值
• remove是刪除最左邊的第一次出現的值
• pop針對的是索引
• remove針對的是值
• pop不傳遞index引數時，其時間複雜度為O(1)
• pop傳遞index引數時，其時間複雜度為O(n)

insert可以在指定的位置處插入元素。當insert時，索引超出範圍時：

• 索引是負數，會在第0個元素前插入元素
• 索引是正數，會在最後一個元素後插入元素

lst = [1, 3, 5, 7]
lst.insert(2, 'm')
print(lst)
lst.insert(10, 'e')
print(lst)
lst.insert(-10, 'a')
print(lst)

執行結果為：

: [1, 3, 'm', 5, 7]
: [1, 3, 'm', 5, 7, 'e']
: ['a', 1, 3, 'm', 5, 7, 'e']

insert操作的時間複雜度是O(n)，append操作的時間複雜度是O(1)。

列表有copy的方法，

lst1 = [1, 3, 2, 5, 7]
lst2 = lst1 # 賦值操作，對可變物件是引用傳遞，對不可變物件是傳值
print(lst2)
lst2.remove(2)
print(lst2)
print(lst1)
lst1 = [1, 3, 2, 5, 7]
lst2 = lst1.copy() # 影子拷貝
lst2.remove(2)
print(lst2)
print(lst1)

執行結果為:

: [1, 3, 2, 5, 7]
: [1, 3, 5, 7]
: [1, 3, 5, 7]
: [1, 3, 5, 7]
: [1, 3, 2, 5, 7]

賦值操作傳遞的是引用，也叫淺拷貝。

copy方法的原型：

def copy(lst):
    tmp = []
    for i in lst:
        tmp.append(i)
    return tmp

清除列表，

lst.clear() # 刪除所有元素

求list的長度，

lst = []
print(len(lst))
lst = list(range(4))
print(len(lst))

列表反轉，

列表排序，原地修改，返回None。預設是順序排列，

lst.sort()
lst.sort(reverse=True)

去除列表中重複元素，

L1 = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
L2 = []
[L2.append(i) for i in L1 if not i in L2]
print(L2)
: ['b', 'c', 'd', 'a']

iter = (x ** 2 for x in range(10) if x % 2 == 0)
iter
<generator object <genexpr> at 0x1056b42b0>>>> 
for el in iter:
    print(el)   
0
4
16
36
64
###>>> print [(x, y) for x in (1, 2, 3, 4) for y in (10, 15, 3, 22) if x * y > 25]
[(2, 15), (2, 22), (3, 10), (3, 15), (3, 22), (4, 10), (4, 15), (4, 22)]

來看幾個跟列表應用的例子，

# 求素數的列表使用法lst = []for n in range(2, 101):
    for x in lst:
        if n % x == 0:
            break
        else:
            lst.append(n)
            print(n)

一個例子

一個可以輸出直方圖的例子，程式碼如下:

(venv) [lavenliu@VM_171_247_centos mysite]$ cat hist.py 
# 從一個列表中建立一個直方圖
values = []   # 首先建立一個空列表# 我們輸入10個整數
print("Enter 10 integers:")
for i in range(10):
    newValue = int(input("Enter integer %d: " % (i+1)))
    values += [newValue]
# 建立直方圖
print("nCreating a histogram from values:")
print("%s %10s %10s" % ("Element", "Value", "Histogram"))
for i in range(len(values)):
    print("%7d %10d  %s" % (i, values[i], "*" * values[i]))

執行結果為:

(venv) [lavenliu@VM_171_247_centos mysite]$ python hist.py 
Enter 10 integers:
Enter integer 1: 10
Enter integer 2: 8
Enter integer 3: 23
Enter integer 4: 15
Enter integer 5: 2
Enter integer 6: 5
Enter integer 7: 7
Enter integer 8: 9
Enter integer 9: 6
Enter integer 10: 4

Creating a histogram from values:
Element      Value  Histogram
      0         10  **********
      1          8  ********      
      2         23  ***********************      
      3         15  ***************      
      4          2  **      
      5          5  *****      
      6          7  *******      
      7          9  *********      
      8          6  ******      
      9          4  ****