python之列表操作的幾個函數

Python中的列表是可變的，這是它卻別於元組和字符串最重要的特點，元組和字符串的元素不可修改。列舉一些常用的列表操作的函數和方法。

1，list.append(x)，將x追加到列表list末尾：

stack = [3,4,5] #定義列表
print(id(stack)) #打印列表的id值
stack.append(6) #將6追加到列表末尾
print(stack) #打印列表
print(id(stack)) #打獵列表的id值
stack.append(7) #將7追加到列表
print(stack) #打印列表
print(id(stack)) #打印列表的id值
'''總結：通過打印id發現，append是在原對象的基礎上新增元素，並沒有改變原對象在內存中的存儲。'''

2，list.extend(L)，通過添加指定迭代器的所有元素來擴充列表，相當於a[len(a):] = L，其中L必須是可迭代的，如列表，字符串，字典，集合等。

#list.extend(L)，通過添加指定列表的所有元素來擴充列表，相當於，list[len(list):] = L
#參數L必須是可迭代的，可以是列表，元組，字符串，字典。集合。

a = [1] #定義原始列表
sTring = 'string' #定義字符串
listNumber = list(range(2,20,3)) #定義數字列表，步長為3
listString = ['a','b','d','e'] #定義字符串列表
dictTa = {'value':120131,'label':'Description','name':'Python',} #定義字典
setTa = set({'value':120131,'label':'Description','name':'Python',}) #定義集合

print(a) #打印原始的列表a
print(id(a)) #打印原始列表的id值

a.extend(sTring) #將字符串sTring作為參數傳遞給extend，以擴充原始列表a
print(type(sTring)) #打印下字符串列表的數據類型
print(a) #打印通過extend擴充字符串后的列表a
print(id(a)) #打印擴充后的列表的id值，與原始id值一樣

a.extend(listNumber) #將數字列表listNumber作為參數傳遞給extend，以擴充列表a
print(type(listNumber)) #打印一下數字列表的數據類型
print(a) #打印通過extend擴充數字列表后的列表a
print(id(a)) #打印擴充數字列表后的id值

a.extend(listString) #將字符串列表作為參數傳遞給extend，以擴充列表a
print(type(listString)) #打印字符串列表的數據類型
print(a) #打印通過extend擴充字符串列表后的列表a
print(id(a)) #打印擴充字符串列表后的id值

a.extend(dictTa) #將字典dictTa作為參數傳遞給extend，以擴充列表
print(type(dictTa)) #打印字典的數據類型
print(a) #打印通過extend擴充字典列表后的列表a
print(id(a)) #打印擴充字典后的id值

a.extend(setTa) #將集合setTa作為參數傳遞給extend，以擴充列表a
print(type(setTa)) #打印集合setTa的數據類型
print(a) #打印通過extend擴充集合后的列表a
print(id(a)) #打印擴充集合后的id值
'''總結，1，id值並沒有變，也就是內存中數據存儲並沒有變；
        2，字典和集合通過extend只擴充鍵，值沒有一起被擴充；
        3，字典和集合通過extend擴充，
            字典的鍵是“有序”排列，即在字典中的位置是啥位置，擴充后在列表中也是對應；
            而集合的鍵是“隨機”排列；

3，list.insert(i,x) 在列表的指定位置插入元素。其中第一個參數i指定列表索引位置，第二個為要插入的值x。如list.insert(0,x)，就是在列表的最前面插入元素x，list.insert(2,x)，就表示在列表索引為2的位置插入元素x；list.insert(len(list),x)，表示在列表末尾插入元素x，相當於list.append(x)。

a = [1,2,3,4,5]
b = ['4','6','8','10']
c = ['a','b','c','d','e']
d = list(range(1,100,20))

a.insert(3,6) #在列表a索引為3的位置插入數字6
a.insert(len(a),7) #在列表b末尾插入數字7，相當於a.append(7)
b.insert(5,'12') #在列表b索引為5的位置插入字符串12
b.insert(len(b),'14') #在列表b末尾插入字符串14，相當於b.append('14')
c.insert(3,'f') #在列表c索引為3的位置插入字符串'f'
c.insert(len(c),'g') #在列表c的末尾插入字符串g，相當於c.append('g')
d.insert(2,10) #在列表d索引為2的位置插入數字10
d.insert(len(d),100) #在列表d的末尾插入數字100，相當於d.append(100)

還有一個問題，如果insert指定的索引位置的值大於列表索引位置的最大值，即list.insert(i,x)，當i>len(list)的時候，x將會被追加到列表末尾，相當於list.append(x)。

4，list.remove(x) 刪除列表中第一個值為x的元素。如果沒有，將引發一個ValueError的錯誤。為了方便演示，創建一個首尾相同元素的列表。

#list.remove(x) 刪除列表list中值為x的第一個元素，如果值不存在就會返回一個錯誤
a = ['a','b','c','d','e','a'] #定義首尾元素相同的列表，方便演示
b = a.remove('a') #刪除列表a里第一個值為字符串a的元素並賦值給變量b
print(a) #打印列表，列表中第一次出現的a被刪除
print(b) #打印b，返回None
c = a.remove('a') #再刪a，就把最后一個a也從列表刪除了
print(a) #打印是否符合預期
print(c) #打印c，返回None

5，list.pop([i]) 從列表的指定位置刪除元素（本人理解為從列表指定位置彈出元素），與remove不同，pop方法刪除的元素是可以返回的。如果沒有指定可選參數[i]的值，pop()從列表末尾開始刪除。pop([i])方法中 i 兩邊的方括號表示這個參數是可選的，而不是要求輸入一對方括號，經常在 Python 庫參考手冊中遇到這樣的標記。為方便與remove對比，還是用上面的例子：

a = ['a','b','c','d','e','a'] #定義首尾元素相同的列表，方便演示
b = a.remove('a') #刪除列表a里第一個值為字符串a的元素並賦值給變量b
print(a) #打印列表，列表中第一次出現的a被刪除
print(b) #打印b，返回None
c = a.remove('a') #再刪a，就把最后一個a也從列表刪除了
print(a) #打印是否符合預期
print(c) #打印c，返回None

d = a.pop(1) #使用pop方法彈出列表a中索引為1的值
print(a) #打印列表a
print(d) #打印彈出的值，值為字符串c

6，list.clear() 移除列表中所有的項，但是保存列表list的數據類型，使用clear方法后，list返回一個空列表。等同於del list[:]

a = [1,2,3,4,5] #定義數字列表b
print(id(a)) #打印列表a的id值
a.clear() #使用方法clear()清空列表中所有項
print(a) #打印a，返回空列表
print(type(a)) #打印數據類型，返回<class 'list'>
print(id(a)) #再次打印列表a的id值，與沒刪除之前一樣

b = [2,3,4,5,6] #定義列表b
print(id(b)) #打印列表b的id值
del b[:] #刪除列表b在內存中的副本，b[:]表示列表b的一個切片，也可以理解為副本.
print(b) #打印列表b，返回[]
print(type(b)) #查看列表b的數據類型，返回<class 'list'>
print(id(b)) # 查看被清空后的列表b的id值與未清空之前是否相同

c = [6,7,8,9,10] #定義列表c
print(c) #打印c，輸出：[6, 7, 8, 9, 10]
del c #刪除c
print(c) #打印c，NameError: name 'c' is not defined

問題：列表b和列表c都是使用的del語句，列表b使用切片，內存中還有位置；列表c是把整個對象都刪除了，在內存中根本沒有了位置。要惡補內存，數據，存儲，對象的知識。

7，list.index(x) 返回列表list中第一個值為x的索引，如果沒有將返回一個ValueError: xxx is not in list錯誤。其中xxx是引發錯誤的值。

a = [1,2,3,4,5] #定義數字列表
b = ['a','b','c','d','e','a'] #定義字符串列表

r1 = a.index(1) #獲取值為1的索引
print(r1)    #打印返回0
r1 = a.index(2) #獲取列表a中值為2的索引
print(r1)    #打印返回1
r1 = a.index(3) #獲取列表a中值為3的索引
print(r1)    #打印返回2
r1 = a.index(4) #獲取列表a中值為4的索引
print(r1)    #打印返回3
r1 = a.index(5) #獲取列表a中值為5的索引
print(r1)    #打印返回4
r1 = a.index(6) #嘗試獲取列表a中值為6的索引，因為值6根本不存在與列表中，返回錯誤ValueError: 6 is not in list


#循環讀取索引
for index, value in enumerate(a):
    print(index)

for index in range(len(a)):
    print(index)

r2 = b.index('a') #獲取列表b中第一個值為a的索引
print(r2)     #打印返回0
r2 = b.index('b') #獲取列表b中第一個值為b的索引
print(r2)    #打印返回1
r2 = b.index('c') #獲取列表b中第一個值為c的索引
print(r2)     #打印返回2
r2 = b.index('d') #獲取列表b中第一個值為d的索引
print(r2)    #打印返回3
r2 = b.index('e') #獲取列表b中第一個值為e的索引
print(r2)    #打印返回4
r2 = b.index('a') #還是獲取列表b中第一個返回值為a的索引
print(r2)     #打印還是返回0

#循環讀取索引
for index, value in enumerate(b):
    print(index)

for index in range(len(b)):
    print(index)
    
    

8，list.count(x) 統計x在列表list中出現的次數。

 

a = [1,2,3,4,5,5,1] #定義數字列表
b = ['a','b','c','d','e','a'] #定義字符串列表

print(a.count(1)) #計算數字1在列表a中出現的次數並打印
print(a.count(6)) #計算數字6在列表a中出現的次數並打印
print(b.count('a')) #計算字符串a在列表b中出現的次數並打印
print(b.count('c')) #計算字符串c在列表b中出現的次數並打印

9，list.sort() 對列表中的元素進行排序(永久），與之對應的有臨時排序sorted(list)。用法如下：

orginalAlist = [1,2,3,4,5,5,1] #定義數字列表
orginalBlist = ['a','b','c','d','e','a'] #定義字符串列表

sortedAlist = sorted(orginalAlist) #對列表A進行臨時排序並賦值給變量sortedAlist
print(sortedAlist) #打印臨時排序后的列表 [1, 1, 2, 3, 4, 5, 5]
print(orginalAlist) #打印原始列表 [1, 2, 3, 4, 5, 5, 1]

sortedBlist = sorted(orginalBlist) #對列表B進行臨時排序並賦值給變量sortedBlist
print(sortedBlist) #打印臨時排序后的列表 ['a', 'a', 'b', 'c', 'd', 'e']
print(orginalBlist) #打印原始列表 ['a', 'b', 'c', 'd', 'e', 'a']


orginalAlist.sort() #將列表orginalAlist用sort進行永久排序
print(orginalAlist) #打印列表 [1, 1, 2, 3, 4, 5, 5]

orginalBlist.sort() #將列表orginalBlist用sort進行永久排序
print(orginalBlist) #打印列表 ['a', 'a', 'b', 'c', 'd', 'e']

10，倒序排列列表中的元素，一般與sort配合使用。

orginalAlist = [1,2,3,4,5,5,1] #定義數字列表
orginalBlist = ['a','b','c','d','e','a'] #定義字符串列表

orginalAlist.reverse() #調用reverse倒序排列列表
print(orginalAlist) #打印 [1, 5, 5, 4, 3, 2, 1]

orginalBlist.reverse() #調用reverse倒序排列列表
print(orginalBlist) #打印 ['a', 'e', 'd', 'c', 'b', 'a']

orginalAlist.sort(reverse=True) #將列表orginalAlist先用sort進行排序，然后將reverse=True作為參數傳遞給sort，將排序好的列表進行倒序排列
print(orginalAlist) #打印排序好的倒序列表 [5, 5, 4, 3, 2, 1, 1]

orginalBlist.sort(reverse=True) #將列表orginalBlist先用sort進行排序，然后將reverse=True作為參數傳遞給sort，將排序好的列表進行倒序排列
print(orginalBlist) #打印排序好的倒序列表 ['e', 'd', 'c', 'b', 'a', 'a']

11，list.copy() 對列表進行淺復制，相當於list[:]

a = [1,2,3,4,5,5,1] #數字列表a
b = ['a','b','c','d','e','a'] #字符串列表b

a1 = a.copy() #將a復制一份並賦值給a1
a2 = a[:] #將a再復制一份並賦值給a2
print(a,a1,a2) #打印三個列表，一樣
print(id(a),id(a1),id(a2)) #打印id，表示並不是同一個對象

b1 = b.copy() #將b復制一份並賦值給b1
b2 = b[:] #將b再復制一份並賦值給b2
print(b,b1,b2) #打印三個列表，內容一致
print(id(b),id(b1),id(b2)) #打印三個列表id，證明三個列表並不是同一個對象

代碼並無實際應用意義，僅供交流學習使用，歡迎補充。