基础部分：《实战深度理解笔记》6产品思维

 1 ## 【早中晚饭吃什么】
 2 ##（1）time,random,判断,循环
 3 import random,time
 4 list=[‘鱼香‘,‘酸白菜‘,‘玉米‘,‘水果‘,‘酱爆‘,‘烧茄子‘]
 5 last=[]
 6 a=input(‘你要吃饭吗？吃就enter，不吃任意键：‘)
 7 if a==‘‘:
 8     start=time.time() # 时间戳time.time()，1548730796.4549906
 9     start_time=time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime(start))
10 ## 墙上时间time.strftime(time.localtime(time.time())),比如2019-1-29
11 ## time.localtime(sta)  # 当地时间time.localtime(time.time())，非正式格式,运行如下：
12 ## time.struct_time(tm_year=2019,tm_mon=1,tm_mday=29,tm_hour=10,tm_min=59,tm_sec=56,tm_wday=1,tm_yday=29,tm_isdst=0)
13     b=random.sample(list,4)  # 在列表list里面选5个得到1个b=[]
14     ## ！！.choice() 得到1个str会重复/.sample()得到1个list,独立不重复
15     for i in range(len(b)):
16         c=input(‘你想吃‘+b[i]+‘吗？吃就enter，不吃任意键:‘)
17         if c==‘‘:
18             last.append(b[i])
19             print(‘已添加进点餐单！‘)
20             time.sleep(1)
21         else:
22             print(‘这道菜很有营养呦~下次吃‘)
23             time.sleep(1)
24     print(‘\n您点的餐有：‘, end=‘‘)
25     food=‘,‘.join(last)  # 【取出[]里面的str】
26     print(food)
27     time.sleep(1)
28     end=time.time()
29     end_time=time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime(end))
30     print(‘您进店的时间是:‘+start_time)
31     print(‘您的下单时间是:‘+end_time)
32     print(‘您可以用餐2h，enjoy you time！ ‘)
33 else:
34     print(‘还是少吃点吧，不按时吃饭对胃不好~\n‘)

 1 ##（2）类/对象
 2 import random,time
 3 class Foodlist():
 4     def __init__(self):
 5         self.x=[‘鱼香‘, ‘酸白菜‘, ‘玉米‘, ‘水果‘, ‘酱爆‘, ‘烧茄子‘]
 6         self.a = input(‘你要吃饭吗？吃就enter，不吃任意键：‘)
 7     def order(self):
 8         last = []
 9         b = random.sample(self.x, 4)  # 在列表list里面选5个得到1个b=[]
10  ## ！！.choice() 得到1个str会重复/.sample()得到1个list,独立不重复
11         for i in range(len(b)):
12             c = input(‘你想吃‘ + b[i] + ‘吗？吃就enter，不吃任意键:‘)
13             if c == ‘‘:
14                 last.append(b[i])
15                 print(‘已添加进点餐单！‘)
16                 time.sleep(1)
17             else:
18                 print(‘这道菜很有营养呦~下次吃‘)
19                 time.sleep(1)
20         print(‘\n您点的餐有：‘, end=‘‘)
21         food = ‘,‘.join(last)  # 【取出[]里面的str】
22         print(food)
23         time.sleep(1)
24     def staa(self):
25         start = time.time()  # 时间戳time.time()，1548730796.4549906
26         self.start_time = time.strftime(‘%Y-%m-%d %H:%M:%S‘, time.localtime(start))
27  ## 墙上时间time.strftime(time.localtime(time.time())),比如2019-1-29
28  ## time.localtime(sta)  # 当地时间time.localtime(time.time())，非正式格式,运行如下：
29  ## time.struct_time(tm_year=2019,tm_mon=1,tm_mday=29,tm_hour=10,tm_min=59,tm_sec=56,tm_wday=1,tm_yday=29,tm_isdst=0)
30     def endd(self):
31         end = time.time()
32         self.end_time = time.strftime(‘%Y-%m-%d %H:%M:%S‘, time.localtime(end))
33     def congra(self):
34         print(‘您进店的时间是:‘ + self.start_time)
35         print(‘您的下单时间是:‘ + self.end_time)
36         print(‘您可以用餐2h，enjoy you time！\n ‘)
37 chi=Foodlist()    # 实例化对象
38 
39 if chi.a==‘‘:
40     chi.staa()   # 进店时间
41     chi.order()  # 选餐
42     chi.endd()   # 下单时间
43     chi.congra() # 结束语
44 else:
45     print(‘还是少吃点吧，不按时吃饭对胃不好~\n‘)

 1 ## 2.类、对象
 2 import csv,time
 3 ## （1）填写表头
 4 with open(‘sample/锦秀花园6栋.csv‘,‘w‘,newline=‘‘) as a:
 5     b=csv.writer(a)
 6     head=[‘小区‘,‘地址‘,‘建筑年份‘,‘楼栋‘,‘单元‘,‘户室‘,‘面积‘,‘朝向‘]
 7     b.writerow(head)
 8 
 9 ## （2）可以循环利用的有：
10 ## ‘小区‘,‘地址‘,‘建筑年份‘,‘楼栋‘
11 ## 1栋楼-x单元1楼的‘户室y01-y04‘,‘面积‘,‘朝向‘
12 name=‘锦绣花园‘
13 add=‘深圳市南山区粤海街道‘
14 year=‘2015‘
15 dong=‘6栋‘
16 danyuan=int(input(‘6栋-单元数(1-4)：‘))
17 
18 ## （3）遍历1栋楼的所有住户信息+录入：所有单元-起始楼层-每个户室(面积，朝向)
19 class Sixdong():
20     def __init__(self):
21         self.sf = int(input(‘起始楼层(3):‘))
22         self.ef = int(input(‘终止楼层(5):‘))
23         self.unit = {}  # 6栋所有单元+所有楼层：{单元:{楼层：{户室：‘朝向，面积‘},,,},,,}
24 
25     ### A. 单元循环
26     def dy_loop(self):
27         for i in range(danyuan):
28             print(‘\n第%d单元信息:‘ % (i + 1))
29             judge = input(‘判断起始楼层尾号:<01,02>？是请enter，否任意键:‘)
30             if judge == ‘‘:
31                 # sfe=input(‘起始楼层尾号(01-04,逗号分开):‘) # 01,02
32                 # sf_e=sfe.split(‘,‘)   #[‘01‘,‘02‘]
33                 sf_e = [‘01‘, ‘02‘]
34             else:
35                 sf_e = [‘01‘, ‘02‘, ‘03‘, ‘04‘]
36 
37     ### B. 起始3楼户室循环,录入模板
38             data0 = {}  # {户室:‘朝向，面积‘,,,}
39             unit0 = {}  # {楼层:{户室：‘朝向，面积‘},,,}
40             for ii in sf_e:
41                 sf_hushi = int(str(self.sf) + ii)
42                 area = int(input(str(sf_hushi) + ‘面积:‘))
43                 direct = int(input(str(sf_hushi) + ‘朝向(1.南北 2.东西):‘))
44                 data0[sf_hushi] = [area, direct]  # 3楼{301:[80,2], 302:[80,2]}
45                 unit0[self.sf] = data0  # 3楼{3:{301:[80,2], 302:[80,2]}}
46                 self.unit[i + 1] = unit0  # 1单元3楼{1:{3:{301:[80,2], 302:[80,2]}}}
47             print(‘\n第%d单元-起始户室(3)data0=:‘ % (i + 1), end=‘‘)
48             print(data0)  # 3楼{301:[80,2], 302:[80,2]}
49             print(‘起始楼层-户室(3)unit0=:‘, end=‘‘)
50             print(unit0)  # 3楼{3:{301:[80,2], 302:[80,2]}}
51             print(‘第%d单元-起始楼层-户室(3)unit=:‘ % (i + 1), end=‘‘)
52             print(self.unit)  # 1单元3楼{1:{3:{301:[80,2], 302:[80,2]}}}
53             time.sleep(1)
54 
55     ### C. 参照起始楼层3楼循环，把4-5楼填满   #{401:[80,2], 402:[80,2]}
56             for mf in range(self.sf + 1, self.ef + 1):  # a. 所有楼层循环(4,6)
57                 data1 = {}  # 中间变量
58                 unit1 = {}  # 中间变量
59                 for iii in sf_e:  # b. 每楼层户室循环
60                     hushi = int(str(mf) + iii)
61                     data1[hushi] = [area, direct]
62                     unit1[mf] = data1
63                 unit0[mf] = data1
64                 self.unit[i + 1] = unit0
65             print(‘\n第%d单元 顶楼data1=:‘ % (i + 1), end=‘‘)
66             print(data1)  # {501: [70, 1], 502: [70, 1]}
67             print(‘所有楼层-户室unit0=:‘, end=‘‘)
68             print(unit0)
69             # {3:{301:[70,1],302:[70,1]}, 4:{}, 5:{}}
70             print(‘所有单元-所有楼层-户室unit=:‘, end=‘‘)
71             print(self.unit)
72             # {1:{3:{},4:{},5:{},  2:{3:{},4:{},5:{}}
73 
74     ## （4）输出内容，存放到.csv
75             for sub_dict in unit0.values():
76                 # 3,4,5的值 {301:[70, 1], 302:[70, 1]}
77                 for j, jj in sub_dict.items():
78                     ## 301:[70, 1], 302:[70, 1]
79                     q = [‘南北‘, ‘东西‘]
80                     jj[1] = q[(jj[1] - 1)]
81                     print(‘单元:%d 户室:%d 面积:%d 朝向:%s‘ % (i + 1, j, jj[0], jj[1]))
82                     w = name + ‘ ‘ + add + ‘ ‘ + year + ‘ ‘ + dong + ‘ ‘ + str(i + 1)83                         + ‘ ‘ + str(j) + ‘ ‘ + str(jj[0]) + ‘ ‘ + jj[1]
84                     print(w)
85                     record = w.split(‘ ‘)  # [‘2‘, ‘301‘, ‘80‘, ‘东西‘]
86                     print(record)
87                     with open(‘sample/锦秀花园6栋1.csv‘, ‘a+‘, newline=‘‘) as f:
88                         b = csv.writer(f)
89                         b.writerow(record)
90         print(‘\n叮咚！excel录入工作完成，撒花~~‘)
91 auto=Sixdong()  # 实例化
92 print(auto.sf)
93 print(auto.ef)
94 auto.dy_loop()

 1 ## （2）全封装函数def
 2 # -- 函数的同级调用：函数名(a,b,...)
 3 import time,random
 4 def show(a_life,a_attack,b_life,b_attack):
 5     print(‘【玩家】 血量：%s 攻击：%s‘ % (a_life,a_attack))
 6     time.sleep(1)
 7     print(‘【敌人】 血量：%s 攻击：%s‘ % (b_life,b_attack))
 8     time.sleep(1)
 9     pk(a_life,a_attack,b_life,b_attack)     ## 同级调用pk()
10 def pk(a_life,a_attack,b_life,b_attack):
11     k=0
12     while a_life > 0 and b_life > 0:     # 指不定pk几次
13         a_life = a_life-b_attack
14         b_life = b_life-a_attack
15         k = k + 1
16         print(‘---------------第%d局--------------------‘%k)
17         print(‘你发起了攻击，【敌人】剩余血量%s‘ % b_life)
18         if b_life>0:
19             print(‘敌人向你发起了攻击，【玩家】剩余血量%s‘ % a_life)
20             time.sleep(1)
21             continue
22         else:
23             a_life=a_life + b_attack
24             print(‘敌人死了，【玩家】最终剩余血量%s‘ % (a_life))
25             break
26     result(a_life, b_life)  ## 同级调用result()
27 def result(a_life, b_life):
28     if a_life> 0 and b_life <= 0:
29         print(‘----------------------------------------‘)
30         print(‘you win！‘)
31     elif a_life<=0 and b_life>0:
32         print(‘----------------------------------------‘)
33         print(‘you lose~‘)
34     else:
35         print(‘----------------------------------------‘)
36         print(‘平局！‘)
37 ## 主函数
38 def main():
39     a_life = random.randint(100, 150)
40     a_attack = random.randint(30, 50)
41     b_life = random.randint(100, 150)
42     b_attack = random.randint(30, 50)
43     show(a_life,a_attack,b_life,b_attack)
44   ## pk()已经在show()里面调用了！！
45   ## result()已经在pk()里面调用了！！
46 main()  # 调用，开始跑程序

 1 ### 项目1    V2.0小课
 2 ## （3）封装成类class-函数def
 3 # -- 类函数的同级调用：self.函数名(a,b,...)
 4 #  注意def时第一个位置是self：函数名(self,a,b,...)
 5 import time,random
 6 class Pk():
 7     def __init__(self):
 8         self.a_life = random.randint(100, 150)
 9         self.a_attack = random.randint(30, 50)
10         self.b_life = random.randint(100, 150)
11         self.b_attack = random.randint(30, 50)
12     def show(self):
13         print(‘【玩家】 血量：%s 攻击：%s‘ % (self.a_life,self.a_attack))
14         time.sleep(1)
15         print(‘【敌人】 血量：%s 攻击：%s‘ % (self.b_life,self.b_attack))
16         time.sleep(1)
17         self.pk(self.a_life, self.b_life)  ## 同级调用pk()
18     def pk(self,a_life,b_life):
19         k=0
20         while a_life > 0 and b_life > 0:
21             a_life= a_life-self.b_attack
22             b_life= b_life-self.a_attack
23             k = k + 1
24             print(‘---------------第%d局--------------------‘ % k)
25             print(‘你发起了攻击，【敌人】剩余血量%s‘ % b_life)
26             if b_life > 0:
27                 print(‘敌人向你发起了攻击，【玩家】剩余血量%s‘ % a_life)
28                 time.sleep(1)
29                 continue
30             else:
31                 a_life = a_life + self.b_attack
32                 print(‘敌人死了，【玩家】最终剩余血量%s‘ % (a_life))
33                 break
34         self.result(a_life,b_life)    ## 同级调用result()
35     def result(self,a_life,b_life):
36         if a_life > 0 and b_life <= 0:
37             print(‘----------------------------------------‘)
38             print(‘you win！‘)
39         elif a_life <= 0 and b_life > 0:
40             print(‘----------------------------------------‘)
41             print(‘you lose~‘)
42         else:
43             print(‘----------------------------------------‘)
44             print(‘平局！‘)
45 game=Pk() # 实例化
46 game.__init__()  # 随机产生
47 game.show()  ## 里面同级调用pk()result()
48 ## 不用写game.pk() game.result()

 1 ### 项目2
 2 ## 2. 全封装函数def -- 函数的同级调用：函数名(a,b,...)
 3 
 4 import random,time
 5 ## (1) 设定角色信息：生成\展示\排序
 6 def set():
 7 ### 我方
 8     a_choice=  [‘【狂血战士】‘,‘【森林箭手】‘,‘【光明骑士】‘,‘【独行剑客】‘,‘【格斗大师】‘,‘【枪弹专家】‘]
 9     a_players=random.sample(a_choice,3) #[‘【独行剑客】‘, ‘【格斗大师】‘, ‘【森林箭手】‘]
10     a={}   #{角色:[血量,攻击力],,,}
11     for i in range(3):
12         a_li = random.randint(100, 150)
13         a_at = random.randint(30, 50)
14         a[a_players[i]]=[a_li,a_at]   #{角色:[血量,攻击力],,,}
15 #### 敌方
16     b_choice= [‘【暗黑战士】‘,‘【黑暗弩手】‘,‘【骷髅骑士】‘,‘【嗜血刀客】‘,‘【首席刺客】‘,‘【陷阱之王】‘]
17     b_players=random.sample(b_choice,3)
18     b={}
19     for i in range(3):
20         b_li = random.randint(100, 150)
21         b_at = random.randint(30, 50)
22         b[b_players[i]]=[b_li,b_at]
23 #### 展示
24     print(‘--------------------【角色信息】----------------------‘)
25     print(‘我的人物:\n‘,end=‘‘)
26     for i0,j0 in a.items():  # 取字典的键：值
27         a_name=i0
28         a_life=j0[0]
29         a_attack=j0[1]
30         print(‘%s 血量:%d 攻击力:%d‘%(a_name,a_life,a_attack))
31     time.sleep(1)
32     print(‘------------------------------------------------------‘)
33     print(‘电脑敌人:\n‘,end=‘‘)
34     di=[]        # 敌方出场顺序
35     for i1,j1 in b.items():  # 取字典的键：值
36         di.append(i1)
37         b_name=i1
38         b_life=j1[0]
39         b_attack=j1[1]
40         print(‘%s 血量:%d 攻击力:%d‘ % (b_name, b_life, b_attack))
41     time.sleep(1)
42 #### 排序
43     print(‘\n--------------------【出场顺序】----------------------‘)
44     wo=[‘‘,‘‘,‘‘]
45     for i0,j0 in a.items():  # 取字典的键：值
46      ## 重点！！
47         x=int(input(‘你想将%s放在第x个上场(x=1,2,3):‘%i0))
48         wo[x-1]=(i0)  # 将i0放到wo的第(x-1)的位置
49     print(‘\n我方角色出场顺序:%s%s%s‘%(wo[0],wo[1],wo[2]))
50     print(‘敌方角色出场顺序:%s%s%s‘%(di[0],di[1],di[2]))
51     time.sleep(1)
52     pk(a,b,wo,di)  # 同级调用
53 
54 ## (2) 3vs3 过程
55 def pk(a,b,wo,di):
56     for k in range(3):     # 角色只有3个,一共3局
57         print(‘\n---------------------【第%d局】----------------------‘%(k+1))
58         print(‘我方角色%s VS 敌方角色%s‘%(wo[k],di[k]))
59         wo_value=a[wo[k]]   # [血量,攻击力]
60         a_life=wo_value[0]   # 血量
61         a_attack=wo_value[1] # 攻击力
62         print(‘%s 血量:%d 攻击力:%d‘%(wo[k],a_life,a_attack))
63         di_value=b[di[k]]   # [血量,攻击力]
64         b_life=di_value[0]   # 血量
65         b_attack=di_value[1] # 攻击力
66         print(‘%s 血量:%d 攻击力:%d‘%(di[k],b_life,b_attack))
67         print(‘------------------------------------------------------‘)
68         input(‘请按enter继续：‘)
69      ## 单局战果
70         a_mark=0 # 记分牌
71         b_mark=0
72         while a_life > 0 and b_life > 0:  # 每1局指不定pk几次
73             b_life = b_life-a_attack
74             print(‘%s发起了攻击，%s剩余血量%s‘%(wo[k],di[k],b_life))
75             if b_life>0:
76                 a_life = a_life - b_attack
77                 print(‘%s发起了攻击，%s剩余血量%s‘ % (di[k], wo[k], a_life))
78                 time.sleep(1)
79                 if a_life>0:
80                     time.sleep(1)
81                     continue
82                 else:
83                     b_mark=b_mark+1  # 单局结果计分
84                     print(‘我死了,%s最终剩余血量%s‘ % (di[k], b_life))
85             else:
86                 a_mark=a_mark+1     # 单局结果计分
87                 print(‘敌人死了,%s最终剩余血量%s‘ %(wo[k],a_life))
88     result(a_mark,b_mark)  # 同级调用
89 
90 ## (3) 游戏结局
91 def result(a_mark,b_mark):
92     print(‘------------最终结果--------------‘)
93     if a_mark>b_mark:
94         print(‘you win！撒花~】‘)
95     elif a_mark<b_mark:
96         print(‘好遗憾,you lose~】‘)
97     else:
98         print(‘哇,实力不相上下,平局！】‘)
99 set()  # 启动程序

  1 ### 项目2
  2 ## 3. 封装成类class-函数def -- 类函数的同级调用：self.函数名(a,b,...)
  3 #  注意def时第一个位置是self：函数名(self,a,b,...)
  4 
  5 import random,time
  6 class Game():
  7     def __init__(self):   # 原始函数里面不能同级调用，它没有同级
  8         self.a_choice=  [‘【狂血战士】‘,‘【森林箭手】‘,‘【光明骑士】‘,‘【独行剑客】‘,‘【格斗大师】‘,‘【枪弹专家】‘]
  9         self.b_choice = [‘【暗黑战士】‘, ‘【黑暗弩手】‘, ‘【骷髅骑士】‘, ‘【嗜血刀客】‘, ‘【首席刺客】‘, ‘【陷阱之王】‘]
 10 
 11 ## (1) 设定角色信息：生成\展示\排序
 12     def set(self):
 13     ### 我方
 14         a_players=random.sample(self.a_choice,3) #[‘【独行剑客】‘, ‘【格斗大师】‘, ‘【森林箭手】‘]
 15         a={}   #{角色:[血量,攻击力],,,}
 16         for i in range(3):
 17             a_li = random.randint(100, 150)
 18             a_at = random.randint(30, 50)
 19             a[a_players[i]]=[a_li,a_at] #{角色:[血量,攻击力],,,}
 20     #### 敌方
 21         b_players=random.sample(self.b_choice,3)
 22         b={}
 23         for i in range(3):
 24             b_li = random.randint(100, 150)
 25             b_at = random.randint(30, 50)
 26             b[b_players[i]]=[b_li,b_at]
 27         self.show(a,b)    # 类函数同级调用一定要加self.！！
 28 
 29     def show(self,a,b):
 30     #### 展示
 31         print(‘--------------------【角色信息】----------------------‘)
 32         print(‘我的人物:\n‘,end=‘‘)
 33         for i0,j0 in a.items():  # 取字典的键：值
 34             a_name=i0
 35             a_life=j0[0]
 36             a_attack=j0[1]
 37             print(‘%s 血量:%d 攻击力:%d‘%(a_name,a_life,a_attack))
 38         time.sleep(1)
 39         print(‘------------------------------------------------------‘)
 40         print(‘电脑敌人:\n‘,end=‘‘)
 41         di=[]        # 敌方出场顺序
 42         for i1,j1 in b.items():  # 取字典的键：值
 43             di.append(i1)
 44             b_name=i1
 45             b_life=j1[0]
 46             b_attack=j1[1]
 47             print(‘%s 血量:%d 攻击力:%d‘ % (b_name, b_life, b_attack))
 48         time.sleep(1)
 49     #### 排序
 50         print(‘\n--------------------【出场顺序】----------------------‘)
 51         wo=[‘‘,‘‘,‘‘]
 52         for i0,j0 in a.items():  # 取字典的键：值
 53          ## 重点！！
 54             x=int(input(‘你想将%s放在第x个上场(x=1,2,3):‘%i0))
 55             wo[x-1]=(i0)  # 将i0放到wo的第(x-1)的位置
 56         print(‘\n我方角色出场顺序:%s%s%s‘%(wo[0],wo[1],wo[2]))
 57         print(‘敌方角色出场顺序:%s%s%s‘%(di[0],di[1],di[2]))
 58         time.sleep(1)
 59         self.pk(a,b,wo,di)   # 类函数同级调用一定要加self.！！
 60 
 61     ## (2) 3vs3 过程
 62     def pk(self,a,b,wo,di):
 63         for k in range(3):     # 角色只有3个,一共3局
 64             print(‘\n---------------------【第%d局】----------------------‘%(k+1))
 65             print(‘我方角色%s VS 敌方角色%s‘%(wo[k],di[k]))
 66             wo_value=a[wo[k]]   # [血量,攻击力]
 67             a_life=wo_value[0]   # 血量
 68             a_attack=wo_value[1] # 攻击力
 69             print(‘%s 血量:%d 攻击力:%d‘%(wo[k],a_life,a_attack))
 70             di_value=b[di[k]]   # [血量,攻击力]
 71             b_life=di_value[0]   # 血量
 72             b_attack=di_value[1] # 攻击力
 73             print(‘%s 血量:%d 攻击力:%d‘%(di[k],b_life,b_attack))
 74             print(‘------------------------------------------------------‘)
 75             input(‘请按enter继续：‘)
 76          ## 单局战果
 77             a_mark=0 # 记分牌
 78             b_mark=0
 79             while a_life > 0 and b_life > 0:  # 每1局指不定pk几次
 80                 b_life = b_life-a_attack
 81                 print(‘%s发起了攻击，%s剩余血量%s‘%(wo[k],di[k],b_life))
 82                 if b_life>0:
 83                     a_life = a_life - b_attack
 84                     print(‘%s发起了攻击，%s剩余血量%s‘ % (di[k], wo[k], a_life))
 85                     time.sleep(1)
 86                     if a_life>0:
 87                         time.sleep(1)
 88                         continue
 89                     else:
 90                         b_mark=b_mark+1  # 单局结果计分
 91                         print(‘我死了,%s最终剩余血量%s‘ % (di[k], b_life))
 92                 else:
 93                     a_mark=a_mark+1     # 单局结果计分
 94                     print(‘敌人死了,%s最终剩余血量%s‘ %(wo[k],a_life))
 95         self.result(a_mark,b_mark)  # 类函数同级调用一定要加self.！！
 96 
 97     ## (3) 游戏结局
 98     def result(self,a_mark,b_mark):
 99         print(‘------------最终结果--------------‘)
100         if a_mark>b_mark:
101             print(‘you win！撒花~】‘)
102         elif a_mark<b_mark:
103             print(‘好遗憾,you lose~】‘)
104         else:
105             print(‘哇,实力不相上下,平局！】‘)
106 start=Game()  # 实例化
107 start.__init__()  # 启动程序
108 start.set()

  1 ### 项目3
  2 import random,time
  3 def start():
  4     print(‘---------------欢迎来到“炼狱角斗场”----------------‘)
  5     time.sleep(1)
  6     words=‘‘‘在昔日的黄昏山脉，奥卡帝国的北境边界上，有传说中的“炼狱角斗场”
  7 ‘献血与战斗是角斗士的归宿，金钱与荣耀是角斗士的信仰！
  8 今日，只要【你的队伍】能取得胜利，你将获得一笔够花500年的财富
  9 将随机生成【你的队伍】和【敌人队伍】！‘‘‘
 10     for i in words:
 11         print(i,end=‘‘)   # 在python软件中是一个字一个字输出的
 12     time.sleep(1)
 13     print(‘\n狭路相逢勇者胜，请按enter继续~‘)
 14 
 15 ## (1) 设定角色信息：生成\展示\排序
 16 def set():
 17     print(‘--------------------【角色信息】----------------------‘)
 18     print(‘我的人物:‘)
 19 ### 我方
 20     a = {}   #{(127, 40): ‘【暗影刺客】‘, (114, 47): ‘【精灵弩手】‘, (139, 33): ‘【暗影刺客】‘}
 21     k = 0
 22     for i in range(3):
 23         name = random.choice([‘【暗影刺客】‘, ‘【精灵弩手】‘, ‘【圣光骑士】‘])
 24         a_li = random.randint(100, 150)
 25         a_at = random.randint(30, 50)
 26         if name == ‘【暗影刺客】‘:  # 每个角色血量、攻击力都不一样
 27             k0 = 3
 28             k1 = 5
 29         elif name == ‘【精灵弩手】‘:
 30             k0 = 4
 31             k1 = 4
 32         else:
 33             k0 = 5
 34             k1 = 3
 35     ## 重点！！若写成a[y]=[a_li,a_at]出现相同的y会覆盖
 36         a[k0*a_li, k1*a_at] = name
 37         print(‘%s 血量:%d 攻击力:%d‘%(name, k0*a_li, k1*a_at))
 38     time.sleep(1)
 39 
 40     print(‘------------------------------------------------------‘)
 41     print(‘电脑敌人:‘)
 42 #### 敌方
 43     b = {}
 44     k = 0
 45     for i in range(3):
 46         b_name= random.choice([‘【暗影刺客】‘, ‘【精灵弩手】‘, ‘【圣光骑士】‘])
 47         b_li = random.randint(100, 150)
 48         b_at = random.randint(30, 50)
 49         ## 重点！！若写成a[y]=[a_li,a_at]出现相同的y会覆盖
 50         if b_name == ‘【暗影刺客】‘:
 51             k0 = 3
 52             k1 = 5
 53         elif b_name == ‘【精灵弩手】‘:
 54             k0 = 4
 55             k1 = 4
 56         else:
 57             k0 = 5
 58             k1 = 3
 59         b[k0*b_li, k1*b_at] = b_name
 60         print(‘%s 血量:%d 攻击力:%d‘ %(b_name, k0*b_li, k1*b_at))
 61     time.sleep(1)
 62     order(a, b)
 63 
 64 #### 排序
 65 def order(a, b):
 66     print(‘\n--------------------【出场顺序】----------------------‘)
 67 ## 重点！！ 变成 列表嵌套元组list[tuple,,]=[(key:val),,,]一一对应排序
 68     a=sorted(a.items())  # 列表嵌套元组[( (血量,攻击力): 人物 ),(),()]
 69     b=sorted(b.items())
 70     for i in range(3):
 71         a_name = a[i][1]        # 人物
 72         b_name=b[i][1]
 73     #    a_life = a[i][0][0]    # 血量
 74     #    a_attack = a[i][0][1]  # 攻击力
 75         x = int(input(‘你想将%s放在第x个上场(x=1,2,3):‘ % a_name))
 76     #  x是按血量大小问的！！
 77         a[i]=a[x-1]   #a 是排序后的 列表嵌套元组[(),(),,,]
 78     print(‘\n我方角色出场顺序:%s%s%s‘ % (a[0][1], a[1][1],a[2][1]))
 79     print(‘敌方角色出场顺序:%s%s%s‘ % (b[0][1], b[1][1],b[2][1]))
 80     time.sleep(1)
 81     pk(a,b) # 同级调用
 82 
 83 ## (2) 3vs3 过程
 84 def pk(a,b):
 85     for k in range(3):     # 角色只有3个,一共3局
 86     # 我方
 87         a_name = a[k][1]  # 人物
 88         a_life = a[k][0][0]  # 血量
 89         a_attack = a[k][0][1]  # 攻击力
 90     #敌方
 91         b_name = b[k][1]  # 人物
 92         b_life = b[k][0][0]  # 血量
 93         b_attack = b[k][0][1]  # 攻击力
 94         print(‘\n---------------------【第%d局】----------------------‘%(k+1))
 95         print(‘我方角色%s VS 敌方角色%s‘%(a_name,b_name))
 96         print(‘%s 血量:%d 攻击力:%d‘%(a_name,a_life,a_attack))
 97         print(‘%s 血量:%d 攻击力:%d‘%(b_name,b_life,b_attack))
 98         print(‘------------------------------------------------------‘)
 99         input(‘请按enter继续：‘)
100      ## 单局战果
101         a_mark=0 # 记分牌
102         b_mark=0
103         while a_life > 0 and b_life > 0:  # 每1局指不定pk几次
104             b_life = b_life-a_attack
105             print(‘%s发起了攻击，%s剩余血量%s‘%(a_name,b_name,b_life))
106             if b_life>0:
107                 a_life = a_life - b_attack
108                 print(‘%s发起了攻击，%s剩余血量%s‘ % (b_name,a_name, a_life))
109                 time.sleep(1)
110                 if a_life>0:
111                     time.sleep(1)
112                     continue
113                 else:
114                     b_mark=b_mark+1  # 单局结果计分
115                     print(‘我死了,%s最终剩余血量%s‘ % (b_name, b_life))
116             else:
117                 a_mark=a_mark+1     # 单局结果计分
118                 print(‘敌人死了,%s最终剩余血量%s‘ %(a_name,a_life))
119     time.sleep(1)
120     result(a_mark,b_mark) # 同级调用
121 
122 ## (3) 游戏结局
123 def result(a_mark,b_mark):
124     print(‘------------最终结果--------------‘)
125     if a_mark>b_mark:
126         print(‘you win！撒花~】‘)
127     elif a_mark<b_mark:
128         print(‘好遗憾,you lose~】‘)
129     else:
130         print(‘哇,实力不相上下,平局！】‘)
131 start() # 启动程序
132 set()  # 启动程序

  1 ### 项目3
  2 ##【类\对象的2种用法】
  3 ##（1）类作为 函数包 (class里面很多def)
  4 ##（2）类作为 实例模板 (继承、调用)
  5 import random,time
  6 # 创建一个类，可实例化成具体的游戏角色
  7 class Role():
  8     def __init__(self, name=‘【角色】‘):  # 把角色名作为默认参数
  9         self.name = name
 10         self.life = random.randint(100, 150)
 11         self.attack = random.randint(30, 50)
 12 # 创建三个子类，可实例化为3个不同类型的角色
 13 class Knight(Role):
 14     def __init__(self, name=‘【圣光骑士】‘):  # 把子类角色名作为默认参数
 15         Role.__init__(self, name)  # 利用了父类的初始化函数
 16         self.life = self.life * 5  # 骑士有5份血量
 17         self.attack = self.attack * 3  # 骑士有3份攻击力
 18 # 职业克制关系
 19     def fight_buff(self,opponent,str1, str2):
 20         if opponent.name==‘【暗影刺客】‘:
 21             self.attack=int(1.5*self.attack)
 22             print(‘『%s』【圣光骑士】对 『%s』【暗影刺客】说：“让无尽光芒制裁你的堕落！”‘ % (str1, str2))
 23 
 24 class Assassin(Role):
 25     def __init__(self, name=‘【暗影刺客】‘):
 26         Role.__init__(self, name)
 27         self.life = self.life * 3
 28         self.attack = self.attack * 5
 29     def fight_buff(self,opponent,str1,str2):
 30         if opponent.name==‘【精灵弩手】‘:
 31             self.attack=int(1.5*self.attack)
 32             print(‘『%s』【暗影刺客】对 『%s』【精灵弩手】说：“主动找死，就别怪我心狠手辣。”‘ % (str1, str2))
 33 
 34 class Bowman(Role):
 35     def __init__(self, name=‘【精灵弩手】‘):
 36         Role.__init__(self, name)
 37         self.life = self.life * 4
 38         self.attack = self.attack * 4
 39     def fight_buff(self,opponent,str1,str2):
 40         if opponent.name==‘【圣光骑士】‘:
 41             self.attack=int(1.5*self.attack)
 42             print(‘『%s』【精灵弩手】对 『%s』【圣光骑士】说：“骑着倔驴又如何？你都碰不到我衣服。”‘ % (str1, str2))
 43 
 44 # 创建一个类，可生成3V3并展示：可分为：欢迎语→随机生成→展示角色
 45 class Game:
 46     def __init__(self):
 47         # 初始化各种变量
 48         self.players = []  # 存玩家顺序
 49         self.enemies = []  # 存敌人顺序
 50         self.score = 0  # 比赛积分
 51         self.i = 0  # 记轮次
 52         # 执行各种游戏函数
 53         self.game_start()  # 欢迎语
 54         self.born_role()   # 随机生成6个角色
 55         self.show_role()   # 展示角色
 56         self.order_role()  # 排序并展示
 57         self.pk_role()     # 让双方 Pk 并展示结果
 58         self.show_result() # 展示最终结局
 59 # 欢迎语
 60     def game_start(self):
 61         print(‘---------------欢迎来到“炼狱角斗场”----------------‘)
 62         time.sleep(1)
 63         words = ‘‘‘在昔日的黄昏山脉，奥卡帝国的北境边界上，有传说中的“炼狱角斗场”
 64 献血与战斗是角斗士的归宿，金钱与荣耀是角斗士的信仰！
 65 今日，只要【你的队伍】能取得胜利，你将获得一笔够花500年的财富
 66 将随机生成【你的队伍】和【敌人队伍】！‘‘‘
 67         for i in words:
 68             print(i, end=‘‘)  # 在python软件中是一个字一个字输出的
 69         time.sleep(1)
 70         print(‘\n狭路相逢勇者胜，请按enter继续~‘)
 71 # 随机生成6个角色
 72     def born_role(self):
 73         for i in range(3):  # 类作为 实例模板,()里面是被调用的类函数
 74             self.players.append(random.choice([Knight(), Assassin(), Bowman()]))
 75             self.enemies.append(random.choice([Knight(), Assassin(), Bowman()]))
 76 # 展示角色
 77     def show_role(self):
 78         print(‘----------------- 角色信息 -----------------‘)
 79         print(‘你的队伍：‘)
 80         for i in range(3):
 81             print(‘『我方』%s 血量：%s  攻击：%s‘ %
 82                   (self.players[i].name, self.players[i].life, self.players[i].attack))
 83         print(‘--------------------------------------------‘)
 84         print(‘敌人队伍：‘)
 85         for i in range(3):
 86             print(‘『敌方』%s 血量：%s  攻击：%s‘ %
 87                   (self.enemies[i].name, self.enemies[i].life, self.enemies[i].attack))
 88         print(‘--------------------------------------------‘)
 89 # 排序并展示
 90     def order_role(self):
 91         order_dict = {}
 92         for i in range(3):
 93             order = int(input(‘你想将 %s 放在第几个上场？(输入数字1~3)‘ % self.players[i].name))
 94             order_dict[order] = self.players[i]   ## ？？？
 95         self.players = []
 96         for i in range(1, 4):
 97             self.players.append(order_dict[i])
 98         print(‘\n你的队伍出场顺序是：%s、%s、%s‘
 99               % (self.players[0].name, self.players[1].name, self.players[2].name))
100         print(‘敌人队伍出场顺序是：%s、%s、%s‘
101               % (self.enemies[0].name, self.enemies[1].name, self.enemies[2].name))
102 # 让双方 Pk 并展示结果
103     def pk_role(self):
104         for i in range(3):
105             input(‘请按回车键继续。‘)
106             print(‘\n----------------- 【第%s轮】 -----------------‘ % (i + 1))
107             # 每一局开战前加buff，角色克制，强遇弱攻击力翻倍
108             self.players[i].fight_buff(self.enemies[i], ‘我方‘, ‘敌方‘)
109             self.enemies[i].fight_buff(self.players[i], ‘敌方‘, ‘我方‘)
110             # print(‘--------------------------------------------‘)
111 
112             while self.players[i].life > 0 and self.enemies[i].life > 0:
113                 self.enemies[i].life -= self.players[i].attack
114                 self.players[i].life -= self.enemies[i].attack
115                 print(‘我方%s 发起了攻击，敌方%s 剩余血量 %s‘ %
116                       (self.players[i].name, self.enemies[i].name, self.enemies[i].life))
117                 print(‘敌方%s 发起了攻击，我方%s 剩余血量 %s‘ %
118                       (self.enemies[i].name, self.players[i].name, self.players[i].life))
119                 print(‘--------------------------------------------‘)
120                 time.sleep(1)
121             if self.players[i].life <= 0 and self.enemies[i].life > 0:
122                 print(‘\n很遗憾，我方%s 挂掉了！‘ % (self.players[i].name))
123                 self.score -= 1
124             elif self.players[i].life > 0 and self.enemies[i].life <= 0:
125                 print(‘\n恭喜，我方%s 活下来了。‘ % (self.players[i].name))
126                 self.score += 1
127             else:
128                 print(‘\n我的天，他们俩都死了啊！‘)
129 # 展示最终结局
130     def show_result(self):
131         if self.score > 0:
132             print(‘【最终结果】\n你赢了！‘)
133         elif self.score == 0:
134             print(‘【最终结果】\n平局。‘)
135         else:
136             print(‘【最终结果】\n你输了。‘)
137 g=Game()  # 启动游戏

  1 # 涉及知识点：【文件读取】【异常处理】
  2 # 【模块】【字典列表】【for/while/if】
  3 import requests,json,random,time
  4 words=‘‘‘今天就是除夕啦，我们都老了一岁~
  5 为了帮大家应对七大姑八大姨的 ‘灵魂拷问‘ ~ ,模拟可能会面对的一些状况:
  6 可以根据题目选出自己认为合适的选项~
  7 完成题目，即可得出你应对灵魂“拷问”的灵敏度。‘‘‘
  8 for i in words:
  9     print(i,end=‘‘)
 10     time.sleep(0.1)
 11 print(‘下面是尬聊（避坑）指南~~‘)
 12 time.sleep(1)
 13 print(‘------------------------------------话题开始---------------------------------------‘)
 14 time.sleep(1)
 15 
 16 ## 1. 文件读取.json 嵌套字典列表类型
 17 try:
 18     with open(‘sample/new_year_questions.json‘, encoding=‘utf-8‘) as f:
 19         a=f.read()     # <class str>  用read方法读取得到str类型
 20         q_json = json.loads(a)    # str解析成 嵌套字典列表类型
 21 except FileNotFoundError:
 22 # .json网源码文件: new_year_questions.json（存储了json-嵌套字典列表类型的数据）
 23     res = requests.get(‘https://static.pandateacher.com/new_year_questions.json‘)
 24     q_json= res.json()   #【对象.json方法】将内容str转换成 字典嵌套列表类型
 25     with open(‘sample/new_year_questions.json‘, ‘w‘, encoding=‘utf-8‘) as f:
 26         f.write(res.text )  # 对象.text获取到str类型
 27 except Exception as e:   # 若为其它异常，则表示加载题库失败，需要终止程序
 28     print("加载题目失败，失败原因：{}".format(e))  # ??
 29     exit()
 30 
 31 ## 2. 展示问题、4个选项，并积分
 32 question = q_json[‘questions_list‘]  # <class ‘list‘>  共8个question
 33 # 列表嵌套字典[{q:‘‘,a:[{},{},{},{}]},{},{}]
 34 result = q_json[‘result‘]            # <class ‘dict‘>  共4个result
 35 mark = {1: 0,2: 0,3: 0,4: 0}  # 设置计分器
 36 num=1
 37 for k in question:  # question-列表嵌套字典8个[{ q:‘‘,a:[{des:‘‘},{},{},{}] },{},,{}]
 38     print(str(num) + ‘. 背景:‘+k[‘q‘])   # k-字典8个{ q:‘‘,a:[{des:‘‘},{},{},{}] }
 39     # 使用enumerate(列表)进行遍历 和 直接遍历列表 区别在于：
 40     # enumerate会自动给列表中的每个值添加序号，序号i从0开始。
 41     time.sleep(1)
 42     for i, answer in enumerate(k[‘a‘]):     # answer={des:‘‘} 共4个
 43         print(‘(%d) %s‘%(i+1, answer[‘desc‘]))
 44         time.sleep(1)
 45     while True:
 46         try:
 47             choice = int(input(‘你的回答是（1/2/3/4）：‘))
 48             if not 1 <= choice <= 4:
 49                 raise Exception
 50             # 手动发出异常，raise表示产生异常+异常类型.被except捕捉
 51             else:
 52                 mark[choice]=mark[choice]+1
 53                 break    # 跳转到for循环，for k in...
 54         except:
 55             x=input(‘输入不是答案序号(1-4)，请重新输入~\n结束请按enter:‘)
 56             if x==‘‘:
 57                 exit()
 58             else:
 59                 continue  # 返回while,chioce=input..
 60     num=num+1
 61     print(‘\n--------------------------------------------------------------------------------‘)
 62     time.sleep(1)
 63 
 64 ## 3. 生成结果
 65 print(‘结果运算中...‘)
 66 time.sleep(1)
 67 max_key=1
 68 max_val =0
 69 for key,val in mark.items():  # 遍历4次{1:1, 2:0, 3:3, 4:4}
 70     print(‘(‘+str(key)+‘)选项，你选了‘+str(val)+‘次‘)
 71 # a.如果val < max_val,最终是final[str(max_key)]
 72 # b.如果val = max_val,
 73 # c.如果val > max_val,暂时将key设置为max_key,接着循环。
 74     if val == max_val:
 75         max_key = random.choice([key,max_key])
 76     elif val > max_val:
 77         max_key = key
 78         max_val = val
 79     else:  # 后续val< max_val
 80         pass
 81 final=result[str(max_key)]  # ‘1‘:[{ topic: "霸气",performance:‘应对‘ ]}
 82 r1=final[0][‘topic‘]        # final[‘topic‘]取不出来，因为[{ }]
 83 print(‘猪年气质：%s\n话题表现：%s‘%(final[0][‘topic‘],final[0][‘performance‘]))
 84 time.sleep(1)
 85 print(‘Wish you clear and fearless. Happy New Year!‘)
 86 
 87 
 88 ## 4. 把程序提交到前端程序接口；涉及知识：【爬虫】、【接口授权】
 89 # jwt表示用户token，里面包含了权限信息，不加这个token就无法访问下面的URL
 90 jwt = ‘eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcHAiOiJweWNsYXNzIiwiZXhwIjoxNTQ5NjExNzg5LCJpZCI6NDI2MzU5LCJvaWQiOiJvUmI4T3dnSlo3UjhraExpWEtsTzVOVklldFMwIiwicGF0aCI6Ii8iLCJwdWlkIjoiMTg5MGZlODEtNTI5NS00ZDE5LThlMmItNzc2ZTA0OTZhN2VkIiwic2NlbmUiOiJwY19zY2FuIiwic3ViIjoibzdoTEgwemc4VGxjQnpCNGVtNEpUbHRrdThObyJ9.g4UoftsqN6gIVDstgWfOfMj0mAyEv7Y-A4iFdipZtwQ‘
 91 # 把本地的 questions.json 中的题目 POST 到 接口
 92 url = ‘https://www.pypypy.cn/python-class-fos/api-academy-go/spring-activity/json-data‘
 93 # json.dumps(字典)表示将字典转换成json格式的数据，默认将中文转换成ASCII格式，
 94 # 这里将ensure_ascii设置为False，表示不使用ASCII格式对中文编码。
 95 headers = {‘Authorization‘: ‘Bearer {}‘.format(jwt)}
 96 data = {‘data‘: question}
 97 try:
 98     res = requests.post(url, json=data, headers=headers)
 99 # 【response对象.raise_for_status方法】将失败的请求当作异常抛出
100     res.raise_for_status()
101     if res.json()[‘errcode‘] != 0:  # 若post失败,展示失败信息,重试
102         print(res.json()[‘errmsg‘])
103         print(‘请尝试重新运行程序!‘)
104     else:    # 若post成功，则提示成功
105         print(‘提交到前端程序接口成功，点击【提交练习】后，手机扫码即可体验程序。‘)
106 except requests.exceptions.HTTPError as e:
107     print(e)
108     print(‘请尝试重新运行程序!‘)
109 except Exception:
110     print(‘提交到前端程序接口失败！‘)
111     print(‘请尝试重新运行程序!‘)