《零基础入门学习Python》（18）--函数：灵活即强大

前言

上一节课我们基本介绍Python函数的用法，这一节课我们主要针对函数的参数进行进一步的深入学习。

知识点

• 形参(parameter)和实参(argument)

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


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

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

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

>>> MyFirstFunction.__doc__
'函数定义过程中的name是叫形参'  

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

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

• 关键字参数 

>>> def SaySome(name,words):
	 print(name + '->' + words)#切记不能搞混了关键字的位置

>>> SaySome('今天天气真好','非常适合出去游玩')
	 
今天天气真好->非常适合出去游玩
>>> SaySome(name='今天天气真好',words='非常适合出去游玩')
	 
今天天气真好->非常适合出去游玩
>>> 

• 默认参数 
  定义了默认值的参数

>>> def SaySome(name='天气',words='真好'):
	 print(name+'->'+words)

	 
>>> SaySome()
	 
天气->真好
>>> SaySome('今天')#当然因为第二个关键字有默认值所以可以只赋一个关键字的值

>>> SaySome(words='啦啦啦')
	 
天气->啦啦啦
	 
今天->真好
>>> SaySome('今天','天气真好')
	 
今天->天气真好

• 收集参数（可变参数）

>>> def test(*params):
    print('参数的长度是：',len(params));
    print('第二个参数是：',params[1]);


>>> test(1,'小甲鱼',3.14,5,6,7,8)
参数的长度是： 7
第二个参数是： 小甲鱼

>>> def test(*params,exp):#收集参数和关键字参数一起用,必须在后面给它赋值否则就会出错
    print('参数的长度是：',len(params));
    print('第二个参数是：',params[1]);


>>> test(1,'小甲鱼',3.14,5,6,7,8)
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    test(1,'小甲鱼',3.14,5,6,7,8)
TypeError: test() missing 1 required keyword-only argument: 'exp'

>>> test(1,'小甲鱼',3.14,5,6,7,exp=8)
参数的长度是： 6
第二个参数是： 小甲鱼


>>> def test(*params,exp=8):
    print('参数的长度是：',len(params));
    print('第二个参数是：',params[1]);


>>> test(1,'小甲鱼',3.14,5,6,7,8)
参数的长度是： 7
第二个参数是： 小甲鱼

课后习题

测试题

• 请问以下哪个是行参哪个是实参？

def MyFun(x):
    return x ** 3

y = 3
print(MyFun(y))

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

• 函数文档和直接用’#’为函数写注释有什么不同？ 

给函数写文档是为了让别人可以更好的理解你的函数

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

>>> MyFirstFunction('fs')
I love FishC.com!    

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

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

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

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

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

MyFirstFunction(name)
#函数文档在函数定义的最开头部分，用不记名字符串表示

• 使用关键字参数，可以避免什么问题的出现？

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

>>> def SaySome(name, words):
        print(name + '->' + words)

>>> SaySome(words='让编程改变世界！', name='小甲鱼')

使用关键字参数，可以有效避免因不小心搞乱参数的顺序导致的BUG

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

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    # 文件类型对象，默认是sys.stdout（标准输出流）
    sep:   string inserted between values, default a space.
    # 第一个参数如果有多个值（第一个参数是收集参数），各个值之间默认用空格（space）隔开
    end:   string appended after the last value, default a newline.
    # 打印最后一个值之后默认参数一个新行标识符(‘\n’)
    flush: whether to forcibly flush the stream.
    # 是否强制刷新流

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

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

动动手

• 编写一个符合以下要求的函数： 
  1)计算打印所有参数的和乘以基数(base=3)的结果 
  2）如果参数中最后一个参数为（base=5），则设定基数为5，基数不参与求和计算。

def mul_sum(*param,base=3):
    result=0
    for each in param:
        result += each

    result *= base

    print('结果是',result)


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

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

def Narcissus():
    for x in range(0,10):
        for y in range(0,10):
            for z in range(0,10):
                sum = x*100 + y*10 +z
                if x**3 + y**3 + z **3 == sum and sum>=100 and sum<1000:
                    print(sum, end='\t')          

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

#或者

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

运行结果：
================== RESTART: C:/Users/ThinkPad/Desktop/12.py ==================
所有的水仙花数分别是：153  370 371 407
--------------------- 

• 写一个函数findstr()，该函数统计一个长度为2的子字符串在另一个字符串中出现的次数。例如：假定输入的字符串为“You cannot improve your past，but you can improve your future.Once time is wasted,life is wasted” 

def findStr(aimStr,subStr):
    count=0
    length=len(aimStr)
    if subStr not in aimStr:
        print('在目标字符串')
    else:
        for each in range(length):
            if aimStr[each] == subStr[0]:
                if aimStr[each+1]==subStr[1]:
                    count += 1
        print('字符串在目标字符串中共%d 次' % count)

aimStr = input('请输入目标字符串:')
subStr = input('请输入字符串（两个字符）:')
findStr(aimStr,subStr)