张新科

张新科

一名纯粹的软件开发者。

Python-函数

1 minute read

Published:

函数

函数变量作用域

Python 函数中变量的作用域和其他语言类似。如果变量是在函数内部定义的，就称为局部变量，只在函数内部有效。一旦函数执行完毕，局部变量就会被回收，无法访问。

全局变量则是定义在整个文件层次上的，比如下面这段代码：

MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
if value < MIN_VALUE or value > MAX_VALUE:
raise Exception('validation check fails')

这里的 MIN_VALUE 和 MAX_VALUE 就是全局变量，可以在文件内的任何地方被访问，当然在函数内部也是可以的。不过，我们不能在函数内部随意改变全局变量的值,所以，如果我们一定要在函数内部改变全局变量的值，就必须加上 global 这个声明比如，下面的写法就是错误的：

MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
...
MIN_VALUE += 1
...
validation_check(5)

UnboundLocalError: local variable ‘MIN_VALUE’ referenced before assignment

所以，如果我们一定要在函数内部改变全局变量的值，就必须加上 global 这个声明

闭包

闭包其实和嵌套函数类似，不同的是，这里外部函数返回的是一个函数，而不是一个具体的值。返回的函数通常赋于一个变量，这个变量可以在后面被继续执行调用。

def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是 exponent_of 函数
square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
square
# 输出
<function __main__.nth_power.<locals>.exponent(base)>

cube
# 输出
<function __main__.nth_power.<locals>.exponent(base)>

print(square(2)) # 计算 2 的平方
print(cube(2)) # 计算 2 的立方
# 输出
4 # 2^2
8 # 2^3

这里外部函数 nth_power() 返回值，是函数 exponent_of()，而不是一个具体的数值。需要注意的是，在执行完square = nth_power(2)和cube = nth_power(3)后，外部函数 nth_power() 的参数 exponent，仍然会被内部函数 exponent_of() 记住。这样，之后我们调用 square(2) 或者 cube(2) 时，程序就能顺利地输出结果，而不会报错说参数exponent 没有定义了。

匿名函数

lambda 是一个表达式（expression），并不是一个语句（statement）.

square = lambda x: x**2
square(3)

9

函数式编程

所谓函数式编程，是指代码中每一块都是不可变的（immutable），都由纯函数（purefunction）的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

让列表中的元素值都变为原来的两倍，非函数式编程：

def multiply_2(l):
    for index in range(0, len(l)):
        l[index] *= 2
    return l

函数式编程：

def multiply_2_pure(l):
    new_list = []
    for item in l:
        new_list.append(item * 2)
    return new_list

函数式编程的特性：

  • 优点:主要在于其纯函数和不可变的特性使程序更加健壮，易于调试（debug）和测试；
  • 缺点:主要在于限制多，难写。当然，Python 不同于一些语言（比如Scala），它并不是一门函数式编程语言，不过，Python 也提供了一些函数式编程的特性，值得我们了解和学习。

Python 主要提供了这么几个函数：map()、filter() 和 reduce()，通常结合匿名函数lambda 一起使用。

  1. map(function, iterable) 函数：对 iterable 中的每个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合。
  2. filter(function, iterable) 函数：它和 map 函数类似，function 同样表示一个函数对象。filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，并返回True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合。
  3. reduce(function, iterable) 函数：它通常用来对一个集合做一些累积操作。参数function 同样是一个函数对象，规定它有两个参数，表示对 iterable 中的每个元素以及上一次调用后的结果，运用 function 进行计算，所以最后返回的是一个单独的数值。
#map实例
l = [1, 2, 3, 4, 5]
new_list = map(lambda x: x * 2, l) # [2， 4， 6， 8， 10]
#filter实例
l = [1, 2, 3, 4, 5]
new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]
#reduce实例
l = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120

迭代器 生成器 装饰器

  • 容器是可迭代对象，可迭代对象调用 iter() 函数，可以得 到一个迭代器。迭代器可以通过 next() 函数来得到下一 个元素，从而支持遍历。
  • 生成器是一种特殊的迭代器（注意这个逻辑关系反之不成 立）。使用生成器，你可以写出来更加清晰的代码；合理使用生成器，可以降低内存占用、优化程序结构、提高程序速度。

装饰器

def my_decorator(func):
	def wrapper():
		print('wrapper of decorator')
		func()
	return wrapper

def greet():
	print('hello world')

greet = my_decorator(greet)
greet()

# 输出
wrapper of decorator
hello world

这里的函数 my_decorator() 就是一个装饰器，它把真正需 要执行的函数 greet() 包裹在其中，并且改变了它的行为，但是原函数 greet() 不变。

简洁模式

def my_decorator(func):
	def wrapper():
		print('wrapper of decorator')
		func()
	return wrapper
@my_decorator
def greet():
	print('hello world')

greet()