day09-函数讲解

1、如何定义一个函数

1 s = '华为加油a'
2 def s_len():
3     i = 0
4     for k in s:
5         i += 1
6     print(i)
7 s_len()

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

1 k = '华为加油a'
2 def s_len(s):
3     i = 0
4     for k in s:
5         i += 1
6     print(i)
7     return  i # 使函数有返回值
8 s_len(k)
9 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.用多个变量接收，有多少个返回值就用多少个变量去接收

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

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

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

3、函数的参数讲解

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

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

　　　　　　1.按照位置传参

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

　　　　　　2.按照关键字传参

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

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

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

　　　　　　以下几种是错误的。

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

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

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

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

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

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

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

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

　　　　　　6.动态参数

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

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

1 def sum(*args):
2     print(args)
3 sum(1,2)
4 sum(1,2,3)
5 sum(1,2,3,4)
6 # result:
7 # (1, 2)
8 # (1, 2, 3)
9 # (1, 2, 3, 4)

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

 1 def sum(*args):
 2     sum = 0
 3     for i in args:
 4         sum += i
 5     print(sum)
 6 sum(1,2)
 7 sum(1,2,3)
 8 sum(1,2,3,4)
 9 # result:
10 # 3
11 # 6
12 # 10

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

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

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

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

 

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

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

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

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

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

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

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

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

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

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

4、函数的注释

　　

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