#!/usr/bin/env python3
# _*_ coding: utf-8 _*_

# 高阶函数
# map() 和 reduce map()函数接收两个参数，一个是函数，一个是Iterable
# map将传入的函数一次作用到序列的每一个元素
import functools
import time
from functools import reduce


def f(x):
    return x * x


r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

print(list(r))

a = list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(a)


# reduce把一个函数作用在一个序列上，这个函数必须接收两个函数，reduce把结果继续和序列的下一元素
# 做累积计算
def add(x, y):
    return x + y


r1 = reduce(add, [1, 2, 3])
print(r1)

l1 = [1, 3, 5, 7, 9]


def fn(x, y):
    return x * 10 + y


print(reduce(fn, l1))

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5}


def str2int(s):
    def fn(x, y):
        return x * 10 + y

    def char2num(s):
        return DIGITS[s]

    return reduce(fn, map(char2num, s))


def char2num(s):
    return DIGITS[s]


def str2int1(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))


print(type(str2int('13521')))


# 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。
# 输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

def normalize(name):
    lowername = name.lower()
    return lowername[0].upper() + lowername[1:]


print(list(map(normalize, ['adam', 'LISA', 'barT'])))


def prod(L):
    return reduce(lambda x, y: x * y, L)


print(prod([3, 5, 7, 9]))


# filter 把传输的函数依次作用于每一个参数，然后根据返回值为True或False决定保留还是丢弃该元素
# 删掉偶数
def is_add(n):
    return n % 2 == 1


print(list(filter(is_add, [n for n in range(20)])))


# 把一个序列中的空字符串删掉
def not_empty(s):
    return s and s.strip()


's'.strip()


# 定义一个从3开始的奇数生成器
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)  # 构造新序列


for n in primes():
    if n < 1000:
        print(n)
    else:
        break


# 回数
def is_paliandrom():
    pass


list = [36, ]

print(sorted([35, 5 - 12, 9, -32]))
print(sorted([35, 5 - 12, 9, -32], key=abs))

L = ['bob', 'about', 'Zoo', 'Credit']
print(sorted(L, key=str.lower, reverse=True))

L1 = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]


def by_name(t):
    return t[0]


def by_score(s):
    return s[1]


print(sorted(L1, key=lambda x: x[0]))
print(sorted(L1, key=lambda x: x[1]))
print(sorted(L1, key=lambda x: x[1], reverse=True))


# 返回函数

# 通常的求和函数定义
def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax


# 如果不需要立即求和，而是在后面的代码中根据需要再计算，则可不返回求和的结果
# 而是返回求和的函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax

    return sum


print(lazy_sum(1, 2, 4))
print(lazy_sum(1, 2, 4)())


# 在上面的例子中，我们在函数中定义了函数sum，并且，内部函数sum
# 可以引用外部函数的参数和局部变量，当外部函数返回内部函数时，相关
# 参数和变量都保存在返回的函数中，这种成为"闭包(Closure)"

def count():
    def f(j):
        return lambda: j * j

    fs = []
    for i in range(1, 4):
        fs.append(f(i))
    return fs


f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())


# 匿名函数
# list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
# y = map(lambda x: x * x, [1, 2, 3, 4, 5])
# print(list(y))

def now():
    print('2019-01-01')


f = now
f()

print(f.__name__)


# 装饰器  是一个返回函数的高阶函数

def log(func):
    def wrapper(*args, **kwargs):
        print('call %s():' % func.__name__)
        return func(*args, **kwargs)

    print('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')

    return wrapper


# 把log放到now()函数的定义处，相当于执行了 now = log(now)

@log
def now():
    print('2018-01-18')


now()


def log(text):
    def decorator(func):
        @functools.wraps(func)  # 把原始函数的__name__属性复制到wrapper函数中
        def wrapper(*args, **kwargs):
            print('%s %s();' % (text, func.__name__))
            return func(*args, **kwargs)

        return wrapper

    return decorator


@log('execute')
def now():
    print('2019-01-20')


now()
print(now.__name__)


# now = log('execute')(now)


def metric(fn):
    start = time.time()

    def wrapper(*args, **kwargs):
        return fn(*args, **kwargs)

    end = time.time()
    print('%s executed in %s ms' % (fn.__name__, end - start))
    return wrapper


#


@metric
def fast():
    time.sleep(4.5013)


fast()

# partial function 片函数
print(int('12', base=16))
print(int('12', base=8))

def int2(x, base=2):
    return int(x,base)

# functools.partial 就是帮助我们创建一个片函数的，不需要定义int2(),可以使用
# 下面的代码穿件一个新的函数int2()
import functools

int2 = functools.partial(int, base = 2)
print(int2('1000000'))