学习python第十五天

0. 你有听说过DRY吗？

答：DRY 是程序员们公认的指导原则：Don't Repeat Yourself.


1. 都是重复一段代码，为什么我要使用函数（而不使用简单的拷贝黏贴）呢？

使用函数有以下好处：

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

2. Python 的函数最多能有几个参数？

答：理论上想要有多少个就可以有多少个，只不过如果函数的参数过多，在调用的时候出错的机率就会大大提高，所以，尽量精简。

3. 创建函数使用什么关键字，要注意什么？

答：使用 “def” 关键字，要注意函数名后边要加上小括号 “()”，然后小括号后边是冒号 “:”，然后缩进部分均属于函数体的内容，例如：
 

1. def MyFun():
2.     # 我是函数体
3.     # 我也是函数体
4.     # 我们都属于函数MyFun()
6. # 噢，我不属于MyFun()函数的了

4. 请问这个函数有多少个参数？
 

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

答： 0，因为类似于这样的写法是错误的，函数的参数需要的是变量，而这里试图用“元祖”的形式来传递是不可行的。

应该这样：

1. >>> def MyFun(x, y):
2.         return x[0] * x[1] - y[0] * y[1]
4. >>> MyFun((3, 4), (1, 2))
5. 10

5. 请问调用以下这个函数会打印什么内容？
 

1. >>> def hello():
2.         print('Hello World!')
3.         return
4.         print('Welcome To FishC.com!')

答：
 

1. >>> hello()
2. Hello World!

因为当 Python 执行到 return 语句的时候，Python 认为函数到此结束，需要返回了。

0. 编写一个函数 power() 模拟内建函数 pow()，即 power(x, y) 为计算并返回 x 的 y 次幂的值。
 

1. def power(x, y):
2.     result = 1
3.    
4.     for i in range(y):
5.         result *= x
7.     return result
9. print(power(2, 3))

或者：

1. def power(x,y):
2.     return x ** y

1. 编写一个函数，利用欧几里得算法（脑补链接）求最大公约数，例如 gcd(x, y) 返回值为参数 x 和参数 y 的最大公约数。
 

1. def gcd(x, y):
2.     while y:
3.         t = x % y
4.         x = y
5.         y = t
7.     return x
8.    
9. print(gcd(4, 6))

2. 编写一个将十进制转换为二进制的函数，要求采用“除2取余”（补脑链接）的方式，结果与调用 bin() 一样返回字符串形式。
 

1. def Dec2Bin(dec):
2.     temp = []
3.     result = ''
5.     while dec:
6.         quo = dec % 2
7.         dec = dec // 2
8.         temp.append(quo)
10.     while temp:
11.         result += str(temp.pop())
13.     return result
15. print(Dec2Bin(62))

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

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

x是形式参数（形参），y是实际参数（实参）。
跟绝大部分编程语言一样，形参指的是函数创建和定义过程中小括号里的参数，而实参指的是函数在调用过程中传递进去的参数。
     
     
1. 函数文档和直接用“#”为函数写注释有什么不同？

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

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

在函数开头写下的字符串是不会打印出来的，但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='小甲鱼')

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


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，基数不参与求和计算。
 

1. def mFun(*param, base=3):
2.     result = 0
3.     for each in param:
4.         result += each
6.     result *= base
7.    
8.     print('结果是：', result)
10. mFun(1, 2, 3, 4, 5, base=5)

1. 寻找水仙花数

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

1. def Narcissus():
2.     for each in range(100, 1000):
3.         temp = each
4.         sum = 0
5.         while temp:
6.             sum = sum + (temp%10) ** 3
7.             temp = temp // 10  # 注意这里用地板除
9.         if sum == each:
10.             print(each, end='\t')
12. print("所有的水仙花数分别是：", end='')
13. Narcissus()

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

1. def findStr(desStr, subStr):
2.     count = 0
3.     length = len(desStr)
4.     if subStr not in desStr:
5.         print('在目标字符串中未找到字符串!')
6.     else:
7.         for each1 in range(length-1):      
8.             if desStr[each1] == subStr[0]:
9.                 if desStr[each1+1] == subStr[1]:
10.                     count += 1
11.                     
12.         print('子字符串在目标字符串中共出现 %d 次' % count)
14. desStr = input('请输入目标字符串：')
15. subStr = input('请输入子字符串(两个字符)：')
16. findStr(desStr, subStr)