python控制流和函数参数、匿名函数和闭包

@[toc]

函数的参数传递

不可变类型传值

如数、字符串、元组

def fa(a):
    a = 100
    print(hex(id(a)))
    print(hex(id(100)))

a = 10
print(hex(id(a)))
print(hex(id(100)))
fa(a)
print(hex(id(a)))
print(hex(id(100)))
import os

0x7ff9798a2850
0x7ff9798a3390
0x7ff9798a3390
0x7ff9798a3390
0x7ff9798a2850
0x7ff9798a3390
#在函数内部a的副本修改为100，a本身没有被修改

可变类型传引用

如列表、字典、集合

def fc(a):
    a.append(100)
    print(hex(id(a)))
l = [1,2,3]
print(l)
print(hex(id(l)))
fc(l)
print(l)

[1, 2, 3]
0x1a847acd180
0x1a847acd180
[1, 2, 3, 100]

参数类型

必须参数

必须以正确的顺序传入函数
调用时数量必须和声明时一样

关键字参数

使用关键字参数来确定传入的参数值
关键字的参数应跟随在位置参数后
允许函数调用时参数的顺序与声明时不一致

def fun(name,key):
    pass
fun(key = 'lambda x:x[1]',name='test')

默认参数

调用函数时，如果没有指定参数，则会使用默认值

默认值只被赋值一次，这使得当默认值是可变对象时会有所不同，即默认值在后续调用中会累积。

def f(a,L=[]):
    print(hex(id(L)))
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))

0x1a847b0e200
[1]
0x1a847b0e200
[1, 2]
0x1a847b0e200
[1, 2, 3]

避免累积的方法

def f(a,L=None):
    if L is None:
        L = []
    print(hex(id(L)))
    L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))

0x1a847acb280
[1]
0x1a8486fae80
[2]
0x1a847b09f00
[3]

不定长参数

需要一个函数能够处理比声明时更多的参数，且声明时不需要命名

加*的参数会以元组(tuple)的形式导入，存放所有未命名的参数变量

def ptest(arg1,*vartuple):
    print(arg1)
    print(vartuple)
ptest(70,'test',50)

70
('test', 50)

加**的参数会以字典的形式导入

def ptest2(arg1,**vardict):
    print(arg1)
    print(vardict)
ptest2(10,a=2,b=4)

10
{'a': 2, 'b': 4}

• 通常这些可变参数是参数列表中的最后一个

• 任何出现在不定长参数的后面的参数只能是关键字参数，不能是位置有关参数

参数列表的分拆

args = [3,6]
print(*args)
print(list(range(*args)))

3 6
[3, 4, 5]

d = {'name':'zjc','age':36,'job':'prof.'}
def printInfo(name,age,job):
    print("Name:{0}\tAge:{1}\tJob:{2}".format(name,age,job))
printInfo(**d)

Name:zjc    Age:36  Job:prof.

匿名函数

lambda只是一个表达式，函数体比def简单很多

• lambda的主体是一个表达式，而不是一个代码块
• 仅仅能在lambda表达式中封装有限的逻辑
• 简单形式下只能使用内部变量
• 普通函数定义中的一个语法技巧

sum = lambda arg1,arg2:arg1 + arg2
print(sum(1,2))

3

return语句

用于退出函数，选择性地向调用方返回一个表
达式

• 不带参数的return语句返回None
• 没有return语句自动返回None

嵌套函数

def make_incrementor(n):
    return lambda x:x+n
f = make_incrementor(1)
print(f(0))

1

闭包

• 在一个外函数中定义了一个内函数，内函数里
  运用了外函数的变量，并且外函数的返回值是
  对内函数的引用
• 闭包变量实际上只有一份，每次开启内函数时
  都在使用同一份闭包变量
• 装饰器

def outer(x):
    def inner(y):
        nonlocal x
        x += y
        return x
    return inner

f1 = outer(10)
print(f1)
print(f1(1))
print(f1(2))
print(outer(10)(1))
print(outer(10)(2))

<function outer.<locals>.inner at 0x000001A848708160>
11
13
11
12