day 11

day11
lambda 表达式(又名匿名函数表达式)
作用:
创建一个匿名函数对象
同def类似，但不提供函数名
语法:
lambda [形参1, 形参2, …] : 表达式
示例:

  def myadd(x, y):
        return x + y
可以改写为:
myadd = lambda x, y: x + y
print(myadd(100, 200))
print(myadd("ABC", "100"))

语法说明:
1. lambda 只是一个表达式，它用来创建一个函数对象
2. 当lambda表达式调用时，先执行冒号后的表达式,并返回表达式的结果的引用
3. lambda 表达式创建的函数只能包含一条表达式
4. lambda比函数简单，且可以随时创建和销毁,有利于减少程序的偶合度

看懂下面的程序在做什么：

   def fx(f, x, y):
       r = f(x, y)
       print(r)
    fx((lambda a, b: a + b), 100, 200)
    fx((lambda x, y: x ** y), 3, 4)

eval 和 exec 函数
eval函数:
作用：
把一个字符串当成一个表达式执行，返回表达式执行后的结果
格式:
eval(source, globals=None, locals=None)
示例:

  x = 100
    y = 200
    s = "x+y"
    v = eval(s)
    print(a)

print(eval("x+y", {'x':10, 'y':20}))   # 30
print(eval("x+y", {'x':10, 'y':20}, {'x':1, 'y':2}))  # 3
print(eval("x+y", {'x':10, 'y':20}, {'x':1}))  # 21

exec函数:
作用：
把一个字符串当成程序来执行
格式：
exec(source, globals=None, local=None)
示例:

  s = 'x=100; print("hello"); x += 1; print(x)'
    print(s)
    exec(s)

函数式编程:
是指用一系列函数解决问题

函数是一等公民

1. 函数本身是对象，可以赋值给变量,赋值后变量绑定函数
2. 允许将函数作为实参传入另一个函数
3. 允许函数返回一个函数

函数式编程的好处:

1. 每一个函数完成细小的功能，一系列函数的任意组合可以解决大的问题
2. 函数仅接收输入并产生输入，不会影响其它全局变量的状态

高阶函数 High Order Function
什么是高阶函数:
满足下列条件中的一个的函数即为高阶函数
1. 函数接受一个或多个函数作为参数传入
2. 函数返回一个函数

python内置(builtins)的高阶函数:
map, filter, sorted
map 函数:
map(func, *iterables) 用函数对可迭代对象中的每一个元素作为参数计算出新的可迭代对象，当最短的一个可迭代对象不再提供数据时，此可迭代对象生成结束

示例 ：

  # 生成一个可迭代对象，要求此可迭代对象可以生成1~9自然数的平方
  1, 4, 9, 16, .... 81
  def power2(x):
      return x**2
  for x in map(power2, range(1, 10)):
      print(x)
  # 求以上数据的和 1 + 4 + 9 + 16 + ... + 81
  print(sum(map(power2, range(1, 10))))

示例:

 # 生成一个可迭代对象, 要求此可迭代对象生成
    #   1**4, 2**3, 3**2, 4**1
    #    1     8     9    4 
    for x in map(pow, [1,2,3,4], [4,3,2,1]):
        print(x)

练习：

1. 求 12 + 22 + 32 + … 92的和

def f2(x):
    return x ** 2
s = sum(map(f2, range(1, 10)))
print(s)
  # 方法2
print(sum(map(lambda x: x**2, range(1, 10))))

2. 求 13 + 23 + 33 + … 93的和

print(sum(map(lambda x: x**3, range(1, 10))))

3. 求 19 + 28 + 37 + … 91的和

   print(sum(map(pow, range(1, 10), range(9, 0, -1))))

filter函数:
格式:
filter(func, iterable)
作用：
筛选可迭代对象iterable中的数据，返回一个可迭代对象,此可迭代对象将对iterable进行筛选
函数func 将对iterable中的每个元素进行求值，返回False时将此数据丢弃,返回True,则保留此数据

示例:
# isodd函数判断x是否为奇数，是奇数返回True
def isodd(x):
return x % 2 == 1
# 打印10以内的奇数:

for x in filter(isodd, range(10)):
    print(x)

sorted 函数:
作用：
将原可迭代对象的数据进行排序，生成排序后的列表
格式:
sorted(iterable, key=None, reverse=False)
参数说明:
iterable 可迭代对象
key 绑定函数，此函数用来提供一个排序的依据
reverse 标志用来设置是否降序排序(从大到小)
示例:

L = [5, -2, -4, 0, 3, 1]
L2 = sorted(L)   # L2 = [-4, -2, 0, 1, 3, 5]
L3 = sorted(L, reverse=True)  L3=[5,3,1...]
L  =    [5, -2, -4, 0, 3, 1]
# 依据:  abs(5), abs(-2), abs(-4), abs(0), ...
L4 = sorted(L, key=abs)  # L4 =[0, 1, -2, 3, -4, 5]

递归函数 recursion
函数直接或间接的调用自身
递归说明:
递归一定要控制递归的层数，当符合某一条件时要终止递归
几乎所有的递归都能用循环来代替

递归的优缺点:
优点：
递归可以把问题简单化,让路径更为清晰,代码更为简洁
缺点：
递归因系统环境影响大,当递归深度太大时，可以会得到不可预知的结果

递归函数的实现方法：
先假设函数已经实现
示例:
求:100 + 99 + 98 + 97 + … + 1 的和
分析:
先假设 mysum(x) 已经完成，且能求
x + (x-1) + … +1的和

def mysum(x):
      # 选判断终止条件
      if x == 1:
          return 1
      return x + mysum(x - 1)

  print(mysum(100))  # 5050