python-(5-1)函数的形参、实参、返回值

1 函数

1-1 定义

对某一个特定的功能或者代码块进行封装，在需要使用该功能的时候直接调用即可
让程序更加简洁，代码更加合理

def 函数名(): # 定义函数
    函数体  # 被封装的功能或代码块
函数名() # 调用函数执行
1
2
3

1-2 内置函数

就是直接能拿来用的函数。（本文该内容仅作简单了解）

数据类型转换

s = "123"
i = int(s)    # 字符串变整数
b = bool(s)   # 字符串变成布尔类型
f = float(s)  # 字符串变成浮点数
print(i,b,f)
1
2
3
4
5

将十进制数和二进制相互转化

a = 100
print(bin(a))  # 十进制变成二进制

b = 0b10010101
print(int(b))  # 二进制变成十进制
1
2
3
4
5

打印数字运算和比较的结果

# 表示10的三次方，也可以写作print(a ** b)
a = 10
b = 3
print(pow(a, b))

list = [192, 21, 38, 102, 300, 9]
print(sum(list))  # 表示列表内的元素之和
print(max(list))  # 表示列表内最大的元素
print(min(list))  # 表示列表内最小的元素
1
2
3
4
5
6
7
8
9

将集合元素转换成列表形式。在使用list()的过程中，其内部一定有一个循环，遍历集合的所有元素，再将其放入空列表中，得到最终结果。

s = {1, 2, 3}
lst = list(s)
print(lst)
1
2
3

直接拿到列表的索引和元素

lst = ["pld", "mk", "bm", "小y", "kog", "dk"]
for name in enumerate(lst):
    print(name)
1
2
3

打印当前数据能执行哪些操作

s = []
print(dir(s))
1
2

2 形参

函数定义时，需要准备接收信息的变量

形参的传参方式有三种。

# 位置传参
def name1(name, age, gender):
    print(name, age, gender)

name1("周星驰", 40, "m")
name1("刘德华", 45, "m")
name1("成龙", 43, "m")
name1("韩红", 39, "f")

# 默认值传参，在函数声明时给变量一个默认值，如果实参不传递信息，默认值生效，否则不生效
# 和位置参数在一起，它必须放在后面
def name2(name, age, gender="m"):
    print(name, age, gender)

name2("周星驰", 40,)
name2("刘德华", 45)
name2("成龙", 43)
name2("韩红", 39, "f")

# *表示位置参数的动态传参，*接收到的值会统一放在一个元组里
def eat(*food):
    print(food)

eat("米饭", "麻婆豆腐", "西湖牛肉羹", "冰淇淋")
eat("麻婆豆腐", "西湖牛肉羹")

# **表示关键字参数的动态传参，**接收到的值会被处理成字典
def eat(**food):
    print(food)

eat(add="麻婆豆腐", drink="西湖牛肉羹")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

上述形参可以随意搭配使用。
当同时出现位置传参、默认值传参、位置参数的动态传参（*args)、关键字参数的动态传参（***kwargs)
从前往后的顺序依次是：位置 > *args > 默认值 > **kwargs

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

func()                         # () {}
func(1)                        # (1,) {}
func(1,2,3,4,5, x=3)           # (1, 2, 3, 4, 5) {'x': 3}
func(1,2,3,4,5, s=21, m="ks")  # (1, 2, 3, 4, 5) {'s': 21, 'm': 'ks'}
1
2
3
4
5
6
7
8

3 实参

调用函数时，传递的信息。在执行时，必须保证形参有数据。

实参的传参方式有3种。

def dinner(main, adding, drink, cake):
    print(main, adding, drink, cake)

# 位置传参
dinner("米饭", "麻婆豆腐", "西湖牛肉羹", "冰淇淋")

# 关键字传参
dinner(main="米饭", adding="麻婆豆腐", drink="西湖牛肉羹", cake="冰淇淋")

# 混合传参，位置参数只能在关键词参数的前面
dinner("米饭", "麻婆豆腐", drink="西湖牛肉羹", cake="冰淇淋")
1
2
3
4
5
6
7
8
9
10
11

3-2 案例练习–买菜

def buy_veg(veg1, veg2, bug):    # 形参
    if bug > 10:                 # 如果预算超过10元
        print("我要买：", veg1)   # 就买veg1
    else:
        print("只能买：", veg2)   # 否则只能买veg2

buy_veg("西红柿", "豆腐", 20)     # 实参
buy_veg("西红柿", "豆腐", 5)
1
2
3
4
5
6
7
8

执行代码后的结果如下：

我要买： 西红柿
只能买： 豆腐
1
2

3-3 案例练习–构建计算器，完成四则运算

def cal(num1, num2, opera):  # 定义函数，设置形参
    if opera == "+":
        print(num1+num2)
    elif opera == "-":
        print(num1-num2)
    elif opera == "*":
        print(num1*num2)
    elif opera == "/":
        print(num1/num2)
    else:
        print("请输入正确的计算符号")

cal(1000, 238, "+")  
cal(1000, 238, "-")
cal(1000, 238, "*")
cal(1000, 238, "/")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4 返回值

函数执行后会给调用方的一个结果

4-1 情况一：

如果函数内没有return，此时外界收到的是None

def func():
    pass
ret = func()
print(ret)
1
2
3
4

4-2 情况二：

如果函数内有return，但只写了return，后面不跟数据，则依旧是None

def func():
    print("abc")
    return
    print("edf")
ret = func()
print(ret)
1
2
3
4
5
6

执行代码的结果是：abc None

由此可知，当代码执行到return时，后面的程序不会执行，类似于循环的break

4-3 情况三：

如果函数内有return，也有数据，此时函数会有返回值，外界能够收到一个数据

def func(a,b):
    return a+b
ret = func(10,20)
print(ret)
1
2
3
4

4-4 情况四：

如果函数内有return，后面跟值1 值2 值3 值4...，此时函数有多个返回值
那么外界收到的是元组，并且该元组内存放所有的返回值

def func():
    return 1,2,3,4,5,6
ret = func()
print(ret)
1
2
3
4

最后代码执行结果是：(1, 2, 3, 4, 5, 6)