map()

内置函数map()，接收两个参数，参数一为函数，参数二为iterable， 将参数一的函数依次作用到参数二的每一个元素上，结果以新的Iterator返回。
解释：
1.Iterable (迭代对象)：可直接用作for循环的对象，如：list tuple dict set str
2.Iterator（迭代器）：可被next()调用，并不断返回下一个值的对象，如:generator(生成器)

#计算x^2
def fun(x):
    return x**2
for i in map(fun, [1, 2, 3, 4, 5]):
    print(i, end=' ')
#把所有的数字变成字符串并把iterator变成list
print(list(map(str, [1, 2, 3, 4, 5])))

reduce()

reduce()接收两个参数，参数一是函数，参数二是序列，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

from functools import reduce
#str2int方法
#输出 738912
DIGITS = {"0":0, "1":1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9}
def str2int(s):
    def fn(x, y):
        return x*10+y
    def char2int(s):
        return DIGITS[s]
    return reduce(fn, map(char2int,s))
print(str2int("738912"))

#输出12345
def add2(x, y):
    return x*10+y
print(reduce(add2, [1, 2, 3, 4, 5]))

#使用lambda匿名函数
DIGITS = {"0":0, "1":1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9}
def char2int(s):
    return DIGITS[s]
print(reduce(lambda x, y: x*10+y , map(char2int, "987654")))

#将字符串的开头字母变大写，其他变小写
def normalize(name):
    if isinstance(name, str):
        return name[0].upper()+name[1:].lower()
print(list(map(normalize, ["Jemma", "TOnnY", "JSHon"])))

filter()

练习：找素数(埃氏筛法)

#找排除掉偶数的序列（除2外，其他偶数都不是素数）
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n
# 找出不被整除的数
def _not_divisible(n):
    return lambda x: x % n > 0
#输出素数
def primes():
    yield 2
    it = _odd_iter()
    while True:
        n = next(it)
        yield n
        it = filter(_not_divisible(n), it)
#找30以内的素数
for i in primes():
    if i < 30:
        print(i)
    else:
        break

练习：找回数

def is_palindrome(n):
    s = str(n)
    return s[:] == s[-1::-1]
for i in filter(is_palindrome, range(100, 300)):
    print(i)

sorted()

练习：对列表中的元组排序

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    return t[0]
def by_score(t):
    return t[1]
print(sorted(L, key=by_name))
print(sorted(L, key=by_score, reverse=True))

返回函数

函数作为返回值。内部函数可以引用外部函数的参数和局部变量，当外部函数返回内部函数时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

#计数器函数，返回递增整数
def createCounter():
    i = 0
    def counter():
        nonlocal i
        i = i + 1
        return i
    return counter

counter = createCounter()
print(counter(), counter())
print([counter(), counter()] == [3, 4])

匿名函数

print(list(map(lambda x: x**2, [1, 2, 3, 4, 5])))
print(list(map(lambda x: -x if x%2==1 else x, [1, 2, 3, 4, 5])))
print(list(filter(lambda x: x%2 == 0, [1, 2, 3, 4, 5])))

nums = [0, 7, 0, 1, 2, 1, 5, 1, 7, 8, 0, 67, 1, 3, 4]
#print(sorted(nums, reverse=True))
print(sorted(nums, key=lambda x: 1 if x == 0 else 0))

dict = {'k1':10,'k2':20,'k3':30}
print(dict[max(dict, key=lambda x: dict[x])])

装饰器Decorator

在代码运行期间动态增加功能的方式 放在运行函数的开头@

import time, functools
def log1(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print("call %s():" % func.__name__)
        return func(*args, **kw)
    return wrapper

def logtext(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print("%s %s():" % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

def metric(fn):
    start = time.time()
    @functools.wraps(fn)
    def wrapper(*args, **kw):
        print('%s executed in %s ms' % (fn.__name__, 1000*(time.time()-start)))
        return fn(*args, **kw)
    return wrapper

@metric
def fast(x, y):
    time.sleep(0.0012)
    return x + y

@metric
def slow(x, y, z):
    time.sleep(0.1234)
    return x * y * z

f = fast(11, 22)
s = slow(11, 22, 33)
if f != 33:
    print('测试失败!1')
elif s != 7986:
    print('测试失败!2')

偏函数functools.partial

#偏函数
int2 = functools.partial(int, base=2)
print(int2('101'))
print(int2('101', base=10))