python learning Functional Programming.py

print(abs(-10))

# 函数可以是变量
f = abs
f(-10)

def add(x,y,f):
    return f(x) + f(y)

x = -5
y = 6
f = abs

# 简单的函数式编程
print(add(x,y,f))

# 高阶函数
# map/reduce
# map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

def f(x):
    return x * x

r = map(f, list(range(1,10)))
print(list(r))

# reduce

#reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，
#这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
#reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

from functools import reduce
def add(x, y):
    return x + y

r = reduce(add, [1,3,5,7,9])
print(r)

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

r = reduce(fn,[1,3,5,7,9])
print(r)

# 配合map 写一个把str转换成int的函数
def char2num(s):
    digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    return digits[s]

r = reduce(fn,map(char2num,'13579'))
print(r)

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2num(s):
    return DIGITS[s]

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

r = char2num('5')
print(r)
r = str2int('13579')
print(r)

# 练习

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

def normalize(name):
    return name.capitalize()

# 测试:
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

# Python提供的sum()函数可以接受一个list并求和，
# 请编写一个prod()函数，可以接受一个list并利用reduce()求积：

def func(x,y):
    return x * y

def prod(L):
    return reduce(func , L)

print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
    print('测试成功!')
else:
    print('测试失败!')

# 利用map和reduce编写一个str2float函数
# 把字符串'123.456789'转换成浮点数123.456789：

def str2float(s):

    # 思路：map 将 123.456789 变为 123456798，即利用字符串的切片跳过小数点
    def char2num(s):
        return DIGITS[s]

    # n = s.index('.') 取得小数点的下标 n = 3
    n = s.index('.')

    # reduce 函数把[123456789]变为整数之后，除以 10 ^ n1， n1 = len(s) - n - 1 = 10 - 3 - 1 = 6
    n1 = len(s) - n - 1
    return reduce(lambda x,y:x*10+y,map(char2num,s[:n]+s[n+1:]))/(10**n1)

print('str2float(\'123.456789\') =', str2float('123.456789'))
if abs(str2float('123.456789') - 123.456789) < 0.00001:
    print('测试成功!')
else:
    print('测试失败!')

# 过滤器
# Python内建的filter()函数用于过滤序列。
# 接受一个函数和一个序列，函数依次作用于序列里的每个元素，根据返回值是 True 还是 False 来决定保留还是丢弃该元素

def is_odd(n):
    return n%2 == 1

L = list(filter(is_odd, [1,2,3,4,5,6,7,8,9,10]))
print(L)

# filter()函数返回的是一个Iterator
# 需要用list()函数获得所有结果并返回list。

# 删除一个序列中的空字符
# Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。返回移除字符串头尾指定的字符生成的新字符串。
# 空串("")为False,其他所有字符串皆为True
def not_empty(s):
    return s and s.strip()

L = list(filter(not_empty, ['A','','B',None,'C',' ']))
print(L)

# filter 求素数 埃氏筛法

'''

首先，列出从2开始的所有自然数，构造一个序列：

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：

3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：

5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

取新序列的第一个数5，然后用5把序列的5的倍数筛掉：

7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

不断筛下去，就可以得到所有的素数。

'''

# _odd_iter : 从 3 开始的奇数序列生成器 Iterator
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

# 筛选函数
def _not_divisiable(n):
    return lambda x : x % n > 0

# 生成器 不断返回下一个素数
def primes():
    yield 2
    it = _odd_iter() # Iterator
    while True:
        n = next(it) # Iterator 的第一项
        yield n
        it = filter(_not_divisiable(n),it) # 能跟第一项整除的就过滤掉

# 打印20之内的素数
for n in primes():
    if n < 20:
        print(n)
    else:
        break

# 练习：
# 回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数：

def _iter_():
    n = 0
    while True:
        yield n
        n = n + 1

def palindrome(n):
    s = str(n)
    i = 0
    j = len(s) - 1
    while i<j:
        if s[i] != s[j]:
            return False
        else:
            i = i + 1
            j = j - 1
    return True

output = filter(palindrome, range(1,200))
L = list(output)
print(L)

# sorted 排序算法

# 如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

#  Python内置的sorted()函数就可以对list进行排序：

print(sorted([36, 5, -12, 9, -21]))

# 此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序

# key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

print(sorted([36, 5, -12, 9, -21], key=abs))

# 字符串排序

L = sorted(['bob', 'about', 'Zoo', 'Credit'])
print(L)

# 忽略大小写排序：
# 即需要key这个函数应用到所有元素上，都变成小写，再比较，所以就是：

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

# 逆序

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

# 从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。

# 练习：
# 用一组tuple表示学生名字和成绩：
# 请用sorted()对上述列表分别按名字、按成绩排序

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

# tips 选取元组中的元素方法同数组。

def by_name(t):
    return t[0]

def by_grade(t):
    return t[1]

L2 = sorted(L,key=by_name)
print(L2)

L2 = sorted(L,key=by_grade)
print(L2)

# 函数作为返回值

# 高阶函数可以接受函数作为参数，也可以把函数当做结果返回

# 可变参数求和

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

#当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

f = lazy_sum(1,3,5,7,9)
print(f)   # <function lazy_sum.<locals>.sum at 0x0227E8E8>

# 再调用 f 才是真正计算结果

print(f()) # 25

# 在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

# 返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。

# 匿名函数 & lambda 演算子
# 传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
# Python中，对匿名函数提供了有限支持。

L = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L)

# 匿名函数lambda x: x * x实际上就是：

def f(x):
    return x * x

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

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

# 用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

f1 = lambda x : x * x

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

# 同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y

# 练习：请用匿名函数改造下面的代码：

def is_odd(n):
    return n % 2 == 1

L = list(filter(is_odd, range(1, 20)))
print(L)

L = list(filter(lambda x : x % 2 == 1, range(1,20)))
print(L)

# Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。

# 装饰器

# 函数也是一个对象
# 函数有一个 __name__ 属性可以拿到函数的名字

def now():
    print("2018-05-02")

print(now.__name__)
f = now
print(f.__name__)

'''
现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，
这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
'''

# 本质上，decorator就是一个返回函数的高阶函数。
# *args: 可变参数
# **kw: 关键字参数
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

# log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。

# 借助Python的@语法，把decorator置于函数的定义处：

@log
def now1():
    print('2018-05-02')

# 调用now1()函数，不仅会运行now1()函数本身，还会在运行now1()函数前打印一行日志：
# 把@log放到now1()函数的定义处，相当于执行了语句：now1 = log(now1)

now()
now1()

'''
由于log()是一个decorator，接受的参数就是原来的now，所以，原来的now1()函数仍然存在，
只是现在同名的now1变量指向了新的函数，于是调用now1()将执行新函数，即在log()函数中返回的wrapper()函数。
在wrapper()函数内，首先打印日志，再紧接着调用原始now1函数。
log()会返回一个函数，就是wrapper。

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，自定义log的文本
'''

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

# 这个3层嵌套的decorator用法如下：

@log('execute')
def now2():
    print('2018-05-02')

now2()

# To be completed

# 偏函数

# Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）

# 通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。

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

print(int('12345'))

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

print(int('12345', base = 8))

print(int('12345', 16))

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

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

print(int2('10000000'))
print(int2('10101010'))

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

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

print(int2('10000000'))
print(int2('10101010'))

print(int2('10000000',base=10))
print(int2('10101010',base=10))

'''
创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，

传入：
int2 = functools.partial(int, base=2)

实际上固定了int()函数的关键字参数base，也就是：
int2('10010')

相当于：
kw = { 'base': 2 }
int('10010', **kw)

当传入：
max2 = functools.partial(max, 10)

实际上会把10作为*args的一部分自动加到左边，也就是：

max2(5, 6, 7)
相当于：

args = (10, 5, 6, 7)
max(*args)

结果为10。
'''

# 当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。