函数的作用
- 可以将具有重复功能的代码封装成函数
- 简化代码量，方便调用
- 函数就是一段具有独立功能的代码块
- 更高效的实现代码重用
函数的使用步骤
- 先定义，再使用
- 不同的需求，参数可有可无
- 函数名满足标识符命名规则
定义函数
def 函数名(参数):
代码1
代码2
……
调用函数
函数名(参数)
# 定义函数
def showMessage():
print('-' * 30)
print('show message'.center(30))
print('-' * 30)
# 调用函数
print('调用函数展示信息')
showMessage()
输出结果
调用函数展示信息
------------------------------
show message
------------------------------
函数的注意事项
- 函数需要先定义再调用
- 函数内部的代码，只有调用才会执行
- 当调用函数的时候，解释器会到定义函数的地方去执行下方缩进的代码，当这些代码执行完，回到调用函数的地方，继续向下执行
函数的参数
- 让函数变得更加灵活
- 参数由实参传递到形参
- 实参的参数应该和形参一一对应
函数的返回值
- 返回给用户一个结果
- 返回的结果在函数调用的地方，可以使用变量接收
- return 后面的代码不会被执行
函数的说明文档
- 快速提示函数的作用
help(函数名) # 查看函数的说明文档
定义函数的说明文档
def 函数名(参数)：
"""说明文档的位置"""
代码
……
# 定义带参数的函数
def sum(num1, num2):
"""求和函数"""
return num1 + num2
# 查看函数的说明文档
help(sum)
输出结果
Help on function sum in module __main__:
sum(num1, num2)
求和函数
def 函数名(参数)：
"""
:param 参数1: 参数1的说明
:param 参数2: 参数2的说明
……
:return:返回值的说明
"""
代码
……
# 定义带参数的函数
def sum(num1, num2):
"""
求和函数
:param num1:参数1
:param num2: 参数2
:return: 返回连个数的和
"""
return num1 + num2
# 查看函数的说明文档
help(sum)
输出结果
sum(num1, num2)
求和函数
:param num1:参数1
:param num2: 参数2
:return: 返回连个数的和
函数的嵌套
- 一个函数里面又调用了另外一个函数
# 嵌套函数
# 定义函数testB
def testB():
print('-' * 30)
# 定义函数testA
def testA():
testB() # 调用函数testB
print('testA'.center(30))
testB()
# 调用函数
testA()
输出结果
------------------------------
testA
------------------------------
局部变量
- 定义在函数体内部，即只在函数体内部生效
- 临时保存数据，即当函数调用完成后，销毁局部变量
全局变量
- 所谓全局变量，指的是在函数体内、外都能生效的变量
- 定义在函数外的变量
- 在函数体内部不能直接修改全局变量
如果直接给全局变量赋新值 a = 200，这相当于定义了一个局部变量
如果使用赋值运算符给全局变量赋值 a += 200，则会报错 - 要想在函数内部修改全局变量，需要使用 global 声明变量
# 全局变量
a = 100
def testA():
print(f'testA中打印：{a}')
def testB():
global a # 声明 a 为全局变量
a += 200
print(f'testB中打印：{a}')
testA()
testB()
print(f'函数外部打印：{a}')
输出结果
testA中打印：100
testB中打印：300
函数外部打印：300
函数的返回值
-
return a, b写法，返回多个数据的时候，默认的数元组类型 - return 后面可以连接列表、元组或字典以返回多个值
return返回元组
# 返回元组
def return_num():
return 1, 2
result = return_num()
print(result)
输出结果
(1, 2)
函数的参数
位置参数
- 调用函数时根据函数定义的参数位置来传递参数
- 传递和定义参数的顺序及个数必须一致
# 位置参数
def user_info(name, age, gender):
print(f'您的名字是：{name}，年龄是：{age}，性别是：{gender}')
user_info('Tom', 20, '男')
输出结果
您的名字是：Tom，年龄是：20，性别是：男
关键字参数
- 函数调用，通过‘键 = 值‘形式加以指定
- 可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求
- 函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字之间不存在先后顺序
# 关键字参数
def user_info(name, age, gender):
print(f'您的名字是：{name}，年龄是：{age}，性别是：{gender}')
user_info(name='Tom', age=20, gender='男')
user_info(age=20, name='Rose', gender='女')
user_info('Tom', age=20, gender= '男') # 位置参数需要在关键字参数前面
输出结果
您的名字是：Tom，年龄是：20，性别是：男
您的名字是：Rose，年龄是：20，性别是：女
您的名字是：Tom，年龄是：20，性别是：男
缺省参数
- 缺省参数也叫默认参数，用于定义函数，为参数提供默认值
- 调用函数时可不传入该默认参数的值
- 所有位置参数必须出现在默认参数前，包括函数定义和调用
- 函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值
# 缺省参数
def user_info(name, age, gender='男'):
print(f'您的名字是：{name}，年龄是：{age}，性别是：{gender}')
user_info('Tom', 20, '男')
user_info('Jack', 18) # 缺省参数可以不传，则使用默认值
输出结果
您的名字是：Tom，年龄是：20，性别是：男
您的名字是：Jack，年龄是：18，性别是：男
不定长参数
- 不定长参数也叫可变参数。
- 用于不确定调用的时候会传递多少个参数（不传参数也可）的场景
- 此时，用于包裹位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便
包裹位置传递
# 包裹位置传递
def user_info(*args):
print(args)
user_info('Tom')
user_info('Tom', 20)
输出结果
('Tom',)
('Tom', 20)
- 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组
- args是元组类型，这就是包裹位置传递
包裹关键字传递
# 包裹关键字传递
def user_info(**kwargs):
print(kwargs)
user_info(name='Tom',age=20)
输出结果
{'name': 'Tom', 'age': 20}
- 传进的所有参数被kwargs收藏，合并为一个字典
- kwargs是字典类型
拆包
元组拆包
# 元组
def return_num():
return 100, 200
num1, num2 = return_num()
print(num1)
print(num2)
输出结果
100
200
字典拆包
# 字典
dict1 = {'name': 'Tom', 'age': 20}
a, b = dict1
print(a)
print(b)
print(dict1[a])
print(dict1[b])
输出结果
name
age
Tom
20
- 字典拆包，拆出来的是对应的key，可以根据 key 获取对应的value
交换变量的值
借助第三方变量
# 交换变量的值
a = 10
b = 20
c = a
a = b
b = c
print(a)
print(b)
输出结果
20
10
使用直接赋值的方式交换两个变量的值
a = 1
b = 2
a, b = b, a
print(a)
print(b)
输出结果
2
1
引用
- 在Python中，值是靠引用来传递的
- 我们可以用 id(数据) 来判断两个变量是否为同一个值的引用，id为内存地址标识符
int类型
# int类型
a = 1
b = a
print(id(a))
print(id(b))
a = 2
print(b)
print(id(a))
print(id(b))
输出结果
4335897776
4335897776
1
4335897808
4335897776
- int 类型为不可变类型
list类型
# list类型
list1 = [10, 20]
list2 = list1
print(id(list1))
print(id(list2))
list1.append(30)
print(list2)
print(id(list1))
print(id(list2))
输出结果
140238548220296
140238548220296
[10, 20, 30]
140238548220296
140238548220296
引用当做实参传递
不可变参数
# 不可变参数
def test1(a):
print(a)
print(id(a))
a += a
print(a)
print(id(a))
b = 100
test1(b)
输出结果
100
4434209040
200
4434212240
可变参数类型
# 可变参数
def test1(list1):
print(list1)
print(id(list1))
list1.append(30)
print(id(list1))
list1 = [10 , 20]
print(id(list1))
test1(list1)
print(list1)
输出结果
140644895160968
[10, 20]
140644895160968
140644895160968
[10, 20, 30]
140644895160968
- 可变类型，改变后元数据也跟着改变
网友评论