09-函数2(函数返回值、文档字符串、作用域、递归函数)

1. 函数的返回值

- 返回值就是函数执行后返回的结果
- 通过return来指定函数的返回值
- return 后面可以跟任意对象，返回值甚至可以是一个函数
- 在函数中， return 后面的代码不会被执行，return 一旦被执行函数自动结束

# 求任意数的和 
# r的值一定在函数内部，外部不能使用，拓展性不强
def fn(*args):
    r = 0
    for n in args:
        r += n
    print(r)
fn(1,2,3)

6


- 1. 可以直接使用函数的返回值
- 2. 可以通过一个变量来接收函数的返回值

# 可以直接使用函数的返回值
def fn():
    return 123
print(fn())

123

# 可以通过一个变量来接收函数的返回值
def fn():
    return 123
a = fn()
print(a)

123

# return 后面可以跟任意对象。 字符串、列表、字典、函数等
def fn():
    return '一二三'
a = fn()
print(a)

一二三

def fn():
    return [1,2,3]
a = fn()
print(a)

[1, 2, 3]

def fn():
    return {'a': 1}
a = fn()
print(a)

{'a': 1}

def fn():
    def fn2():
        print('hello')
    return fn2
a = fn()
print(a) # a 是 函数的对象
a()

<function fn.<locals>.fn2 at 0x7fe4fed680d0>
hello

# return 后面函数不能加括号
def fn():
    def fn2():
        print('hello')
    return fn2()
a = fn()
print(a)

hello
None

# 没有返回值或就一个return，相当于  return None ,返回的就是“None”
def fn2():
    return
a = fn2()
print(a)

None

def fn2():
    print(123)
a = fn2()
print(a)

123
None

def fn3():
    print('abc')
    print('hahaha')
fn3()

abc
hahaha

# 在函数中， return 后面的代码不会被执行，return 一旦被执行函数自动结束
def fn3():
    print('abc')
    return
    print('hahaha')
r = fn3()
print(r)

abc
None

# break 与 return的区别
# break 用来退出当前循环
def fn4():
    for i in range(5):
        if i == 3:
            break
        print(i)
    print('程序执行完毕！')
fn4()

0
1
2
程序执行完毕！

# return 函数结束，其后面的代码不执行
def fn4():
    for i in range(5):
        if i == 3:
            return
        print(i)
    print('程序执行完毕！')
fn4()

0
1
2

# continue 用来跳过当次循环
def fn4():
    for i in range(5):
        if i == 3:
            continue
        print(i)
    print('程序执行完毕！')
fn4()

0
1
2
4
程序执行完毕！


- 总结： fn 是函数对象，fn() 是调用对象 ； print 是函数对象， print() 是调用函数
        - fn 是函数对象,    打印fn就是在打印函数对象。   <function fn.<locals>.fn2 at 0x7fe4fed680d0>
        - fn() 是调用对象， 打印fn()实质就是打印fn()的返回值 

2. 文档字符串

- help() 是python中的内置函数，通过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.

def fn(a):
    '''
    这是一个文档字符串的示例
    函数的参数
    :param a: 作用 类型 默认值
    :return: 需要/不需要    
    '''
    return 123
help(fn)  

Help on function fn in module __main__:

fn(a)
    这是一个文档字符串的示例
    函数的参数
    :param a: 作用 类型 默认值
    :return: 需要/不需要

def fn(a:int)->int:
    return 123
help(fn)

Help on function fn in module __main__:

fn(a: int) -> int

3. 函数的作用域（scope）

- 指的是变量生效的区域
- 两类：
    - 全局作用域：
        - 全局作用域在程序执行时创建，在程序执行结束后销毁
        - 所有函数以外的区域都是全局作用域
        - 在全局作用域定义变量，都是全局变量，全局变量可以在程序任意位置被访问
    - 函数作用域：
        - 函数作用域在函数调用时创建，在调用结束时销毁
        - 函数每调用一次会产生一个新的函数作用域
        - 在函数作用域中定义的变量，都是局部的变量，它只能在函数内部被访问

def fn():
    a = 123
    print('函数内部：a =',a )
fn()

函数内部：a = 123

def fn():
    z = 123
    print('函数内部：z =',z )
fn()
print('函数外部：z =',z )

函数内部：z = 123



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-33-3e049fd5b43a> in <module>
      3     print('函数内部：z =',z )
      4 fn()
----> 5 print('函数外部：z =',z )


NameError: name 'z' is not defined

q = 456
def fn():
    z = 123
    print('函数内部：z =',z )
    print('函数内部：q =',q )
fn()
print('函数外部：q =',q )

函数内部：z = 123
函数内部：q = 456
函数外部：q = 456

def fn2():
    a = 30
    def fn3():
        print('fn3中： a = ',a)
    fn3()
fn2()

fn3中： a =  30

def fn2():
    a = 30
    def fn3():
        a = 40
        print('fn3中： a = ',a)
    fn3()
fn2()

fn3中： a =  40

a = 456
def fn3():
    a = 123
    print('a = ',a)
fn3()

a =  123

a = 456
def fn3():
    a = 123
    print('函数内部a = ',a)
fn3()
print('函数外部a = ',a)

函数内部a =  123
函数外部a =  456

a = 456
def fn3():
    # 在函数内部修改全局变量，需要使用global关键字声明局部变量
    global a # 声明在函数内部使用的a是全局变量
    a = 123
    print('函数内部a = ',a)
fn3()
print('函数外部a = ',a)

函数内部a =  123
函数外部a =  123

4. 命名空间

- 命名空间实质上就是一个字典，是一个专门存储变量的字典
- locals() 用来获取当前作用域的命名空间
- 如果在全局作用域调用locals() 则获取全局命名空间，如果在函数作用域中调用locals() 则调用函数命名空间
- 返回值是一个字典

a = 80
b = 30
scope = locals()
# print(scope)
print(scope['a'])
# 向scope中添加一个key -value (相当于在全局中创建了一个变量)
scope['c'] = 100
print(c)

80
100

def fn4():
    a = 20
    scope = locals()
    scope['b'] = 365
    print(scope)
    print(b)
fn4()

{'a': 20, 'b': 365}
30

# globals() 可以在任意位置获取全局的命名空间
def fn4():   
    global_scope = globals()
    print(global_scope)
fn4()

{'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', '# 求任意数的和\ndef fn(*args):\n    r = 0\n    for n in args:\n        r += n\n    print(r)\nfn(1,2,3)'

递归函数

 - 递归是解决问题的一种方式，思想是将一个大问题分解为一个个的小问题，直到问题无法解答时，再去解决问题
 - 递归： 简单理解就是自己引用自己
 - 递归函数有两个条件：
     - 1. 基线条件： 问题可以分解成最小问题，当满足基线条件时，递归就不执行了
     - 2. 递归条件： 可以将问题继续分解的条件
     - 总结： 在函数中自己调用自己

# 求10的阶乘
# 1！ = 1  
# 2！ = 1 * 2
# 3！ = 1 * 2 * 3
# 10！ = 。。。。* 8 * 9 * 10

print(1*2*3*4*5*6*7*8*9*10)

n = 10
for i in range(1,10):
    n *= i
print(n)

3628800
3628800

def fn(n):
    r = n
    for i in range(1,n):
        r *= i
    return r
print(fn(10)) 

3628800

# 用递归思想求任意数的阶乘
def fn2(n):
    # 1. 基线条件：
    if n == 1:
        return 1
    # 2. 递归条件
    return n * fn2(n - 1)
print(fn2(10))
    

3628800

# 定义一个函数，为任意数字做任意数值的幂运算
# 10 ** 5 = 10 * 10**4
# 10 ** 4 = 10 * 10**3
# 10 ** 1 = 10 
def fn(n, i):
    # 参数n, 代表任意数字； i 代表幂运算值
    # 1. 基线条件：
    if i == 1:
        return n
    # 2. 递归条件：
    return n * fn(n , i -1)
print(fn(8,8))
print(8 ** 8)

16777216
16777216

# 定义一个函数，用来检测一个字符串是回文字符串
# 回文字符串：从前面往后看与从后面往前看是一样的 如 abcba
def fn(s):
    # 参数s表示要检查的字符串是否回文
    
    # 基线条件：
    # 如果第一个和最后一个字符不一致一定不是回文
    if len(s) < 2:
        return True
    elif s[0] != s[-1]:
        return False
    # 递归条件:
    return fn(s[1:-1])
print(fn('abcdefedcba'))
print(fn('wc2cb'))

True
False