我这个小白学习Python课后习题的不同答案讨论（准备长期更新）

icewin

这是关于我学习小甲鱼（小污龟）老版《零基础入门学习Python》的课后题不同答案（异曲同工？小补充？）
前面就有一些，但是本小白没有点懒，从17课开始吧
[url=第017讲：函数 - Python的乐高积木 | 课后测试题及答案 https://fishc.com.cn/thread-41663-1-1.html (出处: 鱼C论坛)]17课[/url]
========================================
关于欧几里德最大公约数，相当于补充了（x,y）大小顺序
def gcd(x,y):
    if x>y:
        while x%y!=0:
            a=x%y
            x=y
            y=a
        return y
    else:
        c=x
        x=y
        y=c
        while x%y!=0:
            a=x%y
            x=y
            y=a
        return y
=============================================
关于10进制转2进制，我还跑去更新了下百度词条，不知道能不能成功哈哈！
这里相当于增加了0和负数的输入性
def bilibili(b):
    t=[]
    i=''
    e=''
    while b<0:
        b=-b
        i='-'
    while b//2!=0:
        a=b%2
        t.append(a)
        b=b//2
    if b!=0:
        t.append(1)
    else:
        t.append(0)
    while t:
        e+=str(t.pop())

    return (i+"0b"+e)

#b要为整数,效果同内置函数bin（）
========================================
有什么优化或者建议欢迎补充

icewin

第18课[url=第018讲：函数：灵活即强大 | 课后测试题及答案 https://fishc.com.cn/thread-42532-1-1.html (出处: 鱼C论坛)]第018讲：函数：灵活即强大 | 课后测试题及答案 https://fishc.com.cn/thread-42532-1-1.html (出处: 鱼C论坛)[/url]
=======================
动动手0
开始我也是和小污龟一样想法，甚至还用了if语句来判断末尾是否等于5，后来想想好像这个题本意不是这个意思，然后就
def su3m(*team,base=3):
    reversed(team)
    return sum(team)*base
==========================
动动手1，开始还以为是小污龟偷懒搞一样的题，然后实力提高的我简单构想了下更复杂的位数组合，但是没有打代码，
看了小污龟的那个放在末端的print（）缩进真的牛啤，第一次知道可以这样玩缩进达到输出顺序改变，
还有就是那个//加while循环感觉很好，比我构想的切片循环取数要简洁得多
小污龟这个牛啤，我就不发我的弟弟代码了
===========================
    动手2，算是偷懒了吧直接用了count，感觉没有领悟小污龟的用意
def findstr():
    t=input("请输入目标字符串:")
    t1=input("请输入子字符串（两个字符）：")
    t2=t.count(t1)
    print('子字符串在目标字符串中共出现',t2,'次')
    return
   
   

icewin

哈哈 我把百度百科那个词条更新了
原版

原版

==================
我增补后的bilibili版

我

icewin

19课第019讲：函数：我的地盘听我的 | 课后测试题及答案
https://fishc.com.cn/thread-42573-1-1.html
(出处: 鱼C论坛)
=======================
看到第4题感觉不对劲，想了下如果都是def fun1（）会怎么样，然后试了下，结果是相当于从新把 fun1()写了一次，旧的删了
然后看这个题，中了小甲鱼圈套，return这个返回值，还是很重要的知识点！！！
=======================
动动手0我的版本如下

1. def whl():
   
2.    
   
3.     t2=list(t)
   
4.     t2.reverse()
   
5.     i=0
   
6.     a=(len(t)//2)
   
7.     for x in range(a):
   
8.         if t[i]==t2[i]:
   
9.             i+=1
   
10.     if i==a:
    
11.         print('是文回联')
    
12.     else:
    
13.         print('不是文回联！')
    
14.    
    
15. t=input('请输入一句话：')
    
16. whl()
    

复制代码

感觉小甲鱼的方法1基础逻辑性很好，但是逻辑太多不容易看懂
方法2和我的基本一样，但我让计算量少了一半，和方法1里面那个//2一样
不过还是小甲鱼规范与一些用的return返回数据
===========================================
动手1我的就很弟弟级别了

1. def count1(a):
   
2.     c=("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
   
3.     d='1234567890'
   
4.     e=" "
   
5.     C=0
   
6.     D=0
   
7.     E=0
   
8.     F=0
   
9.     for x in a:
   
10.         if x in c:
    
11.             C+=1
    
12.         elif x in d:
    
13.             D+=1
    
14.         elif x in e:
    
15.             E+=1
    
16.         else:
    
17.             F+=1
    
18.     print("个字符串共有英文字母",C,"个,","数字",D,"个,","空格",E,'个','其他字符',F,"个。")
    
19.    
    
20. def count(a1,a2):
    
21.     A1=print("第1",end=''),count1(a1)
    
22.      
    
23.     A2=print("第2",end=''),count1(a2)
    
24.     return A1,A2
    
25. 
    
26. 
    
27. 
    
28. count('I love fishc.com.','I love you ,you love me.')
    

复制代码

小甲鱼用的收集参数（我看了其他地方资料这个也叫不定长参数），这个就很nice，另外那个%d格式化整数的用法很惊艳
还有就是字符串那节历史遗留问题，太多内置函数，我使用经常出现语法错误，都不敢用了。

icewin

第20 课[url=第020讲：函数：内嵌函数和闭包 | 课后测试题及答案 https://fishc.com.cn/thread-42685-1-1.html (出处: 鱼C论坛)]第020讲：函数：内嵌函数和闭包 | 课后测试题及答案 https://fishc.com.cn/thread-42685-1-1.html (出处: 鱼C论坛)[/url]
我都快要被劝退了！！！！！！！
这里没讲域什么的，我是真难理解，查了乱七八糟的零零散散的资料，总结是先不去理解反正课后题关系不大，学过的暂时基本够用
放出我半成品的动动手答案，这里我很费解为什么input（）不能用，我打算先将这些问题放一下，当然有高手愿意不辞劳苦指出我的问题，我是非常感激的

1. t=input('输入telegram')
   
2. 
   
3. 
   
4. def zifu():  #先试图把字符搞出来变成一个独立列表，然后想办法取出来搞count
   
5.     w=[]
   
6.     for m in t:         #按理说局部变量里面不能给全局变量赋值，但使用这个for好像没什么影响
   
7.         if m not in w:
   
8.             w.append(m)
   
9.     for i in w:
   
10.         a=t.count(i)
    
11.         c=print(i,a)
    
12.         
    
13. print('字符和次数：',zifu())
    
14. #失败了，转义字符等问题没解决,想过用'''或r，但是少了input就少了灵魂，看了答案很失望，还是用的暴力
    

复制代码

=======================

1. def mima():
   
2.     t=input("密码")
   
3.     t=t.replace('\n',"")
   
4.     i=2
   
5.     key=[]
   
6.     for x in t[3:-3]:
   
7.         i+=1
   
8.         if x.islower()==True:
   
9.             
   
10.             x1=t[(i-3):i]
    
11.             x2=t[(i+1):(i+4)]
    
12.             
    
13.             if 3<i< (len(t)-4):
    
14.                 x3=t[i-4]
    
15.                 x4=t[i+4]
    
16.                 if (x1.isupper()==True)and(x2.isupper()==True)and(x3.isupper()==False)and(x4.isupper()==False):
    
17.                     key.append(x)
    
18.             else:
    
19.                 if i==3:
    
20.                     x4=t[i+4]
    
21.                     if(x1.isupper()==True) and (x2.isupper()==True)and(x4.isupper()==False):
    
22.                         key.append(x)
    
23.                 if i==len(t)-4:
    
24.                     if(x1.isupper()==True) and (x2.isupper()==True)and(x3.isupper()==False):
    
25.                         key.append(x)
    
26.     return key
    
27. print(mima())
    
28. #呕心沥血找的是单个字母，前功尽弃，后来发现是对的，只是不能用input
    

复制代码

==============
我就做了个不限单小写字母的，但是有个末尾bug和其他bug，原因不清楚，先放着，以后懂的语法多了应该就ok

1. def mima():
   
2.     t=input("密码")
   
3.     t=t.replace("\n","")
   
4.     i=2
   
5.     key=[]
   
6.     p=[]
   
7.    
   
8.             
   
9.     for x in t[3:-4]:
   
10.         i+=1
    
11.         if x.islower():
    
12.             p.append(x)   
    
13.             continue
    
14.         x1=t[(i-3-len(p)):(i-len(p))]
    
15.         x2=t[i:(i+3)]
    
16.             
    
17.         if 3<(i-len(p)) and i< (len(t)-3):
    
18.             x3=t[i-4-len(p)]
    
19.             x4=t[i+3]
    
20.             if (x1.isupper())and (x2.isupper())and(x3.isupper()==False)and(x4.isupper()==False):
    
21.                 key.extend(p)
    
22.         else:
    
23.             if (i-len(p))==3:
    
24.                 x4=t[i+3]
    
25.                 if(x1.isupper()) and (x2.isupper())and(x4.isupper()==False):
    
26.                     key.extend(p)
    
27.                   
    
28.               
    
29.             if i==len(t)-3:
    
30.                 x3=t[i-4-len(p)]
    
31.                 x2=t[-3:]
    
32.                 if (x1.isupper()) and (x2.isupper()) and (x3.isupper()==False) :
    
33.                     key.extend(p)
    
34.         p=[]
    
35.    
    
36.                
    
37.     return key
    
38. print(mima())
    
39. 
    
40. #虽然不知道为什么我这个无法搞出 if i==len(t)-3:这个里面的测试，虽然我第一次做得是符合题意的，虽然有点问题，这个不符合题意，但这个bug很纠结

复制代码

==================
ps：这节课可能教学顺序有点问题，让人很难理解和运用，但是可以先不去理解，先放着，半懂就可以，后面我查了资料，等课程学到后面，前面问题会解决，希望别被劝退，我差点就被劝退了，哈哈

icewin

21课没多少想说的，挺简单，就是第3题感觉range（1，100）应该改成range（3，101）这样比较好，毕竟100以内也包括100嘛
第4题没给题目 答案，自由发挥如果是第3题那样可以这样玩
[ i for i in range(1, 100) if not(i%3)]

list(filter(lambda x:not (x%3),range(1,101)))

我找了一个复杂的[x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]这就尴尬了，2个参数首先iterable就不好搞了嵌套循环想不出办法，想了个办法是曲线救国
filter是筛选器，这里面临2个参数要筛选，写下来发现比列表推导式展开还复杂，就放弃了，尝试了许多想法，Error使我强大

icewin

24课，我写的都是伪递归，没能把握递归精髓>>>

大繁化简（复杂问题简单化，公式化，这是最骚的（最难办到），也是第一步思考的逻辑，天才逻辑）-->归途应变（巧妙安插返回值的顺序或方案精简代码）
举个例子：发一下我的弟弟代码，用了递归却显得代码很臃肿

1. def bin6(n,t=[]):         
   
2.     t.append(str(n%2))
   
3.     if n==1:
   
4.         print("0b",end="")
   
5.         while t:
   
6.             print(t.pop(),end="")  
   
7.     else:
   
8.         return bin6(n//2,t)
   
9. n=int(input("输入整数"))
   
10. bin6(n)

复制代码

如果思考是是return bin6(n//2)+str(n%2) 这种逻辑排布，将省去很多繁琐的代码结构。

icewin

25课
第5题我直接用的元组从新输入，看到答案那个split(',')我才想起来字符bif牛啤
动手题

1. print('''
   
2. |---欢迎进入通讯录程序---|
   
3. ''')
   
4. t=print('''
   
5. |---1：查询联系人资料 ---|
   
6. |---2：插入新的联系人 ---|
   
7. |---3：删除已有联系人 ---|
   
8. |---4：退出通讯录程序 ---|
   
9. ''')
   
10. 
    
11. dict1={}
    
12. while 1:
    
13.     g=print(' ')
    
14.     a=int(input("请输入相关的指令代码："))
    
15.     if a==4:
    
16.         print('|---感谢使用通讯程序---|')
    
17.         break
    
18.     else:
    
19.         b=input("请输入联系人姓名：")
    
20.         if a ==1:
    
21.             if b in dict1:
    
22.                 print(b+' : '+dict1[b])
    
23.             else:
    
24.                 print('没有这个人呐，兄弟')
    
25.         elif a==2:
    
26.             if b  in dict1:
    
27.                 print('您输入的姓名在通讯录中已存在-->>'+b+dict1[b])
    
28.                 d=input('是否修用户资料（YES/NO）:')
    
29.                 if d=='YES':
    
30.                     del dict1[b]
    
31.                 else:
    
32.                     continue
    
33.             c=input('请输入用户联系电话：')
    
34.             dict1[b]=c
    
35.         elif a==3:
    
36.             if b in dict1:
    
37.                 del dict1[b]
    
38.             else:
    
39.                 print('冒得这个人')
    
40.             continue
    
41.         else:
    
42.             print("请按提示输入"+t)
    

复制代码

大体上和小甲鱼差不多，小甲鱼input用得比较6少了几行

icewin

26课动手题

1. def niupi():
   
2.     a='''
   
3. |---新建用户：N/n---|
   
4. |---登录帐号：E/e---|
   
5. |---退出程序：Q/q---|
   
6. '''
   
7.     c={}
   
8.     g=['n','e','q','Q','N','E']
   
9.     while 1:
   
10.         print(a)
    
11.         b=input("|---请输入指令代码：")
    
12.         if b not in g:
    
13.             continue
    
14.         
    
15.         if b=='N' or b=='n':
    
16.             d=input("请输入用户名：")
    
17. 
    
18.             while (d in c)or(d==''):
    
19.                 d=input('此用户名已经被使用，请重新输入：')
    
20.             e=input('请输入密码：')
    
21.             while e=='':
    
22.                 print('密码不能为空')
    
23.                 e=input("请输入密码：")
    
24.             c[d]=e
    
25.             print('注册成功赶紧试试登录吧小污龟差差oo')
    
26.             continue
    
27.         if b=='E' or b=='e':
    
28.             d=input("请输入用户名：")
    
29.             while d not in c:
    
30.                 d=input('此用户不存在请重新输入：\n(返回上层按Q )')
    
31.                 if d=="Q":
    
32.                     break
    
33.                     
    
34.             if d=="Q":
    
35.                 continue   
    
36.             e=input("请输入密码：")
    
37. 
    
38.             while c.get(d)!=e:
    
39.                 e=input('密码不对(返回上一级q)')
    
40.                 if e=='q':
    
41.                     break
    
42.             if c.get(d)==e:
    
43.                 print('欢迎进入小污龟系统，请点右上关掉这个程序')
    
44.                 break
    
45.             
    
46.         if b=='Q' or b=='q':
    
47.             break
    
48. 
    
49. 
    
50.             
    
51. niupi()
    
52. 
    

复制代码

小污龟的14行密码设置可以为空，开始我担心.get（）会直接让等号失效，后来测试发现密码帐号可以为空，因为input输入的是‘’而不是None，我多虑了，另外小甲鱼密码输错应该会弹到第一个循环，我的是多次输入，按Q返回上层。不知道分多个函数好还是用一个函数封装好。

icewin

29课圆满完成，先发课堂练习，因为封装比较丑，算个半成品

1. def split1(i):
   
2.     b='f:\\boy_'+str(i)+'.txt'
   
3.     g='f:\\girl_'+str(i)+'.txt'
   
4.     global boy ,girl             #虽然解决繁琐的问题，但是小甲鱼说过global是隐患，所以我又觉得不妥
   
5.     boy=open(b,'a+')
   
6.     girl=open(g,'a+')             #有没有办法弄成nonlocal 或lambda，我测试了
   
7.                                  #报错说是function没有write属性，所以
   
8.    
   
9. def save1():
   
10.     f=open('f:\\record.txt')
    
11.     i=1
    
12.    
    
13.     split1(i)
    
14.     for a1 in f:
    
15.         if '========'in a1:
    
16.             boy.close()
    
17.             girl.close()
    
18.             i+=1
    
19.             split1(i)
    
20.             continue
    
21.         if "小甲鱼:"in a1:
    
22.             boy.write(a1[4::])
    
23.         if "小客服:"in a1:
    
24.             girl.write(a1[4::])
    
25.         
    
26.     boy.close()
    
27.     girl.close()
    
28.     f.close()
    
29. 
    
30.         
    
31. save1()
    

复制代码

比小甲鱼看起来要简单粗暴一点点，当然不够优雅
动手题0

1. def savetxt1():
   
2.     name =input('请输入文件名')
   
3.     file_write=input('请输入内容【单独输入‘:w’保存退出】:\n')
   
4.     name1='f:\\'+name+'.txt'
   
5.     f=open(name1,'a+')
   
6.     while file_write !=':w':
   
7.         
   
8. 
   
9.         f.write(file_write+'\n')
   
10.         file_write=input()
    
11.     f.close()
    
12. 
    
13. 
    
14. 
    
15. savetxt1()
    
16. 
    

复制代码

基本是一样的，只是我用的while 判断，小甲鱼用了if else，从行数来说我略胜一筹。
动手题1
我一直思考怎么同步行数比较用了字典，感觉很牛批，看到小甲鱼直接用.readline（）的指针，就感觉小污龟就是小污龟，666，虽然这把被小污龟ko了，但字典同步打开了新思路

1. def different():
   
2.     name1='f:\\'+input('请输入第一个文件名:')+'.txt'
   
3.     name2='f:\\'+input('请输入另一个文件名:')+'.txt'
   
4.     f1=open(name1,'r')
   
5.     f2=open(name2,'r')
   
6.     i=0
   
7.     line1=0
   
8.     d1={}
   
9.     list1=[]
   
10.     for fx1 in f1:
    
11.         line1+=1
    
12.         d1[line1]=fx1
    
13.     line1=0
    
14.     for fx2 in f2:
    
15.         line1+=1
    
16.         x1=d1[line1]
    
17.         if x1 != fx2:
    
18.                 i+=1
    
19.                 list1.append(line1)
    
20.     print('两个文件共有【',i,'】处不同')
    
21.     for x in list1:
    
22.         print('第',x,'行不一样')
    
23.         
    
24.     f1.close
    
25.     f2.close
    
26. different()
    

复制代码

动手题2，由于指针理解不够，不怎么会.readline（）我写的就是个弟弟，就不发了
动手题3行数来看差不多，但逻辑完全不一样

1. def lineP():
   
2.     file=input('请输入要打开的文件（c:\\text.txt）:')
   
3.     file1=open(file,'r')
   
4.     line=input('请输入需要显示该文件行数【格式如13:21或:21或21:】：')
   
5.     linelist=line.split(':')
   
6.    
   
7.     i=0
   
8.     i1=linelist[0]
   
9.     i2=linelist[1]
   
10.     if i1=='' and i2!='':
    
11.         print('文件',file,'从开始到第',i2,'行内容如下：')
    
12.         i1=0
    
13.         
    
14.     elif i2==''and i1!='':
    
15.         print('文件',file,'从第',i1,'行到末尾内容如下：')
    
16.         i2=len(file1.read())      #取一个大于等于总行数的数想出来的办法
    
17.         file1.seek(0)
    
18. 
    
19.     elif i1=='' and i2=='':
    
20.         print('文件',file,'全文内容如下：')
    
21.         i1=0
    
22.         i2=len(file1.read())
    
23.         file1.seek(0)
    
24. 
    
25.     else:
    
26.         print('文件',file,'从第',i1,'行到第',i2,'行内容如下：')
    
27.     i1=int(i1)
    
28.     i2=int(i2)
    
29.         
    
30.     for x in file1:
    
31.         i+=1
    
32.         if i>=i1 and i<=i2:
    
33.             print(x)
    
34.                
    
35.     file1.close()
    
36. lineP()

复制代码

第四题，感觉差不多，似乎我的更容易理解

1. def x():
   
2.     name1=input('请输入文件名：')
   
3.     name='f:\\'+name1
   
4.     old=input('请输入需要替换的单词或字符：')
   
5.     new=input('请输入新的单词或字符：')
   
6.    
   
7.     file=open(name,'r+')
   
8.     f=file.read()
   
9.    
   
10.     i=f.count(old)
    
11.     print('文件',name1,'中共有',i,'个【',old,'】')
    
12.     print('您确定把所有的【',old,'】替换成【',new,'】吗？')
    
13.     t=input('\n【YES/NO】:')
    
14.     if t=='yes'or t=='YES':
    
15.         f1=f.replace(old,new)
    
16.         file.close()
    
17.         file1=open(name,'w')
    
18.         file1.write(f1)
    
19.         
    
20.     file1.close()
    
21. x()
    
22. 
    
23.    
    

复制代码

icewin

被吞贴了？写半天，被吞了，算了就不发了。

icewin

30课第2题

1. def shou():
   
2.     import os
   
3.     f=input('请输入带查找的初始目录：')
   
4.     f1=input('请输入需要查找的目标文件：')
   
5.    
   
6.     t=list(os.walk(f))
   
7.   
   
8.     for (a,b,c) in t:
   
9.         if f1 in c :
   
10.             print(a+f1)
    
11. shou()
    

复制代码

看起来比课后答案要舒服一点点
第3题

1. def dianying():
   
2.     import os
   
3.   
   
4.     r=open('f:\\测试文件夹\\vedioList.txt','w+')
   
5.     r1=[]
   
6.     f='f:\\课堂练习'
   
7.     os.chdir(f)
   
8.     t=list(os.walk(f))
   
9.     for (a,b,c)in t:
   
10.         for x in c:
    
11.             if '.'in x:
    
12.                 f1=x.split('.')
    
13.                 if (f1[-1])in('mp4','avi','rmvb','mkv'):
    
14.                     r1.append(a+x+'\n')
    
15.     r.writelines(r1)
    
16.     r.close()
    
17. 
    
18. dianying()
    
19.                
    
20.             
    

复制代码

4

第4题行数其实差不多

1. def gjz():
   
2.     import os
   
3.     p=input('请将该脚本放于待查找的文件夹内，请输入关键字：')
   
4.     print('请问是否需要打印关键字【',p,'】在文件中的具体位置',end='')
   
5.     p1=input('（YES/NO）:')
   
6.    
   
7.     if p1== 'YES':
   
8.         f='f:\\课堂练习'
   
9.         f1=os.walk(f)
   
10.         for (a,b,c)in f1:                  #确定是否存在txt文件
    
11.             for x in c:
    
12.                 if '.'in x:
    
13.                     t=x.split('.')
    
14.                     if t[-1]=='txt':
    
15.                         ax=a+'\\'+x
    
16. 
    
17.                         weizi(ax,p)
    
18.                                 
    
19. def weizi(ax,p):           #打印文件位置，关键字位置
    
20.    
    
21.     f2=open(ax,'r')
    
22.     i=0       #行数
    
23.     o=0
    
24.     for x1 in f2:
    
25.         i+=1   
    
26.         if p in x1 :
    
27.             if o==0:                #设法只打印一次排头
    
28.                 print('='*75)
    
29.                 print("在文件【%s】中找到关键字【%s】"%(ax,p))   
    
30.                 o+=1
    
31.             r=0
    
32.             q=0
    
33.             s=[]
    
34.             while q!=-1:
    
35.                 q=x1.find(p,r)
    
36.                 r=q+3
    
37.                 if q!=-1:
    
38.                     s.append(q)
    
39.             print('关键字出现在第',i,'行,第',s,'个位置')
    
40.     f2.close()
    
41. 
    
42. gjz()
    

复制代码

icewin

31课开始的时候我以为没有换行符，想复杂了，搞半天跑起来不正常，后来分步测试，发现是我想多了，扫了眼答案根本吗记，自己从新写，写完发现和答案基本一样。。。。难受

1. import os
   
2. import pickle
   
3. os.chdir("f:\\课堂练习")
   
4. def split1(i,b1,g1):
   
5.     b='boy_'+str(i)+'.txt'
   
6.     g='girl_'+str(i)+'.txt'
   
7.     global boy ,girl            
   
8.     boy=open(b,'wb')
   
9.     girl=open(g,'wb')
   
10.     pickle.dump(b1,boy)
    
11.     pickle.dump(g1,girl)
    
12.     boy.close()
    
13.     girl.close()
    
14.                                 
    
15.    
    
16. def save1():
    
17.     f=open('f:\\课堂练习\\record.txt')
    
18.     i=1
    
19.     b1=[]
    
20.     g1=[]
    
21. 
    
22.     for a1 in f:
    
23.         if '========'in a1:   
    
24.             split1(i,b1,g1)
    
25.             b1=[]
    
26.             g1=[]
    
27.             i+=1
    
28.             continue
    
29.         if "小甲鱼:"in a1:
    
30.             b1.append(a1[4::])
    
31.         if "小客服:"in a1:
    
32.             g1.append(a1[4::])
    
33. 
    
34.     split1(i,b1,g1)
    
35. 
    
36.     f.close()
    
37. 
    
38.         
    
39. save1()
    

复制代码

icewin

35课最后一题，看到有人说二进制不报错，果断试试，感觉不错，我的代码如下

1. import easygui as gui
   
2. import os
   
3. list1=['.txt','.py']
   
4. dict1={'.txt':0,'.py':0}   #文件类型,和个数
   
5. dict2={'.txt':0,'.py':0}   #文件类型和行数
   
6. def file1(path1):    #判断文件是否为路径,更新字典
   
7.     a=os.listdir(path1)
   
8.     for i in range(len(a)):
   
9.         c=path1+'\\'+a[i]
   
10.         b=os.path.isdir(c)
    
11.         if b:               #准备写递归@_@,用walk不知道多好，非要要求用递归
    
12.             file1(c)        #调整了下框架，感觉好像递归行数要简洁一点
    
13.         else:
    
14.             d=os.path.splitext(c)[1]
    
15.             if d in dict1:
    
16.                 dict1[d]+=1
    
17.                 f=open(c,'rb')    #只读搞不了，二进制读取可以解读
    
18.                 dict2[d]=dict2[d]+len(f.readlines())
    
19. 
    
20.                 f.close()
    
21. 
    
22. path1=gui.diropenbox(msg='请选择您的代码库',title='浏览文件夹',default='f:\\课堂练习')
    
23. file1(path1)
    
24. ia=sum(dict2.values())
    
25. ib='%4.2f '%(ia/10e2)+'%'
    
26. ic=10e4-ia
    
27. msg1='您目前共累计编写了%s行代码，完度%s\n离10万行代码还差%s行,请继续努力'%(ia,ib,ic)
    
28. 
    
29. text0='【%s】源文件%s个，源代码%s行\n'
    
30. text1=''
    
31. for t in list1:
    
32.     text2=text0 %(t,dict1[t],dict2[t])
    
33.     text1+=text2
    
34.    
    
35. 
    
36. gui.textbox(msg=msg1,title='统计结果',text=text1)
    

复制代码

icewin

37课最后一题，我间接用了数学概率方法，但是这个表达似乎不怎么样帅气，现在实力有限

1. import random
   
2. class Xy:
   
3.         def __init__(self):   
   
4.                 x=random.randint(0,10)
   
5.                 y=random.randint(0,10)
   
6.                 self.xy=(x,y)
   
7.                 g=random.randint(0,5)
   
8.                 f=random.randint(0,2)
   
9.                 s=random.choice([-1,1])
   
10.                 self.g=g
    
11.                 self.f=f
    
12.                 self.s=s
    
13. 
    
14. gy=[(0,0),(0,1),(0,2),(1,1),(1,0),(2,0)]
    
15. fy=[(0,0),(0,1),(1,0)]
    
16. 
    
17. wg=[(Xy().xy)]
    
18. fish=[]
    
19. gh=100
    
20. for f1 in range(10):
    
21.         fish.append(Xy().xy)
    
22. print(wg,fish)
    
23. def guihp():#每回合后的hp
    
24.     global gh
    
25.     if gh>0:
    
26.         gh-=1       #一次吃多条
    
27.     for tt in fish:
    
28.         if tt==wg[0]:
    
29.             fish.remove(tt)
    
30.             gh+=20
    
31.     if gh>100:    #不加hp上限还能吃鱼，加了就更难了
    
32.         gh=100   
    
33.        
    
34. n=0
    
35. def huifan(n):  #边界回返，如果不回返改成停下来也可以，似乎更像甲鱼的行为
    
36.     if n<0:
    
37.         n=-n
    
38.     if 10<n:
    
39.         n=20-n
    
40.     return n
    
41. def gyidong():#乌龟一次移动
    
42.     wgy=gy[Xy().g]
    
43.     a=wg[0][0]+wgy[0]*Xy().s  #Xy().s是选择方向
    
44.     b=wg[0][1]+wgy[1]*Xy().s
    
45.     a=huifan(a)
    
46.     b=huifan(b)
    
47.     wg[0]=(a,b)
    
48. def fyidong():#鱼一次移动
    
49.     for fn in range(len(fish)):
    
50.         wfy=fy[Xy().f]
    
51.         (af,bf)=fish[fn]
    
52.         af=af+wfy[0]*Xy().s
    
53.         bf=bf+wfy[1]*Xy().s
    
54.         af=huifan(af)
    
55.         bf=huifan(bf)
    
56.         fish[fn]=(af,bf)
    
57.                
    
58. while gh:
    
59.     guihp()
    
60.     gyidong()
    
61.     fyidong()
    
62.     print(wg,fish,gh)
    
63.     if len(fish)==0:
    
64.         print('鱼全部死光光，乌龟胜利')
    
65.         break
    
66. if gh==0:
    
67.     print('这乌龟连个鱼都吃不完')
    

复制代码

关于构造函数总结，可能有不对的地方

1. class MyClass:
   
2.         name = 'FishC'
   
3.         def myFun(self):
   
4.                 print("Hello FishC!")
   
5.         def __init__(self):
   
6.                 self.r='kkkk'
   
7.                 self.c='llll'
   
8.                 print('666')
   
9. print(MyClass.name)#MyClass不带（）只提取属性，构造函数不运行，带括号自动运行。
   
10. print('0==='*20)
    
11. 
    
12. MyClass().myFun() #构造函数先自动运行，函数再运行，和类里面顺序无关。
    
13. 
    
14. print('1==='*20)
    
15. print(MyClass().r,MyClass().c)#这里类构造函数先运行2次，（这个并排优先级很奇怪），再提取里面方法
    
16. print('2==='*20)
    
17. 
    
18. 
    
19. MyClass().r         #构造函数运行一次，没有打印‘方法’
    
20. 
    
21. 
    
22. print('3==='*20)
    
23. x=MyClass()   #构造函数运行一次，下面用‘方法’，不再运行，直接提取‘方法’
    
24. print('4==='*20)
    
25. print(x.r,x.c)  #这样写很奇怪，可能就像餐余垃圾，是死的，如果每次想取随机数还是和类一起写，例如上面1-2
    
26. 
    
27. 
    
28. #如果说类是一个函数，那么类里面的构造函数就是这个类函数会自动执行的运算，调取构造函数里面‘方法’只不过是
    
29. #把运算完后的对应数据取出来，简单来说和一般函数没太大区别，但是因为类的存在使代码行数少了一些def 函数的命名操作
    

复制代码

关于range猜测

1. def range1(x):
   
2.     #姑且先把x想象成一个列表或元组，因为不了解更底层逻辑也只能先这样
   
3.     range1=[]
   
4.     if len(x)==1:
   
5.         a=0
   
6.         b=x
   
7.         c=1
   
8.     elif len(x)==2:
   
9.         a=x[0]
   
10.         b=x[1]
    
11.         c=1
    
12.     elif len(x)==3:
    
13.         a=x[0]
    
14.         b=x[1]
    
15.         c=x[2]
    
16.     while 1:
    
17.         try:
    
18.             range1.append(a)
    
19.             a+=c
    
20.             if b<=a:
    
21.                 break
    
22.         except:
    
23.             pass#不知道底层逻辑报错原因条件还写不出来
    
24.         
    
25.     return range1     
    
26. #突然感觉橙色的字体逻辑来说相对贴近底层逻辑

复制代码