python 内置函数

查看内置函数：

>>> dir(__builtins__)

min(arg1, arg2, *args, *[, key=func])函数：函数至少传入两个参数，但是有只传入一个参数的例外，此时参数必须为可迭代对象，返回的是可迭代对象中的最小元素。

>>> min((11,23,32))               #放入可迭代对象元组
11
>>> min([5,4,6])                  #放入可迭代对象列表
4
>>> min(8,9,12)                   #直接放入数字进行比较
8
>>> min('k','b','c')             #直接放入字母进行比较
'b'
>>> min(9)                        #最少放一个参数（除可迭代参数外）
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    min(9)
TypeError: 'int' object is not iterable
>>> 

max(arg1, arg2, *args, *[, key=func]函数：返回最大值。

>>> max(3,2,8)               #比较数字
8
>>> max((7,5,6))            #比较可迭代元素，元组
7
>>> max([9,8,18])           #比较可迭代元素，列表
18
>>> max('b','k','c')            #比较字母
'k'
>>> 

sorted(iterable, /, *, key=None, reverse=False)函数：iterable是可迭代对象；key主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse是排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>> sorted([5,1,8,6,12])             #对列表里面的元素进行排序
[1, 5, 6, 8, 12]
>>> sorted(['5s','a1s','1','321','grsg'],key=len)  #按照元素的字符长短进行排序。
['1', '5s', 'a1s', '321', 'grsg']
>>> sorted(['5s','a1s','1','321','grsg'],key=len,reverse=True) #添加了参数reverse=True，从大到小排序
['grsg', 'a1s', '321', '5s', '1']
>>> 

reversed(sequence)函数：反转一个序列对象，将其元素从后向前颠倒构建成一个新的迭代器。

>>> a = reversed([3,6,78,1,2,'a','b','c'])                #反转这个列表
>>> list(a)                                               #需要使用list函数来查看
['c', 'b', 'a', 2, 1, 78, 6, 3]

sum(iterable, start=0, /)函数：对系列进行求和计算。

>>> sum((1,2,3))           #对元组里面的数求和
6
>>> sum((1,2,3),10)       #对元组里面的数求和，从10开始加：10+1+2+3
16
>>> sum([2,4,6])            #对列表里面的数求和
12
>>> sum([2,4,6],10)        #对列表里面的数求和，从10开始加：10+2+4+6
22
>>> 

进制转换函数：

>>> bin(5)             #转换为二进制
'0b101'
>>> oct(16)            #转换为八进制
'0o20'
>>> hex(15)            #转换为十六进制
'0xf'
>>> ord('a')           #将字符转化为对应的ASCII码值
97
>>> ord('A'65
>>> chr(65)             #将ASCII码值转化为对应的字符
'A'
>>> 

enumerate(iterable[, start])函数：在字典上进行枚举、列举，对于一个可迭代的(iterable)/可遍历的对象，enumerate将其组成一个索引序列，利用它可以同时获得索引和值。enumerate多用于for循环中得到计数。

>>> enumerate(['a','b','c'])             #枚举对象，返回函数体
<enumerate object at 0x000001F7C5877C60>
>>> list(enumerate(['a','b','c']))       #使用list()查看结果，返回有索引的参数
[(0, 'a'), (1, 'b'), (2, 'c')]
>>> list(enumerate(['a','b','c'],6))     #后边添加参数6，就是索引以6开始
[(6, 'a'), (7, 'b'), (8, 'c')]
>>> dict(enumerate(['a','b','c']))       #使用dict()查看结果，返回有索引的参数
{0: 'a', 1: 'b', 2: 'c'}
>>> list(enumerate(('a','b','c'),6))     #可迭代对象换成了元组，索引也从6开始
[(6, 'a'), (7, 'b'), (8, 'c')]
>>> dict(enumerate({'a','b','c'},8))    #可迭代对象换成了集合，索引也从8开始，集合是没有索引的，所以返回一个假索引
{8: 'a', 9: 'b', 10: 'c'}
>>> 

filter(function or None, iterable)函数：函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

>>> filter(None,[1,2,3])           #返回函数体
<filter object at 0x000001F7C588CCC0>
>>> list(filter(None,[1,2,3]))    #因为需要两个参数，所以必须要填写参数None
[1, 2, 3]
>>> def test(a):                    #添加一条简单的比较大小的函数
    return a>1

>>> list(filter(test,[1,2,3]))    #使用创建好的函数
[2, 3]
>>> list(filter(lambda x:x>1,[1,2,3]))   #直接使用内置lambda函数
[2, 3]
>>> 

map(func, *iterables)函数：以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

>>> map(None,[1,2,3,4,5])      #返回一个函数体
<map object at 0x000001F7C588CD68>
>>> list(map(lambda x:x>3,[1,2,3,4,5]))   #每个元素都会调用函数，每次返回函数的结果
[False, False, False, True, True]
>>> list(map(lambda x:x+1,[1,2,3,4,5]))    #每个元素都会调用函数，每次返回函数的结果
[2, 3, 4, 5, 6]
>>> list(map(str,[1,2,3,4,5]))               #*iterables，这里的*号就是解包的作用，这里再func部分放了str，返回的都是字符串

['1', '2', '3', '4', '5']

zip(iter1 [,iter2 [...]])函数：将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

>>> zip([1,2,3])           #返回函数体
<zip object at 0x000001F7C5820F88>
>>> list(zip([1,2,3]))    #使用list(）查看
[(1,), (2,), (3,)]
>>> list(zip([1,2,3],['a','b','c']))  #配对
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> list(zip([1,2,3],['a','b','c'],{'long','xiao','d'}))
[(1, 'a', 'xiao'), (2, 'b', 'long'), (3, 'c', 'd')]

>>> a = [1,2,3]
>>> b = ['a','b','c']
>>> test = zip(a,b)     #使用变量进行配对
>>> list(test)
[(1, 'a'), (2, 'b'), (3, 'c')]