常用内置函数¶

Python有很多内置函数可以非常方便的解决一些问题，本节给出其中三个在列表中使用较多的内置函数:

map()  
zip()  
enumerate()

map()函数可以将函数作用于可迭代对象中的每一个元素，返回一个可迭代对象。常用于将一个序列映射为另一种数据类型的序列。语法如下：

map(function, iterable, ...)

第一个参数是一个函数，如int,float,str等
第二个参数量是一个可迭代对象，如列表等示例如下所示：

s= ['1','2','3']
print(map(int,s))
# 输出一个可迭代对象 <map object at 0x000002700724EEB8>
print(list(map(int,s)))            # 用list()可将其转为列表输出 [1, 2, 3]
print(list(map(float,range(5))))   # 整数序列映射为浮点数序列并转为列表
# 输出[0.0, 1.0, 2.0, 3.0, 4.0]
print(list(map(str,range(5))))     # 整数序列映射为字符串序列并转为列表
# 输出['0', '1', '2', '3', '4']
print('+'.join(map(str,range(5)))) # 整数序列映射为字符串序列并用‘+’连接
# 输出 0+1+2+3+4
print(''.join(map(str,range(5)))) # 整数序列映射为字符串序列并用空字符串连接
# 输出 01234
m,n = map(int,input().split()) 
# 将在一行中输入的用空格分隔2个数据切分开，转为整型，分别赋值给m,n
print(pow(2,64))                  # 结果为数字18446744073709551616
print(str(pow(2,64)))             # 结果为字符串'18446744073709551616'
print(map(int,str(pow(2,64))))# 可迭代对象<map object at 0x000001A4A11DEEB8>
print(sum(map(int,str(pow(2,64))))) # 输出2的64次方结果每位上的数加和 88

<map object at 0x7fd53a932b50>
[1, 2, 3]
[0.0, 1.0, 2.0, 3.0, 4.0]
['0', '1', '2', '3', '4']
0+1+2+3+4
01234

zip函数可以组合多个可遍历对象，生成一个zip生成器，其语法为：

zip(iter1[, iter2 […]])

iter1、iter2…都是可遍历对象。
采用惰性求值的方式，可以按需要生成一系列元组数据，第i元组数据依次为每个可遍历对象的第i个元素组成的元组，直到所有可遍历对象中最短的元组最后一个元素组成的元组为止。
zip是生成器对象，需要查看其中的数据时，可以用list()函数将其转为列表。示例如下所示：

x = (1,2,3)
y = (4,5,6,8)
z = zip(x,y)   # 惰性求值，生成zip对象，可用list转为列表输出
print(list(z)) # [(1, 4), (2, 5), (3, 6)]
a = [1,2,3]  # 列表a最短，生成元组个数与a长度相同，其他列表中多余元素被丢弃
b = [11,22,33,44]
c = [111,222,333,444]
z = zip(a,b,c)  # 惰性求值，生成zip对象，可用list转为列表输出
print(list(z))  # [(1, 11, 111), (2, 22, 222), (3, 33, 333)]

[(1, 4), (2, 5), (3, 6)]
[(1, 11, 111), (2, 22, 222), (3, 33, 333)]

enumerate函数可以使用一个可遍历对象生成一个enumerate生成器，其语法为：

enumerate(iter[, start])

iter为可遍历对象，start表示序号的起始值。其采用惰性求值的方式，可以按需要生成一系列两个元素组成的元组数据，第一个元素是以start为起始的一个整数（默认start值为0），第二个元素则是iter可遍历对象的数据元素。
简单的说，就是生成一个新的可遍历序列，给原来iter的每个值对应的增添了一个序号数据，示例如下所示：

a = ['apple', 'banana', 'cherry']
E = enumerate(a)              # 生成enumerate对象
print(list(E))                # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]

for i in a:  ##序号,数据
    print(i)

[(0, 'apple'), (1, 'banana'), (2, 'cherry')]
apple
banana
cherry

可以看出，列表a中的所有数据元素都添加了一个序号，形成一个元组，最后构成了enumerate生成器，其也是惰性求值的方式生成数据。

练一练

实例5.4 蒙特卡洛方法计算圆周率

利用列表推导式和zip()函数，用蒙特卡洛方法计算圆周率。
分析：
random.random()可以生成一个[0.0, 1.0]之间的数，利用列表推导式可以生成一批数据。
利用zip()函数将两组这样的数合并成一组坐标。
再判断其是否落在圆内，根据落在圆内的点的数量与总数量的比值得到面积
再由面积公式便可计算出圆周率的值。

# 利用列表推导式和zip()函数，用蒙特卡洛方法计算圆周率
import random

N = 100000
lsx = [random.random() for i in range(N)]  # 列表推导式随机生成N个小数
lsy = [random.random() for i in range(N)]  # 列表推导式随机生成N个小数
# 用zip函数将两个列表中对应序号的数据组成N对坐标值，用list()将其转为列表
ls = list(zip(lsx,lsy))
count = 0
for item in ls:
    if item[0]**2+item[1]**2<=1: # 判断坐标点是否落在圆内
        count=count + 1          # 落在圆内的点数量增加 1
PI = 4 * count/N                 # 计算圆周率值
print('{:.6f}'.format(PI))       # 输出结果3.141880（每次运行结果可能不同）

6.2.8 常用内置函数.ipynb @master — view markup · raw · history · blame

常用内置函数¶