Python函数

函数的定义和调用

函数可以用来封装代码，实现代码的重用。

函数的定义

Python中使用关键字 def 定义函数，后跟函数名称和带括号的形式参数列表。函数内容以:起始，并且缩进。

语法:

def 函数名称(参数列表):
    代码...

示例:

def hello1():
    print("Hello,World")

def hello2():
    print("Hello,World")
    return "Hello"

def hello3(a):
    print(a)

函数的调用

在Python中函数必须先定义再使用，使用函数名后跟圆括号的方式才能调用函数。

示例:

def print_hello():
    print("Hello, World")
# 调用函数
print_hello()  # Hello, World

函数名可以赋值给变量:

def func():
    print("我是一个函数~")

a = func
a()

函数名当作参数传递并调用:

def func2():
    return "这是func2函数"

def func1(f):
    return f()

res = func1(func2)
print(res)  # 这是func2函数

函数名作为函数的值返回并调用:

def func3():
    print("这是func3函数")

def func4(f):
    return f

res = func4(func3)
res()

函数名作为容器数据类型的元素调用:

def func1():
    print("这是func1函数")

def func2():
    print("这是func2函数")

list1 = [func1, func2]
for func in list1:
    func()

函数的参数

定义函数时可以接收一定数量的参数，然后根据实际调用时提供的参数值的不同，输出不同的结果。

示例:

# 接受两个参数，称为形参，实现相加功能
def add_sum(a, b):
    result = a + b
    print(result) # 30
# 调用函数时，传入实参
add_sum(10, 20)

上述示例中，a和b被称为形参，调用时传递的参数10和20被称为实参。

位置参数

def user(name, age):
    print(f'您的名字值{name}，您的年龄是{age}')


user("tom", 20)

如果缺少传递的参数会报错:

def user(name, age):
    print(f'您的名字值{name}，您的年龄是{age}')

# TypeError: user() missing 1 required positional argument: 'age'
user("tom")

关键字参数

def user(name, age, user_id):
    print(f'您的名字是{name}，年龄是{age}，用户id是{user_id}')

user("jerry", user_id=10086, age=20)

注：位置参数必须在关键字参数前面。

默认参数

定义函数的时候，还可以有默认参数，当这个参数没有传递的时候，参数就使用定义时的默认值。

def user(name, age, gender="男"):
    print(f'您的名字是{name}，年龄是{age}，性别是{gender}')


user("tom", 18)
user("lisa", 20, "女")

注：位置参数必须在默认参数前面，包括函数定义和调用。

可变参数

可变参数就是传入的参数个数是可变的，可变参数分为两种：

• 接受任意数量的位置参数，通常使用*args表示。
• 接受任意数量的关键字参数，通常使用**kwargs表示。

*args

所有传入的参数将被放入到一个元组（tuple）中。

def user_info(*args):
    print(args)

user_info("tom")  # ('tom',)
user_info("tom", 20)  # ('tom', 20)
user_info("tom", 20, "男")  # ('tom', 20, '男')
user_info()  # ()

可以直接传递一个列表:

list1 = ["a", "b", "c"]

def user_info(*args):
    print(args)  # ('a', 'b', 'c')
    
# 传入列表的时候需要在前面加一个*
user_info(*list1)

**kwargs

在调用函数时，以关键字参数的形式进行参数传递，最终会将实际参数将组装成字典，kwargs的类型是dict。

def user_info(**kwargs):
    print(kwargs)  # {'name': '张三', 'age': 30}
    print(type(kwargs))  # <class 'dict'>
    
user_info(name="张三", age=30)

可以直接传入一个字典:

dict1 = {"name": "tom", "age": 20, "gender": "man"}

def user_info(**kwargs):
    print(kwargs)  # {'name': 'tom', 'age': 20, 'gender': 'man'}
    print(type(kwargs))  # <class 'dict'>

# 传入字典的时候需要在前面加两个*
user_info(**dict1)

字典拆包:

dict1 = {"name": "tom", "age": 20, "gender": "man"}

name, age, gender = dict1
print(dict1[name])  # tom
print(dict1[age])  # 20
print(dict1[gender])  # man

函数的返回值

在函数中，使用return语句将需要的值返回。return语句用于表示函数执行到此结束，退出函数，并且返回return后面的对象。如果不需要返回值，没有return语句的情况下，默认返回的是None。

示例:

def return_msg():
    return "Hello~~"
res = return_msg()
# 打印返回的值
print(res)  # Hello~~ 
print(type(res))  # <class 'str'>

# 没有return语句，返回的是None
def info():
    print("aaa")
a = info()
print(a)  # None

def return_msg():
    return "Hello~~"
    # 此处代码在return下方，所以不会被执行
    print("world")
res = return_msg()
print(res)  # Hello~~

函数可以返回多个值:

函数返回多个数据，默认是元组类型:

def return_num():
    return 1, 2  # 返回多个数据，默认是元组类型

res = return_num()
print(res)  # (1, 2)

多个变量接受多个返回值:

def return_num():
    name = "tom"
    age = 18
    return name, age

res_name, res_age = return_num()
print(res_name)  # tom
print(res_age)  # 18

函数的嵌套调用

在函数内部，还可以调用其他函数。

嵌套调用

示例1:

def testB():
    print("这是B函数...")
    print("B函数执行结束...")

def testA():
    print("A函数开始")
    testB()
    print("A函数结束")

testA()

输出内容如下:

A函数开始
这是B函数...
B函数执行结束...
A函数结束

示例2:

def print_test1():
    print("*" * 5)

def print_test2(n):
    i = 0
    while i < n:
        print_test1()
        i += 1

print_test2(4)

输出内容如下:

*****
*****
*****
*****

递归函数

除了在函数内部可以调用其他函数外，如果在一个函数内部调用其自身，这个函数就是递归函数。

斐波那契数列:

def fib(n):
    if n == 1 or n == 2:
        return 1
    return fib(n - 1) + fib(n - 2)
print(fib(10)) # 55

求阶乘:

def factorial(n):
    """ n表示要求的数的阶乘 """
    if n == 1:
        return n  # 阶乘为1的时候，结果为1,返回结果并退出
    return n * factorial(n - 1)  # n! = n*(n-1)!

res = factorial(5)  # 调用函数，并将返回的结果赋给res
print(res)  # 打印结果

闭包函数

在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用了外部函数变量的内部函数称为闭包。

示例:

# 外部函数
def func_out():
    num1 = 100

    # 内部函数
    def func_inner():
        # 内部函数使用了外部函数的变量
        result = num1 + 10
        print("result:", result)
    # 外部函数要返回内部函数，这个使用了外部函数变量的内部函数称为闭包
    return func_inner

# 获取闭包对象
new_func = func_out()
# 执行闭包
new_func()

闭包的使用:

def out_name(name):
    def inner_name(msg):
        print(name + ":" + msg)

    return inner_name

# 创建闭包实例
tom = out_name("tom")
tom("你好啊！")
jerry = out_name("jerry")
jerry("你在干嘛啊！")

变量作用域

变量的作用域是指变量的有效范围，变量的作用域分为如下两种：

• 全局变量
• 局部变量

局部变量

定义在函数内部的变量被称为局部变量，拥有一个局部作用域，局部变量只能在其被声明的函数内部访问。

def test():
    a = 10
    print(a)
test()  # 10

# 不能在函数外部访问
# print(a)  # 报错 NameError: name 'a' is not defined

全局变量

定义在函数外的变量拥有全局作用域，被称为全局变量，全局变量可以在整个程序范围内（包括函数里面）访问。

a = 10
def test1():
    print(a)

test1()  # 10

函数内部修改全局变量的值:

a = 10
def test1():
    a = 20  # 此时只是定义了一个局部变量，并没有修改全局变量的值。
    print(a)

test1()  # 20
# 此时a依然是10
print(a)  # 10

global关键字

在上述示例中，如果我们要想修改全局变量的值，可以使用 global 关键字。在函数内部使用global关键字声明的变量是全局变量。

a = 10
def test1():
    global a # 声明a是全局变量，此时函数内部修改外面的全局变量
    a = 20
    print(a)

test1()  # 20

print(a)  # 20

nonlocal关键字

nonlocal关键字用来修改外层的局部变量。

def func_out():
    num1 = 10

    def func_inner():
        nonlocal num1
        num1 = 20
        print(num1)  # 20

    func_inner()
    print(num1)  # 20
func_out()

匿名函数

Python中使用lambda关键字来创建匿名函数。

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。

lambda语法格式:

lambda 参数: 表达式

注意：

• :前面是该匿名函数的参数，:后面的表达式是该函数的返回值

• lambda表达式的参数可有可无。

• lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

示例:

fn = lambda: 100

# lambda内存地址
print(fn)  # <function <lambda> at 0x0000027677989048>

# 调用函数
print(fn())  # 100

求两个数的和: 接收两个参数

add_func = lambda x, y: x + y
print(add_func(10, 20))  # 30

默认参数:

func2 = lambda a, b, c=100: a + b + c
print(func2(10, 20))  # 130

print(func2(10, 20, 30))  # 60

可变参数: *args

func3 = lambda *args: args
print(func3())  # ()
print(func3(1))  # (1,)
print(func3(1, 2))  # (1, 2)
print(func3(1, 2, 3, 4))  # (1, 2, 3, 4)

可变参数: **kwargs

func4 = lambda **kwargs: kwargs
print(func4())  # {}
print(func4(name="tom"))  # {'name': 'tom'}
print(func4(name="tom", age=18))  # {'name': 'tom', 'age': 18}

带判断的lambda:

fn1 = lambda a, b: a if a > b else b
print(fn1(10, 20))

按照指定值排序:

students = [
    {"name": "tom", "age": 18},
    {"name": "jerry", "age": 20},
    {"name": "jack", "age": 22}
]

# 按照name进行升序排序
students.sort(key=lambda x: x["name"])
print(students)  # [{'name': 'jack', 'age': 22}, {'name': 'jerry', 'age': 20}, {'name': 'tom', 'age': 18}]

# 按照name进行降序排序
students.sort(key=lambda x: x["name"], reverse=True)
print(students)

# 按照age进行升序排序
students.sort(key=lambda x: x["age"])
print(students)  # [{'name': 'tom', 'age': 18}, {'name': 'jerry', 'age': 20}, {'name': 'jack', 'age': 22}]

函数的说明文档

函数的说明文档是对函数的解释说明。

查看函数的说明文档

语法:

help(函数名)

示例:

help(print)

定义函数的说明文档

我们自己定义的函数同样可以添加说明文档。

示例:

def add(a, b):
    """
    求和函数add
    :param a: 参数1
    :param b: 参数2
    :return: 返回a+b的和
    """
    return a + b
help(add)