Python函数的介绍

1.函数的作用、定义及调用

函数的作用：是为了封装，实现一个特定的功能。可以重复使用，用起来方便。

格式：

def  函数名称（）：

       函数体（要运行的代码）

注意：函数名称是标识符，所以要遵循标识符的规范。函数名称要见名知意。

函数的定义：函数的定义过程就是完成了封装。

函数的调用：就是去使用封装好的代码。

def run_car():
    print('打开车门')
    print('启动发动机')
    print('系上安全带')
    print('踩油门')
    print('掌握方向')
run_car()#调用函数

运行结果：

打开车门
启动发动机
系上安全带
踩油门
掌握方向

多次调用函数

def run_car():
    print('打开车门')
    print('启动发动机')
    print('系上安全带')
    print('踩油门')
    print('掌握方向')
for i in range(3):
    run_car()

运行结果：

打开车门
启动发动机
系上安全带
踩油门
掌握方向
打开车门
启动发动机
系上安全带
踩油门
掌握方向
打开车门
启动发动机
系上安全带
踩油门
掌握方向

 2.函数的返回值--return

是在函数的定义中，在函数体中使用的一个python关键字（保留字），返回。

return 表示当函数执行完之后，想让函数外面的程序得到函数执行的结果。return 的值可以是任何数据类型。

注意：

--  函数体当中的代码，遇到 return 会终止运行。

--  函数的返回结果可以是任意类型，包括None。

--  当函数体当中没有 return ，默认返回None。

--  函数体外面的程序想打印return 的返回值，必须要用一个变量接收，或者直接用 print(函数名)

举例说明：

 遇到 return 会终止运行

def run_car():
    print('打开车门')
    print('启动发动机')
    print('系上安全带')
    print('踩油门')
    print('掌握方向')
    return 70
    print('继续开')#因为上一条是return,所以这条代码不会执行
result = run_car()#把返回值赋值给一个变量
print(f'函数的运行结果：{result}')#打印出返回值

 运行结果：

打开车门
启动发动机
系上安全带
踩油门
掌握方向
函数的运行结果：70

 函数的返回结果可以是任意类型（return 返回多个值的话，数据类型是元组）

def result():
    return 'hello',[1,2,3],(1,2,3),{'name':'lili'},121,None
# 可以用变量接收，再打印变量
my_result = result()
print(my_result)
# 也可以直接用输出语句打印出来
print(result())

 运行结果：

('hello', [1, 2, 3], (1, 2, 3), {'name': 'lili'}, 121, None)
('hello', [1, 2, 3], (1, 2, 3), {'name': 'lili'}, 121, None)

 函数体当中没有 return ，默认返回None

def result():
    print('hello')
    #此处相当于有一条代码 return None
my_result = result()
print(my_result)
# 与下面代码是一样的
def result():
    print('hello')
    return None
my_result = result()
print(my_result)

运行结果：

hello
None
hello
None

 来看几个python的内置函数（也是方法）的返回值，有没有返回值是定义方定义的，没办法修改

a = [1,2,3]
result = a.append(4)#函数的返回值是None
print(result)
result1 = a.remove(3)#函数的返回值是None
print(result1)
result2 = a.pop(0)#函数的返回值是要删除的内容值
print(result2)

 运行结果：

None
None
1

3.函数的参数

参数的作用是用来往函数体中加原料

举个栗子：

制作咖啡的过程，需要加，水，加豆子，加糖，这些都可以看作是原料（参数）

 函数体：运行多行指定的代码，步骤一致，有的数据不一致，可能会发生变化的数据，就作为参数放到函数的定义当中。

注意：

--  函数定义的时候的参数：形式参数。变量名

--  函数调用的时候的参数：实际参数。变量赋值

def get_coffee(water,suger,bean):#形参
    if suger >= 100:
        return '甜咖啡'
    elif suger < 10:
        return '美式'
    else:
        return '乱七八糟咖啡'
result = get_coffee(100,66,20)#实参
print(result)

 运行结果：

乱七八糟咖啡

 3.1位置参数

注意：

--  形参与实参的个数要一致

--  形参与实参的位置（顺序）要一致（位置不能随便调换）

  位置要一一对应

def add(a,b):
    c = a + b
    return c
print(add(1,2,3)) #实参与形参的个数不一致，所以程序报错

运行结果：

  3.2关键字参数和默认参数

关键字参数：在调用函数时，做一个关键字标记，以防传参错误，造成损失

def add(a,b):
    c = a + b
    return c
print(add(b=3,a=2))#加了关键字后，位置可以随便调换，运行结果是不受影响的

 运行结果：

5

 默认参数：在函数定义时，给某个变量直接赋值，成为默认值。就是使用默认值直接赋值，在调用函数的时候，可以少传参数。

def add(a,b=9):
    c = a + b
    return c
print(add(a=2))#不写b的实参值时，使用默认参数（形参值）b=9
print(add(2,5))#写了b的实参后，使用的是实参赋值给b的值 b=5

运行结果：

11
7

注意：关键字参数，默认参数，都必须放到位置参数后面

def add(b=9,a):
    c = a + b
    return c
print(add(a=2))

运行结果：

 

 SyntaxError:非默认实参跟随默认实参

def add(a,b):
    c = a + b
    return c
print(add(a=5,8))

 运行结果：

 位置参数跟随关键字参数

def add(a,b):
    c = a + b
    return c
print(add(8,a=5))

 运行结果：

 TypeError: add()为参数a获得了多个值

 正确案例：

def add(a,b=6):#默认参数必须放在形参后面
    c = a + b
    return c
print(add(b=5,a=6))
print(add(6,9))
print(add(8,b=7))#关键字参数必须放在实参后面

运行结果：

11
15
15

4.不定长参数

在定义和使用函数的过程当中，不确定需要使用多少个参数

--  位置参数不定长

--  关键字参数不定长

4.1位置参数不定长

 在定义函数时，在形参前面加*，表示不定长参数，返回结果的数据类型是元组

# 普通函数
def add(a,b,c):
    return a + b + c
print(add(1,2,3))
# 不定长参数:不知道传入的实参有多少个，就在形参前面加上一个*
# c会变成一个元组，来接收所有传进来的参数
def add(*c):
    return c
result = add(4,5,6)
print(result)

运行结果：

6
(4, 5, 6)

# 形参中即有位置参数，也有不定长参数时，要先传给位置参数，剩下的值传给不定长参数
def add(a,*c):
    print(a)
    return c
result = add(4,5,6)
print(result)

 运动结果：

4
(5, 6)

注意：位置参数一定要在不定长参数前，否则会报错

def add(*c,a):
    print(a)
    return c
result = add(4,5,6)
print(result)

运动结果：

 调用函数时，在实参前面加*，也表示的是不定长参数

# 函数定义，在形参前面加*，表示位置不定长参数
def add(*c):
    return c
b = [5,6,7]
# b是一个值[5,6,7]
print(add(b))
# 在调用函数时加*是把[]衣服脱掉,只能脱掉列表和元组的衣服
# 相当于b是三个值5，6，7
print(add(*b))

4.2关键字参数不定长

定义函数时，在形参前加**，表示接收关键字参数，返回结果的数据类型是字典

# 两个星号不能接收位置参数，是接收关键字参数
def add(**c):
    return c
print(add(3,4))

 运行结果：

# 两个星号不能接收位置参数，是接收关键字参数
def add(**c):
    return c
print(add(x = 3,y = 4))

 运行结果：

{'x': 3, 'y': 4}

# 两个星号不能接收位置参数，是接收关键字参数
# **c,接收关键字参数，类型永远是字典
def add(a,**c):
    print(a)
    return c
# 先把关键字参数a传入，再把后面所有的值都传给不定长参数
print(add(a = 3,b = 4,d = 5))

 运行结果

3
{'b': 4, 'd': 5}

 注意：**接收到的是关键字参数，实参传入的不是关键字参数，一定会报错

def add(**c):
    return c
x = {'a':5,'b':6}
print(add(x))# x是一个值，是位置参数，不是关键字参数，传给c后会报错

 运行结果：

 调用函数时，实参前加**，表示关键字不定长参数

def add(**c):
    return c
x = {'a':5,'b':6}
# 实参前加两个**，是脱掉字典的衣服
# 相当于把a=5,b=6传给c
print(add(**x))

# *d ==> d是元，**c ==> c是字典
def add(*d,**c):
    print(d)
    return c
print(add(x=99))# 因为d没有传入实参，所以为空元组
print(add(55,))# 因为c没有传入实参，所以为空字典

 运动结果：

()
{'x': 99}
(55,)
{}