python中的reduce内建函数使用方法指南

Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned. Roughly equivalent to：

意思就是说：将一个可迭代的对象应用到一个带有两个参数的方法上，我们称之为appFun,遍历这个可迭代对象，将其中的元素依次作为appFun的参数，但这个函数有两个参数，作为哪个参数呢？有这样的规则，看一下下面reduce方法的实现，有三个参数，第一个参数就是上面说的appFun，第二个参数就是那个可迭代的对象，而第三个呢？当调用reduce方法的时候给出了initializer这个参数，那么第一次调用appFun的时候这个参数值就作为第一个参数，而可迭代对象的元素依次作为appFun的第二个参数；如果调用reduce的时候没有给出initializer这个参数，那么第一次调用appFun的时候，可迭代对象的第一个元素就作为appFun的第一个元素，而可迭代器的从第二个元素到最后依次作为appFun的第二个参数，除第一次调用之外，appFun的第一个参数就是appFun的返回值了。例如reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])，计算1到5的和，因为没有给定initializer参数，所以第一次调用x+y时，x=1,即列表的第一个元素，y=2,即列表的第二个元素，之后返回的1+2的结果作为第二次调用x+y中的x,即上一次的结果,y=2,即第二个元素，依次类推，知道得到1+2+3+4+5的结果。

这样看来，其实下面的代码定义是有一点问题，我们在程序中调用这段代码reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])，得到的结果为16,而正确的结果为15，问题在于如果集合不是以0开始，那么按照如下代码，第一次调用x=1,即第一个元素，y也是等于1，也是第一个元素，而正确的y应该是2。所以真正的reduce方法应该和下面的例子是有差别的。

def reduce(function, iterable, initializer=None): 
  it = iter(iterable) 
  if initializer is None: 
    try: 
      initializer = next(it) 
    except StopIteration: 
      raise TypeError('reduce() of empty sequence with no initial value') 
  accum_value = initializer 
  for x in iterable: 
    accum_value = function(accum_value, x) 
  return accum_value 

sum(lst) 

def customer_sum(lst): 
  result = 0 
  for x in lst: 
    result+=x 
  return result 
 
#或者 
def customer_sum(lst): 
  result = 0 
  while lst: 
      temp = lst.pop(0) 
      result+=temp 
  return result 
 
if __name__=="__main__": 
  lst = [1,2,3,4,5] 
  print customer_sum(lst) 

def add(lst,result): 
  if lst: 
    temp = lst.pop(0) 
    temp+=result 
    return add(lst,temp) 
  else: 
    return result 
 
if __name__=="__main__": 
  lst = [1,2,3,4,5] 
  print add(lst,0) 

lst = [1,2,3,4,5] 
print reduce(lambda x,y:x+y,lst) 
#这种方式用lambda表示当做参数，因为没有提供reduce的第三个参数，所以第一次执行时x=1,y=2,第二次x=1+2,y=3,即列表的第三个元素 
 
 
#或者 
lst = [1,2,3,4,5] 
print reduce(lambda x,y:x+y,lst,0) 
#这种方式用lambda表示当做参数，因为指定了reduce的第三个参数为0，所以第一次执行时x=0,y=1,第二次x=0+1,y=2,即列表的第二个元素， 
假定指定reduce的第三个参数为100，那么第一次执行x=100,y仍然是遍历列表的元素，最后得到的结果为115 
 
 
 
#或者 
def add(x,y): 
  return x+y 
 
print reduce(add, lst) 
#与方式1相同，只不过把lambda表达式换成了自定义函数 
 
#或者 
def add(x,y): 
  return x+y 
 
print reduce(add, lst,0) 
#与方式2相同，只不过把lambda表达式换成了自定义函数 

def statistics(lst): 
  dic = {} 
  for k in lst: 
    if not k in dic: 
      dic[k] = 1 
    else: 
      dic[k] +=1 
  return dic 
 
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
print(statistics(lst)) 

def statistics2(lst): 
  m = set(lst) 
  dic = {} 
  for x in m: 
    dic[x] = lst.count(x) 
 
  return dic 
 
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
print statistics2(lst) 

def statistics(dic,k): 
  if not k in dic: 
    dic[k] = 1 
  else: 
    dic[k] +=1 
  return dic 
 
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
print reduce(statistics,lst,{})  
#提供第三个参数，第一次，初始字典为空，作为statistics的第一个参数，然后遍历lst,作为第二个参数，然后将返回的字典集合作为下一次的第一个参数 
 
或者 
d = {} 
d.extend(lst) 
print reduce(statistics,d) 
#不提供第三个参数，但是要在保证集合的第一个元素是一个字典对象，作为statistics的第一个参数，遍历集合依次作为第二个参数