当前位置: 澳门新濠3559 > 编程 > 正文

所以函数是组织好的,  五、收集参数

时间:2019-11-08 23:18来源:编程
目录: Python3基础之函数用法,python3函数用法 一般来说,函数(function)是组织好的、可重复使用的、具有一定功能的代码段。函数能提高应用的模块性和代码的重复利用率,在Python中

目录:

Python3基础之函数用法,python3函数用法

一般来说,函数(function)是组织好的、可重复使用的、具有一定功能的代码段。函数能提高应用的模块性和代码的重复利用率,在Python中已经提供了很多的内建函数,比如print(),同时Python还允许用户自定义函数。

本文就来实例总结一下Python3的函数用法,具体内容如下:

一、定义

定义函数使用关键字def,后接函数名和放在圆括号( )中的可选参数列表,函数内容以冒号起始并且缩进。一般格式如下:

def 函数名(参数列表): 
  """文档字符串""" 
  函数体 
  return [expression] 

注意:参数列表可选,文档字符串可选,return语句可选。

示例:

def fib(n): 
  """Print a Fibonacci series""" 
  a, b = 0, 1 
  while b < n: 
    print(b, end=' ') 
    a, b = b, a+b 
  print() 

fib(2000) # call 
f = fib  # assignment 
f(2000) 

函数名的值是一种用户自定义的函数类型。函数名的值可以被赋予另一个名字,使其也能作为函数使用。

二、函数变量作用域

在函数内部定义的变量拥有一个局部作用域,在函数外定义的拥有全局作用域。注意:在函数内部可以引用全局变量,但无法对其赋值(除非用global进行声明)。

a = 5     # 全局变量a 

def func1(): 
  print('func1() print a =', a) 

def func2(): 
  a = 21  # 局部变量a 
  print('func2() print a =', a)  

def func3(): 
  global a 
  a = 10  # 修改全局变量a 
  print('func3() print a =', a) 

func1() 
func2() 
func3() 
print('the global a =', a) 

三、函数调用

1、普通调用

与其他语言中函数调用一样,Python中在调用函数时,需要给定和形参相同个数的实参并按顺序一一对应。

def fun(name, age, gender): 
  print('Name:',name,'Age:',age,'Gender:',gender,end=' ') 
  print() 

fun('Jack', 20, 'man') # call 

2、使用关键字参数调用函数

函数也可以通过keyword=value 形式的关键字参数来调用,因为我们明确指出了对应关系,所以参数的顺序也就无关紧要了。

def fun(name, age, gender): 
  print('Name:',name,'Age:',age,'Gender:',gender,end=' ') 
  print() 

fun(gender='man', name='Jack', age=20) # using keyword arguments 

3、调用具有默认实参的函数

Python中的函数也可以给一个或多个参数指定默认值,这样在调用时可以选择性地省略该参数:

def fun(a, b, c=5): 
  print(a+b+c) 

fun(1,2) 
fun(1,2,3) 

注意:通常情况下默认值只被计算一次,但如果默认值是一个可变对象时会有所不同, 如列表, 字典, 或大多类的对象时。例如,下面的函数在随后的调用中会累积参数值:

def fun(a, L=[]): 
  L.append(a) 
  print(L) 

fun(1) # 输出[1] 
fun(2) # 输出[1, 2] 
fun(3) # 输出[1, 2, 3] 

所以函数是组织好的,  五、收集参数。4、调用可变参数函数

通过在形参前加一个星号(*)或两个星号(**)来指定函数可以接收任意数量的实参。

def fun(*args): 
  print(type(args)) 
  print(args) 

fun(1,2,3,4,5,6) 

# 输出: 
# <class 'tuple'> 
# (1, 2, 3, 4, 5, 6) 

def fun(**args): 
  print(type(args)) 
  print(args) 

fun(a=1,b=2,c=3,d=4,e=5) 

# 输出: 
# <class 'dict'> 
# {'d': 4, 'e': 5, 'b': 2, 'c': 3, 'a': 1} 

从两个示例的输出可以看出:当参数形如*args时,传递给函数的任意个实参会按位置被包装进一个元组(tuple);当参数形如**args时,传递给函数的任意个key=value实参会被包装进一个字典(dict)。

5、通过解包参数调用函数

上一点说到传递任意数量的实参时会将它们打包进一个元组或字典,当然有打包也就有解包(unpacking)。通过 单星号和双星号对List、Tuple和Dictionary进行解包:

def fun(a=1, b=2, c=3): 
  print(a+b+c) 

fun()  # 正常调用 
list1 = [11, 22, 33] 
dict1 = {'a':40, 'b':50, 'c':60} 
fun(*list1)  # 解包列表 
fun(**dict1) # 解包字典 

# 输出: 
# 6 
# 66 
# 150 

注:*用于解包Sequence,**用于解包字典。解包字典会得到一系列的key=value,故本质上就是使用关键字参数调用函数。

四、lambda表达式

lambda关键词能创建小型匿名函数。lambda函数能接收任何数量的参数但只能返回一个表达式的值,它的一般形式如下:

lambda [arg1 [,arg2,.....argn]] : expression 

lambda表达式可以在任何需要函数对象的地方使用,它们在语法上被限制为单一的表达式:

f = lambda x, y: x+y 
print(f(10, 20)) 

def make_fun(n): 
  return lambda x: x+n 

f = make_fun(15) 
print(f(5)) 

五、文档字符串

函式体的第一个语句可以是三引号括起来的字符串, 这个字符串就是函数的文档字符串,或称为docstring 。我们可以使用print(function.__doc__)输出文档:

def fun(): 
  """Some information of this function. 
  This is documentation string.""" 
  return 

print(fun.__doc__) 

文档字符串主要用于描述一些关于函数的信息,让用户交互地浏览和输出。建议养成在代码中添加文档字符串的好习惯。

一、函数是什么

​ 计算机语言中的函数是类比于数学中的函数演变来的,但是又有所不同。前面的知识中我们学会了运用基础语法和流程控制语句貌似也能处理一些复杂的问题,但是相对于相似的大量重复性的操作我们就没办法用之前的逻辑方法来解决了,这时候就需要一个可以概括这些重复性操作的统一代码来描述其特征来实现,所以函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。

定义:函数是值将一组语句集合通过一个名字封装起来,要想执行这个函数,只需调用其函数名即可。

优点:在解决问题时,使用函数有诸多好处,最主要的好处就是:增强代码的重用性和可读性,后期扩展方便

  一、形参和实参

python332函数在帮助文档怎看?

1.这个怎么看,我不能理解;2.全局变量局部变量有什么区别吗? 区别肯定有的,不然名字就没必要区分了。全局的作用域比较大,一般在程序代码中任何地方都可以调用,局部变量一般只在函数内部使用。3.函数,说白了就是实现不同功能的代码段,比如MAX(a,b,c,...)函数,求最大值, MIN(a,b,c,...)函数,求最小值等、、、、还有很多。函数一般只知道使用方法(比如所需参数,返回值)和实现功能就行。  

二、函数的定义

  二、函数文档

python33中使用pyqt4编写gui时用到selfconnect函数

好久不用QT4了。 印象中它对于这种事件槽的连接方法有一些规范。 如果不符合规范,即使不提示出错。代码也通过编译也不能用。

第二个可能是你的exit函数不对。你在函数的开头打一个print ("here"),然后看看控制台有没有输出

第三个可能quit()的方法似乎不太对。 我也不太记得了。

最好的办法是你将它的例子代码拿过来重新编译一遍。 看看例子里的退出按钮能不能用。如果不能用可能就是QT的版本问题,也可能是python3的原因。 如果能用就将它的代码复制过来再试。

只要你试通过一次,基本上就会了。 下次照着成功的例子抄就成了。

以前也多次遇到过事件槽不能用的情形,通常是书写的规范不对。 这个还没有仔细去想过原因。  

一般来说,函数(function)是组织好的、可重复使用的、具有一定功能的代码段。函数能提高应用的...

2.1、格式

def 函数名:    函数体

函数定义的简单规则:    函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。    任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。    函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。    函数内容以冒号起始,并且缩进。    return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

举个栗子,简单认识一下函数:

def greet_user():        """显示最简单的问候语"""    print("Hello,"greet_user()

  三、关键字参数

上面这三行代码就是一个简单的函数实例,def是必不可少的,用于定义函数,greet_user是定义的函数名,()

括号内指出函数为完成其任务需要什么样的信息,也就是参数,但是这里它不需要任何信息就能完成其工作,因此括号是空的(即便如此,括号也必不可少)。最后,定义以冒号结尾。

中间的缩进行构成了函数体。这里是函数的重点,所有的操作都是定义在这里的。上面的注释处的文本是被称为文档字符串 ( docstring )的注释,描述了函数是做什么的。文档字符串用三引号括起, Python 使用它们来生成有关程序中函数的文档。

greet_user() 这是对上面定义好的函数的调用。Python中要调用函数,可依次指定函数名以及用括号括起的必要信息-参数,上面的函数因为没有定义参数所以就不需要进行参数的传递,直接加括号调用。

  四、默认参数

2.2、函数的命名规则

函数名必须以下划线或字母开头,可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号;函数名是区分大小写的。函数名不能是保留字。

  五、收集参数

三、参数的传递

  六、课时18课后习题及答案

3.1、形参和实参

举个栗子:

def greet_user:    print("Hello,"+username.titlegreet_user('jack')

上面的代码片段,定义函数greet_user,需要向函数中传递参数,在上面的函数中名后的括号中的username就是形参,调用函数时给函数传入的值'jack'就是实参。实参将用户传递的值传递给形参,形参在传递进函数体中进行相关运算执行。

形参:形式参数,不是实际存在,是虚拟变量。在定义函数和函数体的时候使用形参,目的是在函数调用时接收实参(实参个数,类型应与实参一一对应)

实参:实际参数,调用函数时传给函数的参数,可以是常量,变量,表达式,函数,传给形参 。

区别:形参是虚拟的,不占用内存空间,形参变量只有在被调用时才分配内存单元,实参是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参。

 

3.2、位置实参

鉴于函数定义中可能包含多个形参,因此函数调用中也可能包含多个实参。向函数传递实参的方式很多,可使用位置实参 ,这要求实参的顺序与形参的顺序相同;也可使用关键字实参 ,其中每个实参都由变量名和值组成;还可使用列表和字典。

调用函数时, Python 必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此,最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。

文字描述太多不如举个栗子:看一个显示宠物信息的函数。这个函数指出一个宠物属于哪种动物以及它叫什么名字

def describe_pet(pet_name,animal_type):    print("nI have a " + animal_type)    print("My " + animal_type + "'s name is " + pet_name.titledescribe_pet('Hellen','dog')describe_pet('dog','Hellen')  # 错误的位置参数传递

上述代码的运行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-2.pyI have a dogMy dog's name is Hellen# 参数位置传递错误  结果也不一样I have a HellenMy Hellen's name is DogProcess finished with exit code 0

分析:上述代码上两次实参的传递因为位置不同而得到不同的结果,第二个显然不是我们想要的结果,所以在进行实参传递时确认函数调用中实参的顺序与函数定义中形参的顺序一致。

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

3.3、关键字实参

关键字参数是向形参传递--值对,关键字实参传递让我们无需考虑函数调用中的实参顺序,还清楚地指出了函数调用中各个值的用途。

举个栗子:

def describe_pet(pet_name,animal_type):    print("nI have a " + animal_type)    print("My " + animal_type + "'s name is " + pet_name.title#  关键字传参不必考虑位置describe_pet(pet_name='Hellen',animal_type="dog") describe_pet(animal_type="dog",pet_name='Hellen')

上述代码的运行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-2.pyI have a dogMy dog's name is HellenI have a dogMy dog's name is HellenProcess finished with exit code 0

分析:上面的这个例子是关键字实参传递,使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。

澳门新濠3559 1

注意:如果关键字参数和位置参数一起出现时,关键字参数是不能写在位置参数前面的

一、形参和实参

3.3、默认参数

编写函数时,可给每个形参指定 默认值 。在调用函数中给形参提供了实参时, Python 将使用指定的实参值;否则,将使用形参的默认值。因此,给形参指定默认值后,可在函数调用中省略相应的实参。使用默认值可简化函数调用,还可清楚地指出函数的典型用法。

举个栗子:

def describe_pet(pet_name,animal_type='dog'):    print("nI have a " + animal_type)    print("My " + animal_type + "'s name is " + pet_name.titledescribe_pet('jack')  # 默认animal_type='dog'describe_pet('pick','cat') # 使用位置实参,赋值animal_type='cat'describe_pet(animal_type="cat",pet_name='Hellen')  # 关键字传参

上述代码的执行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-2.pyI have a dogMy dog's name is JackI have a catMy cat's name is PickI have a catMy cat's name is HellenProcess finished with exit code 0

分析:这里修改了函数 describe_pet() 的定义,在其中给形参 animal_type 指定了默认值 'dog' 。这样,调用这个函数时,如果没有给 animal_type 指定值, Python 将把这个形参设置为 'dog' ,如果指定 animal_type的值则就使用指定的值。

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

3.4、不定长参数

有时候可能我们预先不知道函数需要接受多少个实参,好在 Python 允许函数从调用语句中收集任意数量的实参。

举个栗子:

def make_pizza:    printmake_pizza('pepperoni')make_pizza('mushrooms','green peppers','extra cheese')

上述代码的执行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-5.py('pepperoni',)('mushrooms', 'green peppers', 'extra cheese')Process finished with exit code 0

分析:上面的make_pizza函数只有一个形参 *toppings ,但不管调用语句提供了多少实参,这个形参都将它们统统收入囊中。**形参名 *toppings 中的星号让 Python 创建一个名为 toppings 的空元组,并将收到的所有值都封装到这个元组中**,即使是一个值也会生成一个元组。

注意:上面make_pizza函数还有另一种传值方式,test(*[1,2,3,4,5]),这样还是会以元组的方式返回数据

其中 toping = [1,2,3,4,5]

澳门新濠3559 2

举个栗子:

def make_pizza:    printmake_pizza(*'list')                            ====>  ('l', 'i', 's', 't')  /传入字符串时返回元组make_pizza                           ====>    /传入元组时返回元组make_pizza                           ====>    /传入列表时返回元组make_pizza(*{'first':'name','last':'name2'})   ====>  ('first', 'last') /传入字典时,只返回key值元组

函数从调用的角度来说,分为形式参数和实际 参数。形参是指函数创建和定义过程中小括号里的参数;而实参指得是函数在被调用过程中传递进来的参数。举个例子:

3.4.1、结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参,必须在函数定义中将接纳任意数量实参的形参放在最后。 Python 先匹配位置实参和关键字实参,再将余下的实参都收集到最后一个形参中。

def make_pizza(size,*topings):    print(size,topings)make_pizza(2,'pepperoni')make_pizza(16,23,45,'mushrooms','green peppers','extra cheese')

上述代码的执行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-5.py2 ('pepperoni',)16 (23,45,'mushrooms', 'green peppers', 'extra cheese')Process finished with exit code 0

分析:基于上述函数定义, Python 将收到的第一个值存储在形参 size 中,并将其他的所有值都存储在元组 toppings 中。

**注意:*topings只接收位置参数,不能接收关键字参数**

当位置参数遇到topings时:就是有位置参数同时也有N个实参传入,首先将值赋给位置参数,然后剩下的多余的值赋给args以元组的形式输出

>>> def MyFirstFunction(name):
    '函数定义过程中的name是叫形参'
    #因为Ta只是一个形式,表示占据一个参数位置
    print('传递进来的' + name + '叫做实参,因为Ta是具体的参数值!')

>>> MyFirstFunction('小甲鱼')
传递进来的小甲鱼叫做实参,因为Ta是具体的参数值!

3.4.2、使用任意数量的关键字实参

有时候,需要接受任意数量的实参,但预先不知道传递给函数的会是什么样的信息。在这种情况下,可将函数编写成能够接受任意数量的 键—值 对 —— 调用语句提供了多少就接受多少。

举个栗子:

def build_profile(first, last, **user_info):    profile = {}    profile['first_name'] = first    profile['last_name'] = last    for key, value in user_info.items():        profile[key] = value    return profileuser_profile = build_profile('albert','eniston',                             location = 'China',                             field = 'physics',                             age = 18)print(user_profile)

上述代码的执行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-5.py{'first_name': 'albert', 'last_name': 'eniston', 'location': 'China', 'field': 'physics', 'age': 18}Process finished with exit code 0

分析:形参 * *user_info 中的两个星号让 Python 创建一个名为 user_info 的空字典,并将收到的所有名称 — 值对都封装到这个字典中。上面的build_profile函数不知道用户会输入多少信息,指明姓名后,再提供住址、年龄等信息,函数都会将这些信息都存储在空字典中。

注意:上述任意数量关键字实参传值时也有两种方法:一是使用键值传值,二是直接调用**{字典}的方式

print(build_profile(**{'first':123,'last':'name'}))  # 也接受**{字典} 的传值方式# 运行结果{'first_name': 123, 'last_name': 'name'}

 

3.4.2.1、当位置参数遇上**kwargs时:
def build_profile(name, **user_info): #name 是一个位置形参  **user_info是用来生成一个空字典接受其他变量    print    print(user_info)# 首先是赋值一个位置实参,然后将后面键值对指定的实参存储到字典里build_profile('keitter',age=12,location = 'China')          # 使用特殊传值方式 **{}  传入的是字典  最后传出的也是字典build_profile('njson',**{'first':'jack','location':'China'})# 当只传入一个位置实参时  则后面的**user_info 还是会生成一个空字典build_profile('nkitter')       # 当传入的位置参数个数和形参中定义好的位置参数数量不符时就直接报错build_profile('nkitter','name',age=12,location = 'China')    ===》直接报错

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-5.pykeitter{'age': 12, 'location': 'China'}json{'first': 'jack', 'location': 'China'}kitter{}Process finished with exit code 0

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

3.4.2.2、当位置参数、默认参数遇到 **kwargs 时:

注意:默认参数一定不能放到 **kwargs 后面,否则程序会直接报错。

澳门新濠3559,举个栗子:

def build_profile(name, age=18,**user_info):  #name 是一个位置形参  age是默认形参  **user_info是用来生成一个空字典接受其他变量    print    print    print(user_info)# 这很好理解,就是位置实参传值,将默认参数age赋值为12,然后剩下的参数生成字典build_profile('keitter',12,location = 'China')  # 这和上面那个差不多,只不过是使用了关键字实参给默认参数赋值build_profile('nHellon',location = 'China',age=23)# 使用特殊传值方式 **{}  age值和上面两个一样,可以是位置实参,也可以关键字指定build_profile('njson',**{'first':'jack','location':'China'})# 当只传入一个位置实参时 则会生成默认参数值和后面的**user_info 生成的一个空字典build_profile('nkitter')

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-5.pykeitter12{'location': 'China'}Hellon23{'location': 'China'}json18{'first': 'jack', 'location': 'China'}kitter18{}Process finished with exit code 0

二、函数文档

3.4.2.3、当位置参数、默认参数遇上 *args 和 **kwargs 时

注意: *args 只接收位置参数,转换成元组的形式,不接收关键字参数

​ * *kwargs 只接收关键字参数,转换成字典的形式

​ **位置顺序不能变, args必须放在 *kwargs 前面 ,位置参数一定是放在默认参数前面,不定长参数肯定是放在最后面。**

举个栗子:

def build_profile(name, age=18, *user, **user_info): # 位置参数 默认参数 两种不定长参数    print    print    print    print(user_info)# 位置参数肯定是要匹配的 默认参数可给可不给   *args 只接收位置参数  **kwargs 只接收关键字参数build_profile('keitter',12,'people',location = 'China')# 多种形参混合时,不能将默认实参放到最后 会直接报错build_profile('nHellon','people',location = 'China',age=23)    ====》 直接报错# 特殊参数传递方法 注意在传递*[]时,没有指定默认实参时,会将第一个值赋给默认参数build_profile('njson',*[{'name':'jack'},1,2,3],**{'first':'jack','location':'China'},)# 默认没有给 *args  和   * *kwargs 传值时,还是会生成一个空列表和空字典build_profile('nkitter','people')

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-5.pykeitter12('people',){'location': 'China'}json{'name': 'jack'}   # 注意在传递*[]时,没有指定默认实参时,会将第一个值赋给默认参数          # 注意在传递*[]时,除了传给默认参数的,后面的剩的值还是会生成一个元组{'first': 'jack', 'location': 'China'}kitterpeople()               # 还是会生成一个空列表和空字典{}Process finished with exit code 0

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

四、返回值

函数并非总是直接显示输出,相反,它可以处理一些数据,并返回一个或一组值。函数返回的值被称为 返回值 。在函数中,可使用 return 语句将值返回到调用函数的代码行。返回值让你能够将程序的大部分繁重工作移到函数中去完成,从而简化主程序。

返回值的分类:

当返回值数 = 0         ==》返回none当返回值数 = 1         ==》返回object,是什么就返回什么当返回值数 > 1         ==》 返回元组元组中包含所有的返回值 

举个栗子:

def get_formatted(first_name,last_name):    full_name = first_name + ' ' + last_name    return full_name.title()musician = get_formatted('qi','siwill')print

上述代码的执行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-3.pyQi SiwillProcess finished with exit code 0

分析:调用返回值的函数时,需要提供一个变量,用于存储返回的值。在这里,将返回值存储在了变量 musician 中

函数可返回任何类型的值,包括列表和字典等较复杂的数据结构

举个返回字典的例子:

def build_people(first_name,last_name):    person = {'first':first_name,'last':last_name}    return personmusician = build_people('jack','rose')print

上述代码的执行结果为:

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-3.py{'first': 'jack', 'last': 'rose'}Process finished with exit code 0

分析:上述代码就是指返回值个数为1 ,那么是什么就返回什么,person是一个字典所以就返回一个字典,如果是其他对象也都返回对应的。

再举个栗子:

def build_people(first_name,last_name):    # person = {'first':first_name,'last':last_name}    return first_name,last_namemusician = build_people('jack','rose')musician2 = build_people('jack','["Rose","jack"]')printprint(musician2)

C:Python37python3.exe D:/pythoncode/Exercise/Exer8/Exer8-3.py('jack', 'rose')('jack', '["Rose","jack"]')Process finished with exit code 0

分析:上述代码就是指返回值个数大于1 ,那么则返回一个元组,包含所有值的元组。

给函数写文档是为了让别人可以更好的理解你的函数,所以这是一个好习惯。函数文档的作用是描述该函数的功能。

>>> def exchangeRate(dollar):
    """美元—>人民币
    汇率暂定为6.5
    """
    return dollar * 6.5

>>> exchangeRate(10)
65.0

我们发现,在函数开头写下的字符串是不会打印出来的,但它作为函数的一部分存储起来。这个称为函数文档字符串,它的功能跟注释一样。

与注释不同的是,函数文档字符串可以通过特殊属性_ _doc_ _(注:_ _doc_ _两边分别是两条下划线):

>>> exchangeRate(10)
65.0
>>> exchangeRate.__doc__
'美元—>人民币nt汇率暂定为6.5nt'

另外,想用一个函数但不知道其用法时,会通过help()函数查看函数的文档。因此,对自己的函数也可以如法炮制:

>>> help(exchangeRate)
Help on function exchangeRate in module __main__:

exchangeRate(dollar)
    美元—>人民币
    汇率暂定为6.5

 

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

三、关键字参数

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

普通的参数叫做位置参数,使用位置参数可以解决程序员在调用一个函数时候,搞乱位置参数的顺序,以至于函数无法按照预期实现的潜在问题。来看个例子:

>>> def saySomething(name,words):
    print(name + "—>" +words)


>>> saySomething("小甲鱼","让编程改变世界!")
小甲鱼—>让编程改变世界!
>>> saySomething("让编程改变世界!","小甲鱼")
让编程改变世界!—>小甲鱼
>>> saySomething(words="让编程改变世界!",name="小甲鱼")
小甲鱼—>让编程改变世界!

关键字参数其实就是在传入实参时指定形参的变量名,尽管使用这种技巧要多打一些字,但随着程序规模的越来越大、参数越来越多,关键字参数起到的作用就越明显。

 

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

四、默认参数

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

默认参数就是在定义的时候赋予了默认值的参数:

>>> def saySomething(name="小甲鱼",words="让编程改变世界!"):
    print(name + '—>' +words)


>>> saySomething()
小甲鱼—>让编程改变世界!
>>> saySomething("DC","有时候最意想不到的人 才能做出最超乎想象的事")
DC—>有时候最意想不到的人 才能做出最超乎想象的事

使用默认参数的话,就可以不带参数去调用函数。所以,它们之间的区别是:关键字参数是在函数调用的时候,通过参数名指定要赋值的参数,这样做就不怕因为搞不清参数的顺序而导致函数的调用出错;而默认参数是在参数定义过程中,为形参赋初值,当函数调用的时候,不传递参数,则默认使用形参的初始值代替。

 

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

五、收集参数

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

收集参数在大多数的时候被称作可变参数,仅需要在参数前面加上星号(*)即可:

>>> def test(*params):
    print("有%d个参数"%len(params))
    print("第二个参数是:",params[1])


>>> test(1,2,3,4,5,6,7,8)
有8个参数
第二个参数是: 2
>>> test("小甲鱼",123,3.14)
有3个参数
第二个参数是: 123

Python就是把标志为收集参数的参数们打包成一个元组。不过,需要注意的是:如果在收集参数的后面还需要指定其它参数,在调用函数的时候就应该使用关键字参数来指定,否则Python就都会把你的实参都列入收集参数的范畴。举个例子:

>>> def test(*params,extra):
    print("收集参数是",params)
    print("位置参数是",extra)


>>> test(1,2,3,4,5,6,7,8)
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    test(1,2,3,4,5,6,7,8)
TypeError: test() missing 1 required keyword-only argument: 'extra'
>>> test(1,2,3,4,5,6,7,extra=8)
收集参数是 (1, 2, 3, 4, 5, 6, 7)
位置参数是 8

建议在参数中带有收集参数是,可以将其它参数设置为默认参数,这样不容易出错:

>>> test(1,2,3,4,5,6,7,extra=8)
收集参数是 (1, 2, 3, 4, 5, 6, 7)
位置参数是 8
>>> def test(*params,extra=8):
    print("收集参数是",params)
    print("位置参数是",extra)


>>> test(1,2,3,4,5,6,7,8)
收集参数是 (1, 2, 3, 4, 5, 6, 7, 8)
位置参数是 8
>>> test(1,2,3,4,5,6,7)
收集参数是 (1, 2, 3, 4, 5, 6, 7)
位置参数是 8

星号(*)其实既可以”打包“,也可以“解包“。举个例子,假如你需要将一个列表a传入test参数的收集参数 *params中,那么调用test(a)时便会出错,此时,你需要在a前面加上个星号(*)表示参数需要"解包"后才能使用:

>>> def test(*params):
    print("有%d个参数"%len(params))
    print("第二个参数是:",params[1])


>>> a=[1,2,3,4,5,6,7,8]
>>> test(a)
有1个参数
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    test(a)
  File "<pyshell#45>", line 3, in test
    print("第二个参数是:",params[1])
IndexError: tuple index out of range
>>> test(*a)
有8个参数
第二个参数是: 2

Python还有一种收集的形式,就是用两个星号(**)表示。跟前面的介绍不同,两个星号的收集参数表示为将参数们打包成字典的形式。后面讲解。

 

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

六、课时18课后习题及答案

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

澳门新濠3559 3

澳门新濠3559 4

澳门新濠3559 5

澳门新濠3559 6

澳门新濠3559 7

澳门新濠3559 8

编辑:编程 本文来源:所以函数是组织好的,  五、收集参数

关键词: