《Python基础教程》学习笔记之[D7]抽象之函数定义，参数(一)

只做涂鸦笔记之用，如有疑议等问题可留言探讨。

#!/usr/bin/env python2.7
# -*- coding: utf-8 -*- 

# 简单闭包，闭包是一个复杂问题这里只是简单介绍

def multiplier(factor):
    def multiplierByFactory(number):
        return factor*number
    return multiplierByFactory

# 一个函数位于另外一个里面，外层函数返回里层函数。也就是说函数本身被返回了，但是没有被调用，
# 重要的是返回的函数还可以访问它的定义所在的作用域。换句话说，它带着它的环境（局部相关的变量）。
# 看下调用例子的结果

double = multiplier(3)
double(2)
>>> 6

multiplier(3)(4)
>>> 12

# 下面加两个输出语句看看情况

def multiplier(factor):
    print 'factor is %s' % factor
    def multiplierByFactory(number):
        print 'number is %s' % number
        return factor*number
    return multiplierByFactory

>>> multiplier(3)(4)
factor is 3
number is 4
12
>>> double = multiplier(3)
factor is 3
>>> double(2)
number is 2
6
>>>

# 递归 函数自身的调用

def recursion():
    return recursion()

# 上面的是一个无限递归，死循环，会引发一个最大递归深度的错误

# 有用的递归包含以下几个部分
# 当函数直接返回值时有基本实例（最小可能性）问题
# 递归实例，包括一个或者多个问题最小部分的递归调用
# 说了一大堆，很迷茫的样子，其实通俗点说就是 不能无限递归下去，用最少的递归来解决问题
# 两个经典的例子，阶乘和幂

# 这是一个普通的阶乘的例子
def factorial(n):
    result = n
    for i in range(1, n)
        result *=i
    return result

# 这个是改造后递归的例子
def factorial(n):
    if n == 1:
        return 1
    else:
        return n*factorial(n-1)

>>> factorial(5)
120

# 幂
# 普通版
 def power(x, n):
    result = 1
    for i in range(n):
        result *= x
    return result

# 递归版
def power(x, n):
    if n == 0:
        return 1
    else:
        return x*power(x, n-1)

# 二元查找

>>> def search(sequence, number, lower, upper):
...     if lower == upper:
...         assert number == sequence[upper]
...         return upper
...     else:
...         middle = (lower + upper)//2
...         if number > sequence[middle]:
...             return search(sequence, number, middle+1, u
...         else:
...             return search(sequence, number, lower, midd
...
>>> seq = [23, 54,66,2,897,36,99,56]
>>> seq.sort()
>>> seq
[2, 23, 36, 54, 56, 66, 99, 897]
>>> search(seq, 99)                 # 参数，四个，可以修改为默认
Traceback (most recent call last):
  File "", line 1, in 
TypeError: search() takes exactly 4 arguments (2 given)
>>> search(seq, 99, 1, 1000)            # 注意范围
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 7, in search
IndexError: list index out of range
>>> search(seq, 99, 2, 897)
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 7, in search
IndexError: list index out of range
>>> search(seq, 99, 0, 8)
6

# 标准库中的 bisect模块可以非常有效的实现二元查找

# map filter reduce 

map(str, range(10))   # [str(i) for i in range(10)]

def func(x):
    return x.isalnum()

seq = ['foo', 'x41', 34,5]
filter(func, seq)           # [x for x in seq if x.isalnum()]

# lambda

filter(lambda x: x.isalnum() ,seq)

# reduce
numbers = [12,43,656,87,23,9,209,343,22,54,65766,23]
reduce(lambda x,y : x+y, numbers)
67247
>>>

# 上面的这个例子也可以使用内建函数 sum
sum(numbers)