Python_从零开始-同步学习进度

目录

 

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

---

1.0-Python初识

安装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全栈开发、算法工程师等方向继续深造

在编程界，有一句话非常出名，叫“Talk is cheap, show me the code.”——空谈无益，秀代码

 

print()函数

代码-结果-解析

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.尽量描述包含的数据内容。

 

 

作业1

题目要求

除了文字和数字之外，我们还可以灵活运用print()函数，打印出带特殊格式的东西，例如：字符画。现在，请试着打印出一只属于自己的“皮卡丘”，成功打印后，请把你的皮卡丘分享到社群里吧。

题目讲解

1.复制题目要求打印的“皮卡丘”（皮卡丘字符画会在【书写代码】步骤里直接提供）
2.用print(''' ''')打印
注意：标点符号都要用英文

书写代码

请你使用print()函数将下面的皮卡丘打印出来。皮卡丘字符画可以直接复制下面的。

    へ　　　　　／|
　　/＼7　　　 ∠＿/
　 /　│　　 ／　／
　│　Z ＿,＜　／　　 /`ヽ
　│　　　　　ヽ　　 /　　〉
　 Y　　　　　`　 /　　/
　ｲ●　､　●　　⊂⊃〈　　/
　()　 へ　　　　|　＼〈
　　>ｰ ､_　 ィ　 │ ／／
　 / へ　　 /　ﾉ＜| ＼＼
　 ヽ_ﾉ　　(_／　 │／／

 代码参考

print('''     へ　　　　　／|
　　/＼7　　　 ∠＿/
　 /　│　　 ／　／
　│　Z ＿,＜　／　　 /`ヽ
　│　　　　　ヽ　　 /　　〉
　 Y　　　　　`　 /　　/
　ｲ●　､　●　　⊂⊃〈　　/
　()　 へ　　　　|　＼〈
　　>ｰ ､_　 ィ　 │ ／／
　 / へ　　 /　ﾉ＜| ＼＼
　 ヽ_ﾉ　　(_／　 │／／''')

结果

     へ　　　　　／|
　　/＼7　　　 ∠＿/
　 /　│　　 ／　／
　│　Z ＿,＜　／　　 /`ヽ
　│　　　　　ヽ　　 /　　〉
　 Y　　　　　`　 /　　/
　ｲ●　､　●　　⊂⊃〈　　/
　()　 へ　　　　|　＼〈
　　>ｰ ､_　 ィ　 │ ／／
　 / へ　　 /　ﾉ＜| ＼＼
　 ヽ_ﾉ　　(_／　 │／／
Press any key to continue . . .

 

 

作业2

• 题目要求

  请将无脸男对千寻说的话，按照正确的格式打印出来。

• 题目讲解

  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称号
#解析：加号可实现字符串与字符串拼接

type()函数：查询数据类型

Python中一个已有的，既简单又实用的type()函数，来帮助我们查询不确定数据的类型

查询数据类型：type(变量名)

查询数据类型并打印：print(type(变量名))

代码-结果-解析

hero = '亚瑟' 
number = 5
type(hero)
type(number)
print(type(hero))
print(type(number))
#
#

数据转换

负责转换数据类型的函数一共有3种：str()、 int()和float()

• str():将其他数据类型转成字符串，

注意：也可用引号转换

• int():将其他数据类型转成整数，

注意:

1.文字类和小数类字符串，无法转化成整数
2.浮点数转化成整数:抹零取整

• float():将其他数据类型转成浮点数

注意:文字类字符串无法转成浮点数

代码-结果-解析

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

作业1

我想使用以下变量，输出这样一个结果人工智障说：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

解析

字符串转浮点型后与数字相加，后将浮点型结果转为整形后转为字符串后进行数据拼接

 

作业2

• 题目要求

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

• 题目讲解

  1.将非字符串型变量转换为字符串类型
  2.将字符串型变量拼接在一起
  3.使用print()函数打印拼接结果

• 书写代码

  请复制粘贴下方变量，并使用str()函数转换，打印出两句话：

  第一句话：1人我编程累碎掉的节操满地堆
  第二句话：2眼是bug相随我只求今日能早归

  变量：

• number1 = 1
• number2 = 2
• unit1 = '人'
• unit2 = '眼'
• line1 = '我编程累'
• line2 = '是bug相随'
• sentence1 = '碎掉的节操满地堆'

• 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相随我只求今日能早归

 

作业3

• 题目要求

  请运用所给变量，使用数据转换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都没有

解析

字符串转浮点型，后将浮点型结果转为整形后转为字符串后进行数据拼接

条件判断

单向判断：if

代码-结果-解析

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老大的命令了

双向判断：if…else…

如果…不满足，就…
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下的命令

多向判断：if…elif…else…

 代码-结果-解析

stonenumber=5
#为宝石数量赋值
if stonenumber>=6:
    #条件：如果你拥有的宝石数量大于等于6个
    print('你拥有了毁灭宇宙的力量')
    #结果：显示‘就拥有了毁灭宇宙的力量’的结果
elif 3

• 整个条件判断的大前提会按照从上到下的顺序挨个试一遍，看满足哪个条件，满足了就不往下走，不满足就继续试，试到出结果为止
• elif的运行本质上和else一样，都需要一个和elif平级的前提，但是这个前提只能是if
• elif已经带有其他条件的意思，所以elif后也可以不接else

 

if嵌套

 

如何写嵌套代码

扒洋葱大法

第一步就是：我们要搞定最外层那张皮，将最基础的命令和条件写出来。

第二步，在“第一层皮”里增加额外条件。

最后一步，你要为另一个大条件else增加额外条件了！

 

作业1

• 题目要求

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

  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('没办法了，只能尝试呼叫惊奇队长')

运行结果

没办法了，只能尝试呼叫惊奇队长

作业2

• 题目要求

  复仇者联盟的成员也是有工资的，然而，由于美国队长一直被冰封在北极，错过了多次调薪机会，所以美国队长的工资一直是每月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('请铲屎官输入宠物的名字：')

input()函数结果的赋值

name = input('内容')
#函数赋值

name = input('请铲屎官输入宠物的名字：')
print('I Love '+name +'!')

input()函数的数据类型

input()函数的输入值（搜集到的回答），永远会被强制性地转换为字符串类型。（Python3固定规则）

input()函数结果的强制转换

choice = int(input('请输入您的选择：'))
#将输入值强制转换为整数，并赋值给变量choice

作业1

• 题目要求

  哈利·波特在对角巷购买宠物时犯难了，他不知道该给自己的猫头鹰起什么名字。现在请你帮助哈利·波特，为他的猫头鹰起一个名字。

• 题目讲解

  1.搜集猫头鹰的名字（知识点：input(),赋值）
  2.打印结果哈利·波特的猫头鹰叫做XX（其中，XX是你取的名字）（知识点：数据拼接）

• 书写代码

  请你写一段代码：
  为哈利·波特的猫头鹰起个名字，并打印出结果哈利·波特的猫头鹰叫做XX（XX是你起的名字）。

参考代码

name=input('请输入哈利·波特的猫头鹰的名字：')
print('哈利·波特的猫头鹰叫做'+name)

#测试
#请输入哈利·波特的猫头鹰的名字：2233
#哈利·波特的猫头鹰叫做2233

作业2

• 题目要求

  为了三强争霸赛的舞会，罗恩想要减肥，所以他决定控制自己的饮食，少吃一点巧克力蛙。
  哈利为了帮助好朋友罗恩，和他一起制定了一个饮食游戏。
  游戏规则如下：
  如果罗恩一天吃超过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块

作业3

• 题目要求

  接受了霍格沃茨来信的你，带着欣喜与好奇，跟着魔咒学老师吴枫教授，来到了巫师世界的对角巷。在这个相当于人类集市的对角巷，你立刻被魔法世界稀奇古怪的东西吸引，想掏手机刷花呗买买买。
  但是吴枫教授说，麻瓜（没有魔法的人）货币在魔法世界不流通，但是你可以去巫师世界的银行——古灵阁兑换货币。你立刻跟着吴枫老师跑到了古灵阁。当你进到巫师世界的银行时，就有银行的小精灵职员问好：

  注意：以下背景与题目要求相关
  小精灵：您好，欢迎古灵阁，请问您需要帮助吗？需要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个额外条件：if1存取款；elif2货币兑换；else3咨询。
  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

• 练习介绍

  练习目标：

  我们会通过今天的作业，更熟练地取出层层嵌套中的数据，并了解一种新的数据类型：元组。

  练习要求：

  我们知道了列表和字典的不同：列表的基本单位是元素，而字典里是键值对。所以，两者提取数据的方式也不同。
  你可以通过头两个练习来验证自己已经掌握了。
  而在第三道练习，你会学会提取元组里的数据。

• 数据提取-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.元组也支持互相嵌套。

作业2

• 练习介绍

  练习目标

  在层层嵌套的各种数据类型中，准确地提取出你需要的数据。

  练习要求

  在未来世界里，一个新建的童话镇吸引了不少人入住。
  不过，在人群里隐藏着一只狼，会威胁大家的安全。
  童话镇的镇长希望你能找到它，并揭发其身份。
  用程序语言就是说：列表中有个字符串是“狼”，将其打印出来吧。

• 马上行动

  请你通过所学知识，把列表中的“狼”取出来，并打印出来。

• 列表

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

   

• 参考代码

  列表和字典都是可任意嵌套的，可以同时包容不同类型的数据（如字符串、字典、列表等）。
  所以，在提取数据时，要留意每个字符串都占据了一个偏移量。

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

#test
#狼

循环

for...in...循环语句

for i in [1,2,3,4,5]:
     print(i)

#test
#1
#2
#3
#4
#5

for循环：变量

for i in [1,2,3,4,5]:  #i是变量
   print(i)

为什么我总是用i？因为英文是item，所以i是常用名嘛

最后被操作的元素存在i中

for循环：循环对象

字典、列表和字符串属于循环对象

整数、浮点数是不属于循环对象，如果把它们放在for循环里，代码会报错

for i in '吴承恩':
    print(i)

#test
#吴
#承
#恩

range()函数

使用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

for循环：for子句

格式是【冒号】后另起一行，【缩进】写命令

 

while循环

while循环：放行条件

while在英文中表示“当”，while后面跟的是一个条件。当条件被满足时，就会循环执行while内部的代码（while子句）。

man = ''  # 注：这个''代表空字符串
while man != '有':
    man = input('有没有愿意为小龙女死的男人？没有的话就不能出古墓。')
print('小龙女可以出古墓门下山啦~')

while循环：办事流程

缩进才是while子句

两种循环对比

for循环和whlie循环最大的区别在于【循环的工作量是否确定】，for循环就像空房间依次办理业务，直到把【所有工作做完】才下班。但while循环就像哨卡放行，【满足条件就一直工作】，直到不满足条件就关闭哨卡。

所以说，当我们【工作量确定】的时候，我们就可以让for循环来完成重复性工作。反之，要【工作量不确定时】可以让while循环来工作

不过有一种情况for循环和while循环都可以解决问题，那就是【把一件事情做N遍】，不过for循环的代码相对更简洁一些

作业1

• 练习介绍

  练习目标：

  我们会通过今天的作业，再次练习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

作业2

• 练习介绍

  练习目标

  通过这个练习，你会尝试用循环来解决生活中的问题，并了解一种新的列表方法。

  练习要求

  小明、小红、小刚是同班同学，且坐在同一排，分别坐在第一位、第二位、第三位。
  由于他们的身高都差不多，所以，老师计划让他们三个轮流坐在第一位。
  每次换座位的时候，第一位变第三位，后面两位都往前一位。

• 方法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五种运算

• 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语句。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语句，将跳过之后的代码，直接回到循环的开始

# continue语句搭配for循环
for...in...:
    ...
    if ...:
        continue
    ...

# continue语句搭配while循环
while...(条件):
    ...
    if ...:
        continue
    ...

pass语句

pass语句就非常简单了，它的英文意思是“跳过”

a = int(input('请输入一个整数:'))
if a >= 100:
    pass
else:
    print('你输入了一个小于100的数字')

这个代码的意思是：当a>=100的时候，跳过，什么都不做。其他情况，也就是a<100的时候，执行一个print语句。
如果没有pass来占据一个位置表示“什么都不做”，以上的代码执行起来会报错

else语句

最后一种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)

 

 

项目实操关卡-人机PK

通过实战去成长，这体现在：能在学习初期就知道什么是关键知识，了解专业程序员一般是怎么思考和解决问题的，在一遍遍分析问题、拆解问题及解决问题的过程中真正地理解知识，并用这些知识来解决自己的问题。

一个项目一般是怎么完成的。更具体的说，程序员是如何思考和解决问题的呢？

我认为其中一个很重要的能力是【问题拆解】。问题拆解，指的是在做一件事或面对一个问题的时候，将其拆解成多个步骤或多个层次，逐步执行和解决问题，直至达到最终效果。

不过可能是出于长期编写代码的习惯，程序员会将问题拆得更细致一些，即拆到无法再拆为止

将完成一个项目的流程总结为以下三步
1.明确项目目标
2.分析过程，拆解项目
3.逐步执行，代码实现

明确项目目标

在互联网公司，一般情况下是由产品经理提出明确的项目需求，由程序员来实现，他们之间是“相爱相杀”的关系。：）

今天且让我扮演一下产品经理的角色。我们此次要实现的需求是：人机PK小游戏。具体效果请参照下面的示意动图。

简单来说，这个游戏中，会随机生成玩家和敌人的属性，同时互相攻击，直至一方血量小于零。

另外，这样的战斗会持续三局，采取三局两胜制，最后输出战斗结果，公布获胜方。

分析过程，拆解项目

“功能叠加、难度递增”这个角度考虑，将我们要实现的小游戏拆分成了三个版本

各版本程序功能描述

• 版本1.0:规定双方角色属性，战斗时人为计算扣血量，并打印出战斗过程;
• 版本2.0︰随机生成双方角色属性，自动计算扣血量，并优化显示战斗过程的代码;
• 版本3.0:双方进行3局PK，每局判定胜负。三局两胜，判断最终结果.
   

当项目被清晰地拆解后，剩下的就是去逐步执行，也就是重复“执行→遇到问题→解决问题→继续执行”这个循环的过程。

逐步执行，代码实现

• 版本1.0:自定属性，人工PK版本
• 版本2.0:随机属性，自动PK
• 版本3.0:打印战果，三局两胜

版本1.0：自定属性，人工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：随机属性，自动PK

如前所述，这个阶段，我们主要新增【随机属性】和【自动战斗】两个功能，画成流程图是这样子的：

版本2.0流程图

• 随机生成玩家和敌人的属性
• 显示玩家和敌人的属性
• PK过程展示自动攻击扣血

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要增加的功能

版本3.0：打印战果，三局两胜

对比版本2.0，在版本3.0中，我们想要增加的功能是：

1.打印战果：每局战斗后，根据胜负平的结果打印出不同的提示；

2.三局两胜：双方战斗三局，胜率高的为最终赢家。

• 游戏开始
•  
• #循环三局
• 随机生成属性
• 显示属性
• PK过程展示
• 输出单局结果
•  
• 输出三局两胜结果
• 游戏结束
   

反复解释新增功能，是因为这样不断地明确项目的阶段性目标，可以让自己持续专注地推进项目。

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

• 练习介绍

  练习目标：

  我们会在项目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):>')

作业2

• 练习介绍

  练习目标

  在这个练习，我们会学会一种新的“格式化字符串”的方法：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))