函数一

函数

一、灵魂三问？

1、什么是函数？

函数就是一种工具，可以重复调用

2、为什么要用函数？

a:为了防止代码冗余

b:为了增强代码的可读性，简介

3、怎么用函数？

关键字def后面空格加函数名加一个小括号后面跟一个重要的冒号

如def login():

OK，那我们定义好了函数要怎么使用函数呢，如果说定义函数是制造工具，那么调用函数就是使用工具。

二、函数的返回值return

1、不写return，默认返回None
def index():
    print('hello world')


print(index())
>>>hello world
None#此时因为没有一个值接受返回值，所以是None

2、只写return，只有结束函数体代码的效果，返回None
def index():
    print('hello world')
    return


print(index())
>>>hello world
None

3、写return None
def index():
    print('hello world')
    return None


print(index())
>>>hello world
None

4、return返回一个值
a = 1
b = 2
def home():

    if a > b:
        return a
    else:
        return b


res = home()
print(res)
>>>2

5、返回多个值
a = 1                     
b = 2                     
c = '3'                   
d = [4, 5]                
e = {'name': 'yafeng'}    
                          
def func(a, b, c, d, e):  
    return a, b, c, d, e  
>>>(1, 2, '3', [4, 5], {'name': 'yafeng'})

三、函数的参数

这里有几个点需要注意：
函数是先定义，后调用，在定义阶段只检测语法，不会执行任何代码

1、形参
形参是在定义函数时，里面小括号中的参数，用来接收参数，就相当于变量名
2、实参
实参是在函数调用阶段后面小括号中的参数，把数据传到函数内部用，相当于定义变量时的变量值
a = 5
b = 2
def index(a):  # 形参:相当于变量名

    if a > b:
        print(a)
    else:
        print(b)


index(a)  # 实参：相当于变量值
>>>5

3、位置参数：
	通过位置进行传参
   关键字参数：
	指定参数进行传参
 注意：位置参数一定要在关键字参数的前面，连用的时候也不可对同一个形参重复赋值
>>> def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
...     print('Name:%s Age:%s Sex:%s' %(name,age,sex))
>>> register() #TypeError：缺少3个位置参数

4、关键字参数：
在调用函数时，实参可以是指定值的形式，即key=value的形式，称为关键字参数凡是按
照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值

>>> register(sex='male',name='yafeng',age=18)
Name:yafeng Age:18 Sex:male

5、默认参数：
在定义阶段就已经传入参数，
如果你在实参的时候传入了一个新的参数，就会使用新参数
默认参数在传值的时候，通常应不要将可变类型当做参数传递
def reg(username, password, gender='male'):
    print(f"用户名：{username}，密码:{password},性别：{gender}")

reg('tank','dsb')
reg('jason','dsb')
reg('egon','xsb')
reg('xiaohong','dmm','female')
>>>用户名：tank，密码:dsb,性别：male
用户名：jason，密码:dsb,性别：male
用户名：egon，密码:xsb,性别：male
用户名：xiaohong，密码:dmm,性别：female

6、一个小问题（如何不打印别人的爱好）
def reg(hobby, l1=[]):  
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f"爱好：{l1}")

#
reg(hobby='生蚝')
reg('大保健')
reg('女教练')
>>>爱好：['生蚝']
爱好：['生蚝', '大保健']
爱好：['生蚝', '大保健', '女教练']

第一种解决方案：
def reg(hobby, l1=None):  
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f"爱好：{l1}")

#
reg(hobby='生蚝')
reg('大保健')
reg('女教练')
>>>爱好：['生蚝']
爱好：['大保健']
爱好：['女教练']

第二种解决方案：
def reg(hobby, l1):  # 四个形参
    l1.append(hobby)
    print(f"爱好：{l1}")


reg('生蚝', [])
reg('大保健', [])
reg('女教练', [])
>>>爱好：['生蚝']
爱好：['大保健']
爱好：['女教练']

四、可变长参数

• *args的用法

*args:接收所有溢出的位置参数
    接收的值都被存入一个元组tuple中
    官方认证：*args
    只要有*就有可变长参数的效果

    *:打散你传入容器类型
>>> def foo(x,y,z=1,*args): #在最后一个形参名args前加*号
...     print(x)
...     print(y)
...     print(z)
...     print(args)
... 
>>> foo(1,2,3,4,5,6,7)  #实参1、2、3按位置为形参x、y、z赋值，多余的位置实参4、5、6、7都被*接收，以元组的形式保存下来，赋值给args，即args=(4, 5, 6,7)

1
2
3
(4, 5, 6, 7)

• *kwargs的用法

**kwargs:接收所有溢出的关键字参数
        接收的值都被存入一个字典 dict中

    官方认证：**kwargs
def func(a, b, c, d,**kw):
    print(a, b, c, d,kw)


func(1, 2, c=3, d=4, e=5, f=6)
>>>1 2 3 4 {'e': 5, 'f': 6}

如果我们事先生成了一个字典，也可以传值给*kwargs
>>> def foo(x,y,**kwargs):
...     print(x)
...     print(y)
...     print(kwargs)
... 
>>> dic={'a':1,'b':2} 
>>> foo(1,2,**dic) #**dic就相当于关键字参数a=1，b=2，foo(1,2,**dic)等同foo(1,2,a=1,b=2)
1
2
{'a': 1, 'b': 2}

• 嵌套的用法

def foo(a, b, c, d, e, f):
    print(a, b, c, d, e, f)


def bar(*args, **kwargs):
    foo(*args, **kwargs)


bar(1, 2, 3, d=10, e=20, f=30)
>>>1 2 3 10 20 30