1、函数的返回值
1.1遍历元祖
返回值就是函数执行以后返回的结果
求任意数的和
可以通过return 来指定函数的返回值
def fn(*nums):
#定义一个变量保存结果
result = 0
#遍历元祖,并将元组中的元素累加
for n in nums:
result += n
print(result)
fn(1,2,3,4)
返回值:10
1.2 函数返回值
返回值可以直接使用,也可以通过一个变量来接收函数返回值的结果
return 后面可以跟任意的对象,甚至可以是一个函数
def fn():
#return 100 # 100
#return [1,2,3] # [1,2,3]
#return 1+1 # 2
#return False # False
def fn2():
print('python')
return fn2
r = fn()
print®
r()
返回值依次是:
<function fn..fn2 at 0x000001F089AE8268>
python
1.3 return None
如果仅仅写一个return,或者不写return 则相当于return None
def fn2():
#return
a = 10
r=fn()
print®
返回值:None
1.4 return 函数一旦执行,程序自动结束,返回调用处
在函数中,return后面的代码都不会执行,return一旦执行,函数自动结束
def fn3():
print('Hello')
return
print('abc')
r=fn3()
print(r)
返回值:
Hello
1.5 continue、break、return比较
下面程序依次测试break、continue、return
def fn4():
for i in range(5):
if i == 3:
#continue # 用来跳过当次循环
#break # 用来退出当前循环
#return # 用来结束函数,返回调用处
print(i)
print('循环结束')
fn4()
break返回值:
0
1
2
循环结束
continue返回值:
0
1
2
4
循环结束
return返回值:
01
2
1.6 fn 和 fn() 的区别
def fn5():
return 10
print(fn5) #是函数对象实际上在打印函数对象
返回值:<function fn5 at 0x000001D11DFE96A8>
print(fn5()) #是调用函数,实际上是在打印函数fn5()的返回值
返回值:10
2、文档字符串
help() 可以查询python函数中的用法
help(函数对象)
help(print)
Help on NoneType object:
class NoneType(object)
| Methods defined here:
|
| bool(self, /)
| self != 0
|
| new(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| repr(self, /)
| Return repr(self).
def fn(a:int,b:str,c:bool) -> int:
'''
函数的参数
:param a: 作用...
:param b: 作用...
:param c: 作用...
:return: int
'''
return 10
help(fn)
返回值:
Help on function fn in module __main__:
fn(a:int, b:str, c:bool) -> int
函数的参数
:param a: 作用...
:param b: 作用...
:param c: 作用...
:return: int
3、函数的作用域
函数作用域:是指变量生效的区域
在python中有两种作用域
**全局作用域:**全局作用域在程序执行时创建,在程序结束时销毁
所有函数以外的区域都是全局作用域
在全局作用域定义的变量,都属于全局变量,全局变量可以在程序中的任意位置访问
**函数作用域:**函数作用域在函数创建时创建,在调用结束时销毁
函数每调用一次就会产生一个新的函数作用域
在函数作用域中,定义的变量 都是局部变量,它只能在函数内部被访问
a = 20
def fn():
a = 10 #定义在函数内部,所以它的作用域就是函数内部,函数外部无法访问
print('函数内部','a=',a)
print('函数外部','a=',a)
返回值:
函数内部 a= 10
函数外部 a= 20
def fn2():
a = 30
def fn3():
print('fn3中:','a=',a)
fn3()
fn2()
返回值:fn3中:a = 30
函数内部定义的变量优先考虑
def fn2():
a = 30
def fn3():
a = 40
print('fn3中:','a=',a)
fn3()
fn2()
返回值:fns中:a = 40
global 如果希望在函数内部修改全局变量,则需要使用global关键字来声明变量
a = 20
def fn():
global a #声明在函数内部的使用a是全局变变量,此时再去修改a时,就是修改全局变量
a = 10
print('函数内部','a=',a)
fn()
print(‘函数外部’,‘a=’,a)
返回值:
函数内部 a= 10
函数外部 a= 10
4、命名空间
命名空间实际上就是一个字典,是一个专门用来存储变量的字典,
locals()函数用来获取当前作用域的命名空间
如果在全局作用域中调用locals()函数,则获取全局作用域命名空间,如果在函数作用域中,调用locals()则获取的是函数命名空间,返回的是一个字典。
a = 20
s = locals() #当前的命名空间
s[‘b’] = 100 #向字典中添加key-value 就相当于在全局变量中创建了一个变量
print(‘b=’,b)
print(s)
b = 100
#下面的字典中有‘a’:20,‘b’:100
{‘name’: ‘main’, ‘doc’: None, ‘package’: None, ‘loader’: <_frozen_importlib_external.SourceFileLoader object at 0x000001FE51213348>, ‘spec’: None, ‘annotations’: {}, ‘builtins’: <module ‘builtins’ (built-in)>, ‘file’: ‘D:/python/pycharmPro/函数2.py’, ‘cached’: None, ‘a’: 20, ‘s’: {…}, ‘b’: 100}
def fn4():
a = 10
s = locals() #在函数内部调用locals()会获取函数的命名空间
s['b'] = 20
print(s)
fn4()
返回值:
{‘a’: 10, ‘b’: 20}
def fn5():
a = 10
global_space = globals() #globals()函数可以用来在任意空间位置获取全局命名空间
print(global_space)
fn5()
{‘name’: ‘main’, ‘doc’: None, ‘package’: None, ‘loader’: <_frozen_importlib_external.SourceFileLoader object at 0x000002661C303308>, ‘spec’: None, ‘annotations’: {}, ‘builtins’: <module ‘builtins’ (built-in)>, ‘file’: ‘D:/python/pycharmPro/函数2.py’, ‘cached’: None, ‘fn3’: <function fn3 at 0x000002661DE6C828>, ‘a’: 20, ‘fn4’: <function fn4 at 0x000002661DE6C8B8>}
5、递归
5.1 尝试求出10的阶乘(10!)
1! = 1 = 1
2! = 1*2 = 2
3! = 1*2*3 = 6
4! = 1*2*3*4 = 24
print(1*2*3*4*5*6*7*8*9*10)
返回值:3628800
定义一个函数,实现任意数的阶乘
创建一个变量保存结果
#n = int(input(‘请输入一个阶乘数字:’))
#range(1,11)求10的阶乘,但不包含11
for i in range(1,11):
n *= i
print(n)
返回值:3628800
5.2 创建一个函数,求任意数的阶乘
def fn(n):
#创建一个变量,来接收结果
result = n
for i in range(1,n):
result *= i
return result
print(fn(10))
返回值:3628800
5.3 递归式的函数
递归简单理解就是自己调用自己
递归式函数就是在函数中调用自己
def fn2():
fn2()
fn2()
递归是解决问题的一种方式
递归式函数的两个条件
1)基线条件:问题可以被分解成最小的问题,当满足基线条件时递归不再进行。
2)递归条件:将问题继续分解的条件。
5.4 用递归算法求任意数的阶乘
def fn2(n):
#基线条件
if n == 1:
#1的阶乘是它本身
return 1
#递归条件
return n * fn2(n-1)
print(fn2(10))
返回值:3628800
5.5 定义了一个函数,其中有两个参数 n 要做幂运算的数字 i做幂运算次数
def fn4(n,i):
#基线条件 幂为1
if i == 1:
return n
#递归条件
return n*fn4(n,i-1)
print(fn4(2,4))
返回值:16
5.6 创建一个函数,用来检查任意的字符串是否是回文字符串,如果是返回值是True,不是返回False
回文字符串,字符串从后往前念和从前往后念是一样的
abcdefgfedcba
首先检查第一个字符和最后一个字符是否一致,如果不一致不是回文字符串
如果一致则看剩余部分是否是回文字符串
检查bcdefgfedcb 是不是回文
检查cdefgfedc 是不是回文
检查 defgfed 是不是回文
检查 efgfe 是不是回文
检查 fgf 是不是回文
检查 g 是不是回文,g一定是回文
def fn5(s):
#基线条件
if len(s) < 2:
#字符串的长度小于2 则这个字符串一定是回文
return True
elif s[0] != s[-1]:
#如果第一个字符和最后一个字符不相等,不是回文
return False
#递归条件,此处需要注意列表左开右闭
return fn5(s[1:-1])
print(fn5(‘abcdefgfedcba’))
返回值:True
print(fn5(‘python’))
返回值:False
6、引入高阶函数
特点:
1)接收一个或多个函数作为参数
2)将函数作为返回值返回
满足任意一个特点就是高级函数
定义一个函数,可以将指定列表当中的所有偶数保存到一个新的列表中返回
#定义一个函数
def fn(lst):
#创建一个新的列表
new_list = []
#
for n in lst:
#判断n的奇偶
if n % 2 ==0:
new_list.append(n)
#返回新的列表
return new_list
l = [1,2,3,4,5,6,7,8,9,10]
print(fn(l))
返回值:2,4,6,8
当我们使用一个函数作为参数时,实际上是将指定的代码传递进了目标函数
l = [1,2,3,4,5,6,7,8,9,10]
定义一个函数 用来检测一个任意数的偶数
def fn2(i):
if i % 2 == 0:
return True
定义一个函数,用来检查制定数字是否大于5
def fn3(i):
if i > 5:
return True
return False
定义一个函数,用来检测列表中能被3整除的数
def fn4(i):
if i % 3 == 0:
return True
False
#定义一个高阶函数,将上面的函数逐一代入
def fn(func,lst):
创建一个新的列表
new_list = []
#
for n in lst:
if func(n):
#判断n的奇偶
new_list.append(n)
#返回新的列表
return new_list
print(fn(fn2,l))
返回值:2,4,6,8,10
print(fn(fn4,l))
返回值:3,6,9
print(fn(fn3,l))
返回值:6, 7, 8, 9, 10