day09-函数讲解

1、如何定义一个函数

 s = '华为加油a'
 def s_len():
     i = 0
     for k in s:
         i += 1
     print(i)
 s_len()

　　这个函数的功能就是输出字符串的长度。但是他只能输出特定字符串的长度，所以我们换一种写法：

 k = '华为加油a'
 def s_len(s):
     i = 0
     for k in s:
         i += 1
     print(i)
     return  i # 使函数有返回值
 s_len(k)
 s_len('天下第一无敌帅') # 可以直接将字符串当作一个实参

2、函数返回值的介绍

　　函数的返回值有三种情况，分别是无返回值、返回一个值和返回多个值。

　　2.1、无返回值

　　　　无返回值也即返回一个None。无返回值的情况也分为三种：

　　　　1.函数中不写return。

　　　　2.只写一个return。只写一个return代表结束一个函数。若语句执行到return，则跳出这个函数。

　　　　3.return None。这种方式不常用。

　　2.2、返回一个值

　　　　1.返回的一个值，可以是各种数据类型的，不论是列表、元祖还是什么，都可以返回成功。

　　　　2.只要返回，就能够接受的到。

　　　　3.如果一个函数中有多个return，那么只会执行第一个return，后面的return都不会执行。

　　2.3、返回多个值

　　　　1.用多个变量接收，有多少个返回值就用多少个变量去接收

 def return_more():
     return 1,2,3
 a,b,c = return_more()
 print(a,b,c)

　　　　2.可以用一个变量去接收所有的变量，得到的是一个元祖

 def return_more():
     return 1,2,3
 result = return_more()
 print(result)
 # result: (1,2,3)

3、函数的参数讲解

　　函数的参数可以没有，可以有一个，可以有多个。

　　传参时，也有一些细节需要注意：

　　　　　　1.按照位置传参

 def deliver(a,b):
     print(a,b)
 deliver(1,2)

　　　　　　2.按照关键字传参

 def deliver(a,b):
     print(a,b)
 deliver(b = 1,a = 2)

　　　　　　3.混合传参。混合传参必须先按照位置传参，然后才可以按照关键字传参。

 def deliver(a,b):
     print(a,b)
 deliver(1,b = 2)

　　　　　　以下几种是错误的。

#
def deliver(a,b):
    print(a,b)
deliver(1,a = 2) #不能两个都是a

#
def deliver(a,b):
    print(a,b)
deliver(a = 1,2)

　　　　　　4.默认参数。对于默认参数，不传参的话就会用默认的参数，传了的话，就会用传过的。

 def classmates(name,sex = '男'):#设置默认值
     print('%s:%s'%(name,sex))
 classmates('张三')

　　　　　　在这里，sex默认为男，没有传参时，输出的内容就是默认的男。

　　　　　　5.若想要定义默认参数，必须先定义位置参数，才能定义默认参数。

 def classmates(sex = '男',name):#设置默认值
     print('%s:%s'%(name,sex))
 classmates('张三')

　　　　　　上面的这种方式就会报错，为什么呢？这是因为你这里的张三，电脑根本不知道他到底是sex的还是name的。

　　　　　　6.动态参数

　　　　　　（1）*args---接收的是按位置传参的值，组成一个元祖

　　　　　　一般来说，我们想要计算两个数之和，我们会定义a+b，那么我们想要计算n个数之和，我们该怎么办呢？这里我们就用到了动态参数。

 def sum(*args):
     print(args)
 sum(1,2)
 sum(1,2,3)
 sum(1,2,3,4)
 # result:
 # (1, 2)
 # (1, 2, 3)
 # (1, 2, 3, 4)

　　　　　　在上面代码中，我们可以看到，不论调用函数是，实参有多少个，结果都能打印出来，且结果是一个元祖。同时定义函数时，形参必须加星号，至于为什么要用args，是因为它是一种习惯用法，你也可以用其他的变量名，但通常来说，都是用args，方便别人理解。

 def sum(*args):
     Sum = 0
     for i in args:
         Sum += i
     print(Sum)
 sum(1,2)
 sum(1,2,3)
 sum(1,2,3,4)
 # result:
 #
 #
 #

　　　　　　(2)**kwargs---接收的是按关键字传参的值，组成一个字典

 def func(**kwargs):
     print(kwargs)
 func(a = 1,b = 2)
 func(a = 1,b = 2,c = 3)
 func(a = 1,b = 2,c = 3,d = 4)
 # result:
 # {'a': 1, 'b': 2}
 # {'a': 1, 'b': 2, 'c': 3}
 # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

　　　　　　（3）将（1）（2）混合，注意必须先定义位置动态参数，再定义关键字动态参数。

 def func(*args,**kwargs):
     print(args,kwargs)
 func(1,2,a = 3,b = 4)
 # result:(1, 2) {'a': 3, 'b': 4}

　　　　　　(4)细节讲解

def put(*args):
    print(args)
put(1,2,3,4)
# 上面结果为：(1,2,3,4)，但是如果换成下面的形式会输出什么呢？
def put(*args):
    print(*args)
put(1,2,3,4)
# 结果是：1 2 3 4，很明显，第一种的结果是一个元祖，而第二种的结果一个个被打散了的数。那么为什么能够这样使用呢？
# 可以看下面的代码：
print(*[1,2,3,4],*(1,2,3,4))
# 他们的结果都是：1 2 3 4。从结果可知，不论是元祖还是列表，在前面加上星号，都会使之成为一个个的数。而在上面第二段代码中，也是同样道理，输出args时，是一个元祖，输出*args，也就相当于在元祖前面加上星号。

　　　　　　7.在第五点中，若要定义默认参数，但同时还有位置参数时，它们之间有个顺序。若同时还有动态参数时，他们的顺序又是什么呢？

　　　　　　他们的顺序分别是：位置参数、*agrs、默认参数、**kwargs。

　　　　　　为什么默认参数在**kwargs前面呢，仔细想一想，假设**kwargs在默认参数前面，那么第一个关键字肯定是给了**kwargs了，默认参数接收的不知道是哪一个，所以默认参数必须在**kwargs前面，这样默认参数才能接收到他的值。

　　　　　　8.动态参数的另一种传参方式

　　　　　　假设有一个序列l = [1,2,3,4]，我要分别将其中的内容打印出来，可以这样做：

 def func(*args):
     print(args)
 l = [1,2,3,4]
 func(l[0],l[1],l[2],l[3])

　　　　　　但是，如果这个序列中有很多元素，那岂不是很累，所以现在我们可以这样做：

 def func(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值
     print(args)
 l = [1,2,3,4]
 func(*l)#站在实参的角度上，就是将这个序列打散
 #result:(1, 2, 3, 4)

　　　　　　同理，对于**kwargs，我们也可以这样做：

 def func(**kwargs):
     print(kwargs)
 d = {'a':1,'b':2}
 func(**d)

4、函数的注释

　　

 函数的注释
 # def func():
 #     '''
 #     这个函数实现了什么功能
 #     参数1：有什么作用
 #     参数2：有什么作用
 #     :return: 是字符串或者列表的长度
 #     '''
 #     pass