Python笔记11——函数进阶_py编写函数,接受一个整数列表作为参数,返回一个新列表,其中包含原列表中所有的奇

1 函数参数和返回值的作用

函数根据有没有参数以及有没有返回值，可以相互组合，一共有4种组合形式

1. 无参数，无返回值
2. 无参数，有返回值
3. 有参数，无返回值
4. 有参数、有返回值

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

1. 如果函数内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部
2. 如果希望一个函数执行完成后，向外界汇报执行结果，就可以增加函数的返回值

2 函数的返回值进阶

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

练习–温度和湿度测量

• 开发一个函数能够同时返回当前的温度和湿度

def measure():
    "测量温穿和温度“ "
    print("测量开始...")
    temp = 39
    wetness: int = 50
    print("测量结束...")

    # 元组-可以包含多个数据，因此可以使用元组让函数一次返回多个值
    # #如果函数返回的类型是元组，小括号可以省略
    return temp, wetness


result = measure()
print(result)

# 如果丽数返回的类型是元组，同时希望单独的处理元组中的元素
# #可以使用多个变量，一次接收酗数的返回结果
gl_temp, gl_wetness = measure()
print(gl_temp)
print(gl_wetness)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注意:使用多个变量接收结果时，变量的个数应该和元组中元素的个数保持一致

练习

交换两个数字

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

使用其他变量

a = 6
b = temp = 100
b = a
a = temp
1
2
3
4

不使用其他变量

a = 6
b = 100
a = a+b
b = a - b
a = a-b
print(a)
print(b)
1
2
3
4
5
6
7

py专有

a = 6
b = 100
a, b = (b, a)
print(a)
print(b)
1
2
3
4
5

3 函数的参数

3.1 不可变和可变的参数

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

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

def demo(num,num_list):
    print("函数内部")
    #赋值语句
    num = 200
    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)

输出：
函数内部
200
[1, 2, 3]
函数代码完成
99
[4, 5, 6]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

如果传递的参数是可变类型，在函数内部，使用方法修改了数据的内容，同样会影响到外部的数据

def mutable(num_list):
    # num_list = [1，2，3]
    num_list.extend([1, 2, 3])
    print(num_list)


gl_list = [6, 7, 8]
mutable(gl_list)
print(gl_list)

输出：
[6, 7, 8, 1, 2, 3]
[6, 7, 8, 1, 2, 3]
1
2
3
4
5
6
7
8
9
10
11
12
13

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

def demo(num, num_list):
    print("函数内部代码")
    # num = num + numnum +=num
    # num_list.extend(num_list)由于是调用方法,所以不会修改变量的引用#函数执行结束后,外部数据同样会发生变化
    num_list += num_list
    print(num)
    print(num_list)
    print("函数代码完成")


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

输出：
函数内部代码
9
[1, 2, 3, 1, 2, 3]
函数代码完成
9
[1, 2, 3, 1, 2, 3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.2 缺省参数

• 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数
• 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值
• 函数的缺省参数，将常见的值设置为参数的缺省值,从而简化函数的调用

指定函数的缺省参数

• 在参数后使用赋值语句，可以指定参数的缺省值

def print_info(name, gender=True):
    gender_text = "男生"
    if not gender:
        gender_text = "女生"
    print("%s是%s" % (name, gender_text))


print_info("ss")
print_info("sss", False)

输出：
ss是男生
sss是女生
1
2
3
4
5
6
7
8
9
10
11
12
13

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

缺省参数的注意事项

1. 缺省参数的定义位置

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

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

• 在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系!

3.3 多值参数

定义支持多值参数的函数

• 有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用**多值参数
• python中有两种多值参数:
  • 参数名前增加一个*可以接收元组
  • 参数名前增加两个*可以接收字典
• 一般在给多值参数命名时,习惯使用以下两个名字
  • args——存放元组参数，前面有一个
  • kwargs——存放字典**参数,前面有两个*
• args 是arguments的缩写，有变量的含义
• kw是keyword的缩写，kwargs可以记忆键值对参数

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


demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)

输出：
1
(2, 3, 4, 5)
{'name': '小明', 'age': 18, 'gender': True}

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

练习——计算任意多个数字的和
需求

1. 定义一个函数sum_numbers ，可以接收的任意多个整数
2. 功能要求:将传递的所有数字累加并且返回累加结果

def sum_numbers(*args):
    total = 0
    for i in args:
        total += i

    return total


i = sum_numbers(1, 2, 3, 4, 5)
print(i)

1
2
3
4
5
6
7
8
9
10
11

元组和字典的拆包

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

4 函数的递归

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

4.1 递归函数的特点

特点

• 一个函数内部调用自己
  • 函数内部可以调用其他函数，当然在函数内部也可以调用自己

代码特点

1. 函数内部的代码是相同的，只是针对参数不同，处理的结果不同
2. 当参数满足一个条件时，函数不再执行
   • 这个非常重要，通常被称为递归的出口，否则会出现死循环!

4.2 练习

计算数字累加
需求

1. 定义一个函数sum_numbers
2. 能够接收一个num的整数参数
3. 计算1+2 + …num 的结果

gto = 0


def sum_numbers(num):
    global gto
    gto += num
    if num == 0:
        return gto

    sum_numbers(num - 1)


sum_numbers(int(input("input")))
print(gto)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

def sum_numbers(num):
    if num == 1:
        return 1
    # 假设sum_numbers能够完成num -1的累加
    temp = sum_numbers(num - 1)
    # 函数内部的核心算法就是两个数字的相加
    return num + temp


print(sum_numbers(int(input("input"))))
1
2
3
4
5
6
7
8
9
10

5 eval函数

• eval()函数十分强大——将字符串当成有效的表达式来求值并返回计算结果

计算器

需求

1. 提示用户输入一个加减乘除混合运算
2. 返回计算结果

input_str = input("请输入一个算术题:")
print(eval(input_str))
1
2

不要滥用eval

在开发时千万不要使用 eval()直接转换 input 的结果

__import___( 'os ' ).system( 'ls ')
1

• 等价代码

import os
os.system("终端命令")
1
2

• 执行成功，返回0
• 执行失败，返回错误信息