Python第八课(函数1)

Python第八课(函数1)    >>>转到思维导图>>>转到中二青年

函数的返回值

函数内要想返回给调用者值 必须用关键字return

不写return:函数默认返回None

1 def func():
2     print('hahaha')
3 res = func()
4 print(res)
View Code

 只写return:return除了可以返回值之外,还可以直接结束整个函数的运行

只写return 返回的也是None(None就表示什么都没有)

 1 只写return 返回的也是None(None就表示什么都没有)
 2 def func():
 3     l = ['jason','egon','tank']
 4     while True:
 5         for i in l:
 6             if i == 'egon':  # 当i为egon的时候 直接结束函数运行
 7                 # break
 8                 return
 9                 # print('asdasdkljlsjadl')  # 这一行代码拥有都不会运行
10             print(i)
11 res = func()
12 print(res)
View Code

写return None:跟上面的只写return是一样的

1 def func():
2     return None
3 res = func()
4 print(res)
View Code

写return返回一个值:这个值可以是python任意数据类型

 1 def func():
 2     return '123'
 3 def func1():
 4     return [1,2,3]
 5 def func2():
 6     return {'name':'jason'}
 7 def func3():
 8     return (1,)
 9 def func4():
10     return {1,2,3,4,5}
11 def func5():
12     return True
13 print(func(),func1(),func2(),func3(),func4(),func5())
View Code

写return返回多个值:return会自动将多个值以元组的形式返回给调用者

 1 """
 2 1.为什么组织成元祖返回
 3     函数不希望自己处理的结果被修改    
 4 """
 5 def func():
 6     return 1,2,3,4  # 返回的是(1, 2, 3, 4)
 7 res = func()
 8 print(res)
 9  
10 def func1():
11     return 'a','b','c'  # ('a', 'b', 'c')
12 res = func1()
13 print(res)
14  
15  
16 def func2():
17     return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
18 res1 = func2()
19 print(res1)
20  
21  
22 def func3():
23     return {'name':'jason'},{'username':'tank'},{'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
24 res2 = func3()
25 print(res2)
 1 """
 2 2.如何不返回元祖
 3     返回多个值 并且不想让return帮你做处理  自己手动加上你想返回的数据类型符号
 4 """
 5 def func4():
 6     return [[1,2,3,4],[1,2,3,4],[1,2,34]]
 7 res = func4()
 8 print(res)
 9  
10  
11 """
12 1.所有的函数都有返回值,无论你写不写return
13     python中所有的函数都有返回值 不写的情况下默认返回None
14  
15 2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行
16  
17 """

函数的参数概要

 1 s = 'hello'
 2 l = [1.2,3,4]
 3 print(len(s))
 4 print(len(l))
 5  
 6 def my_len(args):  # 需要0个参数
 7     print(args)
 8     n = 0
 9     for i in args:
10         n += 1
11     return n
12 res = my_len()
13 print(res)
14 my_len(l)  # 给my_len传了一个参数
15 my_len('asda')
16 print(my_len('hello'))
17 print(my_len('hello world'))
18 print(my_len([1,2,3,4,5]))
19 """
20 函数参数的两大类型
21     形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
22     实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参
23     
24     形参与实参的关系
25         形参就相当于变量名,而实参就相当于变量的值
26         函数调用传参的过程 就是给形参变量名赋值的过程
27     
28     注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除
29     只在函数内部有效 函数外部无任何影响
30     
31     
32     函数的简易结构
33         def 函数名(形参1,形参2...):
34             '''函数的注释 用来描述该函数的作用以及各个形参的类型'''
35             函数体代码1
36             函数体代码2
37             ...
38             return 函数的返回值
39     
40 """
 1 def func(x,y):
 2     """
 3     该函数的作用
 4     :param x: 对形参x的解释
 5     :param y: 对形参y的解释
 6     :return: 对函数返回值的解释
 7     """
 8     print('hahaha')
 9     return 'heihei'
10  
11 print(help(func))
12 print(help(len))
View Code

位置参数

 1 # 求两个数的大小 返回大的那个
 2  
 3 # 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参
 4 # 位置形参在调用的时候 必须为其传值
 5 def my_max(x,y):
 6     print(x,y)
 7     if x > y:
 8         return x
 9     else:
10         return y
11 res = my_max(1)  # 在调用函数的时候 少一个实参不行
12 res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行
13  
14 res = my_max(20,10)
15  
16 # 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参
17 # print(res)
18  
19  
20 # 第一种直接按照位置传  一一对应
21  
22 # 第二种指名道姓的传  >>>:关键字传参
23 my_max(y=20,x=10)
24 my_max(10,y=20)  # 位置和关键字混合使用
25 my_max(20,y=40)
26 my_max(20,y=40,x=30)
27  
28 """
29 注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
30 但是必须保证
31     1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
32     2.同一个形参不能被多次赋值
33 """

默认值参数

1 # 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
2 # 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
3 # 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值
4 # 在定义阶段 默认值形参必须放在位置形参的后面
 1 def my_max(x,y=100):
 2     if x > y:
 3         return x
 4     return y
 5 # res = my_max(200)
 6 res1 = my_max(200,1000)
 7 res2 = my_max(y=200,x=1000)
 8 print(res2)
 9  
10 def register(username,age,gender='male'):
11     print(username,age,gender)
12 register('jason',18)
13 register('tank',28)
14 register('egon',84)
15 register('kevin',58)
16 register('xiaohou',17,'female')
17  
18  
19 # 默认值参数的应用场景
20 # 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参
21  
22  
23 def info(username,hobby,l=None):
24     if l == None:
25         l = []
26     l.append(hobby)
27     print('%s 的爱好是 %s'%(username,l))
28 info('jason','study')
29 info('tank','生蚝')
30 info('kevin','喝腰子汤')
31 info('egon','女教练')
32  
33 解决方法1
34 info('jason','study',[])
35 info('tank','生蚝',[])
36 info('kevin','喝腰子汤',[])
37 info('egon','女教练',[])
38  
39 解决方法2
40 info('jason','study')
41 info('tank','生蚝')
42 info('kevin','喝腰子汤')
43 info('egon','女教练')
44  
45  
46 m = 100
47 def my_max(x,y=m):
48     print(x,y)
49 m = 222
50 my_max(111)
51  
52  
53 def func(x,y=100):
54     print(x,y)
View Code
1 """
2 函数在定义阶段 内部所使用的变量都已经初始化完毕了
3 不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)
4  
5 函数无论在什么地方被调用
6 都会跑到函数定义阶段去执行代码
7 形参中用到的值都是往函数定义阶段代码往上找
8 """

可变长参数

1 # 可变长参数
2 # 站在调用函数传递实参的角度  实参的个数不固定的情况
3 # 也就意味形参也不固定
4 # 站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数
5  
6 # 站在形参的角度 看 *
7 # 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
 1 def func(x,y,*z):
 2     print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
 3 func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)
 4  
 5 # 站在实参的角度 看 *
 6 def func(x,y,z):
 7     print(x,y,z)
 8 l = [1,2,3]
 9 a,b,c = l
10 func(a,b,c)
11 func(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
12 func(*(1,2,3))  # 等价于func(1,2,3)
13 def func(x,*z):
14     print(x,z)
15 func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参
16 # *只能将列表 元组 集合 字符串
17 # *的内部你可以看成是for循环
18  
19  
20 # 站在形参的角度看 **
21 def func(x,y,**z):
22     print(x,y,z)  # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
23 func(x=1,y=2,z=1,a=1,b=2,c=3)
24 # **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
25 # 字典的value就是关键字的名字指向的值  将字典交给**后面的变量名
26  
27  
28 # 站在实参的角度看 **
29 def func(x,y,z):
30     print(x,y,z)
31 func(12,3,4)
32 func(x=1,y=2,z=3)
33 d = {'x':1,'y':2,'z':333}
34 func(x=1,y=2,z=3)
35 func(**d)  # 等价于func(x=1,y=2,z=333)
36 # **会将字典拆封成 key = value的形式
View Code
 1 """
 2 总结 * 与 **
 3     *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
 4     **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名
 5     
 6     
 7     *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
 8         (*就看成是for循环取值)
 9     **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
10 """
11 # 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
12 def func1(*x,**y):
13     print(x,y)
14 func1(1,2,3,4,5,6,x=1,y=2,z = 3)
15  
16 """
17 注意python推荐形参*和**通用的写法
18 """
19 def func2(*args,**kwargs):
20     print(args,kwargs)
21 func2(1,2,3,4,5,6,x=1,y=2,z = 3)

END

posted @ 2019-07-09 16:07 宋人杰 阅读(...) 评论(...) 编辑 收藏