1. 基本概念
2. 创建和调用
3. 参数及传递
4. 普通可变参数
5. 关键字可变参数
6. 函数的返回值
7. 变量的作用域
8. 嵌套调用
9. 匿名函数
10. 函数说明文档
11. 递归函数

基本概念：

组织好的，可重复使用的，用来实现特定功能：的代码段，就是函数

好处：

• 减少重复代码
• 提高开发效率

意义：

• 代码复用
• 独立作用域
• 定义和调用分离
• 凡此变数中函彼变数者，则此为彼之函数。《代数学》——李善兰

创建和调用

定义函数：也是创建函数，

语法：

def f( x , y ) :
pass

def 函数名(参数列表):
    说明文档
    函数体
    return 返回值

函数名：符合标识符要求

参数列表：（）包裹，用逗号分隔

返回值：可选

示例：

def add(x,y):
'''
:param x: 参数1
:param y: 参数2
:return: 返回结果
'''
print(f'{x}+{y}=',end='')
return x + y

调用函数

功能：调用就是使用函数

语法：

• 函数名
• 函数名( )

直接调用：传入函数参数获取函数结果

函数名()

• a = f( ) ： 把函数结果赋值给a
• f( ) ：直接调用

示例：

def add(x,y):
    print(f'{x}+{y}={x+y}')
# 直接调用函数
add(1,2)     # 1+2=3

赋值调用：把整个函数当作，一个参数或一个对象使用

函数名：x = f，没有括号，表示把此函数当作一个对象或一个参数使用

示例：

def add(x,y):
    print(f'{x}+{y}={x+y}')
			# 赋值调用
x = add(3,5)
print(x)
    '''
        3+5=8 # 执行函数中的输入代码
        None # 函数默认返回结果
    '''

def add(x, y):
print(f'{x}+{y}={x + y}')
return x+y
													# 赋值调用
x = add(3,5)			 # 当作一个参数调用
print(x)
    '''
    3+5=8
    8
    '''

def add(x, y):
				print(f'{x}+{y}={x + y}')
				return x+y
# 赋值调用
x = add # 没有括号
print(x(3,5)) # 这里就要加括号及参数
        '''
        3+5=8
        8
        '''

pass

功能：为完善程序结构的占位语句。可以定义空函数

示例：

def add():
    pass     # 表示函数结构是完整的
add()       #  否则调用时出错

函数说明

功能：对函数的功能：及参数说明

示例：

def add(x,y):
'''
函数说明
:param x:参数说明 
:param y:参数说明
:return:返回值说明
'''
pass

参数及传递

概念：函数定义或调用执行时的传递的数据，叫参数

功能：参与函数的数据传递和计算

传递方式：

• 值传递：适用于实参类型不可变类型：字符，数字，元组
• 引用传递：适用于实参类型可变类型：列表，字典

分类：

形式分类：

• 形参：函数定义是时的参数
• 实参：函数调用确定的参数

示例：

def add(x,y):
    print(x)
    print(y)
    return x+y
    # x和y就是定义时的参数：形参
add(3,5)
    # 3和5就是调用函数确定的参数：实参

功能分类

普通参数：必须写的参数，也叫位置参数，实参的位置与形参的位置一致。

示例：

def add(x,y):
print(x)
print(y)
return x+y
add(3,5)     # x在前面，y在后面。
                  # 3和5是必须写否则出错：这叫普通参数

关键字参数：使用形参的名字来确定实参的值，位置随便

示例：

def add(x,y):
    print(x)
    print(y)
add(y=2,x=15) # 两个位置不同
        '''
        15
        2
        '''

默认参数：函数定义时，给形参设置默认值，只有与默认值不符时，才需要传递实参

定义时：只能写在最后，也可多个

示例：

def add(x,y=10,z=20):
    print(x)
    print(y)
    print(z)
    return x+y
add(3)      # 只写入普通参数
# y = 10 就是默认参数
# z = 20 就是默认参数

可变参数：

位置参数

语法：*args

示例：

def add(x, y, *args):
    print(x)
    print(y)
    print(args)
    return x, y, args
x = [5, 6, 7]
y = (1,2,3)
z = 'python'
print(add(3, 4, x,y,z))
# 3
# 4
# ([5, 6, 7], (1, 2, 3), 'python')
# (3, 4, ([5, 6, 7], (1, 2, 3), 'python'))

关键字参数

语法：**kwargs

示例：

def add(x, y,**kwargs):
    print(x)
    print(y)
    print(kwargs)
    return x, y, kwargs
print(add(1,2,a=33,b=44,c=55))

'''
1
2
{'a': 33, 'b': 44, 'c': 55}
(1, 2, {'a': 33, 'b': 44, 'c': 55})
'''

参数位置

• 位置参数：也叫普通参数，与形参数位置一样，必须填写。
• 普通可变参数： *
• 关键字可为参数：**
• 默认参数： x = y

示例：

def add(x, y,*args, a=3,**kwargs):
    print(x)
    print(y)
    print(a)
    print(args)
    print(kwargs)
    return x, y, args,kwargs
x = [1,2]
y = (3,4)
z = '56'
print(add(1,2,x,y,z,10,11,a=33,b=44,c=55))
'''
1
2
33
([1, 2], (3, 4), '56', 10, 11)
{'b': 44, 'c': 55}
(1, 2, ([1, 2], (3, 4), '56', 10, 11), {'b': 44, 'c': 55})
'''

在星之后的参数，只能使用关键字参数传递

def fun(a,b,c,*,d,e,f):
    print(a)
    print(b)
    print(c)
    print(d)
    print(e)
    print(f)
fun(1,2,3,d=4,e=5,f=6)
'''
1
2
3
4
5
6
'''

普通可变参数

参数个数不确定：

语法：*

示例：

def fun(*args):
    print(args)
a = [10,20,30]
b = [10,20,30,40]
fun(*a)         # (10, 20, 30)
def fun(*args):
    print(args)
fun(5)          # (5,)
fun(5,10)       # (5, 10)
fun(5,10,15)    # (5, 10, 15)

关键字可变参数

关键字定参数不确定

语法：**

示例：

def fun(**kwargs):
    print(kwargs)
a = {'a':1,'b':1}
b = {'a':1,'b':1,'c':1,'d':1}
fun(**a)    # {'a': 1, 'b': 1}
fun(**b)    # {'a': 1, 'b': 1, 'c': 1, 'd': 1}
def fun(**args):
    print(args)
fun(a=10)           # {'a': 10}
fun(b=10,c=30,d=40) # {'b': 10, 'c': 30, 'd': 40}

函数的返回值

return 返回值

• 函数一定会有一个返回值
• return 之后代码不再执行
• 返回多个值，结果为元组

None

如果没有定义返回值，自动则返回None 表示：空

类型：<class 'NoneType>

应用：

• 函数无返回值
• 在if判断时，表示为假：False
• 声明无初始值的变量

示例：

def add(x,y):
    result = x + y

r = add(2,3)
if r:
    print('有返回值')
else:
    print('无返回值')  # 无返回值

示例：

def add(x,y):
    result = x + y
    return result

r = add(10,20)
print(r)      # 30

def add(x,y):
    result = x + y

r = add(10,20)
print(r)      # None

变量的作用域

概念：作用域就是变量作用的范围，在哪里可用，在那里不可用

分类：

• Local：局部变量，在函数内部使用
• Enclosed：闭包作用域
• Global：全局变量，整个程序都可用
• Builtln：python 提供的一些内容，处于内置作用域

局部变量：在函数内部的变量

def tt():
    num = 100
    print(num)

tt()  # num = 100
print(num) # 报错

全局变量：在函数内、外都可使用的变量

a = 50
def tt():
    num = 100
    print(num+a)

def bb():
    num = 200
    print(num+a)

tt()  # 150
bb()  # 250

global:修改全局变量

a = 50
def tt():
    num = 100
    global a
    a = 33
    print(a)
    print(num+a)
tt()
print(a)

'''
33
133
33
'''

嵌套调用

函数里调用了其它的函数或自己

def func_b(): # 第一个函数
    print('---2---')
def func_a(): # 第二个函数
    print('---1---')
    func_b()  # 调用了第一个函数
    print('---3---')

func_a()
'''
---1---
---2---
---3---
'''

匿名函数

概念：没有名字的函数，也叫lambda表达式。

功能：简化函数，做函数的参数等功能，配合高阶函数使用，功能：更强大

语法：lambda [ 变量1 ... ] : 表达式

lambda：关键字

arg：变量：可多个

表达式：expression ：表达式，对变量进行操作

示例：

def add(x, y):  # 定义一个函数
    a = x * y   # 乘法
    return a
print(add(3, 4)) # 调用函数：12
x = lambda a, b: a * b # 定义匿名函数
print(x(3,4))          # 调用函数：12
print(type(x))         # 类型是函数：<class 'function'>

函数说明文档

语法：

def func(x,y):
        '''
        函数说明：
        ：param:x:形参X的说明
        ：param:y形参Y的说明
        ：return:返回值说明
        '''
        函数体
        return 返回值
在函数体之前
多行注释一样

示例：

def add(x,y):
    '''
    求两个数的和
    :param x: 任意数
    :param y: 任意数
    :return: 返回一个数
    '''
    result = x + y
    return result
r = add(10,20)
print(r)  # 30

在函数调用时，鼠标悬停就会有提醒

递归函数

概念：调用自身的函数，这个就是递归

• 递归组成
• 递归调用
• 递归终止

调用过程

每调用一次，都在内存中分配一个 栈帧

每执行一次，都会释放空间

优缺点：

• 优点：思路和代码简单
• 缺点：占用内存多，效率低

示例：

阶乘计算

def fac(n):
    if  n == 1:
        return  n
    else:
        return n*fac(n-1)

print(fac(6))  # 720

图示说明：

def fac(n):
    x = n
    for i in range(1,n):
        x *= i
    return x

print(fac(6))  # 720

累加

def fac(n):
    if  n == 1:
        return  n
    else:
        return n+fac(n-1)

print(fac(100))  # 5050

def fac(n):
    x = n
    for i in range(1,n):
        x += i
    return x

print(fac(10))  # 5050

斐波纳契数

def fib(n):
    if n == 1:
        return n
    elif n == 2:
        return n-1
    else:
        return fib(n-1)+fib(n-2)

print(fib(6))  # 8

for i in range(1,7):        # 输出每一项
    print(fib(i),end='｜')  # 1｜1｜2｜3｜5｜8｜

图示总结：需要高清全图请私信回复【函数全图】