一、函数的定义
函数就是对代码进行一个封装。把实现，某一功能的相同代码，进行封装到一起。下次需要使用时，就不需要再进行代码编写，直接调用即可。
内置函数就是把一些需求量比较大的函数进行统一封装，便于调用。
好处：增加代码的复用性，增加代码可读性，减少代码的编写量，降低维护成本 。
函数名的命名遵循驼峰规则，最好能借名之义。
定义方法：
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的键做循环的，所以元组比字典多一个只没关系，反之则不行。