Python基础第10讲 - 函数
一、函数返回值 ：返回值就是函数执行返回的结果
1.1求任意数的和
```handlebars
def s(*nums):
# 定义一个变量保存结果
result = 0
# 遍历元组，并将元组当中的元素进行累加
for n in nums:
result += n
print(result)
s(1,2,3)
# 结果： 6
用return来指定函数的返回值
我们可以直接使用函数的返回值，可以通过变量来接收函数的返回值
return后面可以跟任意对象，甚至是一个函数
def fn():
return 100
return 'python'
return [1,2,3]
return {'a':'b'}
r = fn() # 这个函数执行的结果就是返回值的结果
print(r) # 100
def fn():
def fn2():
print("hello")
return fn2
r = fn()
print(r) # <function fn.<locals>.fn2 at 0x017750C0>
如果仅仅写一个return或者不写return则相当于return none
def fn2():
# return
a = 10
r = fn2()
print(r) # None
在函数中，return后面的代码不会执行，return一旦执行函数自动结束
def fn3():
print('python')
return
print('java')
r = fn3()
print(r)
# 结果： python
# None
return可以用结束函数
def fn4():
for i in range(5):
if i == 3:
# break # break退出当前循环
# continue # continue跳过本次循环
return # return可以用结束函数
print(i)
print('循环执行完毕')
fn4()
# 结果： 0
# 1
# 2
fn5和fn5()的区别
1. fn5是函数对象 打印fn5就是在打印函数对象
2. fn5()是在调用函数 打印fn5()实际上是在打印fn5()函数的返回值
def fn5():
return 1
# fn5是函数对象 打印fn5就是在打印函数对象
print(fn5) # <function fn5 at 0x03405228>
# fn5()是在调用函数 打印fn5()实际上是在打印fn5()函数的返回值
print(fn5()) # 1
二、文档字符串
help()可以查询其他函数的用法
语法 help(函数对象)
# help(print)
def fn(a:int,b:str,c:bool)-> int:
'''
:param a: 类型 int 默认值...
:param b: 类型 str 默认值...
:param c: 类型 bool 默认值...
:return: int
'''
return 1
help(fn)
三、函数的作用域: 作用域代表指的是变量生效的区域
3.1. 全局作用域
1️⃣ 全局作用域在程序执行时创建，在程序执行结束时销毁
2️⃣ 所有函数以外的部分都是全局作用域
3️⃣ 在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置访问
3.2.函数作用域
1️⃣ 函数作用域在函数调用时创建，在调用结束后销毁
2️⃣ 函数每调用一次就会产生一个新的作用域
3️⃣ 在函数作用域中定义的变量都是局部变量，它只能在函数内部被访问到
def fn():
a = 10 # a定义在函数内部，所以它的作用域是函数内部，函数外部是访问不到的
print('函数内部：','a =',a)
fn() # 函数内部： a = 10
print('函数外部：','a =',a) # 访问不到a， 且会报错
b = 20
def fn():
a = 10 #
print('函数内部：','a =',a)
print('函数内部：','b =',b)
fn() # 函数内部： a = 10
# print('函数外部：','a =',a)
print('函数外部：','a =',b)
结果： 函数内部： a = 10
函数内部： b = 20
函数外部： a = 20
def fn2():
a = 30
def fn3():
a = 40
print('fn3中:','a = ',a)
fn3()
fn2()
结果： fn3中: a = 40
如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
a = 20
def fn3():
# 如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
# a = 10
global a # 声明在函数内部的使用a是全局变量，在去修改a，是修改的是全局的a
a = 10
print('函数内部:','a =',a)
fn3()
print('函数外部:','a =',a)
结果： 函数内部: a = 10
函数外部: a = 10
四、命名空间：命名空间实际上就是一个字典，是一个专门用来存储变量的字典
1.locals()用来获取当前作用域的命名空间
2.如果在全局作用域中调用locals()则获取的是全局命名空间，如果在函数作用域中调用，则获取的是函数的命名空间， 返回是一个字典
# 向字典中添加key-value 就相当于在全局中创建了一个变量
s = locals() # 当前的命名空空间
s['b'] = 100 # 像字典中添加key-value 就相当于在全局中创建了一个变量
print(b) # 100
print(s)
结果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0053C230>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'H:/计算机要点/函数/函数.py', '__cached__': None, 's': {...}, 'fn': <function fn at 0x02D85270>, 'r': None, 'fn2': <function fn2 at 0x02ECDBB8>, 'fn3': <function fn3 at 0x02D85198>, 'fn4': <function fn4 at 0x02D851E0>, 'fn5': <function fn5 at 0x02D85228>, 'b': 100, 'a': 10}
情况1
def fn4():
s = locals() # 在函数内部调用locals()会获取到函数的命名空间
print(s)
fn4()
结果： {}
情况2
def fn4():
a = 10
s = locals() # 在函数内部调用locals()会获取到函数的命名空间
print(s)
fn4()
结果： {'a': 10}
情况3
def fn4():
a = 10
s = locals() # 在函数内部调用locals()会获取到函数的命名空间
s['c'] = 20
print(s)
fn4()
结果： {'a': 10, 'c': 20}
情况4
def fn4():
# a = 10
# s['c'] = 20
# print(c)
# globals() 函数可以用来在任意位置获取全局命名空间
global_space = globals()
print(global_space)
fn4()
结果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0362C230>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'H:/计算机要点/函数/函数.py', '__cached__': None, 's': <function s at 0x037E5078>, 'fn': <function fn at 0x037E5270>, 'r': None, 'fn2': <function fn2 at 0x03A2DBB8>, 'fn3': <function fn3 at 0x037E5198>, 'fn4': <function fn4 at 0x037E5108>, 'fn5': <function fn5 at 0x037E5228>, 'b': 20, 'a': 10}
五、递归
练习：10的阶乘
'''
# 10! 1*2*3*4*5*6*7*8*9*10 = 3628800
# 9! 1*2*3*4*5*6*7*8*9
# ...
# 4! 1*2*3*4 = 24
# 3! 1*2*3 = 6
# 2! 1*2 = 2
# 1! 1
'''
# 定义一个函数实现任意数的阶乘
# 创建一个变量保存结果
n = 10
for i in range(1,10):
# n = n * i
n *= i
print(n)
# 结果： 3628800
递归式的函数
递归简单理解就是自己调用自己
递归式函数，在函数中自己调用自己
def fn(n):
# 创建一个变量保存结果
result = n
for i in range(1, n):
result *= i
return result
print(fn(15))
结果： 1307674368000
无穷递归 类似于死循环
def fn():
fn()
fn()
递归式函数有两个条件
1.基线条件
问题可以被分解为最小的问题，当满足基线条件的时候，递归就不在执行了
2.递归条件
将问题可以分解的条件
'''
10! 1*2*3*4*5*6*7*8*9*10 --> 10 * 9!
9! 1*2*3*4*5*6*7*8*9 --> 9 * 8!
...
4! 1*2*3*4 = 24 --> 4 * 3!
3! 1*2*3 = 6 --> 3 * 2!
2! 1*2 = 2 --> 2 * 1!
1! 1 --> 1! = 1
'''
def fn(n):
# 基线条件 判断n是否是1 如果是1不能再继续递归
if n == 1:
# 1的阶乘就是1，直接返回1
return 1
# 递归条件
return n * fn(n-1)
print(fn(19))
结果：121645100408832000
六、递归的练习
练习1、创建一个函数，来为任意数字做幂运算 n ** 1 5 ** 3
'''
10 ** 5 = 10 * 10 ** 4
10 ** 4 = 10 * 10 ** 3
...
10 ** 1 = 10
'''
def fn(n,i):
# 参数 n:要做幂运算的数字 i 做幂运算的次数
# 基线条件
if i == 1:
# 求1次幂
return n
# 递归条件
return n * fn(n,i-1)
print(fn(5,4))
print(5**4)
练习2
创建一个函数，用来检测任意字符串是否是回文字符串，如果是返回True,如果不是返回False
什么是回文字符串？字符串从后往前读和从后往前读是一样的 例如 abcba abc abcdefgfedcba
1. 先去检测第一个字符和最后一个字符是否一致,如果不一致则不是回文字符串
2. 如果一致，则看剩余部分是否是回文字符串
3. 检查abcdefgfedcba 是不是回文
4. 检查bcdefgfedcb 是不是回文
5. 检查 cdefgfedc 是不是回文
…
6. 检查 fgf 是不是回文
7. 检查 g 是不是回文
def fn2(s):
# 参数 s 就是用来检测是否是回文字符串 如果是返回True 如果不是返回False
# 基线条件
# 如果字符长度小于2，则肯定是回文
if len(s) < 2:
return True
elif s[0] != s[-1]:
# 第一个字符和最后一个字符不相等 则证明肯定不是回文
return False
# 递归条件
return fn2(s[1:-1])
print(fn2('abba'))
