Python 进阶之函数&高阶函数（五）

本篇主要讲Python中不一样的函数使用方式。

函数

定义函数

使用 def语句，格式： def 函数名(参数名): 在缩进块中写函数体，return 返回值。以下几个示例展示函数的使用方式：

# 1. 定义自己的取绝对值函数
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
# my_abs(-2) = 2
print('my_abs(-2) =', my_abs(-2)) 

# 2. 返回多个值的函数，其实是一种假象，返回仍是单一值，且是一个 tuple 
import math  # 表示导入 math包
def move(x, y, step, angle = 0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
# move:  (151.96152422706632, 70.0) 
print('move: ', move(100, 100, 60, math.pi / 6))    

对于函数使用有这几点总结：

• 定义函数时，需要先确定函数名和参数个数；参数个数 - 不正确，Python检查器自动检查，并抛出 TypeError；
• 若有必要，可以先对参数进行数据类型检查，如，判断参数为整数和浮点数 - isinstance(x, (int, float))；
• 函数体内部可以用 return 随时返回函数结果；
• 函数无返回数据执行 return 时，自动 return None;
• 函数可以同时返回多个值，但其实就是一个 tuple。

Python 中有许多内置函数，可参考文档：http://docs.python.org/3/library/functions.html

列举常用的一些数据类型转换方法：

常见数据类型转换方法.png

函数参数

Java 中函数调用是，参数要严格按照参数类型、个数来传递。Python 相对来说代码会更简单些，有五种参数方式使得 Python 中函数调用更加灵活。

1.位置参数
调用函数时，传入的两个值需按照位置顺序依次传入。

def power(x, n):
    pass    # x, n 就是位置参数。

2.默认参数
可看作 函数参数不同的重构函数，简化函数调用；与Java重构方法不同，这里使用默认参数可达到一个函数的不通参数个数调用。

def power(x, n = 2):
    s = 1
    while n > 0:
        n -= 1
        s *= x 
power(5)    # 25  默认n=2，计算x的平方
power(5, 3) # 125 当n>2时，计算的就是x的n次方

Tips：

• 必选参数必须在前，默认参数在后，否则 Python 解释器会报错；
• 当函数有多个参数，把变化大的参数放前面，变化小的放后面。变化小的参数作为默认参数；
• 默认参数必须指向不变对象，不能是 list。【 原因：默认参数 L 变量指向对象 []，若每次调用改变了 L 的内容，则其指向的对象内容也会改变。】

3.可变参数（*nums）
顾名思义，传入的参数是可变的，可以是0-任意个。
特点：在函数调用时将参数自动组装成一个 tuple。
做法：与直接定义一个 list 或 tuple 存放参数对比，定义可变参数仅在 参数前添加一个 * 号。

def calculate(*numbers):
    sum = 0
    for n in numbers:
        sum += n * n
    return sum  
print('cal(1, 2, 3) =', calculate(1, 2, 3))   # cal(1, 2, 3) = 14
print('cal(1, 2, 3, 4, 5, 6) =', calculate(1, 2, 3, 4, 5, 6))

# *nums 将一个数组的所有元素都作为可变参数传入
nums = [1, 2, 3]
print(calculate(*nums))

Tips:

• *若参数是一个 list 或 tuple，则可直接使用 list 或 tuple 将其变成可变参数传入。如： nums = [1, 2]; calc(nums);
• *nums 表示把 nums 这个 list 的所有元素作为可变参数传入，此种写法很常见。

4.关键字参数（**kw）
定义：允许传入0-任意个含参数名的参数，这些关键字在函数内部自动组装成一个 dict。
作用：扩展函数功能。如某两个字段是必填项，其他的是可选项，则可使用关键字参数。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
        
person('Jane', 24)
person('Coral', 24, city = 'Beijing')

# 打印结果：
# name: Jane age: 24 other: {}
# name: Coral age: 24 other: {'city': 'Beijing'}

Tips:

• 若参数是一个 dict，则 *dict 可以将该dict的所有 key-value 用关键字参数传入到函数的 *kw 参数；
• kw 此时会得到一个 dict，但是是 dict的一份拷贝，对 kw 的改动不会影响函数外的 dict。

5.命名关键字参数
定义：对于关键字参数，需要检查 kw 是否存在某些 key 参数。
特点：和 关键字参数 **kw 不同，命名关键字参数需一个特殊分隔符 *，* 后面的参数视为命名关键字参数。
作用：限制调用者可以传入的参数名，同时也可以提供默认值。

# 只接受 * 后面的 city job 作为参数，不能传入任意个参数
def person(name, age, *args, city, job):
    print(name, age, args, city, job)
person('Jane', 1, 'hello', city = 'shanghai', job = 'Paint')
# 打印：Jane 1 ('hello',) Shanghai Paint

Tips:

• 若函数中已有可变参数，则后面跟着的 命名关键字参数就不需要特殊分隔符；
• 命名关键在参数必须传入参数名，不传会报错。

6.参数组合-可变参数
Python 中，可以同时使用 必选参数、默认参数、可变参数、关键字参数 和 命名关键字参数。

def person(name, *habits, **friends):
    print('My name is', name)

    # 遍历tuple
    for item in habits: 
        print('My habits are:', item, end = ' ')

    print('')   
    # 遍历dict
    for name, city in friends.items():
        print('Friend name is', name, ' in', city)

person('Coral', 'Reading', 'Coding', Jane = 'Wuhan', Saint = 'Nanjing')

# 打印：
# My name is Coral
# My habits are: Reading My habits are: Coding 
# Friend name is Jane  in Wuhan
# Friend name is Saint  in Nanjing

Tips:

• 上述几种参数定义顺序：必选参数 > 默认参数 > 可变参数 > 命名关键字参数 > 关键字参数 ；
• 最好不要组合太多，如此会让函数的可理解性变差。

高阶函数

定义：变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数为高阶函数。简言之，就是把函数作为参数传入的函数称为高阶函数。

以下将按照这样几种场景来说明高阶函数：函数作为参数、返回函数、匿名函数、装饰器和偏函数。

1. 函数参数
这里将依次介绍 Python 中四种内置的函数：map、reduce、filter、sorted 。

1）map(func, Iterable)
定义：map(func, Iterable) : return Iterable
作用：将传入的函数func 依次作用于序列的每个元素，并把结果作为新的 Iterable 返回。

# 使用 map() 将函数 f(x)=x*x 作用在 序列 [1, 2, 3, 4, 5], 也即是将序列编程对应元素的平方。
def power(x):
    return x * x

# 返回 Iterator，需 list() 方法计算并返回一个 list   
L = map(power, [1, 2, 3, 4, 5])  
print(list(L)) # [1, 4, 9, 16, 25]

# 将整数序列编程字符串序列
print(list(map(str, [1, 2, 3, 4, 5]))) 

2）reduce(func, 序列)
定义：reduce() 把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce 把结果继续和序列的下一个元素做累计计算，效果就是：reduce(f, [x1, x2, x3]) = f(f(x1, x2), x3) return Iterable 。
作用：必须接收两个参数，把结果继续和 序列的下一个元素做累计计算。

# 问题：将 str 转成 int 的函数。
# 1. 将 str 序列转成 int 序列
def char2Int(ch):
    d = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    return d[ch]
    
# 2. 将 char2Int 函数作用在字符串 '13579'的每一字符上，也即去除对应字符的int值        
it = map(char2Int, '13579') 
# print("first ", list(it))  # 返回的是一个序列 [1, 3, 5, 7, 9]
print(reduce(fn, it))   # 13579

# 3. 最终整理成 str2int() 函数如下：
def str2int(stri):
    def fn(x, y):
        return x * 10 + y
    def char2Int(ch):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[ch]
    return reduce(fn, map(char2Int, stri))

# 4. 进一步简化
def str2int2(stri):
    return reduce(lambda x, y: x * 10 + y, map(char2Int, stri))

# str2int2('1234') =  12345
print('str2int2(\'1234\') = ', str2int2('12345')) 

3）filter(函数，序列)
定义：filter(func, 序列): return Iterator -> list(Iterator)
作用：区别于map()，filter() 把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。。
特点：此高阶函数，关键在于正确实现一个“筛选”函数；返回 Iterator 惰性序列。

def isEmptyChar(ch):
    return ch and ch.strip() 

# ['A', 'B', 'C']
print(list(filter(isEmptyChar, ['A', '', 'B', None, 'C', '']))) 

4）sorted(list, key=func)
定义：sorted(list, key=func) return list .
作用：sort() 接收一个 key 函数来实现自定义的排序，如按绝对值大小排序； key 指定的函数将作用于 list 的每一个元素上，并根据 key 函数返回的结果进行排序。

# 示例一：按绝对值大小排序列表。
L = [30, 5, -12, 9, -21]
print(sorted(L, key=abs))  # [5, 9, -12, -21, 30]

# 实例二：字符串排序，忽略大小写，按字母序列排序。
L = ['bob', 'about', 'Zoo', 'Credit']
print(sorted(L, key=str.lower)) # 忽略大小写进行排序  # ['about', 'bob', 'Credit', 'Zoo']

# 实例三：对实例二中的字串进行反向排序，不改变 key 函数，传入第三个参数 reverse=True
print(sorted(L, key=str.lower, reverse=True))      # ['Zoo', 'Credit', 'bob', 'about']

# 练习：假设学生名字和成绩用tuple 表示，用 sorted() 对上述列表 按名字排序。
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def sort_by_name(tup):
    return str.lower(tup[0])

def sort_by_grade(tup):
    return tup[1]

2. 返回函数
定义：把函数作为结果值返回。

# 示例一：不返回求和的结果，而是返回求和的函数。
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum    # 返回求和的函数

# 调用 lazy_sum() 时，返回的并不是求和结果，而是求和函数
func_sum = lazy_sum(1, 3, 5, 7, 9)  # 返回求和函数    
print(func_sum)         # <function lazy_sum.<locals>.sum at 0x102198598>   
# 调用 func_sum 时，才真正计算求和的结果
print(func_sum())       # 25

说明：

• 在 lazy_sum() 函数中，定义了内部函数 sum()，其可以引用外部函数的参数和局部变量；
• 当 lazy_sum() 返回函数 sum 时，相关参数和变量都保存在返回的函数中，这种称为 “闭包” 的程序结构有极大的威力。
• 每次调用 lazy_sum() 时，都会返回一个新的不等的函数，即使传入相同的参数。

这里简单说明下闭包：

闭包.png

3. 匿名函数
定义：使用关键字 lambda 表示，lambda x: x * x -> 冒号前的x表示函数参数。
在传入函数时，有时不需要显式地定义函数，直接传入匿名函数更方便。

# 示例一：对 map() 传入匿名函数 lambda x: x * x
print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))  # [1, 4, 9, 16, 25]

# 说明：
# 1）lambda 关键字表示匿名函数，冒号前面的 x 表示函数参数；
# 2）匿名函数有一个限制，就是只能有一个表达式，不用写 return，返回值就是该表达式的结果；
# 3）匿名函数的好处就是函数没有名称，不必担心函数名冲突；
# 4）匿名函数也是一个函数对象，可以把匿名函数赋值给一个变量，再利用变量调用该函数。

# 例如：lambda x: x * x 等价于：
# def f(x):
#   return x * x

f = lambda x: x * x
print(f)    # <function <lambda> at 0x1022987b8>
print(f(5)) # 25

# 同样的，可以把匿名函数作为返回值返回，如以下所示：
def build(x, y):
    return lambda: x * x + y * y

func0 = build(2, 3)
print(func0) # <function build.<locals>.<lambda> at 0x101a986a8>
print(func0())  # 13

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

4. 装饰器
定义：在不修改函数定义的前提下，增强某个函数的功能，这种在代码运行期间动态增加功能的方式，称为“装饰器”（Decorator）；

def log(func):
    # 可变参数个数可为0-任意个
    def wrapper(*args, **kw):  
        print('call %s()' % (func.__name__))
        return func(*args, **kw)
    return wrapper

#  需要使用 Python的@语法，把 decorator 置于函数的定义处：
@log
def now():
    print('2017-09-13') 

now()  # call now()  2017-09-13 

说明：

• 将 @log 放在 now() 函数定义处，相当于执行语句：now = log(now)；
• 由于 log() 是一个 decorator，返回一个函数，所以原来的 now() 仍然存在，只是同名的 now 变量指向了返回后的函数，即 wrapper() 函数。
• wrapper() 函数的参数定义是 (*args, **kw) - 所以可以接收任意参数调用。

Tips:

• 类中给类方法添加 @classmethod 装饰器，可以使该方法变成类似 Java 中的静态方法。

5. 偏函数
以一张简图展示：

偏函数.png

6. To myself
Need to practice more .