7.9函数（一）

函数

一、函数简介

1.内置函数：python提前给你的写好了的函数，你直接调用即可

s = 'hello'
print(len(s))  # len() 内置函数:python提前给你的写好了的函数  你直接调用即可

2.自定义函数：函数必须先定义后调用，定义了的函数可以在任意位置调用

s = 'hello'
def my_len():  # 自定义函数
    n = 0
    for i in s:
        n += 1
    print(n)
my_len()  # 函数必须先定义后调用    定义了的函数可以在任意位置调用

此自定义函数my_len()的问题所在：

（1）没有返回值，只能固定的执行打印操作

（2）只能够固定的统计某一个容器类型的长度

二、函数的返回值

函数内要想返回给调用者值，必须用关键字return

def func():
    return '返回值'  # 函数内要想返回给调用者值  必须用关键字return
res = func()
print(res)

1.不写return

不写return ,函数默认返回None

def func():
    print('hahaha')
res = func()
print(res)  # 默认返回None

2.只写return

return可以返回值之外,还可以直接结束整个函数的运行

def func():
    l = ['jason','egon','tank']
    while True:
        for i in l:
            if i == 'egon':  # 当i为egon的时候,直接结束函数运行
                return  # 直接结束了for和while循环，结束整个函数运行
                print('asdasdkljlsjadl')  # 这一行代码永远都不会运行
            print(i)
res = func()
print(res)  # 只写return 返回的也是None(None就表示什么都没有)

3.写return None

跟上面的只写return是一样的

def func():
    return None
res = func()
print(res)  # 返回None

4.写return加上返回一个值

这个值可以是python任意数据类型

def func():
    return '123'
def func1():
    return [1,2,3]
def func2():
    return {'name':'jason'}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())  # 省略res = func()

5.写return加上返回多个值

return会自动将多个值以元组的形式返回给调用者

def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
res = func()
print(res)

def func1():
    return 'a','b','c'  # ('a', 'b', 'c')
res1 = func1()
print(res1)

def func2():
    return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res2 = func2()
print(res2)

def func3():
    return {'name':'jason'},{'username':'tank'},{'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
res3 = func3()
print(res3)

（1）为什么组织成元组返回

因为函数不希望自己处理的结果被修改（元组不可变）

（2）怎样不返回元组形式

返回多个值，并且不想让return帮你做处理（指返回元组形式），只需要自己手动加上你想返回的数据类型符号

def func():
    return [1,2,3,4]  # 返回的是[1, 2, 3, 4]
res = func()
print(res)

def func1():
    return ['a','b','c']  # ['a', 'b', 'c']
res1 = func1()
print(res1)

def func2():
    return [[1,2,3],[1,2,3],[1,2,3]]  # [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
res2 = func2()
print(res2)

def func3():
    return [{'name':'jason'},{'username':'tank'},{'user_name':'egon'}] # [{'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'}]
res3 = func3()
print(res3)

6.总结：

1.python中所有的函数都有返回值，无论你写不写return，不写的情况下默认返回None

2.只写return或者return None并不是为了考虑返回值，而是为了结束函数的运行

三、函数的参数概要

s = 'hello'
l = [1,2,3,4]
print(len(s))  # 需要1个参数
print(len(l))

def my_len():  # 需要0个参数
    n = 0
    for i in s:
        n += 1
    return n
print(my_len())

如何让自定义函数实现内置函数添加参数的功能？

s = 'hello'
l = [1,2,3,4]
def my_len(args):  # 给my_len()传一个参数
    print(args)
    n = 0
    for i in args:  # 对象也该为该参数
        n += 1
    return n
print(my_len(s))
print(my_len(l))
print(my_len('hello world'))  # 实现了len()可以添加参数的功能

1.函数参数的两大类型

（1）形参：在函数的定义阶段，括号内写的变量名，叫做该函数的形式参数。简称：形参

（2）实参：在函数的调用阶段，括号内实际传入的值，叫做该函数的实际参数。简称：实参

2.形参与实参的关系

（1）形参就相当于变量名,而实参就相当于变量的值

（2）函数调用传参的过程，就是给形参变量名赋值的过程

注意：（1）形参和实参的绑定关系只在函数的调用阶段有效，函数运行结束关系自动解除

　　　  （2）只在函数内部有效，函数外部无任何影响

3.函数的简易结构：

def 函数名(形参1,形参2...):
　　'''
　　函数的注释，用来描述该函数的作用以及各个形参的类型
　　'''
　　函数体代码1
　　函数体代码2
　　...
　　return 函数的返回值

4.函数的注释

怎么写以及怎么查看

def func(x,y):
    '''
　　注释第一行：写该函数的作用
　　:param x: 对形参x的解释
　　:param y: 对形参y的解释
　　:return: 对函数返回值的解释
　　'''
    print('hahaha')
    return 'heihei'
print(help(func))  # 调出该函数的注释
print(help(len))  # 调出该函数的注释

四、位置参数

1.位置参数：

（1）在函数定义阶段按照位置从左往右依次书写的变量名，叫做函数位置形参

（2）位置形参在调用的时候，必须为其传值

（3）在函数的调用阶段，传入的参数会按照位置一一对应给形参

第一种：直接按照位置传，一一对应

def my_max(x,y):
    if x > y:
        return x
    else:
        return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行
res = my_max(20,10)  # 必须要一一对应
print(res)

第二种：指名道姓的传（关键字传参）

def my_max(x,y):
    if x > y:
        return x
    else:
        return y
my_max(y=20,x=10)  # 关键字传参
print(my_max(y=20,x=10))
my_max(10,y=20)  # 位置传和关键字传参混合使用
print(my_max(10,y=20))
my_max(x=10,20)  # 报错，位置参数必须在关键字参数的前面
my_max(20,y=40,x=30)  # 报错，同一个形参不能被多次赋值

2.注意：在函数的调用阶段，位置参数和关键字参数可以混合使用

但是必须保证：

（1）位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)

（2）同一个形参不能被多次赋值

五、默认值参数

1.默认值参数：

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

　　（2）在调用的时候可以不为默认值形参传值，默认使用定义阶段就已经绑定的值

def my_max(x,y=100):
    print(x,y)
    if x > y:
        return x
    return y
res = my_max(200)
print(res)

　　（3）在调用的时候如果可以给默认值形参传值，传了那么就使用你传的值

def my_max(x,y=100):
    print(x,y)
    if x > y:
        return x
    return y
res = my_max(200,1000)
print(res)

　　（4）在定义阶段，默认值形参必须放在位置形参的后面

2.默认值参数的应用场景

当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参

def register(username,age,gender='male'):
    print(username,age,gender)
register('jason',18)
register('tank',28)
register('egon',84)
register('kevin',58)
register('xiaohou',17,'female')

3.面试题：统计每个人的爱好

def info(username,hobby,l=[]):
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','study')
info('tank','read')
info('egon','write')
# jason 的爱好是 ['study']
# tank 的爱好是 ['study', 'read']
# egon 的爱好是 ['study', 'read', 'write']

如何解决这个问题

（1）第一种

不使用默认值参数，自己传参数

def info(username,hobby,l=[]):
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','study',[])
info('tank','read',[])
info('egon','write',[])
# jason 的爱好是 ['study']
# tank 的爱好是 ['read']
# egon 的爱好是 ['write']

（2）第二种

调用阶段重新赋值

def info(username,hobby,l=None):
    if l == None:
        l = []
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','study')
info('tank','read')
info('egon','write')
# jason 的爱好是 ['study']
# tank 的爱好是 ['read']
# egon 的爱好是 ['write']

4.函数在定义阶段，内部所使用的变量都已经初始化完毕了，不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)

m = 100
def my_max(x,y=m):
    print(x,y)
m = 222
my_max(111)

函数无论在什么地方被调用，都会跑到函数定义阶段去执行代码，形参中用到的值都是往函数定义阶段代码往上找

六、可变长参数

站在调用函数传递实参的角度，实参的个数不固定的情况，也就意味形参也不固定，如何解决？

解决办法：站在形参的角度，可以用可以用*和**来接收多余的(溢出的)位置参数和关键字参数

1. * 

（1）站在形参的角度，看 *

形参中的 * 会将多余的(溢出的)位置实参，统一用元组的形式处理，传递给 * 后面的形参名

def func(x,y,*z):
    print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
func(1,2,3,4,5,6,7,8,9,10,11,12)

（2）站在实参的角度，看 *

* 的内部你可以看成是for循环，只能将列表，元组，集合，字符串打散并一一传入

def func(x,y,z):
    print(x,y,z)
func(*[1,2,3])  # *会将列表打散成位置实参一一传入，等价于func(1,2,3)

（3）配合使用

def func(x,*z):
    print(x,z)
func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参

2. ** 

（1）站在形参的角度，看 **

** 会接收所有多余的关键字参数，并将关键字参数转换成字典的形式，字典的key就是关键字的名字，字典的value就是关键字的名字指向的值，将字典交给 ** 后面的变量名

def func(x,y,**z):
    print(x,y,z)  # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
func(x=1,y=2,z=1,a=1,b=2,c=3)

（2）站在实参的角度，看 ** 

** 会将字典拆封成 key = value的形式，以关键字参数的形式传递给函数

def func(x,y,z):
    print(x,y,z)
func(**{'x':1,'y':2,'z':3})  # 等价于func(x=1,y=2,z=3)

3.总结：

（1）形参中：

　　* 在形参中能够接受多余的位置参数，组织成一个元祖赋值给 * 后面的变量名

　　** 在形参中能够接受多余的关键字参数，组织成一个字典赋值给 ** 后面的变量名

（2）实参中：

　　* 在实参中能够将列表、元祖、集合、字符串，打散成位置实参的形式传递给函数( * 就看成是for循环取值)

　　** 在实参中能将字典打散成key = value的形式，以关键字参数形式传递给函数

4.如何使你写的函数无论调用者按照正确传参的方式无论怎么传，你的函数都能够正常执行？

def func1(*x,**y):
    print(x,y)  # x = (1, 2, 3, 4, 5, 6)  y = {'x': 1, 'y': 2, 'z': 3}
func1(1,2,3,4,5,6,x=1,y=2,z=3)

python推荐的形参* 和形参** 通用的写法

def func2(*args,**kwargs):
    print(args,kwargs)
func2(1,2,3,4,5,6,x=1,y=2,z=3)