跳到主要内容

函数与高阶函数

信息
2024年8月10日 · ·

1. 函数

函数是一种重复代码的抽象方式,Python 内建支持的一种封装;

调用函数

调用一个函数,需要知道函数的名称和参数;函数名是只想一个函数对象的引用

>>> a = abs
>>> a(-1)
1

可以在交互式命令行通过 help(abs) 查看 abs 函数的帮助信息;

数据类型转换

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

开平方

# 方法一
>>> import math
>>> math.sqrt(100)
10.0

# 方法二
>>> pow(100, 0.5)
10.0

# 方法三
>>> 100 ** 0.5
10.0

定义函数

定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用 return 语句返回。

如果没有 return 语句,函数执行完毕后也会返回结果,只是结果为 None。return None 可以简写为 return。

空函数

定义一个什么事也不做的空函数,可以用 pass 来作为占位符

参数检查

调用函数时,如果参数个数不对,Python 解释器会自动检查出来,并抛出 TypeError

返回多个值

Python 的函数返回多值其实就是返回一个 tuple;在语法上,返回一个 tuple 可以省略括号,而多个变量可以同时接收一个 tuple,按位置赋给对应的值

函数的参数

参数类型说明
位置参数def power(x, n): 传入的值依次赋给对应位置的参数
默认参数def power(x, n=2): 在调用时可以不用输入该位置的参数,而直接使用默认值;变化大的参数放在前,变化小的放在后作为默认参数,降低调用难度;调用含多个默认参数的函数时,可以写上参数名;如调用 def enroll(name, gender, age=6, city='Beiging'): 可以用enroll('Adam', 'M', city='Tianjin')
可变参数def calc(*numbers): 传入的参数个数时可变的,在参数前面加 1 个 * 号,参数接收到的将是一个 tuple;在 tuple/list 前加 1 个 *,可以将其以可变参数传入函数 calc(*[1,2,3])
关键字参数def person(name, age, **kw): 同理可变参数,在参数前面加 2 个_号,允许传入 0 个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict;在 dict前加 2 个_ 可以将其以关键字参数传入函数 person(name, age, **kw)
命名关键字参数def person(name, age, *, city, job): 如果要限制关键字参数的名字,可以用命名关键字参数;命名参数需要以 * 分隔,其后视为命名关键字参数,如果函数定义了一个可变参数,可以不要 *,命名关键字参数可以给默认值

默认参数必须只想不可变对象 不可变对象减少了由于修改数据导致的错误,多任务环境同时读取不需加锁

# 错误写法
>>> def add_end(L=[]):
... L.append('End')
... return L
...
>>> add_end()
['End']
>>> add_end()
['End', 'End']

参数组合

顺序:必选参数 > 默认参数 > 可变参数 > 命名关键字参数 > 关键字参数

递归函数

一个函数在内部调用自己本身,就叫递归函数

函数调用是通过栈实现的,每进入一个函数调用,加一层栈锁,过多时会栈溢出

尾递归

把每一步的结果传递给递归函数,和循环的效果一样,栈不会增加;python 解释器没有对尾递归做优化,会栈溢出

汉诺塔

def move(n, a, b, c):
if n == 1:
print(a, '->', c)
else:
move(n-1, a, c, b)
move(1, a, b, c)
move(n-1, b, a, c)

2. 高阶函数

Higher-order function

变量可以指向函数 and 函数名也是变量 -> 函数可以接收另一个函数作为参数

其参数能够接收别的函数的函数,就是高阶函数

map/reduce

map()

接收两个参数,一个是函数(单个参数),一个是 Iterable 对象,map 将传入的函数依次作用在 Iterable 对象的每一个元素上,并把结果作为一个新的 Iterator 返回,注意 Iterator 是惰性的

>>> list(map(str, [1, 2, 3, 4, 5]))
['1', '2', '3', '4', '5']

reduce()

把一个函数(必须是两个参数)作用在一个序列上,reduce 把结果与下个元素做累计计算

reuce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
# str2int
from functools import reduce

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


def char2num(c):
return DIGITS[c]


def str2int(s):
return reduce(lambda x1, x2: x1 * 10 + x2, map(char2num, s))
# str2float
from functools import reduce

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


def char2num(c):
return DIGITS[c]


def str2int(s):
return reduce(lambda x1, x2: x1 * 10 + x2,
map(char2num, [c for c in s if c != '.']))


def str2float(s):
return str2int(s) / (10**s[::-1].index('.'))
# str2float
def str2float(s):
point = 0

def to_float(i, c):
nonlocal point
if not isinstance(c, int):
point = 1
return i
if point == 0:
return i * 10 + c
else:
point *= 10
return i + c / point

return reduce(to_float, map(char2num, s))

nonlocal 关键字用来在函数或其他作用域使用外层(非全局)变量

filter

接收一个函数(单个参数)和一个序列,序列的每个元素作用于函数,返回 True/False 决定是否保留该元素

素数 - 埃氏筛选

def _odd_iter():
n = 1
while True:
n += 2
yield n


def _not_divisible(n):
return lambda x: x % n > 0


def primes():
yield 2
oi = _odd_iter()
while True:
n = next(oi)
yield n
oi = filter(_not_divisible(n), oi)

sorted

接收一个 Iterable 对象,一个函数(形参:key,一个参数的函数),以及 reverse;key 作用与序列的每个元素,再对结果排序,reverse 表示是否反向排序,默认为 False

3. 函数式编程

面向过程程序设计

通过一层一层的函数调用,把复杂的任务分解成简单任务,这种分解称之为面向过程的程序设计,函数是面向过程编程的基本单元

Functional Programming

一种抽象程度很高的编程范式,纯粹的函数式编程语言(Lisp)编写的函数没有变量,只要输入确定,输出就是确定的(没有副作用)。允许使用变量的函数内部变量状态不确定,同样输入可能输出不同

Python 对函数式编程提供部分支持,其允许使用变量,不是纯函数式编程语言

返回函数

函数作为返回值 往往不需要立即执行的时候,可以使用返回函数的方式达到惰性计算的效果(lazy

闭包(Closure) 当返回函数时,相关参数和变量都保存在返回的函数中,这种程序结构成为闭包

def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs

f1, f2, f3 = count()
>>> f1()
9
>>> f2()
9
>>> f3()
9

返回的函数引用了变量 i,但它并没有立刻执行,等到 3 个函数都返回时,它们引用的变量 i 已经变成了 3,因此最终结果都是 9

返回闭包时,返回函数不要引用任何循环变量,或者后续会发生变化的变量

def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
# f(i) 立即执行,因此 i 的当前值被传入 f()
fs.append(f(i))
return fs
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

添加多层函数,用执行外层函数将循环变量的值绑定到函数的参数中,可以绑定循环变量变化过程中的值

计数器(闭包)

def createCounter():
def counter():
n = 0
while True:
n += 1
yield n
c = counter()
return lambda : next(c)
def createCounter():
n = 0
def counter():
nonlocal n
n += 1
return n
return counter

匿名函数

关键字 lambda 表示匿名函数,冒号前面的是参数表,冒号后面的是返回结果,不用写 return,只能有一个表达式

匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数

>>> f = lambda x: x*x
>>> f(5)
25

也可以把匿名函数当作一个函数的返回值返回

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

装饰器

Decorator

在函数调用前后自动增加处理,不修改函数的定义,这种在代码运行期间动态增加功能的方式,即为 Decorator

import functools


def log(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f'call {func.__name__}():')
return func(*args, **kwargs)

return wrapper
def log(info):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f'{info} {func.__name__}')
return func(*args, **kwargs)

return wrapper

return decorator

调用 Decorator

@log
def now():
print('2020-11-12')
now = log(now)
@log('execute')
def now():
print('2020-11-12')
now = log('execute')(now)

functools.wraps(func) 的作用是将 wrapper 函数的 __name__ 改为被装饰函数对象的 __name__, 相当于:

wrapper.__name__ = func.__name__

Decorator 即在 面向对象(OOP)设计模式 中的 装饰模式,OOP 的装饰模式通过类的继承和组合实现,而 Python 可以直接从语法层面支持 decorator,也可以通过类实现

偏函数

Partial function

把一个函数的某些参数固定住(给这些参数设置默认值),返回一个新函数,以方便调用

偏函数仅仅是给参数设定了默认值,在调用新函数时是可以传入其他值给这些参数的

import functools
# 相当于
# kw = {'base': 2}
# int('1000000', **kw)
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1000000', base=10)
1000000
# 相当于
# args = [10]
# args.extend([5, 6, 7])
# max(*args)
>>> max2 = functools.partial(max, 10)
>>> max2(5, 6, 7)
10

创建偏函数时,实际接收的参数是:函数对象,*args、**kwargs;


PS:感谢每一位志同道合者的阅读,欢迎关注、评论、赞!