迭代对象操作

本篇教学会介绍“迭代对象操作”的内建函数，学会这些用法之后，对于串列、字典、tuple 或集合的操作，就能更加得心应手。

本篇使用的 Python 版本为 3.7.12，所有范例可使用 Google Colab 实作，不用安装任何软件 ( 参考：使用 Google Colab )

常用操作方法

range(start, stop, step)

range(start, stop, step) 可以产生一个“整数序列”，产生后可透过 list()、tuple() 之类的方法转换成对应的类别。

a = range(1,5)
b = range(1,100,10)
c = range(5,-5,-1)
print(list(a))   # [1, 2, 3, 4]
print(list(b))   # [1, 11, 21, 31, 41, 51, 61, 71, 81, 91]
print(list(c))   # [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]

range() 很常出现在一些循环的范例中，下方的例子，会印出 10 以内的奇数。

for i in range(1,10,2):
  print(i)   # 1 3 5 7 9

len(iter)

len(x) 可以取得串列、字典、集合、tuple 的长度 ( 有几个项目 )，也可以取得字串的长度 ( 有几个字母或数字 )

a = [1,2,3,4,5]
b = (1,2,3,4,5)
c = {'x','y','z'}
d = {'a':1,'b':2,'c':3,'d':4}
e = 'apple'
print(len(a))    # 5
print(len(b))    # 5
print(len(c))    # 3
print(len(d))    # 4
print(len(e))    # 5

map(function, iter)

map() 可以使用指定的函数，依序处理可迭代对象的每个项目，处理后产生一个全新的对象，下方的程序使用了同样效果的具名函数 a 和匿名函数 lambda，将原本 [1,2,3,4,5] 串列里每个项目都增加 1，最后转换成串列和 tuple。

map() 会将第二个参数的可迭代对象，提供给第一个参数的函数作为引数使用。

def a(x):
    return x+1
b = map(a, [1,2,3,4,5])
c = map(lambda x: x+1, [1,2,3,4,5])

print(list(b))    # [2, 3, 4, 5, 6]
print(tuple(c))   # (2, 3, 4, 5, 6)

下方的例子，a 为一个文字串列，透过 map() 的方式可以快速的将 a 转换为数字串列。

a = ['1', '2', '3' ,'4', '5']
print(a)                # ['1', '2', '3' ,'4', '5']

b = list(map(int, a))   # 取出 a 的每個項目，套用 int(項目)，組成新物件
print(b)                # [1, 2, 3, 4, 5]

因为 map 回传的是一个可迭代对象，所以也可以将其赋值给变数，下方的例子，使用 map 将一个字串的串列内容，分别赋值给 a 和 b 两个变数。

t = ['12', '34']
a, b = map(int, t)
print(a)    # 12
print(b)    # 34

filter(function, iter)

filter() 可以使用指定的函数，依序判断可迭代对象的每个项目，将判断结果为 Ture 的对象集合成为一个全新的对象，下方的程序使用了同样效果的具名函数 a 和匿名函数 lambda，判断 [1,2,3,4,5] 串列里的每个项目，如果数值大于 2 就取出成为新对象，最后转换成串列和 tuple。

def a(x):
  return x>2
b = filter(a, [1,2,3,4,5])
c = filter(lambda x: x>2, [1,2,3,4,5])

print(list(b))    # [3, 4, 5]
print(tuple(c))   # (3, 4, 5)

sorted(x, key=None, reverse=False)

sorted 可以将可迭代对象进行排序，并产生一个全新的对象。

a = [1,5,3,4,2]
b = sorted(a)
c = sorted(a, reverse=True)

print(list(b))   # [1, 2, 3, 4, 5]
print(list(c))   # [5, 4, 3, 2, 1]

下方程序的 a 是一个二维的串列，使用 key 来让排序以第二个项目做为依据，范例中使用具名函数 test 和 lambda 函数，都是一样的效果 ( 参考：匿名函数 lambda )。

a = [[1,8],[2,1],[5,2],[3,5],[9,3]]
b = sorted(a, key=lambda x: x[1])

def test(x):
  return x[1]

c = sorted(a, key=test)

print(list(b))   # [[2, 1], [5, 2], [9, 3], [3, 5], [1, 8]]
print(list(c))   # [[2, 1], [5, 2], [9, 3], [3, 5], [1, 8]]

reversed(x)

reversed() 可以将有顺序性的对象 ( 字串、串列和 tuple ) 内容反转，产生一个全新的对象。

a = [1,2,3,4,5]
b = (1,2,3,4,5)
c = '12345'

print(list(reversed(a)))   # [5, 4, 3, 2, 1]
print(list(reversed(b)))   # [5, 4, 3, 2, 1]
print(list(reversed(c)))   # ['5', '4', '3', '2', '1']

all(x)

all() 可以判断一个可迭代对象里，是否不包含 False 相关的元素 ( 只要是 0、空白、False 都属于 False 元素 )，如果不包含或“空对象”就会回传 True，如果包含就会回传 False。

a = [1,2,3,4,5]
b = [0,1,2,3,4,5]
c = ['x','y','z','']
d = []

print(all(a))    # True
print(all(b))    # False
print(all(c))    # False
print(all(d))    # True

any(x)

any() 可以判断一个可迭代对象里，是否包含了 True 相关的元素 ( 只要不是 0、空白、False 都属于 True 元素 )，如果包含就会回传 True，反之不包含就会回传 False，此外，如果是“空”的对象，会回传 False。

a = [1,2,3,4,5]
b = [0,1,2,3,4,5]
c = ['x','y','z','']
d = []

print(any(a))    # True
print(any(b))    # True
print(any(c))    # True
print(any(d))    # False

slice(start, stop, step)

slice(start, stop, step) 可以“定义切片范围”，当指定的可迭代对象套用范围后，就会取出范围内的项目，变成新的对象。

a = slice(2,6)
b = slice(2,6,2)
c = [1,2,3,4,5,6,7,8,9]

d = c[a]
e = c[b]
print(d)      # [3, 4, 5, 6]
print(e)      # [3, 5]

zip()

zip() 可以将指定的可迭代对象，打包变成一个新的对象，新对象的长度与“最短”的一致，下方的例子将 a、b、c 三个列表打包，最后使用 list() 转换成串列。

a = [1,2,3,4]
b = [5,6,7]
c = [8,9]
d = zip(a, b, c)
print(list(d))    # [(1, 5, 8), (2, 6, 9)]

意见反馈