定义函数

定义函数用def语句,格式：def 函数名(自变量) ：函数名称的定义规则和变量定义规则相同。在缩进板块中编写函数体，最后用return返回一个值。

求n的阶乘

def f(x) :
    """
    计算阶乘

    :param x: 一个非负整数

    :return: x的阶乘
    """
    y = 1
    for n in range(1, x + 1) :
        y *= n
    # return表示返回一个值，同时结束此函数
    return y

注意：函数内部一旦执行到return，该函数就会停止执行，并将结果返回。如果没有return语句，函数执行完毕就会停止，返回的是一个空值none。

求最大公约数

def gcd(x, y):
    """
    计算两个数的最大公约数

    :param x: 一个非负整数
    :param y: 一个非负整数

    :return: x,y的最大公约数
    """
    (x, y) = (y ,x) if x > y else (x, y)
    for factor in range(x, 0, -1):
        if x % factor == 0 and y % factor == 0:
            return factor

判断素数

def is_prime(x):
    """
    判断素数

    Parameters:
        x - 一个非负整数
        y - 一个非负整数

    Returns:
         如果num是素数返回True,反之返回False
    """
    for num in range (2,int(sqrt(x)) + 1):
        if x % num == 0:
            return False
    # return True
    # 排除1的写法：
    return True if x != 1 else False

• 函数自变量的四种定义方式：

1.不设定自变量

def main():
    pass

2.自变量为确定个数的参数，如上面的is_prime函数，自变量为1个，即x；gcd函数，自变量为2个，即x，y
3.自变量为不确定的参数
如下举例说明：
在参数数量不确定的情况下，求多个数的和
利用*args 定义可变参数：*args 参数数量不确定，可为0个，也可为多个。在调用函数add时，输入的自变量为多少个，函数就求多少个数的和。

def add(*args):
    """
    参数数量不确定的情况下，求多个数的和

    :param argus:
        *args 定义可变参数：*args 参数数量不确定，可为0个，也可为多个

    :return: 多个参数的和
    """
    total = 0
    for value in args:
        total += value
    return total


if __name__ == '__main__':
   # 直接传入可变参数
   # 求的是1+3+2+2+2+2的和
    print(add(1,3,2,2,2,2))
   # 传入列表，求列表中各个元素的和
    mylist = [1, 3, 5, 2, 10]
   # 如果传入的直接就是一个列表，必须在列表前面加上*，才能取到列表中各个元素，否则会被视为只传入了一个值，即列表
    print(add(*mylist))

4.自变量设定了默认值
定义摇n个色子，求每次色子点数之和的函数,假设我们给自变量一个默认值，可设置为“n=2”格式，如下：

def roll_dice(n=2):
    total = 0
    for _ in range (n) :
        total += randint(1, 6)
    return total

if __name__ == '__main__':
    # 调用函数，但未定义自变量，自变量取默认值2
    roll_dice()
    # 调用函数，定义自变量的值为3
    roll_dice(3)

注意：在定义函数自变量时，官方建议不要用空格，如定义自变量为n，并给n赋一个默认值2，官方建议的书写格式为：n=2，而不是n = 2。但在其他情况下，官方建议的书写格式为：n = 2。

---

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句。pass语句的意义：什么都不做，实际上是用来做占位符。比如现在还没有想好怎么写函数的代码，就可以先放一个pass，程序可以顺利运行。
举例说明：

def nop():
    pass

pass还可以放在其他语句中，如：

if x<1:
    pass

---

函数的调用

一个文件就是一个模块，一个模块中可能有1个或任意多个函数

• 当前模块中调用函数

调用函数时，若函数就在当前文本，则可以直接进行调用。格式为：函数名(变量)。由于很多时候这一个函数会被其他文本调用，为了让其他文本在调用此函数时不执行其他的代码，可以使用下面的if条件语句，让其他文本在导入此模块时不执行下面的代码，原理：只有本文件执行时，name = main，当其他文件执行时，name = 这个文件的命名，则name ！= main，if条件不成立，代码不执行。

• 其他模块调用函数

若当前文本需要调用其他文本的函数，则需要引入调用的函数模块。
1.同一跟目录下的两个文本函数之间调用：from 要调用的函数所在文本的名称 import 函数名称
2.不同根目录下的两个文本函数直接的调用：from 要调用的函数所在文本的路径（如day01.practice.prime，表示day01包下面的practice包下面的prime文本）import 函数名称
3.一个文本可能存在多个函数，若需要调用此文本的所有函数，可写作如下格式：import combination * 导入combination中所有模块

#导入 combination文件中所有模块
import combination *

4.直接引入函数所在文本，每次调用时再输入：文件名.函数名称。若原本的文件名太过复杂，还可临时给他命一个新的名字（别名）：import combination as com 此处把combination命为com，在调用时，写作com.f

import combination 
#调用cobination的f(x)函数
print(com.f(5))

• 实例说明

1.直接调用输出内容

打印100以内的素数：

if __name__ == '__main__':
    for num in range(1,100):
        # 当is_prime(num)函数返回的值为True时，if条件语句才会执行
        if is_prime(num):
            print(num)

调用求阶乘函数：f(x)，求组合数C(m, n)

    m = int(input('m = '))
    n = int(input('n = '))
    # 调用函数f(x)
    print(f(m) // f(n) // f(m - n))

2.调用函数构造新的函数

求最小公倍数，lcm函数调用cgd函数

def lcm(x,y):
    """
    计算两个数的最小公倍数

    Parameters:
        x - 一个非负整数
        y - 一个非负整数

    Returns:
        x,y的最小公倍数
    """
    return x * y // gcd(x, y)

3.函数的递归调用

函数的递归调用指的是函数直接或间接调用函数自身，构造这样的递归函数必须满足以下几点：
1.收敛条件 - 让递归在有限的次数完成或者进行回溯
2.如果递归无法在有限次数内收敛就有可能导致RecursionError，而且栈的空间很小，必须控制此函数的递归深度在栈的递归深度内。
3.递归公式
在进入函数调用之前要保存当前的执行现场,函数的执行现场是保存在一种称为栈（stack）的内存空间上，栈是一种先进后出（FILO）的存储结构。所以函数在做递归调用时，会一层一层向下递归，最后在一层一层回溯。

求最大公约数

def gcd(x, y):
    if x > y:
        return gcd(y, x)
    elif y % x == 0:
        return x
    else:
        return gcd(y % x, x)

求1到100的和

def add(n):
    if n == 1 :
        return 1
    return n + add(n - 1)

计算走楼梯有多少种方式

10级楼梯，1次可选择1，2，3层台阶，走完这10层台阶，问有多少种走法

def way(n):
    if n < 0:
        return 0
    elif n == 0:
        return 1
    return way(n - 1) + way(n - 2) + way(n - 3)

汉诺塔

def hanoi(n, a, b, c):
    if n > 0:
        hanoi(n - 1, a, c, b)
        print(a,'---->', b)
        hanoi(n - 1, c, b, a)

---

函数命名冲突

当有多个函数命名冲突时，后面的函数自动覆盖前面相同名称的函数。

• 自己设定的函数和python内置的函数冲突：

如自己编写了一个求最大公约数的函数gcd，和math中的内置的gcd函数冲突

from combination import gcd,
from math import gcd

调用gcd函数时，如果直接书写gcd()，文本会自动调用写在后面的那个函数，如上就会调用math中的gcd，为了避免这种情况，可以按照以下方式调用：

# 方法一
import combination
import math

print(math.gcd())
print(combination.gcd())

# 方法二
from combination import gcd
# 调用的是conbinaion中的gcd函数
print(gcd())
from math import gcd
# 调用的是math中的gcd函数
print(gcd())

函数变量的作用域

变量的作用域有三种：
1.全局（global）作用域的变量：定义在函数外部的变量，此变量可在全局范围内被调用
2.嵌套（enclosed）作用域的变量：当一个函数调用另一个函数时，定义在外层函数中的变量，此变量可被内外层函数调用
3.局部（local）作用域：当一个函数嵌套在另一个函数内部时，定义在内层函数中的变量，此变量只能被内层函数调用
4.内置（build-in）作用域
Python 搜索一个变量的方式是从局部作用域到嵌套作用域再到全局作用域，如果都没有搜索到，则会搜索内置函数，简称为LEGB（Local - Enclosed - Global - Build-in），如果想改变搜索范围，可以使用global和nonlocal关键字改变变量的作用域。
举例说明：

# 在函数外面定义的a是一个全局变量
# 实际开发时一定要减少对全局变量的使用
# global variable
a = 100


def foo():
    # 把foo函数内的变量a改为全局变量，这时如果在函数外调用a，当搜索到此处的a = 200时，原本变量a不能在函数外被调用，但此处变量a改为了全局变量，则能被函数外的代码调用
    global a
    a = 200
    # local variable
    # 函数内部的局部变量 离开foo函数变量是无法访问的
    b = 'hello'

    def bar():
        # 把局部作用域bar中的变量b改为嵌套作用域foo中的局部变量b，这时如果在foo中调用b，则搜索到的是b = 'good'，而不是之前的b = 'hello'
        nonlocal b
        b = 'good'
        print(a)
        print(b)

    bar()
    print(b)


# foo()函数运行结果：200 good good
foo()
# 运行结果：200
print(a)