python-函数式编程

# 高阶函数: 变量可以指向函数-> 函数名也是变量:把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

# *args 和 **kw
# *args是可变参数，args接收的是一个tuple；
# **kw是关键字参数，kw接收的是一个dict。
# 以及调用函数时如何传入可变参数和关键字参数的语法：
# 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；
# 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。
# 使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

# 1.map
L = [1,2,3,4,5,6,7,8,9]
def f1(x):
    return x ** 2
R = list(map(f1,L)) # 让map的结果转换为list
print("map结果:",R) # == > map结果: [1, 4, 9, 16, 25, 36, 49, 64, 81]

# 1.2 map把元素为int的转化为字符串
S = list(map(str,L))
print("元素类型为int的转为字符串:",S) # == > 元素类型为int的转为字符串: ['1', '2', '3', '4', '5', '6', '7', '8', '9']


# 2.reduce
# 2.1 把序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce
def fn(x, y):
    return x * 10 + y
a = reduce(fn, [1, 3, 5, 7, 9])
print("reduce结果为:",a) # == > reduce结果为: 13579

# 练习

# 1.利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：
def formating(name):
    return name.title()
     
L = list(map(formating,['adam', 'LISA', 'barT']))
print("练习1的答案:",L) # == > 练习1的答案: ['Adam', 'Lisa', 'Bart']

# 2.Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积：
def prod(L1=[]):
    def fn(x,y):
        return x * y
    return reduce(fn,L1)
P = prod([1,2,3,4,5,6,7,8])
print("练习2乘积的答案:",P) # == > 练习2乘积的答案: 40320

# 3.利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456

def str2float(s):
    dot = 0
    num = 0
    if "." in s:
        for i,x in enumerate(s):
            if x == ".":
                dot = len(s) - i - 1
                s = s.replace('.','')
                break
    else:
        s = s
    print("s=",s)
    def fn(x,y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn,map(char2num,s)) / (10**dot)
A = str2float("123.45")
print("练习3的结果:",A) # == > 练习3的结果: 123.45

# 3.filter:用于过滤序列和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
def is_odd(n):
    return n % 2 == 1
L1 = list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
print(L1) # ==> [1, 5, 9, 15]

# 3.1 把一个序列中的空字符串删掉，可以这么写：
def not_empty(s):
    return s and s.strip()
L2 = list(filter(not_empty, ['A', '', 'B', None, 'C', '  '])) # == > # 结果: ['A', 'B', 'C']

# 练习回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()滤掉非回数：
def is_palindrome(x):
    if str(x) == str(x)[::-1]: # 本题只需要正顺序和反顺序相等就满足回数的条件了
        return x 
output = filter(is_palindrome, [x for x in range(1,100)])
print("---->",list(output)) # == > ----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99]

# 4.sorted 排序算法
sorter1 = sorted([1,3,6,-20,34])
print("升序排列:",sorter1)
# 4.1 sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序
sorter2 = sorted([1,3,6,-20,-70],key=abs)
print("自定义排序:",sorter2)
sorter2 = sorted([1,3,6,-20,-70],key=abs,reverse=True)
print("自定义反向排序:",sorter2)
# 4.2 字符串排序依照ASCII
sorter3 = sorted(["ABC","abc","D","d"])
print("字符串排序:",sorter3)
# 4.3 忽略大小写排序
sorter4 = sorted(["ABC","abc","D","d"],key=str.lower)
print("忽略字符串大小写排序:",sorter4)
# 4.4 要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：
sorter5 = sorted(["ABC","abc","D","d"],key=str.lower,reverse=True)
print("忽略字符串大小写反向排序:",sorter5)

# 练习假设我们用一组tuple表示学生名字和成绩:L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)] 请用sorted()对上述列表分别按名字排序：
L = [('Bob', 75),('Adam', 90), ('Adam', 92), ('Bart', 66), ('Lisa', 88),('Bart', 100), ('Bart', 88)]
print("名字列表L=",L)
def by_name(t):
    return t[0]
L2 = sorted(L, key=by_name)
print("按照名字排序(默认升序,名字相同的情况下谁的名字在前谁排在前方):",L2) 

# 扩展1:如果名字相同,按照分数排序(默认升序)
def by_name_score(t):
    return (t[0],t[1])
L3 = sorted(L, key=by_name_score)
print("名字相同,按照分数升序排序:",L3)

# 扩展2:如果名字相同,按照分数升序排列
def by_name_score_asc(t):
    return (t[0],t[1])
L4 = sorted(L,key=by_name_score_asc)
print("名字相同,按照分数升序序排列:",L4) # == > [('Adam', 90), ('Adam', 92), ('Bart', 66), ('Bart', 88), ('Bart', 100), ('Bob', 75), ('Lisa', 88)]

from operator import itemgetter, attrgetter

# 扩展3:如果名字相同,按照分数降序排列(答案待补充)
def by_name_score_desc(t):
        return (t[0], t[1])
L4 = sorted(L,key=by_name_score_desc)
print("名字相同,按照分数降序排列(答案待补充):",L4)

# 5.返回函数
# 5.1 不需要立刻求和返回求和的函数：
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9)
print("返回函数:",f()) # ==> 25

# 6.匿名函数:lambda
L6 = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print("匿名函数:",L6) # ==> [1, 4, 9, 16, 25, 36, 49, 64, 81]

# 7.装饰器(Decorator):在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
@log
def now():
    print('2015-3-25')
print("now函数:",now())

def log(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
@log('execute')
def now():
    print('2015-3-25')
print("传入参数的装饰器的now函数:",now.__name__)

# 7.偏函数:当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单
import functools
int2 = functools.partial(int, base=2) # 通过偏函数声明一个函数名为int2的函数，实现转换成int类型并且参数要和base保持一致最后的结果是10进制的类型
print("二进制的数:",int2("1000")) # ==> 8