目录
1.0-Python初识
在编程界,有一句话非常出名,叫“Talk is cheap, show me the code.”——空谈无益,秀代码
print()函数
转义字符
变量和赋值
=和==
变量的命名规范
作业1
作业2
数据类型
字符串
整数
运算符
浮点数
数据拼接
type()函数:查询数据类型
数据转换
作业1
作业2
作业3
条件判断
单向判断:if
冒号和缩进
双向判断:if…else…
多向判断:if…elif…else…
if嵌套
如何写嵌套代码
作业1
作业2
input()函数
作业1
作业2
作业3
列表
什么是列表
从列表提取单个元素
从列表提取多个元素
给列表增加/删除元素
数据类型:字典
什么是字典
从字典中提取元素
给字典增加/删除元素
列表和字典的异同
作业1
作业2
循环
for...in...循环语句
for循环:变量
for循环:循环对象
range()函数
for循环:for子句
while循环
while循环:放行条件
while循环:办事流程
两种循环对比
作业1
作业2
布尔值
用数据做判断:布尔值
【布尔运算】的三种方式
两个数值做比较
直接用数值做运算
布尔值之间的运算
四种新的语句
break语句
continue语句
pass语句
else语句
循环小练习
项目实操关卡-人机PK
明确项目目标
分析过程,拆解项目
逐步执行,代码实现
版本1.0:自定属性,人工PK
版本2.0:随机属性,自动PK
版本3.0:打印战果,三局两胜
格式化字符串
作业1
作业2
安装Python环境
推荐VS2019
复制,直接运行感受python程序
import time
print('你来和我做朋友了吗?我好高兴啊!让我来介绍一下自己')
time.sleep(2)
print('有人说:我是迈入人工智能时代的第一道门槛。')
time.sleep(2)
print('这没错,确实有很多人工智能算法都是通过我来实现的')
time.sleep(2)
print('还有人说,我是编程初学者入门的最好选择')
time.sleep(1)
print('这也对,因为我还被称为"胶水语言",是最简洁的编程语言了')
time.sleep(2)
print('但是,对你而言,我究竟应该是什么呢?')
time.sleep(1)
print('其实,我是你实现目的的一个工具,只要你有需求,我就能帮上忙')
time.sleep(2)
print('我会好好地帮助你,带你紧跟人工智能时代;我会解放你的双手,帮你提高工作效率;')
人才最为紧缺的前十个职位中
可以往数据分析师、爬虫工程师、web全栈开发、算法工程师等方向继续深造
代码-结果-解析
print(520)
#520
#解析:print(数字)计算机会将数字当成表达式自动计算
print(1+1)
#2
print('一起玩吧')
#一起玩吧
#解析:括号内是单引号的情况
print("一起玩吧")
#一起玩吧
#解析:括号内是双引号的情况
print("Let's play")
#Let's play
#解析:括号内单双引号同时存在的情况
#双引号是函数结构,单引号属于字符串内容
print('Let\'s play')
#Let's play
#解析:Python是从左往右匹配单(双)引号的
#当出现引号重复的时候,要将其转义掉,使其不再拥有特殊能力
print('''print内部使用三引号
(连续输入三个单引号)
来实现自动换行''')
#print内部使用三引号
#(连续输入三个单引号)
#来实现自动换行
#解析:三单引号可实现直接自动换行
print('使用转义字符\n实现换行')
#使用转义字符
#实现换行
#解析:在一句话中间加\n也可以直接换行
运行结果
520
2
一起玩吧
一起玩吧
Let's play
Let's play
print内部使用三引号
(连续输入三个单引号)
来实现自动换行
使用转义字符
实现换行
Press any key to continue . . .
拓展:
代码-结果-解析
name='千寻'
print(name)
#千寻
#解析:把“千寻”这两个字【赋值】给了“name”这个【变量】
name='千寻'
name='小千'
print(name)
#小千
#解析:当你放进新的东西时,旧的东西就会被替代掉
运行结果
千寻
小千
Press any key to continue . . .
拓展
#赋值符号=不是左边等于右边的意思。仅仅表示赋值动作
#代表左右两边相等的符号,是比较运算符==
1.只能是一个词。
2.只能包含字母、数字和下划线。
3.不能以数字开头。
4.尽量描述包含的数据内容。
题目要求
除了文字和数字之外,我们还可以灵活运用print()函数,打印出带特殊格式的东西,例如:字符画。现在,请试着打印出一只属于自己的“皮卡丘”,成功打印后,请把你的皮卡丘分享到社群里吧。
题目讲解
1.复制题目要求打印的“皮卡丘”(皮卡丘字符画会在【书写代码】步骤里直接提供)
2.用print(''' ''')打印
注意:标点符号都要用英文
书写代码
请你使用print()函数将下面的皮卡丘打印出来。皮卡丘字符画可以直接复制下面的。
へ /|
/\7 ∠_/
/ │ / /
│ Z _,< / /`ヽ
│ ヽ / 〉
Y ` / /
イ● 、 ● ⊂⊃〈 /
() へ | \〈
>ー 、_ ィ │ //
/ へ / ノ<| \\
ヽ_ノ (_/ │//
代码参考
print(''' へ /|
/\7 ∠_/
/ │ / /
│ Z _,< / /`ヽ
│ ヽ / 〉
Y ` / /
イ● 、 ● ⊂⊃〈 /
() へ | \〈
>ー 、_ ィ │ //
/ へ / ノ<| \\
ヽ_ノ (_/ │//''')
结果
へ /|
/\7 ∠_/
/ │ / /
│ Z _,< / /`ヽ
│ ヽ / 〉
Y ` / /
イ● 、 ● ⊂⊃〈 /
() へ | \〈
>ー 、_ ィ │ //
/ へ / ノ<| \\
ヽ_ノ (_/ │//
Press any key to continue . . .
题目要求
请将无脸男对千寻说的话,按照正确的格式打印出来。
题目讲解
1.根据题目可知,本题需要运用三个知识点:换行,运用转义字符将单引号打印出来,打印函数。
2.换行\n
3.转义字符\'
4.打印函数print()
书写代码
下面是无脸男对千寻说的话:千寻你好,人们叫我'无脸男' 这个世界的人都选择无视我 只有你看到了我并和我打招呼 我感到很孤单,很孤单 你愿意和我成为朋友吗?
请你把这段话按照下面的格式打印出来:
千寻你好,人们叫我'无脸男'
这个世界的人都选择无视我
只有你看到了我并和我打招呼
我感到很孤单,很孤单
你愿意和我成为朋友吗?
代码参考
print('千寻你好,人们叫我\'无脸男\' \n这个世界的人都选择无视我 \n只有你看到了我并和我打招呼 \n我感到很孤单,很孤单 \n你愿意和我成为朋友吗?')
结果
千寻你好,人们叫我'无脸男'
这个世界的人都选择无视我
只有你看到了我并和我打招呼
我感到很孤单,很孤单
你愿意和我成为朋友吗?
最常用的数据类型有三种——字符串(str)、整数(int)和浮点数(float)
用引号括起来的文本,例如
name='千寻'
name2="小千"
name3='''小小小
千'''
正整数、负整数和零的统称,是没有小数点的数字
带小数点的数字
浮点数识别起来非常简单,但是其运算却晦涩难懂、让人头秃。世界级C++大佬Herb Sutter说的:“世上的人可以分为3类:一种是知道自己不懂浮点运算的;一种是以为自己懂浮点运算的;最后一种是极少的专家级人物,他们想知道自己是否有可能,最终完全理解浮点运算。”
代码-结果-解析
print(0.55+0.3)
#0.8500000000000001
#解析:Python计算浮点数的方式与我们不一样。
#Python计算浮点数时,会先把0.55和0.3转化成二进制数
#进制转换
#0.55(十进制) = 0.1000110011001100110011001100110011001100110011001101(二进制)
#0.3(十进制) = 0.0100110011001100110011001100110011001100110011001101(二进制)
#然后,这俩二进制数通过二进制法则运算后,再通过复杂的计算公式,将二进制结果转成十进制小数。
#经过这两次转换,小数点后面就产生了多余的“尾巴”。这样,就造成了我们与程序计算结果的差异。
+就可以实现字符串与字符串
代码-结果-解析
hero = '亚瑟'
enemy = '敌方'
action = '团灭'
gain = '获得'
achieve = 'ACE称号'
print(hero+action+enemy+gain+achieve)
#亚瑟团灭敌方获得ACE称号
#解析:加号可实现字符串与字符串拼接
Python中一个已有的,既简单又实用的type()函数,来帮助我们查询不确定数据的类型
查询数据类型:type(变量名)
查询数据类型并打印:print(type(变量名))
代码-结果-解析
hero = '亚瑟'
number = 5
type(hero)
type(number)
print(type(hero))
print(type(number))
#
#
负责转换数据类型的函数一共有3种:str()、 int()和float()
注意:也可用引号转换
注意:
1.文字类和小数类字符串,无法转化成整数
2.浮点数转化成整数:抹零取整
注意:文字类字符串无法转成浮点数
代码-结果-解析
hero = '亚瑟'
number = 5
print(hero+str(number))
print(hero+'5')
#亚瑟5
#亚瑟5
bug = '666'
hair = '0'
print(int(bug)+int(hair))
#666
height = 183.5
weight = 79
age = '30'
print(float(height))
print(float(weight))
print(float(age))
#183.5
#79.0
#30.0
我想使用以下变量,输出这样一个结果人工智障说:3.8+1等于4
word = '3.8'
number = 1
sentence = '人工智障说:3.8+1等于'
输出结果:
人工智障说:3.8+1等于4
其中,输出结果中的4,是由字符串型变量【word = '3.8'】,加上整数型变量【number = 1】得出来的
参考代码
word = '3.8'
number = 1
sentence = '人工智障说:3.8+1等于'
print(sentence+str(int(float(word)+number)))
代码结果
人工智障说:3.8+1等于4
解析
字符串转浮点型后与数字相加,后将浮点型结果转为整形后转为字符串后进行数据拼接
题目要求
请运用所给变量,使用str()函数打印两句话。
第一句话:1人我编程累碎掉的节操满地堆
第二句话:2眼是bug相随我只求今日能早归
题目讲解
1.将非字符串型变量转换为字符串类型
2.将字符串型变量拼接在一起
3.使用print()函数打印拼接结果
书写代码
请复制粘贴下方变量,并使用str()函数转换,打印出两句话:
第一句话:1人我编程累碎掉的节操满地堆
第二句话:2眼是bug相随我只求今日能早归
变量:
sentence2 = '我只求今日能早归'
参考代码
number1 = 1
number2 = 2
unit1 = '人'
unit2 = '眼'
line1 = '我编程累'
line2 = '是bug相随'
sentence1 = '碎掉的节操满地堆'
sentence2 = '我只求今日能早归'
print(str(number1)+unit1+line1+sentence1)
print(str(number2)+unit2+line2+sentence2)
代码结果
1人我编程累碎掉的节操满地堆
2眼是bug相随我只求今日能早归
题目要求
请运用所给变量,使用数据转换str()、int()、float()及数据拼接符号+,打印一句话: 脸黑怪我咯7张蓝票一个SSR都没有
其中,变量会在【书写代码】步骤里直接提供。
题目讲解
1.由于变量中有小数形式的字符串'7.8'
,所以需要使用转换函数将此变量转换为浮点型
2.转换后使用int()函数取整
3.由于数据拼接需要变量为字符串形式,所以需要将变量转化为字符串类型
4.最后数据拼接,得出结果
书写代码
请运用所给变量,使用数据转换str()、int()、float()及数据拼接符号+,打印一句话: 脸黑怪我咯7张蓝票一个SSR都没有
所给变量:
slogan = '脸黑怪我咯'
number = '7.8'
unit = '张'
sentence = '蓝票一个SSR都没有'
参考代码
slogan = '脸黑怪我咯'
number = '7.8'
unit = '张'
sentence = '蓝票一个SSR都没有'
print(slogan+str(int(float(number)))+unit+sentence)
代码结果
脸黑怪我咯7张蓝票一个SSR都没有
解析
字符串转浮点型,后将浮点型结果转为整形后转为字符串后进行数据拼接
代码-结果-解析
stonenumber=6
if stonenumber>=6:
print('你拥有了毁灭宇宙的力量')
#你拥有了毁灭宇宙的力量
#解析:如果 条件:
# 做点什么
在条件判断代码中的冒号:后、下一行内容的前面,会空几个格
在计算机的沟通语言中,空格的学名叫缩进,比如我们写文章都要空两个格,这就叫首行缩进
对于Python而言,冒号和缩进是一种语法。它会帮助Python区分代码之间的层次,理解条件执行的逻辑及先后顺序。
并且,在if条件语言中,缩进不需要我们手动按空格键。当你用英文输入法打:后按回车,我们的开发工具(用来编写Python代码的程序)为了方便大家编程,会自动实现下一行代码,向右缩进的功能。
此时,被缩进的内容(print()函数)和if条件语句组成了一个代码块(一个整体),成为了if条件下的内部命令
这意味着:如果赋值满足if条件,计算机就会准确执行if条件内部的命令。
冒号和缩进就相当于C语言、C++中的{}的作用
例子:如果没有缩进
代码-结果-解析
stonenumber=6
if stonenumber>=6:
print('你拥有了毁灭宇宙的力量')
#IndentationError: expected an indented block
#解析:(缩进错误:期望一个缩进块)
#当我们去掉缩进时,if条件和print命令成为了两个不同的代码组,属于平行关系。
#你看,print小弟都自立为王了,他自然就不会执行if老大的命令了
如果…不满足,就…
1.【if...else...】双向判断语句是:如果不满足if的条件,就执行else下的命令。
2. if和else自身所代表的条件是互斥的。
3.else想正确运行,一定要有一个和它平级的前提,这个前提可以是if判断,也可以是其他命令,比如循环命令。
代码-结果-解析
stonenumber=3
#赋值语句:为宝石数量赋值
if stonenumber>=6:
#条件:如果你拥有的宝石数量大于等于6个
print('你拥有了毁灭宇宙的力量')
#结果:显示‘你拥有了毁灭宇宙的力量’的结果
else:
#条件:当赋值不满足if条件时,执行else下的命令
print('带着卡魔拉去沃弥尔星寻找灵魂宝石')
#结果:显示‘去找灵魂宝石’的结果
#去找灵魂宝石
要求else前面没有缩进:
首先,当else条件前没缩进时,if和else各自抱团,形成两个不同的代码块。这时,if条件和else条件是平级的。
其次,在平级关系的前提下,他们表示的意思是条件和其他条件的互斥关系——如果不满足if条件,就执行else其他条件
如果有缩进就会报错:【SyntaxError: invalid syntax】(语法错误:无效语法)
else不一定要和if组团才能运行
并不是,虽然想要让else生效,一定需要一个平级的前提条件,但这个前提条件却不一定是条件判断语句,还可以是其他命令语句
可这个和else平级的命令有个限制条件:它得是一个需要再处理的命令。
什么叫再处理呢?就是要让计算机先做个判断(如先运行if条件),看是否通过,如果不通过,再运行else。
举一些具体的例子:while循环、for循环,这些都是需要再处理的命令,所以他们也可以作为else的平级命令。
下面,请你先看一下这段代码
for i in range(10):
if i == 11:
print('找到结果')
break
else:
print('未找到结果')
#未找到结果
#解析:else和if不仅不是平级,而且if语句还缩进了,并且else在if外,比if还高一级
#由于if缩进,成为了for循环的“小弟”。所以else和for的内部条件if无关,只和它的平级条件for循环有关
#这就意味着:根据计算机一行行往下执行命令的语法特点,计算机会先执行for循环下的代码块,完成后再执行else下的命令
代码-结果-解析
stonenumber=5
#为宝石数量赋值
if stonenumber>=6:
#条件:如果你拥有的宝石数量大于等于6个
print('你拥有了毁灭宇宙的力量')
#结果:显示‘就拥有了毁灭宇宙的力量’的结果
elif 3
扒洋葱大法
第一步就是:我们要搞定最外层那张皮,将最基础的命令和条件写出来。
第二步,在“第一层皮”里增加额外条件。
最后一步,你要为另一个大条件else增加额外条件了!
题目要求
请你写出一段代码,在一颗宝石都没偷回来的赋值下,进行条件判断,并产生对应的结果:
1.如果偷回的宝石数是4颗及以上,输出结果获得了打败灭霸的力量,反杀稳了
2.如果偷回的宝石数是1-3颗,输出结果可以全员出动,殊死一搏
3.如果偷回的宝石数是0颗,输出结果没办法了,只能尝试呼叫惊奇队长
注意:标点符号都为英文格式
题目讲解
1.赋值:因为他们一个宝石都没偷回来,为偷来的宝石stonenumber
赋值为0。
2.用if
写第一个条件:如果偷回的宝石数是4颗及以上,输出结果:获得了打败灭霸的力量,反杀稳了
3.用elif
写第二个条件:如果偷回的宝石数是1-3颗,输出结果:可以全员出动,殊死一搏
4.用else
写第三个条件:如果偷回的宝石数是0颗,输出结果:没办法了,只能尝试呼叫惊奇队长
书写代码
请你写出一段代码,在一颗宝石都没偷回来的赋值下,进行条件判断,并产生对应的结果:
如果偷回的宝石数是4颗及以上,输出结果获得了打败灭霸的力量,反杀稳了
如果偷回的宝石数是1-3颗,输出结果可以全员出动,殊死一搏
如果偷回的宝石数是0颗,输出结果没办法了,只能尝试呼叫惊奇队长
注意:标点符号都为英文格式
参考代码
stonenumber=0
if stonenumber>=4:
print('获得了打败灭霸的力量,反杀稳了')
elif 1<=stonenumber<=3:
print('可以全员出动,殊死一搏')
else:
print('没办法了,只能尝试呼叫惊奇队长')
运行结果
没办法了,只能尝试呼叫惊奇队长
题目要求
复仇者联盟的成员也是有工资的,然而,由于美国队长一直被冰封在北极,错过了多次调薪机会,所以美国队长的工资一直是每月80美元。光荣挺进史塔克穷人榜前三名,并获封“美元队长”称号。
题目讲解
1.根据题目,我们知道这里涉及嵌套条件,所以可以用扒洋葱法梳理代码逻辑
2.可以先写最外层的if……elif……else……条件
3.根据题目的从属关系分析,最外层的if条件和else条件都有额外条件
4.依次在外层基础条件下添加额外条件
书写代码
请你写出一段代码,判断美国队长的工资每月80美元属于什么水平。
其中判断工资水平的代码需要满足如下条件:
1.如果月工资小于等于500美元,显示“欢迎进入史塔克穷人帮前三名”
1.1如果月工资在100-500美元之间,显示“请找弗瑞队长加薪”
1.2如果月工资小于等于100美元,显示“恭喜您荣获“美元队长”称号!”
2.如果月工资在500-1000美元之间(含1000美元),打印“祝贺您至少可以温饱了。”
3.其他情况下,如果工资大于1000美元,打印“经济危机都难不倒您!”
3.1如果工资在1000-20000美元(含20000美元)之间,打印“您快比钢铁侠有钱了!”
3.2如果月工资大于20000美元,打印“您是不是来自于瓦坎达国?”
参考代码
money=80
if money<=500:
print('欢迎进入史塔克穷人帮前三名')
if 100
运行结果
欢迎进入史塔克穷人帮前三名
恭喜您荣获“美元队长”称号!
input()函数是输入函数,当你在函数的括号内写出问题时,input()函数会将此问题原样显示在屏幕上,并在终端区域等待你针对此问题的回答。
input('请铲屎官输入宠物的名字:')
input()函数结果的赋值
name = input('内容')
#函数赋值
name = input('请铲屎官输入宠物的名字:')
print('I Love '+name +'!')
input()函数的数据类型
input()函数的输入值(搜集到的回答),永远会被强制性地转换为字符串类型。(Python3固定规则)
input()函数结果的强制转换
choice = int(input('请输入您的选择:'))
#将输入值强制转换为整数,并赋值给变量choice
题目要求
哈利·波特在对角巷购买宠物时犯难了,他不知道该给自己的猫头鹰起什么名字。现在请你帮助哈利·波特,为他的猫头鹰起一个名字。
题目讲解
1.搜集猫头鹰的名字(知识点:input(),赋值)
2.打印结果哈利·波特的猫头鹰叫做XX
(其中,XX是你取的名字)(知识点:数据拼接)
书写代码
请你写一段代码:
为哈利·波特的猫头鹰起个名字,并打印出结果哈利·波特的猫头鹰叫做XX
(XX是你起的名字)。
参考代码
name=input('请输入哈利·波特的猫头鹰的名字:')
print('哈利·波特的猫头鹰叫做'+name)
#测试
#请输入哈利·波特的猫头鹰的名字:2233
#哈利·波特的猫头鹰叫做2233
题目要求
为了三强争霸赛的舞会,罗恩想要减肥,所以他决定控制自己的饮食,少吃一点巧克力蛙。
哈利为了帮助好朋友罗恩,和他一起制定了一个饮食游戏。
游戏规则如下:
如果罗恩一天吃超过10个巧克力蛙,罗恩要给哈利100块;
如果罗恩一天吃小于等于10个的巧克力蛙,哈利就给罗恩100块。
题目讲解
1.搜集罗恩吃的巧克力数量
2.使用双向条件判断if…else
语句,写出游戏规则。
书写代码
请你写一段代码,并满足以下条件:
如果罗恩一天吃超过10个巧克力蛙,罗恩要给哈利100块;
如果罗恩一天吃小于等于10个的巧克力蛙,哈利就给罗恩100块。
输入罗恩吃的巧克力数量,并判断是哈利给罗恩钱,还是罗恩给哈利钱。
参考代码
number=int(input('请输入罗恩吃的巧克力数量'))
if number>10:
print('罗恩要给哈利100块')
else:
print('哈利就给罗恩100块')
#测试
#请输入罗恩吃的巧克力数量1000
#罗恩要给哈利100块
题目要求
接受了霍格沃茨来信的你,带着欣喜与好奇,跟着魔咒学老师吴枫教授,来到了巫师世界的对角巷。在这个相当于人类集市的对角巷,你立刻被魔法世界稀奇古怪的东西吸引,想掏手机刷花呗买买买。
但是吴枫教授说,麻瓜(没有魔法的人)货币在魔法世界不流通,但是你可以去巫师世界的银行——古灵阁兑换货币。你立刻跟着吴枫老师跑到了古灵阁。当你进到巫师世界的银行时,就有银行的小精灵职员问好:
注意:以下背景与题目要求相关
小精灵:您好,欢迎古灵阁,请问您需要帮助吗?需要or不需要?
你:需要
小精灵:请问您需要什么帮助呢?1 存取款;2 货币兑换;3 咨询
你:2
小精灵:金加隆和人民币的兑换率为1:51.3,即一金加隆=51.3人民币
小精灵:请问您需要兑换多少金加隆呢?
(你说了一个数字N)
小精灵:好的,我知道了,您需要兑换(你说的数字N)金加隆。
小精灵:那么,您需要付给我(你说的数字N*51.3)人民币。
注1:如果选择不需要帮助,小精灵会礼貌地说'好的,再见。'
注2: 如果选择帮助【1 存取款】,小精灵会推荐你去存取款窗口;如果选择帮助【3 咨询】,小精灵会推荐你去咨询窗口。
题目讲解
和小精灵的对话可以被这么拆分:
1.小精灵通过input()函数进行提问。
2.提问分为两个基础条件:基础条件1if
需要帮助;基础条件2else
不需要帮助。
3.在基础条件1需要帮助的情况下,又分为3个额外条件:if
1存取款;elif
2货币兑换;else
3咨询。
4.小精灵会根据你的选择,给予不同的回答。如果选择1-存取款或者3-咨询,小精灵会推荐你去对应的窗口。
5.如果选择elif
条件2-货币兑换,需要再通过input()函数提一个问题:请问您需要兑换多少金加隆呢?
6.当获得了回答后,由于1金加隆=51.3人民币,而你支付的是人民币,所以需要计算出支付的人民币数额。
7.这时,你需要使用int()
函数,将回答的数额转换为整数类型进行计算,再通过str()
函数,转换为字符串类型才能进行数据拼接,打印出小精灵说的话那么,您需要付给我(你说的数字N*51.3)人民币。
8.在基础条件2不需要帮助的情况下,小精灵会礼貌的说再见。
书写代码
请你综合四天所学知识,将下面的对话,用代码表现出来。
小精灵:您好,欢迎古灵阁,请问您需要帮助吗?需要or不需要?
你:需要
小精灵:请问您需要什么帮助呢?1 存取款;2 货币兑换;3 咨询
你:2
小精灵:金加隆和人民币的兑换率为1:51.3,即一金加隆=51.3人民币
小精灵:请问您需要兑换多少金加隆呢?
(你说了一个数字N)
小精灵:好的,我知道了,您需要兑换(你说的数字N)金加隆。
小精灵:那么,您需要付给我(你说的数字N*51.3)人民币。
注1:如果选择不需要帮助,小精灵会礼貌地说'好的,再见。'
注2: 如果选择帮助【1 存取款】,小精灵会推荐你去存取款窗口;如果选择帮助【3 咨询】,小精灵会推荐你去存取款窗
参考代码
help=input('小精灵:您好,欢迎古灵阁,请问您需要帮助吗?需要or不需要?')
if help=='需要':
number=int(input('请问您需要什么帮助呢?1 存取款;2 货币兑换;3 咨询'))
if number==1:
print('小精灵:推荐你去存取款窗口')
elif number==2:
print('小精灵:金加隆和人民币的兑换率为1:51.3,即一金加隆=51.3人民币')
N=int(input('小精灵:请问您需要兑换多少金加隆呢?'))
print('小精灵:好的,我知道了,您需要兑换'+str(N)+'金加隆。')
print('小精灵:那么,您需要付给我'+str(N*51.3)+'人民币。')
else:
print('小精灵:推荐你去咨询窗口')
else:
print('好的,再见。')
一个列表需要用中括号[ ]把里面的各种数据框起来,里面的每一个数据叫作“元素”。每个元素之间都要用英文逗号隔开。
列表很包容,各种类型的数据(整数/浮点数/字符串)无所不能包。
list1 = ['小明',18,1.70]
print(list1)
#测试
#['小明', 18, 1.7]
偏移量:列表中的各个元素,好比教室里的某排学生那样,是有序地排列的,也就是说,每个元素都有自己的位置编号(即偏移量)
1.偏移量是从0开始的,而非我们习惯的从1开始;2.列表名后加带偏移量的中括号,就能取到相应位置的元素。
students = ['小明','小红','小刚']
print(students[0])
#测试
#小明
切片:冒号左右两边的数字指的是列表中元素的偏移量
用冒号来截取列表元素的操作叫作切片,顾名思义,就是将列表的某个片段拿出来处理。这种切片的方式可以让我们从列表中取出多个元素
左右空,取到头;左要取,右不取
偏移量取到的是列表中的元素,而切片则是截取了列表的某部分,所以还是列表
list2 = [5,6,7,8,9]
print(list2[:])
print(list2[2:])
print(list2[:2])
print(list2[1:3])
print(list2[2:4])
#[5, 6, 7, 8, 9]
#[7, 8, 9]
#[5, 6]
#[6, 7]
#[7, 8]
增加语句
append()函数给列表增加元素,append的意思是附加,增补
格式是列表名.append( )
append()给列表增加元素,每次只能增加一个元素
append函数并不生成一个新列表,而是让列表末尾新增一个元素。而且,列表长度可变,理论容量无限,所以支持任意的嵌套
students = ['小明','小红','小刚']
students.append('小美')
print(students)
#test
#['小明', '小红', '小刚', '小美']
删除语句
del语句
语法是:del 列表名[元素的索引]
del语句非常方便,既能删除一个元素,也能一次删除多个元素(原理和切片类似,左取右不取)
students = ['小明','小红','小刚','小美']
del students[1]
print(students)
#test
#['小明', '小刚', '小美']
students = ['小明','小红','小刚','小美']
del students[1:3]
print(students)
#test
#['小明', '小美']
students = ['小明','小红','小刚','小美']
del students[:]
print(students)
#test
#[]
众所周知,一个老师的日常就是出卷、改卷。这次期中考呢,小明、小红、小刚分别考了95、90和90分。
假如我们还用列表来装数据的话,我们需要新创建一个列表来专门放分数,而且要保证和姓名的顺序是一致的,很麻烦。
所以类似这种名字和数值(如分数、身高、体重等)两种数据存在一一对应的情况,用第二种数据类型——“字典”(dictionary)来存储会更方便。
字典和列表有3个地方是一样的:1.有名称;2.要用=赋值;3.用逗号作为元素间的分隔符
而不一样的有两处:1.列表外层用的是中括号[ ],字典的外层是大括号{ }
2.列表中的元素是自成一体的,而字典的元素是由一个个键值对构成的,用英文冒号连接。如'小明':95,其中我们把'小明'叫键(key),95叫值(value)。
这样唯一的键和对应的值形成的组合,我们就叫做【键值对】,上述字典就有3个【键值对】:'小明':95、'小红':90、'小刚':90
如果不想口算,我们可以用len()函数来得出一个列表或者字典的长度(元素个数),括号里放列表或字典名称。
这里需要强调的是,字典中的键具备唯一性,而值可重复。也就是说字典里不能同时包含两个'小明'的键,但却可以有两个同为90的值。
students = ['小明','小红','小刚']
scores = {'小明':95,'小红':90,'小刚':90}
print(len(students))
print(len(scores))
#test
#3
#3
字典的索引,和列表通过偏移量来索引不同,字典靠的是键
和列表相似的是要用[ ],不过因为字典没有偏移量,所以在中括号中应该写键的名称,即字典名[字典的键]
scores = {'小明': 95, '小红': 90, '小刚': 90}
print(scores['小明'])
#test
#95
删除字典里键值对的代码是del语句del 字典名[键],而新增键值对要用到赋值语句字典名[键] = 值
album = {'周杰伦':'七里香','王力宏':'心中的日月'}
del album['周杰伦']
print(album)
album['周杰伦'] = '十一月的萧邦'
print(album)
print(album['周杰伦'])
#test
#{'王力宏': '心中的日月'}
#{'王力宏': '心中的日月', '周杰伦': '十一月的萧邦'}
#十一月的萧邦
列表和字典同作为Python里能存储多条数据的数据类型,有许多共同点,也有值得我们注意的不同点,那么接下来我们先来看看不同点
列表和字典的不同点
一个很重要的不同点是列表中的元素是有自己明确的“位置”的,所以即使看似相同的元素,只要在列表所处的位置不同,它们就是两个不同的列表
# 如果==左右两边相等,值为True,不相等则为False。
print(1 == 1)
# 1等于1,所以值为True
print(1 == 2)
# 1不等于2,所以为False
students1 = ['小明','小红','小刚']
students2 = ['小刚','小明','小红']
print(students1 == students2)
scores1 = {'小明':95,'小红':90,'小刚':100}
scores2 = {'小刚':100,'小明':95,'小红':90}
print(scores1 == scores2)
#test
#True
#False
#False
#True
而字典相比起来就显得随和很多,调动顺序也不影响。因为列表中的数据是有序排列的,而字典中的数据是随机排列的。
这也是为什么两者数据读取方法会不同的原因:列表有序,要用偏移量定位;字典无序,便通过唯一的键来取值。
列表和字典的相同点
我们先来看第一个共同点:在列表和字典中,如果要修改元素,都可用赋值语句来完成。看一下代码:
list1 = ['小明','小红','小刚','小美']
list1[1] = '小蓝'
print(list1)
dict1 = {'小明':'男'}
dict1['小明'] = '女'
print(dict1)
#test
#'小明', '小蓝', '小刚', '小美']
#{'小明': '女'}
所以,上面修改小刚成绩的时候,其实直接用赋值语句即可,del语句通常是用来删除确定不需要的键值对。
scores = {'小明':95,'小红':90,'小刚':90}
#del scores['小刚']
#如果只需要修改键里面的值,可不需要del语句
scores['小刚'] = 92
第二个共同点其实之前已经略有提及,即支持任意嵌套。除之前学过的数据类型外,列表可嵌套其他列表和字典,字典也可嵌套其他字典和列表。
列表嵌套列表
students = [['小明','小红','小刚','小美'],['小强','小兰','小伟','小芳']]
print(students[1][1])
#test
#小兰
字典嵌套字典
scores = {
'第一组':{'小明':95,'小红':90,'小刚':100,'小美':85},
'第二组':{'小强':99,'小兰':89,'小伟':93,'小芳':88}
}
print(scores['第二组']['小芳'])
#test
#88
列表和字典相互嵌套
# 最外层是大括号,所以是字典嵌套列表,先找到字典的键对应的列表,再判断列表中要取出元素的偏移量
students = {
'第一组':['小明','小红','小刚','小美'],
'第二组':['小强','小兰','小伟','小芳']
}
print(students['第一组'][3])
#取出'第一组'对应列表偏移量为3的元素,即'小美'
# 最外层是中括号,所以是列表嵌套字典,先判断字典是列表的第几个元素,再找出要取出的值相对应的键
scores = [
{'小明':95,'小红':90,'小刚':100,'小美':85},
{'小强':99,'小兰':89,'小伟':93,'小芳':88}
]
print(scores[1]['小强'])
#先定位到列表偏移量为1的元素,即第二个字典,再取出字典里键为'小强'对应的值,即99。
#test
#小美
#99
练习介绍
练习目标:
我们会通过今天的作业,更熟练地取出层层嵌套中的数据,并了解一种新的数据类型:元组。
练习要求:
我们知道了列表和字典的不同:列表的基本单位是元素,而字典里是键值对。所以,两者提取数据的方式也不同。
你可以通过头两个练习来验证自己已经掌握了。
而在第三道练习,你会学会提取元组里的数据。
数据提取-1
请你通过所学知识,把列表list1中的'love'取出来,并打印出来。
数据提取-2
请你通过所学知识,把字典dict1中的'love'取出来,并打印出来。
拓展知识:元组
下面,介绍一种新的数据类型:元组(tuple)。 可以看到:元组和表格很相似,不过,它是用小括号来包的。
元组和列表都是序列,提取的方式也是偏移量,如 tuple1[1]、tuple1[1:]。另外,元组也支持任意的嵌套。
请你根据以上提供的信息,将tuple1中的A和list2中的D打印出来。看到了,理解了,运用了,就能够掌握了。
参考代码
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])
# 第一步:取出字典中键为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.元组也支持互相嵌套。
练习介绍
练习目标
在层层嵌套的各种数据类型中,准确地提取出你需要的数据。
练习要求
在未来世界里,一个新建的童话镇吸引了不少人入住。
不过,在人群里隐藏着一只狼,会威胁大家的安全。
童话镇的镇长希望你能找到它,并揭发其身份。
用程序语言就是说:列表中有个字符串是“狼”,将其打印出来吧。
马上行动
请你通过所学知识,把列表中的“狼”取出来,并打印出来。
列表
townee = [
{'海底王国':['小美人鱼''海之王''小美人鱼的祖母''五位姐姐'],'上层世界':['王子','邻国公主']},
'丑小鸭','坚定的锡兵','睡美人','青蛙王子',
[{'主角':'小红帽','配角1':'外婆','配角2':'猎人'},{'反面角色':'狼'}]
]
参考代码
列表和字典都是可任意嵌套的,可以同时包容不同类型的数据(如字符串、字典、列表等)。
所以,在提取数据时,要留意每个字符串都占据了一个偏移量。
townee = [
{'海底王国':['小美人鱼''海之王''小美人鱼的祖母''五位姐姐'],'上层世界':['王子','邻国公主']},
'丑小鸭','坚定的锡兵','睡美人','青蛙王子',
[{'主角':'小红帽','配角1':'外婆','配角2':'猎人'},{'反面角色':'狼'}]
]
print(townee[5][1]['反面角色'])
#test
#狼
for i in [1,2,3,4,5]:
print(i)
#test
#1
#2
#3
#4
#5
for i in [1,2,3,4,5]: #i是变量
print(i)
为什么我总是用i?因为英文是item,所以i是常用名嘛
最后被操作的元素存在i中
字典、列表和字符串属于循环对象
整数、浮点数是不属于循环对象,如果把它们放在for循环里,代码会报错
for i in '吴承恩':
print(i)
#test
#吴
#承
#恩
使用range(x)函数,就可以生成一个从0到x-1的整数序列
使用range(a,b) 函数,你可以生成了一个【取头不取尾】的整数序列
range(a,b,c)的意思是:从a数到b(取头不取尾),数数的间隔为c
for i in range(3):
print(i)
#test
#0
#1
#2
for i in range(13,17):
print(i)
'''
test
13
14
15
16
'''
for i in range(0,10,3):
print(i)
'''
test
0
3
6
9
'''
Python多行注释:https://www.php.cn/python-tutorials-415573.html
格式是【冒号】后另起一行,【缩进】写命令
while在英文中表示“当”,while后面跟的是一个条件。当条件被满足时,就会循环执行while内部的代码(while子句)。
man = '' # 注:这个''代表空字符串
while man != '有':
man = input('有没有愿意为小龙女死的男人?没有的话就不能出古墓。')
print('小龙女可以出古墓门下山啦~')
缩进才是while子句
for循环和whlie循环最大的区别在于【循环的工作量是否确定】,for循环就像空房间依次办理业务,直到把【所有工作做完】才下班。但while循环就像哨卡放行,【满足条件就一直工作】,直到不满足条件就关闭哨卡。
所以说,当我们【工作量确定】的时候,我们就可以让for循环来完成重复性工作。反之,要【工作量不确定时】可以让while循环来工作
不过有一种情况for循环和while循环都可以解决问题,那就是【把一件事情做N遍】,不过for循环的代码相对更简洁一些
练习介绍
练习目标:
我们会通过今天的作业,再次练习for循环和while循环。
练习要求:
小美想要用今天学到的循环打印数字1-7,不过,她不喜欢4这个数字……
但是,今天的课堂她没有认真看,导致现在有点晕,不知道怎么写代码。
所以,请你运用课堂中出现的两种循环方式,为她展示下什么叫融会贯通。
这个练习呢,其实就一件事:打印数字。
在这件事的基础上加循环(控制打印范围)和条件判断(跳过4)。
下面,请你用不同的循环方式来帮小美实现“打印1-7,但是不要4”这个愿望。
for 循环
请你用for循环完成小美的愿望。
while 循环
请你用while循环完成小美的愿望。
循环对比
我们对比一下这两种循环写成的代码。
#for循环
for i in range(1,8):
if(i!=4):
print(i)
#while循环
a=1
while a<=7:
if(a!=4):
print(a)
a=a+1
练习介绍
练习目标
通过这个练习,你会尝试用循环来解决生活中的问题,并了解一种新的列表方法。
练习要求
小明、小红、小刚是同班同学,且坐在同一排,分别坐在第一位、第二位、第三位。
由于他们的身高都差不多,所以,老师计划让他们三个轮流坐在第一位。
每次换座位的时候,第一位变第三位,后面两位都往前一位。
方法1:append()函数
可结合循环和append()函数,让列表发生3次变化,每次都打印出来,如下:
students = ['小明','小红','小刚']
students = ['小红','小刚','小明']
students = ['小刚','小明','小红']
方法1-参考代码
参考代码中用的是 for循环,当然,while循环 也是可以的。
感兴趣的同学,可以两者都试试,然后对比一二。
方法2:pop()函数
我们先介绍一下列表中的pop()函数,用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值。
可以将其理解为提取和删除的融合:①提取:取到元素,对列表没有影响;②删除:删除列表的元素。
而移除,则是同时做到取到元素,并且删除列表中的元素。
方法2-参考代码
相信你已经用了新学的方法完成了代码。可以发现:代码从6行减为5行,虽然仅仅1行代码的差别,还不能很好地体现“简化”代码的思想,但这是一种必备的编程思维。
当你发现要实现某功能要用较多代码实现,最先做的不是埋头打代码,而是找找是否有更好、更简洁的解决方法。
#要求打印
#students = ['小明','小红','小刚']
#students = ['小红','小刚','小明']
#students = ['小刚','小明','小红']
#方法一:append()
#for循环
students = ['小明','小红','小刚']
print(students)
for i in range(2):
students.append(students[0])
del students[0]
print(students)
#while循环
students2 = ['小明','小红','小刚']
count=0
while count<3:
print(students2)
students2.append(students2[0])
del students2[0]
count+=1
#方法二:pop()
#for循环
students3 = ['小明','小红','小刚']
print(students3)
for i in range(2):
name=students3.pop(0)
students3.append(name)
print(students3)
#while循环
students4 = ['小明','小红','小刚']
count2=1
while count2<=3:
print(students4)
name=students4.pop(0)
students4.append(name)
count2+=1
计算机利用数据有三种方式:1.直接使用数据,2.计算和加工数据,3.用数据做判断
【布尔值】True和False
代码将会无限运行,陷入【死循环】,你需要在键盘上按几次【ctrl+c】来强制结束运行
None,它代表的是【空值】,自成一派,数据类型是NoneType。要注意它和0的区别,0是整数0,可并非什么都没有
bool()函数:查看一个数据会被判断为真还是假
print('以下数据判断结果都是【假】:')
print(bool(False))
print(bool(0))
print(bool(''))
print(bool(None))
print('以下数据判断结果都是【真】:')
print(bool(True))
print(bool(1))
print(bool('abc'))
'''
以下数据判断结果都是【假】:
False
False
False
False
以下数据判断结果都是【真】:
True
True
True
'''
and、or、not、in、not in五种运算
a = 1
b = -1
print('以下是and运算')
if a==1 and b==1: # 【b实际上是-1】
print('True')
else:
print('False')
print('以下是or运算')
if a==1 or b==1: # 【b实际上是-1】
print('True')
else:
print('False')
list = [1,2,3,4,5]
a = 1
# 做一次布尔运算,判断“a是否在列表list之中”
print(bool(a in list))
print(bool(a not in list))
#运行结果会是什么你应该很清楚啦,看看就好~
dict = {'法国':'巴黎','日本':'东京','中国':'北京'}
a = '法国'
print(bool(a in dict))
'''
以下是and运算
False
以下是or运算
True
True
False
True
'''
这4种新语句配合for循环和while循环,可以让循环发挥更多的功能。我们逐个来看
我们先来看看break语句。break的意思是“打破”,是用来结束循环的,一般写作if...break。它的写法长这样
# break语句搭配for循环
for...in...:
...
if ...:
break
# break语句搭配while循环
while...(条件):
...
if ...:
break
在这里,if...break的意思是如果满足了某一个条件,就提前结束循环。记住,这个只能在循环内部使用。
小小地提醒你,break前面一共缩进了【8个空格】。
这是因为if之下的语句要缩进4个空格(按一次Tab键),这里的if...break又嵌套在while或for循环中,而循环语句本身又要缩进4个空格。这样一来,break就缩进了【4+4=8】个空格(按两次Tab键)。【注】:Tab键和空格键不能同时混用。
continue的意思是“继续”。这个子句也是在循环内部使用的。当某个条件被满足的时候,触发continue语句,将跳过之后的代码,直接回到循环的开始
# continue语句搭配for循环
for...in...:
...
if ...:
continue
...
# continue语句搭配while循环
while...(条件):
...
if ...:
continue
...
pass语句就非常简单了,它的英文意思是“跳过”
a = int(input('请输入一个整数:'))
if a >= 100:
pass
else:
print('你输入了一个小于100的数字')
这个代码的意思是:当a>=100的时候,跳过,什么都不做。其他情况,也就是a<100的时候,执行一个print语句。
如果没有pass来占据一个位置表示“什么都不做”,以上的代码执行起来会报错
最后一种else语句,我们在条件判断语句见过【else】,其实,else不但可以和if配合使用,它还能跟for循环和while循环配合使用
for:当循环中没有碰到break语句,就会执行循环后面的else语句,否则就不会执行
for i in range(5):
a = int(input('请输入0来结束循环,你有5次机会:'))
if a == 0:
print('你触发了break语句,循环结束,导致else语句不会生效。')
break
else:
print('5次循环你都错过了,else语句生效了。')
在while循环中,else的用法也是如此,格式一模一样
while...(条件):
...
else:
...
i = 0
while i<5:
a = int(input('请输入0结束循环,你有5次机会:'))
i = i+1
if a == 0:
print('你触发了break语句,导致else语句不会生效。')
break
else:
print('5次循环你都错过了,else语句生效了。')
大家应该玩过一个小游戏,就是一个人在心里想好一个数,比如24,然后让另一个人猜。如果他猜的数比24小,告诉他“太小了”,如果他猜的数比24大,告诉他“太大了”。
我们一起来完成这个“猜大小游戏”的编程,我的思路大概是这样的:
1.一个人在心里想好一个数————所以这个数字是提前准备好的,所以可以设置一个变量来保存这个数字。我就设置我的数字为24。
2.然后让另一个人猜————所以可以使用input()函数来接收另一个人输入的数字,并用int()转化为整数。
3.直到猜对为止————天知道几次才能猜对,所以肯定需要用到循环,并且由于不知道要循环几次,所以适合while循环。
4.如果他猜的数比24小就告诉他“太小了”,如果他猜的数比24大就告诉他“太大了”——这里一看“如果……就……”的描述,就知道应该用if...else...写一个条件判断。
secret = 24 #设定秘密数字
while True:
guess = input('你来猜猜我的秘密数字是多少:') #输入猜测数字
if int(guess)==secret: #数字对比
print('正确!你很棒哦。')
break
elif int(guess)>secret:
print('你猜的太大了,请重新猜猜~')
else:
print('你猜的太小了,请重新猜猜~')
练习介绍
练习目标:
我们会通过今天的作业,综合运用while True循环和 break。
练习要求:
假设有两名囚徒A和B因为合伙犯罪被抓捕,因没有确凿可以指认罪行的证据,审判者准备单独审判两位囚徒。
若两人都认罪,则两人各判10年;若一个认罪一个抵赖,则认罪的人判1年,抵赖的人判20年;若两人都抵赖,则各判3年。
现在,请写个代码:当两人都抵赖时,打印判决,代码结束;若为其他结果,则在打印判决后继续循环。
1.开启循环,两人分别选择
首先,我们需要知道两个囚徒各自的选择。
2.循环当中,有判断和跳出
判决提示:
若两人都认罪,则两人各判10年;
若一个认罪一个抵赖,则认罪的人判1年,抵赖的人判20年;
若两人都抵赖,则各判3年——这种情况下跳出循环。
参考答案
请查看参考答案,并留意 break 的位置。
感兴趣的话,也可想一想 break 放在其他地方会怎么样
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 # 当满足开头提到的条件时,跳出循环。
练习介绍
练习目标
这个作业会建立在上一个练习的基础上,完善代码的功能。
练习要求
上一个练习,我们将“囚徒困境”写成了代码,让程序收集两名囚犯的认罪情况,进而决定他们的判决:
两人都认罪,则各判10年;一个认罪一个抵赖,则前者判1年,后者判20年;两人都抵赖,各判3年。只有两人都不认罪,程序才会停止。
现在有一个社会学家,在不同的人群中做这个实验,一旦遇到都不认罪的情况,就停止该人群中的实验。
同时,他希望程序能记录每一对实验者的选择,以及记录第几对实验者都选择不认罪。请你帮帮他吧。
完善代码
几个提示:
为了记录每一对实验者的选择,需要用一个可拓展的“容器”来存放这些数据;
为了记录是第几对实验者做了最优选择,需要用一个变量来计数;
为了将每一对实验者的选择再打印出来,需要写一个循环。
参考代码
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]))
'''
A,你认罪吗?请回答认罪或者不认:认罪
B,你认罪吗?请回答认罪或者不认:认罪
两人都得判10年,唉
A,你认罪吗?请回答认罪或者不认:认罪
B,你认罪吗?请回答认罪或者不认:不认
A判1年,B判20年
A,你认罪吗?请回答认罪或者不认:不认
B,你认罪吗?请回答认罪或者不认:不认
都判3年,太棒了
第3对实验者选了最优解。
第1对实验者的选择是:['认罪', '认罪']
第2对实验者的选择是:['认罪', '不认']
第3对实验者的选择是:['不认', '不认']
Press any key to continue . . .
'''
练习介绍
练习目标
通过这个练习,你会学会综合使用循环、数据提取和条件判断。
练习要求
我很喜欢看电影,我回忆了一下,这两年我觉得还不错的国产电影。
下面,会将电影的影片名和主演放在字典里,如movie = {'妖猫传':['黄轩','染谷将太']}
。
需要你补充一些代码,让其他人只要输入演员名,就打印出:××出演了电影××。
movies = {
'妖猫传':['黄轩','染谷将太'],
'无问西东':['章子怡','王力宏','祖峰'],
'超时空同居':['雷佳音','佟丽娅'],
}
动手写代码
补充代码,让代码运行时输入演员的名字时,可以打印出:××出演了电影××。
注:这个练习的提示比较完整,建议先多尝试几次独立完成。
参考代码
看下参考代码(留意一下变量名的取法)。
movies = {
'妖猫传':['黄轩','染谷将太'],
'无问西东':['章子怡','王力宏','祖峰'],
'超时空同居':['雷佳音','佟丽娅'],
}
actor=input('请问你想查询哪位演员:>')
for movie in movies:# 用 for 遍历字典
actors=movies[movie]# 用 for 遍历字典
if actor in actors:
print(actor + '出演了电影' + movie)
通过实战去成长,这体现在:能在学习初期就知道什么是关键知识,了解专业程序员一般是怎么思考和解决问题的,在一遍遍分析问题、拆解问题及解决问题的过程中真正地理解知识,并用这些知识来解决自己的问题。
一个项目一般是怎么完成的。更具体的说,程序员是如何思考和解决问题的呢?
我认为其中一个很重要的能力是【问题拆解】。问题拆解,指的是在做一件事或面对一个问题的时候,将其拆解成多个步骤或多个层次,逐步执行和解决问题,直至达到最终效果。
不过可能是出于长期编写代码的习惯,程序员会将问题拆得更细致一些,即拆到无法再拆为止
将完成一个项目的流程总结为以下三步
1.明确项目目标
2.分析过程,拆解项目
3.逐步执行,代码实现
在互联网公司,一般情况下是由产品经理提出明确的项目需求,由程序员来实现,他们之间是“相爱相杀”的关系。:)
今天且让我扮演一下产品经理的角色。我们此次要实现的需求是:人机PK小游戏。具体效果请参照下面的示意动图。
简单来说,这个游戏中,会随机生成玩家和敌人的属性,同时互相攻击,直至一方血量小于零。
另外,这样的战斗会持续三局,采取三局两胜制,最后输出战斗结果,公布获胜方。
“功能叠加、难度递增”这个角度考虑,将我们要实现的小游戏拆分成了三个版本
各版本程序功能描述
当项目被清晰地拆解后,剩下的就是去逐步执行,也就是重复“执行→遇到问题→解决问题→继续执行”这个循环的过程。
我们要做的主要有三步:1.规定并显示出玩家和敌人的属性 2.双方同时互相攻击,血量根据对方的攻击力扣除 3.若有一方血量小于等于0,游戏结束。
好,我们从第1步开始:设定【玩家】和【敌人】的属性,即【血量】和【攻击】。
print('【玩家】血量:100 攻击:50') # 自定义玩家角色的血量和攻击
print('【敌人】血量:100 攻击:30') # 自定义敌人角色的血量和攻击
第2步:手动计算攻击一次,双方各自所剩的血量。
print('你发起了攻击,【敌人】剩余血量50') # 人工计算敌人血量:100-50=50
print('敌人向你发起了攻击,【玩家】剩余血量70') # 人工计算玩家血量:100-30=70
第3步:继续做人工计算:算一算,玩家攻击2次敌人,敌人的血量就等于0了,这时候可以结束战斗,打印游戏结果。
print('你发起了攻击,【敌人】剩余血量0') # 双方同时攻击,若血量出现小于等于0,游戏结束
print('敌人向你发起了攻击,【玩家】剩余血量40')
print('敌人死翘翘了,你赢了!') # 打印结果
很简单吧!现在我们要做的,就是把这三段代码拼起来,然后我会加一些修饰视觉的换行符和分割线,让运行结果看得更清楚一点。
print('【玩家】\n血量:100\n攻击:50') # 自定义玩家角色的血量和攻击,用换行符'\n'来优化视觉
print('------------------------') # 辅助功能,起到视觉分割的作用,让代码的运行结果更清晰
print('【敌人】\n血量:100\n攻击:30')
print('------------------------')
print('你发起了攻击,【敌人】剩余血量50') # 人工计算敌人血量:100-50=50
print('敌人向你发起了攻击,【玩家】剩余血量70') # 人工计算玩家血量:100-30=70
print('------------------------')
print('你发起了攻击,【敌人】剩余血量0') # 双方同时攻击,若血量出现小于等于0,游戏结束
print('敌人向你发起了攻击,【玩家】剩余血量40')
print('-----------------------')
print('敌人死翘翘了,你赢了!') # 打印结果
结果
【玩家】
血量:100
攻击:50
------------------------
【敌人】
血量:100
攻击:30
------------------------
你发起了攻击,【敌人】剩余血量50
敌人向你发起了攻击,【玩家】剩余血量70
------------------------
你发起了攻击,【敌人】剩余血量0
敌人向你发起了攻击,【玩家】剩余血量40
-----------------------
敌人死翘翘了,你赢了!
唔...虽然看起来还有点儿意思,但所有信息一下子都蹦跶出来,一点都没有体现游戏的进程感。
所以,为了让打印出的东西能有时间间隔地依次出现,我们需要设置一个类似“计时器”的东西。在Python里,我们需要用到两行代码来实现:(敲黑板,很简单的新知识)
import time #调用time模块
time.sleep(secs)
#使用time模块下面的sleep()函数,括号里填的是间隔的秒数(seconds,简称secs)
#time.sleep(1.5)就表示停留1.5秒再运行后续代码
这里有个新名词——模块,它是Python里一个重要的概念
你可以把模块想象成是一个装着许多神奇函数的百宝箱,不过想要使用这个百宝箱里的函数,得先用 import 模块名 这样一句代码来打开它。
然后这里我们想使用time模块里的sleep()函数,也就是让代码运行结果不要一次性全部出现,而是分批分批的出现。就要写成time.sleep(secs)的形式。
如果我想设置成打印的信息间隔1.5秒出现,代码就可以这么写:
import time #通常import语句会写到代码的开头
print('【玩家】\n血量:100\n攻击:50')
print('------------------------')
time.sleep(1.5)
#暂停1.5秒,再继续运行后面的代码
print('【敌人】\n血量:100\n攻击:30')
print('------------------------')
time.sleep(1.5)
#同上
print('你发起了攻击,【敌人】剩余血量50')
print('敌人向你发起了攻击,【玩家】剩余血量70')
print('------------------------')
time.sleep(1.5)
print('你发起了攻击,【敌人】剩余血量0')
print('敌人向你发起了攻击,【玩家】剩余血量40')
print('-----------------------')
time.sleep(1.5)
print('敌人死翘翘了,你赢了!')
这个版本的代码还有两个明显的缺陷:一是玩家和敌人的属性(血量&攻击)是我自己说了算,那胜负早已没有悬念;二是战斗过程中血量的变化要自己手动算,那要计算机有何用?
你放心,这些都是我们会在版本2.0解决的问题。
如前所述,这个阶段,我们主要新增【随机属性】和【自动战斗】两个功能,画成流程图是这样子的:
版本2.0流程图
Python 随机生成数字
import random
#调用random模块
a = random.randint(1,100)
# 随机生成1-100范围内(含1和100)的一个整数,并赋值给变量a
print(a)
方法步骤
1.定义两个变量,来存储玩家血量和玩家攻击力的数值
2.血量是100-150的随机数,攻击力是30-50的随机数
3.将两个变量打印出来
import random
player_life = random.randint(100,150)
#表示玩家血量
player_attack = random.randint(30,50)
#表示玩家攻击
print(player_life)
print(player_attack)
标准的变量名最好是用英文来表达含义,如果是多个单词组成,需要用英文下划线_来隔开。
对于取英文变量名,很多英语水平在高考即巅峰的同学会感到头疼,这里我推荐大家一个网站:CODELF(https://unbug.github.io/codelf),输入中文就可以看到别人是怎么命名的。
好,我们已经知道如何生成随机属性,下面我们就要将属性展示打印出来,请阅读下列代码,弄懂每一行的含义:
import time
import random
#也可合并写成一行:import time,random
# 生成随机属性
player_life = random.randint(100,150) # “player_life” 代表玩家血量
player_attack = random.randint(30,50) # “player_attack” 代表玩家攻击
enemy_life = random.randint(100,150) # “enemy_life” 代表敌人血量
enemy_attack = random.randint(30,50) # “enemy_attack” 代表敌人攻击
# 展示双方角色的属性
print('【玩家】\n'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
#player_life和player_attack的数据类型都是整数,所以拼接时需要先用str()转换
print('------------------------')
time.sleep(1)
#暂停一秒再执行后续代码
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
print('------------------------')
那截至目前,我们已经完成了随机生成属性和展示属性,接下来我们就来实现"自动战斗"。
因为现在双方的血量和攻击是随机生成,不是固定的。所以我们不知道具体要战斗多少回合才能分出胜负,也就是循环次数不明确,那自然要用while循环。
while (player_life >= 0) and (enemy_life >= 0):
#and两边的条件分别用括号括起,是一种习惯,方便阅读
现在我们确定了执行while循环的条件,接下来就是要填充循环内部的内容。
根据刚才的分析,我们希望循环的内容是双方互相攻击,掉血的过程。
print('你发起了攻击,【敌人】剩余血量xxx')
print('敌人向你发起了攻击,【玩家】剩余血量xxx')
print('------------------------')
其中【敌人】剩余血量=敌人当前血量-玩家攻击,【玩家】剩余血量=玩家当前血量-敌人攻击。
事实上我们之前已经定义好了这四个变量,每一次互相伤害后,player_life(玩家血量)和enemy_life(敌人血量)都会被重新赋值,所以转换为代码逻辑就是:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
#赋值语句的执行顺序是先计算等号右边,再赋值给左边的变量
好,自动攻击的基础逻辑也已经理清楚了。我们先合并一下这之前写过的代码。
import time,random
# 生成随机属性
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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
#player_life和player_attack都是整数类型,所以拼接时需要先用str()转换
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(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
补充完成while循环语句,让双方自动战斗、扣血的过程循环起来
import time,random
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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(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('你发起了攻击,【玩家】剩余血量'+str(player_life))
#player_life是整数,所以拼接时要先用str()转换
print('敌人向你发起了攻击,【敌人】剩余血量'+str(enemy_life))
print('------------------------')
time.sleep(1.5)
# 为了体现出战斗回合,这里停顿1.5秒
打印出每局结果,三局两胜,并打印最终战果的功能。这就是我们在版本3.0要增加的功能
对比版本2.0,在版本3.0中,我们想要增加的功能是:
1.打印战果:每局战斗后,根据胜负平的结果打印出不同的提示;
2.三局两胜:双方战斗三局,胜率高的为最终赢家。
反复解释新增功能,是因为这样不断地明确项目的阶段性目标,可以让自己持续专注地推进项目。
import time,random
# 生成双方角色,并生成随机属性。
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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击,【玩家】剩余血量'+str(player_life))
print('敌人向你发起了攻击,【敌人】剩余血量'+str(enemy_life))
print('-----------------------')
time.sleep(1.5)
# 打印战果
if player_life > 0 and enemy_life <= 0:
print('敌人死翘翘了,你赢了')
elif player_life <= 0 and enemy_life > 0:
print('悲催,敌人把你干掉了!')
else:
print('哎呀,你和敌人同归于尽了!')
可以将其拆分成两个部分:先来个三局,再判断最终胜负。
首先我们来看,三局战斗也是一个可以循环的结构,且循环次数是固定的,所以要用到for循环。
在这里我们可以使用for i in range( )的结构,我们先来回顾一下之前学过的range()函数:
range(a,b,c)
a:计数从a开始。不填时,默认从0开始例如, range(1,5),表示从1开始生成
b:计数到b 结束,但不包括b例如, range(11),表示从0开始到11结束,不包括11
c:计数的间隔,不填时默认为1例如, range(0,30,5),表示计数的间隔5
尝试把代码打出来吧,让战斗循环三局。(先不用统计最后的结果)
给两个提示:1.想清楚哪些代码要嵌套到for循环里,即一局战斗里包括什么信息。确定了for写在哪里之后,一句战斗包含的所有信息都要缩进;
2.细节也需要留意,如局与局之间要怎么区分开来(时间间隔&打印局数信息)
之后计算胜场数
player_victory = 0
enemy_victory = 0
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('哎呀,你和敌人同归于尽了!')
最终代码
import time,random
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(2) # 让局与局之间有较明显的有时间间隔
print(' \n——————现在是第'+str(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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击,【玩家】剩余血量'+str(player_life))
print('敌人向你发起了攻击,【敌人】剩余血量'+str(enemy_life))
print('-----------------------')
time.sleep(1.5)
#打印最终战果
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('【最终结果:你赢了!】')
elif enemy_victory > player_victory:
print('【最终结果:你输了!】')
else:
print('【最终结果:平局!】')
print('【玩家】\n'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
我们在用+拼接字符串和变量的时候,常常需要考虑变量是什么类型的数据,如果不是字符串类型,还先需要str()函数转换。
并且一句话常常要拼接成好几个部分,然后我们要考虑每一对引号' '的起始位置,好麻烦,相信你多少会有点体会。
所以,为了更方便地实现不同数据类型的拼接,用【格式符%】是更常用更便利的一种方式
我们可以把%想象成:图书馆里用来占位的一本书。先占一个位置,之后再填上实际的变量。举个例子:下面这两种写法是相同的,请你着重研究下第二行的语法。
print('血量:'+str(player_life)+' 攻击:'+str(player_attack))
print('血量:%s 攻击:%s' % (player_life,player_attack))
我们看到格式符%后面有一个字母s,这是一个类型码,用来控制数据显示的类型。%s就表示先占一个字符串类型的位置。
常见的类型码
%d 整数
%f 浮点数
%s 字符串
修改过后的代码
import time
import random
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(1.5)
print(' \n——————现在是第 %s 局——————' % i)
#对比之前:(' \n——————现在是第'+str(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【最终结果:平局!】')
练习介绍
练习目标:
我们会在项目1代码的基础上,添加一个新功能,同时练习循环和判断的知识。
练习要求:
新功能是:每盘(3局)游戏结束后,游戏会问我们是否要继续游戏,再加一盘。
我们可以选择再来一盘,也可以选择退出游戏。
进一步拆解和分析
看右侧的讲解:
方案1:while True+break
开启一个无限循环,设定跳出条件。
方案2:while 变量名+变量名的布尔值判断
在开头设某变量的布尔值为True,input后开启判断变量的布尔值是否改变。
两种方案-参考代码
看一看你写的代码是否和参考代码差不多。
升级项目1
请你选用上面方案中的一种,为项目1增加“再来一局”的功能。
升级项目1-参考代码
参考代码用了方案1。当然,方案2也是可以的——只要成功添加了新功能。
项目一代码
import time,random
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(2) # 让局与局之间有较明显的有时间间隔
print(' \n——————现在是第'+str(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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击,【玩家】剩余血量'+str(player_life))
print('敌人向你发起了攻击,【敌人】剩余血量'+str(enemy_life))
print('-----------------------')
time.sleep(1.5)
#打印最终战果
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('【最终结果:你赢了!】')
elif enemy_victory > player_victory:
print('【最终结果:你输了!】')
else:
print('【最终结果:平局!】')
方案1:while True+break参考代码
import time,random
while True:
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(2) # 让局与局之间有较明显的有时间间隔
print(' \n——————现在是第'+str(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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击,【玩家】剩余血量'+str(player_life))
print('敌人向你发起了攻击,【敌人】剩余血量'+str(enemy_life))
print('-----------------------')
time.sleep(1.5)
#打印最终战果
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('【最终结果:你赢了!】')
elif enemy_victory > player_victory:
print('【最终结果:你输了!】')
else:
print('【最终结果:平局!】')
res=input('是否要继续游戏:>')
if(res=='否'):
break
else:
print('再加一盘')
方案2:while 变量名+变量名的布尔值判断——参考代码
import time,random
res=True
while res:
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(2) # 让局与局之间有较明显的有时间间隔
print(' \n——————现在是第'+str(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'+'血量:'+str(player_life)+'\n攻击:'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量:'+str(enemy_life)+'\n攻击:'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击,【玩家】剩余血量'+str(player_life))
print('敌人向你发起了攻击,【敌人】剩余血量'+str(enemy_life))
print('-----------------------')
time.sleep(1.5)
#打印最终战果
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('【最终结果:你赢了!】')
elif enemy_victory > player_victory:
print('【最终结果:你输了!】')
else:
print('【最终结果:平局!】')
res=input('是否要继续游戏(True\False):>')
练习介绍
练习目标
在这个练习,我们会学会一种新的“格式化字符串”的方法:format()函数。
在项目1的末尾,我们学会了一种简化代码的方式:格式化字符串。
不过,还有一种更强大的方法,下面我们会先学习,然后再练习。
学习format()函数
format()函数是从 Python2.6 起新增的一种格式化字符串的函数,功能比课堂上提到的方式更强大。
format()函数用来占位的是大括号{},不用区分类型码(%+类型码)。
具体的语法是:'str.format()',而不是课堂上提到的'str % ()'。
而且,它对后面数据的引用更灵活,不限次数,也可指定对应关系。
看完左侧的代码、结果和注释,你就懂上面几句话的意思了。
运用format()函数
将代码中字符串格式化的代码改成format()函数的方法,改完后运行一下,检验是否正确。
参考代码
一共有5行代码需要改,你都找到了吗?
对了,format()在数字格式化的方面提供了很多种选择,有兴趣的可以查一下。
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))