函数：形参与实参，函数文档，关键字参数

参数存在的价值
函数因为参数而灵活，没有参数，一个函数就只能死板的完成一个功能，一个任务。
参数从调用的角度来说，分为形式参数与实际参数，形参指函数创建和定义过程中小括号里的参数，实参指函数在被调用的过程中传递进来的参数。

函数文档
为了描述函数的功能，是为了给别人看的，功能与注释一样。
作用：
1.与注释一样，可以让别人更好的阅读，不同之处在于字符串可以通过特殊属性__doc__获取
2.当一个函数不确定用法时候，可以通过help（）函数来查看函数的文档，即便是自己定义的函数也可以

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

>>> exchangeRate(10)
65.0
>>> exchangeRate.__doc__
'美元——>人民币\n                   汇率暂定为6.5\n                 '
>>> help(exchangeRate)
Help on function exchangeRate in module __main__:

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

关键字参数
普通的参数叫位置参数，只是在调用过程中，很容易搞乱位置参数的顺序，以至于函数无法按照预期实现，因此，有了关键字参数，可以解决这个潜在问题。
关键字参数其实就是在传入实参时候指定形参的变量名，这样即便顺序出问题也没事的

>>> def saylove(name,things):
	print(name+' love '+things)

	
>>> saylove('I','python')
I love python
>>> saylove(things='python',name='I')
I love python

默认参数
默认参数是定义时候赋予了默认值的参数
使用默认参数时候，就可以不带参数去调用函数，所以，与关键字之间的区别是：
关键字参数是在函数调用时候，通过参数名指定要赋值的参数，解决顺序问题，默认参数是在函数定义时候，为形参赋初值，当调用的时候，不需要传递实参，默认使用形参的初始值代替

>>> def saylove(name='i',things='python'):
	print(name+' love '+things)

	
>>> saylove()
i love python
>>> saylove('苏轼','不识庐山真面目，只缘身在此山中')
苏轼 love 不识庐山真面目，只缘身在此山中

收集参数
也称为可变参数，出现的理由是有时候作者也不知道自己创建的函数到底有多少个参数，这个时候，只需要在参数前面加上※即可。

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

	
>>> aaa('i','l','o','v','e')
5个参数
第二个参数是: l

python就是把标志为收集参数的参数们打包成一个元组，只是如果在收集参数后面还需要指定其他参数，在调用函数的时候就应该使用关键参数来指定，否则就会把实参都列入收集参数的范畴内。

>>> def test(*a,b):
	print('收集参数是:',a)
	print('位置参数是:',b)

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

当然也可以使用默认参数

>>> def test(*a,b='8'):
	print('收集参数是:',a)
	print('位置参数是:',b)

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

星号其实可以打包，也可以解包

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

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

课后题
1.以下哪个是形参，哪个是实参？

def MyFun(x):
    return x ** 3

y = 3
print(MyFun(y))

2. 函数文档和直接用“#”为函数写注释有什么不同？
   3.使用关键字参数，可以避免什么问题的出现？
   4.使用help(print)查看print()这个BIF有哪些默认参数？分别起到什么作用？
   5.默认参数和关键字参数表面最大的区别是什么？

解：
1.x是形式参数，y是实际参数

2.为了让别人更好的理解自己的函数
在函数开头写下的字符串Ta是不会打印出来的，但Ta会作为函 数的一部分存储起来，这个我们称之为函数文档字符串，Ta的功能跟注释是一样的。
只是函数文档可以查看，使用函数名.doc
也可使用help查看文档字符串

3.按照参数的顺序调用函数

>>> 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.
    # 是否强制刷新流

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

动手题：
1.编写一个符合以下要求的函数：
a) 计算打印所有参数的和乘以基数（base=3）的结果
b) 如果参数中最后一个参数为（base=5），则设定基数为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)

2.找出所有的水仙花数

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

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

def findStr(desStr, subStr):
    count = 0
    length = len(desStr)
    if subStr not in desStr:
        print('在目标字符串中未找到字符串!')
    else:
        for each1 in range(length-1):      
            if desStr[each1] == subStr[0]:
                if desStr[each1+1] == subStr[1]:
                    count += 1
                    
        print('子字符串在目标字符串中共出现 %d 次' % count)

desStr = input('请输入目标字符串：')
subStr = input('请输入子字符串(两个字符)：')
findStr(desStr, subStr)