Dsh009 python基础编程--函数（中）

1、函数的返回值

• 返回值就是函数执⾏以后返回的结果
• 通过return来指定函数的返回值
• 可以直接使用函数的返回值，也可以通过一个变量来接收函数的返回值
• return后⾯可以跟任意对象，返回值甚⾄可以是⼀个函数

def fn():
    return 345
r = fn()
print(r)    # 输出结果为：345

• 如果仅仅写一个return，或者没有写return，相当于return None
• return一旦执行，函数自动结束

def fn3():
    print('hello')
    return
    print('python')
r = fn3()
print(r)  # 输出结果为：hello  None

• return可以用来结束函数

def fn4():
    for i in range(5):
        if i == 4:
            break
        print(i)
    print('循环结束')
fn4()     # 输出结果为：0  1  2  3  '循环结束'

def fn4():
    for i in range(5):
        if i == 4:
            return
        print(i)
    print('循环结束')
fn4()    # 输出结果为：0  1  2  3  

def fn4():
    for i in range(5):
        if i == 4:
            break
        print(i)
    print('循环结束')
print(fn4())    # 输出结果为：0  1  2  3  '循环结束'  None

def fn4():
    for i in range(5):
        if i == 4:
            return
        print(i)
    print('循环结束')
print(fn4())    # 输出结果为：0  1  2  3  None

求任意数的加和

def s(*a):
    r = 0
    for n in a:  # 遍历元组，并将元组中的元素相加
        r += n
    return r
r1 = s(1,24,6,8)
print(r1)      # 输出结果为：39

2、文档字符串

• help()是Python中内置函数，通过help()函数可以查询Python中函数的⽤法
• 在定义函数时，可以在函数内部编写⽂档字符串，⽂档字符串就是对函数的说明

def fn(a,b,c):
    '''
     这个函数的功能是一个文档字符串在函数中的使用说明
     参数
     a,作用,类型，默认值...
     b,作用,类型，默认值...
     c,作用,类型，默认值...
     返回值
    '''
    return
help(fn)
# 输出结果为：
Help on function fn in module __main__:

fn(a, b, c)
    这个函数的功能是一个文档字符串在函数中的使用说明
    参数
    a,作用,类型，默认值...
    b,作用,类型，默认值...
    c,作用,类型，默认值...
    返回值

def fn(a:int,b:str,c:bool) -> int:
    '''
     这个函数的功能是一个文档字符串在函数中的使用说明
     参数
     a,作用,类型，默认值...
     b,作用,类型，默认值...
     c,作用,类型，默认值...
     返回值
    '''
    return
help(fn)
# 输出结果为：
Help on function fn in module __main__:

fn(a:int, b:str, c:bool) -> int
    这个函数的功能是一个文档字符串在函数中的使用说明
    参数
    a,作用,类型，默认值...
    b,作用,类型，默认值...
    c,作用,类型，默认值...
    返回值

3、函数的作用域

• 作⽤域(scope)
• 作⽤域指的是变量⽣效的区域

a = 30
def fn():
    b = 40
    print('函数内部','a = ',a)
    print('函数内部','b = ',b)
fn()                              # 输出结果：函数内部 a =  30    函数内部 b =  40
print('函数外部','a = ',a)         # 输出结果：函数外部 a =  30

• 在Python中⼀共有两种作⽤域
  • 全局作⽤域
    • 全局作⽤域在程序执⾏时创建，在程序执⾏结束时销毁
    • 所有函数以外的区域都是全局作⽤域
    • 在全局作⽤域中定义的变量，都是全局变量，全局变量可以在程序的 任意位置进⾏访问
  • 函数作⽤域 （局部作用域）
    • 函数作⽤域在函数调⽤时创建，在调⽤结束时销毁
    • 函数每调⽤⼀次就会产⽣⼀个新的函数作⽤域
    • 在函数作⽤域中定义的变量，都是局部变量，它只能在函数内部被访问

def fn1():
    c = 50
    def fn2():
        print('fn2中 c = ',c)
    return fn2()
fn1()             # 输出结果为：fn2中 c =  50

def fn1():
    c = 50
    def fn2():
        c = 400
        print('fn2中 c = ',c)
    return fn2()
fn1()                # 输出结果为：fn2中 c =  400

def fn1():
    c = 50
    def fn2():
        c = 400
        print('fn2中 c = ',c)
    fn2()
    return fn2()
fn1()             # 输出结果为：fn2中 c =  400     fn2中 c =  400

• 如果希望在函数内部修改全局变量，则需要使用一个关键字global来声明变量

a = 30
def fn1():
    a = 100
    print('a =',a)
fn1()              # 输出结果为：a = 100
print('a =',a)      # 输出结果为：a = 30

a = 30
def fn1():
    global a   # 声明对全局变量进行编辑
    a = 100
    print('a =',a)
fn1()               # 输出结果为：a = 100
print('a =',a)      # 输出结果为：a = 100

4、命名空间

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

a = 30
b = 40
scope = locals()
print(scope)
print(scope['a'])
# 输出结果为：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000022AF94DB2E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/demo/08 函数.py', '__cached__': None, 'a': 30, 'b': 40, 'scope': {...}}
30

a = 30
b = 40
scope = locals()
print(scope)
print(scope['a'])
scope['c'] = 600
print(scope)
# 输出结果为：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001DF8720B2E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/demo/08 函数.py', '__cached__': None, 'a': 30, 'b': 40, 'scope': {...}, 'c': 600}

def fn():
    a = 90
    scope = locals()
    print(scope)
fn()             # 输出结果为：{'a': 90}

a = 30
b = 40
# scope = locals()
g = globals()
print(g)
#输出结果为：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000013F2B97B2E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/demo/08 函数.py', '__cached__': None, 'a': 30, 'b': 40, 'g': {...}}

5、递归函数

• 递归是解决问题的⼀种⽅式，类似于循环，它的整体思想是将⼀个⼤问题分解为⼀个个的⼩问题，直到问题⽆法分解时，再去解决问题。
• 递归简单理解就是自己调用自己，递归式函数就是在函数中自己调用自己
• 递归式函数有2个条件
  • 1.基线条件 问题可以被分解为最⼩问题，当满⾜基线条件时，递归就不执⾏了
  • 2.递归条件 可以将问题继续分解的条件

求任意数的阶乘

def fn(n):
    # 定义一个变量求保存结果
    r = n
    if n > 0:
        for i in range(1,n):
            r *= i
        return r
print(fn(10))    # 输出结果为：3628800

def fn(n):
    if n == 1:  # 基线条件，满足该条件就不再递归了
        return 1
    return n * fn(n-1)  # 递归条件
print(fn(10))    # 输出结果为：3628800

6、练习

6.1 练习1

定义一个函数，为任意数做幂运算n**i

def fn4(n,i):
    if i == 1:
        return n
    return n * fn4(n,i-1)
print(fn4(5,3))

6.2 练习2

定义⼀个函数，⽤来检查⼀个任意的字符串是否是回⽂字符串，如果是返 回True，不是返回False。
回⽂字符串从前往后念和从后往前念是⼀样的。 例如 TNT

def fn(s):
    if len(s) < 2:
        return True
    elif s[0] != s[-1]:
        return  False
    return fn(s[1:-1])
print(fn('abcbab'))   # 输出结果为：False
print(fn('abcba'))   # 输出结果为：True