python-函数的使用

一、函数的定义

首先，我们来看一个简单的例子来定义函数：

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