第11讲 python函数进阶

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