6 大综合：【产品思维】
实例1 【早中晚饭吃什么】
A. 流程结构：time/random模块 /循环/判断
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('
您点的餐有：', 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('还是少吃点吧，不按时吃饭对胃不好~
')
B. 类/对象函数
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('
您点的餐有：', 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！
')
37 chi=Foodlist() # 实例化对象
38
39 if chi.a=='':
40 chi.staa() # 进店时间
41 chi.order() # 选餐
42 chi.endd() # 下单时间
43 chi.congra() # 结束语
44 else:
45 print('还是少吃点吧，不按时吃饭对胃不好~
')
实例2 【锦绣花园6栋.csv】
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('
第%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('
第%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('
第%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('
叮咚！excel录入工作完成，撒花~~')
91 auto=Sixdong() # 实例化
92 print(auto.sf)
93 print(auto.ef)
94 auto.dy_loop()
实例3 【血量游戏】
A. 项目1（for/while/if）
Aa. 全封装函数def-- 函数的同级调用：函数名(a,b,...)
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() # 调用，开始跑程序
Ab. 封装成类class-函数def -- 类函数的同级调用：self.函数名(a,b,...)
# 注意def时第一个位置是self：函数名(self,a,b,...)
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()
B. 项目2（类class/函数def）
Ba. 全封装成-函数def
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('我的人物:
',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('电脑敌人:
',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('
--------------------【出场顺序】----------------------')
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('
我方角色出场顺序:%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('
---------------------【第%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() # 启动程序
Bb. 封装成类class-函数def
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('我的人物:
',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('电脑敌人:
',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('
--------------------【出场顺序】----------------------')
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('
我方角色出场顺序:%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('
---------------------【第%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()
C. 项目3（角色克制）
【类对象的2种用法】（1）类作为函数包 (class里面很多def) （2）类作为实例模板 (继承、调用)
Ca. 全封装成-函数def
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('
狭路相逢勇者胜，请按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('
--------------------【出场顺序】----------------------')
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('
我方角色出场顺序:%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('
---------------------【第%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() # 启动程序
Cb. 封装成类class-函数def
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('
狭路相逢勇者胜，请按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('
你的队伍出场顺序是：%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('
----------------- 【第%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('
很遗憾，我方%s 挂掉了！' % (self.players[i].name))
123 self.score -= 1
124 elif self.players[i].life > 0 and self.enemies[i].life <= 0:
125 print('
恭喜，我方%s 活下来了。' % (self.players[i].name))
126 self.score += 1
127 else:
128 print('
我的天，他们俩都死了啊！')
129 # 展示最终结局
130 def show_result(self):
131 if self.score > 0:
132 print('【最终结果】
你赢了！')
133 elif self.score == 0:
134 print('【最终结果】
平局。')
135 else:
136 print('【最终结果】
你输了。')
137 g=Game() # 启动游戏
实例4 【新年尬聊】
涉及知识点：【文件读取】【异常处理】【模块】【字典列表】【for/while/if】
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)，请重新输入~
结束请按enter:')
56 if x=='':
57 exit()
58 else:
59 continue # 返回while,chioce=input..
60 num=num+1
61 print('
--------------------------------------------------------------------------------')
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
话题表现：%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('请尝试重新运行程序!')