上述代码的图例解释如图3-1所示。
可变数据类型列表的引用代码如下：
def 函数名():
代码
代码如下：
# 定义一个函数，能够完成打印信息的功能
def printInfo():
print('------------------------------------')
print(' 人生苦短，我用Python' )
print('------------------------------------')
printInfo()
------------------------------------
人生苦短，我用Python
------------------------------------
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它。调用函数很简单，通过“函数名()”即可完成调用。
先思考一个问题：现在需要定义一个函数，这个函数能够完成2个数的乘法运算，并且把结果打印出来，以下的代码可以实现吗？这样设计有什么缺陷吗？代码如下：
def mul2():
a = 7
b = 9
c = a*b
print (c)
以上代码可以完成两个数值的相乘，但只适用于特定的两个数值。如果要使该函数更通用，即能计算任意两个数的乘积，在定义函数的时候可以让函数接收要处理的数据，就解决了这个问题，这就是函数的参数。 定义带有参数的函数代码如下：
def mul2(a, b):
c = a*b
print (c)
调用上面函数的方法是调用函数名字，并且在括号里输入函数要处理的具体数据“(参数)”，代码如下：
def mul2(a, b):
c = a*b
print (c)
mul2(8,9) #调用带有参数的函数时，需要在小括号中传递数据
72
另外，关于函数参数，有两个具体的概念“形参”和“实参”：
（1）定义时，小括号中的参数，用来接收参数用的，称为 “形参”。
（2）调用时，小括号中的参数，用来传递给函数用的，称为 “实参”。
其中，形参可以分别是缺省参数，不定长参数； 实参可以分为位置参数和关键字参数。
函数调用时，按形参的位置，从左往右，一一匹配传递参数。位置参数必须一一对应，缺一不可，代码如下：
def mul2(a, b):
c = a*b
print (c)
mul2(7.,9) #7，9这两个实参的传递方法是位置参数
63.0
函数调用时，通过“形参=值”方式为函数形参传值，不用按照位置为函数形参传值，这种方式叫关键字参数，代码如下：
def mul2(a, b):
c = a*b
print (c)
mul2(9, b=7) #7，9这两个实参的传递方法是关键字参数，传入顺序可与形参定义顺序不同
63
注意：
（1）关键字参数必须在位置参数的右边，且对同一个形参不能重复传值。
（2）如果位置参数和关键字参数同时混合使用，那么顺序上必须先传位置参数，再传关键字参数。
形参设定默认值，称为缺省参数，也叫默认参数，代码如下：
def mul2(a, b=1):
c = a*b
print (c)
mul2(7)
mul2(7,9) #b为缺省参数，此时，调用函数时传入新的b，所以在函数计算时b等于9
7 63
注意：
（1）调用函数时，如果没有传入默认参数对应的实参，则使用默认值。
（2）默认参数必须在普通参数的后边。
元组型不定长参数：形参变量名前面加上一个“*”，这个参数则为元组型不定长参数。元组型可变形参必须在形参列表的最后边，代码如下：
#第1章/hanshu.py
# *args 不定长参数，可以接收0~多个实参
# 把实参的1,2,3, 包装成元组(1, 2, 3)再传递, 等价于args = (1, 2, 3)
def func(*args):
# 函数内部使用，无需加*
print(args, type(args))
# 函数调用
func(1, 2, 3, 4)
(1, 2, 3, 4) <class 'tuple'>
字典型不定长参数：定义参数时需要在形参名前添加“**”，则为字典型不定长参数。字典型可变形参必须在形参列表的最后边，代码如下：
#第1章/hanshu.py
# 把实参包装成 {'city': 'sz', 'age': 18}给kwargs传递
# kwargs = {'city': 'sz', 'age': 18}
def func(name, **kwargs):
# 同时存在形参name, name不会被包装到字典中
print(name)
print(kwargs) # 函数内部使用，无需加*
# 实参的写法： 变量=数据，变量=数据
func(name='mike', city='sz', age=18)
mike
{'city': 'sz', 'age': 18}
函数参数的关键要点总结：
（1）缺省参数需要在非缺省参数之后。
（2）关键字参数需要在位置参数之后。
（3）所有传递的关键字参数必须有对应参数，并且顺序不重要。
（4）参数只能赋值一次。
（5）缺省参数通常是可选的，可以不传递值。
返回值，就是程序中函数完成一件事情后，最后给调用者的结果。想要在函数中把结果返回给调用者，需要在函数中使用return关键字，代码如下：
def add2num(a, b):
return a+b
注意，当一个函数返回了一个数据，如果想要用这个数据，那么就需要保存。 保存函数的返回值实例代码如下：
#第1章/hanshu.py
#定义函数
def add2num(a, b):
return a+b
#调用函数，顺便保存函数的返回值
result = add2num(72,17)
#因为result已经保存了add2num的返回值，所以在接下来的场景中，就可以使用了
print (result) #结果等于89
89
在Python中，在关键字return后面将多个返回值用逗号隔开即可以返回多个值。
在Python中，值是靠引用来传递的。可以用id()来判断两个变量是否为同一个值的引用。可以将id值理解为变量在计算机中的内存地址标示，代码如下：
#第1章/hanshu.py
a=1
b=a
print(id(a))
print(id(b))
a=2
print(id(a))
print(id(b))
1657366446320 1657366446320 1657366446352 1657366446320
上述代码的图例解释如图3-1所示。
可变数据类型列表的引用代码如下：
#第1章/hanshu.py
a=[1,2]
b=a
print(id(a))
print(id(b))
a.append(3)
print(a)
print(id(a))
print(id(b))
1657473933696 1657473933696 [1, 2, 3] 1657473933696 1657473933696
上述代码的图例解释如图3-2所示。
因此，数据类型可变还是不可变的本质是：在改变数据具体的值时，其内存的地址索引是否改变；改变的话当前数据为不可变数据类型，不变的话则为可变数据类型。
Python中函数参数是引用传递（注意不是值传递）。因此，可变类型与不可变类型的变量分别作为函数参数时，产生的影响是不同的。具体来说，对于不可变类型，因变量不能修改，所以函数中的运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量，代码如下：
#第1章/hanshu.py
a = (1,2,3)
def add(arr):
arr += arr
add(a)
print(a)
(1, 2, 3)
此代码将输出 [1,2,3,1,2,3]，而不是 [1,2,3]。
当传递一个列表（或其他可变对象）给函数时，实际上是传递了这个对象的引用。因此，函数内部对该对象的任何更改将影响函数外部的该对象。
在 add 函数内部，使用了“+=”运算符，这是一个就地修改的运算符。这意味着它会修改原始列表，而不是创建一个新的列表。因此，当执行arr += arr时，实际上是将arr列表的内容添加到自身，所以结果是 [1,2,3,1,2,3]。