函数基础

函数基础：

def diedai(iter):    #iter可以换成a（参数名可以随便填）
    for i in iter:   #函数定义，命名：驼峰规程，dieDai(a)
        print(i)

#参数形式：可选参数，必备参数，默认参数，不传参数

def fun1():
    print('不能传参数')

#必备参数
def fun2(a):
    print('必须传参数:',a)

调用结果：
fun2(2)
必须传参数: 2


#=默认参数            #可以指定默认参数，参数可传可不传
def fun3(b=2):
    print('默认参数:',b)

fun3()
默认参数: 2

fun3(b=1)
默认参数: 1

fun3()
默认参数: 2

#可选参数

def fun4(*arg):
    print('可传0个到多个:',arg)

fun4()
可传0个到多个: ()
fun4(1)
可传0个到多个: (1,)    #元组只有一个数要加逗号
fun4(1,2,3,4,5)
可传0个到多个: (1, 2, 3, 4, 5)


fun4([1,2])
可传0个到多个: ([1, 2],)

fun4((1,2))
可传0个到多个: ((1, 2),)

 fun4({1:11})
可传0个到多个: ({1: 11},)  #总结：都把它当成一个元素，并且把它包装成元组！


fun4(*[1,2])             #加个#，就把里面的壳去掉，解包
可传0个到多个: (1, 2)
fun4(*{1:11})           #可以把键取出来
可传0个到多个: (1,)

#关键字参数

def fun5(a,b):   #=定义的时候是跟必备参数一样的
    print(a,b)   #必须放最后

fun5(a=1,b=2)
1 2

fun2(a=3):
必须传参数:3

def fun6(**kwarg):
    print('关键字参数',kwarg)   #包装成字典

fun6(a=1,b=2)
关键字参数 {'b': 2, 'a': 1}   #包装成字典，可传0个到多个

fun6()
关键字参数 {}   #空字典

fun6(**{'a':1})             #这样形式写keyward必须是字符串
关键字参数 {'a': 1}

#参数混合时

def fun7(a=1,b):   #non-default默认参数
    print(a,b)
报错：#必备参数+默认参数，默认参数要放在必备参数后面

def fun7(a,b=1):   
    print(a,b)

fun7(1,b=2)
1 2
#参数混合时，关键字参数放最后（以"="形式出现）

fun7(a=1,b=2)    #必备参数可以加"="   
1 2

fun7(1,2)
1 2

fun7(2,a=1)
报错：2已经是必备参数，又来一个必备参数，关键字参数放后面，根据定义顺序确保必备参数只能拿到一个值

def fun8(b,m=1,*a):
    print(b)
    print(m)
    print(a)

fun8(1,m=1,1,2,3,4,5)   #报错，m=1是关键字参数要放最后

fun8(1,1,2,3,4,5,m=1)   #报错

fun8(1,1,2,3,4,5)
1
1
(2, 3, 4, 5)


def fun8(*a,b,m):
    print(a,b,m)


fun8(1,2,3,b=1,m=2)
(1, 2, 3) 1 2

def fun8(b,m=1,*a):
    print(b)
    print(m)
    print(a)
错误输入情况：
fun8(1,m=1,1,2,3,4) #错误原因：因为关键字参数m=1必须放最后
fun8(1,1,2,3,4,m=1) #错误原因：因为根据定义顺序，先是第二位定义了一个m=1，最后面又定义了一个m=1，重复定义
正确输入：
fun(1,2,3,4,5) 

输出结果:

def fun9(*a,b,m):
    print(a,b,m)
正确输入：
fun9(1,2,3,b=1,m=2)
输出结果：

def fun11(a,b=1,*arg,**kwarg):
    print('这是必备参数:',a)
    print('这是默认参数:',b)
    print('这是可选参数（不定长参数）',arg)
    print('这是关键词参数',kwarg)
    return 'OK'

正确输入：fun11(1,2,1,2,3,x=1,y=2,z=3)
输出结果：

             
或者
def fun11(a,*arg,b=1,**kwarg):
    print('这是必备参数:',a)
    print('这是默认参数:',b)
    print('这是可选参数（不定长参数）',arg)
    print('这是关键词参数',kwarg)
    return 'OK'

正确输入：fun11(1,1,2,3,b=3,x=1,y=2,z=3) #b的位置可以在字典的前后

输出结果：

 #return     作用：返回函数运行结果

def fun1(a,b):
    if a>b:
        return a

fun1(2,1)
2
a=fun1(2,1)
a
2

def fun1(a,b):
    if a>b:
        print(a)

 fun1(2,1)
2
b=fun1(2,1)
2

print(b)
None

#fun1和fun2的区别是若将a=fun1(2,1),a=2;b=fun2(2,1),b=None
return返回了fun1的运行结果

def fun10(a,b):
#    return('我不下去')

    if a>b:
        print(a)
        
加return('我不下去了')      
fun10(2,1)
'我不下去了'                   #return,函数结束标志，可以放在任何地方。把return放到最后，先打印2，再打印'我不下去了'。
 
不加return语句
fun10(2,1)
2

#lanbda函数,匿名函数

g=lambda x:x+1

g(1)
2

g
<function <lambda> at 0x01733C90>

　　fun()是一个函数，fun就是一个函数体

lambda函数就是没有函数名的函数

g=lambda x:x+1
等同于：
def g(x):
    return(x+1)

lambda简化了函数定义的书写形式。是代码更为简洁，但是使用函数的定义方式更为直观，易理解

　　应用场景：
　　　　1.有些函数如果只是临时一用，而且它的业务逻辑也很简单时，就没必要用def 来定义，这个时候就可以用lambda。
　　　　2.函数都支持函数作为参数，lambda 函数就可以应用

g=lambda :x+1


g()
会报错，X没定义

g=lambda x,y: x*y      #  冒号前面是参数，后面是返回值

g(1)会报错

g(1,1)
1