1. 函数概述
函数是组织好的、实现单一功能或相关联功能的代码段。我们可以将函数视为一段有名字的代码，这类代码可以在需要的地方以“函数名()”的形式调用。
input() #输入
print() #输出
（1）未使用函数的程序
# 打印边长为2个星号的正方形
for i in range(2):
for i in range(2):
print("*",end=" ")
print()
# 打印边长为3个星号的正方形
for i in range(3):
for i in range(3):
print("*",end=" ")
print()
# 打印边长为4个星号的正方形
for i in range(4):
for i in range(4):
print("*",end=" ")
print()# 打印正方形的函数
def print_triangle(lenth):
for i in range(lenth):
for i in range(lenth):
print("*",end="")
print()(2) 使用函数的程序
# 使用函数，打印边长为2个星号的正方形
print_triangle(2)
# 使用函数，打印边长为3个星号的正方形
print_triangle(3)
# 使用函数，打印边长为4个星号的正方形
print_triangle(4)函数式编程优点：
2.函数的定义和调用
前面使用的print()函数和input()都是Python的内置函数，这些函数由Python定义。开发人员也可以根据自己的需求定义函数，Python中使用关键字def来定义函数，其语法格式如下：
举例：定义一个计算两个数之和的函数
# 无参函数
def add():
result = 11 + 22
print(result)
有参函数
def add_modify(a, b):
result = a + b
print(result)
(2) 调用函数
1）函数在定义完成后不会立刻执行，直到被程序调用时才会执行
函数名([参数列表])
1. 程序在调用函数的位置暂停执行。
2. 将数据传递给函数参数。
3. 执行函数体中的语句。
4. 程序回到暂停处继续执行。
2）函数内部也可以调用其他函数，这被称为函数的嵌套调用。
3）函数在定义时可以在其内部嵌套定义另外一个函数，此时嵌套的函数称为外层函数，被嵌套的函数称为内层函数。
3. 函数参数的传递
我们通常将定义函数时设置的参数称为形式参数（简称为形参），将调用函数时传入的参数称为实际参数（简称为实参）。函数的参数传递是指将实际参数传递给形式参数的过程。
函数参数的传递可以分为位置参数传递、关键字参数传递、默认参数传递、参数的打包与解包以及混合传递。
(1) 位置参数的传递
函数在被调用时会将实参按照相应的位置依次传递给形参，也就是说将第一个实参传递给第一个形参，将第二个实参传递给第二个形参，以此类推。
def get_max(a, b):
if a > b:
print(a,"是较大的值！")
else:
print(b,"是较大的值！")
get_max(8, 5) # 8是最大的值
(2) 关键字参数的传递
关键字参数的传递是通过“形参=实参”的格式将实参与形参相关联，将实参按照相应的关键字传递给形参。
def connect(ip, port):
print(f"设备{ip}:{port}连接！")
connect(ip="127.0.0.1", port=8080)
注意： 如何区分用的是哪种方式传递 符号"/" 符号“/”符号“/
def func(a, b, /, c):
print(a, b, c)
# 错误的调用方式
# func(a=10, 20, 30)
# func(10, b=20, 30)
# 正确的调用方式
func(10, 20, c=30)
(3) 默认参数的传递
函数在定义时可以指定形参的默认值，如此在被调用时可以选择是否给带有默认值的形参 传值，若没有给带有默认值的形参传值，则直接使用该形参的默认值。
def connect(ip, port=8080):
print(f"设备{ip}:{port}连接！") # 定义
connect(ip="127.0.0.1")
connect(ip="127.0.0.1", port=3306 # 调用设备127.0.0.1:8080连接！
设备127.0.0.1:3306连接！
4. 参数的打包与解包
（1）打包
如果函数在定义时无法确定需要接收多少个数据，那么可以在定义函数时为形参添加“*”或“**”：
def test(*args): # 定义
print(args)
test(11, 22, 33, 44, 55) # 调用
(11, 22, 33, 44, 55)
def test(**kwargs): # 定义
print(kwargs)
test(a=11, b=22, c=33, d=44, e=55) # 调用
{'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55}
（2）解包
def test(a, b, c, d, e): # 定义
print(a, b, c, d, e)
nums = (11, 22, 33, 44, 55) # 调用
test(*nums)
{'a': 11, 'b': 22, 'c': 311 22 33 44 553, 'd': 44, 'e': 55}
def test(a, b, c, d, e): #定义
print(a, b, c, d, e)
nums = {"a":11, "b":22, "c":33, "d":44, "e":55} #调用
test(**nums)
11 22 33 44 55
5. 混合传递
前面介绍的参数传递的方式在定义函数或调用函数时可以混合使用，但是需要遵循一定的规则，具体规则如下：
在定义函数时：
def test(a, b, c=33, *args, **kwargs):
print(a, b, c, args, kwargs) # 定义
test(1, 2)
test(1, 2, 3)
test(1, 2, 3, 4)
test(1, 2, 3, 4, e=5) # 调用
1 2 33 () {}
1 2 3 () {}
1 2 3 (4,) {}
1 2 3 (4,) {'e': 5}
6. 函数的返回值
函数中的return语句会在函数结束时将数据返回给程序，同时让程序回到函数被调用的位置继续执行。
def filter_sensitive_words(words): # 定义
if "山寨" in words:
new_words = words.replace("山寨", "**")
return new_words
result = filter_sensitive_words("这个手机是山寨版吧！") # 调用
print(result)
这个手机是**版吧！
如果函数使用return语句返回了多个值，那么这些值将被保存到元组中。
def move(x, y, step):
nx = x + step
ny = y - step #定义
return nx, ny # 使用return语句返回多个值
result = move(100, 100, 60) #调用
print(result)
(160, 40)
7. 变量作用域
变量并非在程序的任意位置都可以被访问，其访问权限取决于变量定义的位置，其所处的有效范围称为变量的作用域。
根据作用域的不同，变量可以划分为局部变量和全局变量。
（1）局部变量
def test_one():
number = 10 # 局部变量
print(number) # 函数内部访问局部变量
test_one()
print(number) # 函数外部访问局部变量
不同函数内部可以包含同名的局部变量，这些局部变量的关系类似于不同目录下同名文件的关系，它们相互独立，互不影响。
示例：
def test_one():
number = 10
print(number) # 访问test_one()函数的局部变量number
def test_two():
number = 20
print(number) # 访问test_two()函数的局部变量number
test_one()
test_two()
10
20
（2）全局变量
number = 10 # 全局变量
def test_one():
print(number) # 函数内部访问全局变量
test_one()
print(number) # 函数外部访问全局变量
10
10全局变量在函数内部只能被访问，而无法直接修改
这是因为函数内部的变量number视为局部变量，而在执行“number+=1”这行代码之前并未声明过局部变量number
函数内部只能访问全局变量，而无法直接修改全局变量
示例：
# 定义全局变量
number = 10 # 已经声明
def test_one():
print(number)
number += 1
test_one()
print(number)
LEGB原则：
LEGB是程序中搜索变量时所遵循的原则，该原则中的每个字母指代一种作用域，具体如下：
L-local
局部作用域
例如，局部变量和形参生效的区域。
E-enclosing
嵌套作用域
例如，嵌套定义的函数中外层函数声明的变量生效的区域。
G-global
全局作用域
例如，全局变量生效的区域。
B-built-in
内置作用域
例如，内置模块声明的变量生效的区域。
Python在搜索变量时会按照“L-E-G-B ”这个顺序依次在这四种区域中搜索变量：若搜索到变量则终止搜索，使用搜索到的变量；若搜索完L、E、G、B这四种区域仍无法找到变量，程序将抛出异常。
8. global和nonlocal关键字
函数内部无法直接修改全局变量或在嵌套函数的外层函数声明的变量，但可以使用global或nonlocal关键字修饰变量以间接修改以上变量。
（1） global关键字1.glob
al关键字
使用global关键字可以将局部变量声明为全局变量，其使用方法如下：
global 变量
number = 10 # 定义全局变量
def test_one():
global number # 使用global声明变量number为全局变量
number += 1
print(number)
test_one()
print(number)
（2）nonlocal关键字
使用nonlocal关键字可以在局部作用域中修改嵌套作用域中定义的变量，其使用方法如下：
nonlocal 变量
def test():
number = 10
def test_in():
nonlocal number
number = 20
test_in()
print(number)
test()
9. 特殊形式的函数
（1）递归函数
1）函数在定义时可以直接或间接地调用其他函数。若函数内部调用了自身，则这个函数被称为递归函数。
2）递归函数在定义时需要满足两个基本条件：一个是递归公式，另一个是边界条件。其中:
3）递归函数的执行可以分为以下两个阶段：
a递推：递归本次的执行都基于上一次的运算结果。
b回溯：遇到终止条件时，则沿着递推往回一级一级地把值返回来。
def函数名([参数列表])：
if 边界条件：
rerun 结果
else:
return 递归公式
实例（递归函数 阶乘n)
n! = 1 * 2 * 3 * … * n，可以分为以下两种情况：
1. 当n=1时，所得的结果为1。 #边界条件
2. 当n>1时，所得的结果为n*(n-1)!。#递归公式
1:
def func(num):
if num == 1:
return 1
else:
return num * func(num - 1)
num = int(input("请输入一个整数："))
result = func(num)
print("5!=%d"%result)
2:
(2) 匿名函数
匿名函数是一类无需定义标识符的函数，它与普通函数一样可以在程序的任何位置使用。Python中使用lambda关键字定义匿名函数，它的语法格式如下：
lambda <形式参数列表> :<表达式>
1) 匿名函数与普通函数的主要区别如下：a普通函数在定义时有名称，而匿名函数没有名称；
2) 定义好的匿名函数不能直接使用，最好使用一个变量保存它，以便后期可以随时使用这个函数:
# 定义匿名函数，并将它返回的函数对象赋值给变量temp
temp = lambda x : pow(x, 2)
temp(10)
扫一扫
9923
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
