Python函数
<p>1、函数的定义</p>
<pre><code>function：代码块。 /就是将我们要执行的代码进行结构的整合，形成可重复调用的代码块。
（1）关键字: def
（2）函数名
命名规范：
<1>、 字母开头。
<2>、 不允许有关键字 。
<3>、 不允许有特殊符号 。
<4>、 不允许莫名其妙的函数名 a,b。
（3）参数
参数是定义在参数括号里，由调用时传入，作用在函数内部的变量。
<1>、 如果有参数，写在参数括号里。
<2>、 如果没有，写空括号。
（4）内容块
函数的调用:
函数在没有调用之前不会执行, 函数名加括号，并且进行对应的传参的形式。
在定义函数是定义的参数,我们称之为 "形参 " 。
在调用函数的时候我们传递值 我们称之为 "实参"。</code></pre>
<p>2、函数的优点</p>
<pre><code>函数与代码复制的相比较，优点如下：
（1）减少冗余代码。
（2） 代码结构清晰。
（3） 有助于保持代码的一致性。</code></pre>
<p>3、创建函数</p>
<pre><code>语法格式
def FunctionName([parameterlist]):
['''comments''']
[functionbody]
参数说明
FunctionName:函数名称。
parameterlist：可选参数，用于指定向函数中传递的参数。
comments：可选参数，表示为函数指定注释。
functionbody：可选参数，要执行的功能代码。如果函数有返回值，可以使用return返回语句。（如果定义一个什么也不做的函数，可以使用pass作为占位符）。</code></pre>
<p>4、调用函数</p>
<pre><code>语法格式
FunctionName([parametersvalue])
参数说明：
FunctionName:函数名称。
parametersvalue:可选参数，用于指定各个参数的值。若无则写一对小括号即可。</code></pre>
<p>5、参数传递</p>
<pre><code>5.1、形式参数
在定义函数时，函数名后括号里的参数我们称之为 "形参"。
5.2、实际参数
在调用函数时，函数名后括号里的参数我们称之为 "实参"。 即调用函数时的传递值为"实参"。
5.3、参数位置
也称为必备参数，必须按照真确的顺序传递到函数中，即调用时的数量和位置必须和定义的一致。
特点1:数量必须与定义的一致。数量与定义的不一致时，可能会抛出TypeError异常。
案例
调用BMI指标函数 Fun_bmi(person,height,weight),将参数少传递一个代码如下:
Fun_bmi("json",1.80) 计算json的BMI指标
执行上面这行代码，会报TypeError
特点2:位置必须与定义的一致。位置与定义的不一致时，可能会抛出TypeError异常或产生的结果与预期不符合。
案例
调用BMI指标函数 Fun_bmi(person,height,weight),将参数位置写错代码如下:
Fun_bmi(1.80,"json",50) 计算json的BMI指标
执行上面这行代码，会报TypeError
5.4、关键字参数
说明
在指定实际参数时，不再需要与形式参数位置完全一致。
案例
调用BMI指标函数 Fun_bmi(person,height,weight),写上参数名字代码如下:
Fun_bmi(height=1.80,person="json",weight=50) /计算json的BMI指标
执行上面这行代码，显示结果与预期一致。
5.5、为参数设置默认值
说明
（1）定义函数时，直接指定形式参数的默认值，这样当没有传入参数时会直接使用默认值，不会抛出异常。
（2）定义函数时，指定默认的形式参数必须放在所有参数的最后，否则会产生语法错误。
格式
def FunctionName(...,[parameter1=defaultvalue1]):
[代码块]
参数说明
FunctionName:函数名称。
parameter1=defaultvalue1：可选参数，用于指定向函数中传递的参数，并且为该参数设置默认值defaultvalue1。
5.6、查看当前的默认值。
案例
调用BMI指标函数 Fun_bmi(person,height,weight)
Fun_bmi(1.80,"json",weight=50) /计算json的BMI指标
显示上面函数的默认值，可以使用Fun_bmi.__default__，结果为"50"
5.7、默认值必须指向不可变对象
说明
使用可变对象作为函数的默认值时，多次调用可能会导致不符合预期的结果。
案例:定义1个函数，并为其参数设置可变的默认值。
def demo(obj=[]): #定义函数并为参数obj指定默认值[]
print("obj的值："，obj)
obj.append(1)
test1:
demo()
输出： obj的值： []
test2:
demo()
demo()
输出：
obj的值： []
obj的值： [1]
test3:
def demo(obj=None): /定义函数并为参数obj指定默认值[]
if obj == None
obj = []
print("obj的值：",obj)
obj.append(1)
demo()
demo()
输出：
obj的值： []
obj的值： []
5.8、可变参数
可变参数也叫不定长参数。即传入函数的实际参数个数不定。
(1)*parameter
说明
表示接收任意多个实际参数并放到一个元组中。
案例-1
定义一个函数，让其可以接收任意多个实际参数。
代码如下：
def printcoffee(*coffeename): /定义输出我喜欢的咖啡名字的函数
print('\n我喜欢的咖啡有：')
for item in coffeename:
print(item) /输出咖啡名字
调用3次这个函数，分别指定不同个数的实际参数，代码如下：
printcoffee('蓝山')
printcoffee('蓝山','土耳其')
printcoffee('蓝山','土耳其','摩卡')
输出：
我喜欢的咖啡有:
蓝山
我喜欢的咖啡有:
蓝山
土耳其
我喜欢的咖啡有:
蓝山
土耳其
摩卡
案例-2
如果想使用一个已经存在的列表作为函数的可变参数，可以在列表的名称前面加上*，代码如下：
param = ['蓝山','土耳其','摩卡'] /定义列表
printcoffee(*param) /通过列表指定函数的可变参数
输出：
我喜欢的咖啡有:
蓝山
土耳其
摩卡
(2)**parameter
说明
表示接收任意多个类似关键字参数一样显示赋值的实际参数，并放到一个字典中。
案例-1
定义一个函数，让其可以接收任意多个显示赋值的实际参数。
代码如下：
def printsign(**sign): /定义输出我喜欢的咖啡名字的函数
print()
for key,value in sign.items():
print("["+key+"]的星座是："+value) /输出咖啡名字
调用2次这个函数，代码如下：
printsign(A="水瓶"，B="双鱼")
printsign(A="水瓶"，B="双鱼",c="白羊")
输出：
[A]的星座是：水瓶
[B]的星座是：双鱼
[A]的星座是：水瓶
[B]的星座是：双鱼
[C]的星座是：白羊
案例-2
如果想要使用一个已经存在的字典作为函数的可变参数，可以在字典的名称前面加**
代码如下：
dict = {"A":"水瓶","B":"双鱼","C":"白羊"}
print(**dict)
输出：
[A]的星座是：水瓶
[B]的星座是：双鱼
[C]的星座是：白羊</code></pre>
<p>6、无参数函数</p>
<pre><code>案例
无参数函数
def keru():
print("hello lukr")
调用函数
keru()
输出:
hello lukr</code></pre>
<p>7、返回值</p>
<pre><code>说明
为函数设置返回值的作用是将函数的处理结果返回给调用它的程序。
格式
relut = return [value]
参数说明:
relut:用于保存返回结果
value:可选参数，用于指定返回的值，可以是一个或多个。
当函数中没有return语句时，或者省略了return语句的参数时，将返回None，即返回空值。</code></pre>
<p>8、函数的划分</p>
<p>8.1、按照参数类型划分：位置参数;关键字参数;默认参数;参数组</p>
<pre><code>（1）位置参数
是我们在传参的时候，实参传递的顺序按照形参定义的顺序进行传递的传参方式。
#有参数函数
def KERU(name,age):
print("hello %s,I'm %s years old"%(name,age))
#调用函数
KERU("lukr",18)
KERU(18,"lukr")
# 输出：
# hello lukr,I'm 18 years old
# hello 18,I'm lukr years old
（2）关键字参数
是我们在传参的时候，以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式。
有参数函数
def KERU(name,age):
print("hello %s,I'm %s years old"%(name,age))
调用函数
KERU(name = "lukr",age = 18)
KERU(age = 18,name = "lukr")
输出：
hello lukr,I'm 18 years old
hello lukr,I'm 18 years old
（3）默认参数
是在我们定义参数时候，我们给形参一个默认值，在我们调用函数的时候，如果不给有默认值的形参传参，会自动采用默认值。 注意：默认值参数必须写在正常参数的后面。
有参数函数
def KERU(name,age = 18):
print("hello %s,I'm %s years old"%(name,age))
调用函数
KERU(name = "lukr",age = 16)
KERU(age = 17,name = "lukr")
KERU(name = "lukr")
输出：
hello lukr,I'm 16 years old
hello lukr,I'm 17 years old
hello lukr,I'm 18 years old
注意：默认值要写在正常参数的后面，否则会报错
def KERU(age = 18,name):
print("hello %s,I'm %s years old"%(name,age))
调用函数
KERU(name = "lukr") 这里出现了歧义，<1>把参数传给了age，name忘记了传参<2>把参数传给了name，age采用默认值；计算机无法判断歧义，所以会报错。
输出：
SyntaxError: non-default argument follows default argument
注意：默认值要写在正常参数的后面，否则会报错
def KERU(name,age = 18,sex = "female"):
print("hello %s,I'm %s years old,%s."%(name,age,sex))
调用函数
KERU(name = "lukr")
输出：
hello lukr,I'm 18 years old,female.
（4）参数组
指我们将参数变成元组参数组或者字典参数组。
1.元组参数组
通过给形参前面添加*使参数变成一个元组，所有传递的参数变成元组的元素。
def hello(*data):
print(data)
调用函数
hello()
hello(1)
hello(1,2,3)
输出：
()
(1,)
(1, 2, 3)
2.字典参数组
通过给形参前面添加**使参数变成一个字典，所有传递的参数变成字典的键值对，这里传参要求键等于值的形式。
def hello(**data):
print(data)
调用函数
hello()
hello(a = 1)
hello(a = 1,b = 2,c = 3)
输出：
{}
{'a': 1}
{'a': 1, 'b': 2, 'c': 3}
def hello(*data,**kwd):
print(data)
print(kwd)
调用函数
hello(1,2,3)
输出：
(1, 2, 3)
{}
hello(a = 1,b = 2,c = 3)
输出：
()
{'a': 1, 'b': 2, 'c': 3}
hello(1,b = 2,c = 3)
输出：
(1,)
{'b': 2, 'c': 3}</code></pre>
<p>8.2、按照返回值划分</p>
<pre><code>区别点在于是否有返回值。
（1）返回型函数:有返回值。
注:SAY_hello这个函数有返回值，作用是返回"hello world!"。类型是:str
def SAY_hello():
return "hello world!"
SAY_hello()
输出:
无
print(type(SAY_hello()))
输出:
<class 'str'>
（2）计算型函数:没有返回值。
注:say_hello这个函数没有返回值，它的功能只是打印出"hello world!"。类型是:None
def say_hello():
print("hello world!")
say_hello()
输出:
hello world!
print(type(say_hello()))
输出:
hello world!
<class 'NoneType'></code></pre>
<p>8.3、return</p>
<1> return将函数当中的值返回出来。
<2> return结束，函数结束，函数当中return下面的语句不会执行。
<3> return只能返回一个值。
def say_hello():
print("hello world!")
def SAY_hello():
return "hello world!","thanks!"
print("thanks!") 不会执行，return结束，函数就结束了。
def SAY_HELLO():
return "HELLO WORLED!"
print(type(say_hello()))
输出:
hello world!
<class 'NoneType'>
print(type(SAY_hello()))
输出:
<class 'tuple'>
print(say_hello())
输出:
hello world!
None
print(SAY_hello())
输出:
('hello world!', 'thanks!') return只能返回1个参数
print(SAY_HELLO())
输出:
HELLO WORLED!return 只能返回1个参数