函 数

6.1 定义函数

语法格式如下

 例如，定义一个计算两个数之和的函数，代码如下：

无参函数：

def add():
    result = 11 + 22
    print(result)

有参函数：

def add():
    result = 11 + 22
    print(result)

6.2调用函数

函数在定义完成后不会立刻执行，直到被程序调用时才会执行。

语法格式如下：

函数名([参数列表])

函数内部也可以调用其他函数，这被称为函数的嵌套调用。

 

 6.3函数参数的传递

函数参数的传递可以分为位置参数传递、关键字参数传递、默认参数传递、参数的打包与解包以及混合传递。

6.3.1位置参数的传递

函数在被调用时会将实参按照相应的位置依次传递给形参，也就是说将第一个实参传递给第一个形参，将第二个实参传递给第二个形参，以此类推。

def get_max(a, b):
    if a > b:
        print(a,"是较大的值！")
    else:
        print(b,"是较大的值！")
get_max(8, 5)

6.3.2关键字参数的传递

关键字参数的传递是通过“形参=实参”的格式将实参与形参相关联，将实参按照相应的关键字传递给形参。

def connect(ip, port):
    print(f"设备{ip}:{port}连接！")
connect(ip="127.0.0.1", port=8080)

6.3.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连接！

6.3.4参数的打包与解包

1.打包——“*”

定义：

def test(*args):    print(args)

调用：

tst(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.1解包

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}

2.2解包

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

6.4函数的返回值

函数中的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)

6.5变量作用域

变量并非在程序的任意位置都可以被访问，其访问权限取决于变量定义的位置，其所处的有效范围称为变量的作用域。

6.5.1局域变量和全局变量

根据作用域的不同，变量可以划分为局部变量和全局变量。

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()

2.全局变量

全局变量可以在整个程序的范围内起作用，它不会受到函数范围的影响。

number = 10         							# 全局变量
def test_one():
    print(number)   							# 函数内部访问全局变量
test_one()
print(number)       							

全局变量在函数内部只能被访问，而无法直接修改。

 函数内部只能访问全局变量，而无法直接修改全局变量。

6.5.2 global和nonlocal关键字

1.global关键字

使用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()

6.7.1递归函数

递归函数的执行可以分为以下两个阶段：

1.递推：递归本次的执行都基于上一次的运算结果。

2.回溯：遇到终止条件时，则沿着递推往回一级一级地把值返回来。

递归函数的一般定义格式如下所示：

def函数名([参数列表])：
	if 边界条件：
		rerun 结果
	else:
		return 递归公式

6.7.2匿名函数

匿名函数是一类无需定义标识符的函数，它与普通函数一样可以在程序的任何位置使用。Python中使用lambda关键字定义匿名函数，它的语法格式如下：

lambda <形式参数列表> :<表达式>

 

# 定义匿名函数，并将它返回的函数对象赋值给变量temp
temp = lambda x : pow(x, 2) 
temp(10)