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('我会好好地帮助你,带你紧跟人工智能时代;我会解放你的双手,帮你提高工作效率;')

人才最为紧缺的前十个职位中

Python_从零开始-同步学习进度_第1张图片

Python_从零开始-同步学习进度_第2张图片

 

可以往数据分析师、爬虫工程师、web全栈开发、算法工程师等方向继续深造

Python_从零开始-同步学习进度_第3张图片

在编程界,有一句话非常出名,叫“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 . . .

拓展:

转义字符

Python_从零开始-同步学习进度_第4张图片

 

 

变量和赋值

代码-结果-解析

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='''小小小
千'''

整数

正整数、负整数和零的统称,是没有小数点的数字

运算符

Python_从零开始-同步学习进度_第5张图片

浮点数

带小数点的数字

浮点数识别起来非常简单,但是其运算却晦涩难懂、让人头秃。世界级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…

Python_从零开始-同步学习进度_第6张图片

 代码-结果-解析

stonenumber=5
#为宝石数量赋值
if stonenumber>=6:
    #条件:如果你拥有的宝石数量大于等于6个
    print('你拥有了毁灭宇宙的力量')
    #结果:显示‘就拥有了毁灭宇宙的力量’的结果
elif 3
  • 整个条件判断的大前提会按照从上到下的顺序挨个试一遍,看满足哪个条件,满足了就不往下走,不满足就继续试,试到出结果为止
  • elif的运行本质上和else一样,都需要一个和elif平级的前提,但是这个前提只能是if
  • elif已经带有其他条件的意思,所以elif后也可以不接else

 

if嵌套

Python_从零开始-同步学习进度_第7张图片

 

如何写嵌套代码

扒洋葱大法

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

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

最后一步,你要为另一个大条件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的值。

Python_从零开始-同步学习进度_第8张图片

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...循环语句

Python_从零开始-同步学习进度_第9张图片Python_从零开始-同步学习进度_第10张图片

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循环

Python_从零开始-同步学习进度_第11张图片Python_从零开始-同步学习进度_第12张图片

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】来强制结束运行

【布尔运算】的三种方式

两个数值做比较

  • >
  • <
  • ==
  • !=
  • <=
  • >=

直接用数值做运算

Python_从零开始-同步学习进度_第13张图片

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
    ...

Python_从零开始-同步学习进度_第14张图片

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小游戏。具体效果请参照下面的示意动图。

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

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

Python_从零开始-同步学习进度_第15张图片

分析过程,拆解项目

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

各版本程序功能描述

  • 版本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过程展示
  • 输出单局结果
  •  
  • 输出三局两胜结果
  • 游戏结束
     

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

Python_从零开始-同步学习进度_第16张图片

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))

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

你可能感兴趣的:(Python)