1函数的返回值

●返回值就是函数执行以后返回的结果
●通过return来指定函数的返回值
●return后面可以跟任意对象，返回值甚至可以是一个函数

def s(*b): r=0for i in b:r+=iprint(r)
s(1,2,3)6   # 但是这个r=6  这个r自始至终都在函数内部 
def s(*b):r=0for i in b:r+=iprint(r)  # 但是这个r=6 ，这个r自始至终都在函数内部，我们得想办法把它拿出来，这时
s(1,2,3)
print(r)  NameError: name 'r' is not defined #没有被定义

def fn ():return 123
fn()     #执行却没有任何结果

def fn():# return 后面跟什么值，函数就会返回什么值# return 后面可以跟任意的对象，甚至是一个值# return 123# return 'python'# return [1,2,3]return '1,2,3'r = fn()print(type(r),r)<class 'str'> 1,2,3

def fn():def fn2 ():print('hahahh')return fn2
r = fn()
print(r)
r()<function fn.<locals>.fn2 at 0x0000000002496F70>
hahahh

def fn():a=13
r=fn()
print(r)None

def fn():a=13print('haha')
r=fn()
print(r)haha
None

●在函数中return 的代码都不会执行，return一旦执行，函数立即结束。

def fn():print('haha')return # 在函数中return 的代码都不会执行，return一旦执行，函数立即结束。print('123')
r=fn()
print(r)haha
None

def fn():for i in range(5):print(i)
fn()0
1
2
3
4

def fn():for i in range(5):if i ==3:break # break 立即退出当前循环  continue 用来跳过当次循环print(i)print('循环执行完毕！！！')
fn()0
1
2
循环执行完毕！！！

def fn():for i in range(5):if i ==3:return #用来结束函数print(i)print('循环执行完毕！！！')
fn()0
1
2

明白了return 的作用后 就可以这样使用

# 求任意数的和
def fn(*c):r=0for i in c:r+=1return r
# r=fn(1,2,5,8)print(r)NameError: name 'r' is not defined #这样还是不行呀

● 所以，类比于 pop.（）等有返回值函数的操作
或是print(fn(1,2,5,8))

# 求任意数的和
def fn(*c):r=0for i in c:r+=1return r
r=fn(1,2,5,8)  #或是print(fn(1,2,5,8))print(r)
4

●fn 是函数对象 打印fn实际上就是在打印函数对象
●fn()调用函数 打印fn()实际上就是在打印fn()的返回值

def fn():return 123
print(fn) # fn 是函数对象 打印fn实际上就是在打印函数对象
print(fn()) #fn()调用函数  打印fn()实际上就是在打印fn()的返回值<function fn at 0x0000000002466EE0>
123

def fn():print('hello')
print(fn)
print(fn())<function fn at 0x00000000024C6EE0>
hello
None   # 说明这个函数是没有

def fn():print('hello')
print(fn)
fn()<function fn at 0x0000000002466EE0>
hello   # 这样他就不会显示None

def fn():return 123fn()

调用函数你根本不知道函数是否有返回值，你得打印他定义一个变量 如r=fn(1,2,5,8) print® 或者是print(fn(1,2,5,8))

def fn():return 123print(fn())    #必须打印函数 才会有返回值的123

2文档字符串

●help()是Python中内置函数，通过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.关于模块内置函数打印的帮助：
打印（…）
打印（值，…，sep=''，end='\n'，文件=系统标准输出，刷新=假）
将值打印到流或系统标准输出默认情况下。
可选关键字参数：
文件：类似文件的对象（流）；默认为当前系统标准输出.
sep：在值之间插入字符串，默认为空格。
结束：字符串附加在最后一个值之后，默认为换行。
冲洗：是否强制冲洗水流。#有兴趣可以玩玩 但是知道 value  end='\n' 就够了
value 就是传个1  就是1 传个 '哈哈'   就是哈哈
print('d')
print(56546)d
56546def fn():for i in range(8):print(i,end='\n')fn()
0
1
2
3
4
5
6
7

当你你开发函数，然后编写文档字符串

def fn(a:int,b:str,c:bool):'''这是一个文档字符串的案例参数的作业:param a:作用...类型...默认值...:param b:作用...类型...默认值...:param c:作用...类型...默认值...:return:'''return  123fn(1,'abc',True)#  执行一遍也没有结果因为并没有返回这个值

3. 函数的作用域

●作用域(scope)
●作用域指的是变量生效的区域（我们定义一个变量，这个变量有的时候并不是整个程序都能看到的）

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

def fn():a=10 #a定义在了函数内部，所以a的作用域就是函数内部，函数外部访问不到。print('函数内部:','a=',a)
fn()
print('函数外部:','a=',a)函数内部: a= 10print('函数外部:','a=',a)
NameError: name 'a' is not defined  # name'a'没有被定义

b=20 #全局作用域
def fn():a=10 #函数作用域print('函数内部:','a=',a)print('函数内部:','b=',b)
fn()
print('函数外部:','b=',b)函数内部: a= 10
函数内部: b= 20
函数外部: b= 20

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

p=5
def fn():a=30def fn2():print('fn2中:','a=',a)print('fn2中:','p=',p)fn2()
fn()
print('全局中:','a=',a)NameError: name 'a' is not defined #在全域中看不到函数内部的作用域
fn2中: a= 30
fn2中: p= 5 

这就说明在 fn4中能看到fn3的作用域。 在 fn3中能看到fn2的作用域 在 fn2中能看到fn的作用域。 在 fn中能看到全局作用域 。但是不在函数内却部看不到 函数作用域 。在 fn中看不到fn2的作用域 。 在 fn2中看不到fn3的作用域。

p=5
def fn():a=30def fn2():a=55print('fn2中:','a=',a)   #这里要注意缩进 要不然会IndentationError: unindent does not match any outer indentation level  缩进错误：未缩进与任何外部缩进级别都不匹配fn2()
fn()fn2中: a= 55  

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

a=20
def fn3():a=10print('函数内部:','a=',a)
fn3()
print('函数外部:','a=',a)函数内部: a= 10
函数外部: a= 20

●如果希望在函数内部修改全局变量，则需要使用一个global关键字，来声明变量。
●声明在函数内部的使用a是全局变量，此时我们修改a,就是在修改全局变量

a=20
def fn3():global a   #如果希望在函数内部修改全局变量，则需要使用一个global关键字，来声明变量a=10  #声明在函数内部的使用a是全局变量，此时我们修改a,就是在修改全局变量print('函数内部:','a=',a)
fn3()
print('函数外部:','a=',a)函数内部: a= 10
函数外部: a= 10

4命名空间

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

命名空间

a=20
b=20
scope=locals() #获取当前的命名空间print(scope)
print(a)
print(scope['a']){'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000000020408B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/LongProject/作业.py', '__cached__': None, 'a': 20, 'b': 20, 'scope': {...}}
20
20

a=20
b=20
scope=locals() #获取当前的命名空间#向scope中添加一个key-value（就相当于在全局中创建了一个变量）
scope['c']=2165
print(scope)
print(scope['c']){'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000000005008B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/LongProject/作业.py', '__cached__': None, 'a': 20, 'b': 20, 'scope': {...}, 'c': 2165}
2165

函数内部的命名空间

def fn():scope=locals()  #要获取函数内部的命名空间print(scope)
fn(){}

def fn():a=20scope=locals()  #要获取函数内部的命名空间scope['d']=5 #当然这种非正常操作不建议经常使用print(scope)
fn(){'a': 20, 'd': 5}

def fn():a=20scope=locals()  #要获取函数内部的命名空间scope['d']=5  print(scope)  # 此时在函数内部的命名空间打印d 是不行的 这点了解就好print(d)fn()NameError: name 'd' is not defined

利用globals() 这个函数可以在任意位置获取全局的命名空间globals_scope=globals()

关键用法就是
def fn():
globals_scope = globals()
print(globals_scope)

fn()

a=80
b=20
def fn():#globals() #这个函数可以在任意位置获取全局的命名空间globals_scope=globals()print(globals_scope)
fn(){'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000000020308B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/LongProject/作业.py', '__cached__': None, 'a': 80, 'b': 20, 'fn': <function fn at 0x0000000002496EE0>}

5递归函数

求10的阶乘

n=10
for i in range(1,10):n=n*iprint(n)10
20
60
240
1200
7200
50400
403200
3628800

（友情提示:range() 函数在列表那节）

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

n=1
for i in range(2,11):n=n*iprint(n)2
6
24
120
720
5040
40320
362880
3628800

#定义一个函数，来实现任意的阶乘def fn(n):#参数n用来求求任意数的阶乘for i in range(1,n):n*=iprint(n)fn(10)3628800

当然以上的和递归确实毫无干系
#递归函数
#从前有座山…

#递归简单理解就是自己去引用自己
#递归函数就是在函数中调用自己

#无穷递归 类似于我们死循环

# def fn():
#
#     fn()
#
# fn()

递归

（递归的很关键的是return）
●递归是解决问题的一种方式
●整体思想是 将一个大问题分解成一个一个的小问题，直到问题无法 分解时再去解决问题
递归函数的两个条件
1.基线条件 问题可以被分解为最小的问题，当满足基线条件时，递归就不执行了
2.递归条件 可以将问题继续分解的条件

#用递归的解决方案 来实现任意数的阶乘

#10！=10*9！
#9！=9*8!
#...
#1!=1
def fn(n):# 参数n  要求阶乘的数字# 基线条件 判断n为1的时候 就不递归了if n==1:# 1的阶乘就是它本身 1return 1# 递归条件return n*fn(n-1)  # 因为本来是return n*n-1 ！  n-1的阶乘我们是没有的  但fn()本就是一个可以求阶乘的函数 
print(fn(10))       #fn(n-1)=(n-1)!

return nfn(n-1) 这个部分最关键
因为本来是return nn-1 ！ n-1的阶乘我们是没有的 但fn()本就是一个可以求阶乘的函数

练习

定义一个函数 来为任意数字做任意幂运算
这个是我自己想的 但是这种方法是没有领会精神的仅供参考

def  fn(n,i):# 参数n做幂运算的数字 i 做幂运算的次数# 基线条件if n==1:return nif i==0:return 1# 递归条件return n**i
print(fn(555,2))308025

老师所讲的
定义一个函数 来为任意数字做任意幂运算

# 练习 定义一个函数 来为任意数字做任意幂运算
#10**5=10*10**4
#10**4=10*10**3
#.....
#10**1=10def  fn(n,i):# 参数n做幂运算的数字 i 做幂运算的次数# 基线条件if i==1:    #很奇怪这里若是n==1会报错 RecursionError: maximum recursion depth exceeded in comparison    #比较中超过了最大递归深度。这个问题在这里极其容易出现 比如 n*fn(n,i)return n# 递归条件return n*fn(n,i-1) #  10**5=10*10**4#  n**i=n*n**i-1
print(fn(5,8))
print(5**8)390625
390625

定义一个函数 用来检查一个任意字符串是否是回文字符串，如果是就返回True 如果不是就返回False

#练习 定义一个函数 用来检查一个任意字符串是否是回文字符串，如果是就返回True 如果不是就返回False
#abcdefedcba
#先检查第一个字符和最后一个字符是否一致，如果不一致一定不是回文
#如果第一个字符和最后一个字符一致，那么再看其余的部分是不是回文字符串
#检查bcdefedcb是不是回文字符串
#检查cdefedc是不是回文字符串
#...
#检查efe是不是回文字符串
#检查g 是不是回文字符串
def fn(s):#参数s是要检查的字符串#基线条件if len(s)<2:return True#字符串长度小于2  则字符串一定是回文elif s[0]!=s[-1]:#第一个字符串和最后一个字符串不相等 不是回文return False#递归条件return  fn(s[1:-1])  #意思就是把第一个和最后一个去掉
print(fn('abcdefedcba'))

def fn(s):if len(s)<2:return Truereturn  s[0]==s[-1] and fn(s[1:-1])
print(fn('abcdlcba'))False

如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素 （取左不取右）

s='123454321'
print(s[1:-1])2345432