Python3解释器内置了很多函数，可以随时调用它们，内置函数简介如下表，直接点击函数名可直达详细用法。

1、python内置函数表

下面详细介绍个人感觉比较好用的内置函数：

2、好用的内置函数

• enumerate

语法：enumerate(sequence, start=0)返回每个序列对象中元素的索引值和元素组成的元组。索引值默认从0开始，可以自定义索引开始号（-1，1等都可以）。

my_list = ['apple', 'banana', 'grapes', 'pear', 'apple'] 
for i in enumerate(my_list):#默认start从0开始
    print(i)#i为一个元组

(0, 'apple')

(1, 'banana')

(2, 'grapes')

(3, 'pear')

(4, 'apple')

my_list = ['apple', 'banana', 'grapes', 'pear', 'apple'] 
for i in enumerate(my_list,1):#设置start为1
    print(i)

(1, 'apple')

(2, 'banana')

(3, 'grapes')

(4, 'pear')

(5, 'apple')

• filter

语法：filter(function, iterable)过滤iterable对象中的元素，返回一个由所有符合要求（function判断后为True）的元素所构成的新可迭代对象。

filter_numbers = filter(lambda x: x < 0, range(-6, 6))
#range(-6, 6)中元素经过lambda x: x < 0判断为True的返回。
list(filter_numbers)#filter_numbers为一个迭代对象，加list转换为列表。

[-6, -5, -4, -3, -2, -1]

• map

语法：map(function, iterable, ...)将function运用于iterable中每个元素，收集结果输出为一个新的iterable对象。匿名函数(lambdas)经常配合map函数一起使用。

items = [1, 2, 3, 4, 5]
list(map(lambda x: x**2, items))#lambda x: x**2作用于items中每个元素

[1, 4, 9, 16, 25]

list(map(lambda x, y: x + y, range(-2, 2), range(1, 5)))#传入两个iterable对象range(-2, 2), range(1, 5)

[-1, 1, 3, 5]

• print

语法：print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)sep, end, file 和 flush 如果存在，必须以关键字参数的形式给出。

*objects，每一次要输出的多个对象，每个对象之间使用,分割；
sep，定义输出时，每个对象之间的分割符，默认为一个空格；
end，每一次输出多个对象后末尾结束符号，默认为换行符；
file，要写入的对象文件，默认为 sys.stdout
flush，输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。#没明白flush作用

with open("./new1.txt","w") as f:#写入模式打开文件new1.txt
    print("haha","crycry",sep="@@",end="!",file=f,flush=True)#设置分隔符为@@，末尾符号为，输出文件为new1.txt

• range

range返回一个iterable对象。常运用于for循环中。语法：range(start,stop,step)，start,stop,step只能为整数。

start，计数开始处，默认为0开始；
stop，计数结束处，不包含stop；
step，步长，隔几个数计数一次。

In [3]: list(range(5))#默认start为0忽略
Out[3]: [0, 1, 2, 3, 4]

In [4]: list(range(0,5))#默认步长为1忽略
Out[4]: [0, 1, 2, 3, 4]

In [13]: list(range(0,5,1))#步长为1
Out[13]: [0, 1, 2, 3, 4]

In [12]: list(range(-5,-1))#步长为负
Out[12]: [-5, -4, -3, -2]

• round

语法：round(float,n)，可粗放的理解为取float对象的四舍五入值。

In [22]: round(1.55)#默认四舍五入取整数
Out[22]: 2

In [23]: round(1.55,1)
Out[23]: 1.6

In [24]: round(0.5,1)
Out[24]: 0.5

In [25]: round(0.5)#尽然为0，而不是数学中的1
Out[25]: 0


In [26]: round(2.675,2)#这个例子更开脑洞，尽然不会返回2.68，跟浮点数的精度有关。
Out[26]: 2.67

In [27]: print('{:.20f}'.format(2.675))#康康2.675精度为20时输出的是个什么鬼
2.67499999999999982236#这就可以理解为什么不是2.68了

python实现数学中的四舍五入

可以自己造个轮子，找了个轮子：https://www.cnblogs.com/kaituorensheng/p/12559825.html

def new_round(_float, _len):
    """
    Parameters
    ----------
    _float: float
    _len: int, 指定四舍五入需要保留的小数点后几位数为_len
     
    Returns
    -------
    type ==> float, 返回四舍五入后的值
    """
    if isinstance(_float, float):
        if str(_float)[::-1].find('.') <= _len:
            return(_float)
        if str(_float)[-1] == '5':
            return(round(float(str(_float)[:-1]+'6'), _len))
        else:
            return(round(_float, _len))
    else:
        return(round(_float, _len))
new_round(2.675,2)

2.68

• zip

语法：zip(*iterables)，将多个iterable对象元素从左到右一一对应拆分为元组，然后再组成一个iterable对象。

list1 = range(1,5,1)
list2 = list("abcd")
list3 = range(1,3)
list(zip(list1,list2))

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

list(zip(list1,list3))#iterable对象不一致时，取短迭代对象的长度

[(1, 1), (2, 2)]

dict(zip(list1,list2))#zip常用来生成字典

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}