python10高阶函数

1.函数
函数本身也可以赋值给变量,即:变量可以指向函数。

函数名其实就是指向函数的变量!

上述操作发现:abs为函数名,给abs=1重新赋值后,abs已不是函数,而是一个整数。
2.高阶函数
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

3.map函数
map() 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回。

# def pow1(x):
#    return x*x
# print map(pow1,range(1,11))
map() 作为高阶函数,把运算规则抽象了.

4.reduce函数
reduce 把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算。

5.filter函数
filter() 也接收一个函数和一个序列。和 map() 不同的是filter()把传入的函数依次作用于每个元素,然后根据返回值是 True
还是 False决定保留还是丢弃该元素。
在一个 list中,删掉偶数,只保留奇数:

• 把一个序列中的空字符串删请尝试用 filter() ;
• 用 filter()删除 1~100 的素数;
6.sorted函数
• 排序也是在程序中经常用到的算法。 无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。通常规定如下:
x < y, return -1
x == y, return 0
x > y, return 1
倒序排序
In [3]: sorted(t)
Out[3]: [1, 12, 24, 34, 37]

In [4]: def reversed_cmp(x,y):
  ...:    if x>y:
  ...:        return -1
  ...:    elif x < y:
  ...:        return 1
  ...:    else:
  ...:        return 0
  ...:    

In [5]: sorted(t,reversed_cmp)
Out[5]: [37, 34, 24, 12, 1]
In [11]: def ignore_case_cmp(x,y):
  ....:    lower1 = x.lower()
  ....:    lower2 = y.lower()
  ....:    if lower1 < lower2:
  ....:        return -1
  ....:    elif lower1 > lower2:
  ....:        return 1
  ....:    else:
  ....:        return 0
  ....:    

In [13]: sorted(li,ignore_case_cmp)
Out[13]: ['haoningning', 'Haoningning', 'wangying', 'xiaowenya']

高阶函数的抽象能力非常强大,而且核心代码可以保持得非常简洁。
7.函数作为返回值
高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。
def lazy_sum(*args):
def sum():
ax = 0
for n in arg
ax = ax + n
return ax
return sum
f = lazy_sum(1,2,3,4)
f()
#调用 lazy_sum()时,返回的并不是求和结果,而是求和函数
#调用函数 f时,才真正计算求和的结果
调用 lazy_sum()时,每次调用都会返回一个新的函数,即使传入相同的参数

# 示例1:
def wrap_sum(*args):
   def my_sum():    # (1,2,3,4)
       sum_num = 0
       for i in args:
           if notisinstance(i,(int,float)):
               print 'Error Type'
           sum_num = sum_num + i
       return sum_num
   return my_sum

# print my_sum(1,2,3,6)
f1 = wrap_sum(1,2,3,6)
print f1
# print f1()

f2 = wrap_sum(1,2,3,6)
print f2
# 示例2：
def count():
   fs = []
   for i in range(1,4):
       def f():
           return i*i
       fs.append(f)
   return fs
##解决方案：再嵌套一个函数
def count():
   fs = []
   for i in range(1,4):   # i=1
       def f(j):
           def g():
               return j*j
           return g
       fs.append(f(i))  # fs.append(f(1)) fs=[]
   return fs


6f1,f2,f3 = count()
print f1()
print f2()

f1,f2,f3 = count()
print f1()
print f2()
print f3()
8.匿名函数
•当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便。
•关键字 lambda表示匿名函数,冒号前面的x表示函数参数

• 匿名函数有只能有一个表达式,不用写 return ,返回值就是该表达式的结果。
• 因为匿名函数没有名字,不必担心函数名冲突。 此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数

•也可以把匿名函数作为返回值返回

# 匿名函数可以赋值给一个变量，需要运行时，变量名()
f = lambda :1
print f()


# 匿名函数传递必选参数和默认参数
f = lambda x,y=2:x**y
print f(2,3)
print f(2)

# 匿名函数传递可变参数
f = lambda *x:map(lambda x:x+x,x)
print f(1,2,3,4)

# 匿名函数传递关键字参数
f = lambda **kwargs:kwargs.items()
print f(name="fentiao",age=5)
from __future__ import division
x = input('num1:')
oper = raw_input('operator:')
y = input('num2:')
d = {
   "+": lambda x, y: x +y,
   "-": lambda x, y: x -y,
   "*": lambda x, y: x *y,
   "/": lambda x, y: x /y
}
if oper not in d.keys():
   print 'input +,-,*,/'

print d[oper](x,y)

9.装饰器
•装饰器就是用来装饰函数。
• 想要增强原有函数的功能;
• 但不希望修改now()函数的定义;
• 在代码运行期间动态增加功能的方式;装饰器
•定义的装饰器实质是返回函数的高阶函数。(试试下面的装饰器)

import time
def timmer(func):
   def dec():
       start_time = time.time()
       func()
       stop_time = time.time()
       return "%s run %fs"%(func.__name__ ,stop_time-start_time)
   return dec
@timmer    #hello2=timmer(hello2),语法糖
def hello2():
   print 'hello2....'
   time.sleep(2)
print hello2()