了解函数
函数
在计算机中称之为函数，在现实生活中称之为功能。函数是能够实现特定功能的计算机代码，它是一种特定的代码组结构。
作用
提高代码的重复利用率，避免重复开发相同代码
提高程序的开发效率
便于程序维护
定义函数规则
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
函数名和变量的命名规则基本一致
函数只会在调用的时候执行。不调用，不执行。
函数结构
1
2
3
4
5
6
7
8
| # 函数结构
"""
def 函数名(参数列表):
函数体
"""
# 执行调用函数
# 函数名()
|
函数语法
基本格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| # 基本结构
"""
def 函数名():
代码块
"""
def func():
print("new function")
# 调用函数
func()
# 输出结果
# new function
|
带有参数格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| # 带有参数的函数
"""
def 函数名(参数1, 参数2......):
代码块
"""
def eat(food):
print("I like eat:", food)
# 调用函数
eat("apple")
"""
food为形参, 定义函数时, 括号内的参数为形参
apple为实参, 调用函数时, 括号内d的参数为实参
实参将值传递给形参的本质过程，本质上就是简单的变量赋值。
"""
# 输出结果
# I like eat: apple
|
带有默认值参数格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| # 带有默认参数的函数
"""
def 函数名(参数1=值1, 参数2=值2......):
代码块
"""
def eat(food="apple"):
print("I like eat:", food)
# 调用函数
# 如果没有传入实参, 将会使用默认值
eat()
# 输出结果
# I like eat: apple
# 调用时传入的实参会覆盖默认值
eat("banana")
# 输出结果
# I like eat: banana
# 执行
|
使用关键字参数格式
防止参数按照位置传递出现的错误
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
| # 带有关键字参数的函数
"""
def 函数名(形参1=实参1, 形参2=实参3......):
代码块
"""
def eat(address="home", food="apple"):
print("I eat", food, "at", address)
# 使用默认参数 调用函数
eat()
# 输出结果
# I eat apple at home
# 不指定关键字参数 调用函数
eat("banana", "home")
# 输出结果
# 参数较多时赋值顺序颠倒，将会影响程序执行结果
# I eat home at banana
# 指定关键字 调用函数
eat(food="banana", address="home")
# 输出结果
# 关键字参数就是为了解决以上问题
# I eat banana at home
|
收集(不定长)参数
收集参数可以收集的参数不受数量限制
1）非关键字收集参数
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
| # 非关键字收集参数
# 在形参前添加一个*即可
# 收集的实参会组成一个元组
# 接受没有任何形参接受的非关键字实参
# 可以和普通的形参共存
"""
def 函数名(*参数名):
代码块
"""
# food是参数名, 可以是任何变量名
def eat(*food):
# 收集的实参会组成一个元组
print("I like eat:", food)
# 使用*会将参数"解包"(以后会讲到)
print("I like eat:", *food)
# 调用函数
eat("apple", "banana")
# 输出结果
# I like eat: ('apple', 'banana')
# I like eat: apple banana
|
2) 关键字收集参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| # 关键字收集参数
# 在形参前添加两个*
# 收集的实参会组成一个字典，形参名作为键，值作为值
# 仅接收没有任何形参接收的关键字参数
# 可以和普通的形参共存
"""
def 函数名(**参数名):
代码块
"""
# food是参数名, 可以是任何变量名
def eat(**food):
# 收集的实参会组成一个字典
print("I like eat:", food)
# 调用函数
eat(a="apple", b="banana")
# 输出结果
# I like eat: {'a': 'apple', 'b': 'banana'}
|
注意
多种参数混合使用时, 顺序应当如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| """
def 函数名(参数, *非关键字收集参数, 关键字参数, **关键字收集参数):
代码块
"""
def eat(food, *other_food, address="home", **other_field):
print("food===>", food)
print("other_food===>", other_food)
print("address===>", address)
print("other_field===>", other_field)
eat("apple", "banana", address="school", many=5)
# 输出结果
# food===> apple
# other_food===> ('banana',)
# address===> school
# other_field===> {'many': 5}
|
函数返回值
格式
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
| # return
"""
def 函数名():
代码块
return 结果
"""
def add(a, b):
return a+b
result = add(1, 2)
print(result)
# 输出结果
# 3
# 多个返回值(返回值为元组)
def add(a, b):
return a, b, a+b
result = add(1, 2)
print(result)
# 输出结果
# (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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
注意
没有返回值
其实所有的代码都有返回值, 只是没有指定返回值时, 返回结果为None
1.具有return语句的函数，我们称之为具有返回值的函数
2.return可以为当前函数执行完毕的函数返回一个结果，这个返回值可以用变量接收
3.return执行之后，函数将会终止，所以return之后的语句是不会被执行的
4.一个函数可以使用多个return语句，但是只有一个会被执行，一般都是放入分支结构中
5.一个函数如果需要返回多个数据，使用复合数据类型(list,tuple,set,dict)来操作即可
「 在看的，麻烦点一下再走~ 」
|
