一、函数的返回值
返回值就是函数执行以后返回的结果
def s(*nums):
# 定义一个变量来保存结果
result = 0
# 遍历元组，并将元组当中的元素进行累加
for n in nums:
result += n
print(result)
s(7,4,5,6) #22
用return来指定函数的返回值
我们可以直接使用函数的返回值也可以通过变量来接收函数的返回值
return后面可以跟任意对象，甚至可以是一个函数
def fn():
# return 100
# return 'python'
# return [1,2,3]
# return {'a':'b'}
def fn2():
print('hello,fn2()')
return fn2
r = fn() # 这个函数执行的结果就是返回值的结果
# print(r) #100,python,[1, 2, 3],{'a': 'b'}
print(fn())#<function fn.<locals>.fn2 at 0x0000024B20956DC8>
r()#hello,fn2()
如果仅仅写一个return或者不写return则相当于return none
def fn2():
# return
a = 10
r = fn2()
print(r)
在函数中，return后面的代码不会执行，return一旦执行函数自动结束
def fn3():
print('python')
return 3
print('java')
r = fn3()
print(r)
def fn4():
for i in range(5):
if i == 3:
break # break退出当前循环 0 1 2 循环执行完毕
# continue # continue跳过本次循环 0 1 2 4 循环执行完毕
# return # return可以用结束函数 0 1 2
print(i)
print('循环执行完毕')
fn4()
fn5和fn5()的区别
def fn5():
return 1
# fn5和fn5()的区别
print(fn5) # fn5是函数对象 打印fn5就是在打印函数对象--<function fn5 at 0x000001F554906678>
print(fn5()) # fn5()是在调用函数 打印fn5()实际上是在打印fn5()函数的返回值--1
二、文档字符串
比如：# help()函数 可以查询其他函数的用法
语法 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.
'''
def fn(a:int,b:str,c:bool)-> int:
'''
:param a: 类型 int 默认值...
:param b: 类型 str 默认值...
:param c: 类型 bool 默认值...
:return: int
'''
return 1
help(fn)
'''
Help on function fn in module __main__:
fn(a: int, b: str, c: bool) -> int
:param a: 类型 int 默认值...
:param b: 类型 str 默认值...
:param c: 类型 bool 默认值...
:return: int
'''
三、函数的作用域
作用域指的就是变量生效的区域
全局作用域
全局作用域在程序执行时创建，在程序执行结束时销毁
所有函数以外的部分都是全局作用域
在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置访问
函数作用域
函数作用域在函数调用时创建，在调用结束后销毁
函数每调用一次就会产生一个新的作用域
在函数作用域中定义的变量都是局部变量
b = 20
def fn():
a = 10 # a定义在函数内部，所以它的作用域是函数内部，函数外部是访问不到的
print('函数内部:','a =',a) #函数内部: a = 10
print('函数内部:','b =',b) #函数内部: b = 20
fn()
# print('函数外部:', 'a =', a) #NameError: name 'a' is not defined
print('函数外部:', 'b =', b) #函数外部: b = 20
def fn2():
a = 30
def fn3():
a = 40
print('fn3中:','a = ',a)#40
fn3()
fn2()#fn3中: a = 40
global:改变全局变量
a = 20
def fn3():
# 如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
# a = 10
global a # 声明在函数内部的使用a是全局变量，在去修改a，是修改的是全局的a
a = 10
print('函数内部:','a =',a)
fn3()#函数内部: a = 10
print('函数外部:','a =',a)#1函数内部: a = 10
四、命名空间
命名空间实际上就是一个字典，是一个专门用来存储变量的字典
locals()用来获取当前作用域的命名空间
如果在全局作用域中调用locals()则获取的是全局命名空间；
如果在函数作用域中调用，则获取的是函的命名空间 返回是一个字典
s = locals() # 当前的命名空间
s['b'] = 100 # 像字典中添加key-value 就相当于在全局中创建了一个变量
# print(b)
print(s)
def fn4():
a = 10
s = locals() # 在函数内部调用locals()会获取到函数的命名空间
s['c'] = 20
# print(c)
print(s) #{'a': 10, 'c': 20}
# globals() 函数可以用来在任意位置获取全局命名空间
global_space = globals()
print(global_space)
fn4()
五、递归
练习 定义一个函数求10的阶乘(10!)
10 ! 12345678910 = 3628800
9! 123456789
…
4! 1234 = 24
3! 123 = 6
2! 1*2 = 2
1! 1
print(123456789*10)
定义一个函数实现任意数的阶乘
# 创建一个变量保存结果
n = 10
for i in range(1,10):
# n = n * i
n *= i
print
递归式的函数
递归简单理解就是自己调用自己
递归式函数，在函数中自己调用自己
def fn(n):
# 创建一个变量保存结果
result = n
for i in range(1, n):
result *= i
return result
print(fn(20)) #2432902008176640000
def fn(n):
res = n
for i in range(1,n):
res *= i
return res
fn(5)
print(fn(5))#120
# 无穷递归 类似于死循环
# def fn():
#
# fn()
#
# fn()
递归式函数有两个条件
1.基线条件
问题可以被分解为最小的问题，当满足基线条件的时候，递归就不在执行了
2.递归条件
将问题可以分解的条件
def fn(n):
# 基线条件 判断n是否是1 如果是1不能再继续递归
if n == 1:
# 1的阶乘就是1，直接返回1
return 1
# 递归条件
return n * fn(n-1)
print(fn(2))
六、递归的练习
练习1. 创建一个函数 来为任意数字做幂运算 n ** i 5 ** 3
def fn(n,m):
if m==1:
return n
return n*fn(n,m-1)
# return n**m
r = fn(7,3)
print(r) #343
print(7**3) #343
# 10 ** 5 = 10 * 10 ** 4
# 10 ** 4 = 10 * 10 ** 3
# ...
# 10 ** 1 = 10
def fn1(n,i):
# 参数 n:要做幂运算的数字 i 做幂运算的次数
# 基线条件
if i == 1:
# 求1次幂
return n
# 递归条件
return n * fn1(n,i-1)
print(fn1(5,4)) #625
print(5**4) #625
练习2 回文检测
# 创建一个函数，用来检测任意字符串是否是回文字符串，如果是返回True,如果不是返回False
# 什么是回文字符串？字符串从后往前读和从后往前读是一样的 例如 abcba abc
# abcdefgfedcba
# 先去检测第一个字符和最后一个字符是否一致,如果不一致则不是回文字符串
# 如果一致，则看剩余部分是否是回文字符串
# 检查abcdefgfedcba 是不是回文
# 检查bcdefgfedcb 是不是回文
# 检查 cdefgfedc 是不是回文
# ...
# 检查 fgf 是不是回文
# 检查 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('ab558ba'))
第二种写法
def fn(s):
l = len(s)
ls = list(s)
if(l<2):
return True
if(l>=2):
l1 = l//2
while l1>0:
if(ls[0] != ls[-1]):
return False
ls.pop(0)
ls.pop(-1)
l1-=1
return True
print(fn('123o721'))
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
