1. 函数的返回值

  • 返回值就是函数执行以后返回的结果
  • 通过return来指定函数的返回值

  • return后面可以跟任意对象，返回值甚至可以是一个函数 ```python

    写一个函数的最初的梦想，是不是封装好这个功能，让我们随时可以使用（调用）

    def fun(*args): r = 0 for i in args:

    1.   r += i

    print(r) return r # fun(1, 2, 3, 4) = r

result = fun(1, 2, 3, 4) # 函数的返回值用函数的调用fun()来接受了这个返回值的结果

print(r) #局部变量不能全局使用

print(fun(1, 2, 3, 4) - 4) print(result - 4)

10 10 6 6

==================

任何类型的值都可以作为函数的返回值来返回

def fun1():

  1. # return 1
  2. # return None
  3. # return True
  4. # return [1, 2, 3]
  6. def fun2():
  7.     print(111)
  8.     return 112
  9. return fun2

print(fun1()) # 调用fun1()，但没有返回值 print(fun1()()) # fun1()() = fun2(), 调用 fun1()中的fun2() r = fun1()

print(r())

.fun2 at 0x0000024DA05DFC10> 111 112 111

112

对于返回值来说，如果你不写return xxx 和 只写一个return ，返回的结果都是None

return的特性： 在函数中，return后面的代码都不会执行， return一旦执行，函数自动结束

def fun3(): print(111) return print(2222)

fun3()

111

======================= def fun4(): for i in range(5): if i == 3: break # 用来退出当前循环

  1.         # continue # 用来跳出当前循环
  2.         return
  3.     print(i)
  4. print('循环执行结束')

fun4()

0 1 2

循环执行结束

def fun4(): for i in range(5): if i == 3:

  1.         # break  # 用来退出当前循环
  2.         continue # 用来跳出当前循环
  3.         return
  4.     print(i)
  5. print('循环执行结束')

fun4()

0 1 2 4 循环执行结束

  1. <a name="ENh6R"></a>
  2. ## 2. 文档字符串
  4. - help()是Python中内置函数，通过help()函数可以查询Python中函数的用法
  5. - 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明
  6. ```python
  7. # 文档字符串，运用于对函数或者面向对象做功能、参数等的说明帮助文档
  8. def fun(a, b):
  9.     """
  10.     这是一个文档字符串的示例
  11.     这个函数的功能是做什么。。。。。
  12.     函数的参数：
  13.     :param a: 作用  功能  类型  默认值
  14.     :param b:作用  功能  类型  默认值
  15.     :return: 返回值
  16.     """
  18. # help()帮助查看文档说明的
  19. #help(input)
  20. help(fun)
  21. ---------------------------
  22. Help on function fun in module __main__:
  24. fun(a, b)
  25.     这是一个文档字符串的示例
  26.     这个函数的功能是做什么。。。。。
  27.     函数的参数：
  28.     :param a: 作用  功能  类型  默认值
  29.     :param b:作用  功能  类型  默认值
  30.     :return: 返回值

3. 函数的作用域

  • 作用域(scope)
  • 作用域指的是变量生效的区域
  • 在Python中一共有两种作用域
    • 全局作用域
    • 全局作用域在程序执行时创建，在程序执行结束时销毁
    • 所有函数以外的区域都是全局作用域
    • 在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问
    • 函数作用域
    • 函数作用域在函数调用时创建，在调用结束时销毁
    • 函数每调用一次就会产生一个新的函数作用域
    • 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问 ```python b = 456 def fun(): a = 123 print(‘函数内部’, a) print(‘函数内部’, b)

fun()

print(‘函数外部：’, a) # NameError: name ‘a’ is not defined

print(‘函数外部：’, b)

函数内部 123 函数内部 456

函数外部： 456

def fun2():

  1. # 声明a是全局变量，属于全局作用域
  2. global a
  3. a = 20
  5. def fun3():
  6.     print('fun3里面', a)
  7. fun3()

fun2()

print(a)

fun3里面 20 20

  1. <a name="yvg8L"></a>
  2. ## 4. 命名空间
  4. - 命名空间实际上就是一个字典，是一个专门用来存储变量的字典
  5. - locals()用来获取当前作用域的命名空间
  6. - 如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间
  7. - 返回值是一个字典
  8. ```python
  9. a = 1
  10. b = 2
  11. c = 3
  12. d = 4
  13. space = locals()
  14. # space['e'] = 5
  15. print(space)
  16. ----------------------------
  17. {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002B9895E08B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/pythonProject/Python基础/第9讲 函数中/命名空间.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'space': {...}}
  19. ======================================
  20. def fun():
  21.     abc = 123
  22.     space1 = locals()
  23.     space2 = globals()
  24.     print('space1:', space1)
  25.     print('space2:', space2)
  27. fun()
  28. -----------------------------------
  29. space1: {'abc': 123}
  30. space2: {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021A952108B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/pythonProject/Python基础/第9讲 函数中/命名空间.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'fun': <function fun at 0x0000021A95358040>}

5. 递归函数

  • 递归是解决问题的一种方式，它的整体思想，是将一个大问题分解为一个个的小问题，直到问题无法分解时，在去解决问题
  • 递归式函数有2个条件
      1. 基线条件 问题可以被分解为最小问题，当满足基线条件时，递归就不执行了
      1. 递归条件 可以将问题继续分解的条件 ```python

        需求： 求10! 求10的阶乘

        def fun(n): for i in range(1, n): n *= i return n

print(‘10! = ‘,fun(10))

=================

求任意数字的任意次幂运算

def fun(n, m): # fun(n, m)是求n的m次幂运算

  1. # 基线条件
  2. if m == 1:
  3.     return n
  5. # 递归条件
  6. return n * fun(n, m-1)

print(‘10**5 = ‘,fun(10, 5))

10**5 = 100000

====================================

回文字符串的练习

检测一个字符串是不是一个会问字符串，是的返回True， 否则返回false

abcdefgfedcba abcdefggfedcba

bcdefgfedcb bcdefggfedcb

cdefgfedc cdefggfedc

g gg

def fun1(s): # 判断是否是回文字符串

  1. # 基线条件
  2. if len(s) < 2:
  3.     return True
  4. elif s[0] != s[-1]:  # != 就是不等于
  5.     return False
  6. # 递归条件
  7. print(s[1:-1])
  8. return fun1(s[1:-1])

s = input(‘请输入字符串: ‘) if len(s) < 2: print(‘字符串太短’) else:

  1. print(fun1(s))

请输入字符串: abcdedcba bcdedcb cdedc ded e True 

  1. <br />
  2. <a name="article-title"></a>
  3. # 作业
  5. 1. 用函数实现一个判断用户输入的年份是否是闰年的程序<br />1.能被400整除的年份<br />2.能被4整除，但是不能被100整除的年份<br />以上2种方法满足一种即为闰年
  6. ```python
  7. def leap_year(year):
  8.     if year % 400 == 0:
  9.         print('闰年')
  10.     elif (year % 4 == 0) and (year % 100 != 0):
  11.             print('闰年')
  12.     else:
  13.         print('不是闰年')
  15. leap_year(int(input('请输入年份：')))
  1. 猴子吃桃问题（递归）：

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

  1. def monkey(j, n): # j:剩几个桃子, n:第几天 
  2.     i = 1
  3.     for i in range(n-1):
  4.         print(f'第{10-i}天', j)
  5.         j = (j + 1) * 2
  6.     return j
  8. num = monkey(1, 10) # 第10天剩下1个桃子
  9. print(f'第1天 {num}')
  10. -------------------------
  11. 第10天 1
  12. 第9天 4
  13. 第8天 10
  14. 第7天 22
  15. 第6天 46
  16. 第5天 94
  17. 第4天 190
  18. 第3天 382
  19. 第2天 766
  20. 第1天 1534
  22. ===================
  23. def monkey(i, n): # i:剩几个桃子, n:第几天
  24.     print(f'第{n}天有{i}个桃子')
  25.     if n > 1:
  26.         i = (i + 1) * 2
  27.     else:
  28.         return i
  29.     n = n - 1
  30.     return monkey(i, n)
  32. monkey(1, 10)  # 第10天剩下1个桃子
  33. --------------
  34. 第10天有1个桃子
  35. 第9天有4个桃子
  36. 第8天有10个桃子
  37. 第7天有22个桃子
  38. 第6天有46个桃子
  39. 第5天有94个桃子
  40. 第4天有190个桃子
  41. 第3天有382个桃子
  42. 第2天有766个桃子
  43. 第1天有1534个桃子
  45. ====================
  46. def fun(n):  # fun(n) 是为了求n天之前的桃子一共有多少个
  47.     # 今天也就是n 等于1 的时候，这个就是基线条件
  48.     if n == 1:
  49.         return 1
  51.     return (fun(n-1) + 1) * 2
  54. print(fun(10))
  55. ---------------------
  56. 1534