定义
>>> def add(a, b):
... return a + b
# f.py
def f(param):
print(param)
if __name__ == '__main__':
f('Hello Python Function')
# RUN
bovenson@ThinkCentre:~/Git/notes/Python/Code/LearnPythonCode/function$ python3 f.py
Hello Python Function
嵌套
# nest.py
def f(param):
def inner(parami):
print('Inner: ', parami)
print(param)
inner('HI')
if __name__ == '__main__':
f('Hello Python Function')
# f.inner('Hello Inner') # ERROR: AttributeError: 'function' object has no attribute 'inner'
bovenson@ThinkCentre:~/Git/notes/Python/Code/LearnPythonCode/function$ python3 nest.py
Hello Python Function
Inner: HI
调用
传参
可使用的正式参数类型：
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
#!/usr/bin/python3
#可写函数说明
def printme( str ):
"打印任何传入的字符串"
print (str)
return
#调用printme函数
printme()
# 输出
Traceback (most recent call last):
File "test.py", line 10, in <module>
printme()
TypeError: printme() missing 1 required positional argument: 'str'
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，Python 解释器能够用参数名匹配参数值。
#!/usr/bin/python3
#可写函数说明
def printme( str ):
"打印任何传入的字符串"
print (str)
return
#调用printme函数
printme( str = "菜鸟教程")
# 输出
菜鸟教程
不定长参数
可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
>>> def f(p, *arg_tuple, **arg_dict):
... print('p: ', p)
... print('arg tuple: ', arg_tuple)
... print('arg dict : ', arg_dict)
...
>>> f(1, 2, 3, a=4, b=5)
p: 1
arg tuple: (2, 3)
arg dict : {'b': 5, 'a': 4}
匿名函数
语法
lambda [arg1 [,arg2,.....argn]]:expression
示例
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
# 输出
相加后的值为 : 30
相加后的值为 : 40
变量作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
x = int(2.9) # 内建作用域
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：
>>> if True:
... msg = 'I am from Runoob'
...
>>> msg # msg 变量定义在 if 语句块中，但外部还是可以访问的
'I am from Runoob'
>>>
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中
#!/usr/bin/python3
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
# 输出
函数内是局部变量 : 30
函数外是全局变量 : 0
global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
修改全局变量 num：
#!/usr/bin/python3
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)
# 输出
1
123
123
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字：
#!/usr/bin/python3
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
# 输出
100
100
# 1
>>> a = 10
>>> def fa():
... print(a)
...
>>> fa()
10
# 2
>>> def fb():
... a = a + 1
... print(a)
...
>>> fb()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in fb
UnboundLocalError: local variable 'a' referenced before assignment
# 3
>>> def fc(a):
... a = a + 1
... print(a)
...
>>> fc(a)
11
# 4
>>> def fd():
... global a
... print(a)
...
>>> fd()
10
# 5
>>> def fe():
... global a
... a = a + 1
... print(a)
...
>>> fe()
11
# 6
>>> def ff():
... nonlocal a
... print(a)
...
File "<stdin>", line 2
SyntaxError: no binding for nonlocal 'a' found