018，函数2 形参和实参

  本节课可 参考 中谷教育 的python视频《形参和实参》，更为详细，容易理解。

函数的 形式参数和实际参数（形参和实参）： 形式参数：parameter  实际参数：argument

>>> def MyFirstFunction(name):

    '函数定义过程中的name是叫形参'

    #因为它只是一个形式，表示占据一个参数位置

    print('传递进来的' + name + '叫做实参，因为它是具体的参数值')

 >>> MyFirstFunction('fishdm')

传递进来的fishdm叫做实参，因为它是具体的参数值

 

函数文档

 >>> def MyFirstFunction(name):

    '函数定义过程中的name是叫形参'      -----------------叫函数文档，并不会被打印出来。跟注释#类似

    #因为它只是一个形式，表示占据一个参数位置

    print('传递进来的' + name + '叫做实参，因为它是具体的参数值')

 >>> MyFirstFunction('fishdm')

传递进来的fishdm叫做实参，因为它是具体的参数值

如：  

>>> MyFirstFunction. __doc__    #这叫函数的特殊属性，用双下划线开始和结束

'函数定义过程中的name是叫形参'

>>> 

用help也可以看到文档属性的内容：  

>>>  help ( MyFirstFunction )

Help  on  function  MyFirstFunction  in  module  __main__ :

 

MyFirstFunction ( name )

     函数定义过程中的name 是 叫 形 参

 

>>> 

关键字参数：  

>>>  def  SaySome ( name , words ) :

     print ( name  +  '->'  +  words )

 

    

>>>  SaySome ( 'fishdm' , '努力学习python' )

fishdm -> 努力学习python

>>>  SaySome ( '努力学习python' , 'fishdm' )                #形参和实参位置是一一对应的，

努力学习python -> fishdm

>>>  SaySome ( words  =  '努力学习python' , name  =  'fishdm' )            #等于告诉python关键字提示索引

fishdm -> 努力学习python            

>>> 

 

默认参数：  

>>>  def  SaySome ( name  =  'fishdm', words  =  '努力学习python' ):

     print ( name  +  '->'  +  words )

 

    

>>>  SaySome ( )

fishdm -> 努 力 学 习 python

>>>  SaySome ( 'yudaoming' )

yudaoming -> 努 力 学 习 python

>>>  SaySome ( 'yudaoming', '坚持' )

yudaoming -> 坚 持

>>> 

 

关键字参数是在函数调用的时候通过参数名制定需要赋值的参数，这样可以避免代码多的时候搞不清函数的顺序导致函数调用时候出现莫名其妙的错误

默认参数是在参数定义的过程中为形参赋予初始值，当函数调用时候如果不传递任何实参也可以得到初始值，而避免程序报错。

 

收集参数（可变参数）  （用*号表示）

>>>  def  test ( * params ) :

     print ( '参数的长度是：' , len ( params ))

     print ( '第二个参数：' , params [ 1 ])

 

    

>>>  test ( 1 , 'fishdm' , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

参 数 的 长 度 是 ：  10

第 二 个 参 数 ：  fishdm

>>> 

   

>>>  def  test ( * params , exp ) :

     print ( '参数的长度是：' , len ( params ) , exp )

     print ( '第二个参数：' , params [ 1 ])

 

    

>>>  test ( 1 , 'fishdm' , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

Traceback  ( most  recent  call  last ) :

   File  "<pyshell#38>" ,  line  1 ,  in  < module >

     test ( 1 , 'fishdm' , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 )

TypeError :  test ( )  missing  1  required  keyword - only  argument :  'exp'

>>>  test ( 1 , 'fishdm' , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , exp  =  'abc' )

参 数 的 长 度 是 ：  10  abc

第 二 个 参 数 ：  fishdm

>>> 

 

测试题：

      

0. 请问以下哪个是形参哪个是实参？

1. def MyFun(x):
2.     return x ** 3
4. y = 3
5. print(MyFun(y))

 答：x是形参，y是实参

x是形式参数（形参），y是实际参数（实参）。

跟绝大部分编程语言一样，形参指的是函数创建和定义过程中小括号里的参数，而实参指的是函数在调用过程中传递进去的参数。

1. 函数文档和直接用“#”为函数写注释有什么不同？

给函数写文档是为了让别人可以更好的理解你的函数，所以这是一个好习惯：

1. >>> def MyFirstFunction(name):
2.         '函数文档在函数定义的最开头部分，用不记名字符串表示'
3.         print('I love FishC.com!')

复制代码

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

函数的文档字符串可以按如下方式访问：

1. >>> MyFirstFunction.__doc__
2. '函数文档在函数定义的最开头部分，用不记名字符串表示'

复制代码

另外，我们用help()来访问这个函数也可以看到这个文档字符串：

1. >>> help(MyFirstFunction)
2. Help on function MyFirstFunction in module __main__:
4. MyFirstFunction(name)
5. 函数文档在函数定义的最开头部分，用不记名字符串表示

复制代码

2. 使用关键字参数，可以有效避免什么问题的出现呢？

答：避免调用函数时顺序错误引发的一系列问题。

关键字参数，是指函数在调用的时候，带上参数的名字去指定具体调用的是哪个参数，从而可以不用按照参数的顺序调用函数，例如：

1. >>> def SaySome(name, words):
2.         print(name + '->' + words)
4. >>> SaySome(words='让编程改变世界！', name='小甲鱼')

复制代码

3. 使用help(print)查看print()这个BIF有哪些默认参数？分别起到什么作用？

答：内容排版不同       

1. >>> help(print)
2. Help on built-in function print in module builtins:
4. print(...)
5.     print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
6.     
7.     Prints the values to a stream, or to sys.stdout by default.
8.     Optional keyword arguments:
9.     file:  a file-like object (stream); defaults to the current sys.stdout.
10.     # 文件类型对象，默认是sys.stdout（标准输出流）
11.     sep:   string inserted between values, default a space.
12.     # 第一个参数如果有多个值（第一个参数是收集参数），各个值之间默认用空格（space）隔开
13.     end:   string appended after the last value, default a newline.
14.     # 打印最后一个值之后默认参数一个新行标识符(‘\n’)
15.     flush: whether to forcibly flush the stream.
16.     # 是否强制刷新流

复制代码

4. 默认参数和关键字参数表面最大的区别是什么？

答：默认参数是赋予形式参数默认值，关键字参数是使得实际参数与形参相对应而避免顺序错误引发的系统报错。

关键字参数是在函数调用的时候，通过参数名制定需要赋值的参数，这样做就不怕因为搞不清参数的顺序而导致函数调用出错。而默认参数是在参数定义的过程中，为形参赋初值，当函数调用的时候，不传递实参，则默认使用形参的初始值代替。

动动手：

     

0. 编写一个符合以下要求的函数：

   

    a) 计算打印所有参数的和乘以基数（base=3）的结果

    b) 如果参数中最后一个参数为（base=5），则设定基数为5，基数不参与求和计算。    

 答：  

def  fun ( * num ) :

     if  num [ -1 ]  ==  5 :

         print ( sum ( num [ : -1 ])*5)

     else :

         print ( sum ( num ))

 

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

 论坛参考答案：  

def  mFun ( * param ,  base = 3 ) :

     result  =  0

     for  each  in  param :

         result  +=  each

 

     result  *=  base

    

     print ( '结果是：' ,  result )

 

mFun ( 1 ,  2 ,  3 ,  4 ,  5 ,  base = 5 )

 

  1. 寻找水仙花数     

题目要求：如果一个3位数等于其各位数字的立方和，则称这个数为水仙花数。例如153 = 1^3+5^3+3^3，因此153是一个水仙花数。编写一个程序，找出所有的水仙花数。  

答：  

def  fun ( num ):

     num  =  int ( num )

     for  i  in  range ( 100, num ):

         if  i  ==  pow (( i  //  100 ), 3 )  +  pow (( i  //  10  %  10 ), 3 )  +  pow (( i  %  100  %  10 ), 3 ):

              print ( i )      

        

fun ( 999 )

 论坛参考答案：  

def  Narcissus ( ) :

     for  each  in  range ( 100 ,  1000 ) :

         temp  =  each

         sum  =  0

         while  temp :

              sum  =  sum  +  ( temp % 10 )  **  3

              temp  =  temp  // 10  # 注意这里用地板除

 

         if  sum  ==  each :

              print ( each ,  end = ' \t ' )

 

print ( "所有的水仙花数分别是：" ,  end = '' )

Narcissus ( )

 总结：一直没理解参考答案的意思，看来我还是比较原始，用算法强行算

 

2. 编写一个函数findstr(),该函数统计一个长度为2的子字符串在另一个字符串中出现的次数。例如：假定输入的字符串为"You cannot improve your past, but you can improve your future. Once time is wasted, life is wasted.",子字符串为"im"，函数执行后打印“子字母串在目标字符串中共出现3次”。      

程序执行效果：

 

答：我不会告诉你这简单的几行代码调试了我将近一个小时。。。。。  原因是卡在  

  print  ( '子字符串在目标字符串出现了'  +  str ( i )  +  '次' )

 这里，一直提示TypeError: Can't convert 'int' object to str implicitly，可怜我的英语水平，摸了很久才发现字符串跟数字不能做+i的赋值是int，而前面的字符串是str，只有把i转化为字符串才解决。  

letter  =  input ( '请输入目标字符串：' )

letter2  =  input ( '请输入子字符串：' )

def  findstr ( letter2 ) :

     if  letter2  in  letter :

         i  =  letter . count ( letter2 )

         print  ( '子字符串在目标字符串出现了'  +  str ( i )  +  '次' )

        

findstr ( letter2 )

 经过观察前两题的参考答案，似乎悟出一点东西：函数的意义在于直接调用，那么这题我的答案显得函数有些多余，于是作了一些改动，感觉更符合函数用法了。  

def  findstr ( ) :

     letter  =  input ( '请输入目标字符串：' )

     letter2  =  input ( '请输入子字符串：' )

     if  letter2  in  letter :

         i  =  letter . count ( letter2 )

         print  ( '子字符串在目标字符串出现了'  +  str ( i )  +  '次' )

        

findstr ( )

 

论坛参考答案：

 

def  findStr ( desStr ,  subStr ) :

     count  =  0

     length  =  len ( desStr )

     if  subStr  not  in  desStr :

         print ( '在目标字符串中未找到字符串!' )

     else :

         for  each1  in  range ( length ) :      

              if  desStr [ each1 ]  ==  subStr [ 0 ] :

                   if  desStr [ each1 +1 ]  ==  subStr [ 1 ] :

                        count  +=  1

                       

         print ( '子字符串在目标字符串中共出现 %d 次'  %  count )

 

desStr  =  input ( '请输入目标字符串：' )

subStr  =  input ( '请输入子字符串(两个字符)：' )

findStr ( desStr ,  subStr )

 

看了这答案，总结我的代码缺陷之处：1，没有作字符判断（在if里加上else就行了 else:         print('在目标字符串中未找到') ）。2，没有利用本节课的形参和实参知识进行练习，还只是把以前学的字符串内置函数嵌套入def中。但我对参考答案里的判断字符出现次数的算法用了两个循环嵌套有点疑惑，直接用count是不是比切片来得更直接？？！