Python用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)保持一致性。在程序中,可能会见多处需要实现平等的效益,如果老是都勾一全勤实现,不仅浪费时间,使代表吗臃肿,不易读,还可能无处实现的机能产生差距。但调用同一个函数,若函数修改了,则其它调用的地方都随着变动了。这样不但实际职能实现保了同,还能要代码更卫生,易读。

  (2)保持一致性。在次中,可能会见多处需要实现均等的效应,如果老是都勾一尽实现,不仅浪费时间,使代表吗臃肿,不易读,还可能没处实现的法力发生反差。但调用同一个函数,若函数修改了,则其它调用的地方都接着变动了。这样不仅实际效果实现保障了一致,还能够而代码更清新,易读。

  (3)可扩展性。当我们用给能够函数帮助我们做到还多之任务,我们只需要在函数中修实现即可。若参数有转移,则单独需要修改调用的地方。

  (3)可扩展性。当我们用为能够函数帮助我们成功还多之任务,我们只是需要以函数中编辑实现即可。若参数有生成,则就需要修改调用的地方。

  (4)使用函数让程序还易看。

  (4)使用函数让程序还便于看。

  (5)函数让代码更易测试与调剂。

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

 

 

3.  参数

3.  参数

  于Python中,参数为分为实参和形参。实参就是调用函数时,在括号中指定的具备实际值的参数;形参就是当概念函数时,在括号中指定的变量,无实际值。  其中,实参包括:位置实参、关键字实参、默认值等。

  以Python中,参数为分为实参和形参。实参就是调用函数时,在括号中指定的所有实际值的参数;形参就是在概念函数时,在括号中指定的变量,无实际值。  其中,实参包括:位置实参、关键字实参、默认值等。

 

 

4. 函数的调用

4. 函数的调用

  函数的调用很粗略,即用函数名称加圆括哀号(),若有参数,则拿其参数放在括号中,若有差不多个参数,则以那个放括号中,并因而逗号分开。具体语法格式如下所示:

  函数的调用很粗略,即用函数名称加圆括声泪俱下(),若发生参数,则将该参数放在括号中,若发生多只参数,则用那放置括号中,并就此逗号分开。具体语法格式如下所示:

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

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

  因此,函数调用存在个别种植情况,一种是无参函数调用;一栽是发参函数调用。

  因此,函数调用存在个别种情景,一栽是无参函数调用;一种植是生参函数调用。

 

 

4.1 无参函数的调用

4.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()

  说明:

  说明:

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

  第1尽,用def 关键字定义一个函数greet_user(),并因冒号结尾。

  第2履行,用文档字符串来诠释说明该函数的效应。

  第2实施,用文档字符串来诠释说明该函数的法力。

  第3执,打印一长条登录时的接问候语。

  第3行,打印一漫长登录时的欢迎问候语。

  第4推行,用要字return 结束函数。

  第4执行,用要字return 结束函数。

  第6实施,调用该函数greet_user()。由于该函数没有参数,所以一直用函数称作加括号()调用即可。

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

 

 

  运行结果:

  运行结果:

  

  

Welcome to login!
Welcome to login!

 

 

4.2 有参函数的调用

4.2 有参函数的调用

  由于函数定义着恐含多独形参,因此发生参函数的调用也说不定含有多个实参。
调用函数时,给函数传递实参的点子有:位置实参、关键字实参、默认、还可能是列表和字典等等。

  由于函数定义着或带有多个形参,因此发生参函数的调用也或包含多单实参。
调用函数时,给函数传递实参的艺术发出:位置实参、关键字实参、默认、还可能是列表和字典等等。

 

 

4.2.1 位置实参

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

  说明:

  说明:

  第2尽,用def
关键字定义一个涵盖形参username的函数greet_user(),并以冒号结尾。

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

  第8履,调用有参数的函数greet_user(),把实参”Yun”
的价传为形参username。

  第8实行,调用有参数的函数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)

  说明:

  说明:

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

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

  第9实行,调用函数test_func(),并仍岗位指定其参数值,即x=1,y=2,z=3。

  第9实施,调用函数test_func(),并论岗位指定其参数值,即x=1,y=2,z=3。

  第11尽,调用函数test_func(),并随职务指定其参数值,即x=4,y=5,z=6。

  第11推行,调用函数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)

  说明:

  说明:

  第1实践,用要字def定义了一个参数个数不确定的函数test_func(),其中“*args”表示形参个数不确定。

  第1实行,用要字def定义了一个参数个数不确定的函数test_func(),其中“*args”表示形参个数不确定。

  第2实施,将接受及的参数为列表的样式出口。

  第2履,将吸纳及之参数为列表的款式出口。

  第6尽,调用函数test_func(),不提供其他的参值。

  第6推行,调用函数test_func(),不提供其他的参值。

  第8执行,调用函数test_func(),提供一个实参:1。

  第8实践,调用函数test_func(),提供一个实参:1。

  第10执,调用函数test_func(),提供零星个实参:1、2。

  第10实行,调用函数test_func(),提供零星只实参:1、2。

  第12履行,调用函数test_func(),提供三单实参:1、2、3。

  第12实践,调用函数test_func(),提供三独实参:1、2、3。

  第14执,调用函数test_func(),提供四只实参:1、2、3、4。

  第14实行,调用函数test_func(),提供四单实参:1、2、3、4。

  第16执行,调用函数test_func(),提供五独实参:1、2、3、4、5。

  第16履,调用函数test_func(),提供五只实参: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)
 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.1面临定义的函数。

  例如,我们采取要字实参来调用1.4.2.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")

  说明:

  说明:

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

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

 

 

  运行结果:

  运行结果:

Welcome to  Yun !
Welcome to  Yun !

  从以上运行结果可知,跟1.4.1.1遇之同一。

  从以上运行结果可知,跟1.4.1.1饱受之一律。

  

  

  (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.1受的同。

  从以上运行结果会,与1.4.1.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

  从上述之周转结果可知:

  从以上之运行结果能够:

  (1)当我们因而要字参数调用函数时,必须每个实参都得点名其关联的显得参名。

  (1)当我们为此要字参数调用函数时,必须每个实参都亟待点名其关联的显示参名。

  (2)错误提示无指出第11行之掠,这是因Python时解释型语言,但面前的代码出错了,若没针对生进行处理,那么即便停,不再运行后续的代码。

  (2)错误提示无指出第11执之吹拂,这是坐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)

  说明:

  说明:

  第1推行,我们因此要字def定义函数test_func()时,由于未认可函数的形参个数,故用“**kwargs”作为形参。

  第1履,我们就此要字def定义函数test_func()时,由于不承认函数的形参个数,故用“**kwargs”作为形参。

  第2实行,打印该形参”**kwargs”的值。

  第2推行,打印该形参”**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)可知道指出函数的一流用法

  例如,创建一个函数具有三独形参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 返回一个列表

  例如,创建一个函数接受一个列表,然后拿奇数组成一个初的列表作为返回值。

  例如,创建一个函数接受一个列表,然后拿奇数组成一个新的列表作为返回值。

  代码:

  代码:

 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)

  说明:

  说明:

  第3履,创建一个拖欠的列表。

  第3执,创建一个空的列表。

  第4行,创建一个奉到的列表的副本。

  第4履行,创建一个收受到的列表的副本。

  第5实施,使用while循环列表副本。

  第5实践,使用while循环列表副本。

  第6履,每次从列表副本中只是出最终的因素,将那个赋值给变量list_num。

  第6实行,每次从列表副本中就出最终的素,将那个赋值给变量list_num。

  第7~10执行,判断弹有之元素是否也偶数,如果是,则跳过,反之,则以那个增加至创建的空列表list_nums_new中。

  第7~10尽,判断弹来的素是否为偶数,如果是,则跳过,反之,则用那长及开创的空列表list_nums_new中。

  第11执行,用return语句返回奇数组成的新列表list_nums_new。

  第11实践,用return语句子返回奇数组成的新列表list_nums_new。

  第13执,调用函数test_func(),将那个返回回值赋值给变量list。

  第13行,调用函数test_func(),将该回到回值赋值给变量list。

  第14履行,打印返回的列表。

  第14执行,打印返回的列表。

 

 

  运行结果:

  运行结果:

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

 

 

5.5 返回一个字典

5.5 返回一个字典

   例如,创建一个函数接受一个字典,然后将价值的奇数的键-值对组合一个初字典返回。

   例如,创建一个函数接受一个字典,然后将价值的奇数的键-值对组合一个初字典返回。

  代码:

  代码:

 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。

  第3执,创建一个空字典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,".")

    说明:

    说明:

  第1实施,使用import导入模块max_num。

  第1实践,使用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中导入求最酷价值与伸手最好小值的函数,并分别叫它赢得一个号。

  第3尽,使用要最好小值的函数的别名调用其方式要最好小价。

  第3推行,使用要最好小值的函数的别名调用该艺术要最好小值。

  第6实践,使用要最好要命价值的函数的别名调用该法要最好老价值。

  第6尽,使用要最好酷价值的函数的别名调用那方法要最好充分价值。

 

 

  运行结果:

  运行结果:

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
语词都承诺在文件开始,唯一不同的气象是,在文件开始用了诠释来叙述整个程序。