python定义一个求和函数求参数的和并返回,Python基础知识12: 函数的返回值和参数进阶...

一、内容总览

1.1、函数参数和函数返回值的作用

1.2、函数的返回值进阶

1.3、函数的参数进阶

1.4、递归函数

二、函数参数和函数返回值的作用

2.1、函数根据有没有参数以及有没有返回值，相互组合之后有以下四种情况

无参数 无返回值

无参数 有返回值

有参数 无返回值

有参数 有返回值

定义一个函数是否要返回值，以及是否要传参数，要根据自己的需求而定

2.2、函数的返回值进阶~利用元组返回多个值

我们在开发的过后中，在调用一个函数后，我们希望函数返回多个值，这时候我们就可以利用元祖了，元组可以包含多个不同类型的值，如下，查询一个人的信息，返回他的身高和年龄(提示：你可以利用字典包含多个值返回)

def people_info():

name = "小王"

age = 26

# 如果函数返回的类型是元组，小括号可以省略

return name,age 或者 return (name,age)

result = people_info()

print("名字=%s 年龄=%d" % (result[0],result[1]))

返回元组取值的优化：用多个变量去接受返回元组的值，要求：变量的个数要与函数返回元组的个数一致，优点是：不用在使用索引取值

def people_info():

name = "小王"

age = 26

# 如果函数返回的类型是元组，小括号可以省略

return name,age 或者 return (name,age)

name,age = people_info()

print("名字=%s 年龄=%d" % (name, age))

延伸：交换两个变量的值，如：a = 2 b = 3 ,交换其值

解法1：使用中间变量

c = a

a = b

b = c

解法二：不使用中间变量

a = a + b

b = a - b

a = a - b

解法三：python专有，利用元祖赋值交换

a,b = (b,a)

三、函数的参数-进阶(不可变和可变的参数)：函数内部赋值不会影响到外部的实参，通过方法修改其值会改变外部实参

3.1、针对函数内部的参数进行赋值，是不会影响到函数调用时传递的实参变量，如下

def test(num):

# num 在这里相当于一个局部变量，刚开始与外面的gl_num指向的是同一个 数据内存地址，

# 在函数内被重新赋值为 20，又指向了数据 20 的内存地址，

# 而原来的 gl_num 还是指向 10的内存地址

num = 20

print(num)

gl_num = 10

test(gl_num)

print(gl_num)

3.2、在函数内部使用方法修改可变参数会影响外部实参，如下

def test(num_list):

num_list.append(5)

print(num_list)

gl_num_list = [1,2,3,4]

test(gl_num_list)

print(gl_num_list)

打印结果是：

[1,2,3,4,5]

[1,2,3,4,5]

拓展： 可变类型的 +=,num_list += num_list 本质上是调用列表的：num_list.extend(num_list)，如下面的列表

def test(num_list):

num_list += num_list

print(num_list)

gl_num_list = [1,2,3]

test(gl_num_list)

print(gl_num_list)

打印结果是：

[1,2,3,1,2,3]

[1,2,3,1,2,3]

3.3、列表的排序方法明确缺省参数的概念及作用( 提示：缺省参数也就是形参默认有值的)

定义函数时，可以给 某个参数 指定一个 默认值，具有默认值的参数就叫做 缺省参数

调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用定义函数时指定的参数默认值

函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用

如下：列表的升序与降序 ~ 传参

gl_number_list = [3,1,5]

# 默认就是升序排序，因为这种应用需求更多

gl_number_list.sort()

print(gl_number_list)

# 只有当需要排序的时候，才需要传递 reverse 参数

gl_number_list.sort(reverse=True)

print(gl_number_list)

指定参数为缺省参数，直接在参数名后面加上 = 值 就好了，如下

def test(name,gender=True):

gender_test = "男"

if not gender:

gender_test = "女"

print("%s 是 %s"% (name, gender_test))

test("李四",True)

打印结果：

李四 是 男

缺省参数，需要使用 最常见的值 作为默认值！如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！

缺省参数 注意事项

(1)、缺省参数的定义位置：必须保证 带有默认值的缺省参数 在参数列表的末尾，下面的例子

# 错误的

def test(name,age="18",height):

# 正确的

def test(name,height,age="18"):

(2)、调用带有多个缺省参数的函数

在 调用函数的时候，如果有 多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！,如下：只给height赋值

def test(name,age="1",height=""):

print("名字=%s 年龄=%s 身高=%s"%(name, age, height))

test("老王",height="178"):

3.4、多值参数

有时候可能需要 一个函数 能够处理的参数 个数 是不确定的，这个时候，就可以使用 多值参数

python 中有 两种 多值参数：

参数名前增加一个 * 可以接收 元组

参数名前增加两个 * 可以接收 字典

一般在给多值参数命名时，习惯使用下面的两个名字

*args(arguments的缩写，有变量的含义) ，存放元组，参数前有一个 *

**kwargs(kw是单词keywords的缩写)，存放 字典 参数，前面有两个 *

看下面的例子：

def test(name,*args,**kwargs):

print(name)

print(args)

print(kwargs)

test3("小李",1, 2,3,A="1",B="2")

3.5、元组 和 字典 的拆包(拆包语法：简化了元组变量和字典变量的传递)

在调用带有多值参数的函数时，如果希望：

将一个元组变量，直接传递给 args,在传值的实参前面加上 一个 *

将一个字典变量，直接传递给 kwargs,在传值的实参前面加上 两个 *

如下

def test(*args,**kwargs):

print(args)

print(kwargs)

tuple1 = (1,2,3)

dict1 = {"name":"小王","age":18}

test(*tuple1,** dict1)

打印结果是：

(1, 2, 3)

{'name': '小王', 'age': 18}

四、函数的递归(函数调用自身的编程技巧就叫做 递归)，在处理不确定的循环条件时，比较有用，例如：遍历整个文件的目录

4.1、递归函数的特点

一个函数内部调用自己：函数内部既可以其他函数，也可以调用自己

代码特点：(1)、函数内部的代码是相同的，只是针对参数不同，处理的结果不同,(2)、当参数满足一个条件时，函数不再执行(这个通常被称为递归的出口，很重要，如果没有会出现 死循环)

def test(num):

if num == 1:

return

test(num-1)

print(num)

test(5)

打印结果是：

4

3

2

1

5

从上面的打印结果我们可以看出，当外面的 test(5) 调用的时候，print(num) 函数是不会执行的，等其他调用都结束了才会执行

4.2、递归函数的例子：累加求和求 1到100的和，用递归如下

def sum_number(num):

# 1、出口

if num == 1:

return 1

# 2、数字累加 num + (1+2+...num-1)

temp = sum_number(num-1)

# 3、两个数字相加的和

return num + temp

result = sum_number(100)

print(result)

4.3、下面是一个计算递归求和的图示

计算递归求和的图示