Python的乐高积木

By admin in 4858.com on 2019年5月4日

目录:

函数

函数

一、定义函数

Python中,定义3个函数要选择def说话,依次写出函数名、括号、括号中的参数(倘使急需参数)和冒号:,然后在缩进块中(缩进四个空格)编写函数体,有重返值的话用return语句再次来到。将先后的超过47%千斤职业移到函数中去完结,从而简化主程序。

1个简便的函数如下:

def test(name):
    """打印问候语"""
    print('hello ' + name)
    return name

用3引号括起来的文书是文书档案字符串,Python用它们生成生成函数的文书档案。

还是能定义空函数:

def test():
    pass

  一、创立和调用函数

一.  函数的定义  

一.  函数的定义  

二、函数的参数

  二、函数的参数

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

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

1、地方参数

调用函数时,Python要将函数调用中的每一种实参关联到函数定义中对应的形参,那种涉及方式叫做地点参数。

def power(x, y):
    """计算x的y次方"""
    return x**y

x、y尽管地点参数,调用power函数时必须传入对应的x、y

>>>power(2, 4)
16

  三、函数的重返值

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

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

二、暗中同意参数

本着上面包车型大巴power函数,若是大繁多情景只需总括平方,就能够运用暗许参数,对power函数做如下修改:

def power(x, y=2):
    return x**y

那时调用power函数时,倘诺不提供y参数,则私下认可总结x的平方:

>>>power(3)
9
>>>power(3, 3)
27

专注暗中同意参数需放在必选参数前面,通过暗中同意参数,能够简化函数的调用。

  肆、课时17课后习题及答案

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

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

三、关键字参数

要害字参数允许你传入任性个key-value,这一个key-value在函数内部自行组装为多个dict。

设若运用首要字参数,不用思考函数调用中的实参顺序难点:

def person(first_name, last_name):
    return first_name + ' ' + last_name

>>>person(first_name='zhang', last_name='san')
zhang san
>>>person(last_name='san', first_name='zhang')
zhang san

除此以外,要传递多少个key-value咋做吧?

def person(**person_info):
    print(person_info)

# 传入多个key-value
>>>person(name='tom', age=10)
{'name': 'tom', 'age': 10}
# 传入dict
>>>info = {'name': 'tom', 'age': 10}
>>>person(**info)
{'name': 'tom', 'age': 10}

能够开采,我们传入的主要性字参数名字未有此外限制,当然能够通过增加条件判定来促成,可是麻烦,命名第一字参数很好的化解了这一个标题:

def person(name, *, age, job):
    print(name, age, job)

瞩目形参列表的星号,星号后的形参正是命名主要字参数,假使传入的显要字参数的名字不在在这之中,就能报错:

>>>person('tom', age=20, job='it')
tom 20 it
>>>person('tom', age=20, job='it', sex='boy')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() got an unexpected keyword argument 'sex'

 

    代码块

    代码块

四、可变参数

顾名思义便是传播的参数个数是可变的,这一点和首要字参数近似。

def get_sum(*numbers):
    return sum(numbers)

# 传入多个实参
>>>get_sum(1, 2, 3, 4)
10
# 传入list
>>>l = [1, 2, 3, 4]
>>>get_sum(*l)
10
# 传入tuple
>>>t = (1, 2, 3, 4])
>>>get_sum(*t)
10

为了使得程序得代码变得不难,就必要把程序分解成相当的小得组成都部队分。有两种艺术能够兑现:函数、对象、模块。

    return [返回值]

    return [返回值]

3、函数的重回值

函数并非总是直接突显输出,它能够管理局地数额,并再次回到三个或一组值。
Python的重临值相比较奇特,除了回到单个基本类型数据、列表、字典、set外,还足以回到四个值,比方:

def test():
    return 1, 2, 3, 4

>>>test()
(1, 2, 3, 4)

可以看到,Python的函数再次来到多值其实就是回到三个tuple。

***********************

  

  

三、函数编写注意事项

  • 应给函数钦命描述性名称,且只在其间使用小写字母和下划线。描述性名称可支持您和别人精通代码想要做哪些。
  • 各样函数都应涵盖简要地解说其效果的注明,该注释应紧跟在函数定义前边,并选择文书档案字符串格式
  • 给形参内定私下认可值时,等号两边不要有空格:

def power(x, y=2):
    return x**y

对于函数调用中的关键字实参,也应遵照那种约定:

>>>power(3, y=4)
  • 要是程序或模块包蕴多少个函数,可应用多个空行将紧邻的函数分开

1、成立和调用函数

  说明:  

  说明:  

***********************

  (1)函数代码块以 def 关键字先导,然后空格加函数称呼,圆括号(),以冒号(:)结尾。个中,若函数有参数,则将其放在括号中,若有三个参数,则用逗号分开。

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

开始接触的BIF就是Python帮大家封装好的函数。在Python中创建三个函数用def关键字。

  (二)函数的剧情以冒号初步,并且换行后需缩进。

  (二)函数的剧情以冒号早先,并且换行后需缩进。

def myFristFunction():
      print("DC love ZWW")
      print("1314520")

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

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

留意:在函数的末尾要增进有的小括号哦。那小括号是少不了的。接下来是函数的调用:

  (肆)代码块正是兑现函数效用的实际的代码。

  (四)代码块正是促成函数功能的求实的代码。

>>> myFristFunction()
DC love ZWW
1314520

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

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

函数的调用和运转搭飞机制:当函数myFristFunction()爆发调用操作的时候,Python会自动往上找到def
myFristFunction()的定义进程,假诺没找到就能报错。然后依此施行该函数所包括的代码块部分(也正是冒号后缩进的那部分内容)。只供给一条语句,就足以兑现函数内的所用作用。

 

 

只要,笔者想把刚刚的剧情打字与印刷二回,小编只必要调用二遍函数即可:

  

  

>>> for each in range(3):
    myFristFunction()


DC love ZWW
1314520
DC love ZWW
1314520
DC love ZWW
1314520

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

  由此,可粗略的求证,函数即由函数名称及函数体组成。在那之中函数体包括:文书档案字符串、代码块、重返值。 

 

  比方,定义八个接待用户登入时的问候语的函数。

  举个例子,定义二个接待用户登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.  函数的功用

2.  函数的功力

>>> def mySecondFunction(name):
    print(name+"爱ZWW")


>>> mySecondFunction("DC")
DC爱ZWW
>>> mySecondFunction("dc")
dc爱ZWW

  在Python中,函数的的功用珍视有三点:

  在Python中,函数的的意义重大有3点:

选用三个参数的时候,只供给用逗号隔离

  (一)代码重用。在先后中,能够调用已经有个别函数,不用再重复写达成代码,故使得代码简洁,并能达成均等的功力。

  (一)代码重用。在先后中,可以调用已经部分函数,不用再重复写完结代码,故使得代码简洁,并能完结均等的法力。

>>> def add(name1,name2):
    print(name1+" love "+name2)


>>> add("DC","ZWW")
DC love ZWW

  (2)保持1致性。在程序中,或然会多处必要贯彻均等的效率,假设老是都写二回落成,不仅浪费时间,使代吗臃肿,不易读,还只怕没处落成的功力不尽相同。但调用同四个函数,若函数修改了,则别的调用的地点都随着变动了。那样不光实际职能达成保险了平等,还是能使代码更干净,易读。

  (2)保持1致性。在程序中,可能会多处索要贯彻均等的功用,固然每一回都写贰遍达成,不仅浪费时间,使代吗臃肿,不易读,还只怕没处达成的成效有出入。但调用同3个函数,若函数修改了,则其余调用的地点都随着变动了。那样不光实际功能完毕有限支撑了同样,还是能够使代码更整洁,易读。

 那到底能够稍微个参数呢?理论上想要多少个就有多少个。

  (三)可扩大性。当大家需求让能够函数援助我们做到更多的职务,我们只需在函数中编辑实现就能够。若参数有浮动,则只需修改调用的地点。

  (3)可扩张性。当我们要求让能够函数协理我们完成愈多的天职,大家只需在函数中编辑达成就能够。若参数有生成,则只需修改调用的地点。

 

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

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

*********************

  (伍)函数让代码更便于测试和调弄整理。

  (伍)函数让代码更易于测试和调护治疗。

三、函数的再次来到值

 

 

*********************

3.  参数

3.  参数

作者们的函数要有再次回到值,只必要在函数中选择关键字return,后边就接着要回来的值。

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

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

>>> def add(name1,name2):
    print(name1+" love "+name2)
    return "LOVE"

>>> add("DC","ZWW")
DC love ZWW
'LOVE'
>>> def add(name1,name2):
    print(name1+" love "+name2)
    return name1

>>> add("DC","ZWW")
DC love ZWW
'DC'

 

 

 

4858.com ,肆. 函数的调用

4. 函数的调用

*******************************

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

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

肆、课时一七课后习题及答案

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

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

*******************************

  因而,函数调用存在三种状态,壹种是无参函数调用;一种是有参函数调用。

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

测试题:

 

 

 

四.一 无参函数的调用

四.壹 无参函数的调用

0. 你有听别人讲过DKugaY吗?  

  比方,定义一个应接用户登六时的问候语的函数,并调用它。

  比方,定义二个应接用户登陆时的问候语的函数,并调用它。

答:DQX56Y是技术员们公认的指引规范:Don’t
Repeat Yourself. 
赶快武装你的想念呢,拿起函数,不要再去重新拷贝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()

一.
都以重新壹段代码,为何本身要使用函数(而不使用简易的正片黏贴)呢?

  说明:

  说明:

答:

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

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

利用函数:

  第贰行,用文档字符串来疏解表达该函数的意义。

  第1行,用文书档案字符串来讲解表明该函数的功效。

0) 可以降低代码量(调用函数只需要一行,而拷贝黏贴需要N倍代码)
1) 可以降低维护成本(函数只需修改def部分内容,而拷贝黏贴则需要每一处出现的地方都作修改)
2) 使序更容易阅读(没有人会希望看到一个程序重复一万行“I love FishC.com”)

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

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

 

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

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

二. 函数能够有八个参数吗?     

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

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

答:能够的,理论上您想要有多少个就足以有多少个,只可是就算函数的参数过多,在调用的时候出错的机率就能够大大升高,由此写那么些函数的程序猿也会被相应的问讯祖宗,所以,尽量精简吧,在Python的社会风气里,精简才是王道!

 

 

 

  运维结果:

  运转结果:

3. 开立函数使用什么主要字,要注意哪些?    

  

  

答:使用“def”关键字,要专注函数名前面要增多小括号“()”,然后小括号前面是冒号“:”,然后缩进部分均属于函数体的始末,比方:

Welcome to login!
Welcome to login!
def MyFun():
    # 我是函数体
    # 我也是函数体
    # 我们都属于函数MyFun()

# 噢,我不属于MyFun()函数的了

 

 

 

4.2 有参函数的调用

Python的乐高积木。四.贰 有参函数的调用

4. 请问那些函数有个别许个参数?

  由于函数定义中只怕含有八个形参,因而有参函数的调用也恐怕包罗七个实参。
调用函数时,给函数传递实参的不2法门有:地方实参、关键字实参、私下认可、还或然是列表和字典等等。

  由于函数定义中大概包罗多个形参,由此有参函数的调用也恐怕带有多少个实参。
调用函数时,给函数字传送递实参的艺术有:地点实参、关键字实参、暗中同意、还可能是列表和字典等等。

def MyFun((x, y), (a, b)):
    return x * y - a * b

 

 

答:即使您回复多个,那么恭喜你错啦,答案是0,因为类似于那样的写法是百无一是的!

四.二.一 地点实参

4.二.1 地点实参

大家分析下,函数的参数供给的是变量,而那边您试图用“元祖”的样式来传递是不可行的。
     
自个儿想你若是那样写,你应该是要抒发这么个乐趣:

  由于应用地方实参传参要求实参的顺序与形参的顺序同样,由此,在调用函数时,必须将函数调用中的每种实参都关涉到函数定义中的三个形参。即实参的职位必须与形参的地点保持一致。

  由于应用地点实参传参必要实参的顺序与形参的顺序同样,因而,在调用函数时,必须将函数调用中的各类实参都关系到函数定义中的二个形参。即实参的职位必须与形参的地方保持壹致。

>>> def MyFun(x, y):
        return x[0] * x[1] - y[0] * y[1]

>>> MyFun((3, 4), (1, 2))
10

  (壹)唯有三个职位实参
  比如,定义一个招待用户登陆时的问候语的函数,依据不一样用户打字与印刷一条有关的问候语,并调用它。

  (一)唯有1个职位实参
  举个例子,定义一个迎接用户登六时的问候语的函数,依照不一样用户打字与印刷一条相关的问候语,并调用它。

 

  代码:

  代码:

5. 请问调用以下这几个函数会打字与印刷什么内容?

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 hello():
        print('Hello World!')
        return
        print('Welcome To FishC.com!')

  说明:

  说明:

 答:会打印:

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

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

>>> hello()
Hello World!

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

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

因为当Python实践到return语句的时候,Python以为函数到此结束,需求再次回到了(纵然尚未任何再次来到值)。

 

 

动动手: 

  运营结果:

  运转结果:

0. 编辑一个函数power()模拟内建函数pow(),即power(x,
y)为总括并重返x的y次幂的值。

Welcome to  Yun !
Welcome to  Yun !

解:

 

 

def power(x, y):
    result = 1

    for i in range(y):
        result *= x

    return result

print(power(2, 3))

  (贰)有三个确定个数的职位实参

  (二)有八个料定个数的岗位实参

 

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

  举个例子,定义叁个有七个形参的函数,并调用它。

一. 编纂一个函数,利用欧几里得算法(脑补链接)求最大公约数,比如gcd(x,
y)再次回到值为参数x和参数y的最大公约数。

  代码:

  代码:

解:

 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 gcd(x, y):
    while y:
        t = x % y
        x = y
        y = t

    return x

print(gcd(4, 6))

  说明:

  说明:

 

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

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

二.
编写制定三个将10进制调换为贰进制的函数,须要使用“除二取余”(脑补链接)的点子,结果与调用bin()同样重回字符串方式。

  第八行,调用函数test_func(),并按岗位内定其参数值,即x=一,y=二,z=三。

  第八行,调用函数test_func(),并按义务钦命其参数值,即x=1,y=二,z=三。

解:

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

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

def Dec2Bin(dec):
    temp = []
    result = ''

    while dec:
        quo = dec % 2
        dec = dec // 2
        temp.append(quo)

    while temp:
        result += str(temp.pop())

    return result

print(Dec2Bin(62))

 

 

 

  运营结果:

  运转结果:

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

  从以上的运作结果能够,钦赐的职分实参的值不相同,其函数重回的值也分裂。

  从以上的周转结果可知,钦定的职分实参的值不一样,其函数重临的值也分化。

 

 

  (三)有几个不承认个数的职位实参

  (三)有四个不明确个数的职责实参

  有时候,大家不能够事先精通函数要求承受多少个职分实参,由此,我们能够运用
‘*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定义了1个参数个数不鲜明的函数test_func(),其中“*args”表示形参个数不分明。

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

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

  第二行,将收受到的参数以列表的款式出口。

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

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

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

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

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

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

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

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

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

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

  第26行,调用函数test_func(),提供七个实参:壹、二、三、四、伍。

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

 

 

  运营结果:

  运维结果:

 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,还能够明白的提议函数调用中各样值的用处。不过,使用首要这参数时,必须可信的钦赐函数定义中的形参名。

  举例,我们利用首要字实参来调用壹.4.2.第11中学定义的函数。

  例如,大家使用首要字实参来调用一.四.二.第11中学定义的函数。

  (一)唯有二个主要字参数

  (一)只有一个第二字参数

  代码:

  代码:

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

  说明:

  说明:

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

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

 

 

  运转结果:

  运转结果:

Welcome to  Yun !
Welcome to  Yun !

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

  从以上运行结果能够,跟壹.四.一.第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

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

  从上述运维结果可见,与壹.四.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

  从上述的运维结果能够:

  从上述的运行结果可以:

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

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

  (2)错误提醒未建议第2一行的错,那是因为Python时解释型语言,但日前的代码出错了,若没对那3个举行管理,那么就终止,不再运行后续的代码。

  (二)错误提醒未提出第二壹行的错,那是因为Python时解释型语言,但前面的代码出错了,若没对充足举行拍卖,那么就告1段落,不再运行后续的代码。

 

 

  (三)有多个不鲜明个数的基本点字参数

  (三)有多少个不鲜明个数的首要字参数

  有时候,大家鞭长莫及事先明白函数供给经受多少个主要字实参,因而,大家能够利用‘**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”作为形参。

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

  第1行,打印该形参”**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)可简化函数调用。

  (二)可驾驭建议函数的优良用法

  (二)可精晓指出函数的卓著用法

  举个例子,创制一个函数具备多个形参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.  返回值

5.1 重临值的定义

伍.一 再次回到值的定义

  再次回到值是指函数重回的值,是函数主要的组成都部队分。由于函数的常有在于得以落成程序的片段作用,因而,许多时候大家须求将函数施行后的结果重回给程序再由程序作出更进一步的操作。此时,可选用return 语句将值重回到调用函数的代码行。

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

 

 

伍.贰 重回值的效益

⑤.二 重临值的法力

  再次回到值效用:能够将先后的大许多千斤职业移到函数中去完毕,从而简化主程序。

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

 

 

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 .

 

 

伍.4 再次回到2个列表

伍.4 重临三个列表

  比方,创立二个函数接受三个列表,然后将奇数组成1个新的列表作为再次回到值。

  比如,创设二个函数接受3个列表,然后将奇数组成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)

  说明:

  说明:

  第一行,创设1个空的列表。

  第一行,创造八个空的列表。

  第伍行,创造三个收受到的列表的别本。

  第肆行,创制多少个接受到的列表的别本。

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

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

  第四行,每便从列表副本中单出终极的成分,将其赋值给变量list_num。

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

  第7~十行,判别弹出的因素是还是不是为偶数,如若是,则跳过,反之,则将其扩充到创制的空列表list_nums_new中。

  第7~十行,剖断弹出的成分是还是不是为偶数,假如是,则跳过,反之,则将其增添到创制的空列表list_nums_new中。

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

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

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

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

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

  第2四行,打字与印刷重临的列表。

 

 

  运维结果:

  运维结果:

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

 

 

伍.伍 重返四个字典

伍.五 再次回到3个字典

   举个例子,创制贰个函数接受二个字典,然后将值的奇数的键-值对组合三个新字典再次回到。

   比方,创设三个函数接受3个字典,然后将值的奇数的键-值对组合叁个新字典重临。

  代码:

  代码:

 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。

  第3行,制造3个空字典dict_nums_new。

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

  第4~捌行,使用for语句循环接受的字典,然后推断该值是不是为奇数,倘诺不是,则跳过;反之,则扩张到空字典中。

  

  

  运营结果:

  运转结果:

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

 

 

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

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

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

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

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

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

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

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

  (二)可在众多不等的顺序中引用函数。

  (二)可在好些个不一样的次序中选定函数。

  (叁)可与其他技术员共享这个文件而不是整个程序。

  (三)可与别的技士共享那个文件而不是壹体程序。

 

 

陆.壹 模块的导入

6.1 模块的导入

  依据不相同的急需,模块的导入方法也诸多。模块的导入方法有:导入整个模块、导入特定的函数、导入模块中的全数函数。并且,大家可利用as来给导入的函数活或许模块钦命别名。

  依照分化的须要,模块的导入方法也诸多。模块的导入方法有:导入整个模块、导入特定的函数、导入模块中的全体函数。并且,大家可使用as来给导入的函数活或许模块钦赐外号。

 

 

⑥.一.1 导入整个模块

六.1.1 导入整个模块

  导入整个模块的法子为:

  导入整个模块的点子为:

  import 模块名

  import 模块名

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

  举例,我们创立将一.陆.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 .

 

 

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

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

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

  导入特定的函数的不二等秘书技为:

  from 模块名  import  函数名

  from 模块名  import  函数名

  比方,将求大4四个数的最大值和最小值的函数放到3个模块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中程导弹入求最大值和求最小值的函数,并分别给它们取三个小名。

  第三行,使用求最小值的函数的外号调用其格局求最小值。

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

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

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

 

 

  运转结果:

  运转结果:

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

  从以上结果可见,使用函数别称和选拔函数本身是壹模一样的职能。

  从上述结果可见,使用函数别称和选择函数本人是一样的遵守。

  由此,在导入模块或然模块中的函数时,要是模块名称和函数名称比较尝,都可对其内定别称,在调用时,使用其别称即可。

  因而,在导入模块恐怕模块中的函数时,假使模块名称和函数名称比较尝,都可对其内定小名,在调用时,使用其外号就能够。

 

 

陆.一.3  导入全数的函数 

陆.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.  函数编写标准

七.  函数编写规范

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

  编写函数时,应坚守以下标准:

  (一)函数名称应具备描述性,且只行使小写字母和下划线来定名。
  (贰)种种函数都应包罗文书档案字符串,即简要地解说该函数的功能的批注,该注释应紧跟在函数定义后边。
  (3)给形参内定暗中认可值时,等号两边不要有空格。
  (四)对于函数调用中的关键字实参,也应遵守等号两边不要有空格的预订。
  (5)PEP
8(
  (陆)即使程序或模块包罗四个函数,可利用八个空行将左近的函数分开。
  (7)全数的 import
语句都应放在文件开头,唯一区别的情况是,在文书开端使用了讲解来讲述整个程序。

  (一)函数名称应持有描述性,且只利用小写字母和下划线来命名。
  (二)每一个函数都应涵盖文书档案字符串,即简要地演说该函数的成效的评释,该注释应紧跟在函数定义前边。
  (三)给形参钦命默许值时,等号两边不要有空格。
  (四)对于函数调用中的关键字实参,也应遵循等号两边不要有空格的预订。
  (5)PEP
8(
  (陆)借使程序或模块包涵多少个函数,可选用七个空行将紧邻的函数分开。
  (7)全部的 import
语句都应放在文件初阶,唯1差异的景况是,在文件起初使用了讲授来说述整个程序。

 

 

 

 

 

 

 

 

 

 

 

 

  

  

  

  

  

  

 

 

  

  

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有