概念

函数（function）是：组织好的、可重复使用的、用于执行特定任务的代码块。

使用函数的主要优势：

• 代码复用：提高代码复用性，减少重复代码。
• 结构清晰：让程序更易读、更易维护。
• 模块化开发：把程序分成若干个小功能，便于团队合作。

分类

Python 中函数分为3类：

内置函数

无需任何操作，直接就能使用。

如：print()、type()、range()等。

内置函数官方文档：https://docs.python.org/zh-cn/3.13/library/functions.html

模块提供的函数

需要先导入指定的模块后，才能使用。

如：math.sqrt()、math.floor()等。

模块函数官方文档：https://docs.python.org/zh-cn/3.13/py-modindex.html

自定义函数

根据自己需要自行定义的函数。（下文细讲）

定义函数

语法格式：

def 函数名():
    函数体
    函数体

示例代码：

def welcome():
    print("欢迎大家都来学习Python")
    print("学会Python，搞AI")

调用函数

语法格式：(下面的语法格式是基本调用形式，不涉及传递参数)

函数名()

示例代码：

welcome()
welcome()

注意：函数必须先定义，再调用。

参数

参数的作用

参数可以让函数能接收外部传入的数据，能让函数更具通用性和灵活性。

示例代码：

def order(num, dish):
    print(f'您点的是：{num}份 {dish}')
    print(f'{dish}可是很好吃的！')
    print(f'您只点了{num}份，够吃吗？\n')

order(2, '辣子鸡')

形参与实参

形参：在定义函数时，用来接收数据的变量叫形参，形参是函数定义者设置的。

实参：在调用函数时，给函数传递的具体值叫实参，实参是函数调用者提供的。

注意：

• 形参存储的到底是什么数据类型，要看调用者传递的实参具体是什么。
• 形参的使用范围仅限函数体内。

位置参数

什么是位置参数？顾名思义，调用函数时，根据参数在函数定义时出现的顺序，把实参的值，依次传递给对应的形参。

注意：在使用位置参数时，实参的个数与顺序，必须和形参保持一致！

示例代码：

def order(num, dish):
    print(f'您点的是：{num}份 {dish}')
    print(f'{dish}可是很好吃的！')
    print(f'您只点了{num}份，够吃吗？\n')

order(2, '辣子鸡')

关键字参数

什么是关键字参数？函数调用时，通过形参名 = 值的形式传递的参数，就是关键字参数。

关键词参数的优势是：调用函数时，传递实参不受形参的顺序限制。

示例代码：

def greet(name, gender, age, height):
    print(f'我叫{name}, 性别{gender}, 年龄是{age}, 身高是{height}cm')


# 调用函数(使用关键词参数)
greet(name='远方', gender='男', age=40, height=178)
greet(height=178, gender='男', name='远方', age=40)

位置参数和关键字参数可以混用，但位置参数必须写在关键字参数之前。示例代码：

# 正确使用方式
greet('远方', '男', height=178, age=40)

# 错误示例
greet(height=178, age=40, '远方', '男')
greet(name='远方', '男', 40, 178)
greet(name='远方', '男', age=40, 178)
greet(height=178, age=40, gender='男', name='远方', age=40)
greet(height=178, age=40, gender='男', name='远方', school='尚硅谷')

限制传参方式

具体限制方式：/前面只能用位置参数，*后面只能用关键字参数。

示例代码：

def greet(name, /, gender, *, age, height):
    print(f'我叫{name}, 性别{gender}, 年龄是{age}, 身高是{height}cm')

# 正确示例
greet('远方', '男', age=40, height=178)
greet('远方', gender='男', age=40, height=178)

# 错误示例
greet(name='远方', gender='男', age=40, height=178)
greet('远方', '男', 40, height=178)

参数默认值

定义函数时，通过形参名 = 值的形式，为形参设置默认值。

注意：定义函数时，默认参数必须放在必选参数的后面。换个说法，某个形参，一旦设置了默认值，那它后面的所有形参，也必须要写默认值。

def welcome(username = 'Python'):
    print(f'你好，{username}')

welcome()
welcome("远方")

可变参数

在定义函数时，如果不确定会传入多少个参数，那就可以使用可变参数，有如下两种写法：

• 使用*形参名来接收任意数量的位置参数，多个位置参数最终会被打包成一个元组。
• 使用**形参名来接收任意数量的关键字参数，多个关键字参数最终会打包成一个字典。

可变位置参数示例：

def test1(*args):
    print(args, type(args))

test1('远方', '男', 40, 178) # ('远方', '男', 40, 178) <class 'tuple'>

可变关键字参数示例：

def test2(**kwargs):
    print(kwargs, type(kwargs))

test2(name='远方', gender='男', age=40, height=178)
# {'name': '远方', 'gender': '男', 'age': 40, 'height': 178} <class 'dict'>

同时使用可变位置参数和可变关键字参数的情况下，必须先写可变位置参数。示例代码：

def test3(a, b, *args, c='Python', **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)


test3('远方', '男', '不抽烟', '不喝酒', age=40, height=178)
# 运行结果如下：
# 远方
# 男
# Python
# ('不抽烟', '不喝酒')
# {'age': 40, 'height': 178}

特殊字面量None

None 是一个特殊的字面量，用来表示：空值、无值、无意义。

None 的官方文档：https://docs.python.org/zh-cn/3.13/library/constants.html#None

几个关键点：

• None 的类型是 NoneType。
• None 出现在布尔判断中（if判断条件、while循环条件），会被当做 False 来处理。
• None 不能参与任何数学运算，也不能参与字符串拼接。
• 不给函数设置返回值，那函数默认就会返回 None。

None 出现最多的两个场景：

• 函数中没有写 return，或写了 return 但没有返回任何内容。
• 变量定义时，暂时不知道要存放什么类型的数据，可以先赋值为 None。

示例代码：

msg = None
print(msg, type(msg))

# None 转为布尔值是 False
print(bool(msg))
if not msg:
    print('Ok.')

# None 不能参与数学运算，也不能与字符串拼接，以下写法均会报错
# result1 = msg + 1
# result2 = msg + 'hello'

返回值

此处主要说明自定义函数的返回值，内置函数以及模块提供的函数根据对应文档说明确定返回值的情况。

没有返回值

对于自定义的函数，如果我们不设置返回值，函数也会默认返回 None。（由于 None 表示空，所以如果一个函数的返回值是 None ，就可以说这个函数没有返回值。）

示例代码：

def add(x, y):
    print(f'{x} + {y} = {x + y}')

result = add(1, 2)
print(result) # None

设置返回值

使用return关键字设置函数的返回值，return的作用有两个，分别是：

• 结束函数的运行。
• 把 return后面的值，作为函数的返回值。

示例函数（结束函数的运行）：

def test(n):
    print('test executed')
    if n <= 0:
        print('test failed\n')
        return # 这样写IDE内会有波浪线，建议下面的写法
        return None

    print('test passed')
    return n

print(test(-1))
print(test(1))

示例函数（设置返回值）：

def add(x, y):
    result = x + y
    print(f'{x} + {y} = {result}')
    return result

add_result = add(1, 2)
print(add_result) # 3

全局作用域 VS 局部作用域

什么是作用域？

作用域就是变量能起作用的范围（变量在哪里能用，在哪里不能用）。

全局作用域 _ 全局变量

全局作用域：整个.py文件最外层的范围，就是全局作用域。

全局变量：写在全局作用域中的变量，就是全局变量，全局变量在整个程序中都可以访问。

局部作用域 _ 局部变量

局部作用域：函数的内部范围，就是局部作用域。

局部变量：写在局部作用域中（函数内部）的变量，就叫局部变量，它只能在当前函数中使用。

global 关键字

在函数内部使用 global 关键字，可以声明变量为全局变量。

示例代码：

a = 100
print('全局打印（a）', a)

def test():
    global a
    a = 200
    print('函数中的打印（a）', a)


test()
print('全局打印（a）', a)

嵌套调用

说明：嵌套调用就是在一个函数执行过程中，调用了另外一个函数。

示例代码：

def greeting(uname, msg):
    print(f'我叫{uname}， 我想说的话在下面：')
    speak(msg)
    print('嗯，我想说的结束了')

def speak(msg):
    print('----------------')
    print(msg)
    print('----------------')

greeting('远方', '你好啊，终于有时间开始学 Python 了')

递归调用

说明：递归调用就是函数自己调用自己的一种操作。

注意：递归必须要具备终止条件，否则就会出现死循环。

示例代码1：

def welcome(n):
    print(f'Welcome to {n}!')
    if n > 1:
        welcome(n-1)

welcome(5) # 执行结果如下：
# Welcome to 5!
# Welcome to 4!
# Welcome to 3!
# Welcome to 2!
# Welcome to 1!

print()

def welcome2(n):
    if n > 1:
        welcome2(n-1)
    print(f'Welcome to {n}!')

welcome2(5) # 执行结果如下：
# Welcome to 1!
# Welcome to 2!
# Welcome to 3!
# Welcome to 4!
# Welcome to 5!

示例代码02：（递归完成阶乘）

def fdef factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

result = factorial(5)
print(result)actorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

result = factorial(5)
print(result)

函数说明文档（函数注释）

python 中函数说明文档（也就是函数注释）要写在函数内，用来描述：函数功能、需要哪些参数、返回什么结果。

它的语法和普通字符串一样，用三引号包裹，示例代码如下：

def add(a, b):
    """
    计算两个数相加的结果
    :param a:第一个数
    :param b:第二个数
    :return:二者相加的结果
    """
    return a + b


ret = add(1, 2)
print(ret)

有了函数说明文档之后，在PyCharm IDE内将鼠标放在调用函数的名称上悬浮一会（如果不显示，多悬浮一会），就会弹出函数的说明文档信息，如下图：