一.  函数的定义 ,Python用def关键字来定义函数

函数

函数

一.  函数的定义  

一.  函数的定义  

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

  在Python中,函数是逻辑结构化和过程化的壹种艺术;是带名字的、协会好的、可重复使用的代码块,用于落成具体的职分。Python用def关键字来定义函数,然后用return关键字重回值,其语法格式如下:

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

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

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

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

    代码块

    代码块

    return [返回值]

    return [返回值]

  

  

  说明:  

  说明:  

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

  (一)函数代码块以 def 关键字初叶,然后空格加函数称谓,圆括号(),以冒号(:)结尾。个中,若函数有参数,则将其坐落括号中,若有多少个参数,则用逗号分开。

  (贰)函数的始末以冒号开端,并且换行后需缩进。

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

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

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

  (四)代码块便是落到实处函数功效的有血有肉的代码。

  (四)代码块便是贯彻函数功用的切实可行的代码。

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

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

 

 

  

  

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

  由此,可回顾的辨证,函数即由函数名称及函数体组成。当中函数体包蕴:文书档案字符串、代码块、重返值。 

  举个例子,定义一个招待用户登入时的问候语的函数。

  举例,定义1个应接用户登6时的问候语的函数。

  代码:

  代码:

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.  函数的作用

  在Python中,函数的的职能首要有叁点:

  在Python中,函数的的功力首要有三点:

  (1)代码重用。在程序中,能够调用已经某些函数,不用再重复写实今世码,故使得代码简洁,并能落成平等的机能。

  (一)代码重用。在先后中,能够调用已经部分函数,不用再重新写落成代码,故使得代码简洁,并能落成平等的效能。

  (2)保持壹致性。在先后中,大概会多处供给落成平等的机能,假设老是都写二回达成,不仅浪费时间,使代吗臃肿,不易读,还恐怕没处落成的功效有差别。但调用同贰个函数,若函数修改了,则别的调用的地点都随着变动了。这样不光切实职能完结保险了平等,还是能够使代码更干净,易读。

  (2)保持壹致性。在先后中,或然会多处索要达成平等的魔法,假设老是都写一次达成,不仅浪费时间,使代吗臃肿,不易读,还恐怕没处落成的作用有距离。但调用同一个函数,若函数修改了,则其余调用的地点都接着变动了。那样不仅实效达成保险了同样,还是可以使代码更洁净,易读。

  (三)可扩大性。当大家须要让能够函数支持我们完结越来越多的职责,咱们只需在函数中编辑落成就可以。若参数有变动,则只需修改调用的地方。

  (3)可扩充性。当大家需求让能够函数帮忙我们做到更多的职分,大家只需在函数中编辑完成就可以。若参数有浮动,则只需修改调用的地点。

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

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

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

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

 

 

3.  参数

3.  参数

  在Python中,参数也分为实参和形参。实参就是调用函数时,在括号中钦点的富有实际值的参数;形参即是在概念函数时,在括号中钦点的变量,无实际值。  当中,实参包含:地方实参、关键字实参、暗中认可值等。

  在Python中,参数也分为实参和形参。实参正是调用函数时,在括号中钦定的享有实际值的参数;形参正是在概念函数时,在括号中钦命的变量,无实际值。  个中,实参包涵:地点实参、关键字实参、私下认可值等。

 

 

四. 函数的调用

四. 函数的调用

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

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

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

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

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

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

 

 

四.一 无参函数的调用

四.一 无参函数的调用

  举个例子,定义3个招待用户登6时的问候语的函数,并调用它。

  比方,定义1个招待用户登录时的问候语的函数,并调用它。

  代码:

  代码:

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

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

  第三行,用文书档案字符串来解说表达该函数的机能。

  第一行,用文书档案字符串来批注表达该函数的功效。

  第三行,打字与印刷一条登入时的应接问候语。

  第3行,打字与印刷一条登陆时的接待问候语。

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

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

  第五行,调用该函数greet_user()。由于该函数未有参数,所以平昔用函数名加括号()调用就能够。

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

 

 

  运转结果:

  运转结果:

  

  

Welcome to login!
Welcome to login!

 

 

肆.2 有参函数的调用

4.2 有参函数的调用

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

  由于函数定义中或者带有多少个形参,因而有参函数的调用也说不定含有多少个实参。
调用函数时,给函数字传送递实参的格局有:地方实参、关键字实参、暗许、还也许是列表和字典等等。

 

 

四.2.一 地点实参

4.二.一 地方实参

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

  由于使用地点实参传参要求实参的逐一与形参的一一一样,因而,在调用函数时,必须将函数调用中的各样实参都关乎到函数定义中的3个形参。即实参的任务必须与形参的任务保持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。

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

 

 

  运维结果:

  运营结果:

Welcome to  Yun !
Welcome to  Yun !

 

 

  (二)有四个肯定个数的地方实参

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

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

  第十行,调用函数test_func(),并按任务内定其参数值,即x=一,y=2,z=3。

  第7行,调用函数test_func(),并按岗位钦赐其参数值,即x=1,y=2,z=三。

  第3一行,调用函数test_func(),并按职分钦点其参数值,即x=四,y=伍,z=陆。

  第1壹行,调用函数test_func(),并按任务钦定其参数值,即x=四,y=5,z=陆。

 

 

  运转结果:

  运营结果:

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)有几个不认同个数的地方实参

  (三)有四个不认账个数的任务实参

  有时候,我们鞭长莫及事先明白函数必要接受多少个职位实参,由此,大家能够使用
‘*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”表示形参个数不鲜明。

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

  第三行,将选用到的参数以列表的情势出口。

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

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

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

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

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

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

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

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

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

  第壹四行,调用函数test_func(),提供三个实参:壹、2、叁、肆。

  第二4行,调用函数test_func(),提供多个实参:1、2、叁、四。

  第三6行,调用函数test_func(),提供几个实参:一、二、叁、四、伍。

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

 

 

  运转结果:

  运营结果:

 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”作为形参,然后会把每回调用时传出的职位实参值以列表的款型当做参数字传送递。那个地点实参能够没有人值,或然有四个值。

 

 

四.2.二  关键字实参

④.二.二  关键字实参

  关键字实参是传递给函数的名号-值对,即各类实参都由变量和值组成。由于能够直接将实参中名称和值关联起来,因而向函数字传送递实参时就不会搅乱,调用函数时不仅不用思虑实参的依次,仍可以明白的提议函数调用中各样值的用途。可是,使用重要那参数时,必须标准的钦赐函数定义中的形参名。

  关键字实参是传递给函数的称呼-值对,即各类实参都由变量和值组成。由于能够直接将实参中名称和值关联起来,由此向函数字传送递实参时就不会搅乱,调用函数时不仅不要思量实参的逐条,还能够知道的提议函数调用中每一个值的用处。不过,使用主要这参数时,必须准确的内定函数定义中的形参名。

  举例,大家运用重要字实参来调用一.四.二.1中定义的函数。

  举例,大家利用首要字实参来调用一.肆.二.1中定义的函数。

  (一)唯有一个第2字参数

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

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

 

 

  运营结果:

  运营结果:

Welcome to  Yun !
Welcome to  Yun !

  从上述运营结果可见,跟1.四.一.第11中学的1致。

  从上述运转结果可见,跟一.4.壹.第11中学的一致。

  

  

  (贰)有四个规定个数的根本字参数

  (二)有五个规定个数的最主要字参数

  代码:

  代码:

 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

  从上述运转结果能够,与壹.四.一.第11中学的1致。

  从上述运转结果可见,与1.四.一.第11中学的1致。

  

  

  那么,借使大家不内定实参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

  从以上的运营结果可知:

  从上述的周转结果可见:

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

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

  (贰)错误提醒未建议第三壹行的错,那是因为Python时解释型语言,但日前的代码出错了,若没对丰富进行拍卖,那么就结束,不再运营后续的代码。

  (二)错误提醒未提议第贰1行的错,那是因为Python时解释型语言,但前面包车型大巴代码出错了,若没对丰盛实行拍卖,那么就停下,不再运营后续的代码。

 

 

  (三)有三个不明确个数的严重性字参数

  (叁)有三个不分明个数的要紧字参数

  有时候,我们鞭长莫及事先理解函数需求接受几个主要字实参,由此,大家能够动用‘**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”作为形参。

  第3行,大家用关键字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解释器能够科学的解读地点实参。

  使用暗许值的利益:

  使用私下认可值的补益:

  (一)可简化函数调用。

  (一)可简化函数调用。

  (二)可通晓提出函数的特出用法

  (二)可了解建议函数的超人用法

  比方,创制四个函数具备多少个形参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

  从以上的运营结果可见:

  从上述的周转结果能够:

  (一)调用有默许值的函数时,假如没有点名实参,那么形参将使用自家的私下认可值,反之,则动用内定的实参。

  (一)调用有默许值的函数时,如若未有点名实参,那么形参将使用小编的默许值,反之,则选取钦点的实参。

  (二)当混合使用主要字实参和地方实参时,位置实参只可以放在珍视字实参的先头。

  (二)当混合使用首要字实参和任务实参时,地方实参只可以放在主要字实参的前方。

 

 

5.  返回值

5.  返回值

伍.一 再次回到值的概念

伍.1 再次回到值的定义

  重返值是指函数再次来到的值,是函数首要的组成都部队分。由于函数的有史以来在于落成程序的局地机能,因而,繁多时候我们须要将函数推行后的结果回到给程序再由程序作出进一步的操作。此时,可使用
return 语句将值重临到调用函数的代码行。

  重回值是指函数再次来到的值,是函数主要的组成都部队分。由于函数的有史以来在于完结程序的一对机能,由此,诸多时候大家须要将函数试行后的结果再次回到给程序再由程序作出进一步的操作。此时,可应用
return 语句将值重返到调用函数的代码行。

 

 

万博官网登录,5.二 重临值的功能

五.二 再次来到值的功力

  重回值成效:能够将次第的繁多艰难职业移到函数中去做到,从而简化主程序。

  重临值成效:能够将顺序的大部艰辛专门的学业移到函数中去做到,从而简化主程序。

 

 

伍.三 重返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.四 再次回到一个列表

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

  举例,创制3个函数接受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)

  说明:

  说明:

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

  第二行,创立三个空的列表。

  第陆行,创设一个收受到的列表的别本。

  第四行,成立叁个接受到的列表的别本。

  第四行,使用while循环列表别本。

  第六行,使用while循环列表别本。

  第四行,每一回从列表别本中单出终极的元素,将其赋值给变量list_num。

  第伍行,每便从列表别本中单出终极的因素,将其赋值给变量list_num。

  第7~十行,推断弹出的因素是或不是为偶数,假设是,则跳过,反之,则将其扩大到创制的空驶列车表list_nums_new中。

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

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

  第贰一行,用return语句再次回到奇数组成的新列表list_nums_new。

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

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

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

  第二四行,打字与印刷再次来到的列表。

 

 

  运维结果:

  运转结果:

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

 

 

5.伍 重临一个字典

5.伍 再次回到多少个字典

   举例,创设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)

  说明:

  说明:

  第3行,创制贰个空字典dict_nums_new。

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

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

  第4~捌行,使用for语句循环接受的字典,然后判定该值是或不是为奇数,假设不是,则跳过;反之,则扩展到空字典中。

  

  

  运营结果:

  运维结果:

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

 

 

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

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

  在Python中,模块正是扩大名字为.py的公文,它包罗要导入到程序中的代码。

  在Python中,模块正是扩展名称为.py的文件,它涵盖要导入到程序中的代码。

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

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

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

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

  (2)可在无尽见仁见智的程序中收音和录音函数。

  (贰)可在不少两样的主次中选拔函数。

  (3)可与任何技士共享那个文件而不是整整程序。

  (三)可与其他程序猿共享这几个文件而不是百分百程序。

 

 

6.一 模块的导入

陆.壹 模块的导入

  依照不一致的内需,模块的导入方法也多数。模块的导入方法有:导入整个模块、导入特定的函数、导入模块中的全部函数。并且,大家可应用as来给导入的函数活只怕模块内定外号。

  依据分歧的内需,模块的导入方法也大多。模块的导入方法有:导入整个模块、导入特定的函数、导入模块中的全部函数。并且,大家可使用as来给导入的函数活大概模块钦定外号。

 

 

六.壹.1 导入整个模块

六.壹.1 导入整个模块

  导入整个模块的诀窍为:

  导入整个模块的艺术为:

  import 模块名

  import 模块名

  比如,我们创设将一.陆.三中的代码修改一下,值保持函数代码部分,作为1个球放四两数的最大者的模块max_num,然后在三个调用程序test_max.py使用该模块。

  举个例子,大家制造将一.六.三中的代码修改一下,值保持函数代码部分,作为1个球任性两数的最大者的模块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。

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

 

 

  运转结果:

  运营结果:

The max is 20 .
The max is 20 .

 

 

陆.一.2  导入特定的函数

6.一.二  导入特定的函数

  导入特定的函数的不二诀窍为:

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

  from 模块名  import  函数名

  from 模块名  import  函数名

  比如,将求肆意五个数的最大值和最小值的函数放到2个模块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中导入求最大值和求最小值的函数,并各自给它们取叁个外号。

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

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

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

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

 

 

  运维结果:

  运维结果:

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

  从上述结果能够,使用函数外号和利用函数本人是均等的效应。

  从以上结果能够,使用函数小名和选拔函数本人是一样的机能。

  由此,在导入模块恐怕模块中的函数时,借使模块名称和函数名称相比较尝,都可对其内定别称,在调用时,使用其小名就可以。

  由此,在导入模块或许模块中的函数时,假设模块名称和函数名称相比尝,都可对其钦点外号,在调用时,使用其别称就能够。

 

 

陆.一.三  导入全体的函数 

6.1.叁  导入全数的函数 

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

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

  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个模块中分别导入的特定函数和导入全数函数的点子,其调用该函数的功用是不改变的。

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

 

 

七.  函数编写标准

柒.  函数编写标准

  编写函数时,应根据以下规范:

  编写函数时,应依据以下规范:

  (一)函数名称应具备描述性,且只利用小写字母和下划线来定名。
  (2)各类函数都应包蕴文书档案字符串,即简要地解说该函数的功能的批注,该注释应紧跟在函数定义前边。
  (三)给形参钦定暗许值时,等号两边不要有空格。
  (4)对于函数调用中的关键字实参,也应服从等号两边不要有空格的约定。
  (5)PEP
8(https://www.python.org/dev/peps/pep-0008/)建议代码行的长度不要超过79字符。
  (6)如果程序或模块包蕴七个函数,可接纳多少个空行将紧邻的函数分开。
  (七)全数的 import
语句都应放在文件初始,唯一不一样的动静是,在文书早先使用了解说来描述整个程序。

  (1)函数名称应持有描述性,且只使用小写字母和下划线来命名。
  (二)种种函数都应包罗文书档案字符串,即简要地演说该函数的作用的笺注,该注释应紧跟在函数定义前面。
  (三)给形参钦定默许值时,等号两边不要有空格。
  (4)对于函数调用中的关键字实参,也应遵照等号两边不要有空格的预订。
  (5)PEP
8(https://www.python.org/dev/peps/pep-0008/)建议代码行的长度不要超过79字符。
  (6)若是程序或模块包括多个函数,可应用多个空行将周边的函数分开。
  (7)全数的 import
语句都应放在文件初叶,唯1不相同的气象是,在文书最先使用了解说来叙述整个程序。

 

 

 

 

 

 

 

 

 

 

 

 

  

  

  

  

  

  

 

 

  

  

相关文章