1、函数的声明和调用

函数的声明
函数的调用

（1）、函数的声明

函数声明的一般形式：

def <函数名> (参数列表):
    <函数语句>
    return <返回值>     #不写返回值则默认返回None

函数声明示例：

def calcSum(a, b):
    return a + b

（2）、函数的调用

直接使用函数名(参数)的形式调用，若无参数则之间函数名+括号

函数的调用示例：

# 计算两个数的和
def calcSum(a, b):
    return a + b

def mPrint():
    print('This is my Print Function!')

m = calcSum(10, 20) # 调用calcSum() 函数
print(m)
mPrint()            # 调用mPrint()函数

运行结果：
30
This is my Print Function!

2、函数的参数

函数的默认值参数
函数的参数传递（位置传递和关键字传递）
可变数量参数传递
拆解序列的函数调用
函数调用时参数的传递方法

（1）、默认值参数

含有默认值参数的函数形式如下：

def <函数名>(参数=默认值):
    <语句>

声明时必须先声明无默认值参数，再声明含默认值参数

默认值参数函数示例：

def clacFunction(a, b, c=10):
    return a + b * c

print(clacFunction(1, 2, 5))
print(clacFunction(1, 2))

运行结果：
11
21

（2）、函数的参数传递

位置传递
关键字传递

位置传递：参数按照声明的先后位置传递给函数；

关键字传递: 按照关键字将参数传递给函数；

调用函数提供参数时，按顺序传递参数要位于关键字参数之前，并且不能有重复的情况，负责报错；

def function(hi='Hi', lan='python', sy='!'):
    print(hi, lan, sy)

function('Hello', 'Python')
#function('HHi', lan='C++', '!!!')   #函数报错，第三个参数传递给lan有重复
function('HHi', lan='C++', sy='!!!')

运行结果：
Hello Python !
HHi C++ !!!

（3）、可变参数传递

在定义函数时，如果参数名前面加上一个星号“*”，则表示该参数就是可变参数；在调用时，如果依次顺序将所有的其他变量都赋值后，剩下的参数会收集在一个元组中，元组的名称就是前面带星号的参数名。

可变参数传递示例：

def function(*tup):
    for i in tup:
        print(i, end=' ')

function(10, 20, 5, 3, 'Hello', 'Douzhq')

运行结果：
10 20 5 3 Hello Douzhq

带*号的参数应放在最后，如果带星号的参数放在最前面的时候，仍可正常工作，但调用后面的参数必须以关键字参数的方式提供，否则因其后的位置无法获得值而发生错误

可变参数和其他参数示例：

def function(*tup, num1, num2):
    for i in tup:
        print(i, end=' ')
    return num1 * num2

#function(10, 20, 5, 3, 'Hello', 'Douzhq', 10, 20) #运行出错，num1和num2未传值
function(10, 20, 5, 3, 'Hello', 'Douzhq', num1 = 10, num2 = 20)

运行结果：
10 20 5 3 Hello Douzhq

还可以用字典的方式传递参数，参数前加两个星（**）表示以字典的形式收集参数

字典传递示例：

def function(b='a', **dct):
    print(dct)
    print(b)

function(10, a='b', c='d')

运行结果：
{‘a’: ‘b’, ‘c’: ‘d’}
10

（4）、拆解序列的函数调用

拆解元组：提供位置参数（*）

拆解字典：提供位置参数（**）

拆解序列函数的示例：

def function(a, b):
    return a+b

print(function(*(10, 20)))
print(function(**{'a': 10, 'b': 20}))

运行结果：
30
30

（5）、函数调用时参数的传递方法

函数调用时，若提供的参数是不可变的参数，那么在函数内部对其修改时，函数外部其值不改变；若提供可变参数，则在函数内部对其改变时，函数外部其值也会发生变化。

函数修改可变参数示例：

def function(f):
    f.append(10)

lst = [12, 22, 32]
print('调用前：', lst)
function(lst)
print('调用后：', lst)

运行结果：
调用前： [12, 22, 32]
调用后： [12, 22, 32, 10]

函数的默认值的内存是固定的，在函数第一次调用时分配

Python函数的陷阱示例：

def function(lst = []):
    lst.append(10)
    print(lst)

function()
function()
function([1, 2, 3, 4])
function()
function()

因为默认参数是可变参数，所以每调用一次默认参数，就会对其修改一次
运行结果：
[10]
[10, 10]
[1, 2, 3, 4, 10]
[10, 10, 10]
[10, 10, 10, 10]

6、Python中的函数（一）