函数的返回值

  • 在两个函数之间要相互使用到内部变量时，就可以用到函数的返回值
  • 函数的返回值是函数执行以后返回的结果，可以通过return返回指定结果 ```python def fun(*args): r=0 for i in args:
    1.   r+=i
    return(r) #结果是10

print(fun(1,2,3,4)) #10 换成fun(1,2,3,4)-4结果是6

```python
def fun1():
    def fun2():
        return fun2

print(fun1()())        #这里fun1()=fun2 fun1()()=fun2()
  • 任何类型的值都可以作为函数的返回值来返回
  • 当函数体中没有return语句时，函数运行结束,则默认返回 None，也被称为隐含返回值
  • return的特性：在函数中，return后面的代码都不会执行，return一旦执行，函数自动结束 ```python def fun1(): print(111) return print(2222)

fun3() #结果是111

def fun2(): for i in range(5): if i == 3: break #换成continue return再次执行 print(i) print(‘结束循环’)

fun2()

break时执行结果是0 1 2 结束循环；continue时执行的结果是0 1 2 4 结束循环；return时执行的结果是0 1 2。注意它们三个的用法


- 函数有多个返回值
   - 当执行函数体内代码时，遇到第一个 return 就将指定值返回到函数调用处，也就是执行到return这行代码，后面的都不执行了。
   - 多个返回值时，用逗号隔开，但默认为元组
```python
def fun():
    a,b,c = (1,2,3)
    return a
    return b
    return c


a,b,c = fun()
print(a,b,c)    #结果是1

把3 4 5行改成 return a,b,c 结果是 1 2 3

文档字符串

  • 文档字符串运用对函数或面向对象做功能、参数等的说明帮助文档

  • help()是python中的内置函数，通过help()函数可以查询到python中函数的用法

    函数的作用域

    作用域介绍

  • 作用域（scope）指的是变量生效的区域，函数的作用域决定了在哪一部分程序可以访问特点变量的名称

  • 作用域的分类
    • 内建作用域(built-in)：系统固定模块里面的变量，例如int()等
    • 全局作用域(global)
      • 全局作⽤域在程序执⾏时创建，在程序执⾏结束时销毁
      • 所有函数以外的区域都是全局作⽤域
      • 在全局作⽤域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进⾏访问
    • 嵌套的父级函数的局部作用域(enclosing)：包含此函数的上级函数局部作用域，但不是全局的
    • 局部作用域(local)
      • 函数作用域在函数调用时创建，在调用结束时销毁
      • 函数每调用一次就会产生⼀个新的函数作用域
      • 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问

        作用域的优先级

        image.png
        局部作用域(L)>父级函数作用域(E)>全局作用域(G)>系统模块(B)
        a = int(3.14)    # built-in
b = 11            # global
def outer():
c = 5        # enclosing
def inner():
d = 6    # local
return 1
        注意：nonlocal是将变量声明成

        global关键字

        当我们需要在函数内部直接修改全局变量时，可以将函数内部的局部变量通过global关键字声明为全局变量。 ```python def func():

        global a 这一行是声明a是全局变量

        a=20 # a是func的局部变量 fun的全局变量 def fun(): print(‘fun里面’,a) fun()

func() print(a) #20

<a name="2qFAF"></a>
# 命名空间

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

![image.png](https://cdn.nlark.com/yuque/0/2021/png/2769909/1612420948260-75609b2e-0334-454e-86ce-cfcb3737bb07.png#align=left&display=inline&height=251&margin=%5Bobject%20Object%5D&name=image.png&originHeight=501&originWidth=1798&size=88505&status=done&style=none&width=899)<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/2769909/1612428684120-a77ac914-83f5-4141-992b-bd767a2daf4c.png#align=left&display=inline&height=253&margin=%5Bobject%20Object%5D&name=image.png&originHeight=505&originWidth=1820&size=96355&status=done&style=none&width=910)<br />第32行改成 space=locals() 运行结果是{'abc' : '123'} 此时是局部变量
<a name="5WWUO"></a>
# 递归函数

- 函数Func(args)直接或间接调用函数本身，则该函数称为递归函数。
- 递归函数的思想就是将一个大问题分解成若干个小问题，直到问题无法分解时，再去解决问题
- 递归的两个条件
   - 基线条件：问题可以被分解成最小的问题，当满足基线条件时，递归不再执行
   - 递归条件：将问题继续分解的条件
- 递归注意事项
   - 递归函数本身没有结束条件，需要自己设置结束调节来终止函数的调用
   - 利用递归实现的循环都可以实现，且递归效率低，因此使用的很少

练习1：求10！<br />分析如下：

- 阶乘本质：n! = 1 * 2 * 3 * ... * n,
- 用函数func(n)表示, 可以看出:func(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = func(n-1) * n,

所以, func(n)可以表示为n * func(n-1)
```python
def fun(n):
    # 基线条件
    if n == 1:
        return 1
    # 递归条件
    return n * fun(n-1)


fun(10)
print(fun(10))

练习2：求任意数字的任意次幂运算

def fun(m,n):
    # 基线条件：
    if n == 1:
        return m
    # 递归条件：
    return m*fun(m,n-1)


s=fun(10,5)
print(s)

练习3：检测一个字符串是否是回文字符串，如果是，返回值为True；如果不是，返回值为False。例如 ‘abcdcba’ 和 ‘abcddcba’ 是回文字符串

def fun(s):
    if len(s)<2:
        return True
    elif s[0] != s[-1]:
        return False


s=input('')
if len(s)<2:
    print('字符串太短')
else:
    print(fun(s))

函数执行的注意点：

  1. 代码从上至下执行
  2. 函数只有在调用的时候才会执行
  3. 函数执行完毕，则返回到函数调用处 ```python def test(): print(‘—5—‘)
                     # 此处相当于return None

def test2(): print(‘—3—‘) test() print(‘—4—‘)

def test3(): print(‘—1—‘) test2() print(‘—2—‘)

test3()

打印的结果是 —1— —3— —5— —4— —2—

<a name="CkRDS"></a>
# 小练习

1. 用函数实现一个判断用户输入的年份是否是闰年的程序①能被400整除的年份②能被4整除，但是不能被100整除的年份。以上2种方法满足一种即为闰年
```python
def func(year):
    if year.isdigit == False:
        print('你输入的有误')
        year = input('请输入年份：')
    else:
        if int(year) < 0:
            print('你输入的有误')
            year = input('请输入年份：')
        elif int(year) % 400 == 0:
            print(f'{year}是闰年')
        elif int(year) % 4 == 0 and int(year) % 100 != 0:
            print(f'{year}是闰年')
        else:
            print(f'{year}是闰年')


year = input('请输入年份：')
func(year)
  1. 猴子吃桃问题(递归)∶

猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了，求第一天共摘了多少桃子?

def peach(day):
    # 基线条件：
    if day ==10:
        return 1
    # 递归条件：
    return 2*(peach(day+1)+1)


a=peach(1)
print('第一天摘得桃子数为:%d'%a)

image.png