11ch

11.1.1函数和过程

函数可以不带参数，最后返回一个值，

过程是简单，特殊，没有返回值的函数。

返回的对象的数目	python实际返回的对象
0	.None
1	object
>1	tuple

11.2.2关键字参数

你可以按顺序输入对应的参数也可以显式的给定参数

比如：def foo(x)       foo(x = 2)

11.2.4参数组

你可以向函数传递没有显式定义的参数，比如元组和字典

 func(positional_args,keyword_args,*tuple_grp_nonkw_args, **dict_grp_kw_args)

from operator import add, sub
from random import randint, choice

ops = {'+':add, '-':sub}
MAXTRIES = 2
def doprob():
    op = choice('+-')
    nums = [randint(1,10) for i in range(2)]
    nums.sort(reverse = True)
    ans = ops[op](*nums)
    pr = '%d %s %d='%(nums[0], op, nums[1])
    oops = 0
    while True:
        try:
            if int(raw_input(pr)) == ans:
                print "correct"
                break
            if oops == MAXTRIES:
                print 'answer
 %s%d'%(pr,ans)
            else:
                print'incorrect... try again'
                oops += 1
        except (KeyboardInterrupt, 
                EOFError, ValueError):
            print 'invalid input...try again'

def main():
    while True:
        doprob()
        try:
            opt = raw_input('Again? [y]').lower()
            if opt and opt[0] == 'n':
                break
        except(KeyboardInterrupt, EOFError):
            berak
if __name__ == '__main__':
    main()

这是一个让人解算术题的程序

 11.3.5内部/内嵌函数

在函数的内部定义函数时，这个函数的作用域是它的外部函数。

如果内部函数的定义里包含了对在外部函数里定义的对象的引用（或者说这个对象在外部函数之外），

这时内部函数将是一个闭包（closure）

11.3.6函数装饰器

装饰器看起来是这样的：

@decorator()

def func2Bdecorated(func_opt_args):

效果相当于

def func2Bdecorated(func_opt_args):

func2Bdecorated = decorator(func2Bdecorated)

之前的例子中装饰器没有参数，现在给出有参数的例子：

@deco1(deco_arg)

@deco2

def func():pass

相当于
func = deco1(deco_arg) (deco2(func))

通过一个例子更好的理解装饰器：

from time import ctime, sleep

def tsfunc(func):
    def wrappedFunc():
        print '[%s] %s() called' % (ctime(), func.__name__)
        return func()
    return wrappedFunc

@tsfunc
def foo():
    pass

foo()
sleep(4)

for i in range(2):
    sleep(1)
    foo()

11.4传递函数

在python中函数是可以作为参数传递的(在c语言中的回调函数)

def convert (func, seq):
    'conv. sequence of numbers to same type'
    return [func (eachNum) for eachNum in seq]
myseq = (123, 45.67, -6.2e8, 999999999L)
print convert(int, myseq)
print convert(long, myseq)
print convert(float, myseq)

一个抓取网页html代码的程序：

from urllib import urlretrieve

def firstNonBlank(lines):
    for eachLine in lines:
        if not eachLine.strip():
            continue
    else:
        return eachLine

def firstLast(webpage):
    f = open(webpage)
    lines = f.readlines()
    f.close()
    print firstNonBlank(lines)
    lines.reverse()
    print firstNonBlank(lines),

def download(url = 'http://www.baidu.com',
             process = firstLast):
    try:
        retval = urlretrieve(url)[0]
    except IOError:
        retval = None
    if retval:
        process(retval)

if __name__ == '__main__':
    download()

11.6可变长度的参数

通过元组和字典可以实现函数参数的长度可变，

在描述这样一个函数时，参数的循序应该是 位置参数（调用时参数按顺序落位）--> 默认参数 --> 元组 --> 字典。

函数式编程举例

函数式编程的另外一个有用的应用出现在调试和性能测量的方面上

def testit(func, *nkwargs):
    try:
        retval = func(*nkwargs)
        result = (True, retval)
    except Exception, diag:
        result = (False, str(diag))
    return result
def test():
    funcs = (int, long, float)
    vals = (1234, 12.34,"1234", "12.34")
    for eachFunc in funcs:
        print "-" * 20
        for eachVal in vals:
            retval =testit(eachFunc, eachVal)
            if retval[0]:
                print"%s(%s)=" % (eachFunc.__name__,eachVal), retval[1]
            else:
                print "%s(%s) =failed:" % (eachFunc.__name__, eachVal), retval[1]
 
if __name__ == "__main__":
    test()

11.7函数式编程
11.7.1匿名函数与lambda

命名函数可以写成：def true(): return True

而匿名函数则写成：lambda: True

def add(x, y): return x+y

lambda x, y: x + y

在使用的时候，lambda要赋给一个变量

11.7.2内建函数apply(), filter(), map(), reduce()

filter(func, seq):seq中的每个元素都放进func，返回值为True的元素一起成一个序列，filter返回这个序列。

这个函数的实现可以是这样：

def filter(bool_func, seq):
    filtered_seq = []
    for eachItem in seq:
        if bool_func(eachItem):
            filtered_seq.append(eachItem)
return filtered_seq

应用filter()可以写一个获取任意奇数的代码

from random import randint

def odd(n):
    return n % 2
allNums = []
for eachNum in range(9):
    allNums.append(randint(1, 99))
print filter(odd, allNums)

第一次重构，使用lambda表达式：

from random import randint
allNums = []
for eachNum in range(9):
    allNums.append(randint(1,99))
print filter(lambda n: n%2, allNums)

第二次重构，使用列表解析

from random import randint

allNums = []
for eachNum in range(9):
    allNums.append(randint(1,99))
print [n for n in allNums if n % 2]

第三次重构，再度使用列表解析（并且重命名randint)

from random import randint as ri
print [n for n in [ri(1,99) for i in range(9)] if n % 2]

3.map()

map()将把函数映射到每个序列的元素上，并返回一个含有所有返回值的列表。

zip()可以这样使用

>>>zip([1,3,5],[2,4,6])

[(1,2),(3,4),(5,6)]

换成map()来模仿（这体现了map如何并发迭代序列的）

>>>map(None, [1,3,5],[2,4,6])

[(1,2),(3,4),(5,6)]

4.reduce()

 reduce（func, [1,2,3]) = func(func(1,2),3)

使用python来实现reduce():

def reduce(bin_func, seq, init = None):
    lseq = list(seq)
    if init is None:
        res = lseq.pop(0)
    else:
        res = init
    for item in lseq:
        res = bin_func(res, item)
    return res

像这样的代码：

def mySum(x,y): return x+y
allNums = range(5)
total = 0
for eachNum in allNums:
    total = mySum(total, eachNum)
print total #10

使用lambda和reduce()可以写成：

print reduce((lambda x,y: x+y) , range(5))
#10

11.7.3偏函数应用

当你使用包含大量参数的函数的时候，偏函数应用（PFA）可以帮助你避免写大量重复的代码（有点像模板）

警惕关键字：
为了让参数以正确的顺序传入函数，有时候你不得不使用关键字命名，这里有一个没用关键字命名的错误示例，

baseTwoBAD = partial(int, 2)
baseTwoBAD('10010')
TypeError
因为int(num, base)
故num = 2,而'10010' = base
所以我们应该使用关键字命名:
baseTwo = partial(int, base = 2)
baseTwo('10010')
#18

 简单GUI类的例子

使用GUI时常常会遇到很多参数，这时也很适合使用PFA

from functools import partial
import Tkinter
root = Tkinter.Tk()
Mybutton = partial(Tkinter.Button, root, fg='white',bg='blue')
b1 = Mybutton(text = 'Button1')
b2 = Mybutton(text = 'Button2')
qb = Mybutton(bg = 'red', text = 'QUIT', command = root.quit)
b1.pack()
b2.pack()
qb.pack(fill = Tkinter.X, expand=True)
root.title('PFAs!')
root.mainloop()

11.8变量作用域

11.8.2 global语句

在函数内部使用global arg即可访问全局变量，而不会覆盖掉全局变量。

11.8.4闭包

如果在内部函数中对外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就比认为是闭包（closure）的，

定义在外部函数内，但由内部函数引用的变量被称为自由变量。

例子：

def counter(start_at=0):
    count = [start_at]
    def incr():
        count[0] +=1
    return count[0]
return incr        

>>>count = counter(5)

>>>print count()

6

>>>print count()

7

一个使用闭包，装饰器的例子

from time import time
def logged(when):
    def log(f,*args,**kargs):
        print'''Called:
function: %s
args: %r
kargs: %r''' %(f, args, kargs)

    def pre_logged(f):
        def wrapper(*args, **kargs):
            log(f, *args, **kargs)
            return f(*args, **kargs)
        return wrapper

    def post_logged(f):
        def wrapped(*args, **kargs):
            now = time()
            try:
                return f(*args, **kargs)
            finally:
                log(f,*args,**kargs)
                print "time delta: %s" % (time()-now)
        return wrapped
    try:
        return {"pre":pre_logged,
                "post":post_logged}[when]
    except KeyError, e:
        raise ValueError(e), 'must be "pre" or "post"'

@logged("pre")
def hello(name):
    print "Hello,", name

hello("World!")

11.8.5作用域和lambda

>>> def foo():
    y = 5
    bar = lambda(y):x+y
    print bar(y)
    y = 8
    print bar(y)

    
>>> foo()
15
18
>>> def foo():
    y = 5
    bar = lambda:x+y
    print bar()
    y = 8
    print bar()

    
>>> foo()
15
18
>>> def foo():
    y = 5
    bar = lambda y=y:x+y
    print bar()
    y = 8
    print bar()

    
>>> foo()
15
15

lambda和普通的函数一样有作用域，lambda y=y将内置一个作用域在lambda里的局部变量y。

11.10生成器

协同程序：协同程序是可以运行的独立函数调用，可以暂停或者挂起，并从程序离开的地方继续或者重新开始

(这本书讲的不好，生成器迭代器另外找资料看)