python常用内置函数

map函数

map(函数，序列)

将单参数函数映射至序列中每个元素，返回结果列表（Python2.x）或map对象（python3.x）

内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。map是(有key和value组成)的遍历

>>> list(map(str, range(5)))                #把列表中元素转换为字符串

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

>>> def add5(v):                                #单参数函数     

return v+5

>>> list(map(add5, range(10)))          #把单参数函数映射到一个序列的所有元素

[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>> def add(x, y):                                            #可以接收2个参数的函数     

return x+y

>>> list(map(add, range(5), range(5,10)))      #把双参数函数映射到两个序列上

[5, 7, 9, 11, 13]

isinstance函数

isinstance(object,class-or-type-or-tuple)

测试对象是否属于指定类型是实例

内置函数type()和isinstance()可以判断数据类型。

>>> type([3])                                     #查看[3]的类型 <class 'list'>

>>> type({3}) in (list, tuple, dict)        #判断{3}是否为list,tuple或dict类型的实例

False

>>> isinstance(3, int)                         #判断3是否为int类型的实例

True

>>> isinstance(3j, (int, float, complex))   #判断3是否为int,float或complex类型

True

 eval函数

eval(s[,globals[,locals]])

计算字符串中表达式的值并返回

 sorted函数

sorted(列表[,cmp[,key[,reverse]]])

返回排序后的列表，python 3.x 中的sorted方法没有cmp参数

 reversed函数

reversed(列表或元组)

返回逆序后的迭代器对象

sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表

reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']

>>> sorted(x, key=lambda item: (len(item), item))  #先按长度排序，长度一样的正常排序

['b', 'd', 'ba', 'bc', 'aaaa']

>>> reversed(x)                        #逆序，返回reversed对象

<list_reverseiterator object at 0x0000000003089E48>

>>> list(reversed(x))                   #reversed对象是可迭代的

[5, 1, 9, 3, 8, 7, 10, 6, 0, 4, 2]

 max、min、sum函数

max(x)、min(x)、sum(x)

返回序列中的最大值、最小值或数值型序列中所有元素之和

max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。

内置函数max()和min()的key参数可以用来指定比较规则

>>> x = [’21’, ‘1234’, ‘9’]                                   #返回字符串中最大字母

>>> max(x)

'9'

>>> max(x, key=len)

'1234'

>>> max(x, key=int)

'1234'

 reduce函数

标准库functools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>> from functools import reduce

>>> seq = list(range(1, 10))

>>> reduce(lambda x, y: x+y, seq) 45

filter函数

内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。

像过滤器一样

>>> seq = ['foo', 'x41', '?!', '***']

>>> def func(x):                 

        return x.isalnum()                     #测试是否为字母或数字

>>> filter(func, seq)                                #返回filter对象

<filter object at 0x000000000305D898>

>>> list(filter(func, seq))                          #把filter对象转换为列表

['foo', 'x41']

 range函数

 range()是Python开发中非常常用的一个内置函数，语法格式为range([start,] end [, step] )。该函数返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。

>>> range(5)                          #start默认为0，step默认为1

range(0, 5)

>>> list(_)

[0, 1, 2, 3, 4]

>>> list(range(1, 10, 2))          #指定起始值和步长

[1, 3, 5, 7, 9]

>>> list(range(9, 0, -2))           #步长为负数时，start应比end大

[9, 7, 5, 3, 1]

 zip函数

zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如同拉拉链一样。

>>> list(zip('abcd', [1, 2, 3]))                  #压缩字符串和列表

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

>>> list(zip('123', 'abc', ',.!'))                  #压缩3个序列

[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]

>>> x = zip('abcd', '1234')

>>> list(x)

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

 

 ord() 用来返回单个字符的序数或Unicode码

chr() 用来返回某序数对应的字符

str() 直接将其任意类型参数转换为字符串。

enumerate()函数

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。

>>> list(enumerate('abcd'))                                     #枚举字符串中的元素

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

>>> list(enumerate(['Python', 'Greate']))                 #枚举列表中的元素

[(0, 'Python'), (1, 'Greate')]

>>> list(enumerate({'a':97, 'b':98, 'c':99}.items()))   #枚举字典中的元素

[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]

>>> for index, value in enumerate(range(10, 15)):  #枚举range对象中的元素     

print((index, value), end=' ') (0, 10) (1, 11) (2, 12) (3, 13) (4, 14)

zip（）函数

zip()函数返回可迭代的zip对象。
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b)                               #返回zip对象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList)                                         #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]