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
posted @ 2020-11-30 22:48  听雨危楼  阅读(566)  评论(0)  编辑  收藏  举报