本篇主要讲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
列举常用的一些数据类型转换方法：
函数参数
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() 时，都会返回一个新的不等的函数，即使传入相同的参数。
这里简单说明下闭包：
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. 偏函数
以一张简图展示：
6. To myself
Need to practice more .
