python learning Functional Programming.py

Posted Chang Zhao

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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可以创建一个新的函数,这个新函数可以固定住原函数的部分参数,从而在调用时更简单。

以上是关于python learning Functional Programming.py的主要内容,如果未能解决你的问题,请参考以下文章

《Learning.Python》pdf

Python Machine Learning

Python Learning: 02

Python - 7 Steps to Mastering Machine Learning With Python

Learning Python telnet.lib

python learning_curve函数