1
a =[12, 95, 88, 45]
2
sum([x**x for x in a if x % 2])
3

4

5
fn = lambda x,y :x**y
6
def foo():
7
  pass
8
fn =foo

1
import functools
2

3
fn = lambda n: functools.reduce(int.__mul__, range(1, n + 1))

1
import heapq
2

3
list1 = [1, 4, 5, 63, 24]
4
heapq.nsmallest(3, list1)   # 最小的 3 个，注意 n 在前
5
heapq.nlargest(3, list1)    # 最大的 3 个

1
import itertools
2

3
for val in itertools.combinations('abcde', 3):
4
    print(val)

1
for val in itertools.permutations('abc'):
2
    print(val)

1
for val in itertools.product('ABCD', '123'):
2
    print(val)

1
from functools import wraps
2

3
def record(func):
4
    @wraps(func)
5
    def wrapper(*args, **kwargs):
6
        ret_value = func(*args, **kwargs)
7
        return ret_value
8

9
    return wrapper

1
import time
2
from functools import wraps
3
from random import randint
4

5
def record_time(output):
6

7
    def func(function):
8

9
        # 装饰器函数，计算函数执行时间
10
        @wraps(function)
11
        def timeCount(*args, **kwargs):
12
            timestart = time.time()
13
            result = function(*args, **kwargs)
14
            timesend= time.time()
15
            output(function.__name__, timesend - timestart)
16
            return result
17
        return timeCount
18

19
    return func
20

21
def log_to_file(fn, duration):
22
    with open('result.txt', 'a')as fs:
23
        fs.write('%s: %.3f秒\n' %(fn,duration))
24

25

26
@record_time(log_to_file)
27
def fool():
28
    time.sleep(randint(1,3))
29

30

31
def main():
32
    for _ in range(5):
33
        # 此处调用foo并不是真正执行分两类而是执行了wrpper
34
        fool()
35
    # 取消装饰器
36
    foo2 = fool.__wrapped__
37
    for _ in range(3):
38
        # 此处调用被装饰之前写的函数
39
        foo2()
40

41

42

43
if __name__ == '__main__':
44
    main()