def 函数名称(,Python用def关键字来定义函数

函数

函数

1.  函数的定义  

1.  函数的定义  

  在Python中,函数是逻辑结构化和进度化的一种艺术;是带名字的、组织好的、可重复使用的代码块,用于达成具体的任务。Python用def关键字来定义函数,然后用return关键字重返值,其语法格式如下:

  在Python中,函数是逻辑结构化和进程化的一种办法;是带名字的、组织好的、可重复使用的代码块,用于完毕具体的职分。Python用def关键字来定义函数,然后用return关键字重返值,其语法格式如下:

  def 函数名称([参数1],[参数2],…,[参数N]):

  def 函数名称([参数1],[参数2],…,[参数N]):

    ”””文书档案字符串”””

    ”””文档字符串”””

    代码块

    代码块

    return [返回值]

    return [返回值]

  

  

  说明:  

  说明:  

  (1)函数代码块以 def 关键字开首,然后空格加函数名号,圆括号(),以冒号(:)结尾。当中,若函数有参数,则将其位于括号中,若有四个参数,则用逗号分开。

  (1)函数代码块以 def 关键字初叶,然后空格加函数名号,圆括号(),以冒号(:)结尾。在那之中,若函数有参数,则将其放在括号中,若有四个参数,则用逗号分开。

  (2)函数的情节以冒号发轫,并且换行后需缩进。

  (2)函数的始末以冒号发轫,并且换行后需缩进。

  (3)函数的首先行语句能够采取性地应用文书档案字符串,首要用以存放函数表达,描述该函数的效应。文书档案字符串用三引号括起来,Python使用它们来变化有关程序中等高校函授数的文书档案。

  (3)函数的率先行语句可以选取性地选用文书档案字符串,首要用以存放函数表达,描述该函数的职能。文书档案字符串用三引号括起来,Python使用它们来扭转有关程序中函数的文档。

  (4)代码块正是实现函数效率的具体的代码。

  (4)代码块正是促成函数功效的切切实实的代码。

  (5)以 return[返回值]
来甘休函数,并回到二个值给调用方。若函数没有切实可行的再次来到值,则return会重临None。

  (5)以 return[返回值]
来停止函数,并赶回一个值给调用方。若函数没有实际的再次来到值,则return会重返None。

 

 

  

  

  因此,可粗略的辨证,函数即由函数名称及函数体组成。个中等高校函授数体蕴涵:文书档案字符串、代码块、重返值。 

  由此,可粗略的验证,函数即由函数名称及函数体组成。个中等高校函授数体包涵:文书档案字符串、代码块、再次来到值。 

  例如,定义二个欢迎用户登录时的问候语的函数。

  例如,定义叁个欢迎用户登录时的问候语的函数。

  代码:

  代码:

1 def greet_user():
2     """用户登录时,显示简单的问候语"""
3     print("Welcome to login!")
4     return 
1 def greet_user():
2     """用户登录时,显示简单的问候语"""
3     print("Welcome to login!")
4     return 

 

 

2.  函数的法力

2.  函数的功能

  在Python中,函数的的功效重点有三点:

  在Python中,函数的的成效重点有三点:

  (1)代码重用。在先后中,能够调用已经有的函数,不用再重复写完结代码,故使得代码简洁,并能完毕平等的效益。

  (1)代码重用。在程序中,能够调用已经有个别函数,不用再重复写完成代码,故使得代码简洁,并能完毕均等的效用。

  (2)保持一致性。在程序中,可能会多处必要完结均等的效应,若是老是都写二回完成,不仅浪费时间,使代吗臃肿,不易读,还大概没处完成的意义有出入。但调用同1个函数,若函数修改了,则别的调用的地点都接着变动了。那样不仅实效达成保障了同样,还是能使代码更洁净,易读。

  (2)保持一致性。在先后中,也许会多处供给实现平等的功效,假诺老是都写1回完结,不仅浪费时间,使代吗臃肿,不易读,还只怕没处实现的意义有差距。但调用同多个函数,若函数修改了,则别的调用的地点都跟着变动了。那样不光实际作用实现保证了平等,仍是能够使代码更整洁,易读。

  (3)可增加性。当大家须求让能够函数协助大家成功愈来愈多的天职,大家只需在函数中编辑完毕即可。若参数有变化,则只需修改调用的地点。

  (3)可扩充性。当我们要求让能够函数援助大家成功越多的义务,大家只需在函数中编辑达成即可。若参数有浮动,则只需修改调用的地点。

  (4)使用函数让程序更便于阅读。

  (4)使用函数让程序更易于阅读。

  (5)函数让代码更便于测试和调节。

  (5)函数让代码更易于测试和调节。

 

 

3.  参数

3.  参数

  在Python中,参数也分为实参和形参。实参正是调用函数时,在括号中钦定的装有实际值的参数;形参就是在概念函数时,在括号中内定的变量,无实际值。  当中,实参包蕴:地点实参、关键字实参、默许值等。

  在Python中,参数也分为实参和形参。实参便是调用函数时,在括号中钦点的持有实际值的参数;形参就是在概念函数时,在括号中内定的变量,无实际值。  个中,实参包涵:地方实参、关键字实参、默许值等。

 

 

4. 函数的调用

4. 函数的调用

  函数的调用很简短,即用函数名称加圆括号(),若有参数,则将其参数放在括号中,若有八个参数,则将其放置括号中,并用逗号分开。具体语法格式如下所示:

  函数的调用很简单,即用函数名称加圆括号(),若有参数,则将其参数放在括号中,若有八个参数,则将其放置括号中,并用逗号分开。具体语法格式如下所示:

         函数名称([参数1],[参数2],…,[参数N])

         函数名称([参数1],[参数2],…,[参数N])

  由此,函数调用存在两种情状,一种是无参函数调用;一种是有参函数调用。

  因而,函数调用存在三种情景,一种是无参函数调用;一种是有参函数调用。

 

 

4.1 无参函数的调用

4.1 无参函数的调用

  例如,定义一个欢迎用户登录时的问候语的函数,并调用它。

  例如,定义2个欢迎用户登录时的问候语的函数,并调用它。

  代码:

  代码:

1 def greet_user():
2     """用户登录时,显示简单的问候语"""
3     print("Welcome to login!")
4     return
5 
6 greet_user()
1 def greet_user():
2     """用户登录时,显示简单的问候语"""
3     print("Welcome to login!")
4     return
5 
6 greet_user()

  说明:

  说明:

  第三行,用def 关键字定义1个函数greet_user(),并以冒号结尾。

  第3行,用def 关键字定义3个函数greet_user(),并以冒号结尾。

  第③行,用文档字符串来诠释表达该函数的效益。

  第3行,用文书档案字符串来诠释表达该函数的机能。

  第一行,打字与印刷一条登录时的迎接问候语。

  第叁行,打字与印刷一条登录时的欢迎问候语。

  第6行,用关键字return 停止函数。

  第⑥行,用关键字return 截至函数。

  第伍行,调用该函数greet_user()。由于该函数没有参数,所以间接用函数名加括号()调用即可。

  第肆行,调用该函数greet_user()。由于该函数没有参数,所以直接用函数名加括号()调用即可。

 

 

  运转结果:

  运营结果:

  

  

Welcome to login!
Welcome to login!

 

 

4.2 有参函数的调用

4.2 有参函数的调用

  由于函数定义中大概含有四个形参,由此有参函数的调用也恐怕蕴涵多少个实参。
调用函数时,给函数字传送递实参的艺术有:位置实参、关键字实参、暗中认可、还恐怕是列表和字典等等。

  由于函数定义中或然含有八个形参,由此有参函数的调用也可能包涵七个实参。
调用函数时,给函数字传送递实参的不二法门有:地点实参、关键字实参、私下认可、还也许是列表和字典等等。

 

 

4.2.1 地方实参

4.2.1 地点实参

  由于使用位置实参传参要求实参的一一与形参的一一相同,因此,在调用函数时,必须将函数调用中的每一个实参都事关到函数定义中的2个形参。即实参的职位必须与形参的职位保持一致。

  由于应用位置实参传参需求实参的种种与形参的种种相同,因而,在调用函数时,必须将函数调用中的每个实参都涉及到函数定义中的二个形参。即实参的职位必须与形参的地点保持一致。

  (1)唯有二个地点实参
  例如,定义八个迎接用户登录时的问候语的函数,依照不一致用户打字与印刷一条相关的问候语,并调用它。

  (1)只有贰个岗位实参
  例如,定义1个欢迎用户登录时的问候语的函数,依照分歧用户打字与印刷一条相关的问候语,并调用它。

  代码:

  代码:

1 # 有参函数调
2 def greet_user(username):
3     """用户登录时,显示简单的问候语"""
4     print("Welcome to ",username,"!")
5     return
6 
7 #有参函数调用
8 greet_user("Yun")
1 # 有参函数调
2 def greet_user(username):
3     """用户登录时,显示简单的问候语"""
4     print("Welcome to ",username,"!")
5     return
6 
7 #有参函数调用
8 greet_user("Yun")

  说明:

  说明:

  第3行,用def
关键字定义1个带有形参username的函数greet_user(),并以冒号结尾。

  第3行,用def
关键字定义2个暗含形参username的函数greet_user(),并以冒号结尾。

  第十行,调用有参数的函数greet_user(),把实参”Yun”
的值传给形参username。

  第柒行,调用有参数的函数greet_user(),把实参”Yun”
的值传给形参username。

 

 

  运营结果:

  运转结果:

Welcome to  Yun !
Welcome to  Yun !

 

 

  (2)有七个肯定个数的岗位实参

  (2)有多个肯定个数的职位实参

  例如,定义3个有八个形参的函数,并调用它。

  例如,定义二个有多少个形参的函数,并调用它。

  代码:

  代码:

 1 def test_func(x,y,z):
 2     """接受三个参数值,并打印它们"""
 3     print(x)
 4     print(y)
 5     print(z)
 6     return
 7 
 8 print("---第一次调用---")
 9 test_func(1,2,3)
10 print("---第二次调用---")
11 test_func(4,5,6)
 1 def test_func(x,y,z):
 2     """接受三个参数值,并打印它们"""
 3     print(x)
 4     print(y)
 5     print(z)
 6     return
 7 
 8 print("---第一次调用---")
 9 test_func(1,2,3)
10 print("---第二次调用---")
11 test_func(4,5,6)

  说明:

  说明:

  第③行,用def关键字定义一个具有x,y,z三个形参的函数test_func()。

  第2行,用def关键字定义五个具有x,y,z七个形参的函数test_func()。

  第玖行,调用函数test_func(),并按岗位内定其参数值,即x=1,y=2,z=3。

  第⑧行,调用函数test_func(),并按职务钦赐其参数值,即x=1,y=2,z=3。

  第二1行,调用函数test_func(),并按岗位钦赐其参数值,即x=4,y=5,z=6。

  第壹1行,调用函数test_func(),并按岗位钦点其参数值,即x=4,y=5,z=6。

 

 

  运维结果:

  运维结果:

1 ---第一次调用---
2 1
3 2
4 3
5 ---第二次调用---
6 4
7 5
8 6
1 ---第一次调用---
2 1
3 2
4 3
5 ---第二次调用---
6 4
7 5
8 6

  从上述的周转结果可见,钦点的职位实参的值不一样,其函数再次回到的值也不比。

  从以上的运营结果可以,钦赐的位置实参的值差异,其函数重回的值也差别。

 

 

  (3)有八个不肯定个数的地点实参

  (3)有多少个不认可个数的职位实参

  有时候,大家不能够事先通晓函数需求承受多少个职位实参,因而,大家得以应用
‘*args’ 定义形参,
Python函数会从调用语句中收集任意数量的地点实参实行处理。

  有时候,大家无能为力事先领会函数须求经受多少个岗位实参,因而,我们得以采取‘*args’ 定义形参,
Python函数会从调用语句中收集任意数量的职务实参进行处理。

  代码:

  代码:

 1 def test_func(*args):
 2     print(args)
 3     return
 4 
 5 print("---第一次调用---")
 6 test_func()
 7 print("---第二次调用---")
 8 test_func(1)
 9 print("---第三次调用---")
10 test_func(1,2)
11 print("---第四次调用---")
12 test_func(1,2,3)
13 print("---第五次调用---")
14 test_func(1,2,3,4)
15 print("---第六次调用---")
16 test_func(1,2,3,4.5)
 1 def test_func(*args):
 2     print(args)
 3     return
 4 
 5 print("---第一次调用---")
 6 test_func()
 7 print("---第二次调用---")
 8 test_func(1)
 9 print("---第三次调用---")
10 test_func(1,2)
11 print("---第四次调用---")
12 test_func(1,2,3)
13 print("---第五次调用---")
14 test_func(1,2,3,4)
15 print("---第六次调用---")
16 test_func(1,2,3,4.5)

  说明:

  说明:

  第③行,用关键字def定义了一个参数个数不分明的函数test_func(),其中“*args”表示形参个数不明确。

  第③行,用关键字def定义了1个参数个数不鲜明的函数test_func(),其中“*args”表示形参个数不明确。

  第叁行,将吸收到的参数以列表的花样出口。

  第3行,将收取到的参数以列表的样式出口。

  第五行,调用函数test_func(),不提供其余实参值。

  第⑤行,调用函数test_func(),不提供别的实参值。

  第九行,调用函数test_func(),提供2个实参:1。

  第七行,调用函数test_func(),提供二个实参:1。

  第七行,调用函数test_func(),提供三个实参:① 、2。

  第捌行,调用函数test_func(),提供多少个实参:一 、2。

  第贰2行,调用函数test_func(),提供多少个实参:① 、② 、3。

  第一2行,调用函数test_func(),提供四个实参:壹 、贰 、3。

  第一4行,调用函数test_func(),提供四个实参:壹 、② 、③ 、4。

  第24行,调用函数test_func(),提供多个实参:壹 、二 、三 、4。

  第贰6行,调用函数test_func(),提供四个实参:壹 、二 、叁 、四 、5。

  第36行,调用函数test_func(),提供多个实参:壹 、贰 、三 、肆 、5。

 

 

  运营结果:

  运营结果:

 1 ---第一次调用---
 2 ()
 3 ---第二次调用---
 4 (1,)
 5 ---第三次调用---
 6 (1, 2)
 7 ---第四次调用---
 8 (1, 2, 3)
 9 ---第五次调用---
10 (1, 2, 3, 4)
11 ---第六次调用---
12 (1, 2, 3, 4.5)
 1 ---第一次调用---
 2 ()
 3 ---第二次调用---
 4 (1,)
 5 ---第三次调用---
 6 (1, 2)
 7 ---第四次调用---
 8 (1, 2, 3)
 9 ---第五次调用---
10 (1, 2, 3, 4)
11 ---第六次调用---
12 (1, 2, 3, 4.5)

  从上述运转结果可以,当我们不确认函数有微微确认的地方实参时,可选用“*args”作为形参,然后会把每一回调用时传出的任务实参值以列表的款式当做参数字传送递。这个职位实参能够没有人值,也许有多个值。

  从上述运维结果可见,当大家不确认函数某些许确认的岗位实参时,可应用“*args”作为形参,然后会把每一遍调用时传出的职位实参值以列表的花样当做参数字传送递。那几个岗位实参能够没有人值,只怕有多少个值。

 

 

4.2.2  关键字实参

4.2.2  关键字实参

  关键字实参是传递给函数的称谓-值对,即各类实参都由变量和值组成。由于能够一直将实参中名称和值关联起来,由此向函数字传送递实参时就不会搅乱,调用函数时不只毫无考虑实参的顺序,还是能够知晓的提议函数调用中每一种值的用处。可是,使用重要那参数时,必须精确的钦定函数定义中的形参名。

  关键字实参是传递给函数的称号-值对,即每种实参都由变量和值组成。由于能够从来将实参中名称和值关联起来,由此向函数传递实参时就不会搅乱,调用函数时不只毫无考虑实参的顺序,仍是能够精通的提议函数调用中每一种值的用途。不过,使用首要那参数时,必须准确的内定函数定义中的形参名。

  例如,大家运用主要字实参来调用1.4.2.第11中学定义的函数。

  例如,大家选取重要字实参来调用1.4.2.第11中学定义的函数。

  (1)唯有3个首要字参数

  (1)唯有二个根本字参数

  代码:

  代码:

1 def greet_user(username):
2     """用户登录时,显示简单的问候语"""
3     print("Welcome to ",username,"!")
4     return
5 
6 #有参函数调用
7 greet_user(username="Yun")
1 def greet_user(username):
2     """用户登录时,显示简单的问候语"""
3     print("Welcome to ",username,"!")
4     return
5 
6 #有参函数调用
7 greet_user(username="Yun")

  说明:

  说明:

  第⑩行,调用函数greet_user()时,使用主要字实参来给函数字传送值。

  第八行,调用函数greet_user()时,使用主要字实参来给函数传值。

 

 

  运营结果:

  运行结果:

Welcome to  Yun !
Welcome to  Yun !

  从以上运转结果可见,跟1.4.1.第11中学的一致。

  从上述运营结果能够,跟1.4.1.第11中学的一致。

  

  

  (2)有三个规定个数的主要性字参数

  (2)有几个规定个数的重中之重字参数

  代码:

  代码:

 1 def test_func(x,y,z):
 2     """接受三个参数值,并打印它们"""
 3     print(x)
 4     print(y)
 5     print(z)
 6     return
 7 
 8 print("---第一次调用---")
 9 test_func(x=1,y=3,z=3)
10 print("---第二次调用---")
11 test_func(x=4,y=5,z=6)
 1 def test_func(x,y,z):
 2     """接受三个参数值,并打印它们"""
 3     print(x)
 4     print(y)
 5     print(z)
 6     return
 7 
 8 print("---第一次调用---")
 9 test_func(x=1,y=3,z=3)
10 print("---第二次调用---")
11 test_func(x=4,y=5,z=6)

 

 

  运营结果:

  运营结果:

1 ---第一次调用---
2 1
3 3
4 3
5 ---第二次调用---
6 4
7 5
8 6
1 ---第一次调用---
2 1
3 3
4 3
5 ---第二次调用---
6 4
7 5
8 6

  从上述运营结果可见,与1.4.1.第11中学的一致。

  从以上运行结果可见,与1.4.1.第11中学的一致。

  

  

  那么,假若大家不钦赐实参z的值,那结果什么呢?

  那么,假诺大家不钦点实参z的值,那结果什么呢?

  代码:

  代码:

 1 def test_func(x,y,z):
 2     """接受三个参数值,并打印它们"""
 3     print(x)
 4     print(y)
 5     print(z)
 6     return
 7 
 8 print("---第一次调用---")
 9 test_func(x=1,y=3,3)
10 print("---第二次调用---")
11 test_func(x=4,y=5,6)
 1 def test_func(x,y,z):
 2     """接受三个参数值,并打印它们"""
 3     print(x)
 4     print(y)
 5     print(z)
 6     return
 7 
 8 print("---第一次调用---")
 9 test_func(x=1,y=3,3)
10 print("---第二次调用---")
11 test_func(x=4,y=5,6)

 

 

  运转结果:

  运维结果:

1   File "F:/PyProject/s14/day3/test_function.py", line 10
2     test_func(x=1,y=3,3)
3                      ^
4 SyntaxError: positional argument follows keyword argument
1   File "F:/PyProject/s14/day3/test_function.py", line 10
2     test_func(x=1,y=3,3)
3                      ^
4 SyntaxError: positional argument follows keyword argument

  从上述的运维结果能够:

  从以上的运作结果可知:

  (1)当大家用关键字参数调用函数时,必须每一种实参都需点名其涉嫌的形参名。

  (1)当大家用关键字参数调用函数时,必须每一个实参都需点名其涉及的形参名。

  (2)错误提醒未指出第21行的错,那是因为Python时解释型语言,但前边的代码出错了,若没对那些进行处理,那么就停下,不再运营后续的代码。

  (2)错误提醒未提议第壹1行的错,那是因为Python时解释型语言,但前面包车型客车代码出错了,若没对卓殊举办拍卖,那么就止住,不再运营后续的代码。

 

 

  (3)有多个不鲜明个数的重要字参数

  (3)有多少个不鲜明个数的机要字参数

  有时候,大家无能为力先行精晓函数要求经受多少个基本点字实参,因而,大家能够利用‘**kwargs’定义形参,
Python函数会从调用语句中收载任意数量的基本点字实参举行处理。

  有时候,大家鞭长莫及先行驾驭函数要求接受多少个基本点字实参,因此,大家能够运用‘**kwargs’定义形参,
Python函数会从调用语句中收载任意数量的重点字实参举行处理。

  代码:

  代码:

 1 def test_func(**kwargs):
 2     print(kwargs)
 3     return
 4 
 5 print("---第一次调用---")
 6 test_func()
 7 print("---第二次调用---")
 8 test_func(x=1)
 9 print("---第三次调用---")
10 test_func(x=1,y=2)
11 print("---第四次调用---")
12 test_func(x=1,y=2,z=3)
13 print("---第五次调用---")
14 test_func(x=1,y=2,z=3,x1=4)
15 print("---第六次调用---")
16 test_func(x=1,y=2,z=3,x1=4,y1=5)
 1 def test_func(**kwargs):
 2     print(kwargs)
 3     return
 4 
 5 print("---第一次调用---")
 6 test_func()
 7 print("---第二次调用---")
 8 test_func(x=1)
 9 print("---第三次调用---")
10 test_func(x=1,y=2)
11 print("---第四次调用---")
12 test_func(x=1,y=2,z=3)
13 print("---第五次调用---")
14 test_func(x=1,y=2,z=3,x1=4)
15 print("---第六次调用---")
16 test_func(x=1,y=2,z=3,x1=4,y1=5)

  说明:

  说明:

  第一行,大家用关键字def定义函数test_func()时,由于不承认函数的形参个数,故用“**kwargs”作为形参。

  第③行,大家用关键字def定义函数test_func()时,由于不认账函数的形参个数,故用“**kwargs”作为形参。

  第三行,打字与印刷该形参”**kwargs”的值。

  第一行,打字与印刷该形参”**kwargs”的值。

 

 

  运维结果:

  运行结果:

 1 ---第一次调用---
 2 {}
 3 ---第二次调用---
 4 {'x': 1}
 5 ---第三次调用---
 6 {'x': 1, 'y': 2}
 7 ---第四次调用---
 8 {'x': 1, 'y': 2, 'z': 3}
 9 ---第五次调用---
10 {'x': 1, 'y': 2, 'z': 3, 'x1': 4}
11 ---第六次调用---
12 {'x': 1, 'y': 2, 'z': 3, 'x1': 4, 'y1': 5}
 1 ---第一次调用---
 2 {}
 3 ---第二次调用---
 4 {'x': 1}
 5 ---第三次调用---
 6 {'x': 1, 'y': 2}
 7 ---第四次调用---
 8 {'x': 1, 'y': 2, 'z': 3}
 9 ---第五次调用---
10 {'x': 1, 'y': 2, 'z': 3, 'x1': 4}
11 ---第六次调用---
12 {'x': 1, 'y': 2, 'z': 3, 'x1': 4, 'y1': 5}

  从以上的运维结果能够,当大家调用形参个数不鲜明,且用“**kwargs”作为形参的函数时,我们不得不采纳主要字实参传值,并且会将点名的根本字实参当作字典的款型出口。

  从上述的周转结果可见,当我们调用形参个数不鲜明,且用“**kwargs”作为形参的函数时,大家只好动用重要字实参传值,并且会将钦定的显要字实参当作字典的样式出口。

 

 

4.2.3  默认值

4.2.3  默认值

  默许值便是点名的常量。当大家编辑函数时,能够给各种形参钦点暗中认可值,然后在调用函数时,倘若给形参提供了实参,则利用提供的实参,不然使用形参的钦命的形参的暗中认可值。

  私下认可值正是点名的常量。当我们编辑函数时,可以给种种形参钦赐暗中认可值,然后在调用函数时,假若给形参提供了实参,则采取提供的实参,不然使用形参的内定的形参的暗中同意值。

  由此,给形参钦命暗中同意值后,可以在函数调用中不难相应的实参。可是形参列表中,暗中认可值只可以放到任何形参的末端,那样才能使Python解释器能够正确的解读地方实参。

  由此,给形参钦命私下认可值后,能够在函数调用中简易相应的实参。不过形参列表中,默许值只好放到任何形参的背后,那样才能使Python解释器能够科学的解读地方实参。

  使用暗中认可值的补益:

  使用暗许值的功利:

  (1)可简化函数调用。

  (1)可简化函数调用。

  (2)可了然建议函数的杰出用法

  (2)可清楚建议函数的高人一等用法

  例如,创制2个函数具有多个形参x、y、z,当中z的暗中同意值为0,然后调用该函数,并打字与印刷的值。

  例如,成立二个函数具有三个形参x、y、z,在那之中z的默许值为0,然后调用该函数,并打字与印刷的值。

  代码:

  代码:

 1 def test_func(x,y,z=0):
 2     print(x)
 3     print(y)
 4     print(z)
 5 
 6 print("---第一次调用---")
 7 test_func(1,2)
 8 print("---第二次调用---")
 9 test_func(1,y=2)
10 print("---第三次调用---")
11 test_func(x=1,y=2)
12 print("---第四次调用---")
13 test_func(1,2,3)
14 print("---第五次调用---")
15 test_func(1,2,z=3)
16 print("---第六次调用---")
17 test_func(x=1,y=2,z=3)
 1 def test_func(x,y,z=0):
 2     print(x)
 3     print(y)
 4     print(z)
 5 
 6 print("---第一次调用---")
 7 test_func(1,2)
 8 print("---第二次调用---")
 9 test_func(1,y=2)
10 print("---第三次调用---")
11 test_func(x=1,y=2)
12 print("---第四次调用---")
13 test_func(1,2,3)
14 print("---第五次调用---")
15 test_func(1,2,z=3)
16 print("---第六次调用---")
17 test_func(x=1,y=2,z=3)

 

 

  运营结果:

  运转结果:

 1 ---第一次调用---
 2 1
 3 2
 4 0
 5 ---第二次调用---
 6 1
 7 2
 8 0
 9 ---第三次调用---
10 1
11 2
12 0
13 ---第四次调用---
14 1
15 2
16 3
17 ---第五次调用---
18 1
19 2
20 3
21 ---第六次调用---
22 1
23 2
24 3
 1 ---第一次调用---
 2 1
 3 2
 4 0
 5 ---第二次调用---
 6 1
 7 2
 8 0
 9 ---第三次调用---
10 1
11 2
12 0
13 ---第四次调用---
14 1
15 2
16 3
17 ---第五次调用---
18 1
19 2
20 3
21 ---第六次调用---
22 1
23 2
24 3

  从上述的周转结果能够:

  从以上的运作结果能够:

  (1)调用有暗中同意值的函数时,即使没有点名实参,那么形参将使用小编的暗中同意值,反之,则动用钦定的实参。

  (1)调用有暗中认可值的函数时,假如没有点名实参,那么形参将使用自家的暗中认可值,反之,则运用钦点的实参。

  (2)当混合使用主要字实参和岗位实参时,地点实参只可以放在重点字实参的前头。

  (2)当混合使用主要字实参和任务实参时,地方实参只好放在主要字实参的前面。

 

 

5.  返回值

5.  返回值

5.1 再次来到值的定义

5.1 重回值的定义

  重返值是指函数重回的值,是函数首要的组成都部队分。由于函数的有史以来在于贯彻程序的有的机能,由此,很多时候我们须求将函数执行后的结果回到给程序再由程序作出进一步的操作。此时,可接纳return 语句将值重返到调用函数的代码行。

  再次来到值是指函数重返的值,是函数首要的组成都部队分。由于函数的一向在于达成程序的某个机能,由此,很多时候大家供给将函数执行后的结果回到给程序再由程序作出更为的操作。此时,可选取return 语句将值再次来到到调用函数的代码行。

 

 

5.2 重回值的功能

5.2 重返值的职能

  重临值功能:能够将顺序的超越47%千斤工作移到函数中去做到,从而简化主程序。

  再次来到值功能:能够将次第的绝半数以上辛劳工作移到函数中去做到,从而简化主程序。

 

 

5.3 再次回到1个简短值

5.3 重临一个简便值

  例如,创制四个函数接受多少个参数,然后回来最大者。

  例如,创立一个函数接受七个参数,然后回来最大者。

  代码:

  代码:

 1 def test_func(x,y):
 2     """判断数字大小,返回最大值"""
 3     if x > y:
 4         max_num = x
 5     else:
 6         max_num = y
 7     return max_num
 8 
 9 max_number = test_func(11,18)
10 print("The maximum is",max_number,".")
 1 def test_func(x,y):
 2     """判断数字大小,返回最大值"""
 3     if x > y:
 4         max_num = x
 5     else:
 6         max_num = y
 7     return max_num
 8 
 9 max_number = test_func(11,18)
10 print("The maximum is",max_number,".")

 

 

  运营结果:

  运转结果:

The maximum is 18 .
The maximum is 18 .

 

 

5.4 再次来到三个列表

5.4 重返三个列表

  例如,创立三个函数接受多少个列表,然后将奇数组成叁个新的列表作为重回值。

  例如,创立一个函数接受八个列表,然后将奇数组成1个新的列表作为再次来到值。

  代码:

  代码:

 1 def test_func(list_nums):
 2     """接收一个列表,返回奇数组成的列表"""
 3     list_nums_new = []
 4     list_nums_bak = list_nums[:]
 5     while list_nums_bak:
 6         list_num = list_nums_bak.pop()
 7         if list_num % 2 == 0 :
 8             pass
 9         else:
10             list_nums_new.append(list_num)
11     return list_nums_new
12 
13 list = test_func([0,1,2,3,4,5,6,7,8,9])
14 print(list)
 1 def test_func(list_nums):
 2     """接收一个列表,返回奇数组成的列表"""
 3     list_nums_new = []
 4     list_nums_bak = list_nums[:]
 5     while list_nums_bak:
 6         list_num = list_nums_bak.pop()
 7         if list_num % 2 == 0 :
 8             pass
 9         else:
10             list_nums_new.append(list_num)
11     return list_nums_new
12 
13 list = test_func([0,1,2,3,4,5,6,7,8,9])
14 print(list)

  说明:

  说明:

  第②行,创立八个空的列表。

  第叁行,成立八个空的列表。

  第四行,创建一个经受到的列表的副本。

  第6行,创设二个承受到的列表的副本。

  第6行,使用while循环列表副本。

  第陆行,使用while循环列表副本。

  第④行,每一回从列表副本中单出最终的要素,将其赋值给变量list_num。

  第伍行,每一遍从列表副本中单出最后的要素,将其赋值给变量list_num。

  第7~10行,判断弹出的成分是还是不是为偶数,要是是,则跳过,反之,则将其增添到开创的空驶列车表list_nums_new中。

  第7~10行,判断弹出的因素是还是不是为偶数,即使是,则跳过,反之,则将其扩张到成立的空驶列车表list_nums_new中。

  第壹1行,用return语句重回奇数组成的新列表list_nums_new。

  第三1行,用return语句再次来到奇数组成的新列表list_nums_new。

  第贰3行,调用函数test_func(),将其重回值赋值给变量list。

  第二3行,调用函数test_func(),将其重临值赋值给变量list。

  第叁4行,打字与印刷再次回到的列表。

  第叁4行,打字与印刷重返的列表。

 

 

  运营结果:

  运营结果:

[9, 7, 5, 3, 1]
[9, 7, 5, 3, 1]

 

 

5.5 再次回到一个字典

5.5 重临3个字典

   例如,创设3个函数接受一个字典,然后将值的奇数的键-值对组合三个新字典再次来到。

   例如,创造一个函数接受2个字典,然后将值的奇数的键-值对构成四个新字典重返。

  代码:

  代码:

 1 def test_func(dict_nums):
 2     """接收一个列表,返回值为奇数组成的字典"""
 3     dict_nums_new = {}
 4     for key,vlaue in dict_nums.items():
 5         if vlaue % 2 == 0 :
 6             pass
 7         else:
 8             dict_nums_new[key] = vlaue
 9     return dict_nums_new
10 
11 dict = test_func({'a':0,'b':1,'c':2,'d':3,'e':4,'f':5})
12 print(dict)
 1 def test_func(dict_nums):
 2     """接收一个列表,返回值为奇数组成的字典"""
 3     dict_nums_new = {}
 4     for key,vlaue in dict_nums.items():
 5         if vlaue % 2 == 0 :
 6             pass
 7         else:
 8             dict_nums_new[key] = vlaue
 9     return dict_nums_new
10 
11 dict = test_func({'a':0,'b':1,'c':2,'d':3,'e':4,'f':5})
12 print(dict)

  说明:

  说明:

  第1行,创立2个空字典dict_nums_new。

  第一行,创立多个空字典dict_nums_new。

  第4~8行,使用for语句循环接受的字典,然后判断该值是还是不是为奇数,借使不是,则跳过;反之,则增添到空字典中。

  第4~8行,使用for语句循环接受的字典,然后判断该值是或不是为奇数,要是还是不是,则跳过;反之,则增添到空字典中。

  

  

  运营结果:

  运转结果:

{'b': 1, 'd': 3, 'f': 5}
{'b': 1, 'd': 3, 'f': 5}

 

 

6.  将函数存款和储蓄在模块中

6.  将函数存款和储蓄在模块中

  在Python中,模块便是扩展名为.py的文书,它含有要导入到程序中的代码。

  在Python中,模块就是扩张名为.py的文本,它含有要导入到程序中的代码。

  将函数存款和储蓄在模块中,然后再将模块导入到主程序中。那样做的益处有:

  将函数存储在模块中,然后再将模块导入到主程序中。那样做的补益有:

  (1)可隐藏程序代码的底细。

  (1)可隐藏程序代码的细节。

  (2)可在不少分歧的顺序中引用函数。

  (2)可在众多不等的次第中选定函数。

  (3)可与其他程序员共享那一个文件而不是全部程序。

  (3)可与别的程序员共享这几个文件而不是成套程序。

 

 

6.1 模块的导入

6.1 模块的导入

  遵照差异的急需,模块的导入方法也很多。模块的导入方法有:导入整个模块、导入特定的函数、导入模块中的全体函数。并且,我们可使用as来给导入的函数活恐怕模块钦定别称。

  依据不一样的急需,模块的导入方法也很多。模块的导入方法有:导入整个模块、导入特定的函数、导入模块中的全部函数。并且,我们可选拔as来给导入的函数活大概模块钦命别称。

 

 

6.1.1 导入整个模块

6.1.1 导入整个模块

  导入整个模块的措施为:

  导入整个模块的不二法门为:

  import 模块名

  import 模块名

  例如,大家创设将1.6.3中的代码修改一下,值保持函数代码部分,作为多个球任意两数的最大者的模块max_num,然后在一个调用程序test_max.py使用该模块。

  例如,大家成立将1.6.3中的代码修改一下,值保持函数代码部分,作为三个球任意两数的最大者的模块max_num,然后在二个调用程序test_max.py使用该模块。

  模块中的函数:

  模块中的函数:

1 def test_max(x,y):
2     """判断数字大小,返回最大值"""
3     if x > y:
4         max_num = x
5     else:
6         max_num = y
7     return max_num
1 def test_max(x,y):
2     """判断数字大小,返回最大值"""
3     if x > y:
4         max_num = x
5     else:
6         max_num = y
7     return max_num

 

 

  代码:

  代码:

1 import max_num
2 
3 max = max_num.test_max(20,18)
4 print("The max is",max,".")
1 import max_num
2 
3 max = max_num.test_max(20,18)
4 print("The max is",max,".")

    说明:

    说明:

  第二行,使用import导入模块max_num。

  第叁行,使用import导入模块max_num。

 

 

  运营结果:

  运转结果:

The max is 20 .
The max is 20 .

 

 

6.1.2  导入特定的函数

6.1.2  导入特定的函数

  导入特定的函数的法门为:

  导入特定的函数的措施为:

  from 模块名  import  函数名

  from 模块名  import  函数名

  例如,将求任意五个数的最大值和最小值的函数放到二个模块max_min_num的模块中,然后调用在那之中求最小值的函数。

  例如,将求任意多个数的最大值和最小值的函数放到贰个模块max_min_num的模块中,然后调用在那之中求最小值的函数。

  模块:

  模块:

 1 def test_max(x,y):
 2     """判断数字大小,返回最大值"""
 3     if x > y:
 4         max_num = x
 5     else:
 6         max_num = y
 7     return max_num
 8 
 9 def test_min(x,y):
10     """判断数字大小,返回最大值"""
11     if x < y:
12         min_num = x
13     else:
14         min_num = y
15     return min_num
 1 def test_max(x,y):
 2     """判断数字大小,返回最大值"""
 3     if x > y:
 4         max_num = x
 5     else:
 6         max_num = y
 7     return max_num
 8 
 9 def test_min(x,y):
10     """判断数字大小,返回最大值"""
11     if x < y:
12         min_num = x
13     else:
14         min_num = y
15     return min_num

 

 

  代码:

  代码:

1 from max_min_num import test_min
2 
3 min = test_min(20,18)
4 print("The min is",min,".")
1 from max_min_num import test_min
2 
3 min = test_min(20,18)
4 print("The min is",min,".")

 

 

  运营结果:

  运行结果:

The min is 18 .
The min is 18 .

 

 

  假诺必要从有个别模块中程导弹入多少个函数,可采纳逗号分开即可。具体方法如下所示:

  借使急需从有个别模块中程导弹入多个函数,可选用逗号分开即可。具体方法如下所示:

    from 模块名  import 
[函数名1], [函数名2],…, [函数名N]  

    from 模块名  import 
[函数名1], [函数名2],…, [函数名N]  

  例如,调用模块max_min_num中的求最大值和最小值的函数。

  例如,调用模块max_min_num中的求最大值和最小值的函数。

  代码:

  代码:

1 from max_min_num import test_min as t_min,test_max as t_max
2 
3 min = t_min(20,18)
4 print("The min is",min,".")
5 
6 max = t_max(20,26)
7 print("The max is",max,".")
1 from max_min_num import test_min as t_min,test_max as t_max
2 
3 min = t_min(20,18)
4 print("The min is",min,".")
5 
6 max = t_max(20,26)
7 print("The max is",max,".")

  说明:

  说明:

  第1行,从模块max_min_num中导入求最大值和求最小值的函数,并分别给它们取八个别称。

  第1行,从模块max_min_num中程导弹入求最大值和求最小值的函数,并分别给它们取三个小名。

  第①行,使用求最小值的函数的小名调用其方法求最小值。

  第2行,使用求最小值的函数的别名调用其艺术求最小值。

  第4行,使用求最大值的函数的别称调用其艺术求最大值。

  第六行,使用求最大值的函数的外号调用其方式求最大值。

 

 

  运营结果:

  运营结果:

1 The min is 18 .
2 The max is 26 .
1 The min is 18 .
2 The max is 26 .

  从上述结果可见,使用函数小名和利用函数自个儿是同等的功用。

  从上述结果可见,使用函数别称和动用函数自己是均等的功力。

  因而,在导入模块或然模块中的函数时,假如模块名称和函数名称相比较尝,都可对其钦点别称,在调用时,使用其小名即可。

  由此,在导入模块也许模块中的函数时,如果模块名称和函数名称相比尝,都可对其内定别称,在调用时,使用其小名即可。

 

 

6.1.3  导入全数的函数 

6.1.3  导入全体的函数 

  导入全数的函数的法子如下:

  导入全部的函数的主意如下:

  from 模块名 import *

  from 模块名 import *

  例如,调用模块max_min_num中的全部函数。

  例如,调用模块max_min_num中的全体函数。

  代码:

  代码:

1 from max_min_num import *
2 
3 min = test_min(20,18)
4 print("The min is",min,".")
5 
6 max = test_max(20,26)
7 print("The max is",max,".")
1 from max_min_num import *
2 
3 min = test_min(20,18)
4 print("The min is",min,".")
5 
6 max = test_max(20,26)
7 print("The max is",max,".")

 

 

  运营结果:

  运转结果:

1 The min is 18 .
2 The max is 26 .
1 The min is 18 .
2 The max is 26 .

  从以上结果可见,从2个模块中分别导入的特定函数和导入全数函数的不二法门,其调用该函数的机能是不变的。

  从上述结果能够,从3个模块中分头导入的一定函数和导入全部函数的主意,其调用该函数的功用是不变的。

 

 

7.  函数编写规范

7.  函数编写规范

  编写函数时,应服从以下标准:

  编写函数时,应服从以下标准:

  (1)函数名称应负有描述性,且只行使小写字母和下划线来命名。
  (2)每一种函数都应涵盖文档字符串,即简要地演讲该函数的遵守的注释,该注释应紧跟在函数定义后面。
  (3)给形参钦点暗中认可值时,等号两边不要有空格。
  (4)对于函数调用中的关键字实参,也应遵照等号两边不要有空格的预订。
  (5)PEP
8(https://www.python.org/dev/peps/pep-0008/)建议代码行的长度不要超过79字符。
  (6)借使程序或模块包涵多少个函数,可利用八个空行将附近的函数分开。
  (7)全部的 import
语句都应放在文件起初,唯一差别的气象是,在文件先导使用了诠释来叙述整个程序。

  (1)函数名称应拥有描述性,且只行使小写字母和下划线来定名。
  (2)各样函数都应涵盖文书档案字符串,即简要地演说该函数的功用的表明,该注释应紧跟在函数定义前边。
  (3)给形参内定默许值时,等号两边不要有空格。
  (4)对于函数调用中的关键字实参,也应依照等号两边不要有空格的预约。
  (5)PEP
8(https://www.python.org/dev/peps/pep-0008/)建议代码行的长度不要超过79字符。
  (6)假诺程序或模块包括多少个函数,可应用四个空行将附近的函数分开。
  (7)全部的 import
语句都应放在文件初叶,唯一差异的图景是,在文书起初使用了诠释来叙述整个程序。