第六课 函数基础

第六课 函数基础

一、函数的定义

　　函数就是对代码进行一个封装。把实现，某一功能的相同代码，进行封装到一起。下次需要使用时，就不需要再进行代码编写，直接调用即可。

　　内置函数就是把一些需求量比较大的函数进行统一封装，便于调用。

　　好处：增加代码的复用性，增加代码可读性，减少代码的编写量，降低维护成本 。

　　函数名的命名遵循驼峰规则，最好能借名之义。

　　

定义方法：
def function_name(params):    #def 关键字表示定义一个函数。
function_name 函数名，和变量名的命名要求相同，以字母和_开头，可以包含字母、数字和_。
params 表示参数，可以是零个，一个 或者多个参数，函数参数不用指定参数类型。
        block
        return expression(表达式)/value
例子：
def DieDai(iter):  #函数名为DieDai，参数是iter
    for i in iter:     #这就是一个取出可迭代对象里面的值的循环
        print(i)
输出结果：

二、参数形式

　　1、不传参数

def fun1():  #由于在定义函数的时候没有输入参数，所以这个函数不能传参数，在没有传参数的时候就能运行这个函数
    print('不能传参数')
输出结果：

　　 2、必备参数

def fun2(a):    #在定义函数的时候输入了参数，调用的时候必须传入参数
       print('必须传参数:',a)
输出结果：

 　　3、默认参数

def fun3(b=1): #可以传参，也可以不传参，不传参时输出默认值，传参时输出传参值，传参时可以直接输入4，也可以指定输入b=4
    print('默认参数',b)
输出结果：

 　　4、可选参数（不定长参数）

def fun4(*arg): #可传0个到多个参数；不传参时输出空元组；*是必须的，arg可自定义；将参数包装成元组；传参时打入*号可以解包（把里面的壳去掉），*{}输出其中的键，不加*号将{}当成一个元素
    print('可选参数,可传0个到多个:',arg)
输出结果：

 　　5、关键字参数

def fun5(a,b): #定义的时候跟必备参数是一样的，关键字参数其实是一种必备参数 ，混合传参的时候必须要放最后
    print(a,b)


def fun6(**kwarg):  #可传0个到多个，不传是输出一个空字典；定义的时候遵循变量命名规则；**是必须的，kwarg是约定俗成，可以自定义；将传参包装成字典；**{}这种形式下keyword必须是字符串
    print('关键字参数',kwarg)

关键字参数有两种，上面一种没有明确的界限，在传参的时候都可以用=号的形式来，上面一种本身是必备参数。
输出结果：

 　　6、参数混合的时候如何传参

参数混合的时候，关键字参数必须放最后面
默认参数加必备参数
def fun7(a,b=2): #默认参数必须在必备参数的后面
    print(a,b)

调用的时候:
fun7(1,b=2)
fun7(a=1,b=2)
fun7(1,2)     #默认参数也可以不指定
fun7(a=1,2) #会报错，用为关键字参数必须放最后面
fun7(2,a=1) #会报错，在传参时会根据定义时的顺序来传参，确保必备参数能够拿到值，并且只能有一个

输出结果：

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

　　return的作用：

　　1、返回函数的运行结果

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

def fun2(a,b):           if a>b:
        print(a)    
fun1和fun2的区别是若将a=fun1(2,1),a=2;b=fun2(2,1),b=None
return返回了fun1的运行结果
运行结果：

　　2、函数结束的标志

def fun10(a,b):
    return('我下不去了') #终止函数的标志，可以放在任何地方
    if a>b:
        print(a)
输出结果：

 四、lambda 匿名函数

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

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

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

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

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

四、作业

　　1、找到1-100内的质数，用while和for来做，结束之后打印“搜索结束”。(质数：只能被1和自己整除，如2，只有除以1和2才能整除)

 　　　　思路：先判断一个数字是不是质数，比如15，将15除以2到14，若存在能够整除无余，就说明这是一个合数，否则就是一个质数

j=15                   #先确定一个数字j
for i in range(2,15):    #确定被除的数字也就是（2-14）
     if j%i==0:             #遍历j除以i，若存在整除现象，说明是个合数
        print(j,'是一个合数')
        break
else:                           #否则，就是一个质数
    print(j,'是一个质数')
输出结果：

 　　　　思路：然后再将1-100的数放入j即可

j=1
while j<101:               #外面是一个将1-100的数字填入j的while循环
    for i in range(2,j):   #里面是一个检验每个数字是否是质数的for循环 
        if j%i==0:
            break
    else:
        print(j,end=' ')   
    j+=1
else:
    print()
    print('搜索结束') 

输出结果：

或者
num=[]                       #也可以建立个列表
for j in range(1,101):
    for i in range(2,j):
       if j%i==0:
            break
    else:
        num.append(j)    #将每一个符合质数的数字填入列表num
else:
    print(num)              #最后输出列表
    print('搜索结束') 
输出结果：

 　　3、定义一个函数，能够输入元组和字典。将字典的值（value）和元组的值交换，交换结束后返回字典和元组。

　　　　思路：输入元组和字典：要输入元组，说明要*arg；要输入字典，说明要**kwarg。def change(*arg,**kwarg)

　　　　思路：交换字典的值和元组的值：先定义一个元组tu=(1,2,3),一个字典di=('a':11,'b':22,'c':33),要将123和11,12,13进行交换，要交换必须要将元组改变为可变（列表）:tu=list(tu)。在传参的时候应该输入change(*tu,**di),因为如果直接输入tu的话会把里面的元素直接定义为1个元素出现（（1,2,3,），）的现象。若要交换可以直接用tu[0],di['a']=di['a'],tu[0]。

def change(*arg,**kwarg):    
    arg=list(arg)      #将元组arg转化列表
    i=0                    #为列表第一个元素定义索引
    for key in kwarg.keys():   #遍历字典所有的键
        arg[i],kwarg[key]=kwarg[key],arg[i]  #交换字典kwarg和列表arg的值
        i+=1              #让列表跟着字典的键做循环，字典键+1，列表索引也加1
    else:
        print(kwarg)    #输出更改后的字典    
        print(tuple(arg))  #输出更改后的元组，不过要将列表元组化
输出结果：

　　同时，由于列表arg是跟着字典kwarg的键做循环的，所以元组比字典多一个只没关系，反之则不行。