python学习笔记2_def count(): 　　fs = [] 　　for i in range(1,4): 　　　　

1、高阶函数（将函数作为变量）

def add(x, y, f):
    return f(x) + f(y)
print add(-9,-8,abs)
#输出17
1
2
3
4

2、map函数

#对每一个元素进行处理
#输入list,返回list
def format_name(s):
    return s.title()

print map(format_name, ['adam', 'LISA', 'barT'])
##title()方法返回所有单词的第一个字符大写的字符串
##['Adam', 'Lisa', 'Bart']
1
2
3
4
5
6
7
8

3、reduce函数

#两两求值
def prod(x, y):
    return x * y

print reduce(prod, [2, 4, 5, 7, 12])
##3360
####第三个参数作为初始值
reduce(f, [1, 3, 5, 7, 9], 100)
1
2
3
4
5
6
7
8

4、剔除list中不满足条件的数

import math

def is_sqr(x):
    return math.sqrt(x) - int(math.sqrt(x)) == 0

print filter(is_sqr, range(1, 101))
#range(1,100)不包含100
##[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
1
2
3
4
5
6
7
8

5、sort函数

#默认从小到大排序
def cmp_ignore_case(s1, s2):
    if s1.lower() < s2.lower():
        return -1
    if s1.lower() > s2.lower():
        return 1
    return 0
#排前面返回-1，排后面返回1，相等为0
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)
###['about', 'bob', 'Credit', 'Zoo']
1
2
3
4
5
6
7
8
9
10

6、返回函数

###################
# coding:utf-8
def calc_prod(lst):
    def andx():
        def prod(x, y):
            return x * y
        return reduce(prod,lst)
    return andx##返回函数名

##返回f和返回f()不一样
f = calc_prod([1, 2, 3, 4])
print f#函数名
print f()##函数
##<function andx at 0x000000000216FA58>，24
##############
# coding:utf-8
def calc_prod(lst):
    def andx():
        def prod(x, y):
            return x * y
        return reduce(prod,lst)
    return andx()##返回函数

##返回f和返回f()不一样
f = calc_prod([1, 2, 3, 4])
print f##函数
print f()##错误
##<function andx at 0x000000000216FA58>，24
###24, error
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

7、闭包

#内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
##闭包的特点是返回的函数还引用了外层函数的局部变量，
##所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()
print f1(),f2(),f3()
##输出9，9，9
##fs保存的是[i*i,i*i,i*i]，所以返回9，9，9
def count():
    fs = []
    for i in range(1, 4):
        def f(m = i):
            return m * m
        fs.append(f)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()
##默认参数完成定义时获取i值且运行函数时无需参数输入的功能，输出1，4，9，fs保存的是函数名
def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i*i
        fs.append(f())
    return fs
f1, f2, f3 = count()
print f1, f2, f3
##将f()添加进fs，f()已计算i*i，f1,f2,f3均为函数的结果，fs保存的是函数结果，输出1，4，9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

8、匿名函数

map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
##[1, 4, 9, 16, 25, 36, 49, 64, 81]
#关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
##限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。
myabs = lambda x: -x if x < 0 else x 
myabs(-1)
##1
#返回匿名函数
1
2
3
4
5
6
7
8

9、装饰器

#定义一个函数，运行时想动态的增加一个功能，又不想改变函数本身的代码
#编写一个函数，它接受一个函数，在内对其包装，再返回一个函数
##############################################################
#不带参数的装饰器
def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn
#传入任意参数
####注意，接收的是函数名，返回的也是函数名，接受f,返回fn,都是函数名
#这两个是python中的可变参数。
##*args表示任何多个无名参数，它是一个tuple；
##**kwargs表示关键字参数，它是一个dict。
##并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前
import time

def performance(f):
    def fs(x):
        print 'call ' + f.__name__ + ' in ' + time.ctime()
        return f(x)
    return fs

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

print factorial(10)
###
call factorial in Tue Nov  8 19:33:56 2016
3628800
###################################################################
#带参数的装饰器
def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')
def test():
    pass
print test()
##[DEBUG] test()...
##None
###log_decorator作为f的装饰器，又是log的闭包，
###从log得到参数，将得到的参数作为变量用进装饰器装饰f，返回一个函数名。
###相当与为了传入一个参数，在装饰器外面定义了一个相对装饰器的一个全局变量。
import time

def performance(unit):
    def f1(f):
        a = time.time()
        def f2(*args, **kw):
            print 'call ' + f.__name__ + '() in ' + str(time.time() - a) + unit
            return f(*args, **kw)
        return f2
    return f1

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

print factorial(10)
###
call factorial() in 5.00679016113e-06ms
3628800
#####
#使用装饰器后函数名会发生改变，可使用functools把原函数的属性复制到新函数上
###
import time, functools

def performance(unit):
    def f1(f):
        #@functools.wraps(f)
        def f2(*args, **kw):
            return f(*args, **kw)
        return f2
    return f1

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

print factorial.__name__
##输出f2
import time, functools

def performance(unit):
    def f1(f):
        @functools.wraps(f)
        def f2(*args, **kw):
            return f(*args, **kw)
        return f2
    return f1

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

print factorial.__name__
##输出factorial
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

10、偏函数

##定义一个新函数修改原函数的默认参数
int()
#默认转化10进制
import functools
int2 = functools.partial(int, base=2)
##修改后int2默认转化2进制成整型
import functools
sorted_ignore_case = functools.partial(sorted,key = str.lower)
print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])
###输出
['about', 'bob', 'Credit', 'Zoo']
##sorted函数原型
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
1、iterable 传入的可迭代的数据类型，即传入需要排序的数据，如list等
2、cmp接受一个函数，拿整形举例，形式为:
    def f(a,b):
       return a-b
    如果排序的元素是其他类型的，如果a逻辑小于b，函数返回负数；
    a逻辑等于b，函数返回0；a逻辑大于b，函数返回正数就行了
3、key也是接受一个函数，不同的是，这个函数只接受一个元素,形式如下
    def f(a):
         return len(a)
    key接受的函数返回值，表示此元素的权值，sort将按照权值大小进行排序
4、reverse参数
    接受False 或者True 表示是否逆序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25