Python之第七章 函数 --- 基础
目录
Python之第七章 函数 --- 基本
1.模块化程序设计
1.基本思想
2.特点
2.定义函数
1.格式：
2.函数名：
3.形式参数：
4.函数体
编辑
3.函数调用
1.作用
2.格式
3.调用方式
4.实例
4.return语句
1.作用
2.注意
3.return可以返回任意Python的对象
5.函数参数
1.位置参数
2.关键字参数
3.默认参数
4.不定长参数（可变参数）
6.变量作用域
1.作用域
2.编程语言中变量的作用域从结构形式分成
3.Python的作用域共分4层
4.Python查找规则
5.全局变量和局部变量
6.global 和 noniocal关键字
global --- 指定当前变量使用外部的全局变量
面试真题：
nonlocal --- 修改签到作用域中的变量
7.函数递归调用
1.作用
2.例 递归算法计算n!
3.注意：
8.匿名函数
1.使用lambda关键字创建匿名函数
2.格式
3.匿名函数只能有一个表达式，有自己的命名空间，不用再写return语句，表达式的结果就是其返回值
Python之第七章 函数 --- 基本
1.模块化程序设计
1.基本思想
将一个大型程序按照功能分隔成若干个小型模块
2.特点
1. 模块相对独立，功能单一、结果清晰、接口简单（内聚、耦合）
2. 减少程序的复杂性
3. 提高元器件的可靠性
4. 缩短软件开发周期
5.避免程序开发的重复劳动
2.定义函数
1.格式：
def 函数名（形参列表）：#函数首部
内部功能代码 # 函数体
return 表达式2.函数名：
函数名区分其他函数作用，本质是该函数在内存所占空间的首地址，是一个常量，命令要求见名知意
3.形式参数：
作用 --- 函数接收数据的变量空间
原则 --- 调用函数的时候，形参变量会分配空间，调用结束后释放空间
设计 --- 形参名称、个数，多个参数使用逗号分隔
4.函数体
编写程序实现函数功能
def summer(lis):
'''这里写函数的说明文档,
:param lis : 参数列表说明,
:return:返回值说明
'''
t = 0
for i in lis:
t += i
return t
summer()
3.函数调用
1.作用
使用函数功能，传递参数
2.格式
函数名 ( 实参列表 )
3.调用方式
fun(m) # 调用fun函数，将实参m传递给形参
n = fun(m) # 调用fun函数，返回值赋值给n变量
s = s*fun(m) # 调用fun函数，返回值参与后续运算
fun() # 无返回值、无参，只是执行一次4.实例
例 计算C（m，n） = m! / (n! * (m-n)!)
# 例 计算C（m，n） = m! / (n! * (m-n)!)
def fun(x):
'''
:param x: 需要进行阶乘的参数
:return: 返回X的阶乘
'''
funx = 1
for i in range(1, x + 1):
funx = funx * i
return funx
m = int(input("请输入m的值："))
n = int(input("请输入n的值："))
C = fun(m) / (fun(n) * fun(m - n))
print('结果：', C)
结果：
请输入m的值：5
请输入n的值：2
结果： 10.0
4.return语句
1.作用
表示函数执行到此结束，返回其后的对象，函数执行到此结束，若无返回值，省略return语句，会返回None
2.注意
一旦函数执行过程中遇到return语句，之后的函数体代码都不会执行，会跳出函数体
def func():
pass
return # 此时，后边的代码都不会执行
print()
pass3.return可以返回任意Python的对象
5.函数参数
1.位置参数
不许参数、必备参数，必须按照正确的顺序传到函数中，实参和形参按位置对齐，个数相同
def fun(str1, str2): # 形参
print(str1, str2)
fun('hello', 'world') # 实参2.关键字参数
使用形参的名字来确定输入的参数值，实参不再需要与形参的位置完全一直
def fun(str1, str2): # 形参
print(str1, str2)
fun(str2='hello', str1='world') # 实参3.默认参数
调用参数时，如果没有传递参数，会默认使用默认阐述
def fun(str1, str2): # 形参
print(str1, str2)
fun('hello') # 实参注意 ：
默认参数必须写到形参列表的最右边，否则报错
默认参数尽量不要指向不变的对象
例 国内上市某互联网公司的Python面试题：
def func(a=[]): a.append('A') return a print(func()) print(func()) print(func()) 结果： ['A'] ['A', 'A'] ['A', 'A', 'A'] 而不是： ['A'] ['A'] ['A'] #原因：函数体装入内存后，a列表会被创建，内存中有a列表内容，伴随着每一次调用a列表都不会清空回收，会继续使用直到程序结束 def func(a=[]): print('函数内部a的地址为：%s' % id(a)) a.append('A') return a b = print(func()) print('b的地址为：%s' % id(b)) print(b) c = print(func()) print('c的地址为：%s' % id(c)) print(c) d = print(func()) print('d的地址为：%s' % id(d)) print(d) 结果： 函数内部a的地址为：2915279324672 ['A'] b的地址为：140722425179352 None 函数内部a的地址为：2915279324672 ['A', 'A'] c的地址为：140722425179352 None 函数内部a的地址为：2915279324672 ['A', 'A', 'A'] d的地址为：140722425179352 None需要输出结果为 --- 使用不变的类型作为默认值修改
['A'] ['A'] ['A']def func(a=None): if a is None: a = [] a.append('A') return a print(func()) print(func()) print(func()) 结果： ['A'] ['A'] ['A']
4.不定长参数（可变参数）
定义 --- 传入的参数可以是任意多个
格式1 --- * 形参，增加一个星号，可以接受多个参数并存储到元组中
例
def func(str1, *str2):
print(str1, str2)
func('hello', 'world', 'china', '123456')
结果：
hello ('world', 'china', '123456')格式2 --- ** 参数，增加两个星号，以关键字参数形式传递，以字典形式存储
例
def func(str1, **str2):
print(str1, str2)
func('hello', a='world', b='china', c='123456')
结果：
hello {'a': 'world', 'b': 'china', 'c': '123456'}注意：
若形参列表中只有单独的星号，则对实参必须以关键字参数形式传入
def func(str1, *,str2): print(str1, str2) func('hello', str2='world') 结果： hello world
6.变量作用域
1.作用域
作用域指变量的有效范围，决定访问权限
2.编程语言中变量的作用域从结构形式分成
块级、函数、类、模块、包（由小到大），Python没有块级 等同于普通语句
3.Python的作用域共分4层
| 层 | 作用 |
|---|---|
| L（local） | 局部 |
| E（enclosing） | 闭包函数外的函数中 |
| G（global） | 全局 |
| B（built-in） | 内建 |
x = int(2, 9) # 内建作用域
global_bar = 0 # 全局作用域
def outer():
out_ver = 1 # 闭包函数外的函数中
def inner():
in_var = 2 # 局部作用域4.Python查找规则
L -> E -> G -> B的顺序查找变量，即在局部找不到变量则回到局部外去找，再找不到则到全局去找，最后到内建去找变量，若还找不到则报错
5.全局变量和局部变量
定义在函数内部的称为局部变量，定义在函数外的变量全局的作用域，称为全局变量
a = 1 # 全局变量
def func():
b = 2 # 局部变量
print(a)
def inner():
c = 3 # 更局部的变量
print(a)
print(b) # b外部变量
print(c)
func()
结果：
16.global 和 noniocal关键字
total = 0 # 全局变量
def plus(arg1, arg2):
total = arg1 + arg2
print('函数内局部变量total =', total)
print('函数内局部变量total地址为:%s' % id(total))
return total
plus(10, 20)
print('函数外的全局变量total=', total)
print('函数外的全局变量total地址为:%s' % id(total))
结果：
函数内局部变量total = 30
函数内局部变量total地址为:3010629299408
函数外的全局变量total= 0
函数外的全局变量total地址为:3010629298448global --- 指定当前变量使用外部的全局变量
total = 0 # 全局变量
def plus(arg1, arg2):
global total # 使用global声明此处total引用外部的total
total = arg1 + arg2
print('函数内局部变量total =', total)
print('函数内局部变量total地址为:%s' % id(total))
return total
plus(10, 20)
print('函数外的全局变量total=', total)
print('函数外的全局变量total地址为:%s' % id(total))
结果：
函数内局部变量total = 30
函数内局部变量total地址为:2221631892688
函数外的全局变量total= 30
函数外的全局变量total地址为:2221631892688面试真题：
a = 10
def test():
a += 1
print(a)
test()
#执行会报错，a += 1 相当于a = a+1 所覆盖，Python规定如果函数内部需要修改一个变量，那么该变量为内部变量，除非使用global声明
#应修改为下列结果
a = 10
def test():
global a # 声明使用外部变量
a += 1
print(a)
test()nonlocal --- 修改签到作用域中的变量
a = 1
print('全局变量a的地址：', id(a))
def fun():
a = 2
print('函数fun内部a的地址为：', id(a))
def inner():
nonlocal a
a = 3
print('函数inner调用后闭包内部变量a的地址：', id(a))
inner()
print('函数 inner低啊用后，闭包外部的a的地址：', id(a))
fun()
结果：
全局变量a的地址： 2248198875440
函数fun内部a的地址为： 2248198875472
函数inner调用后闭包内部变量a的地址： 2248198875504
函数 inner低啊用后，闭包外部的a的地址： 22481988755047.函数递归调用
1.作用
一个函数在它的函数内部调用自身称为递归调用
2.例 递归算法计算n!
def fun(n):
if n == 0:
return 0
else:
if n > 1:
x = fun(n - 1) * n
else:
x = 1
return x
m = int(input('请输入一个正整数：'))
print('阶乘的结果为：', fun(m))
结果：
请输入一个正整数：30
阶乘的结果为： 2652528598121910586363084800000003.注意：
1.每一次递归，整体问题的值都要比原来的要小，并且低轨道一定层次后必须给出结果。
2.为了防止递归的无休止调用，必须在函数内部有终止递归的手段，一般配合if-else语句
3.递归需要注意防止递归深度溢出，在Python中使用栈这种数据结构实现的，默认的深度为1000层，超出该深度会抛出异常，每当进入下一个递归时，栈会增加一层，当函数每返回一次。栈会减少一层
4.递归可以使用程序变得简洁，增加程序可读性，但每次递归都要重新开辟内存空间
8.匿名函数
当创建函数时有时不需要显式的定义函数，直接省略函数名传入参数计算即可，省略函数的命名，通过水平不发生表达式实现函数
1.使用lambda关键字创建匿名函数
所谓匿名即不再使用def关键字来创建函数
lambda --- 只是一个表达式，不是一个代码块，函数体比def定义的函数简单
lambda --- 只能封装有限的逻辑语句
2.格式
lambda 参数 : 表达式
lambda x: x * x
# 相当于
def fun(x):
return x * xlambda 势函数关键字
lambda之后的x为函数参数，相当于原先的形参
x*x为执行代码