函数基础

一.函数的定义

在编程的过程中，会出现代码冗余，可读性差，不易修改，所以出现了函数，函数类似一个工具，这个工具可以拿过来直接使用

 

def 函数名(形参1，形参2...):
　　'''函数的注释，描述函数的作用以及参数的类型'''
　　代码块
　　...
　　return   # return可以获取函数执行后的返回值，也可以结束函数的运行

1.函数名的定义类似变量名
2.函数名加括号立即执行函数体代码 优先级最高
3.函数必须先定义再调用

func(10,20)  # 报错，因为函数必须先 定义 在 引用（调用）
def func(x,y):  # 定义函数
    if x > y:
        print(x)  # return x  返回值 x
    else:
        print(y)  # return y  返回值 y
func(2,5)  # >>> 5  函数名加括号立即执行函数体代码
res = func(2,5)
print(res)   # 返回值 None
print(func)  # <function func at 0x0000027893BE2EA0> func 对应的是函数的内存地址

二.return 函数的返回值

1.不写return 
2.只写return
3.return None
4.return 返回一个值
5.return 返回多个值

不写 return 返回值 None

def func():
    print('waller')
func()  # >>> waller
res = func()  # 定义变量接收给返回值
print(res)  # >>> None

 只写 return 返回值 None 除此之外还可以结束函数的运行

def func():
    l = [1,2,3]
    while True:
        for i in l:
            if i == 2:  # 当 i == 2 时结束整个循环需要两个break，分别结束for和while
                #break
                return  # 函数里的return可以结束整个函数，之后的代码永远不执行
            print(i)
            # else:
            #     print(i)
        # break

res = func()
print(res)  # >>> None

只写 return None

ef func():
    return None
res = func()
print(res)  # >>> None

return 返回一个值，这个值可以是任意类型

def func1():
    return 123
def func2():
    return 'waller'
def func3():
    return [1,'age']
def func4():
    return (1,)
def func5():
    return {'hubby':'read'}
def func6():
    return {1,}
def func7():
    return True
print(func1(),func2(),func3(),func4(),func5(),func6(),func7())
# >>> 123 waller [1, 'age'] (1,) {'hubby': 'read'} {1} True

return 返回多个值 返回的时一个元组，函数处理的结果不想被修改

def func1():
    return 1,2,3,'a','b'
res1 = func1()
print(res1)  # >>> (1, 2, 3, 'a', 'b')

def func2():
    return [1,2],['a',1]
res2 = func2()
print(res2)  # >>> ([1, 2], ['a', 1])

def func3():
    return {'name':'waller'},{'age':20}
res3 = func3()
print(res3)  # >>> ({'name': 'waller'}, {'age': 20})

# 返回多个值，不想函数处理成元组，可以自己动手加上数据类型符号，使多个值变成一个值
def func4():
    return [{'name':'waller'},{'age':20}]  # 利用return打印一个值的特点
res4 = func4()
print(res4)  # [{'name': 'waller'}, {'age': 20}]

注意：

1.所有的函数都有返回值
2.只写return 或return None 不是为了返回值，是为了结束函数的运行

三.参数：

参数的两大类型：
    形参：在函数定义阶段括号内的参数，这个形参相当于变量名，简称 形参
   实参：在函数调用截断括号内的参数，这个参数相当于变量值，简称 实参

    形参与实参的关系：
        形参相当于变量名，实参相当于变量值
        函数调用传参的阶段，就是实参变量值给形参变量名赋值的过程

    注意：
        形参和实参的绑定关系只有在函数调用阶段生效，函数运行完自动解除绑定关系
        只有在函数内部有效，函数外部无影响

def func(x,y):
    '''
    函数的作用以及参数的类型
    :param x:
    :param y:
    :return:
    '''
    print('waller')
    return  'wong'
print(help(func))  # 打印出函数的注释

 传参：

位置传参：
    位置形参：在函数定义阶段，括号内从左到右依次写入的变量名较叫位置形参，调用时必须为其传值
    位置实参：在函数调用阶段，对应位置形参依次在括号内填入的值，这些值会一一传给形参（类似变量名赋值）
关键字传参：
    在函数调用阶段，按照形参的变量名 赋值

注意：
    位置传参和关键字传参和混合使用，但关键字传参要在位置传参的后面
　　 同一个参数不能被多次赋值

 位置传参：
def num_max(x,y):  # x,y 是位置形参，需要传值
    if x > y:
        return x  # 若x > y 返回值是 x
    else:
        return y  # 否则 返回值是 y
res = num_max(2,6)  # 2和6 是位置实参，按照x与y的位置传递参数 x = 2，y = 6
print(res)  # 打印函数的返回值  >>> 6

res = num_max(5)  # 报错 ，位置实参传参个数少于形参数
res = num_max(2,6,7)  # 报错，位置实参传参个数多余形参数


关键字传参：
def num_max(x,y):  # x,y 是位置形参，需要传值
    if x > y:
        return x  # 若x > y 返回值是 x
    else:
        return y  # 否则 返回值是 y
res = num_max(y=6,x=2)  # 按关键字为形参传参
print(res)  # >>> 6
res = num_max(y=6,x=2,x=1)  # 报错，同一个形参不能被多次传值

res = num_max(2,y=6)  # 位置参数和关键字参数同时使用
res = num_max(y=6,2)  # 报错，关键字参数要在位置参数后面

 

默认参数：

定义：
    在函数定义阶段，形参（变量名）就已经被赋值了

在调用阶段，可以不为默认形参传值，默认使用定义阶段绑定的值
在调用阶段，如果为默认形参传值，就使用调用阶段传入的值

注意：
    定义阶段，默认形参要在位置形参的后面

应用场景：
    当形参接收的值大多数是相同值的情况下，可以使用默认形参

def num_max(x,y=100):
    if x > y:
        return x
    return y
res = num_max(50)  # x = 50 y = 100  # 传入位置参数 50给形参x，形参y不传值，使用默认参数
print(res)  # >>> 100

res1 = num_max(50,20)  # x = 50 y = 20  # 传入位置参数 50给形参x，20给形参y
print(res)  # >>> 50


def info(name,age,gender = 'male'):  # gender = 'male' 是默认参数
    print('name is {},age is {},gender is {}'.format(name,age,gender))
info('waller',20)  # >>> name is waller,age is 20,gender is male
info('wong',24)  # >>> name is wong,age is 24,gender is male
info('tuan',22,'female')  # >>> name is tuan,age is 22,gender is female

可变长参数 *和**

形参中的 * 可以将实参中多余的位置参数组成元组的形式赋值给形参中*后面的变量名,不能接收关键字实参
实参中的 * 可以将实参中除字典的容器类型数据打散，依次赋值给形参

形参中的 ** 可以将实参中多余的key=value的关键字形式实参存成字典的形式 赋值给形参中** 后面的变量名，不能接收其他容器类型的实参(俗称封装)
实参中的 ** 会将实参中的字典类型数据，按照key=value的关键字传参的形式赋值给形参(俗称打散)

python 推荐*和**写法：

def func(*args,**kwargs):  # 调用者按照正确的传参方式无论怎么传都可以接受
    print(args,kwargs)

形参中的 *

def func(x,y,*z):
    print(x,y,z)
func(1,2,3,4,5,6,)  # >>> 1 2 (3, 4, 5, 6)  z = (3, 4, 5, 6)

实参中的 *

def func(x,y,z):
    print(x,y,z)
func(*[1,2,3,])  # >>> 1 2 3

def func(x,y,z):
    print(x,y,z)
func(*('a','b',1))  # >>> a b 1

def func(x,y,z):
    print(x,y,z)
func(*{'a',(1,2),5})

def func(x,y,*z):
    print(x,y,z)
func('a',5,*[1,2,3])  # a 5 (1, 2, 3)

形参中 ** 

ef func(x,**y):
    print(x,y)
func(x='a',y='b',z='c',d=1,e=2)  # y = {'y': 'b', 'z': 'c', 'd': 1, 'e': 2}
# >>> a {'y': 'b', 'z': 'c', 'd': 1, 'e': 2}

实参中的 ** 

def func(x,y):
    print(x,y)

d = {'x':'waller','y':20}
func(**d)