函数

函数

函数

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个欢迎用户登录时的问候语的函数。

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

  代码:

  代码:

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回完毕,不仅浪费时间,使代吗臃肿,不易读,还只怕没处实现的功力分歧。但调用同3个函数,若函数修改了,则其它调用的地方都跟着变动了。那样不仅切实际效果能实现保障了平等,还是能使代码更整洁,易读。

  (2)保持一致性。在先后中,恐怕会多处索要达成平等的职能,就算每一趟都写叁次完成,不仅浪费时间,使代吗臃肿,不易读,还大概没处完毕的功用有差距。但调用同一个函数,若函数修改了,则此外调用的地方都跟着变动了。那样不光切实功用落成保证了同一,仍可以够使代码更清洁,易读。

  (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 关键字定义三个函数greet_user(),并以冒号结尾。

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

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

  第贰行,用文书档案字符串来诠释表明该函数的职能。

  第三行,打印一条登录时的欢迎问候语。

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

  第六行,用关键字return 结束函数。

  第5行,用关键字return 甘休函数。

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

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

 

 

  运转结果:

  运维结果:

  

  

Welcome to login!
Welcome to login!

 

 

4.2 有参函数的调用

4.2 有参函数的调用

  由于函数定义中大概带有多少个形参,由此有参函数的调用也说不定含有四个实参。
调用函数时,给函数字传送递实参的法门有:地点实参、关键字实参、私下认可、还或许是列表和字典等等。

  由于函数定义中恐怕带有三个形参,由此有参函数的调用也说不定含有八个实参。
调用函数时,给函数字传送递实参的点子有:地点实参、关键字实参、默许、还或然是列表和字典等等。

 

 

4.2.1 地点实参

4.2.1 地方实参

  由于应用地点实参传参供给实参的顺序与形参的相继相同,由此,在调用函数时,必须将函数调用中的各种实参都事关到函数定义中的3个形参。即实参的地点必须与形参的地点保持一致。

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

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

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

  代码:

  代码:

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")

  说明:

  说明:

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

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

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

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

 

 

  运维结果:

  运维结果:

Welcome to  Yun !
Welcome to  Yun !

 

 

  (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(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()。

  第壹行,用def关键字定义1个具有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”表示形参个数不分明。

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

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

  第①行,将接受到的参数以列表的样式出口。

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

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

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

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

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

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

  第二2行,调用函数test_func(),提供三个实参:壹 、② 、3。

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

  第③4行,调用函数test_func(),提供七个实参:① 、② 、叁 、4。

  第①4行,调用函数test_func(),提供多少个实参:壹 、2、叁 、4。

  第②6行,调用函数test_func(),提供四个实参:一 、② 、三 、④ 、5。

  第三6行,调用函数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)只有1个重视字参数

  (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()时,使用主要字实参来给函数字传送值。

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

 

 

  运转结果:

  运维结果:

Welcome to  Yun !
Welcome to  Yun !

  从上述运营结果能够,跟1.4.1.1中的一致。

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

  

  

  (2)有多少个规定个数的第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)错误提示未建议第叁1行的错,那是因为Python时解释型语言,但眼下的代码出错了,若没对特别进行处理,那么就截至,不再运转后续的代码。

  (2)错误提醒未提议第③1行的错,那是因为Python时解释型语言,但前边的代码出错了,若没对尤其举办处理,那么就停下,不再运转后续的代码。

 

 

  (3)有四个不鲜明个数的根本字参数

  (3)有三个不鲜明个数的最主要字参数

  有时候,大家不可能先行明白函数需求承受多少个基本点字实参,由此,我们能够动用‘**kwargs’定义形参,
Python函数会从调用语句中募集任意数量的第2字实参实行拍卖。

  有时候,大家不可能事先明白函数须求承受多少个至关首要字实参,由此,我们得以采用‘**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)

  说明:

  说明:

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

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

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

  第3行,打字与印刷该形参”**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)可领略提出函数的一流用法

  例如,创造1个函数具有多个形参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 再次来到值的机能

  重返值功能:能够将顺序的大部劳累工作移到函数中去做到,从而简化主程序。

  再次回到值效率:能够将先后的绝半数以上勤奋工作移到函数中去做到,从而简化主程序。

 

 

5.3 重临1个简短值

5.3 重回1个简易值

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

  例如,创立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 重返3个列表

5.4 再次来到二个列表

  例如,创造2个函数接受二个列表,然后将奇数组成四个新的列表作为再次来到值。

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

  代码:

  代码:

 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)

  说明:

  说明:

  第二行,创设二个空的列表。

  第2行,成立二个空的列表。

  第四行,创立1个经受到的列表的副本。

  第肆行,成立多少个收受到的列表的副本。

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

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

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

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

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

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

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

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

  第①3行,调用函数test_func(),将其再次来到值赋值给变量list。

  第③3行,调用函数test_func(),将其再次回到值赋值给变量list。

  第壹4行,打字与印刷返回的列表。

  第24行,打印重回的列表。

 

 

  运营结果:

  运营结果:

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

 

 

5.5 再次来到1个字典

5.5 重返2个字典

   例如,创设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行,制造3个空字典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中的代码修改一下,值保持函数代码部分,作为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,".")

    说明:

    说明:

  第2行,使用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的模块中,然后调用个中求最小值的函数。

  例如,将求任意五个数的最大值和最小值的函数放到1个模块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中程导弹入求最大值和求最小值的函数,并各自给它们取四个别名。

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

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

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

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

 

 

  运转结果:

  运营结果:

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 .

  从以上结果能够,从二个模块中分别导入的一定函数和导入全体函数的格局,其调用该函数的意义是不变的。

  从以上结果能够,从贰个模块中分别导入的一定函数和导入全数函数的法门,其调用该函数的效能是不变的。

 

 

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
语句都应放在文件先河,唯一分化的图景是,在文书起头使用了诠释来描述整个程序。

 

 

 

 

 

 

 

 

 

 

 

 

  

  

  

  

  

  

 

 

  

  

相关文章