小甲鱼python课后习题【16,17,18,19,20】

【学习笔记，仅供学习交流使用，知识源于鱼c论坛】

作业16：

测试题：

0、我们根据列表、元祖和字符串的共同特点，把它们三统称为什么？
序列
  1）都可以通过索引得到每一个元素
  2）默认索引值总是从0开始（当然灵活的Python还支持负数索引）
  3）可以通过分片的方法得到一个范围内的元素的集合
  4）有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

1、请问分别使用什么BIF，可以把一个可迭代对象转换为列表、元祖和字符串？
  list(),tuple(),str()
  list([iterable]) 把可迭代对象转换为列表
  tuple([iterable]) 把可迭代对象转换为元祖
  str(obj) 把对象转换为字符串

1.  >>> temp = 'I love FishC.com!'
2.  >>> list(temp)
3.  ['I', ' ', 'l', 'o', 'v', 'e', ' ', 'F', 'i', 's', 'h', 'C', '.', 'c', 'o', 'm', '!']

2、你还能复述出“迭代”的概念吗？
  所谓迭代，是重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。

3、你认为调用 max(‘I love FishC.com’) 会返回什么值？为什么？
  会返回：‘v’，因为字符串在计算机中是以ASCII码的形式存储（ASCII对照表：http://bbs.fishc.com/thread-41199-1-1.html），参数中ASCII码值最大的是’v’对应的118。

4、哎呀呀，现在的小屁孩太调皮了，邻居家的孩子淘气，把小甲鱼刚写好的代码画了个图案，麻烦各位鱼油恢复下啊，另外这家伙画的是神马吗？怎么那么眼熟啊！？？

1.  name = input('请输入待查找的用户名：')
2.  score = [['迷途', 85], ['黑夜', 80], ['小布丁', 65], ['福禄娃娃', 95], ['怡静', 90]]
3.  IsFind = False
4.   
5.  for each in score:
6.      if name in each:
7.          print(name + '的得分是：', each[1])
8.          IsFind = True
9.          break
10.     
11. if IsFind == False:
12.     print('查找的数据不存在！')

动动手：

0、猜想一下 min() 这个BIF的实现过程

def min(x):
      Least = x[0]
For each in x:
If each < least
least = each
return(least)

1、视频中我们说 sum() 这个BIF有个缺陷，就是如果参数里有字符串类型的话就会报错，请写出一个新的实现过程，自动“无视”参数里的字符串并返回正确的计算结果

 def sum(x):
    result = 0
    
    for each in x:
        if (type(each) == int) or (type(each) == float):
            result += each
        else:
            continue
 
    return result
 
print(sum([1, 2.1, 2.3, 'a', '1', True]))
    

2、请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！

作业17：

测试题：

0、你有听说过DRY吗？
  DRY是程序员们公认的指导原则：Don’t Repeat Yourself.
  快快武装你的思维吧，拿起函数，不要再去重复拷贝一段代码了！

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

2、函数可以有多个参数吗？
   可以的，理论上你想要有多少个就可以有多少个，只不过如果函数的参数过多，在调用的时候出错的机率就会大大提高，因而写这个函数的程序员也会被相应的问候祖宗，所以，尽量精简吧，在Python的世界里，精简才是王道！

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

1.  def MyFun():
2.      # 我是函数体
3.      # 我也是函数体
4.      # 我们都属于函数MyFun()
5.  # 噢，我不属于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]
3.   
4.  >>> MyFun((3, 4), (1, 2))
5.  10

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

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

  会打印：Hello World!
  因为当Python执行到return语句的时候，Python认为函数到此结束，需要返回了（尽管没有任何返回值）。

动动手：

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

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

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

 def gcd(x, y):
    while y:
        t = x % y
        x = y
        y = t
    return x
    
print(gcd(4, 6))

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

 def Dec2Bin(dec):
    temp = []
    result = ''
    while dec:
        quo = dec % 2
        dec = dec // 2
        temp.append(quo)
    while temp:
        result += str(temp.pop())
    return result

print(Dec2Bin(62))

3、请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！

作业18：

测试题：

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

def MyFun(x):  
    return x**3  
y = 3  
print(MyFun(y))  

  x 是形参，y 是实参。函数定义过程中参数是形参，调用函数过程中的参数是实参。

1、函数文档和直接用“#”为函数写注释有什么不同？
函数文档是为了让其他人能更好的理解使用你的函数。
  def MyFunction():
“这是一个函数文档，放在函数定义的最开头部分\n第二行”
  print(‘I Love You!’)
我们看到在函数开头写下的字符串Ta是不会打印出来的,但Ta会作为函数的一部分存储起来,这个我们称之为函数文档字符串, Ta的功能跟注释是一样的。

函数的文档字符串可以按如下方式访问：
  MyFunction.doc
‘这是一个函数文档，放在函数定义的最开头部分\n第二行’
另外，我们用help()来访问这个函数也可以看到这个文档字符串。
  help(MyFunction)
  Help on function MyFunction in module main:
  MyFunction()
这是一个函数文档，放在函数定义的最开头部分

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

关键字参数是在调用函数时，带上函数参数的名字去指定调用哪个参数，从而不用按照参数的顺序调用参数。

不使用关键字参数可能出现以下现象：

def MyFunction1(he,she):  
    print('蒙多说%s是个大爷们'%he)  
    print('宝石说%s是个小娘们'%she)  
MyFunction1('拉克丝','德莱厄斯')  

蒙多说拉克丝是个大爷们
宝石说德莱厄斯是个小娘们
这样德莱厄斯的斧子可不答应喔，使用关键字参数即可，如下：

MyFunction1(she = '拉克丝',he ='德莱厄斯')  

蒙多说德莱厄斯是个大爷们
宝石说拉克丝是个小娘们

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

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.stout(标准输出流)  
    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.  
    #是否强制刷新流  

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

  默认参数是在函数定义时就为形参赋予初值，若调用函数时没有为形参传递实参，则使用用默认参数。关键字参数是在调用函数时，传递实参时指定对应的形参。

动动手：

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

def MyFunction2(*param, base = 3)
	'计算第一个参数的和，然后乘以第二参数的结果'  
    result = 0  
    for each in param:  
        result += each  
    result *= base  
    print('计算结果是：',result)  
MyFunction2(2,3,4,5,6)  

计算结果是： 60

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

def FindFlower():    
    '计算所有的水仙花数'    
    print('所有水仙花数：')    
    for each in range(100,1000):    
        baiwei = each//100    
        shiwei = (each - 100*baiwei)//10    
        gewei = each%10    
        count = baiwei**3 + shiwei**3 + gewei**3    
        if count == each:    
            print(each, end = '\t')    
    

FindFlower()
所有水仙花数：153 370 371 407

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

def findstr(str1,str2):    
    '统计第一个字符串参数（长度为2）在第二个字符串参数出现次数'    
    length = len(str2)    
    count = 0    
    if str1 not in str2:    
        print('在目标字符串中未找到子字符串！')    
    else:    
        for each in range(length - 1):    
            if str2[each] == str1[0]:    
                if str2[each + 1] == str1[1]:    
                    count += 1    
    print('子字符串在目标字符串中共出现%d次' %count)    

  findstr(‘im’,‘You cannot improve your past, but you can improve your future. Once time is wasted, life is wasted.’)
  子字符串在目标字符串中共出现3次

作业19：

测试题：

0、下边程序会输出什么？

def next():  
    print('我在next()函数里...')  
    pre()  
  
def pre():  
    print('我在pre()函数里...')  
  
next()  

输出如下：
我在next()函数里…
我在pre()函数里…

1.请问以下这个函数有返回值吗？

def hello():  
    print('Hello FishC!')  

  这个函数返回值 None，python的函数都是有返回值的，所以17课的动动手的习题2才会那样打印的。
  print(hello())
  Hello FishC!
  None

2.请问Python的return语句可以返回多个不同类型的值吗？
  可以，默认用逗号隔开，是以元组的形式返回，也可以用列表包含起来返回。

def MyFunction():  
    return 1,'allen','小甲鱼'  
 MyFunction()  
(1, 'allen', '小甲鱼')  
def MyFunction():  
    return [1,'allen','小甲鱼']  
MyFunction()  
[1, 'allen', '小甲鱼']  

3.请目测以下程序会打印什么内容？

def fun(var):  
    var = 1314  
    print(var, end = '')  
  
var = 520  
fun(var)  
print(var)  

会打印1314520。因为函数对var的赋值操作只在函数内有效。

4.目测以下程序会打印什么内容？

var = 'Hi'  
  
def fun1():  
    global var  
    var = ' Baby '  
    return fun2(var)  
  
def fun2(var):  
    var += 'I love you'  
    fun3(var)  
    return var  
  
def fun3(var):  
    var = ' 小甲鱼 '  
  
print(fun1())  

结果如下：
Baby I love you

动动手：

0、编写一个函数，判断传入的字符串参数是否为“回文联”

def huiwen(string): 
    '判断传入的字符串是否为回文联' 
    list1 = list(string)  
    list2 = list(reversed(string))  
    if list1 == list2:  
        return '是回文联'  
    else:  
        return '不是回文联'  
  
print(huiwen('上海自来水来自海上'))  

运行结果：
是回文联

写程序的时候写错了一个版本，如下：

def huiwen(string):  
    '判断传入的字符串是否为回文联'
    list1 = list(string)  
    list2 = list1.reverse()  
    if list1 == list2:  
        return '是回文联'  
    else:  
        return '不是回文联'  
  
print(huiwen('上海自来水来自海上'))  

运行结果：
不是回文联
  原因是list的reverse()方法是返回None的，只会对列表内的元素逆序排序。而string的reserved()方法是会返回逆序后的字符串的。

1、编写一个函数，分别统计传入字符串参数（可能不止一个参数）的英文字母、空格、数字和其它字符的个数。

def tongji(*param):
    '判断传入的参数中英文字母，空格，数字，其他字符的个数'  
    length = len(param)  
    for i in range(length):  
        letters = 0  
        space = 0  
        number = 0  
        other = 0  
        for each in param[i]:  
            if each.isalpha():  
                letters += 1  
            elif each.isspace():  
                space += 1  
            elif each.isdigit():    
                number += 1    
            else:    
                other += 1    
        print('第%d个字符串共有：%d个英文字母，%d个空格，%d个数字，%d个其他字符'%(i+1,letters,space,number,other))     
    
tongji('1 love y0u~~~','i am better 1314 ### &1')    

运行结果：
第1个字符串共有：6个英文字母，2个空格，2个数字，3个其他字符
第2个字符串共有：9个英文字母，5个空格，5个数字，4个其他字符

作业20：

测试题：

0、如果希望在函数中修改全局变量的值，应该使用什么关键字？
  使用global关键字。
1、在嵌套的函数中，如果希望在内部函数修改外部函数的局部变量，应该使用什么关键字？
  使用nonocal关键字。

>>> def outside():  
           number = 4  
           def inside():  
               nonlocal number  
               number *= number  
               return number  
           return inside()  
         
>>> outside()  

打印结果：16

2、Python的函数可以嵌套，但是注意访问的作用域问题哦，请问以下代码存在什么问题？

def outside():  
       print('I am outside!')  
       def inside():  
              print('I am inside!')  
         
inside()  

函数嵌套中，内部函数只能在外部函数的范围内调用，改为:

def outside():  
       print('I am outside!')  
       def inside():  
              print('I am inside!')  
       inside()  
outside()

3.请问为什么代码A没有报错，但是代码B报错了？应该如何修改？代码A：

def outside():  
       var = 5  
       def inside():  
           var = 3  
           print(var)  
       inside()  
         
outside() 

代码B：

def outside():  
       var = 5  
       def inside():  
           print(var)  
           var = 3 
       inside()  
outside()  

  因为代码B中var没有定义就使用print打印var，外层函数的var变量内层函数不能访问。

4.请问如何访问funIn()呢？

def funOut():  
       def funIn():  
           print('宾果！你成功访问到我啦')  
       return funIn()  

直接调用funOut函数即可：
funOut()
宾果！你成功访问到我啦

5.请问如何访问funIn()呢？def funOut():

   def funIn():  
       print('宾果！你成功访问到我啦')  
   return funIn  

得加一个小括号：

>>> print(funOut())  
<function funOut.<locals>.funIn at 0x0000021DADD9E9D8>  
>>> type(funOut())  
<class 'function'>  
>>> funOut()()  

宾果！你成功访问到我啦
我觉得funOut函数返回的funIn类似C语言中的函数名，是一个地址。

6.以下是“闭包”的一个例子，请你目测下会打印什么内容？,

def funX():  
       x = 5  
       def funY():  
           nonlocal x  
           x += 1  
           return x  
       return funY  
 
a = funX()     
print(a())  
print(a())  
print(a())  

打印6,7,8。只要认为funX()函数返回的是funY()的地址就能理解了，a()只不过是调用funY()。