一、山脚

第0关

打印皮卡丘

  • print()函数
  • 打印换行

请你使用print()函数和'''将下面的皮卡丘打印出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
へ　　　　　／|
　　/＼7　　　 ∠＿/
　 /　│　　 ／　／
　│　Z ＿,＜　／　　 /`ヽ
　│　　　　　ヽ　　 /　　〉
　 Y　　　　　`　 /　　/
　ｲ●　､　●　　⊂⊃〈　　/
　()　 へ　　　　|　＼〈
　　>ｰ ､_　 ィ　 │ ／／
　 / へ　　 /　ﾉ＜| ＼＼
　 ヽ_ﾉ　　(_／　 │／／
　　7　　　　　　　|／
　　＞―r￣￣`ｰ―＿

题目讲解

1.复制题目要求打印的“皮卡丘”（直接复制下一步中的字符画即可）

2.用print(‘’’ ‘’’)打印

注意：标点符号都要用英文

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
print(   
    
''' 
    へ　　　　 　／|
　　/＼7　　　 ∠＿/
　 /　│　　 ／　／
　│　Z ＿,＜　／　　 /`ヽ
　│　　　　　ヽ　　 /　　〉
　 Y　　　　　`　 /　　/
　ｲ●　､　●　　⊂⊃〈　　/
　()　 へ　　　　|　＼〈
　　>ｰ ､_　 ィ　 │ ／／
　 / へ　　 /　ﾉ＜| ＼＼
　 ヽ_ﾉ　　(_／　 │／／
　　7　　　　　　　|／
　　＞―r￣￣`ｰ―＿
  '''
)

练习-定个小目标-参考

【题目】

利用print()函数，打印出自己的学习目标和学习计划，以及对应的奖惩措施，即“flag学习法”

【提示】

“flag学习法”：规定时间——>目标——>惩罚和奖励措施。建议完成代码点击右上角分享到社交平台：如微信/朋友圈/QQ空间，让更多朋友见证你的进步。

【参考】

1
2
3
4
print('目标：用一个月的时间入门python，写出一个简单的项目!')
print('计划：每天一个小时学习Pyhton小课；每周复盘知识点；边学边练！')
print('惩罚：做不到，就给朋友圈所有点赞的亲友，每人发个一元红包！')
print('奖励：完成目标，奖励自己一款索尼蓝牙耳机！')

第一关

大话西游

【提示】

  1. 利用input()函数获取用户输入的数据，并把这些数据放在一个变量中

示例：A = input(‘输入一个你错过的人：’)

  1. 在print()函数中，利用加号+实现字符串的拼接

示例：print(‘曾经有一份真挚的爱情放在我面前，ta的名字是’+ A)

  1. 代码添加注释，操作：#(文本内容)

【示例】

A = input(‘输入一个你错过的人：’) #用input()函数获取用户数据，并放到变量A里面

print(‘曾经有一份真挚的爱情放在我面前，ta的名字是’+A)

#通过加号，把获取到的数据A和字符串拼接起来，并用print()函数打印出来

运行结果：(输入 紫霞仙子)

输入一个你错过的人：紫霞仙子

曾经有一份真挚的爱情放在我面前，ta的名字是紫霞仙子

【参考】

1
2
3
4
5
6
7
8
9
A = input('输入一个你错过的人：')     #用input()函数获取用户数据，并放到变量A里面
B = input('输入你最想对ta说的话：')   #用input()函数获取用户数据，并放到变量B里面
C = input('输入一个时长(比如三分钟)：')#用input()函数获取用户数据，并放到变量C里面
print('曾经有一份真挚的爱情放在我面前，ta的名字是' + A)
#通过加号，把获取到的数据A和字符串拼接起来，并用print()函数打印出来
print('可我没有珍惜，如果上天能再给我一次机会，我会对他说三个字'+ B)
#通过加号，把获取到的数据B和字符串拼接起来，并用print()函数打印出来
print('如果非要给这句话加上一个期限，我希望是'+ C)
#通过加号，把获取到的数据C和字符串拼接起来，并用print()函数打印出来

听见无脸男的声音

  • print()函数
  • 转义字符

下面是无脸男对千寻说的话，请你把这段话，运用转义字符按照如下格式打印出来。

1
2
3
4
5
千寻你好，人们叫我'无脸男'
这个世界的人都选择无视我
只有你看到了我并和我打招呼
我感到很孤单，很孤单
你愿意和我成为朋友吗？

题目讲解

**1.**复制下面这段无脸男对千寻说的话：

千寻你好，人们叫我’无脸男’ 这个世界的人都选择无视我 只有你看到了我并和我打招呼 我感到很孤单，很孤单 你愿意和我成为朋友吗？

**2.**提示：文本中有引号的地方需要用到转义字符 ' ；需要换行的地方用 \n

【参考】

1
print("千寻你好，人们叫我'无脸男'\n这个世界的人都选择无视我\n只有你看到了我并和我打招呼\n我感到很孤单，很孤单\n你愿意和我成为朋友吗？")

程序员的一人饮酒醉

  • 数据拼接
  • 数据转换

请运用所给变量，使用str()函数打印两句话。
第一句话：1人我编程累碎掉的节操满地堆
第二句话：2眼是bug相随我只求今日能早归 

1
2
3
4
5
6
7
8
number1  = 1
number2 = 2
unit1 = '人'
unit2 = '眼'
line1 = '我编程累'
line2 = '是bug相随'
sentence1 = '碎掉的节操满地堆'
sentence2 = '我只求今日能早归'

题目讲解

1.将非字符串型变量转换为字符串类型

2.将字符串类变量拼接在一起

【讲解】

1.使用str()函数

2.使用拼接符号**+**

3.使用print()函数

【参考】

1
2
3
4
5
6
7
8
9
10
11
number1  = 1
number2 = 2
unit1 = '人'
unit2 = '眼'
line1 = '我编程累'
line2 = '是bug相随'
sentence1 = '碎掉的节操满地堆'
sentence2 = '我只求今日能早归'
first = str(number1) + unit1 + line1 + sentence1
second = str(number2) + unit2 + line2 + sentence2
print(first)print(second)

非酋的吐槽

  • 数据拼接
  • 数据转换

请运用所给变量，使用数据转换**str()、int()、float()及数据拼接符号+**，打印一句话： 脸黑怪我咯7张蓝票一个SSR都没有 

1
2
3
4
slogan = '脸黑怪我咯'
number = '7.8'
unit = '张'
sentence = '蓝票一个SSR都没有'

题目讲解

1.由于变量中与小数形式的字符串，所以需要使用转换函数将此变量转换为浮点型

2.转换后使用int()函数取整

3.由于数据拼接需要变量为字符串形式，所以需要将变量转化为字符串类型

4.最后数据拼接，得出结果

【讲解】

- 使用float()函数将小数形式的字符串变量转换

- 使用int()函数取整

- 使用str()函数将数据转换为字符串形式

- 使用**+**进行数据拼接

【参考】

1
2
3
4
5
6
slogan = '脸黑怪我咯'
number = '7.8'
unit = '张'
sentence = '蓝票一个SSR都没有'
word = slogan + str(int(float(number))) + sentence
print(word)

第二关

红豆

【题目】

请让这首诗实现换行的功能

​ print(‘《红豆》王维 红豆生南国, 春来发几枝。 愿君多采撷, 此物最相思。’)

换行后，终端的运行效果如下：

《红豆》王维

红豆生南国, 春来发几枝。

愿君多采撷, 此物最相思。

【提示】

可以使用转义字符【\n】

【参考】

1
print('《红豆》王维\n红豆生南国, 春来发几枝。\n愿君多采撷, 此物最相思。')

手机啊手机

【题目】

请输入每天花在手机上的娱乐时间 a，再把时间 a 乘以7，再打印–“您一周花在手机上的娱乐时间总共是××小时”。

【提示】

  1. 用input()函数获取用户数据

  2. 使用int()函数把数据转换为整数，再乘以7

  3. 使用str()函数把一周花在手机上的娱乐时间转换为字符串，用print() 函数输出。

【参考】

1
2
3
a = input('请输入你每天花在手机上的娱乐时间：')
b = int(a) * 7
print('您一周花在手机上的娱乐时间总共是'+str(b)+'小时')

寻找宝石

  • if条件判断语句

请你写出一段代码，在一颗宝石都没偷回来的赋值下，进行条件判断，并产生对应的结果： 

1
2
3
1.如果偷回的宝石数是4颗及以上，输出结果**获得了打败灭霸的力量，反杀稳了**
2.如果偷回的宝石数是1-3颗，输出结果**可以全员出动，殊死一搏**
3.如果偷回的宝石数是0颗，输出结果**没办法了，只能尝试呼叫惊奇队长**

题目讲解

1.为变量【赋值】，写出“一个宝石都没偷回来”的情况

2.用【if】写第一个条件：如果偷回的宝石数是4颗及以上，输出结果：获得了打败灭霸的力量，反杀稳了

3.用【elif】写第二个条件：如果偷回的宝石数是1-3颗，输出结果：可以全员出动，殊死一搏

4.用【else】写第三个条件：如果偷回的宝石数是0颗，输出结果：没办法了，只能尝试呼叫惊奇队长

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#以下为答案示例(stonenumber=0/1/2/3/4/5/6都是对的)
stonenumber=5
#偷回宝石数量赋值
if stonenumber >= 4:    
    #条件：如果你拥有的宝石数量大于等于4个    
    print('获取打败灭霸的力量')    
    #结果：显示‘获取打败灭霸的力量’的结果 
elif 1 < stonenumber <= 3:    
    #条件：如果想让宝石数量停留在4至5个    
    print('可以全员出动，殊死一搏')     
    #结果：显示‘可以全员出动，殊死一搏’的结果   
else:    
    #条件：当赋值不满足if和elif条件时，执行else下的命令，宝石数量在3个以下    
    print('没办法了，只能尝试呼叫惊奇队长')    
    #结果：显示‘没办法了，只能尝试呼叫惊奇队长’的结果

美国队长的工资

  • if条件判断语句
  • if嵌套
1
2
3
4
5
6
7
8
9
判断美国队长的工资水平，代码需要满足如下条件：
1.如果月工资小于等于500美元，显示“欢迎进入史塔克穷人帮前三名”
  1.1如果月工资在100-500美元之间，显示“请找弗瑞队长加薪”
  1.2如果月工资小于等于100美元，显示“恭喜您荣获“美元队长”称号！”
2.如果月工资在500-1000美元之间（含1000美元），打印“祝贺您至少可以温饱了。”
3.其他情况下，如果工资大于1000美元，打印“经济危机都难不倒您！”
  3.1如果工资在1000-20000美元（含20000美元）之间，打印“您快比钢铁侠有钱了！”
  3.2如果月工资大于20000美元，打印“您是不是来自于瓦坎达国？”
4.不管赋值改变后输出结果如何，都需固定打印结果“程序结束”

题目讲解

1.根据题目，我们知道这里涉及嵌套条件，所以可以用扒洋葱法梳理代码逻辑

2.根据要求，先写最外层的if……elif……else……条件

3.根据题目的从属关系分析，最外层的if条件和else条件都有额外条件

4.依次在外层基础条件下添加额外条件

【讲解】

1.使用if条件嵌套

2.嵌套条件需要缩进

3.注意单双引号同时存在时的互相转换

4.通过钱数输出对应的结果

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#以下为答案示例(salary为多少都是对的)
salary = 200
#对美国队长的工资赋值
if salary <= 500:    
    #条件：如果工资小于等于500    
    print('欢迎进入史塔克穷人帮前三名')    
    #结果：显示‘欢迎进入史塔克穷人帮前三名’的结果     
    if salary <= 100:        
        #条件：如果工资小于等于100        
        print('恭喜您荣获“美元队长”称号！')        
        #结果：显示‘恭喜您荣获“美元队长”称号！’的结果     
    else:        
        #条件：当条件满足第4行if，不满足第8行if，执行这个命令        
        print('请找弗瑞队长加薪')        
        #结果：显示‘请找弗瑞队长加薪’的结果 
    elif 500 < salary <= 1000:    
        #条件：如果工资大于500，小于等于1000    
        print('祝贺您至少可以温饱了。')     
        #结果：显示‘祝贺您至少可以温饱了。’的结果 
    elif salary > 1000:    
        #条件：如果工资大于1000    
        print('经济危机都难不倒您！')    
        #结果：显示‘经济危机都难不倒您！’的结果     
        if 1000 < salary <= 20000:        
            #条件：如果工资大于1000，小于等于20000        
            print('您快比钢铁侠有钱了！')        
            #结果：显示‘您快比钢铁侠有钱了！’的结果        
        else:        
            #条件：满足第20行elif条件，不满足第24行if条件,则执行这个命令        
            print('您是不是来自于瓦坎达国？')        
            #结果：显示‘您是不是来自于瓦坎达国？’的结果print('程序结束')

第三关

我要控制我自己

【背景】

最近，派大星想要减肥，他决定控制自己的饮食，少吃一点蟹黄堡。 海绵宝宝为了帮助好朋友派大星，和派大星一起制定了一个饮食游戏。

游戏规则如下： 如果派大星一天吃超过40个蟹黄堡，就要给海绵宝宝100块； 如果派大星一天吃小于等于40个的蟹黄堡，海绵宝宝就给派大星100块。

【题目】

请你写出一段代码： 当输入派大星一天吃的蟹黄堡数量时，可以打印出这天该派大星给海绵宝宝钱，还是海绵宝宝给派大星钱。

【提示】

1.使用input()函数获取获得派大星吃的蟹黄堡的数量。

2.使用int() 函数强制类型转换，将字符串转换为整数。

3.使用if…else… 条件判断语句.

【参考】

1
2
3
4
5
t = int(input('派大星今天吃了多少个蟹黄堡'))
if t > 40:    
	print('派大星给海绵宝宝100块')
else:    
	print('海绵宝宝给派大星100块')

恋爱告白决策

题目】

使用Pyhton代码来演示恋爱过程：

首先判断：两人的关系是不是达到了【朋友之上，恋人未满】？

如果不是，那么输出：进度条还不够，再等等。程序终结。

如果是，那么再判断：你是不是想和对方有进一步的发展？

如果不是，那么输出：还是做朋友吧。程序终结。

如果是，那么再判断：对方是不是想有进一步的发展？

如果不是，那么输出：恭喜获得“好人卡”。

如果是，那么输出：恭喜你们，有情人终成眷属！

【提示】

  1. 条件判断的使用：if…elif…elif…else

  2. 使用input()函数，不需要赋值也可以直接进行条件判断。比如：if input(‘吃了吗？’)==’吃了’:

【参考】

1

1
2
3
4
5
6
7
8
9
10
11
12
13
now = input('你们之前的感情有进入暧昧期了吗？回答有/没有：')
if now =='没有':    
    print('进度条还不太够，再等等吧。')
else:    
    p1 = input('你希望你们的关系再往前一步吗？回答想/不想：')    
    if p1=='不想':        
        print('那还是做朋友吧。')    
    else:        
        p2 = input('那个人呢，ta想吗？回答想/不想：')        
        if p2=='不想':            
            print('恭喜你！获得好人卡*1')        
        else:            
            print('恭喜你们！在一起！')

2

1
2
3
4
5
6
7
8
9
10
11
now = input('你们之前的感情有进入暧昧期了吗？回答有/没有：')
p1 = input('你希望你们的关系再往前一步吗？回答想/不想：')
p2 = input('那个人呢，ta想吗？回答想/不想：')
if now =='没有':    
    print('进度条还不太够，再等等吧。')
elif p1=='不想':    
    print('那还是做朋友吧。')
elif p2=='不想':    
    print('恭喜你！获得好人卡*1')
else:    
    print('恭喜你们！在一起！')

3

1
2
3
4
5
6
7
8
if input('你们之前的感情有进入暧昧期了吗？回答有/没有：') =='没有':    
    print('进度条还不太够，再等等吧。')
elif input('你希望你们的关系再往前一步吗？回答想/不想：')=='不想':    
    print('那还是做朋友吧。')
elif input('那个人呢，ta想吗？回答想/不想：')=='不想':    
    print('恭喜你！获得好人卡*1')
else:    
    print('恭喜你们！在一起！')

4

1
2
3
4
5
6
7
8
9
10
11
now = input('你们之前的感情有进入暧昧期了吗？回答有/没有：')
if now =='没有':    
    exit('进度条还不太够，再等等吧。')
p1 = input('你希望你们的关系再往前一步吗？回答想/不想：')
if p1=='不想':    
	exit('那还是做朋友吧。')
p2 = input('那个人呢，ta想吗？回答想/不想：')
if p2=='不想':    
	exit('恭喜你！获得好人卡*1')
else:    
	print('恭喜你们！在一起！')

5

1
2
3
4
5
6
7
8
9
10
11
12
13
now = input('你们之前的感情有进入暧昧期了吗？回答有/没有：')
if now =='没有':    
    print('进度条还不太够，再等等吧。')
else:    
    p1 = input('你希望你们的关系再往前一步吗？回答想/不想：')    
    if p1=='不想':        
        print('那还是做朋友吧。')    
    else:        
        p2 = input('那个人呢，ta想吗？回答想/不想：')        
        if p2=='不想':            
            print('恭喜你！获得好人卡*1')        
        else:            
            print('恭喜你们！在一起！')

测测你健康吗？

【题目】

输入你的体重和身高，根据BIM指数的计算公式，输出不同BIM指数对应的身体状况（过轻、正常、过重、健康）。

【背景】

BMI指数是一个国际上常用的衡量人体胖瘦程度，以及是否健康的指数。

它的计算方式如下： BMI = 体重 ÷（身高×身高） 比如一个体重50kg，身高160cm的人，BMI = 50 ÷（1.6*1.6）=19.5

对照BMI的表格：

image-20221006144352547

【提示】

  1. 使用条件判断语句if…elif…else的语句来写代码。

  2. 使用input()函数获取输入的身高和体重数据。

  3. 使用float()函数将字符串数据转换为浮点数。

【参考】

1
2
3
4
5
6
7
8
9
10
a = float(input('请输入你的体重(kg)：'))
b = float(input('请输入你的身高(m)：'))
bmi = a/(b*b)if bmi >= 28.0:    
    print('肥胖')
elif bmi >= 24.0:    
    print('过重')
elif bmi >= 18.5:    
    print('正常')
else:    
    print('过轻')

哈利波特的宠物

  • input()函数
  • 数据拼接

为哈利·波特的猫头鹰起个名字，并打印出结果哈利·波特的猫头鹰叫做XX（其中，XX是你起的名字）。

题目讲解

1.搜集猫头鹰的名字（知识点：input(),赋值）

2.打印结果【哈利·波特的猫头鹰叫做XX】（XX是你取的名字）（知识点：数据拼接）

【参考】

1
2
name = input('为哈利·波特的猫头鹰起个名字：')
print('哈利·波特的猫头鹰叫做' + name)

罗恩的减肥计划

  • input()函数
  • 数据类型转换
  • if条件判断语句

随机输入罗恩一天吃的巧克力蛙数量时，可以判断出这天，是罗恩给哈利钱，还是哈利给罗恩钱，并打印出来。

1
2
3
如果罗恩一天吃超过10个巧克力蛙，罗恩要给哈利100块；
如果罗恩一天吃小于等于10个的巧克力蛙，哈利就给罗恩100块。
输入罗恩吃的巧克力数量，并判断是哈利给罗恩钱，还是罗恩给哈利钱。

题目讲解

1.搜集罗恩吃的巧克力数量（知识点：input()、数据转换）

2.写第一个条件：如果罗恩一天吃超过10个巧克力蛙，罗恩要给哈利100块；

3.写第二个条件：如果罗恩一天吃小于等于10个的巧克力蛙，哈利就给罗恩100块。

（知识点：if…else…）

【参考】

1
2
3
4
5
6
number = int(input('请输入罗恩吃的巧克力数量：'))
#int将其转换为整数，之后好进行大小的比较
if number > 10:    
    print('罗恩要给哈利100块')
else:     
    print('哈利就给罗恩100块')

古灵阁金币兑换

  • input()函数
  • if条件判断语句
  • 数据类型转换
  • 数据拼接
  • 数据运算

注1：如果选择不需要帮助，小精灵会礼貌地说’好的，再见。’
注2: 如果选择帮助【1 存取款】，小精灵会推荐你去存取款窗口；如果选择帮助【3 咨询】，小精灵会推荐你去咨询窗口。

1
2
3
4
5
6
7
8
9
小精灵：您好，欢迎古灵阁，请问您需要帮助吗？需要or不需要？
你：需要
小精灵：请问您需要什么帮助呢？1 存取款；2 货币兑换；3 咨询
你：2
小精灵：金加隆和人民币的兑换率为1:51.3，即一金加隆=51.3人民币
小精灵：请问您需要兑换多少金加隆呢？
（你说了一个数字N）
小精灵：好的，我知道了，您需要兑换（你说的数字N）金加隆。
小精灵：那么，您需要付给我（你说的数字N*51.3）人民币。

题目讲解

和小精灵的对话可以被这么拆分：

1.最基础的条件判断：需要帮助；不需要帮助（if…else…）

2.在需要帮助的情况下，又分为1存取款；2货币兑换；3咨询；三种情况。（if…elif…else…）

3.在2-货币兑换的情况下，需要再提一个问题，收集答案，打印出小精灵回答的结果（input()、数据拼接、数据转换）。

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
chioce = input('您好，欢迎古灵阁，请问需要帮助吗？需要or不需要？')
if chioce == '需要':    
    number = input('请问您需要什么帮助呢？1 存取款；2 货币兑换；3 咨询')    
    if number == '2':        
        print('金加隆和人民币的兑换率为1:51.3，即一金加隆=51.3人民币')        
        print('请问您需要兑换多少金加隆呢？')        
        money = input('请输入你需要兑换的金加隆')        
        print('好的，我知道了，您需要兑换' + money + '金加隆。')        
        print('那么，您需要付给我'+str（int(float(money)*51.3)）+'人民币。')            
    elif number == '1':        
        print('请到存取款窗口办理')            
    elif number == '3':        
        print('请到咨询窗口咨询')            
    else:        
        print('输入错误，没有你需要的服务')
    elif chioce == '不需要':    
        print('好的，再见')
    else:    
        print('输入错误')

第四关

君子爱“数”,取之有道

  • 列表和字典的嵌套
  • 拓展知识：元组
1
2
list1 = [{'嫉妒':'envy'},{'恨':'hatred'},{'爱':'love'}]
print(list1[2]['爱'])

题目讲解

第一步：取出字典中键为3对应的值（dict1[3]），即[‘love’,’hatred’,’envy’]

第二步：再取出列表[‘love’,’hatred’,’envy’]中的第一个元素（dict1[3][0]）

【参考】

1
2
3
4
5
6
7
8
9
list1 = [{'嫉妒':'envy'},{'恨':'hatred'},{'爱':'love'}]
print(list1[2]['爱'])

# 第一步：取出列表中的第三个元素（list1[2]），字典{'爱':'love'}；
# 第二步：取出list1[2]中键'爱'所对应的值，即'love’（list1[2]['爱']）。


dict1 = {1:['cake','scone','puff'],2:['London','Bristol','Bath'],3:['love','hatred','envy']}
print(dict1[3][0])

题目讲解

第一步：元组和列表都是序列,提取的方式也是偏移量，如 tuple1[1]、tuple1[1:]。

第二步：先取出列表中的第二个元素中的（list2[1]）

第三步：然后在第二个元素的基础上在去取值，即list2[1][1]

注：（元组和列表的取值方式是相同的）

【参考】

1
2
3
4
5
6
7
8
9
10
# 第一步：取出字典中键为3对应的值（dict1[3]），即['love','hatred','envy']。
# 第二步：再取出列表['love','hatred','envy']中的第一个元素（dict1[3][0]）。

tuple1 = ('A','B')
list2 = [('A','B'),('C','D'),('E','F')]

print(tuple1[0])
print(list2[1][1])

# 从代码里，也可看出：1.元组内数据的提取也是用偏移量；2.元组也支持互相嵌套。

找到那只狼

  • 数据的嵌套
  • 数据的提取

列表中有个字符串是“狼”，将其打印出来吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
townee = [
    {'海底王国':['小美人鱼''海之王''小美人鱼的祖母''五位姐姐'],'上层世界':['王子','邻国公主']},
    '丑小鸭','坚定的锡兵','睡美人','青蛙王子',
    [{'主角':'小红帽','配角1':'外婆','配角2':'猎人'},{'反面角色':'狼'}]
    ]

print(townee[5])
#1看最外层是中括号还是大括号，中括号是列表，填变量[],再看要找的元素前面有几个逗号中括号里就写几
print(townee[5][1])
#2看要找元素外层是中括号还是大括号，中括号是列表，填变量[],再看要找的元素前面有几个逗号中括号里就写几
print(townee[5][1]['反面角色'])
#3看要找元素外层是中括号还是大括号，大括号是字典，填变量[],把键放到里面

第五关

循环加判断，我们不要4。

  • for 循环
  • while 循环

打印1-7，但是不要4

【参考】

1
2
3
4
5
6
7
8
9
for i in range(1,8,1): #range计数从1开始，到8结束但不包含8，计数的间隔为1
	if i!= 4:# 当i != 4，执行打印语句；等于4时不打印。
		print(i)

i = 0  #定义了一个变量     
while i < 7: #当i小于8时，就自动执行后续缩进部分的语句
	i=i+1 #没执行依稀循环，变量i的值都加1
	if i!=4 : #当i != 4，执行打印语句；等于4时不打印。
		print(i)

轮流坐前排

  • 循环处理数据
  • 移除列表元素
1
2
3
小明、小红、小刚是同班同学，且坐在同一排，分别坐在第一位、第二位、第三位。
由于他们的身高都差不多，所以，老师计划让他们三个轮流坐在第一位。
每次换座位的时候，第一位变第三位，后面两位都往前一位。

【提示】

这里需要用到列表的切片和索引。

【解答】

1
2
3
4
5
6
students = ['小明','小红','小刚']
for i in range(3):
	student1 = students[0]    
    students = students[1:]    
    students.append(student1)    
    print(students)

【pop()函数解答】

我们先介绍一下列表中的pop()函数，用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

可以将其理解为提取和删除的融合：

①提取：取到元素，对列表没有影响；

②删除：删除列表的元素。

而移除，则是同时做到取到元素，并且删除列表中的元素。

【提示】

你可以先运行一下右侧的头几行代码感受一下，然后再运用pop()函数来满足“轮流坐前排”这个需求。

【解答】

1
2
3
4
5
students = ['小明','小红','小刚']
for i in range(3):
    student1 = students.pop(0)  # 运用pop()函数，同时完成提取和删除。
    students.append(student1)  # 将移除的student1安排到最后一个座位。
    print(students)

第六关

囚徒困境

  • while True
  • break
1
2
假设有两名囚徒A和B因为合伙犯罪被抓捕，因没有确凿可以指认罪行的证据，审判者准备单独审判两位囚徒。
若两人都认罪，则两人各判10年；若一个认罪一个抵赖，则认罪的人判1年，抵赖的人判20年；若两人都抵赖，则各判3年。

【讲解】

1.开启循环，两人分别选择

首先，我们需要知道两个囚徒各自的选择（input*2）。

2.循环当中，有判断和跳出

两个囚徒的选择，会有四种不同的结果。所以，可以用’if…elif…else’。

判决提示：

若两人都认罪，则两人各判10年；

若一个认罪一个抵赖，则认罪的人判1年，抵赖的人判20年；

若两人都抵赖，则各判3年——这种情况下跳出循环。

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
while True:
    a = input('A，你认罪吗？请回答认罪或者不认')
    b = input('B，你认罪吗？请回答认罪或者不认')
    if a == '认罪' and b == '认罪':
        print('两人都得判10年，唉')
    elif a == '不认' and b == '认罪':
        print('A判20年，B判1年，唉')
    elif a == '认罪' and b == '不认':
        print('A判1年，B判20年')
    else:
        print('都判3年，太棒了')
        break  # 当满足开头提到的条件时，跳出循环。

记录困境中的选择

  • for循环
  • range()函数

记录每一对实验者的选择，以及记录第几对实验者都选择不认罪。

几个提示：

为了记录每一对实验者的选择，需要用一个可拓展的“容器”来存放这些数据；

为了记录是第几对实验者做了最优选择，需要用一个变量来计数；

为了将每一对实验者的选择再打印出来，需要写一个循环。

在打印的那个循环里，需要留意列表是从0开始计数的。

【解答】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
n = 0
list_answer = []

while True:
    n += 1
    a = input('A，你认罪吗？请回答认罪或者不认：')
    b = input('B，你认罪吗？请回答认罪或者不认：')
    list_answer.append([a,b])  # 用列表嵌套的方式来存放实验者的选择，也可用元组或字典。
    if a == '认罪' and b == '认罪':
        print('两人都得判10年，唉')
    elif a == '不认' and b == '认罪':
        print('A判20年，B判1年，唉')
    elif a == '认罪' and b == '不认':
        print('A判1年，B判20年')
    else:
        print('都判3年，太棒了')
        break

print('第' + str(n) + '对实验者选了最优解。')

for i in range(n):
    # 注意数据类型的转换，以及计数起点的不同（0和1）
    print('第' + str(i+1) + '对实验者的选择是：' + str(list_answer[i]))

演员的作品

  • 数据提取
  • 条件判断
1
movie = {'妖猫传':['黄轩','染谷将太']}

【提示】

对该练习完整的提示：

1.先用for…in…遍历字典，把键（即电影名）取出来；

2.再用字典的键把字典里的值（即包含主演名字的列表）取出来；

3.最后用if A in B 作为条件判断A在不在B中，即输入的演员名在不在这个列表中。如果在这个列表中，就打印出××出演了电影××。

【解答】

1
2
3
4
5
6
7
8
9
10
11
12
movies = {
'妖猫传':['黄轩','染谷将太'],
'无问西东':['章子怡','王力宏','祖峰'],
'超时空同居':['雷佳音','佟丽娅'],
}

actor = input('你想查询哪个演员？')
for  movie in movies:  # 用 for 遍历字典
    actors = movies[movie]  # 读取各个字典的主演表
    if actor in actors:
        print(actor + '出演了电影' + movie)

第七关

再来一盘

  • 循环
  • 判断

新功能是：每盘（3局）游戏结束后，游戏会问我们是否要继续游戏，再加一盘。
我们可以选择再来一盘，也可以选择退出游戏。

【讲解】

要达成目标，有两种方案：

1.while True+break：

开启一个无限循环，设定跳出条件。

当得到肯定回复时，继续运行；当得到否定回复时，运行break，停止循环，退出游戏。

2.while 变量名+变量名的布尔值判断：

在开头设某变量的布尔值为True，input后开启判断变量的布尔值是否改变。

当得到肯定回复时，while True，继续运行；当得到否定回复时，while False，停止循环，退出游戏。下面，我们先用较简单的代码来体会一下这两种方案。

方案1：while True+break

开启一个无限循环，设定跳出条件。

当得到肯定回复时，继续运行；当得到否定回复时，运行break，停止循环，退出游戏。

1
2
3
4
# 方案1while True:    
a1 = input('要继续游戏吗，请输入n退出，输入其他继续：')    
if a1 == 'n':        
    break

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#for循环
import time
import random
for i in range(1,4):    
    player_victory = 0    
    enemy_victory = 0    
    time.sleep(1.5)    
    print('  \n——————现在是第 %s 局——————' % i)    
    player_life = random.randint(100,150)    
    player_attack = random.randint(30,50)    
    enemy_life = random.randint(100,150)    
    enemy_attack = random.randint(30,50)    
    print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack)) 
    print('------------------------')    
    time.sleep(1)    
    print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))   
    print('-----------------------')    
    time.sleep(1)    
    while player_life > 0 and enemy_life > 0:        
        player_life = player_life - enemy_attack         
        enemy_life = enemy_life - player_attack        
        print('你发起了攻击，【玩家】剩余血量%s' % player_life)        
        print('敌人向你发起了攻击，【敌人】的血量剩余%s' % enemy_life)     
        print('-----------------------')        
        time.sleep(1.2)    
	if player_life > 0 and enemy_life <= 0:        
        player_victory += 1        
        print('敌人死翘翘了，你赢了！')    
    elif player_life <= 0 and enemy_life > 0:        
        enemy_victory += 1        
        print('悲催，敌人把你干掉了！')    
    else:        
        print('哎呀，你和敌人同归于尽了！')
if player_victory > enemy_victory :    
    time.sleep(1)    
    print('\n【最终结果：你赢了！】')
elif enemy_victory > player_victory:    
    print('\n【最终结果：你输了！】')
else:     
    print('\n【最终结果：平局！】')

方案2：while 变量名+变量名的布尔值判断

在开头设某变量的布尔值为True，input后开启判断变量的布尔值是否改变。

当得到肯定回复时，while True，继续运行；当得到否定回复时，while False，停止循环，退出游戏。

1
2
3
4
5
6
7
8
# 方案2
again = True
while again:    
    a2 = input('要继续游戏吗，请输入y继续，输入其他退出：')    
    if a2 == 'y':        
        again = True    
    else:        
        again = False

【参考】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import time
import random

while True:
    player_victory = 0
    enemy_victory = 0
    for i in range(1,4):
        time.sleep(1.5)
        print('  \n——————现在是第 %s 局——————' % i)
        player_life = random.randint(100,150)
        player_attack = random.randint(30,50)
        enemy_life = random.randint(100,150)
        enemy_attack = random.randint(30,50)

        print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack))
        print('------------------------')
        time.sleep(1)
        print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))
        print('-----------------------')
        time.sleep(1)

        while player_life > 0 and enemy_life > 0:
            player_life = player_life - enemy_attack 
            enemy_life = enemy_life - player_attack
            print('你发起了攻击，【玩家】剩余血量%s' % player_life)
            print('敌人向你发起了攻击，【敌人】的血量剩余%s' % enemy_life)
            print('-----------------------')
            time.sleep(1.2)

        if player_life > 0 and enemy_life <= 0:
            player_victory += 1
            print('敌人死翘翘了，你赢了！')
        elif player_life <= 0 and enemy_life > 0:
            enemy_victory += 1
            print('悲催，敌人把你干掉了！')
        else:
            print('哎呀，你和敌人同归于尽了！')

    if player_victory > enemy_victory :
        time.sleep(1)
        print('\n【最终结果：你赢了！】')
    elif enemy_victory > player_victory:
        print('\n【最终结果：你输了！】')
    else: 
        print('\n【最终结果：平局！】')

    a1 = input('要继续游戏吗，请输入n退出，输入其他继续：')  # 在 while True 循环中设置跳出条件。
    if a1 == 'n':
        break

再来一种

  • 格式化字符串
  • format()函数

学习format()函数

format()函数是从 Python2.6 起新增的一种格式化字符串的函数，功能比课堂上提到的方式更强大。

format()函数用来占位的是大括号{}，不用区分类型码（%+类型码）。

具体的语法是：’str.format()’，而不是课堂上提到的’str % ()’。

而且，它对后面数据的引用更灵活，不限次数，也可指定对应关系。

看完左侧的代码、结果和注释，你就懂上面几句话的意思了。

运用format()函数

将代码中字符串格式化的代码改成format()函数的方法，改完后运行一下，检验是否正确。

【解答】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import time
import random

player_victory = 0
enemy_victory = 0

while True:
    for i in range(1,4):
        time.sleep(1.5)
        print('  \n——————现在是第 {} 局——————'.format(i))
        player_life = random.randint(100,150)
        player_attack = random.randint(30,50)
        enemy_life = random.randint(100,150)
        enemy_attack = random.randint(30,50)

        print('【玩家】\n血量：{}\n攻击：{}'.format(player_life,player_attack))
        print('------------------------')
        time.sleep(1)
        print('【敌人】\n血量：{}\n攻击：{}'.format(enemy_life,enemy_attack))
        print('-----------------------')
        time.sleep(1)

        while player_life > 0 and enemy_life > 0:
            player_life = player_life - enemy_attack 
            enemy_life = enemy_life - player_attack
            print('敌人发起了攻击，【玩家】剩余血量{}'.format(player_life))
            print('你发起了攻击，【敌人】的血量剩余{}'.format(enemy_life))
            print('-----------------------')
            time.sleep(1.2)

        if player_life > 0 and enemy_life <= 0:
            player_victory += 1
            print('敌人死翘翘了，你赢了！')
        elif player_life <= 0 and enemy_life > 0:
            enemy_victory += 1
            print('悲催，敌人把你干掉了！')
        else:
            print('哎呀，你和敌人同归于尽了！')

    if player_victory > enemy_victory :
        time.sleep(1)
        print('\n【最终结果：你赢了！】')
    elif enemy_victory > player_victory:
        print('\n【最终结果：你输了！】')
    else: 
        print('\n【最终结果：平局！】')

    a1 = input('要继续游戏吗，请输入n退出，输入其他继续：')
    if a1 == 'n':
        break

第八关

学习小组成绩的合并排序

  • 列表合并
  • 列表排序
1
2
3
一次测评中，老师将 学习小组A 和 学习小组B 的测评成绩(满分 100 分)从低到高记录放进两个列表：
A=[91, 95, 97, 99]，B=[92, 93, 96, 98] 。
现在，老师想将两个小组的成绩合并为一个列表，并按照从低到高的顺序排序

1. 合并列表-1

分析问题，明确结果

我们的问题是：将两个列表合并起来，并按照从低到高的顺序排序，要得到问题的结果，我们还需要借助打印函数看看我们合并的是否正确。

思考要用到的知识&思考切入点

增加列表的内容与合并列表的含义相同，所以我们可以使用append作为解题的切入点，请你试试！

提示：假设要用已学过的知识来完成这道作业，需要用到列表的新增函数和循环。

1
2
3
4
5
list1 =  [91, 95, 97, 99]  
list2 =  [92, 93, 96, 98]
for i in list2:    
	list1.append(i)
print(list1)

2.合并列表-2

上网搜索新知识&找到新的切入点

好了。你已经完成了第一个需求：合并列表。不过，有没有发现，这个代码还是比较冗余的。有没有更简单的方法呢？请你自己上网搜索一下

python 合并两个列表，看看是否有更简单的方法（提示：以字母e开头），学会后再回来继续做作业吧。

请你根据新学到的知识，简化代码。

注（如果你直接将 list2 合并到 list1 上，那就无法做到只看A组的成绩，所以，最好再建一个列表来合并两组的成绩）

1
2
3
4
5
6
list1 =  [91, 95, 97, 99]  
list2 =  [92, 93, 96, 98]
# 把 A 组成绩赋值给一个新列表，用来存合并的成绩——这个细节要注意！
list3 =list1
list3.extend(list2)
print(list3)

3.列表排序

主动搜索，掌握新知

老师鼓励你自己去探寻解决问题的方法，上网搜索一下列表的排序方法吧，是不是发现了一个以字母s开头的方法？

1
2
3
4
5
6
list1 =  [91, 95, 97, 99]  
list2 =  [92, 93, 96, 98]

list3.sort()
print(list3)

老师我又来了

  • 循环
  • 判断

计算出两组的平均分，并挑出那些在平均分之下的成绩。

【提示】

解题三连击：

1.目前我们想要的结果是：求平均值和判断比较；

2.我们可以用到的知识有：循环叠加成绩，然后除以总人数，即可求平均值。判断比较用小于号和空列表即可；

3.我们的切入点：由于学生的成绩已经被我们集中到一个列表里，所以可以用for循环遍历这个列表来取出小于平均值的成绩。

经过三连击，相信你已经可以帮老师自动化地达成目标了。

【解答】

1
2
3
4
5
6
7
8
9
10
11
12
scores1 =  [91, 95, 97, 99, 92, 93, 96, 98]  
sum = 0
scores2 = []
for score in scores1:    
    sum = sum + score    
    average = sum/len(scores1)  
print('平均成绩是：{}'.format(average))
for score in scores1:    
    if score < average:        
        scores2.append(score)        
		continue
print(' 低于平均成绩的有：{}'.format(scores2))

第二种 解题三连击：

1.目前我们想要的结果是：求平均值和判断比较；

2.我们可以去找的新知识有：Python 求平均值；

3.我们的切入点：请你通过搜索，找到更简单的求平均值的方法，来改造代码。

【提示】

这个方法的单词首字母是“n”，性质是“拓展程序库”。在改造代码前，可以先读懂网上的案例。

【解答】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np  # 导入 numpy库，下面出现的 np 即 numpy库

scores1 =  [91, 95, 97, 99, 92, 93, 96, 98]  
scores2 = []

average = np.mean(scores1)  # 一行解决。
print('平均成绩是：{}'.format(average))

for score in scores1:
    if score < average:
        scores2.append(score)
        continue  # 少于平均分的成绩放到新建的空列表中，然后继续判断。
print(' 低于平均成绩的有：{}'.format(scores2))  # 上个关卡选做题的知识。

# 下面展示一种NumPy数组的操作，感兴趣的同学可以自行去学习哈。
scores3 = np.array(scores1)
print(' 低于平均成绩的有：{}'.format(scores3[scores3<average]))

第九关

hellokitty 抽奖器

  • 函数封装
  • 函数调用
运行抽奖器的代码参考
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import random
import time
# 用random函数在列表中随机抽奖，列表中只有3位候选者。
luckylist = ['海绵宝宝','派大星','章鱼哥']
# random模块中有个随机选取一个元素的方法：random.choice()。
a = random.choice(luckylist)  # 从3个人中随机选取1个人。
print('开奖倒计时',3)
time.sleep(1)  # 调用time模块，控制打印内容出现的时间
print('开奖倒计时',2)
time.sleep(1)
print('开奖倒计时',1)
time.sleep(1)
# 使用三引号打印hellokitty的头像
image = '''
 /\_)o<
|      \\
| O . O|
 \_____/
'''
print(image)  # ……
print('恭喜'+a+'中奖！')  
# 使用print函数打印幸运者名单

分析代码结构，完成函数封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 提示：将以下部分封装进函数
luckylist = ['海绵宝宝','派大星','章鱼哥']
a = random.choice(luckylist)  
print('开奖倒计时',3)
time.sleep(1)
print('开奖倒计时',2)
time.sleep(1)
print('开奖倒计时',1)
time.sleep(1)
image = '''
 /\_)o<
|      \\
| O . O|
 \_____/
'''
print(image)
print('恭喜'+a+'中奖！')
# 查看注释，运行代码。

hellokitty 抽奖器

  • 函数封装
  • 函数调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 查看注释，运行代码。
import random
import time

# 将抽奖程序封装成函数
def choujiang(q,w,e):  # 定义一个抽奖函数，带有3个参数，也就是3位候选人
    luckylist = [q,w,e]  # 定义一个中奖名单的列表
    a = random.choice(luckylist)  # 在中奖名单里面随机选择
    print('开奖倒计时',3)
    time.sleep(1)
    print('开奖倒计时',2)
    time.sleep(1)
    print('开奖倒计时',1)
    time.sleep(1)
    image = '''
    /\_)o<
    |      \\
    | O . O|
    \_____/
    '''
    print(image)
    print('恭喜'+a+'中奖！')
    
choujiang('虚竹','萧峰','段誉')  # 调用函数

年终奖有多少

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def bonus(month):    
    if month < 6:        
        money = 500        
        return money    
    elif 6 <= month <= 12:        
        money = 120 * month        
        return money    
    else:        
        money = 180 * month        
        return money
def info(name, month):    
    gain = bonus(month)    
    print('%s来了%s个月，获得奖金%s元' % (name, month, gain)) 
info('大聪',14)

和电脑玩石头剪刀布

  • 项目拆解
  • 逐步执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import random

# 出拳
punches = ['石头','剪刀','布']
computer_choice = random.choice(punches)
user_choice = ''
user_choice = input('请出拳：（石头、剪刀、布）')  # 请用户输入选择
while user_choice not in punches:  # 当用户输入错误，提示错误，重新输入
    print('输入有误，请重新出拳')
    user_choice = input()

# 亮拳
print('————战斗过程————')
print('电脑出了：%s' % computer_choice)
print('你出了：%s' % user_choice)

# 胜负
print('—————结果—————')
if user_choice == computer_choice:  # 使用if进行条件判断
    print('平局！')
elif (user_choice == '石头' and computer_choice == '剪刀') or (user_choice == '剪刀' and computer_choice == '布') or (user_choice == '布' and computer_choice == '石头'):
    print('你赢了！')
else:
    print('你输了！')

让代码更简洁

  • 代码简化
  • index()函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import random

# 出拳
punches = ['石头','剪刀','布']
computer_choice = random.choice(punches)
user_choice = ''
user_choice = input('请出拳：（石头、剪刀、布）')  # 请用户输入选择
while user_choice not in punches:  # 当用户输入错误，提示错误，重新输入
    print('输入有误，请重新出拳')
    user_choice = input()

# 亮拳
print('————战斗过程————')
print('电脑出了：%s' % computer_choice)
print('你出了：%s' % user_choice)

# 胜负
print('—————结果—————')
if user_choice == computer_choice:  # 使用if进行条件判断
    print('平局！')
# 电脑的选择有3种，索引位置分别是：0石头、1剪刀、2布。
# 假设在电脑索引位置上减1，对应：-1布，0石头，1剪刀，皆胜。
elif user_choice == punches[punches.index(computer_choice)-1]:
    print('你赢了！')
else:
    print('你输了！')

一起来debug

  • bug
  • debug
1
2
3
4
5
6
7
8
9
10
11
scores = {'语文':89, '数学':95, '英语':80}
sum_score = 0

def get_average(scores):
    for subject, score in scores.items():
        sum_score += score
        print('现在的总分是%d'%sum_score)
    ave_score = sum_score/len(scores)
    print('平均分是%d'%ave_score)

get_average(scores)

答案

1
2
3
4
5
6
7
8
9
10
11
scores = {'语文':89, '数学':95, '英语':80}

def get_average(scores):
    sum_score = 0
    for subject, score in scores.items():
        sum_score += score
        print('现在的总分是%d'%sum_score)
    ave_score = sum_score/len(scores)
    print('平均分是%d'%ave_score)

get_average(scores)
1
2
3
4
5
6
7
8
not_bad_word = True
while not_bad_word:
    x = input('请给旺财取个外号：')
    if x == '小狗' and x =='汪汪':
        not_bad_word = False
        print('我生气了，不想理你了！')

print('对不起，以后我不会这么叫你了')

答案

1
2
3
4
5
6
7
8
not_bad_word = True
while not_bad_word:
    x = input('请给旺财取个外号：')
    if x == '小狗' or x =='汪汪':
        not_bad_word = False
        print('我生气了，不想理你了！')

print('对不起，以后我不会这么叫你了')
1
2
3
4
5
deposit = [100,300,900,2000,5000,0,2000,4500]

for i in range(1, len(deposit)):
    times = deposit[i]/deposit[i-1]
    print('你的存款涨了%f倍'%times)

答案

1
2
3
4
5
6
7
8
9
deposit = [100,300,900,2000,5000,0,2000,4500]

for i in range(1, len(deposit)):
    if deposit[i-1] == 0:  # 判断除数等于0时，特殊处理。
        print('你上次存款为 0 哦！')
    else:
        times = deposit[i]/deposit[i-1]
        print('你的存款涨了%f倍'%times)

贴心的除法计算器

  • debug
  • try…except
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
print('\n欢迎使用除法计算器！\n')

while True:
    try:
        x = input('请你输入被除数：')
        y = input('请你输入除数：')
        z = float(x)/float(y)
        print(x,'/',y,'=',z)
        break  # 默认每次只计算一次，所以在这里写了 break。
    except ZeroDivisionError:  # 当除数为0时，跳出提示，重新输入。
        print('0是不能做除数的！')
    except ValueError:  # 当除数或被除数中有一个无法转换成浮点数时，跳出提示，重新输入。
        print('除数和被除数都应该是整值或浮点数！')
    
    # 方式2：将两个（或多个）异常放在一起，只要触发其中一个，就执行所包含的代码。
    # except(ZeroDivisionError,ValueError):
    #     print('你的输入有误，请重新输入！')
    
    # 方式3：常规错误的基类，假设不想提供很精细的提示，可以用这个语句响应常规错误。
    # except Exception:
    #     print('你的输入有误，请重新输入！')

一次性说完

  • 类的创建和调用
  • 创建类的两个关键点
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Chinese:

    def __init__(self,hometown,region):
        self.hometown = hometown
        self.region = region
        print('程序持续更新中……')

    def born(self):
        print('我生在%s。'%(self.hometown))

    def live(self):
        print('我在%s。'%(self.region))
    
    # 新建方法，调用上面的两个方法（注：方法名可自定义）。
    def citys(self):
        self.born()
        self.live()

wufeng = Chinese('广东', '深圳')
wufeng.citys()
# 调用方法后，程序运行方法中的代码（即依次调用方法`born`和`live`）。

重要的事情说三遍

  • 类的创建和调用
  • 创建类的两个关键点
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Robot:
    def __init__(self):
        self.name = input('我现在刚诞生，还没有名字，帮我起一个吧。')
        self.master = input('对了，我要怎么称呼你呢？')
        print('你好%s，我叫%s。很开心，遇见你~'%(self.master,self.name))
    
    def say_wish(self):
        wish = input('告诉一个你的愿望吧：')
        print(self.master+'的愿望是：')
        # 这里也可以用字符串的格式化，不过，用循环语句的话，之后改复述次数会方便些。
        for i in range(3):
            print(wish)

robot1 = Robot()
robot1.say_wish()

老师和父亲

  • 子类的继承
  • 子类的定制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Teacher:
    face = 'serious'
    job = 'teacher'


class Father:
    face = 'sweet'
    parenthood = 'dad'


class TeacherMore(Teacher, Father):
    pass

class FatherMore(Father, Teacher):
    face = 'gentle'

time3 = TeacherMore()
time4 = FatherMore()
print(time3.face)
print(time4.face)

学习时间记录

  • 子类的继承
  • 子类的定制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Student:
    def __init__(self, name, job=None, time=0.00, time_effective=0.00): 
        self.name = name
        self.job = job
        self.time = time
        self.time_effective = time_effective

    def count_time(self, hour, rate):
        self.time += hour
        self.time_effective = hour * rate

class Programmer(Student):
    def __init__(self, name):
        Student.__init__(self, name, job='programmer', time=0.00, time_effective=0.00)

    def count_time(self, hour, rate=1):
        Student.count_time(self, hour, rate)

student1 = Student('韩梅梅')
student2 = Programmer('李雷')
print(student1.job)
print(student2.job)
student1.count_time(10, 0.8)
student2.count_time(10)
print(student1.time_effective)
print(student2.time_effective)

书的分类

  • 子类的继承和定制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Book:
 
    def __init__(self, name, author, comment, state = 0):
        self.name = name
        self.author = author
        self.comment = comment
        self.state = state
 
# 创建一个Book类的子类 FictonBook

class FictonBook(Book):
    def __init__(self, name, author, comment, state = 0, type = '虚构类'):
        Book.__init__(self, name, author, comment, state = 0)
        self.type = type

    def __str__(self):
        status = '未借出'
        if self.state == 1:
            status = '已借出'
        return '类型：%s 名称：《%s》 作者：%s 推荐语：%s\n状态：%s ' % (self.type, self.name, self.author, self.comment, status)


book = FictonBook('囚鸟','冯内古特','我们都是受困于时代的囚鸟')
print(book)

我想看TA的书

  • 代码优化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class Book:
 
    def __init__(self, name, author, comment, state = 0):
        self.name = name
        self.author = author
        self.comment = comment
        self.state = state
 
    def __str__(self):
        status = '未借出'
        if self.state == 1:
            status = '已借出'
        return '名称：《%s》 作者：%s 推荐语：%s\n状态：%s ' % (self.name, self.author, self.comment, status)
 
class BookManager:

    authors = []
    def __init__(self):
        book1 = Book('撒哈拉的故事','三毛','我每想你一次，天上便落下一粒沙，从此便有了撒哈拉。')
        book2 = Book('梦里花落知多少','三毛','人人都曾拥有荷西，虽然他终会离去。')
        book3 = Book('月亮与六便士','毛姆','满地都是六便士，他却抬头看见了月亮。')
        self.books = [book1,book2,book3]
        self.authors.append(book1.author)
        self.authors.append(book2.author)
        self.authors.append(book3.author)
 
    def menu(self):
        while True:
            print('1.查询书籍')
            choice = int(input('请输入数字选择对应的功能：'))
            if choice == 1:
                self.show_author_book()
            else:
                print('感谢使用！')
                break
 
    def show_author_book(self):
        author = input('请输入想查询作家的名称：')
        if author in self.authors:
            print(author + '的作品有：')
            for book in self.books:
                if book.author == author:
                    print(book)
        else:
            print('很可惜，我们暂时没有收录这位作者的作品')

manager = BookManager()
manager.menu()

数据转移中的变化

  • 编码和解码
  • 文件读写
1
2
3
4
5
6
7
8
9
10
11
12
13
# 1.分别使用gbk和utf-8编码自己的名字，并将其打印出来。
print('士不可不弘毅，任重而道远'.encode('utf-8'))
print('士不可不弘毅，任重而道远'.encode('gbk'))



# 2.复制上一步得到的结果，进行解码，打印出你的名字（两次）。
print(b'\xe5\xa3\xab\xe4\xb8\x8d\xe5\x8f\xaf\xe4\xb8\x8d\xe5\xbc\x98\xe6\xaf\x85\xef\xbc\x8c\xe4\xbb\xbb\xe9\x87\x8d\xe8\x80\x8c\xe9\x81\x93\xe8\xbf\x9c'.decode('utf-8'))
print(b'\xca\xbf\xb2\xbb\xbf\xc9\xb2\xbb\xba\xeb\xd2\xe3\xa3\xac\xc8\xce\xd6\xd8\xb6\xf8\xb5\xc0\xd4\xb6'.decode('gbk'))


# 3.使用gbk解码：b'\xb7\xe7\xb1\xe4\xbf\xc6\xbc\xbc\xd3\xd0\xd2\xe2\xcb\xbc'，并打印出来。
print(b'\xb7\xe7\xb1\xe4\xbf\xc6\xbc\xbc\xd3\xd0\xd2\xe2\xcb\xbc'.decode('gbk'))
1
2
3
4
5
6
# 先打开图片
with open('photo2.png','rb') as file:  # 以“rb”模式打开图片
    data = file.read()
    with open('photo3.png','wb') as newfile:  # 以“wb”模式写入
        newfile.write(data)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
file1 = open('scores.txt','r',encoding='utf-8') 
file_lines = file1.readlines() 
file1.close()

final_scores = []

for i in file_lines:
    data =i.split()
    sum = 0  # 先把总成绩设为0
    for score in data[1:]:  # 遍历列表中第1个数据和之后的数据
        sum = sum + int(score)  # 然后依次加起来，但分数是字符串，所以要转换    
    result = data[0]+str(sum)+'\n'  # 结果就是学生姓名和总分
    print(result)
    final_scores.append(result)

print(final_scores)

sum1 = open('winner.txt','w',encoding='utf-8') 
sum1.writelines(final_scores)
sum1.close()

1
2
3
4
5
6
7
8
9
10
11
# 下面已经为你准备好了打开的代码和一些变量名的准备。
# 请你完成数据处理以及新建文档（同一个目录）的代码。
# 一个提示：可以用 print 作为检验代码，步步为营。

file1 = open('winner.txt','r',encoding='utf-8') 
file_lines = file1.readlines() 
file1.close()

dict_scores = {}
list_scores = []
final_scores = []
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 下面注释掉的代码，皆为检验代码（验证每一步的思路和代码是否达到目标，可解除注释后运行）。

file1 = open('winner.txt','r',encoding='utf-8') 
file_lines = file1.readlines() 
file1.close()

dict_scores = {}
list_scores = []
final_scores = []

# print(file_lines) 
# print(len('\n'))

# 打印结果为：['罗恩102\n', '哈利383\n', '赫敏570\n', '马尔福275\n']
# 经过测试，发现'\n'的长度是1。所以，名字是“第0位-倒数第5位”，分数是“倒数第4位-倒数第二位”。
# 再根据“左取右不取”，可知：name-[:-4],score-[-4:-1]

for i in file_lines:  # i是字符串。
    print(i)
    name = i[:-4]  # 取出名字（注：字符串和列表一样，是通过偏移量来获取内部数据。）
    score = int(i[-4:-1])  # 取出成绩
    print(name)
    print(score)
    dict_scores[score] = name  # 将名字和成绩对应存为字典的键值对(注意：这里的成绩是键)
    list_scores.append(score)

# print(list_scores)
list_scores.sort(reverse=True)  # reverse，逆行，所以这时列表降序排列，分数从高到低。
# print(list_scores)

for i in list_scores:
    result = dict_scores[i] + str(i) + '\n'
    # print(result)
    final_scores.append(result)

print(final_scores)  # 最终结果

winner_new = open('winner_new.txt','w',encoding='utf-8') 
winner_new.writelines(final_scores)
winner_new.close()

古诗默写

  • 文件读写
1
2
3
4
5
6
7
8
9
10
list_test = ['一弦一柱思华年。\n','只是当时已惘然。\n']  # 将要默写的诗句放在列表里。
with open ('poem2.txt','r') as f:
    lines = f.readlines()
print(lines)
with open('poem2.txt','w') as new:
    for line in lines:
        if line in list_test:  # 属于默写列表中的句子，将其替换成横线。
            new.write('____________。\n')
        else:
            new.write(line)

时间记录器

  • 内置模块
  • 模块学习
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import time

input("欢迎使用“时间管理器”！请按回车继续。")

while True:
    task_name = input('请输入任务名：')
    task_time = int(input('你觉得自己至少可以专注这个任务多少分钟？输入 N 分钟'))
    input('此次任务信息：\n我要完成的任务：%s\n我至少要专注：%d分钟\n按回车开始计时：'%(task_name,task_time))
    start = time.time()  # 开始计时
    start_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))  # 格式化日期
    
    # 实际代码：分钟转成秒要乘60，用-1来倒计时。
    # for t in range(task_time*60,0,-1):
    for t in range(task_time,0,-1):
        info = '请专注任务，还要保持专注 ' + str(t) + ' 秒哦！'
        print(info,end="")
        print("\b"*(len(info)*2),end="",flush=True)
        time.sleep(1)
    print('你已经专注了 %d 分钟，很棒~再加把劲，完成任务！'%task_time)  # 倒计时后，才继续运行之后的代码。

    # 询问任务是否完成
    task_status = input('请在任务完成后按输入y:')
    if task_status == 'y':
        end = time.time()  # 一定用户按了 y，就记下结束时间。
        end_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))  # 日期格式化
        actual_time = int((end -start)/60)  # 始末时间相减，从秒换算到分，除以60。
        start_end = start_time + '——' + end_time + '\n'
        with open('timelog3.txt','a', encoding = 'utf-8') as f:
            f.write(task_name + ' 的预计时长为：' + str(task_time) + '分钟\n')
            f.write(task_name + ' 的实际时长为：' + str(actual_time) + '分钟,具体时间为：' + start_end)
        again = input('建立一个新任务请按 y, 退出时间日志记录器请按 q：')
        if again == 'q':            
            break
    else:
        print('抱歉，你的输入有误。请重启时间记录器。')

print('愿被你善待的时光，予你美好的回赠。')

再出古诗默写题

  • 内置模块
  • 模块学习
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import os

list_test = ['一弦一柱思华年。\n','只是当时已惘然。\n']

with open ('poem3.txt','r') as f:
    lines = f.readlines()

with open('poem_new.txt','w') as new:
    for line in lines:
        if line in list_test:
            new.write('____________。\n')
        else:
            new.write(line)

os.replace('poem_new.txt', 'poem3.txt')

自制动态二维码

  • 自学模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 先导入模块
'''from MyQR import myqr

myqr.run(
    words='http://weixin.qq.com/r/kzlje9TEE4lsrZAY92yB',
    # 扫描二维码后，显示的内容，或是跳转的链接
    version=5,  # 设置容错率
    level='H',  # 控制纠错水平，范围是L、M、Q、H，从左到右依次升高
    picture='she.gif',  # 图片所在目录，可以是动图
    colorized=True,  # 黑白(False)还是彩色(True)
    contrast=1.0,  # 用以调节图片的对比度，1.0 表示原始图片。默认为1.0。
    brightness=1.0,  # 用来调节图片的亮度，用法同上。
    save_name='Python.gif',  # 控制输出文件名，格式可以是 .jpg， .png ，.bmp ，.gif
    )'''

绝对值的多种求法

  • 内置函数
  • 内置模块
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import math

# 方法1：条件判断
def abs_value1():
    a = float(input('1.请输入一个数字：'))
    if a >= 0:
        a = a
    else:
        a = -a
    print('绝对值为：%f' % a)

# 方法2：内置函数 abs()
def abs_value2():
    a = float(input('2.请输入一个数字：'))
    a = abs(a)
    print('绝对值为：%f' % a)

# 方法3：内置模块 math
def abs_value3():
    a = float(input('3.请输入一个数字：'))
    a = math.fabs(a)
    print('绝对值为：%f' % a)

# 运行函数，查验一下。
abs_value1()
abs_value2()
abs_value3()

拯救选择困难症

  • 产品思维
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 帮你做选择之我要吃什么
import random

# 将需要用到的表格和变量放在开头
list_food = ['KFC', '蒸菜馆', '楼下快餐店', '桂林米粉', '东北饺子', '金牌猪脚饭', '三及第汤饭']  # 备选菜单，可自定义。
list_choice = []

# 由于两个原因都包含判断过程，所以，为了让代码更简洁，可将其封装成函数。
def choose(list):
    while True:
        food = random.choice(list)
        judgement = input('去吃【%s】好不好啊？同意的话输入y，不想吃直接回车即可。'%(food))
        if judgement == 'y':
            print('去吃【%s】！就这么愉快地决定啦！'%(food)) 
            break

# 判断环节
reason = int(input('你不知道吃什么的原因是：1.完全不知道吃什么；2.在几家店之间徘徊（请输入1或2）：'))
if reason == 1:
    choose(list_food)
elif reason == 2:
    add = True
    while add:
        choice = input('请输入让你犹豫的店名（注：一家一家输，完成后输入y）：')
        if choice != 'y':  # 这个判断语句，是为了不将 y 也添加到菜单里。
            list_choice.append(choice)
        if choice == 'y':
            add = False
    choose(list_choice)          
else:
    print('抱歉，目前还不支持第三种情况——不过，你可以加代码哦。')

模拟广告牌

  • 产品思维
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 运行前可将第8行改为 for i in range(20) 控制一下循环次数。
# 或者，可以直接运行，然后用“刷新网页”这种方法强行打断程序。

import os, time

def main():  # 用函数封装，可复用性会高一些（可在其他的.py文件里调用该函数。）
    content = ' 风变编程，陪你一起学Python '  # 广告词可自定义。
    while True:
        # linux/os x系统【清除屏幕】代码（线上使用本代码）
        os.system('clear')  # 清屏和打印结合起来，形成滚动效果。
        # windows系统【清除屏幕】代码
        '''
        os.system('cls') 
        '''
        print(content)
        content = content[1:] + content[0]  # 这行代码相当于：将字符串中第一个元素移到了最后一个。
        time.sleep(0.25)  # 你可以改下时间，体会“循环周期”和“滚动速度”之间的关联。

if __name__ == '__main__':  # 类里面学到的检测方法，在函数中其实也可以用。
    main()