python 的几个内置函数（enumerate,lambda ,zip, filter, map, reduce ）用法

python map(fun，[arg]+)函数最少有两个参数，第一参数为一个函数名，第二个参数是对应的这个函数的参数（一般为一个或多个list）。

enumerate() 函数

语法 以下是 enumerate() 方法的语法:
enumerate(sequence, [start=0])
参数 sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置

seq = ['one', 'two', 'three']
 for i, element in enumerate(seq):
	 print( i, element)
0 one
1 two
2 three

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print( list(enumerate(seasons)))
##[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(  list(enumerate(seasons, start=1)) )      # 下标从 1 开始
##[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

map()

def fun(x):
	  return x+1
print(list(map(fun,[1,2,3])))
#[2,3,4]

 def p(x):
	 return x**2
 a = [1,2,3,4]
map(p,a)
<map object at 0x0000027C2BD81780>
print( list(map(p,a)))
#[1, 4, 9, 16]

def fun(x,y,z):
...     return x*y*z
print(list(map(fun,[1,2,3],[1,2,3],[1,2,3])))
#[1,8,27]

lambda表达式：有人说类似于一种匿名函数，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用。

s = [1,2,3]
print(list(map(lambda x:x+1,s)))
#[2,3,4]

这里的 lambda x:x+1 相当于 上面的fun()函数, lambda和（冒号）: 之间相当于 fun()函数的参数, :(冒号)之后 x+1 相当于fun()函数的return x+1

s = [1,2,3]
print(list(map(lambda x,y,z:x*y*z ,s,s,s)))
#[1,8,27]

map和lambda表达式联合使用

 a = [2,5,6]
 print(list(map(lambda x:x*10,a)))
#[20, 50, 60]
 print(a)
 #[2, 5, 6]

内置函数列表
https://www.runoob.com/python/python-built-in-functions.html

open()

f = open('test.txt')
f.read()

zip(a,b)

a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b)     # 打包为元组的列表
 #[(1, 4), (2, 5), (3, 6)]

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

def is_odd(n):
   return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

.str.format

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 "{1} {0} {1}".format("hello", "world")  # 设置指定位置
 print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

enumerate

enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合转换为一个索引序列，一般用于for循环中，同时列出元素和元素的索引号。

my_list = ['a', 'b', 'c', 'd']
for i, x in enumerate(my_list):
   print i, x
   
my_list = ['a', 'b', 'c', 'd']
for item in enumerate(my_list):
   print item

eval

eval(source, globals=None, locals=None)
eval() 函数用来执行一个字符串表达式，并返回表达式的值。

x = 3
result = eval('4*x')
print(result)  # 12

result = eval('x**3')
print(result)  # 27

result = eval('3+3')
print(result)  # 6

result = eval('x*x')
print(result)  

sorted

sorted（）函数，接收任何可迭代对象，返回一个排序后的新对象。

l1 = [2, 4, 3, 1, "6", "a", 5, 9, 7]
new_l1 = sorted(l1)
print(new_l1)
#[1, 2, 3, 4, 5, 7, 9, '6', 'a']

sorted()函数可对任意可迭代对象进行排序

l3 = ['a', 'A', 'b', 'B', 'c', 'C']
new_l3 = sorted(l3)
print(new_l3)
#['A', 'B', 'C', 'a', 'b', 'c']

key参数的值是一个函数，他对list中的每个原始执行操作后作为排序依据。

new_list1 = sorted(l1, key=lambda x: x * -1)
print(new_list1)

l4 = [['aa', 2], ['bb', 1], ['cc', 3]]
new_l4 = sorted(l4, key=lambda x: x[1])
print(new_l4)
#[['bb', 1], ['aa', 2], ['cc', 3]]

1.lambda lambda其实就是一条语句，lambda(x):body。x是lambda函数的参数，参数可以有任意多个(包括可选参数);body是函数体，只能是一个表达式，并且直接返回该表达式的值。

f=lambda x:x+1
f(2) #3
(lambda x,y:x+y)(2,3) #5

2.filter filter(func, list)接受两个参数：一个函数func和一个列表list，返回一个列表。函数func只能有一个参数。filter的功能：列表中所有元素作为参数传递给函数，返回可以另func返回真的元素的列表

l=[‘abc’,‘acd’,‘1245’,‘ddad’,‘aaa’]
func(s)
return s.startswith(‘a’)
filter(func, l)
#[‘abc’,‘acd’,‘aaa’]

filter为过滤list,并返回list,绑定的函数为一个返回bool值的函数
filter(lambda item:item>2,[1,2,3,4])
#[3,4]

def fun(x):
return x>2 and x<6
list=[1,2,3,4,5,6,7]
filter(fun,list)
#[3,4,5]

3.zip zip函数接受任意多个序列作为参数，将所有序列按相同的索引组合成一个元素是各个序列合并成的tuple的新序列，新的序列的长度以参数中最短的序列为准。另外(*)操作符与zip函数配合可以实现与zip相反的功能，即将合并的序列拆成多个tuple

x=[1,2,3],y=[‘a’,‘b’,‘c’]
zip(x,y)
[(1,‘a’),(2,‘b’),(3,‘c’)]
zip(*zip(x,y))
[(1,2,3),(‘a’,‘b’,‘c’)]
.
x=[1,2,3],y=[‘a’,‘b’,‘c’]
for a,b in zip(x,y)
print(a,b)

4.map为操作list,返回list,绑定的函数为修改list中每一个值的函数

list=[1,2,3]
map(lambda x : x*2,list)
#[2, 4, 6]

5.reduce为逐次操作list里的每项，接收的参数为 2个,最后返回的为一个结果

def myadd(x,y):
return x+y
sum=reduce(myadd,(1,2,3))
#6

def add(x, y) : # 两数相加
return x + y
reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5
15
reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数