Python教程 - 内置的迭代对象操作函数

这篇文章会介绍了Python语言中用于迭代对象的内置函数，熟悉这些函数后，就能够轻松掌握迭代对象的转换和操作。

list(x)

list(x)  可以创建空列表，或将“字符串、元组、字典或集合”转换成列表。

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

dict(x)

dict(x) 可以创建空字典，或将“带有键与值、两个值的二维列表或元组、双字符的字符串串列或元组”转换成字典。

a = dict(name='oxxo', age=18, eat=['apple','banana'])
b = dict([['x','100'],['y','200'],['z','300']])
c = dict(['ab','cd','ef'])
print(a)    # {'name': 'oxxo', 'age': 18, 'eat': ['apple', 'banana']}
print(b)    # {'x': '100', 'y': '200', 'z': '300'}
print(c)    # {'a': 'b', 'c': 'd', 'e': 'f'}

set(x)

set(x) 可以创建空集合，或将“列表、元组、字符串或字典”转换成集合。

a = set()
b = set([1,2,3,4,5,1,2,3,4,5])
c = set({'x':1,'y':2,'z':3})
d = set('hello')
print(a)   # set()
print(b)   # {1, 2, 3, 4, 5}  只留下不重复的部分
print(c)   # {'x', 'y', 'z'}  如果是字典，只保留键
print(d)   # {'l', 'o', 'h', 'e'}  只留下不重复的部分

frozenset(x)

frozenset(x) 可以创建一个“不可变”的集合，创建方式和set()完全相同（frozenset字面意思就是冻结的set）。

a = frozenset()
b = frozenset([1,2,3,4,5,1,2,3,4,5])
c = frozenset({'x':1,'y':2,'z':3})
d = frozenset('hello')
print(a)   # frozenset()
print(b)   # frozenset({1, 2, 3, 4, 5})
print(c)   # frozenset({'x', 'z', 'y'})
print(d)   # frozenset({'e', 'h', 'l', 'o'})

tuple(x)

tuple(x) 可以创建空元组，或将“列表、集合、字符串或字典”转换成元组。

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

enumerate(x, start=y)

enumerate() 可以将“列表、集合、元组、字典”创建为可迭代并附加索引值的enumerate对象，start的数值代表索引值开始的数字，默认从0开始（不填写默认0）。

a = enumerate(['a','b','c'])
b = enumerate(('a','b','c'))
c = enumerate({'a','b','c'})
d = enumerate({'a':1,'b':2,'c':3}, start=2)
print(a)          # <enumerate object at 0x7f8de8677050>
print(list(a))    # [(0, 'a'), (1, 'b'), (2, 'c')]
print(list(b))    # [(0, 'a'), (1, 'b'), (2, 'c')]
print(list(c))    # [(0, 'a'), (1, 'b'), (2, 'c')]
print(list(d))    # [(2, 'a'), (3, 'b'), (4, 'c')] 设定 start=2，第一项的索引值变成 2

iter(x)

iter() 可以将“列表、集合、元组、字典”创建为可迭代的iter对象，下方程序可以看到不同形态的iter对象。

a = iter([1,2,3])
b = iter((1,2,3))
c = iter({'a','b','c'})
d = iter({'a':1,'b':2,'c':3})
print(a)    # <listiterator object at 0x7f8de866e450>
print(b)    # <tupleiterator object at 0x7f8de866ec90>
print(c)    # <setiterator object at 0x7f8de86c0910>
print(d)    # <dictkeyiterator object at 0x7f8de86ec7d0>

next(x)

next() 通常和iter()与enumerate()搭配，可以将enumerate和iter对象的内容“依次取出并移除”，每执行一次就取出一个，直到完全取出为止。

a = enumerate(['a','b','c'])
print(next(a))    # (0, 'a')
print(next(a))    # (1, 'b')
print(next(a))    # (2, 'c')
print(list(a))    # []    # 全部取出后只剩下空列表

b = iter(['a','b','c'])
print(next(b))    # a
print(next(b))    # b
print(next(b))    # c
print(list(b))    # []    # 全部取出后只剩下空列表

range(start, stop, step)

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

参数	说明
start	起始数字
stop	结束数字 - 1
step	步长，可不填，默认 1

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) 可以获取序列、字典、集合、元组的长度，也可以获取字符串的长度。

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，最后转换成列表和元组。

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() 可以使用指定的函数，依次判断可迭代对象的每个项，将判断结果为True的对象集合成一个全新的对象，下面程序使用了同样效果的具名函数a和匿名函数lambda，判断 [1,2,3,4,5] 序列里的每个项，如果数值大于2就取出成为新对象，最后转换成列表和元组。

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 可以将可迭代对象进行排序，并产生一个全新的对象。

参数	说明
x	可迭代的对象，例如列表、字符串、元组、字典、集合
key	可不填，默认由第一个项判断（如果有多层内容），也可指定判断的项
reverse	可不填，默认False从小到大，设置True表示从大到小

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函数，都是一样的效果。

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() 可以将有顺序性的对象（字符串、列表和元组）内容反转，产生一个全新的对象。

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) 可以「定义切片范围」，当指定的可迭代对象套用范围后，就会取出范围内的项，变成新的对象。

参数	说明
start	起始数字
stop	结束数字 - 1
step	可不填，数字间隔，预设 1

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