函数(参数，作用域，返回函数，匿名函数，偏函数)

函数参数：

python 中的函数参数类型有 必须参数，关键字参数，默认参数，可变参数，组合参数

 

必须参数 

即形参和实参按照顺序一一对应

 

关键字参数 

函数调用使用关键字确定传入的参数值，允许实参和形参的顺序不一致，因为 python 解释器能够用参数名匹配参数值

代码：

#!/usr/bin/python3

def personinfo(age, name):
    print('年龄：', age)
    print('名称：', name)
    return

personinfo(21, '小萌')
print('-------------------')
personinfo(name = '小萌', age = 21)
print('-------------------')
personinfo(age = 21, name = '小萌')

 

默认参数

和 c++ 中一致

若要更改某一个默认参数值，又不想传入其它默认参数，且该默认参数的位置不是第一个，则可以通过参数名更改想要更改的默认参数值

代码：

#!/usr/bin/python3

def gel(a = 1, b = 2, c = 3):
    print(a, b, c)
    return

gel()
gel(10)
gel(b = 10)

'''
输出：
1 2 3
10 2 3
1 10 3
'''

 

可变参数

加了 * 的变量名会存放所有未命名的变量参数。如果变量参数再函数调用时没有指定参数，就是一个空元组。

代码：

#!/usr/bin/python3

def personinfo(arg, *var):
    print(arg)
    for indx in var:
        print(indx, end = ' ')
    print()
    return

personinfo(2, 'fd', 'aa')

 

用 ** 处理可变的关键字参数：

other = {'city' : 'beijing', 'hoby' : 'coding'}

def personinfo(name, number, **kw):
    print('名称：', name, '学号: ', number, '其它：', kw)

personinfo('gel', 3366, city = other['city'], hoby = other['hoby'])
personinfo('gel', 3366, **other)#等效于上一条语句

 

组合参数

在编程中上述四种参数可以组合使用。注意定义参数的顺序是必须参数、默认参数、可变参数和关键字参数

代码：

#!/usr/bin/python3

def exp(p1, p2, df = 0, *vart, **kw):
    print(p1, p2, df, vart, kw)

exp(1, 2)
exp(1, 2, c = 3)
exp(1, 2, 3, 'a', 'b')
exp(1, 2, 3, 'abc', x = 9)

# 输出：
# 1 2 0 () {}
# 1 2 0 () {'c': 3}
# 1 2 3 ('a', 'b') {}
# 1 2 3 ('abc',) {'x': 9}

 

变量作用域：

局部变量

和c++中一致，局部变量只能在定义它的函数中使用

 

全局变量

在函数体内可以直接使用全局变量，但在函数体中更改变量的值并不会更改全局变量的值。这是因为调用函数时创建了新的命名空间，它作用于该函数代码块。

代码：

#!/usr/bin/python3

x = 50
def func(x):
    print('全局x=', x)
    x = 2
    print('局部x=', x)

func(x)
print('全局x=', x)

输出：
全局x= 50
局部x= 2
全局x= 50

注意：函数中使用某个变量时，如果该变量名既有全局变量又有局部变量，默认使用局部变量的值

 

要在函数中修改全局变量的值需要使用 global 关键字

代码：

#!/usr/bin/python3

x = 50
def func():
    global x
    x = 2
    print('局部x=', x)

func()
print('全局x=', x)

# 输出：
# 局部x= 2
# 全局x= 2

注意：不能对形参使用 global 关键字

global 声明必须在函数中对应参数使用之前

 

返回函数：

代码：

#!/usr/bin/python3

def sum_late(*args):
    def calc_sum():
        ax = 0
        for n in args:
            ax += n
        return ax
    return calc_sum

print(sum_late(1, 2, 3, 4))#输出对应的函数地址
calc_sum = sum_late(1, 2, 3, 4)
print(calc_sum())

#每次调用都会返回一个新的函数，即使传入相同的参数也是如此
f1 = sum_late(1, 2, 3)
f2 = sum_late(1, 2, 3)
print('if f1 == f2?', f1 == f2)

# 输出：
# <function sum_late.<locals>.calc_sum at 0x05804108>
# 10
# if f1 == f2? False

注意：每次调用都会返回一个新的函数，即使传入相同的参数也是如此

 

闭包

如果在一个内部函数里对外部函数(不是在全局作用域)的变量进行引用，内部函数就被认为是闭包

注意：返回闭包时，返回函数不要引用任何循环变量或后继会发生变化的变量，否则很容出错：

#!/usr/bin/python3

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

f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())

#输出并不是我们预期的1, 4, 9
# 输出：
# 9
# 9
# 9

显然，上面出错的原因是加入 fs 后的函数并没有立即离开 for 循环(i 的作用域)，因此会收到 i 的后续影响。

要修改使其正确的话我们可以再套一个函数隔开 i 的作用域即可：

#!/usr/bin/python3

def count():
    def f(x):
        def g():
            return x * x
        return g

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

f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())

# 输出：
# 1
# 4
# 9

 

匿名函数：

lambda 函数拥有自己的命名空间，不能访问自有参数列表之外或全局命名空间的参数

lambda 函数的语法只包含一个语句

python 中 lambda 不能有 return 语句，但其实 : 后面部分即为返回值，：之前部分可以看作是参数，且可以只用默认值

两个数求和：

#!/usr/bin/python3

sum = lambda x, y : x + y
print(sum(1, 2))
print(sum(2, 3))
# 输出：
# 3
# 5

 

和 filter 一起使用：

def func(x):
    return x > 3

l1 = [1, 2, 3, 4, 5]

f_list = filter(func, l1)
print([item for item in f_list])

print([item for item in filter(lambda x : x > 3, l1)])

# 输出：
# [4, 5]
# [4, 5]

python3 开始 filter 返回迭代器(之前是返回列表)

如果需要将迭代器改成列表可以：

filter_list = [item for item in a_file_object]

 

偏函数：

类似于 c++ bind 的一个东西：http://www.cnblogs.com/geloutingyu/p/8335230.html

#!/usr/bin/python3

from functools import partial

def mod(n, m):
    return n % m

mod_by_100 = partial(mod, 100)

print(mod(100, 7))
print(mod_by_100(7))
# 输出：
# 2
# 2