一、函数的定义
首先，我们来看一个简单的例子来定义函数：
def test():
print('hello')
在其中
def ： 关键字，用来告诉解释器，接下来的一段代码是一个函数
test ： 函数名
() ： 用来接收参数
print('hello') : 函数内部的功能
当解释器执行到函数这一块时，函数内部的功能是不会执行的，只会把这个函数放入到内存中，并且起了个名字，叫test。 直到了遇到了一个指定函数名，
如test()才会真正的去执行。
执行函数的代码如下：
def test():
print('hello')
test() #直接调用函数
f=test #把函数名赋值给f
f() #再次执行函数
-----结果-----
hello
hello
二、函数的返回值
在执行的函数的时候，如果想知道某个函数执行的一个结果，就需要用到函数的返回值，如：
def add():
a=1
a+=1
return a #给出函数的返回值
b=add() #把函数的返回值赋值给b
print(b)
-----结果-----
2
如果在函数中，没有用return来给出返回值，而在调用函数的时候，来获取返回值，会有什么现象捏，我们来尝试下：
def add():
a=1
a+=1
b=add()
print(b)
-----结果-----
None
由此可见。还是可以获取返回值，只不过返回值为None
return在函数中，除了可以给出一个返回值外，还有另外一个作用，那就是中断函数操作
def test():
print('hello')
return 1
print('world')
a=test()
-----结果-----
hello #world不会被打印出来
三、参数
3.1函数中参数的几种类型：
在一个函数中，可能会有三种情况：
①无参数
②有单个参数
③有多个参数
无参数的情况，在上面的内容中已经举例过，不再过多介绍
关于有参数的情况，首先来介绍下形参和实参
形参：
形参是写在定义函数()中的参数，它只是一种形式参数,如
def add(x) #定义一个函数add，其中x为形参
实参：
实参是写在调用函数()中的参数，如
def add(x):
...
add(2) #调用add函数，其中的2就是实参
3.2单个参数
介绍完了形参和实参，我们来一起看一个简单的单个参数的例子：
def add(x):
a=1
b=x+1
return b
c=add(2)
print(c)
d=add(3)
print(d)
-----结果-----
3
4
3.3多参数
def test(x,y):
print(x)
print(y)
test(1,2)
-----结果-----
1
2
当形参中有两个参数，但实参中只有一个参数时，运行会出错：
def test(x,y):
print(x)
print(y)
test(1)
-----结果-----
TypeError: test() missing 1 required positional argument: 'y'
3.4默认参数
关于默认参数，顾名思义，就是一个函数的运行结果中，函数中某个参数的值，不受实参的影响，它有一个固定的值，如：
def test(x,y=2): #把y设置为一个默认的参数
print(x)
print(y)
test(1)
-----结果-----
1
2
从上面的例子中，可以看出，在调用函数中，只把1传给了x形参，且没有对y进行传参数。结果可以照样运行
但是，如果在使用了默认参数的情况下，形参的数量等于实参的数量，会发生什么现象呢，如下：
def test(x,y=2):
print(x)
print(y)
test(1,3)
-----结果-----
1
3
由此，我们可以看到，设置的默认参数没有生效，因此得出一个结论，调用函数时，实参的内容，会覆盖掉形参中的默认参数
注意：在使用默认参数的时候，一定要把默认参数放到形参里的最后面，比如说，下面这个写法就是错误的
def test(x,y=2,z)
3.5指定参数
在一般情况下，调用函数时，实参中参数值的传递顺序，和函数中形参的顺序是对应起来的，但是，我们也可以使实参中第一个参数的值，传给
形参中第二个参数，如：
def test(x,y):
print(x)
print(y)
test(y=2,x=1) #把2传给了y，把1传给了x
-----结果-----
1
2
3.6动态参数
当我们在形参中带入一个*，会把会把函数运行结果自动转为了元组
def test(*x): #在形参中加入了一个*
print(x,type(x))
test(1)
test(1,2,3)
-----结果-----
(1,) <class 'tuple'>
(1, 2, 3) <class 'tuple'>
如果在形参中带入两个*，那么会把函数的运行结果转为字典类型
def test(**x): #在形参中加入了两个*
print(x,type(x))
test(k1=1,k2=2) #实参中，需要把键和值都写入
-----结果-----
{'k1': 1, 'k2': 2} <class 'dict'>
那么，如果想要在函数中同时使用元组和字典，该怎么使用捏，如下：
def test(*x,**y):
print(x,type(x))
print(y,type(y))
test(11,22,33,k1=1,k2=2)
-----结果-----
(11, 22, 33) <class 'tuple'> #会自动把执行结果分到元组和字典中
{'k1': 1, 'k2': 2} <class 'dict'>
注意：当形参中同时有一个*和两个*时，一定要把一个*放在前面
刚刚我们在调用函数的时候，传的参数为（11,22,33,k1=1,k2=2） ,如果我们把这些传参，分别放入一个列表和一个字典中，再进行调用函数，会有如下现象：
def test(*x,**y):
print(x,type(x))
print(y,type(y))
l=[11,22,33]
d={'k1':1,'k2':2}
test(l,d)
-----结果-----
([11, 22, 33], {'k1': 1, 'k2': 2}) <class 'tuple'> #把所有内容都放入了函数的x中
{} <class 'dict'>
如果想把实参分别放入函数的x和y中，可以这样：
def test(*x,**y):
print(x,type(x))
print(y,type(y))
l=[11,22,33]
d={'k1':1,'k2':2}
test(*l,**d)
-----结果-----
(11, 22, 33) <class 'tuple'>
{'k1': 1, 'k2': 2} <class 'dict'>
四、lambda表达式
lambda表达式是一种简单函数的表现形式，且自带return
fun=lambda a:a+1 #定义一个lambda表达式，第一个a，相当于函数中的形参，a+1为函数的功能 result=fun(99) print(result) -----结果----- 100