Python基础知识九 函数二

1、函数的返回值

• 返回值就是函数执行以后返回的结果。
• 通过return来指定函数的返回值。
• 可以直接使用函数的返回值，也可以通过一个变量来接收函数的返回值。

def fn():
    return 'Hello'
print(fn())
# 运行结果：
# Hello

def fn(*args):
    r = 0
    for n in args:
        r += n
    return r
r = fn(1,2,3)
print(r)
# 运行结果：
# 6

• return后面可以跟任意的对象，甚至可以是一个函数。

def fn1():
    print('Python')

def fn2():
    return fn1

print(fn2())
# 运行结果：
# <function fn1 at 0x000001457A54AC80>

• 在函数中，return后的代码都不会执行，retrun一旦执行函数自动结束。

def fn():
    print('Hello')
    return
    print('World')
fn()
# 运行结果：
# Hello

• continue、break和return的区别：
  • continue：跳过当次循环
  • break：退出当前循环
  • return：函数结束
• fn是函数对象，打印fn就是在打印函数对象。
• fn()是调用函数，打印fn()实际上就是在打印fn()的返回值。

def fn1():
    return 'Python'

def fn2():
    return fn1

print(fn2())
# 运行结果：
# <function fn1 at 0x00000222AAA1AC80>

def fn1():
    return 'Python'

def fn2():
    return fn1()

print(fn2())
# 运行结果：
# Python

def fn1():
    return 'Python'

def fn2():
    return fn1()

print(fn2)
# 运行结果：
# <function fn2 at 0x000002536DE0AD08>

2、文档字符串

2.1 help()

• help()内置函数，可以查询Python中函数的用法。
• 语法：help(函数对象)

help(print)
'''
运行结果：
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
'''

2.2 文档字符串

• 在定义函数的时候，可以在函数内部编写文档字符串，文档字符串就是函数的说明。
• 当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明。

def fn(a:bool,b:int,c:str)-> int:
    '''
    这是一个文档字符串的示例

    这个函数的作用.......
    函数的参数
    :param a: 作用 类型 默认值...
    :param b: 作用 类型 默认值...
    :param c: 作用 类型 默认值...
    :return:  需要/不需要
    '''
    return 123
help(fn)

3、函数的作用域

• 作用域(scope)，指的就是变量生效的区域。
• 在Python当中一共有2种作用域。

3.1 全局作用域

• 全局作用域在程序执行时创建，在程序执行结束时销毁；
• 所有函数以外的区域都是全局作用域；
• 在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问。

3.2 函数作用域

• 函数作用域在函数调用时创建，在调用结束时销毁；
• 函数每调用一次就会产生一个新的函数作用域；
• 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问。

# 例1
a = 20
def fn():
    b = 15
    print('函数内部: a =',a)    # 函数内部: a = 20
    print('函数内部: b =',b)    # 函数内部: b = 15
fn()
print('函数外部: a =',a)    # 函数外部: a = 20
print('函数外部: b =',b)    # NameError: name 'b' is not defined

# 例2
a = 20
def fn2():
    a = 30
    def fn3():
        a = 40
        print('fn3中：a =',a)
    fn3()
    print('fn2中：a =',a)
fn2()
print('函数外：a =',a)
# 运行结果：
# fn3中：a = 40
# fn2中：a = 30
# 函数外：a = 20

3.3 global关键字

• 在函数内部修改全局变量，需要使用global关键字声明。

a = 123
def fn4():
    global a
    # 声明在函数内部使用的a是全局变量，此时去修改a，就是在修改全局的a
    a = 456
    print('函数内部：a =',a)
fn4()
print('函数外部：a =',a)
# 运算结果：
# 函数内部：a = 456
# 函数外部：a = 456

4、命名空间

• 命名空间就是一个字典，是一个专门用来保存变量的字典。
• locals() 函数用来获取当前作用域的命名空间，返回一个字典。
• globals() 函数可以用来获取全局作用域的命名空间。

a = 15
b = 20
scope = locals()
print(scope)
print(a)    # 15
print(scope['b'])    # 20
scope['c'] = 'Hello'
# 向scope里面添加了一个key-value
print(c)    # Hello

def fn():
    a = 1
    # 在函数内部调用locals()会获取函数的命名空间
    scope = locals()
    scope['c'] = 2
    print(scope)    # {'a': 1, 'c': 2}
    print(c)    # NameError: name 'c' is not defined

    # globals() 函数可以用来获取全局的命名空间
    global_scope = globals()
    print(global_scope)
fn()

5、递归函数

5.1 递归函数的基本概念

• 递归式的函数，就是在函数中自己调用自己。
• 递归是解决问题的一种思想，它和循环很像。它的整体思想是把一个大的问题分解为一个小的问题，直到问题无法分解时，再去解决问题。
• 递归函数的两个条件：
  • 1.基线条件：问题可以被分解为最小的问题，当满足基线条件时，递归就不在执行了；
  • 2.递归条件：将问题继续分解的条件。

'''
例：用递归的思想解决任意数的阶乘问题
10! = 10 * 9!
9! = 9 * 8!
8! = 8 * 7!
...
1! = 1
'''
def fn(n):
    # 1. 基线条件
    if n == 1:
        return 1
    # 2. 递归条件  10 * 9!
    return  n * fn(n-1)
print(fn(10))
# 运行结果：
# 3628800

5.2 递归练习

例1：定义一个函数，为任意数字做任意次幂的运算。
分析：
8 ** 6 = 8 * 8 ** 5
8 ** 5 = 8 * 8 ** 4
8 ** 4 = 8 * 8 ** 3
…
8 ** 1 = 8

def fn1(n,i):
    # 参数 n 代表任意数字 i 代表给任意数字做任意的幂运算（5 ** 3，n就是5 i就是3）
    # 1.基线条件 求n的1次幂
    if i == 1:
        return n
    # 2.递归条件 8 ** 6 = 8 * 8 ** 5
    return n * fn1(n,i-1)
print(fn1(8,6))    # 262144
print(8 ** 6)    # 262144

例2：定义一个函数，用来检测任意的一个字符串是否是回文字符串，如果是则返回True，如果不是则返回False。
分析：
回文字符串：字符串从前往后念和从后往前念是一样的，例如 abcba。
如果第一个字符和最后一个字符不一致，则该字符串一定不是回文字符串。
判断 abcdefgfedcba 是不是回文？先判断第一个字符和最后一个字符是否相等，若相等，
继续判断 bcdefgfedcb ，第一个字符和最后一个字符若相等，
继续判断 cdefgfedc，
…
直到 g

def fn2(s):
    # 参数s表示要检查的字符串是否是回文字符串
    # 1. 基线条件：⑴若字符串长度为1，则是回文字符串；
    #            ⑵若字符串的第一个字符和最后一个字符不相等，则不是回文字符串。
    if len(s) < 2:
        return True
    elif s[0] != s[-1]:
        return False
    # 2. 递归条件：abcdefgfedcba -> bcdefgfedcb -> cdefgfedc -> ...
    return fn2(s[1:-1])
print(fn2('a'))    # True
print(fn2('aa'))    # True
print(fn2('ab'))    # False
print(fn2('abcdefgfedcba'))    # True

例3：汉诺塔游戏，现在有ABC三根柱子。要求：将A柱所有的圆盘放到C柱。在移动的过程中可以借助B柱。并且规定大圆盘不能放小圆盘上面，每次只能移动一个盘子。用递归的方式来解决汉诺塔问题。
分析：
1.如果有一个盘子 A -> C
2.如果有大于等于两个盘子，我们总可以把他们看成是2个盘子，最下面的一个和最上面的一个(多个)
2.1 先把最上面的一个(多个) A -> B
2.2 把最下面的一个盘子 A -> C
2.3 把B柱上面的一个或多个 B -> C

分治算法 ：大整数的乘法 二分搜索 快速排序 汉诺塔问题…

def HanoiTower(num,a,b,c):
    # 参数 num代表的盘子 a b c分别代表的是A B C柱
    # 基线条件 1.如果有一个盘子 A -> C
    if num == 1:
        print('第 1 个盘从',a,'->',c)

    else:
        # 递归条件
        # num >= 2
        # 2.1 先把最上面的一个(多个) A -> B 借助C num-1表示去掉最下面的盘子
        HanoiTower(num-1,a,c,b)

        # 2.2 把最下面的盘子 A -> C
        print('第',num,'个盘从',a,'->',c)

        # 2.3 把B柱上面的一个或多个 B -> C 借助A
        HanoiTower(num - 1, b, a, c)

HanoiTower(3,'A','B','C')
# 运算结果：
# 第 1 个盘从 A -> C
# 第 2 个盘从 A -> B
# 第 1 个盘从 C -> B
# 第 3 个盘从 A -> C
# 第 1 个盘从 B -> A
# 第 2 个盘从 B -> C
# 第 1 个盘从 A -> C