python入门3

python 比较6的

函数式编程

**：首先 先要知道 变量可以指向函数，然后这个变量就是函数了，就可以当做函数被使用。

高阶函数

*：函数的参数可以接收变量，也可以接收 函数，凡是接收函数的函数，叫做高阶函数

例1：def add(x,y,f):

return f(x)+f(y)
add(10,5,abs)
例2 ： import math
def add(x, y, f):
return f(x) + f(y)
print add(25, 9, math.sqrt)
**

map()

**高阶函数：接收一个函数f和一个list；返回一个新的list（原来的list中每一个element都被f操作一遍）

例 def f(x):
return x*x
return map(f,[1,2,3,4,5])

reduce()

高阶函数：同样接收一个f和list，与map不同，f(x,y)必须接收两个参数

f将list中每2个element一次操作一遍，，先操作第一个和第二个，然后操作结果，与第三个操作，还可以设置个初始值reduce(f,list,num)使list中第一个数先和num操作然后结果与第二个操作

例子 def f(x,y)
return x+y
reduce(f,[1,2,3,4,5],100)
## #
## ##

filter() ##

高阶函数：同样接收一个f和list，f对每一个元素进行判断 返回的 true 或者false 根据结果 筛掉不符合的元素

例子1 def is_odd(x):
return x % 2 == 1
然后，利用filter()过滤掉偶数：
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

例子2  def is_not_empty(s):
return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

sorted(f,list)

高阶函数：用来排序

f(x,y)

想要让x在y前面 return -1

x在y后面 return 1

x和y相等 return 0

例子1

def reversed_cmp(x, y):
if x > y:
return -1
if x < y:
return 1
return 0
sorted([1,2,3,6,3,7],f)
例子2
def cmp_ignore_case(s1, s2):
u1 = s1.upper()
u2 = s2.upper()
if u1 < u2:
return -1
if u1 > u2:
return 1
return 0
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

返回函数 ##

函数不光能接收函数，还能返回函数，

def calc_sum(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
calc_sum 返回的是lazy_sum
print calc_sum([1,2,3,4,5,6])

我们会发现打印的是个lazy_sum函数地址而不是结果

如果想执行结果

我们需要 执行 返回的函数；

f=calc_sum([1,2,3,4,5,6])

print f(),其应用可以让结果不立即出来，

看下一个内容 闭包

闭包

讲函数定义到函数里面，目的是使里面的函数（内函数）不被外面访问，

但是当内函数用到外函数的变量作为参数的时候 ，我们成为闭包。

切记一定不要用 外面函数中变化的 变量来作为参数如

例：def outer():
fs[]
for i in range(1,4)
def inner():
fs.append i*i
return i*i
return fs
f1,f2,f3= outer()
print f1(),f2(),f3()
返回结果为 9，9，9
(这里用三个函数接收因为fs存的是三个方法而不是值)
不信你自己print fs或者累不下面的代码
def count():
fs = []
for i in range(1, 4):
fs.append(i*i)
return fs

f=count()
print f
如果你不想返回三个9 那么 找一个先的参数接收
def count():
fs=[]
for i in range(1,4)
def f(y):
def lo():
y=i
return y*y
return lo
fs.append(f(i))
return fs
就会返回1,4,9
def f(y):
def lo():
y=i
return y*
return lo

注意这个

其实返回的是[f1(),f2(),f3()]

期间我看的是廖雪峰的教程，想法有些抽象。慢慢看半天就差不多了

匿名函数

python对匿名函数有一些支持，单只支持单行的表达式格式是

lambda: 参数 单行函数

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

例sorted([1,2,3,4,5],lamdba x,y:  -cmp(x,y))
[5,4,3,2,1]
map(lamdba x:x*x,[1,2,3,4,5])

装饰器

类似于java 中的拦截器，不过python能非常轻松的完成，而且功能更加强大，如：给一个函数 日志，用高阶函数完成

def pre(f):
def g():
print 'call%s '%(f.__name__)
r=f()
return r
return g
然后用
l=pre(f)---->f=pre(f)去调用
python中省去了调用 直接写
@pre(f)

即可写日志！
**无参装饰器**：   装饰器要装饰不同函数，当函数参数不同，如果装饰器将 参数写固定， 就会出现编译错误
这时要借助 *args **kw将参数写可变
例子：同上，写日志：

def pre(f):
def fn(*args,**kw):
print 'call %s '%(f.__name__)
return f（*args,**kw）
return  fn
import time
例子：在函数上打印使用时间
def performance(f):
def fn(*args,**kw):
t1=time.time()
r=f(*args,**kw)
t2=time.time()
print 'call %s() in %fs'%(f.__name__,(t2-t1))
return r
return fn
@performance
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

用参装饰器 ##

当你想写的日志不是固定的call f.name, 想针对不同的函数设置不同的级别 这时候需要给装饰器更完善一下

def log（index）:
def wraps(f):
def g(*args,**kw):
print'[%s]call %s '%{index,f.__name__}
return f(*args,**fw)
return g
return wrap
@log
fercial()
打印调用函数所用时间
import time

def performance(unit):
def pre_decorator(f):
def log(*args,**kw):
time1 =time.time()
r=f(*args,**kw)
time2 = time.time()
if unit =='ms':
t=(time2-time1)*1000
else:
t=(time2-time1)
print 'call %s() in %f %s'%(f.__name__,t,unit)
return r
return log
return pre_decorator

@performance('s')
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

进一步优化装饰器

当再使用装饰器的时候打印的name,doc都是装饰器里的属性

有一些依靠name来操作的函数就会出现错误，为了避免

应该使装饰器里的函数的name,doc等于被装饰函数

def perform(f):
def wraps(*args,**kw):
wraps.__name__=f.__name__
wraps.__doc__=f.__doc__
return f(*args,**kw)
return  wraps
@perform
def fercial(n):
print n
print fercial.__name__
python有个简单的：functools中的wraps方法
import functools
def log(f):
@functools.wraps(f)
def wrapper(*args, **kw):
print 'call...'
return f(*args, **kw)
return wrapper

偏函数

当一个函数有很多参数时，调用者就需要提供多个参数。如果减少参数个数，就可以简化调用者的负担。

比如，int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

int(‘12345’)

12345

但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做 N 进制的转换：

int(‘12345’, base=8)

5349

int(‘12345’, 16)

74565

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):

return int(x, base)

这样，我们转换二进制就非常方便了：

int2(‘1000000’)

64

int2(‘1010101’)

85

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

import functools

int2 = functools.partial(int, base=2)

int2(‘1000000’)

64

int2(‘1010101’)

85

所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。