1-Python - 内置函数
before
之前的学习中，或多或少的介绍并使用过Python的内置函数了，并感受到这些函数带来的方便之处。本节就来学习Python为我们提供的这些实用的"高阶工具"，其中包括内置函数，或者经过版本更新而移动到了某个模块下的函数。
让人又爱又恨的lambda
之前讲嵌套作用域的时候曾说到lambda函数，现在就来具体说说这个lambda。
Python除了使用def语句创建函数之外，还提供另一种创建函数的形式，那就是lambda表达式。lambda表达式是一个用lambda关键字创建的功能简单的小型函数对象，一般只是把函数结果赋值给一个变量，通过这个变量加括号执行lambda并获取结果，而不是如def语句将函数赋值给变量。所以称lambda函数为匿名函数，匿名是说在内存空间中只有函数的内存地址，但这个函数是没有函数名的，所以叫做匿名函数。
lambda表达式的一般语法：
lambda arg1, arg2 ... argn : expression
声明 参数 表达式
如果需要用函数实现简单的功能，lambda表达式就可以替代def语句形式：
def foo(x):
return x ** 2
print(foo(2)) # 4
l = lambda x: x ** 2
print(l(3)) # 9
print((lambda x: x ** 2)(3)) # 9
上例第4行lambda表达式执行结果赋值给变量l，通过l来调用这个匿名函数，第6行和第4行是等价的。从代码简洁程度来看，lambda表达式更优雅。
lambda表达式也支持多个参数，支持简单的if/else语句：
l= lambda x, y, z: x if x < y < z else 'error'
print(l(2, 3, 4)) # 2
print(l(5, 4, 3)) # error
嵌套作用域的最大受益者是lambda表达式！还记得之前讲嵌套作用域的例子吗？
x = 1
def foo(x):
def bar(y):
return x < y
return bar
f = foo(10) # 基准值x:10
print(f) # <function foo.<locals>.bar at 0x00C56738>
print(f(5)) # False
print(f(20)) # True
上例用lambda表达式可以写成：
def foo(x):
return (lambda y: x < y)
f = foo(10) # 基准值 x:10
print(f) # <function foo.<locals>.<lambda> at 0x02A86738>
print(f(5)) # False
print(f(20)) # True
上例中，首先为foo函数的x参数传递形参10，而foo函数内的lambda表达式需要x、y两个参数，我们在调用这个lambda表达式时，分别传递了参数y。那么x就去自己的作用域找，没找到，就去嵌套作用域找，找到了之前传的参数10，然后计算(比较两个数的大小)并返回结果。
我们可以继续使用lambda表达式优化上面的示例：
l = (lambda x: (lambda y: x < y))
print(l) # <function <lambda> at 0x00FA4B28>
l1 = l(10) # 基准值 x:10
print(l1) # <function <lambda>.<locals>.<lambda> at 0x00C26738>
print(l1(5)) # False
print(l1(20)) # True
上例，当print(l)时获取的是整个lambda表达式的执行结果对象，就是也就是一个内存地址。
当l1 = l(10)时，首先将10传递给lambda x的x，并在嵌套作用域内"记住"x；然后由于加括号是获取lambda表达式的执行结果，所以从执行结果对象中拿到执行结果，只是比较巧的是，这个结果也是一个lambda表达式，所以，l1拿到的是lambda y: x < y的执行结果对象；后续的l1(5)和l1(20)都是在让lambda y: x < y这个执行结果对象执行判断x和y的大小并返回比较结果。
上面的示例还可以优化！
print((lambda x: (lambda y: x < y))(10)(5)) # False
print((lambda x: (lambda y: x < y))(10)(20)) # True
上例的执行原理和之前的示例一样，只是少了一步赋值操作。
通过上面示例的不断优化，虽然代码也越来越简洁，但代码的可读性也在不断下降，也越来越变的晦涩难懂。
所以，不要为了"优雅"而"过度优化"！从而让原本简洁、优雅的lambda表达式，变得不讨人喜欢。
也通过上面的示例，让我们知道了初学者为啥对于lambda表达式是拒绝的，因为都会感觉特别难用！难理解！导致产生lambda能实现的功能基本都能由def语句完成，那么为何不用def来完成呢？这种思想，进而导致初学者谈lambda色变，渐渐的忘记使用Python为我们提供的的这些技巧性的"小工具"。
最后，我们总结一下lambda表达式特点。
-
lambda是表达式，而不同于def语句。
-
lambda执行的功能有限，是为了编写更简单的函数而设计的，def通常来执行更大的任务。
-
保持lambda的简单优雅，一个易懂的表达式要比看似神秘且复杂的语句更显友好。
-
lambda表达式在简单功能上跟def语句一样，包括对作用域的查找，同样遵循LEGB原则。
映射函数：map
map函数用来将迭代器内的每个元素都执行func函数，并将结果返回，它需要两个参数：
map(func, *iterables)
# func: 可执行的函数
# iterables：迭代器，可迭代的序列
来个示例：
l = []
def f1(x):
return x ** 2
for i in range(1, 5):
l.append(f1(i))
print(l) # [1, 4, 9, 16]
上面的代码很好理解，for循环将每次拿到的i通过f1函数进行求平方操作，然后添加到一个列表中。
代码简单易理解，我们用map优化它：
from collections import Iterable
def f2(x):
return x ** 2
map_obj = map(f2, range(1, 5))
print(map_obj) # <map object at 0x000001FBA0311668>
print(isinstance(map_obj, Iterable)) # True
print(list(map_obj)) # [1, 4, 9, 16]
心里牢记map的参数！map将第二个参数中的每个值都交给第一个值去计算，并将结果收集，然后返回一个map对象(其本质是个可迭代对象)，想要取数据需要显式的通过list强转或for循环取值。
这里补充一点，Python3对于这些结果集可能比较大，如果直接返回可能会带来一些意外情况，所以对这类对象做了优化，如range、map，只给你返回个对象，想要取值自己手动来取，而Python2中则直接将结果集返回：
Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:22:17) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> map(lambda x: x ** 2, range(1, 5))
[1, 4, 9, 16]
>>> range(1, 5)
[1, 2, 3, 4]
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> map(lambda x: x ** 2, range(1, 5))
<map object at 0x0000018FB9892748>
>>> range(1, 5)
range(1, 5)
补充完毕，言归正传，我们可以继续优化上面的map示例：
map_obj = map(lambda x: x ** 2, range(1, 5))
print(map_obj) # <map object at 0x0000020C4FA4A828>
# list(map_obj) # 除了 lsit 显式转换得到结果，也可以for循环
for i in map_obj:
print(i)
上例使用lambda和函数是等价的，只不过lambda搭配map确实比较优雅！
map也支持多个序列同时执行函数：
print(list(map(lambda x, y: x ** y, [2, 3, 4], [3, 2, 2]))) # [8, 9, 16]
上例，map函数将两个列表元素根据索引——映射为key:value的格式传递给lambda的x，y参数，计算后返回结果。
但下面这种情况也是允许存在的：
print(list(map(lambda x, y: x ** y, [2, 3, 4], [3]))) # [8]
上例，map函数将两个列表元素根据索引——映射为key:value的格式时，无法映射的将会被丢弃。
再来介绍map的另一种用法，就是可以在join时使用：
# join时，如果可迭代对象内的每个元素是整数，join会报错
# print(' '.join([1, 2, 3, 4])) # TypeError: sequence item 0: expected str instance, int found
# 我们可以自己处理
print(' '.join([str(i) for i in [1, 2, 3, 4]])) # 1 2 3 4
# 但不够优雅，来使用map来处理
print(' '.join(map(str, [1, 2, 3, 4]))) # 1 2 3 4
我们对map函数做个总结：
-
在Python 2中，map函数返回的是列表。
-
在Python 3中，map函数返回的是可迭代的map对象。
-
map函数将多个序列内的元素以映射的方式交给函数执行，且无法映射的将会被丢弃。
拉链函数：zip
zip函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。
如果各个可迭代对象的元素个数不一致，则返回的对象长度与最短的可迭代对象相同。
基本语法：
zip(iterables,iterables2,...iterablesn)
# iterables：可迭代对象
示例：
from collections import Iterable
l1 = [1, 2, 3, 4]
l2 = ['a', 'b', 'c', 'd']
zip_obj = zip(l1, l2)
print(zip_obj) # <zip object at 0x000002A308D1D308>
print(isinstance(zip_obj, Iterable)) # True
print(list(zip_obj)) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
# list 显式的获取了 zip_obj 中的值后，zip_obj 这个可迭代对象就为空了
zip_obj = zip(l1, l2)
print(dict(zip_obj)) # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
zip将两个可迭代对象中的元素按照索引进行映射为元组，如果显式转换为列表，结果就是列表套元组的形式；如果显式转换为字典，则结果就是字典。
如果zip在映射时，对于哪些无法映射的元素将会被丢弃：
l1 = [1, 2, 3, 4]
l2 = ['a', 'b']
zip_obj = zip(l1, l2)
print(list(zip_obj)) # [(1, 'a'), (2, 'b')]
也可以映射多个可迭代对象：
title = ["股票名称", "股票代码", "最新价"]
value1 = ["顺威股份", 2676, 3.69]
value2 = ["嘉泽新能", 601619, 4.91]
value3 = ["东方园林", 2310, 5.57]
print(list(zip(title, value1)))
print(list(zip(title, value1, value2)))
print(list(zip(title, value1, value2, value3)))
"""
[('股票名称', '顺威股份'), ('股票代码', 2676), ('最新价', 3.69)]
[('股票名称', '顺威股份', '嘉泽新能'), ('股票代码', 2676, 601619), ('最新价', 3.69, 4.91)]
[('股票名称', '顺威股份', '嘉泽新能', '东方园林'), ('股票代码', 2676, 601619, 2310), ('最新价', 3.69, 4.91, 5.57)]
"""
除此之外，也可以对其他的数据类型进行映射：
title = ["股票名称", "股票代码", "最新价"]
value1 = ["顺威股份", 2676, 3.69]
value2 = ["嘉泽新能", 601619, 4.91]
value3 = ["东方园林", 2310, 5.57]
print(dict(zip(title, value1))) # {'股票名称': '顺威股份', '股票代码': 2676, '最新价': 3.69}
tmp_list = []
for value in [value1, value2, value3]:
tmp_list.append(dict(zip(title, value)))
print(tmp_list)
"""
[
{'股票名称': '顺威股份', '股票代码': 2676, '最新价': 3.69},
{'股票名称': '嘉泽新能', '股票代码': 601619, '最新价': 4.91},
{'股票名称': '东方园林', '股票代码': 2310, '最 新价': 5.57}
]
"""
过滤函数：filter
filter函数根据条件过滤序列，将符合条件的元素返回。
filter函数需要两个参数，其语法格式如下：
filter(func, *iterables)
func: 可执行的函数
iterables：可迭代对象，可迭代的序列
来个示例：
from collections import Iterator
f = filter(lambda x: x % 2 == 0, range(1, 6))
print(f) # <filter object at 0x000001A10B2FA240>
print(isinstance(f, Iterator)) # True
print(list(f)) # [2, 4]
def foo(x):
return x % 2 == 0
print(list(filter(foo, range(1, 6)))) # [2, 4]
上面示例中，filter会将可迭代对象中的每个元素都依次传递给可执行的函数来处理，并将处理结果返回filter对象(通过isinstance(f, Iterator)证明)，我们可以从这个filter对象中拿到想要的结果i，另外，上面lambda和foo函数是等价的。
再来看个示例：
print(list(filter(None, range(1, 6)))) # [1, 2, 3, 4, 5]
print(list(filter("", range(1, 6)))) # TypeError: 'str' object is not callable
上例，如果filer函数的第一个参数传递必须传递一个可调用的对象，否则报错！如果这个可调用的对象是None的话，会返回第二个参数(可迭代对象)的所有元素。
小结
-
在Python 2中，filter函数返回的是列表。
-
在Python 3中，filter函数返回的是可迭代对象。
-
filter函数中的第一个参数为None的话，则将为真的元素返回，如果返回的是不可调用对象的话，会报错。
累积函数：reduce
如果要对序列内的所有的元素的做加减乘除操作，那么现在利用reduce函数是个好办法。
注意：Python3中 reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：
from functools import reduce
reduce函数语法如下：
reduce(func, sequence, initializer)
func: function
sequence: 序列
initializer： 初始值，可选参数
示例：
from functools import reduce
def foo(x, y): # 两数相加
print(x, y)
"""
1 2
3 3
6 4
10 5
"""
return x + y
sum1 = reduce(foo, [1, 2, 3, 4, 5]) # 计算列表和：1+2+3+4+5
sum2 = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
print(sum1) # 15
print(sum2) # 15
上例中，其计算过程是首先传进去两个元素，并计算相加的结果，然后将得到的结果当成其中一个参数，与后续传递过来的参数进行相加，进行累积运算。
再来看initial参数：
from functools import reduce
def foo(x, y):
print(x, y)
"""
8 1
9 2
11 3
14 4
18 5
"""
return x + y
result = reduce(foo, [1, 2, 3, 4, 5], 8)
print(result) # 23
如上例，当有initializer参数时，它会被当成第一个参数参与累积过程。
如下示例，如果序列为空，则将initializer值返回。
from functools import reduce
def foo(x, y):
print(x, y)
return x + y
result = reduce(foo, [], 8)
print(result) # 8
当然，reduce函数不仅仅能进行加法累积，还能进行其他的累积过程：
from functools import reduce
print(reduce(lambda x, y: x + y, range(1, 6))) # 15
print(reduce(lambda x, y: x - y, range(1, 6))) # -13
print(reduce(lambda x, y: x * y, range(1, 6))) # 120
print(reduce(lambda x, y: x / y, range(1, 6))) # 120
其他内置函数
除了之前介绍的几个高阶函数，Python还提供了其他的内置函数。
下表展示了常用的内置函数：
| 函数 | 描述 |
|---|---|
| print(objects, sep=' ', end='\n', file=sys.stdout, flush=False) | 将对象输出到文本流中，以sep开始，以end结尾，file则指定输出位置，默认为控制台，flush为强制刷新。 |
| input(*args, **kwargs) | 从标准输入中的获取结果并字符串形式返回 |
| len(object) | 返回容器内的元素个数 |
| max(iterable，key=func)** | 返回iterable中的最大项或有两个参数或更多参数中的最大项，key则为定制的排序函数 |
| min(iterable,key=func) | 返回iterable中的最小项或有两个参数或更多参数中的最小项,key则为定制的排序函数 |
| range(start, stop, [step]) | 返回指定范围的可迭代对象 |
| sum(iterable,[start]) | 返回iterable内元素(int类型)之和，start参数则为额外参与计算的数值。 |
| id(object) | 返回对象的内存地址 |
| help([object]) | 返回解释器的帮助信息，如指定对象，则返回该对象的帮助信息 |
| abs() | 返回参数的绝对值 |
| all(*args, **kwargs) | 判断可迭代对象内的元素bool值为True则返回True，否则返回False |
| any(*args, **kwargs) | 如果可迭代对象内的元素bool值只要有一个为True则返回True，否则返回False |
| dir() | 如果无参，则返回当前作用域下的变量名、属性，如果指定参数，则返回执行名称下的变量列表，包括参数的属性 |
| ascii(*args, **kwargs) | 返回参数的字符串，如果参数非ASCII字符则用repr函数编码的字符 |
| bin(*args, **kwargs) | 返回整数的二进制表示形式 |
| chr(*args, **kwargs) | 返回整数对应的字符 |
| int(*args, **kwargs) | 将2、8、16进制数转为10进制表示 |
| ord(*args, **kwargs) | 返回字符对应的整数 |
| hex(*args, **kwargs) | 返回整数的16进制表示 |
| oct(*args, **kwargs) | 返回整数的8进制表示 |
| bin(*args, **kwargs) | 返回整数的2进制表示 |
| format(*args, **kwargs) | 格式化字符串 |
| locals() | 一般用在局部作用域内，以字典的形式返回局部变量。 |
| globals() | 一般用在全局作用域内，以字典的形式返回全局变量。 |
| repr(object) | 返回对象的字符串形式 |
| sorted(iterable,key=None, reverse=False) | 默认以升序的方式将以新列表的方式返回，reverse参数为True的话，则以降序的方式返回，key参数则可以定制排序方式。 |
| round(number, ndigits=None) | 以整数形式返回浮点数的四舍五入值，如果执行ndigits参数，则保留小数点的位数。 |
| pow(x, y,[z]) | 如果只有x、y两个参数，则返回x**y的结果，如果指定z参数，则是对x**y的结果模运算。相当于x**y%z |
| enumerate(iterable, start=0) | 遍历可迭代对象的序列，并同列出数据和数据的下标 |
上表中，以加粗的函数用的较多。
max/min
print(max(['b', 'c', 'e'])) # e
print(min(['b', 'c', 'e'])) # b
print(max([1, 'b', 3, 5, 'd'])) # TypeError: '>' not supported between instances of 'str' and 'int'
main/min返回序列的最大值和最小值，但要求是序列中的数据类型必须一致，不然无法比较。
range
from collections import Iterable
res = range(3)
print(res) # range(0, 3)
print(isinstance(res, Iterable)) # True
print(list(res)) # [0, 1, 2]
在Python3中，range返回的是一个可迭代对象，需要显式的调用其中的元素。
chr/ord
print(chr(97)) # a
print(ord('a')) # 97
print(chr(1000)) # Ϩ
print(chr(1114111)) #
print(chr(1114112)) # ValueError: chr() arg not in range(0x110000)
如上例，一般，我们通常使用chr和ord函数查看range(256)范围内整数对应的字符。但chr函数也能返回基于Unicode16位编码方式的整数对应的字符，它的范围是0~1114111，超过此范围就报错。注意，Unicode16位编码方式兼容ASCII编码。
来个示例：
print(ord('张'), chr(24352)) # 24352 张
print(chr(1114111)) #
print(chr(1114112)) # 报错：ValueError: chr() arg not in range(0x110000)
进制转换
print("10-->2", bin(20)) # 0b10100
print("10-->8", oct(20)) # 0o24
print("10-->16", hex(20)) # 0x14
上例，bin函数返回十进制的二进制表示；oct函数返回十进制的八进制表示；hex函数返回十进制的二进制。
那么，如果八进制转十六进制，或者十六进制转二进制该怎么办？
print('2-->8: ', oct(int('0b1010', 2))) # 2-10-8
print('2-->10:', int('0b1010', 2)) # 2-10
print('2-->16:', hex(int('0b1010', 2))) # 2-10-16
print('8-->2:', bin(int('0o12', 8))) # 8-10-2
print('8-->10:', int('0o12', 8)) # 8-10
print('8-->16:', hex(int('0o12', 8))) # 8-10-16
print('10-->2', bin(10)) # 10-2
print('10-->8', oct(10)) # 10-2
print('10-->16', hex(10)) # 10-16
print('16-->2:', bin(int('0xa', 16))) # 16-10-2
print('16-->8:', oct(int('0xa', 16))) # 16-10-8
print('16-->10:', int('0xa', 16)) # 16-10
"""
2-->8: 0o12
2-->10: 10
2-->16: 0xa
8-->2: 0b1010
8-->10: 10
8-->16: 0xa
10-->2 0b1010
10-->8 0o12
10-->16 0xa
16-->2: 0b1010
16-->8: 0o12
16-->10: 10
"""
如上例所示，10进制转别的进制直接使用对应的函数。而其他的进制转换都要先将本进制转为10进制，再通过各自进制的方法转换这个10进制数字就可以了。而需要注意的是int函数在将别的进制转换为10进制时，第一个参数要以字符串的形式传参。
dir
def foo():
pass
print(dir())
print(dir(foo))
"""
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'foo']
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
"""
如上例所示，当dir函数不指定参数的时候，返回当前作用域的变量及属性，而当指定参数的时候，则返回指定参数的属性。
globals/locals
def foo():
x, y = 2, 3
print(locals())
print(globals())
foo()
print(locals())
print(globals())
"""
{'y': 3, 'x': 2}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027355A6B518>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/tmp/test.py', '__cached__': None, 'foo': <function foo at 0x0000027355A11EA0>}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027355A6B518>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/tmp/test.py', '__cached__': None, 'foo': <function foo at 0x0000027355A11EA0>}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027355A6B518>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/tmp/test.py', '__cached__': None, 'foo': <function foo at 0x0000027355A11EA0>}
"""
如上例所示，locals函数一般用于局部作用域内，以字典的形式返回局部变量。而globals无论在局部还是全局，都以字典的形式返回当前位置的全局变量。如果locals用在全局，则跟globals返回的内容一致。
repr/str
print(repr('abc')) # 'abc'
print(str('abc')) # abc
如上例，repr函数将对象返回字符串的形式，类似str函数，但是repr返回的对象更友好与解释器(更加规范，返回的更多信息，倾向于解释器)，而str配合print返回的结果对用户更友好(提高用户的可读性，倾向于用户)。
sorted/list.sort
l1 = [2, 3, 1, 5, 4, 9]
print(id(l1)) # 2186440903304
s1 = sorted(l1) # 默认是升序排序
s2 = sorted(l1, reverse=True) # reverse为True时，降序排序
print(s1, id(s1)) # [1, 2, 3, 4, 5, 9] 2186440801672
print(s2, id(s2)) # [9, 5, 4, 3, 2, 1] 2186439007176
l2 = [4, 8, 3, 5, 7, 6]
print(id(l2)) # 2046115172296
l2.sort()
print(l2, id(l2)) # [3, 4, 5, 6, 7, 8] 2046115172296
l2.sort(reverse=True) # reverse为True时，降序排序
print(l2, id(l2)) # [8, 7, 6, 5, 4, 3] 2046115172296
如上例，sorted函数将可迭代对象内的元素以升序的形式排序，并将排序结果以一个新列表的形式返回，相当于完全拷贝了一份原列表，然后对副本进行排序。
而sort只是列表自带的排序方法，并且是原地排序，即在原列表上进行排序。
这两个排序各有优势，sorted比list.sort更为强大，适用范围更广泛。在实际应用中，如果需要保留原列表，则采用sorted函数排序，否则可以选择list.sort方法，因为list.sort无需复制原列表，在效率和内存占用上更有优势。
round
from math import pi
print(pi) # 3.141592653589793
print(round(pi)) # 3
print(round(pi, 3)) # 3.142
如上例所示，round函数默认返回浮点数的四舍五入后的整数值，而指定ndigits参数，则返回四舍五入后的浮点类型的数值，小数位的位数取决于ndigits的参数值。
enumerate
for number, value in enumerate(range(6)): # # 传递一个可迭代对象，start参数默认为0
print(number, "\t",value)
"""
number value
0 0
1 1
2 2
3 3
4 4
5 5
"""
for number, value in enumerate(range(6), start=10): # # 传递一个可迭代对象，start参数默认为0
print(number, "\t",value)
"""
number value
1 0
2 1
3 2
4 3
5 4
6 5
"""
如上例所示，enumerate(iterable, start=0)函数接收两个参数，iterable参数接收一个可迭代对象，而start参数则是指定在循环中，为每个元素设置序号的起始位置。start参数(默认为0)可以指定。一般较多的用在for循环中。
that's all
欢迎斧正，that's all
