1.  函数的定义 ,1.  函数的定义 

函数

函数

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 无参函数的调用

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

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

  代码:

  代码:

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(),并以冒号结尾。

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

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

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

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

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

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

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

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

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

 

 

  运转结果:

  运行结果:

  

  

Welcome to login!
Welcome to login!

 

 

4.2 有参函数的调用

4.2 有参函数的调用

  由于函数定义中也许包罗三个形参,由此有参函数的调用也或者带有多少个实参。
调用函数时,给函数字传送递实参的办法有:地点实参、关键字实参、私下认可、还可能是列表和字典等等。

  由于函数定义中或然包罗多个形参,因而有参函数的调用也或然带有三个实参。
调用函数时,给函数字传送递实参的方法有:地点实参、关键字实参、暗许、还可能是列表和字典等等。

 

 

4.2.1 地点实参

4.2.1 位置实参

  由于使用地点实参传参要求实参的次第与形参的次第相同,由此,在调用函数时,必须将函数调用中的各个实参都关系到函数定义中的叁个形参。即实参的职位必须与形参的职位保持一致。

  由于应用地点实参传参供给实参的次第与形参的顺序相同,因而,在调用函数时,必须将函数调用中的每一种实参都关乎到函数定义中的二个形参。即实参的职位必须与形参的职位保持一致。

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

  (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
关键字定义3个带有形参username的函数greet_user(),并以冒号结尾。

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

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

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

 

 

  运维结果:

  运维结果:

Welcome to  Yun !
Welcome to  Yun !

 

 

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

  第3行,用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定义了四个参数个数不显著的函数test_func(),其中“*args”表示形参个数不明确。

  第③行,将吸纳到的参数以列表的款式出口。

  第①行,将收取到的参数以列表的情势出口。

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

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

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

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

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

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

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

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

  第②4行,调用函数test_func(),提供八个实参:一 、贰 、三 、4。

  第一4行,调用函数test_func(),提供八个实参:① 、② 、③ 、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")

  说明:

  说明:

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

  第8行,调用函数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)错误提醒未提出第①1行的错,那是因为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)可明白提出函数的头名用法

  例如,制造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 重临一个简练值

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 重返三个列表

  例如,创立3个函数接受二个列表,然后将奇数组成二个新的列表作为再次回到值。

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

  代码:

  代码:

 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)

  说明:

  说明:

  第二行,创建1个空的列表。

  第③行,创制2个空的列表。

  第伍行,创立多个接受到的列表的副本。

  第5行,成立三个经受到的列表的副本。

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

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

  第5行,每一次从列表副本中单出最终的要素,将其赋值给变量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个字典

   例如,成立三个函数接受一个字典,然后将值的奇数的键-值对构成贰个新字典重返。

   例如,创立2个函数接受三个字典,然后将值的奇数的键-值对组合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)

  说明:

  说明:

  第一行,创设二个空字典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,".")

    说明:

    说明:

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

  例如,将求任意四个数的最大值和最小值的函数放到3个模块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个小名。

  第二行,使用求最小值的函数的别称调用其格局求最小值。

  第①行,使用求最小值的函数的外号调用其情势求最小值。

  第⑤行,使用求最大值的函数的别称调用其方法求最大值。

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

 

 

  运转结果:

  运营结果:

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 .

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

  从上述结果可见,从1个模块中分头导入的一定函数和导入全部函数的艺术,其调用该函数的效率是不变的。

 

 

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
语句都应放在文件开端,唯一分化的状态是,在文件开头使用了诠释来讲述整个程序。

 

 

 

 

 

 

 

 

 

 

 

 

  

  

  

  

  

  

 

 

  

  

相关文章