函数是执行相同操作的语句的集合。不用每次都写相同的流程，通过将其定义为函数，只需调用函数就可以执行固定的流程。函数包括Python中预定义的print函数等内置函数，以及用户自行定义的用户自定义函数。本节介绍如何使用用户定义的函数。
目录
14-1 函数定义和调用函数
14-2 调用函数时使用参数
14-3 关于 Python 参数中的按参考传递和按值传递
14-4 使用 return 语句将函数的返回值返回给调用者
14-5 为参数设置默认值
14-6 使用关键字参数调用函数
14-7 在函数中接受可变数量的参数
14-1 函数定义和调用函数
这一张我们主要讲解如何定义用户自定义函数以及如何调用函数。
定义一个函数
用户自定义函数定义如下：
def 函数名称（argument1，argument2，...）：
函数内执行程序
return 返回值在 def 之后指定函数名称。稍后我们将讨论如何命名函数。
函数名称后的小括号 ( ) 中描述了参数（argument）。可以指定 0 个参数，如果指定多个参数，则用逗号 (,) 分隔。
def 函数名称():
函数内执行程序
return 返回值调用函数时，块内的操作按顺序执行。当执行多个进程时，将它们描述在一个块中。
def 函数名称(引数1, 引数2, ...):
函数中要执行的进程1
函数中要执行的进程2
函数中要执行的进程3
return 返回值※在 Python 中，块是使用缩进定义的。
函数可以使用 return 语句将值返回给函数的调用者。要返回的值写在返回语句之后。没有必要就不用写return语句。如果在没有执行 return 语句的情况下到达功能块的末尾，则 None 不会返回给调用者。
示例代码
请看下面的示例。
def myfunc():
print("Hello")
myfunc()
>> Hello我们定义了一个用户定义函数 myfunc，然后调用了该函数。在函数内部，执行了打印函数并将字符打印到屏幕上。
调用函数
可以调用和使用定义的函数。该函数可以这样调用：
函数名（argument1，argument2，...）在描述要调用的函数的名称之后，描述 小括号（） 之间的参数（称为实际参数）。可以指定 0 个参数，如果指定多个参数，则用逗号 (,) 分隔。以下是 0 个参数。
函数名()调用函数从函数返回一个值。如果要使用返回值，可以将其分配给变量，如下所示。
val = 函数名（argument1，argument2，...）
被调用方可以使用 return 语句向函数的调用者返回任何值，如果没有执行 return 语句，则为 None。函数的调用者可能使用也可能不使用返回值。
函数必须在调用之前定义。例如，如果函数定义如下，然后调用，它工作正常。
def sample():
print("Hello")
sample()
>> Hello反之，如果调用一个没有定义的函数，就会出错。
sample()
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> NameError: name 'sample' is not defined示例代码
请看下面的示例。
def myfunc():
print("Hello")
myfunc()
>> Hello
myfunc()
>> Hello
val = myfunc()
>> Hello
print(val)
>> None定义的函数可以被调用任意次数。这次我调用了定义的函数 3 次。另外，当我第三次调用它时，我将从函数返回的值分配给一个变量并尝试输出该变量的值。
如何命名函数
根据以下规则命名函数。（与变量名相同）。
・可以使用的字符是 a 到 z、A 到 Z、0 到 9、下划线（_）、汉字等。 ・
数字（0 到 9）不能用作第一个字符。
・下划线可以用作第一个字符，但它们有特殊用途。它在很多情况下都会使用，所以通常最好不要使用它。
区分大小写。
・不能使用保留字。我们将一一确认一下。
除了字母数字字符和下划线，Python 3 还可以在函数名中使用汉字（不推荐）。
def 问候():
print("你好")
问候()
>> 你好函数名称中允许使用数字，但将它们用作第一个字符会导致 SyntaxError 错误。
def 7hello():
>> File "≤stdin>", line 1
>> def 7hello():
>> ^
>> SyntaxError: invalid syntax函数名称区分大小写。
def Sample():
print("Hello")
def sample():
print("bye")
Sample()
>> Hello
sample()
>> bye保留字是 Python 语法中使用的字（例如，if 或 and）。保留字列表如下。
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield保留字不能用作函数名。试图将其定义为变量名将导致 SyntaxError 错误。
def from():
>> File "<stdin>", line 1
>> def from():
>> ^
>> SyntaxError: invalid syntax请注意，定义与内置函数同名的用户定义函数将覆盖该函数。例如，尝试使用相同的函数名覆盖返回绝对值的内置函数 abs。
print(abs(-5))
>> 5
def abs(num):
return 0
print(abs(-5))
>> 0第一次调用abs函数时，还是调用了内置函数，所以返回的是绝对值，调用它会返回0。
14-2 调用函数时使用参数
通过在调用函数时指定参数，您可以在函数端使用该值。本节介绍如何在调用函数时指定参数。
调用带参数的函数
调用函数时，可以通过使用参数将数字和字符串等值传递给函数。在被调用函数中，可以将调用方传递过来的值赋值给变量，在函数内部使用。例如，考虑这样一个函数：
def myfunc(str1, num1):
print(str1)
print(num1)函数在函数名称后的小括号（） 中描述其参数。这些被称为形式论证。对于形式参数，描述变量名称以接收从函数调用端传递的值。对于上面的函数，定义了两个参数，分别带有变量 str1 和 num1。
调用函数时，为函数端定义的参数个数指定值。这些被称为实参。在要调用的函数名后写上 ( 和 ) 之间的值。这个函数是用两个参数定义的，所以在调用函数的时候，指定两个值，然后按如下方式调用。
myfunc("Yuhua", 28)当一个函数被调用时，调用方指定的值被赋值给函数方描述为参数的变量。在本例中，调用者指定了两个值，“Yuhua”和 28，因此该函数将“Yuhua分配给变量 str1，将 28 分配给变量 num1。
在函数内，您可以引用和使用分配给参数中描述的变量的值。对于前面的函数，传递给参数的值被输出到屏幕。结果，调用函数时指定的两个值在函数内被打印到屏幕上。
可以传递给函数的值不仅可以是字符串和数字，还可以是列表和元组对象。被调用函数可以使用作为参数传递的列表或元组对象。请注意，数字和字符串是一旦创建就无法更改的不可变对象，其处理方式与可变对象列表略有不同，后者可以在以后更改。
示例代码
请看下面的示例。
def myfunc(str1, num1):
print("Name: " + str1 + ", Old: " + str(num1))
myfunc("Yuhua", 28)
>> Name: Yuhua, Old: 28
myfunc("Jiangming", 32)
>> Name: Jiangming, Old: 32在此示例中，函数被调用两次，并向参数传递不同的值。被调用函数使用传递的值作为参数打印到屏幕上。
看另一个例子。
def myfunc(mylist):
print("Name: " + mylist[0] + ", Old: " + str(mylist[1]))
myfunc(["Yuhua", 28])
>> Name: Yuhua, Old: 28
myfunc(["Jiangming", 34])
>> Name: Jiangming, Old: 34
在此示例中，使用指定为参数的列表对象调用该函数。在函数方面，从使用参数传递的列表对象的元素中获取值并输出到屏幕。
实际和形式参数的数量
调用函数时指定的值个数（实参个数）和被调用函数中定义的参数个数（形参个数）必须相同。如果一个函数被定义为接受，比如说，三个参数，那么要调用这个函数，你必须用三个值来调用它。
如果函数定义为接受3个参数，但调用函数时只指定了2个或4个值，就会出现TypeError错误。
例如，定义一个编写为接收两个参数的函数，如下所示。
def myfunc(num1, num2):
return num1 + num2在调用这个函数的时候，如果你指定了两个值并调用它，它就会被正常调用。
def myfunc(num1, num2):
return num1 + num2
myfunc(10, 20)
>> 30在不指定一个值的情况下调用此函数将导致 TypeError 错误。
def myfunc(num1, num2):
return num1 + num2
myfunc(10)
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> TypeError: myfunc() missing 1 required positional argument: 'num2'同样，用三个值调用这个函数会导致TypeError错误。
def myfunc(num1, num2):
return num1 + num2
myfunc(10, 20, 30)
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> TypeError: myfunc() takes 2 positional arguments but 3 were given请注意，函数端的形参个数和函数调用端的实参个数必须相同。除非你为参数指定默认值或设置可变数量的参数。这些在另一页上解释。
14-3 关于 Python 参数中的按参考传递和按值传递
在调用函数时使用参数将值传递给函数时，Python 使用按引用传递，它传递值存储的位置，而不是按值传递，它复制值。在这里，在简要说明按值传递和按引用传递之间的区别之后，我将说明 Python 实际上是如何使用参数将它们传递给函数的。
什么是值传递和参考传递
在我们了解 Python 如何通过引用传递参数之前，让我们先讨论一下按值传递和按引用传递之间的一般区别。（所使用的编程语言通常决定使用哪种方法）。
按值传递
传值是一种在调用函数时复制形式参数中指定的值并将其传递给实际参数的方法。
存储的是同一个值，但是存储位置是独立的，所以即使在函数内部改变了存储实参的变量的值，调用变量的值也不会受到影响。
通过引用传递
引用传递是一种在调用函数时将形式参数中指定的值的存储位置信息传递给实际参数的方法。
由于函数端变量和调用者变量的引用值存储在同一位置，因此在函数内更改变量的值也会更改调用者变量引用的值。
这样，在函数内更改值时，按值传递和按引用传递的行为不同，因此了解正在使用哪种方法很重要。
在 Python 中如何通过引用传递参数
在 Python 中，当我们在调用函数时指定参数时，会使用引用传递。但是，在 Python 的情况下，如果我们指定一个不能更改的不可变对象（如字符串或数字）作为参数，或者如果我们指定一个在创建后可以更改的可变对象参数（例如列表或字典） ，行为会略有不同。
如果将不可变对象指定为参数
首先，让我们检查一下将数值、字符串或不可变对象指定为参数的情况。即使您指定数字或字符串，使用引用传递也没有区别。
请看下面的示例程序。输出赋值给变量x的对象ID后，调用函数，输出函数中赋值给变量n的对象ID。您可以看到两者都引用同一个对象。
def myfunc(n):
print(id(n))
x = 10
print(id(x))
>> 140706808076224
myfunc(x)
>> 140706808076224但是，字符串和数字等不可变对象在创建后无法更改。因此，当一个被赋予实参的变量在函数中被改变并赋予一个新值时，新值被保存在另一个存储位置，然后被引用。
请看下面的示例程序。您在函数内更改变量 n 的值，但调用者中变量 x 引用的值保持不变。
def myfunc(n):
print(n)
n += 3
print(n)
x = 10
print(x)
>> 10
myfunc(x)
>> 10
>> 13
print(x)
>> 10即使参数以这种方式通过引用传递，如果为参数指定了不可变值，它的行为就像按值传递一样。
当可变对象被指定为参数时
接下来，让我们检查何时将可变对象（例如列表或字典）指定为参数。在指定列表或字典时也使用按引用传递。
请看下面的示例程序。输出赋值给变量x的对象ID后，调用函数，输出函数中赋值给变量n的对象ID。您可以看到两者都引用同一个对象。
def myfunc(n):
print(id(n))
x = [10, 20]
print(id(x))
>> 1514213397120
myfunc(x)
>> 1514213397120诸如列表之类的可变对象以后可以更改其元素的值。在函数中对实际参数赋值的变量的任何更改都会更改存储在当前存储位置的值，从而更改调用函数的变量引用的值。
请看下面的示例程序。函数内对变量 n 中元素值的任何更改也会更改调用变量 x 引用的列表中的元素。
def myfunc(n):
print(n)
n[1] = 15
print(n)
x = [10, 20]
print(x)
>> [10, 20]
myfunc(x)
>> [10, 20]
>> [10, 15]
print(x)
>> [10, 15]如果以这种方式将可变对象指定为参数，则它的行为就好像它是通过引用传递的一样。
在 Python 中使用参数时，通过引用将它们传递给函数没有区别，但请注意，行为会有所不同，具体取决于指定为参数的对象是不可变对象还是可变对象。
14-4 使用 return 语句将函数的返回值返回给调用者
调用函数后，可以使用 return 语句将值返回给函数的调用者。本节介绍如何将函数的返回值返回给调用者。
使用 return 语句返回值
调用函数时，函数块内的处理从顶部开始按顺序进行，到达块的末尾时，函数内的处理结束，处理返回给调用者。在这种情况下，该函数将 None 值返回给调用者。
请参见以下示例。
def myfunc():
print("Hello")
x = myfunc()
>> Hello
print(x)
>> None调用函数后，函数的返回值赋值给变量x并输出到屏幕。如果您没有明确指定要从函数返回的值，则值 None 会像这样返回。
return 语句用于将函数中的任意值返回给它的调用者。
return 返回值当在函数内执行return 语句时，函数内的处理到此结束，处理返回到函数的调用者。这时候如果return语句后面写了一个返回值，这个值就会返回给调用者。
示例代码
请看下面的示例。
def myfunc():
print("Hello")
return "Good bye"
x = myfunc()
>> Hello
print(x)
>> Good bye调用函数后，函数的返回值赋值给变量x并输出到屏幕。函数中使用 return 语句返回字符串“Good bye”作为返回值。
return 语句可以出现在函数块中的任何位置，而不仅仅是函数的末尾。不管写在哪里，当return语句执行时，函数内的处理到此结束。此外，可以描述多个 return 语句。也可以在函数内部编写条件分支，根据条件返回不同的返回值给调用者。
示例代码
次のサンプルを見てください。
def myfunc(num):
if num % 2 == 0:
return "偶数"
return "奇数"
for i in range(1, 5):
print(str(i) + "是" + myfunc(i))
>> 1 是奇数
>> 2 是偶数
>> 3 是奇数
>> 4 是偶数在这个例子中，for 语句用于改变传递给函数的参数的值，而在函数内部，多个 return 语句用于根据传递的值改变返回给调用者的值。
返回多个值
return语句后只能写一个返回值，但是通过创建一个对象如元组，以多个值作为元素并将其设置为返回值，可以有效地将多个值返回给调用者功能。可以做。
请参见以下示例。
def myfunc():
name = "Yuhua"
old = 24
return (name, old)
x = myfunc()
print("name : " + x[0])
>> name : Yuhua
print("old : " + str(x[1]))
>> old : 24在函数内部，我们用两个参数的值创建一个元组对象，并将其设置为 return 语句的返回值。调用该函数后，从返回的元组中提取每个元素作为返回值并输出到屏幕。像这样使用诸如元组之类的对象作为返回值允许我们将多个值传递回调用者。
注意创建元组对象时可以省略(和)，所以前面例子中的函数可以这样写：
def myfunc():
name = "Yuhua"
old = 24
return name, old但是创建一个元组对象并设置为返回值是比较难理解的。
示例代码
请看下面的示例。
def myfunc(num1, num2):
goukei = num1 + num2
heikin = (num1 + num2) / 2
return (goukei, heikin)
num1 = 10
num2 = 8
x = myfunc(num1, num2)
print("num1 = " + str(num1))
>> num1 = 10
print("num2 = " + str(num2))
>> num2 = 8
print("总计 = " + str(x[0]))
>> 总计 = 18
print("平均值 = " + str(x[1]))
>> 平均值 = 9.0在这个示例中，函数内执行了多次计算，创建了一个元组对象，每个结果作为一个元素，并将其作为返回值返回给函数调用者。
14-5 为参数设置默认值
在设置为接受参数的函数中，为形式参数设置默认值允许在调用函数时省略参数。本节介绍如何为参数设置默认值。
为参数设置默认值
可以在定义函数时为参数设置默认值。如果设置了默认值并且在进行函数调用时省略了参数，则将使用默认值。
如果要为参数设置默认值，请按如下方式描述。
def 函数名称（参数 = 默认值）：
函数内处理
return 返回值调用函数时，如果指定参数，则使用其值，如果省略参数，则使用默认值。
示例代码
请参阅以下示例。
def myfunc(msg = "Hello"):
print(msg)
myfunc("你好")
>> 你好
myfunc()
>> Hello它将“Hello”设置为参数的默认值。如果在调用函数时指定参数，则使用该值，但如果省略参数，则默认值将代替形式参数而不是实际参数并使用。
为多个参数设置默认值时的注意事项
如果你有多个参数，你可以为每个参数设置默认值。您也可以只为某些参数设置默认值。但是，如果有多个参数，并且只有部分参数有默认值，那么没有默认值的参数不能写在有默认值的参数后面。
要么像这样给所有的参数设置默认值，要么在没有默认值的参数之后定义有默认值的参数也没关系。
〇为所有参数设置默认值
def 函数名（参数1 = 默认值1，参数2 = 默认值2）：
返回
函数名 (n1, n2)
函数名称 (n1)
函数名()
〇 仅为第二个参数设置默认值
def 函数名（参数1，参数 2 = 默认值2）：
返回
函数名 (n1, n2)
函数名称 (n1)如果存在未设置默认值的参数，则必须通过指定实际参数来调用该函数。
如下所示，如果在没有默认值的参数之前定义了具有默认值的参数，则会发生错误。
✕仅为第一个参数设置默认值
def 函数名（参数1 = 默认值1，参数2）：
返回
✕仅为三个参数中的第二个设置默认值
def 函数名（参数1，参数2 = 默认值2，参数3）：
返回请参见以下示例。尝试为第一个参数定义默认值的函数将导致 SyntaxError 错误。
def myfunc(n1 = 10, n2):
return
>> File "<stdin>", line 1
>> SyntaxError: non-default argument follows default argument示例代码
请看下面的示例。
def myfunc(num1, str1 = "无输入", str2 = "未知"):
print("年龄是" + str(num1) + "。", end='')
print("名字是" + str1 + "。", end='')
print("地址是" + str2 + "。")
myfunc(28, "Yuhua", "Qingdao")
>> 年龄是28。名字是Yuhua。地址是Qingdao。
myfunc(25, "Yuhua")
>> 年龄是28。名字是Yuhua。地址是未知。
myfunc(30)
>> 年龄是28。名字是无输入。地址是未知。它需要三个参数，第二个和第三个参数具有默认值。如果在调用函数时省略参数，将使用默认值代替。
将列表等可变对象设置为默认值时的注意事项
使用默认值需要注意的另一件事是，当函数定义完成时，它们只会被评估一次。
例如，如果我们定义了这样一个函数：
def myfunc(num1, num2 = 10):
num2 *= 2
print(num1 + num2)
myfunc(5)
myfunc(7)参数 num2 的默认值为 10。如果在调用函数时省略第二个参数，函数会将默认值 10 赋给形式参数变量 num2。它只在定义时执行一次。
更具体地说，变量 num2 被设置为引用定义函数时存储默认值 10 的位置。每次调用该函数时都会应用此设置。所以每次 num2 指的是定义函数时存储默认值的同一个地方。
如果默认值是一个一旦创建就不能改变的不可变对象，例如数字或字符串，在函数中为变量 num2 分配一个不同的值将覆盖最初存储默认值 10 的值。相反，新的值存储在新的位置，并且引用了变量 num2，所以原来存储默认值 10 的位置的值保持不变。因此，当再次调用该函数时，变量 num2 将始终引用与第一次相同的位置并具有值 10。
如果默认值是像这样的不可变对象，不需要太担心，但如果默认值是一个可变对象，比如列表，就需要小心了。例如，如果我们定义了这样一个函数：
def myfunc(str1, list1 = ["a"]):
list1.append(str1)
return list1
myfunc("b")
myfunc("c")
myfunc("d")参数 list1 的默认值为 [“a”]，它是一个列表对象。在这种情况下，在定义函数时也只进行一次评估。具体来说，变量 list1 被设置为引用值 [“a”] 存储的位置作为默认值。每次调用该函数时都会应用此设置。所以每次list1都引用了定义函数时存放默认值的同一个地方。
如果默认值是list这样的可变对象，如果在函数中通过添加元素改变变量list1，原来存放默认值[“a”]的地方的值会被覆盖。你可以 当再次调用该函数时，变量 list1 将始终引用与第一次相同的位置，因此它将具有重写的值。
如果我们尝试了前面的例子，我们就会得到这样的结果：
def myfunc(str1, list1 = ["a"]):
list1.append(str1)
return list1
myfunc("b")
>> ['a', 'b']
myfunc("c")
>> ['a', 'b', 'c']
myfunc("d")
>> ['a', 'b', 'c', 'd']不是每次调用函数时都将 [“a”] 的默认值分配给参数 list1，而是每次调用函数时修改存储在同一位置的值。当然，如果你了解规范并想这样操作也无妨，但如果假设每次都会进行初始化，你会得到意想不到的结果，所以要小心。
如果你每次都想初始化和使用一个像list这样的可变对象，官网说明应该改程序如下。
def myfunc(str1, list1 = None):
if list1 is None:
list1 = ["a"]
list1.append(str1)
return list1
myfunc("b")
>> ['a', 'b']
myfunc("c")
>> ['a', 'c']
myfunc("d")
>> ['a', 'd']不是将可变对象指定为默认值，而是指定 None，并将初始值设置为在函数处理期间再次分配参数的变量。由于默认值不是可变对象，因此在函数中更改它不会更改默认值所指的值。因此，每次调用该函数时，list1 都会设置为引用存储 None 的位置，从而导致每次都进行初始化。
14-6 使用关键字参数调用函数
调用带参数的函数时，可以指定函数中定义的形式参数的名称，而不是仅以形式参数名称=值的格式指定值。这种形式称为关键字参数。本节介绍如何使用关键字参数调用函数。
位置和关键字参数
调用带参数的函数时，调用方指定的参数值依次赋值给函数方为参数定义的变量。这种形式称为位置参数。
def 函数名（形式参数1，形式参数2）：
....
return
函数名（实际参数1，实际参数2）在位置参数的情况下，参数的值是按照它们列出的顺序传递的，所以实参1传递给形式参数1，实参2传递给形式参数2。
另一方面，在关键字参数格式中，要传递给形式参数的值在函数的调用侧以形式参数名称=值的形式指定。
def 函数名（形式参数1，形式参数2）：
....
return
函数名（形式参数1 = 实际参数1，形式参数2 = 实际参数2）在关键字参数的情况下，参数的写入顺序是任意的，因为它指定了将值传递给函数端的哪个虚拟参数。所以你可以按如下方式颠倒顺序。
def 函数名（形式参数1，形式参数2）：
....
return
函数名（形式参数2 = 实际参数2，形式参数1 = 实际参数1）示例代码
请看下面的示例。
def myfunc(num1, str1):
print("num1=" + str(num1))
print("str1=" + str1)
myfunc(num1=10, str1="Orange")
>> num1=10
>> str1=Orange
myfunc(str1="Lemon", num1=15)
>> num1=15
>> str1=Lemon我们可以以关键字参数的形式调用函数。在关键字参数格式的情况下，写入参数的顺序是自由的。
混合位置和关键字参数
我们还可以调用混合了位置参数和关键字参数的函数。在这种情况下，首先指定位置参数，然后是关键字参数。
def 函数名（形式参数1，形式参数2，形式参数3）：
....
return
函数名（实际参数1，形式参数2 = 实际参数2，形式参数3 = 实际参数3）如果在关键字参数后指定一个没有正式参数名称的参数，则会发生错误 SyntaxError: positional argument follows keyword argument。
我不知道关键字参数在什么情况下有用，但是当有大量参数并且您想弄清楚该值是针对哪个参数时，它可能会有效。
示例代码
请看下面的示例。
def myfunc(old, name, address):
print("年龄是" + str(old) + "。", end='')
print("名字是" + name + "。", end='')
print("地址是" + address + "。")
myfunc(28, "Yuhua", "Qingdao")
>> 年龄是28。名字是Yuhua。地址是Qingdao。
myfunc(address="Shanghai", old=25, name="Jiangming")
>> 年龄是25。名字是Jiangming。地址是Shanghai。
myfunc(32, address="Beijing", name="Yuyang")
>> 年龄是32。名字是Yuyang。地址是Beijing。我们首先以普通形式调用函数，然后以关键字参数形式调用函数。最后，该函数以普通形式和关键字形式的混合调用。
14-7 在函数中接受可变数量的参数
即使参数的数量在函数定义中不固定，也可以定义为接收可变数量的参数。本节描述如何定义一个函数来接受可变数量的参数。
定义可变数量的参数
函数调用侧指定的参数（实际参数）数量与函数侧参数（形式参数）数量相同。（如果要设置默认值，也可以省略它）。
def 函数名（形式参数1，形式参数 2）：
....
return
函数名（实参数1，实参数2）在函数端为形式参数的名称加上星号 (*) 前缀允许该形式参数接受 0 到任意数量的值。
def 函数名（形式参数 1，*形式参数 2）：
....
return
函数名（实际参数1）
函数名（实际实参1，实际实参2）
函数名（实际实参1，实际实参2，实际实参3）
函数名（实际实参1，实际实参2，实际实参3，实际实参4）
函数名（实际实参1，实际实参2，实际实参3，实际实参4，实际实参5）在上面的例子中，实参 1 被赋值给了形参 1，但是实参 2 到实参 5 都被赋值给了形参 2。这时候形式参数2就变成了一个元组对象，这样就可以赋多个值，把作为参数传递的值作为一个元组元素添加进去。
示例代码
请看下面的示例。
def myfunc(num1, *tupple1):
print(tupple1)
myfunc(10)
>> ()
myfunc(10, "Hello")
>> ('Hello',)
myfunc(10, "Hello", 25)
>> ('Hello', 25)
myfunc(10, "Hello", 25, "Orange")
>> ('Hello', 25, 'Orange')
myfunc(10, "Hello", 25, "Orange", True)
>> ('Hello', 25, 'Orange', True)调用函数时，第一个参数始终分配给函数端的 num1，但在第二个之后指定的所有参数都作为函数端的 tupple1 的元素添加。如果省略第二个参数，tupple1 将是一个空元组。
在函数端，可以通过顺序检索元组的元素来检索传递的参数的值。
示例代码
请看下面的示例。
def myfunc(category, *ranktuple):
count = 1
print(category)
for val in ranktuple:
print("No." + str(count) + ":" + val)
count += 1
print("\n", end='')
myfunc("Fruits", "Orange", "Melon", "Banana", "Apple")
>> Fruits
>> No.1:Orange
>> No.2:Melon
>> No.3:Banana
>> No.4:Apple
myfunc("Mobile", "Android", "iPhone")
>> Mobile
>> No.1:Android
>> No.2:iPhone我们根据调用函数时指定的参数数量更改了函数中显示的文本数量。
