從 JavaScript 角度學 Python(11) - 串列 20 種操作的方法

發表於 更新於 分類於

Google AD

撰寫一篇文章其實真的很花時間，如果你願意「關閉 Adblock (廣告阻擋器)」來支持我的話，我會非常感謝你 ヽ(・∀・)ﾉ

Liker 讚賞

這篇文章如果對你有幫助，你可以花 30 秒登入 LikeCoin 並點擊下方拍手按鈕(最多五下)免費支持與牡蠣鼓勵我。
或者你可以請我喝一杯咖啡。

前面簡單聊了字典與串列之後，接下來我想額外拉一篇輕鬆無負擔的章節來描述與紀錄一下關於 Python 的串列處理。

前言

前面簡單聊了字典與串列之後，接下來我想額外拉一篇輕鬆無負擔的章節來描述與紀錄一下關於 Python 的串列處理。

JavaScript 的 20 種操作方法

在 JavaScript 中我們有高達約二十種的陣列操作方法，為了避免怕你忘記，所以以下也列出來給你回味一下：

  • shift
  • unshift
  • pop
  • push
  • splice
  • sort
  • reverse
  • length
  • join
  • reduce
  • reduceRight
  • indexOf
  • lastindexOf
  • some
  • every
  • forEach
  • map
  • filter
  • slice
  • concat

那麼 Python 呢？也會有這些類似 JavaScript 一樣多的陣列操作方法嗎？基本上是有的，而這邊我也盡可能依據兩種模式來分類：

  • 可能會因為操作而影響原有串列的方法
  • 不會影響原有串列的方法

底下也會搭配簡短的說明與範例來呈現。

所以這一篇相對會輕鬆一點，主要有點類似了解一下這些操作方法怎麼使用，如果這邊有遺漏或者寫錯就多多見諒(因為實在太多啦~~~)。

我粗估算了一下我列出來的數量也剛剛好與 JavaScript 相同都是二十種，而這一篇我就不會放上任何迷因圖哩。

可能會因為操作而影響原有串列的方法

基本上這邊的分類有可能會因為你的操作而導致原始串列的改變，所以在使用上就要多加注意一下，否則你有可能會寫出 Bug。

insert

將資料往特定索引位置塞入，請注意第一個參數是索引位置，第二個則是要塞入的內容，除此之外，所以位置是以 0 當作起始點唷。

1
2
3
lis = ['A', 'B', 'C']
lis.insert(1, 'Q')
print(lis) # ['A', 'Q', 'B', 'C']

append

append 與 JavaScript 的 push 方法有 87% 像，因此你也可以把它理解成 push 語法，因為它會在串列的最後一個插入資料。

1
2
3
lis = ['A', 'B', 'C']
lis.append('Q')
print(lis) # ['A', 'B', 'C', Q]

pop

pop 會將串列最後一筆給取出來：

1
2
3
lis = ['A', 'B', 'C']
print(lis.pop()) # C
print(lis) # ['A', 'B']

但是如果你傳入索引位置的話，則會變成指定取出：

1
2
3
lis = ['A', 'B', 'C']
print(lis.pop(1)) # B
print(lis) # ['A', 'C']

extend

extend 在翻譯上是擴展、延長的意思，所以它的概念類似於串列相加的概念。

1
2
3
4
5
6
lisA = ['A', 'B', 'C']
lisB = ['D', 'E', 'F']
lisA.extend(lisB)

print(lisA) # ['A', 'B', 'C', 'D', 'E', 'F']
print(lisB) # ['D', 'E', 'F']

sort

sort 非常的簡單，就是將串列中的內容作排序，基本上而排序的方式則是會依據 ASCII 去排序。

1
2
3
lis = [14, 30, 35, 42, 5, 16, 70, 98, 19, 100]
lis.sort()
print(lis) # [5, 14, 16, 19, 30, 35, 42, 70, 98, 100]

reverse

reverse 應該不用太多的說明了，就是反轉串列的意思。

1
2
3
lis = ['A', 'B', 'C', 'D', 'E', 'F']
lis.reverse()
print(lis) # ['F', 'E', 'D', 'C', 'B', 'A']

remove

remove 在運作上是採用內容的方式去刪除，假設如果你只知道該內容是什麼，但不知道索引位置，那就可以使用該方法。

1
2
3
lis = ['A', 'B', 'C', 'D', 'E', 'F']
lis.remove('D')
print(lis) # ['A', 'B', 'C', 'E', 'F']

clear

clear 非常的乾脆，就是直接清空串列。

1
2
3
lis = ['A', 'B', 'C', 'D', 'E', 'F']
lis.clear()
print(lis) # []

不會影響原有串列的方法

接下來這邊的操作上是不太會影響原有的串列。

len

len 非常好懂，與 JavaScript 的 length 非常相像，可以用於回傳陣列長度。

1
2
3
4
5
lisA = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(len(lisA))  # 10

lisB = ['r', 'a', 'y']
print(len(lisB)) # 3

index

找出串列中特定東西的索引位置，請注意 index 是以 0 為起始。

1
2
3
4
5
6
lis = ['r', 'a', 'y']

print(lis.index('r')) # 0
print(lis.index('a')) # 1
print(lis.index('y')) # 2
print(lis) # ['r', 'a', 'y']

reversed

reversed 與 reverse 非常的像，但是它不會影響原有的串列，因此反轉後會回傳一個新的串列，但請注意要使用 list 重新轉換。

1
2
3
lis = ['A', 'B', 'C', 'D', 'E', 'F']
print(list(reversed(lis))) # ['F', 'E', 'D', 'C', 'B', 'A']
print(lis) # ['A', 'B', 'C', 'D', 'E', 'F']

sorted

sorted 與 sort 也非常類似，但是它並不會影響到原有的串列。

1
2
3
lis = [14, 30, 35, 42, 5, 16, 70, 98, 19, 100]
print(sorted(lis)) # [5, 14, 16, 19, 30, 35, 42, 70, 98, 100]
print(lis) # [14, 30, 35, 42, 5, 16, 70, 98, 19, 100]

list

list 雖然可以拿來做轉換，但是它也可以拿來拷貝一份新的陣列。

在看範例之前，我想先補充一下，下面範例我有使用一個很特別的方法叫做 id()，這個方法可以回傳記憶體的位置，而會在前面提到這個是因為我們會使用 list 拷貝一份串列出來，為了驗證兩者串列的不同才會使用 id()。

1
2
3
4
5
6
7
lisA = [14, 30, 35, 42, 5, 16, 70, 98, 19, 100]
lisB = list(lisA)
print(id(lisA)) # 4464143936
print(id(lisB)) # 4464824640

lisA[0] = 1
print(lisB) # [14, 30, 35, 42, 5, 16, 70, 98, 19, 100]

slice

看到 slice 先不要興奮，在 Python 中的 slice 用法比較特別一點，主要是用 [:] 來切割串列，而不是 slice() 語法。

從起始 0 取到索引 4 的位置：

1
2
3
4
lisA = ['A', 'B', 'C', 'D', 'E', 'F']
lisB = lisA[:4]
print(lisA) # ['A', 'B', 'C', 'D', 'E', 'F']
print(lisB) # ['A', 'B', 'C', 'D']

從起始索引 2 到 4 的位置：

1
2
3
4
lisA = ['A', 'B', 'C', 'D', 'E', 'F']
lisB = lisA[2:4]
print(lisA) # ['A', 'B', 'C', 'D', 'E', 'F']
print(lisB) # ['C', 'D']

從索引 3 開始往後取得全部：

1
2
3
4
lisA = ['A', 'B', 'C', 'D', 'E', 'F']
lisB = lisA[3:]
print(lisA) # ['A', 'B', 'C', 'D', 'E', 'F']
print(lisB) # ['C', 'D', 'F']

copy

copy 方法就非常直覺就是拷貝的意思：

1
2
3
4
lisA = [14, 30, 35, 42, 5, 16, 70, 98, 19, 100]
lisB = lisA.copy()
print(id(lisA)) # 4464143936
print(id(lisB)) # 4464824640

filter

filter 用法其實與我們在寫 JavaScript filter 語法雷同可以用來做篩選資料的行為：

1
2
3
4
5
6
7
8
9
lisA = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def count(item):
  return item % 2 == 0

newList = filter(count, lisA)

print(list(newList)) # [2, 4, 6, 8, 10]
print(lisA) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

map

map 會建立一個新的陣列，然後依據你傳入的函式去回傳。

1
2
3
4
5
6
7
8
9
lisA = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def count(item):
  return item + item

newList = map(count, lisA)

print(list(newList)) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
print(lisA) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

any

any 概念類似 JavaScript 的 some，只要裡面有一個 True 那麼就會回傳 True。

1
2
3
4
5
lisA = [True, True, True]

print(any(lisA)) # True
lisB = [True, True, False]
print(any(lisB)) # True

all

all 對比 JavaScript 的話，則是 every，只要有一個是 False 那麼就會回傳 False。

1
2
3
4
5
lisA = [True, True, True]
print(all(lisA)) # True

lisB = [True, True, False]
print(all(lisB)) # False

join

join 會依據你傳入的變數內容來轉換成另一種形式呈現，而這個在呈現上也與 JavaScript 非常雷同。

1
2
3
4
5
lisA = ['A', 'B', 'C']
lisB = ['D', 'E', 'F']
s = '-'
print(s.join(lisA)) # A/B/C
print(lisA) # ['A', 'B', 'C']

參考文獻

作者的話

因為改買了紹興酒，所以今天跑去全聯買了雞蛋與去骨雞腿，只是這一次額外嘗試挑戰紹興酒蛋，但酒蛋必須是溏心蛋，所以只好明天來研究一下如何製作溏心蛋。

關於兔兔們

兔法無邊