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

前言

前面簡單聊了字典與串列之後,接下來我想額外拉一篇輕鬆無負擔的章節來描述與紀錄一下關於 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

reversedreverse 非常的像,但是它不會影響原有的串列,因此反轉後會回傳一個新的串列,但請注意要使用 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

sortedsort 也非常類似,但是它並不會影響到原有的串列。

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']

參考文獻

作者的話

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

關於兔兔們

兔法無邊

Liker 讚賞 (拍手)

如果這一篇筆記文章對你有幫助,希望可以求點支持或 牡蠣 鼓勵 (ノД`)・゜・。

Liker 是一個按讚(拍手)的讚賞機制,每一篇文章最多可以按五下(拍手),按讚過程你是完全不用付費的(除非你想要每個月贊助我 :D),你只需要登入帳號就可以開始按讚。
而 Liker 會依據按讚數量分配獎金給創作者,所以如果你願意按個讚我會非常感謝你唷。

Google AD

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