函数

定义

>>> 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

调用

>>> add(1, 1)
2

传参

可使用的正式参数类型：

必需参数

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

#!/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}

匿名函数

python 使用 lambda 来创建匿名函数

语法

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 （Local）局部作用域
E （Enclosing）闭包函数外的函数中
G （Global）全局作用域
B （Built-in）内建作用域

以 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

最后更新于5年前

这有帮助吗？