【python】函数调用
函数
方法：
def func_name(param1, param2){
# 执行语句...
return val
}
# 调用函数
func_name(param1 = p1, param2 = p2)
func_name(param2 = p2, param1 = p1)参数：
| 参数 | 描述 |
|---|---|
| def | 定义函数所使用的关键字，所有的函数前面都必须使用该关键字。 |
| func_name | 函数的名称。 |
| param1 | 函数的形参1。 |
| param2 | 函数的形参2，函数可以有任意多个形参。 |
| return | 后面接函数的返回值，函数的返回值只能有一个，可以是任意的数据类型。 |
1.例如
#def sub(a, b):
# return a - b
def sub(a: int, b: int): #实参:四餐类型
return a - b
ret = sub(a = 1024, b = 512)
print("sub =", ret)
ret = sub(b = 512, a = 1024)
print("sub =", ret)
值传递与引用传递
在python中， 根据函数的参数 的数据类型不同，可以将函数参数的传递方式分为按值传递和引用传递。如果实参的类型为不可变类型，比如 字符串、数字 和 元组 等，那么参数的传递方式就是按值传递，如果实参的类型为可变类型，比如列表 和 字典 等，那么参数的传递方式就是按引用传递。
| 数据类型 | 传递方式 |
|---|---|
| 字符串 | 值传递 |
| 数字 | 值传递 |
| 元组 | 值传递 |
| 列表 | 引用传递 |
| 字典 | 引用传递 |
函数注解
语法：
def func(param1:param1 note, param2:param2 note=default val)->return val note:
pass参数：
| 参数 | 描述 |
|---|---|
| param1 | 形参1。 |
| param1 note | 形参1 的注解。 |
| param2 | 形参2。 |
| param2 note | 形参2 的注解。 |
| default val | 形参2的默认值。 |
| val note | 返回值的注解。 |
说明
我们定义了一个带函数注解的函数 func，该函数接受两个参数，第一个参数为 param1，第二个参数为 param2，返回一个返回值。
其中 param1 note 是对参数 param1 的说明信息，param2 note 是对参数 param2 的说明信息，default val 是参数 param2 的默认值。
return val note 是对该函数返回的值的说明信息。
获取函数注解信息详解
print(func_name.__annotations__)参数
| 参数 | 描述 |
|---|---|
| func_name | 需要获取注解信息的函数。 |
我们使用 func_name.__annotations__ 语句可以获取函数名为 func_name 的注解信息。
def my_sum(num1:'开始的数', num2:'结束的数'=100)->'开始数到结束数所有数的和':
res = 0
for i in range(num1, num2+1):
res = res + i
return res
sum_res = my_sum(1, 50)
print("sum_res =", sum_res)
sum_res = my_sum(1)
print("sum_res =", sum_res)
print(my_sum.__annotations__)输出：
sum_res = 1275
sum_res = 5050
{'num1': '开始的数', 'num2': '结束的数', 'return': '开始数到结束数所有数的和'}
局部函数
在大多数编程语言中，函数 的定义一般只能在 全局作用域，即定义的函数都是全局函数，而在 Python 中，函数不仅可以定义在全局作用域，还可以在函数内部定义函数。在函数内部定义的函数，被称为局部函数，局部函数对外部是隐藏的，局部函数只能包含该函数的函数体内调用。
1. 例子：
def print_info():
def print_start():
print("====Start======")
def print_end():
print("====End======")
print_start()
print("Site:HaiCoder, Module:Python")
print_end()
# 在函数内部定义并调用函数
print_info()输出：
====Start======
Site:HaiCoder, Module:Python
====End======
2. 例子：
def num_handle(t, num1, num2):
def add(num1, num2):
return num1 + num2
def sub(num1, num2):
return num1 - num2
def mul(num1, num2):
return num1 * num2
if t == "add":
return add(num1, num2)
if t == "sub":
return sub(num1, num2)
if t == "mul":
return mul(num1, num2)
# 在函数内部定义并调用函数
add_result = num_handle("add", 10, 20)
print("add_result =", add_result)
sub_result = num_handle("sub", 10, 20)
print("sub_result =", sub_result)
mul_result = num_handle("mul", 10, 20)
print("mul_result =", mul_result)输出：
add_result = 30
sub_result = -10
mul_result = 200
def func(d):
d.a = 2
d.b = 3
class test:
def __init__(self, a, b):
self.a = a
self.b = b
def funcb():
d = test(1, 2) # 1
func(d) # 2
print(d.a)
print(d.b)
funcb()
class test01(object):
def __init__(self, a):
self.a = a
class test02(object):
def __init__(self, b):
self.b = b
class test03(object):
def __init__(self, test01, test02):
self.test01 = test01
self.test02 = test02
def update(self):
self.test01.a = 3
self.test02.b = 5
def func():
test1 = test01(1)
test2 = test02(2)
test3 = test03(test1, test2)
test3.update()
print(test1.a)
print("==")
print(test2.b)
print("==")
print(test3.test01.a)
print("==")
print(test3.test02.b)
func()
