Python学习笔记——python基础 4. 函数进阶_一个元祖用两个变量接受可以么

Python学习笔记—— 4. 函数进阶

1，函数的返回值

① 利用元祖可以返回多个值

直接使用 return 返回一个参数的值

def measure():
    """返回当前的温度"""
    print("开始测量。。。")
    temp = 39
    print("测量结束。。。")
    return temp
result = measure()
print(result)
1
2
3
4
5
6
7
8

开始测量。。。
测量结束。。。
39

使用元祖可以输出多个变量

def measure():
    """返回当前的温度"""
    print("开始测量。。。")
    temp = 39
    wetness = 50
    print("测量结束。。。")
    return temp,wetness
result = measure()
print(result)
1
2
3
4
5
6
7
8
9

开始测量。。。
测量结束。。。
(39, 50)

② 可以用多个值接受返回的元祖

还是以上面的代码为例，如果要分别接收并输出温度和湿度

def measure():
    """返回当前的温度"""
    print("开始测量。。。")
    temp = 39
    wetness = 50
    print("测量结束。。。")
    return temp,wetness
result = measure()
print(result[0])
print(result[1])
1
2
3
4
5
6
7
8
9
10

开始测量。。。
测量结束。。。
39
50

此外，我们可以用多个变量接受元祖的值，用更简便的方法达到同样的效果。

def measure():
    """返回当前的温度"""
    print("开始测量。。。")
    temp = 39
    wetness = 50
    print("测量结束。。。")
    return temp,wetness
result1,result2 = measure()
print(result1)
print(result2)
1
2
3
4
5
6
7
8
9
10

开始测量。。。
测量结束。。。
39
50

元祖的小技巧：交换两个变量的值

a , b = b , a
应该为a , b = （b , a）和用“多个值接受返回的元祖”道理相同

2，函数的参数

在函数内部赋值不会影响外部实参

def demo(num):
    num = 100#在函数内部针对参数使用赋值语句不会影响实参
    print(num)
    print("函数执行完成！")

gl_num = 1
demo(gl_num)
print(gl_num)
1
2
3
4
5
6
7
8

100
函数执行完成！
1

在函数内部使用 方法 修改可变类型的参数会影响外部实参的值

def demo(num_list):
    num_list.append(9)#在函数内部针对参数使用赋值语句不会影响实参
    print(num_list)
    print("函数执行完成！")

gl_list = [1,2,3]
demo(gl_list)
print(gl_list)
1
2
3
4
5
6
7
8

[1, 2, 3, 9]
函数执行完成！
[1, 2, 3, 9]

3，函数的缺省参数

定义函数时，可以给某个参数指定一个默认值，具有默认值的参数叫做缺省参数。
调用函数时，如果没有传入缺省参数的值，则是用参数默认值。
一般情况下，将常见的值设置为缺省参数的缺省值，从而简化函数的调用。
例如：对列表排序的方法

gl_num_list = [6, 3, 9]
#默认就是升序排序，因为这种需求更多
gl_num_list.sort()
print(gl_num_list)
#只有当需要降序排序时，才需要传递“reverse”参数
gl_num_list.sort(reverse=True)
print(gl_num_list)

1
2
3
4
5
6
7
8

[3, 6, 9]
[9, 6, 3]

指定缺省参数默认值的方法

def print_info(name,gender = True):
    """
    
    :param name: 班上同学的姓名
    :param gender: True 男生 False 女生
    """

    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s"%(name,gender_text))
print_info("小明")
print_info("小红",False)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

小明 是 男生
小红 是 女生

缺省参数的注意事项

① 必须保证带有默认值的缺省参数在参数列表末尾
所以以下定义是错误的：

def print_info(name, gender = True , title)
1

②调用具有多个缺省参数的函数时，需要指定参数名，这样解释器才能知道参数的对应关系 ！

def print_info(name,title = 2,gender = True):
    """
    
    :param name: 班上同学的姓名
    :param gender: True 男生 False 女生
    """
    print(title)
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s 是 %s"%(name,gender_text))
print_info("小明",title=1)
print_info("小红",gender=False)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1
小明 是 男生
2
小红 是 女生

4，多值参数

有时可能需要一个函数能够处理的参数个数是不确定的，这个时候就可以使用多值参数
Python中有两种多值参数：
参数名前加一个 * 可以接收元祖
参数名前加两个 * 可以接收字典

def demo(num, *args, **kwargs):
    print(num,args,kwargs)

demo(1)
demo(1, 2, 3, 4, 5, 6, name="小明", )

1
2
3
4
5
6

1 () {}
1 (2, 3, 4, 5, 6) {‘name’: ‘小明’}

一般在给多值参数命名时，习惯用以下两个名字：

*args ——存放元祖参数
**kwargs ——存放字典参数

实例：参数求和

def sum_number(*args):
    num = 0
    print(args)
    for n in args:
        num += n
        
    return num
print(sum_number(1,2,3,4,5))
1
2
3
4
5
6
7
8

(1, 2, 3, 4, 5)
15

元组和字典的拆包

在调用带有多值参数的函数时，如果希望将一个元组变量直接传递给args，将一个字典变量直接传递给kwargs，就可以使用拆包，简化参数的传递
拆包的方式是：
在元组变量前，增加一个*
在字典变量前，增加两个*

def demo(*args,**kwargs):
    print(args)
    print(kwargs)
gl_nums = (1,2,3)
sl_dict = {"name" : "小明","age":18}
demo(*gl_nums,**sl_dict)
1
2
3
4
5
6

(1, 2, 3)
{‘name’: ‘小明’, ‘age’: 18}
((1, 2, 3),)
{‘kwargs’: {‘name’: ‘小明’, ‘age’: 18}}

5，函数的递归

代码特点：
① 函数内部的代码是相同的，只是针对的参数不同，处理的结果不同。
② 当参数满足一个条件时，函数不再执行（这个非常重要，通常被称为递归的出口）
示例：

def sum_number(num):
    print(num)
    #递归的出口
    if num == 1:
        return
    # 自己调用自己
    sum_number(num - 1)
sum_number(3)

1
2
3
4
5
6
7
8
9

3
2
1

def sum_numbers(num):
    # 1.出口
    if num == 1:
        return 1
    # 2.数字的累加
    temp = sum_numbers(num - 1)
    return num + temp
result = sum_numbers(100)
print(result)

1
2
3
4
5
6
7
8
9
10

5050