函数式编程
后面的闭包和装饰器很重要，参数可以是函数，把函数传进去参与运算。
过程是一个没有返回值的函数，函数本身也是一个对象，因此可以赋值给引用；
一个模块中函数不可重名，因此不支持重载，因为python是以函数名来识别调用的哪一个；
模块中函数的定义是自上而下的；
可以多个返回值，看作是一个元组；也可以分开多个变量接受返回值；
def p(): return 1,2,3 a=p() print a a,b,c=p() print a,b,c
函数的属性
文档属性：__doc__
可以对函数直接传东西进去；
函数参数
位置参数，必须传入；默认参数，可传入，在函数定义时用=..输入默认值，在外界不传入时，使用默认值；可变长度参数，*args元组类型的可变参数，**kwargs字典类型的可变参数；
这几种不同的参数类型可以单个使用，也可以一同使用。
# 位置参数，默认参数，可变参数（元组，字典）
def func(name,count=1,*args,**kwargs):
print name
print count
print args
print kwargs
# 如果传入为确认名字值，和函数一样，则对号入座
func(count=1,name=2)
func("python",12,13,14,15,code=12)
# 对应输出为
python
12
(13, 14, 15)
{‘code‘: 12}
func("python",*(12,13,14,15),**{‘code‘=12})
#这里后面的可变参数会有一部分当作默认参数传入，即12当作默认传入，后面才是可变参数
函数的参数，只有满足前面的参数，才会依次使用，位置参数一定要传入。
Lambda
本身也是一个函数，是一个匿名函数，只能是一行
#表示传入x，返回x+1 a = lambda x:x+1 print a(1)
变量的作用域
x = 1 def func(): #这里的global作用是声明这个x是外部的x global x x+=1 print x func()
函数的闭包：
def f1(x): def f2(y): return x*y return f2 #这里把函数f1的值传入后，给f2，相当于在操作F2之前，注入了一个预先的值，输入了x f2 = f1(10) #输入了y print f2(10)
装饰器
@start(‘shizhen‘)
这个就是装饰器，用在函数的上面
函数的调用可以是一层一层的，外面传入参数，内层的可以使用；
def start(name): def wrapper(f): def wrapper1(): print "start by "+name f() return wrapper1 return wrapper #装饰器要放在函数的上面 @start(‘shizhen‘) def f(): print "function" #这里运行时运行@的这个函数start，会把f这个函数在第二层的时候传进去执行，特点是参数可以是函数， 不再只是单独的对象，而是函数。start的第一层如果无参数‘shizhen’的话，则直接传入f函数。 f()
练习题：
1.实现一个函数max，接受任意个整数的参数，返回其中的最大值
def max(*args): length = len(args) if length == 0: print "empty" else: result = args[0] for i in range(0,length): if result < args[i]: result = args[i] print " max is " + str(result) max(1,2,3,5,2,3,7,8,2,1,10)
2.实现一个带参数的装饰器@callfunction(caller name), 传入的参数是调用者的名字，在调用函数之前，先打印一句 "The caller is [caller name]"的log
def callfunction(name):
def wrapper(f):
#这一层的作用是传入f的传入参数，这里是空，可用*args（可变参数）作为通用的参数
def wrapper1():
print "the caller is " + name
f()
return wrapper1
return wrapper
@callfunction("shizhen")
def f():
print "shizhen is so cool"
f()
装饰器需要一层一层的先把参数和函数全都传入后，在内部自建一层才能把前面传入的所有进行运算。
callfunction(‘shizhen‘)(f)()
3.实现一个装饰器@timeit, 这个装饰器的作用是当函数执行完毕以后，打印出来具体使用的时间
#第一层传入func函数
def timeit(f):
#第二层传入func函数的输入参数
def wrapper(*args，**kwargs):
print (time.strftime("%H:%M:%S"))
f(*args,**kwargs)
print (time.strftime("%H:%M:%S"))
return wrapper
@timeit
def func(*args):
for i in range(0,len(args)):
if args[i] > 10:
print "find:" + str(args[i])
time.sleep(1)
func(1,23,12,31,2,1,23,12,31,23,1,23,1,23,4,3,42,3,42,34,111)
函数式编程时，参数的传入是分开的，一个整体一个整体的传，先传函数本体，再传函数的输入参数
timeit(f)(*agrs)
*agrs也就是可以是多个参数，也可以是没有参数。
*args,**kwargs。用这两个作为参数的函数接受参数是非常安全的。
也就是一层一层的把东西传入进去，装饰器参数+函数+函数参数（*args,**kwargs这个很安全）。。