函数返回值和参数进阶

目标

# 函数参数和返回值的做用
# 函数的返回值 进阶
# 函数的参数 进阶
# 递归函数

01.函数参数和返回值的做用

# 函数根据 有没有参数 以及 有没有返回值，能够相互组合，一共有4种组合形式
# 1.无参数，无返回值
# 2.无参数，有返回值
# 3.有参数，无返回值
# 4.有参数，有返回值

定义函数时，是否接收参数，或者是否返回结果，是根据实际功能需求来决定的！

# 1.若是函数内部处理的数据不肯定，就能够将外界的数据以参数传递到函数内部
# 2.若是但愿一个函数执行完成后，向外界汇报执行结果，就能够增长函数的返回值

 02.函数的返回值 进阶

# 在程序开发中，有时候，会但愿一个函数执行结束后，告诉调用者一个结果，
以便调用者针对具体的结果作后续的处理
# 返回值是函数完成工做后，最后给调用者的一个结果
# 在函数中使用 return 关键字能够返回结果
# 调用函数一方，可使用变量来接收函数的返回结果

问题：一个函数执行后可否返回多个结果？

示例——温度和湿度测量

假设要开发一个函数可以同时返回当前的温度和湿度

def measure():
    """测量温度和湿度"""
    print("测量开始...")
    temp = 39
    wetness = 50
    print("测量结束。。。")
　　# 利用元组在返回温度的同时，也可以返回湿度
    # 元组-能够包含多个数据，所以可使用元组让函数一次返回多个值
    # 若是函数返回的类型是元组，小括号能够省略
    # return(temp,wetness)
    return temp,wetness
result = measure()
print(result)

接收返回元组函数的方式

# 当函数执行完成以后，result中保存的数据是元组
result = measure()
print(result)
# 要单独的处理温度或者湿度 记录单独的下标 不方便
print(result[0])
print(result[1])
# 若是函数返回的类型是元组，同时但愿单独的处理元组中的元素
# 可使用多个变量，一次接收函数的返回结果
# 注意：使用多个变量接收结果时，变量的个数应该和元祖中元素的个数保持一致
gl_temp,gl_wetness = measure()

print(gl_temp)
print(gl_wetness)

面试题——交换两个数字

题目要求

# 1.有两个整数变量 a = 6，b = 100
# 2.不使用其余变量，交换两个变量的值

# 解法1- 使用其余变量
a = 6
b = 100

c = a
a = b
b = c
print(a)
print(b)

# 解法2- 不使用其余变量
a = 6
b = 100

a = a + b
b = a - b
a = a - b
print(a)
print(b)

#解法3- Python专有，利用元组
a = 6
b = 100

# a,b = (b,a)
# 提示：等号右边是一个元组，只是把小括号省略了
a,b = b,a

print(a)
print(b)

 

03.函数的参数 进阶

3.1 不可变和可变的参数

问题1：在函数内部，针对参数使用赋值语句，会不会影响调用函数时传递的实参变量？

不会！　　　　不管传递的参数是可变仍是不可变，只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用

def demo(num,num_list):
    print("函数内部的代码")
    # 在函数内部，针对参数使用赋值语句,不会修改到外部的实参变量
    num = 100
    num_list = [1,2,3]
    print(num)
    print(num_list)
    print("函数执行完成")
gl_num = 99
gl_list = [4,5,6]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

问题2：若是传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，一样会影响到外部的数据

def demo(num_list):
    print("函数内部的代码")
    # 使用方法修改列表的内容
    num_list.append(9)

    print(num_list)
    print("函数执行完成")

gl_list = [1,2,3]
demo(gl_list)
print(gl_list)

 

面试题—— +=

在Python中，列表变量调用+=本质上是在执行列表变量的extend方法，不会修改变量的引用

def demo(num,num_list):
    print("函数开始")
    # 本质上是在作 num = num + num
    num += num
    print(num)
    num_list += num_list
    # 本质上并不是 num_list = num_list + num_list
    # 而是调用列表的extend方法
    # 列表变量使用+=不会作相加再赋值的操做
    # 即影响并修改了全局变量中的列表变量调用
    # 因为是调用方法，因此不会修改变量的引用
    # 函数执行结束后，外部数据一样会发生变化
    # num_list.extend(num_list)
    print(num_list)
    print("函数完成")

gl_num = 9
gl_list = [1,2,3]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

 

3.2 缺省参数

# 定义函数时，能够给某个参数指定一个默认值，具备默认值的参数就叫作缺省参数
# 调用函数时，若是没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
# 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用
# 例如：对列表排序的方法

gl_list = [6,3,9]
# sort方法若是不传递参数，默认按照升序排列-由于较为经常使用
gl_list.sort()
# 若是须要按照降序排列,须要执行reverse参数
gl_list.sort(reverse=True)
# reverse就是缺省参数，若是不传递任何参数就会采用默认值，reverse的默认值是false
# 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用
print(gl_list)

指定函数的缺省参数

在参数后使用赋值语句，能够指定参数的缺省值

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.若是一个参数的值不能肯定，则不该该设置默认值，具体的数值在调用函数时，由外界传递！

缺省参数的注意事项

1）缺省参数的定义位置

必须保证带有默认值的缺省参数在参数列表末尾

因此如下定义是错误的

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

2）调用带有多个缺省参数的函数

在调用函数时，若是有多个缺省参数，须要指定参数名，这样解释器才可以知道参数的对应关系！

# 例如当定义了三个参数，须要定义肯定的参数，在后面直接写上参数名跟上要传递的实参
def print_info(name,title="",gender=True)

print_info("小美",gender=False)

3.3 多值参数

定义支持多值参数的函数

#有时可能须要 一个函数 可以处理的参数 个数 是不肯定的，这个时候，就可使用 多值参数
#Python中有两种多值参数：
#     参数名前增长一个 * 能够接收 元组
#     参数名前增长两个 * 能够接收 字典

# 通常在给多值参数命名时，习惯使用如下两个名字
#    *args - 存放元组参数，前面有一个 *
#    **kwargs - 存放字典参数，前面有两个 *
#args 是 arguments 的缩写，右边梁的含义
#kw 是 keyword 的缩写，kwargs 能够记忆 键值对参数

def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)

# 1为实参num的参数，2345为*nums的元组参数，
# name = "小明"为**person的字典参数 
# 当输入时能够看到下方提示所属参数
demo(1,2,3,4,5,name = "小明")

提示：多值参数 的应用会常常出如今网络上一些大牛开发的框架中，知道多值参数，有利于咱们可以读懂大牛的代码

 多值参数案例 ——  计算任意多个数字的和

需求

1.定义一个函数 sum_numbers,能够接收的任意多个整数

2.功能需求：将传递的全部数字累加而且返回累加结果

def sum_numbers(*args):
# def sum_numbers(args):
# 当使用*指令的参数和没有*指令的参数，在调用函数时
# *指令的元组参数无需无需多加一对括号，
# 而没有*指令的则须要在多个数据外再加个括号
# 若是想要调用任意多个参数，能够在参数名前加个*
    num = 0

    print(args)
    # 循环遍历
    for n in args:
        num += n
    return num
result = sum_numbers(1,2,3)
# result = sum_numbers((1,2,3))
print(result)

元组和字典的拆包

# 在调用带有多支参数的函数时，若是但愿：
        将一个元组变量，直接传递给 args
        将一个字典变量，直接传递给kwargs
# 就可使用拆包，简化参数的传递，拆包的方式：
        在元组变量前，增长一个*
        在字典变量前，增长两个*

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

#元组变量/字典变量
gl_nums = (1,2,3)
gl_dict = {"name": "小明","age": 18}

# demo(gl_nums,gl_dict)
# 会致使两个变量都在args参数中输出，而kwargs参数只能输出一个空的字典{}
# 因此就须要使用到拆包语法，简化元组变量/字典变量的传递
demo(*gl_nums,**gl_dict)
# 下面的方法也称为拆包语法，只是没有上面的方便
# demo(1,2,3,name="小明",age = 18)

 

04.函数的递归

函数调用自身的编程技巧称为递归

4.1递归的函数特色

特色

　　一个函数 内部 调用本身

　　函数内部能够调用其余函数，固然在函数内部也能够调用本身

代码特色

1.函数内部的代码是相同的，只是针对参数不一样，处理结果不一样

2.当参数知足一个条件时，函数再也不执行

　　这个很是重要，一般被称为递归的出口，不然会出现死循环，形成程序出错！

def sum_number(num):
    print(num)
    # 在编写递归程序时，须要有一个递归的出口，当参数知足某个条件时，再也不执行函数
    if num == 1:
        return
    # 本身调用本身
    sum_number(num - 1)

sum_number(3)

4.2 递归案例 —— 计算数字累加

需求

1.定义一个函数 sum_numbers

2.可以接收一个 num 的整数参数

3.计算 1+2+...num 的结果

# 定义一个函数 sum_numbers
# 可以接收一个 num 的整数参数
# 计算 1+2+...num 的结果

def sum_numbers(num):
    # 1.设置出口
    if num == 1:
        return 1
    # 2.数字的累加 num + (1...num - 1)
    # 假设 sum_numbers 可以正确的处理1...num-1
    temp = sum_numbers(num - 1)
    # 两个数字的相加
    return  num + temp

result = sum_numbers(5)
print(result)

 

提示：递归是一个编程技巧，初次接触递归会感受有些吃力！在处理不肯定的循环条件时，格外的有用，例如：遍历整个文件目录的结构