Python中的函数

1.函数的定义

函数定义，即函数是一段可以重复使用的代码,用来独立的完成某个功能

1.def定义

在Python中函数的定义方式为：

def function_name():
	print("Hello World")

其中function_name是函数名，print(“Hello World”)是定义的函数内容
当我们运行这个函数后
（注意：函数是先定义再使用）

function_name()

运行结果：

Hello World

2.lambda定义

lambda定义的函数是匿名函数，也叫一行语句函数，函数没有名字，我们需要给赋一个新的名字

lambda 形式参数 : 函数内容

形式参数可以为多个

new_name = lambda x, y : x + y
print(new_name(1, 2))

执行结果：

3

2.参数

形参和实参

还记得我们是怎么定义函数的吗
让我们回顾一下

def function_name(formal):
	print("Hello World")

其中括号里formal指的就是形式参数

function_name(actual)

其中括号里actual指的就是实际参数

位置参数和关键字参数

我们的形参和实参包括（位置参数和关键字参数）
位置参数

def print_args(arg1, arg2, arg3):
    print(arg1, arg2, arg3)
print_args(1, 2, 3)
print_args(3, 2, 1)

运行结果

1 2 3
3 2 1

关键字参数
（注意：使用关键字传参的时候，等号左右不能加空格且必须通过关键字去对应）

def print_args(arg1, arg2, arg3):
    print(arg1, arg2, arg3)
print_args(arg1=2, arg2=3, arg3=4)
print_args(arg2=2, arg3=3, arg1=4)    

运行结果

2 3 4
4 2 3

位置参数和关键字参数
当我们想同时使用位置参数和关键字参数时，关键字参数要跟在位置参数后

def print_args(arg1, arg2, arg3):
    print(arg1, arg2, arg3)
print_args(1, 2, arg3=10)

运行结果

1 2 10

我们还规定了 （/ 前只能用位置参数，* 后只能用关键字参数）

# /前只能用位置参数
# *后只能用关键字参数
def fun_args(arg1, arg2, arg3, /):
    print(arg1, arg2, arg3)
fun_args(1, 2, 3)
def fun_args(*, arg1, arg2, arg3):
    print(arg1, arg2, arg3)
fun_args(arg1=1, arg2=2, arg3=3)

运行结果

1 2 3
1 2 3

3.返回值

返回值，return，可以返回一个值也可以返回多个值，可以直接结束函数

4.嵌套函数和递归函数

嵌套函数

嵌套函数定义，即在函数内部可以再定义另外一个函数

def outer():
    def inner():
        print("inner")
    inner()
    print("outer")
outer()

运行结果

inner
outer

递归函数

递归函数定义，即一个函数内部，调用了自己，循环往复

def multiplication(n):
    if n == 1:
        return 1
    else:
        return multiplication(n - 1) * n
print(multiplication(5))

运行结果

120

练习

练习1

定义函数

定义一个函数，要求：有三个形参，可以不传递参数，可以传递一个参数，可以传递两个参数，可以传递三个参数

def func_args(arg1=None, arg2=None, arg3=None):
    print(arg1, arg2, arg3)
func_args()
func_args(1)
func_args(1, 2, )
func_args(1, 2, 3)

运行结果

None None None
1 None None
1 2 None
1 2 3

定义一个函数，要求：有三个形参，第一个参数必须以位置参数传递，第二个和第三个参数必须以关键字参数传递

def func_args(arg1, /, *, arg2=None, arg3=None):
    print(arg1, arg2, arg3)
func_args(1)
func_args(1, arg2=2)
func_args(1, arg2=2, arg3=3)

运行结果

1 None None
1 2 None
1 2 3

练习2

lambda使用

fruit_list = [‘watermelon’, ‘apple’, ‘grape’, ‘mango’, ‘pineapple’, ‘blueberry’, ‘strawberry’]
对fruit_list进行排序，要求：按照每个元素的最后一个字符进行排序，如果相等，按照倒数第二个字符排序

fruit_list = ['watermelon', 'apple', 'grape', 'mango', 'pineapple', 'blueberry', 'strawberry']
fruit_list.sort(key=lambda x: (x[-1], x[-2]))
print(fruit_list)

运行结果

['apple', 'pineapple', 'grape', 'watermelon', 'mango', 'blueberry', 'strawberry']

涉及范围：list方法详解

练习3

递归函数的使用(选做)

list = [{‘name’: ‘小红’, ‘sub’: [{‘name’: ‘小明’, ‘sub’: [{‘name’: ‘小花’}]}, {‘name’: ‘小黑’}]}]
这是一个嵌套列表，但是嵌套的可能有n层，如何运用递归函数得到列表中所有的name值，并且有层级关系的名字需要拼接起来，得到的结果是[‘小红’, ‘小红/小明’, ‘小红/小明/小花’, ‘小红/小黑’]

def get_names(data, prefix=''):
    result = []
    for item in data:
        name = item['name']
        full_name = prefix + '/' + name if prefix else name
        result.append(full_name)
        if 'sub' in item:
            sub_names = get_names(item['sub'], full_name)
            result.extend(sub_names)
    return result
data = [{'name': '小红', 'sub': [{'name': '小明', 'sub': [{'name': '小花'}]}, {'name': '小黑'}]}]
names = get_names(data)
print(names)

运行结果

['小红', '小红/小明', '小红/小明/小花', '小红/小黑']