从 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 当作起始点唷。

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

append

append 与 JavaScript 的 push 方法有 87% 像，因此你也可以把它理解成 push 语法，因为它会在串列的最後一个插入资料。

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

pop

pop 会将串列最後一笔给取出来：

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

但是如果你传入索引位置的话，则会变成指定取出：

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

extend

extend 在翻译上是扩展、延长的意思，所以它的概念类似於串列相加的概念。

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 去排序。

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 应该不用太多的说明了，就是反转串列的意思。

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

remove

remove 在运作上是采用内容的方式去删除，假设如果你只知道该内容是什麽，但不知道索引位置，那就可以使用该方法。

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

clear

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

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

不会影响原有串列的方法

接下来这边的操作上是不太会影响原有的串列。

len

len 非常好懂，与 JavaScript 的 length 非常相像，可以用於回传阵列长度。

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 为起始。

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 重新转换。

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 也非常类似，但是它并不会影响到原有的串列。

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()。

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 的位置：

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 的位置：

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

从索引 3 开始往後取得全部：

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 方法就非常直觉就是拷贝的意思：

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 语法雷同可以用来做筛选资料的行为：

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 会建立一个新的阵列，然後依据你传入的函式去回传。

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。

lisA = [True, True, True]

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

all

all 对比 JavaScript 的话，则是 every，只要有一个是 False 那麽就会回传 False。

lisA = [True, True, True]
print(all(lisA)) # True

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

join

join 会依据你传入的变数内容来转换成另一种形式呈现，而这个在呈现上也与 JavaScript 非常雷同。

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

参考文献

• 关於 JavaScript 阵列20种操作的方法

作者的话

因为改买了绍兴酒，所以今天跑去全联买了鸡蛋与去骨鸡腿，只是这一次额外尝试挑战绍兴酒蛋，但酒蛋必须是溏心蛋，所以只好明天来研究一下如何制作溏心蛋。

关於兔兔们

• Tailwind CSS 台湾官网
• Tailwind CSS 台湾 (脸书粉丝专页)
• 兔兔教 × Tailwind CSS Taiwan (脸书社群)
• 兔兔教大本营