python - 函数

标准写法

定义一个函数，函数名叫 summary()，

• 函数有两个参数：a 和 b，a 的默认值为 1 ，b 的默认值为 2；
• :int 指定参数为 int 类型（注解）；
• -> int 指定返回值为 int（注解）;
• r""" """是标准的函数注释；
• 要是空函数，还没想好功能，用 pass 进行占位

def summary(a: int = 1, b: int = 2) -> int:
    r"""
    加法运算
    :param a: 加数
    :param b: 加数
    :return: 和
    """

    return a + b
    pass


print(summary(1))

注意：注解只是起到提示作用，即便代码出现很明显的类型错误，也是可以执行的；

比如下面这行代码，给了个字符串参数，代码只是会出现警告，但是可以执行。

print(summary('1'))

注解的作用：除了代码警告之外，对于后期的代码分析，也会更加友好一些。

# 打印一个函数的参数类型和返回值类型
print(add.__annotations__) 

可变参数

允许是任意多个参数（0-n），参数传至函数内部的时候，数据被装到元组中。

def summary(*arr):
    # arr 是一个元组
    print(sum(arr))


print(summary(1,2,3))

关键参数

与可变参数类似。

允许是任意多个参数（0-n），参数传至函数内部的时候，数据被装到字典中。

def summary(**arr):
    # arr 是一个字典
    print(arr)


print(summary(a=1,b=2,c=3))

递归

def factorial(n):
    return 1 if n <= 1 else n*factorial(n-1)
    pass


print(factorial(3))

print('hello world!!')

变量作用域

跟 java 一致，优先使用离自己最近的变量，先使用局部的变量，再使用全局的。

# 有个全局的变量 a = 3
a = 3


def m1(a):
    # 优先使用参数 a
    print(a)
    pass


def m2():
	# 这个函数内部没有参数 a，所有要使用全局的变量
    print(a)
    pass

m1(6)
m2()

global关键字

写一段奇怪的代码，猜一猜输出 a 的结果是啥？

a = 3


def add():
    a = 2


add()

print(a)

为什么说这段代码很奇怪？

python 是没有字段声明的，因此 a = 2 有两种可能性：

• 可能 a 已经有值，重新赋值成了 2；
• 也有可能是，重新声明了一个 a，令其值为 2。

上述代码的输出结果是 3，add()函数内部，又声明了一个局部变量 a。
如果希望 add() 函数对 a 重新赋值，则需要用到 global 关键字。

global用法

1. 引用父级作用域的变量，比如：下面代码中的 a；
2. 声明一个全局变量，比如：下面代码中的 b；
3. 逐层向上查找，父级没有，就找父级的父级；

a = 3


def add():
    global a
    a += 2
    global b
    b = None


add()

print(a)
print(b)

闭包（函数嵌套）

闭包和面向对象，概念存在一定的重合，暂时没有其它特别妙的应用场景；

可能在 lambda 表达式上，或者封装特别复杂的函数，会有一些妙用。

案例

def math(x, o, y):
    def add(a, b):
        return a + b

    def sub(a, b):
        return a + b

    operator = {'add': add, 'sub': sub}
    return operator.get(o)(x, y)


print(math(1, 'add', 2))

nonlocal的用法

已知闭包就是一个函数，使用 global 时，会产生一种代码歧义，比如下面这个代码，

只给你看一部分，我们看不出 global 引用的变量，是闭包外的（全局），还是闭包内。

def counter(x):

    def add(b):
        global ret
        ret += b
        return ret

    return add

nonlocal 主要用于闭包和嵌套函数中，重新绑定局部作用域以外的变量‌。

逐层向上寻找变量，父级函数没有，就找父级的父级；但是不包含全局的，全局的仍然使用 global。

def counter(x):
    ret = x

    def add(b):
        nonlocal ret
        ret += b
        return ret

    return add


print(counter(3)(4))