python分析空调能耗 python 空调

条件控制语句

1. 条件判断语句

当今世界，很多智能设备，极大方便了我们的生活。比如某种智能空调的设定为：如果室温高于32度就自动打开。这个如果……就……的逻辑就是条件判断。而如果……就……这种最基本的条件判断，就是这一切的基础。Python碰到表示条件判断语句的时候，它会先判断是否符合条件，如果符合，那就执行相应的代码块。

注：Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

最简单的例子是，如果一个数字大于0，就打印"这个数字是正数"。

num = 12
if num > 0:
    print("这个数字是正数")

思考：实现上面的程序功能不使用条件判断语句，使用已学过的知识能否实现？

其实这是可以实现的，这就用到了第二天学习的逻辑运算符了。知识点"and运算非布尔值时是找false，遇到false直接输出false，否则输出最后一个"。代码如下：

num = 12
num > 0 and print("这个数字是正数")	# 该方法可读性比条件判断语句差，不建议多使用

再以智商分类为例，输入不同的智商值，程序会输出对应的智商等级。

score = int(input('输入智商值：'))	# input()函数用法之后介绍
if score < 80:
	print('智力低下')
if score >= 80 and score < 110:	# and逻辑运算符，与if 80 <= score < 110:等价
	print('普通智力')
if score >= 110 and score < 140:
	print('智力较高')
if score >= 140:
	print('天才或接近天才')

当输入一个智商值后，首先条件判断输入的值是否符合低于80，符合就执行打印智力低下，不符合时执行下一条语句，下一条语句功能是条件判断是否在介于80和110之间，符合就执行打印普通智力，不符合就执行下一条语句，以此类推，实现智商分类的功能。

条件判断语句是可以嵌套的，即一个条件语句在另一个条件语句里。作用是在基础条件满足的情况下，再在基础条件底下增加额外的条件判断。

比如以下代码:

score = input("请输入你本次的考试成绩:")
if score >= 60:
    print("你已经及格")
    if score >= 90:
        print("你很优秀，祝您再创佳绩")

2. input函数

Python3版本中 input() 函数接受一个标准输入数据，返回为 string 类型。函数语法为input([prompt]),prompt为提示信息(非必须),作用是用户进行输入前，已经打印出来的提示。input函数功能是接收用户键盘输入的值，可以用赋值运算符申明一个变量。

input()	# input语句有一个阻塞程序的功能，只有当用户输入了东西之后代码才会继续执行
print("Hello World")

string = input("请输入：")	# 输入Hello World，并将Hello World赋值给字符串变量string
print(string)	# 打印Hello World

Python3里input()默认接收到的是str类型，对于纯数字输入时具有自己的特性，它返回所输入的数字的类型(int,float)。

比如，在智商分类程序中 score = int(input(‘输入智商值：’))，Python会把输入的字符串当成整数来看待。这里需要注意，只有字符串本身是数字类型才可以转化。另外，需要注意的是，只能输入整型变量，输入浮点数比如输入1.5程序会报错。这和print(int(1.5))打印1本质上是不同的。

注：输入函数除了input()函数之外，还有raw_input()函数，请自行补充了解。

3. if-else语句

if-else语句的逻辑是如果if后面的条件判定为true，就执行其相应的条件代码。如果为false，就执行else对应的条件代码。if-else语句常用于实现如果……就……，反之……就……的功能需求。当然运用第二天学习到的三元运算符的知识也能实现此语句功能。

if-else语句格式如下：

# 判断是否逃离北上广
# 把选择放到了 choice 变量里，你要用它做什么呢？
choice = input('逃离北上广和逃回北上广，你怎么选？')

# 我需要判断变量 choice 和字符串 '逃离北上广' 是否相等
if choice == '逃离北上广':
  # 如果相等，我需要打印“恰合心意，平衡生活”
  print('恰合心意，平衡生活')
else:
  # 如果不相等，我需要打印“寻求成长，奋起拼搏”
  print('寻求成长，奋起拼搏')

# 判断输入的数字是否为自然数
num = int(input("请输入一个整数:"))
if num >= 0:
    print("这是一个自然数")
else:
    print("这不是一个自然数")

# 使用三元运算符
num = int(input("请输入一个整数:"))
print("这是一个自然数") if num >= 0 else print("这不是一个自然数")

# 打印每日涨粉数量，若没有获取到输入，就打印出 你忘记记录今天的涨粉量了
# 定义一个名为 check_growth() 的函数，函数有一个参数 growth，即当日涨粉量
def check_growth(growth):
# 如果获取到输入，就把获取到的输入把涨粉数打印出来
# if bool(growth) == True:
  if growth:	# 有输入的情况，growth bool值为True，就执行打印growth的动作
    print(growth)
  else:	# 没有输入的情况，就执行打印 你忘记记录今天的涨粉量了的动作
    print('你忘记记录今天的涨粉量了')
    
input_growth = input('请输入今天的涨粉量:')
check_growth(input_growth)

4. if-elif-else语句

现实中很多时候，做判断或选择往往不是2选1，更多的是N选1。比如智能空调：室温高于32度，自动开启制冷功能；室温低于10度，自动开启制热功能；其他情况无操作；比如彩票根据不同的情况给出奖金等。这里除了“其他就无操作”使用else之外，还有两个（或多个）范围没有互相交叉部分的情况时，就适合用到if-elif-else语句了。

if-elif-else语句用法如下：

# 如果 "判断条件_1" 为 True 将执行 "执行语句_1" 块语句
if 判断条件_1:
    执行语句_1……
# 如果 "判断条件_1" 为False，将判断 "判断条件_2"
# 如果"判断条件_2" 为 True 将执行 "执行语句_2" 块语句
elif 判断条件_2:
    执行语句_2……
# 如果 "判断条件_2" 为False，将执行"执行语句_3"块语句
else:
    执行语句_3……

# 根据考试成绩获取妈妈的奖励
score = int(input('请输入你的成绩：'))

if score >= 90:
    print('奖励马尔代夫三日游')
elif score >= 80:
    print('奖励一台新电脑')
elif score >= 70:
    print('奖励一套五三')
elif score >= 60:
    print('奖励一顿油焖虾')
else:
    print('奖励一顿胖揍')

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

elif 的语法非常简单。但在应用 elif 时，我们要注意的是：if、elif 和 else 的代码执行是严格遵循某个顺序的。

if ... elif ... else 语句的特点是“顺序检验，分支执行”。它会按照代码顺序，依次判断 if、elif 后接的条件是否成立，一旦发现某个条件满足，就会执行该条件指定的代码块，并跳出分支结构；至于其他分支的代码，它就一概不管了。

这里说的if、elif 和 else 的代码执行会严格遵循的“某个顺序”，具体来说就是条件判断的顺序。一般而言，if 后面跟的条件最先判断，elif 后的条件按照从上到下的顺序依次判断，最后再判断 else 对应的条件。

小结：

• 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。
• 4、条件判断可以没有else语句，可以有多个elif语句

思考：既然if-elif-else语句可以使用多个if语句同样也能实现，那为什么还需要学习if-elif-else语句呢？

要回答这个问题，就要理解多个 if 语句和 if ... elif ... else 语句在代码执行上的不同。我们先来看某设计者写的这两段代码，它们的设计目标都是小红帽根据 HP 值输出合适的装备，你觉得哪种写法更能满足设计者的要求呢？

HP = 350

# 代码示例：不使用 elif
if HP < 400:
  print('选择装备：高坚果之铠')
if 400 <= HP < 800:
  print('选择装备：高级巫师袍')
if HP >= 800:
  print('选择装备：外婆的红斗篷')

# 代码示例：使用 elif
if HP < 400:
  print('选择装备：高坚果之铠')
elif HP < 800:
  print('选择装备：高级巫师袍')
else:
  print('选择装备：外婆的红斗篷')

单看要实现的功能，这两段代码确实没什么区别；两段代码也都很好理解，不使用 elif 语句的代码甚至更符合人的直觉。那我们为什么还需要 elif 呢？

这是因为，两段代码的内部执行流程是不一样的：

发现了吗？在 HP = 350 的情况下，若代码中不使用 elif，则计算机需要进行三次条件判断；但在 if ... elif ... else 语句中，HP < 400 的条件一旦被满足，就会跳出条件分支，所以计算机只需要进行一次条件判断就够了。

你还可以自己画一下 HP = 500 和 HP = 800 时的流程图。总之，不使用 elif 的代码无论在 HP 值为多少时，都需要进行三次条件判断；但使用 elif 的代码最多只需要进行两次条件判断。这意味着什么？

对人脑来说，判断需要耗费很多认知资源；对计算机而言，条件判断同样会占用计算机的运算资源，影响代码执行效率。

前面说过，多路分支适合用来解决“多选一”的问题。在多个条件中只能满足一项，也就只能走一个分支，对这样的需求来说，使用 if ... elif ... else 语句无疑是更合适的。

不过，在使用 if ... elif ... else 语句时，还有个需要我们避开的坑。将上面的代码稍作更改，发现有什么问题吗？

HP = 350

if HP > 200:
  print('选择装备：高坚果之铠')
elif HP > 400:
  print('选择装备：高级巫师袍')
elif HP > 800:
  print('选择装备：外婆的红斗篷')

这段代码的问题很明显：两个 elif 分支永远不会被执行。这是因为我们把最宽泛的条件 HP > 200 接在了 if 后面，一旦满足 HP > 200，计算机就会打印 选择装备：高坚果之铠，然后跳出条件分支，elif 后的两个条件就不会被判断了。

也就是说，如果我们想让条件判断的逻辑符合我们的预想，我们就需要让计算机先判断最苛刻的 HP > 800 是否成立，再判断 HP > 400 是否成立，然后再判断最容易成立的 HP > 200。

5. if语句练习

学习完了条件判断语句之后，我们需要合理地设计条件。总结如下：

# 需求：根据指定的月份打印该月是什么季节
# 3 4 5是春季
# 6 7 8是夏季
# 9 10 11是秋季
# 12 1 2是冬季

month = int(input("请输入月份"))
if 0 < month < 13:
    if month == 3 or month == 4 or month == 5:
        print("春季")
    elif month == 6 or month == 7 or month == 8:
        print("夏季")
    elif month == 9 or month == 10 or month == 11:
        print("秋季")
    elif month == 12 or month == 1 or month == 2:
        print("冬季")
else:
    print("俺也不造这是个啥月")

需求：按照下面的流程图，写小红帽打小怪兽的程序代码

ending_normal = '小红帽没有打怪，采采蘑菇就回了家'
ending_wolf = '小红帽使用技能“荆棘术”打败了灰狼'
ending_dragon_1 = '小红帽使用技能“火球术”打败了黑龙'
ending_dragon_2 = '小红帽使用技能“隐形术”躲过了黑龙，安全回到家中'

# 按照流程图完成代码的条件分支
answer_1 = input('小红帽探险时遇到敌人了吗？回答有/没有：')
if answer_1 == '有':
	answer_2 = input('小红帽遇见的敌人是谁？回答灰狼/黑龙')
    if answer_2 == '黑龙':
    	answer_3 = input('小红帽带上万能魔杖了吗？回答带了/没带')
        if answer_3 == '带了':
        	print(ending_dragon_1)
      	else:
        	print(ending_dragon_2)
    else:
    	print(ending_wolf)
else:
	print(ending_normal)

6. while语句

while 循环由 循环条件 和 循环体 两部分组成。

循环条件是个布尔值，每次循环都会进行判断，当满足循环条件（值为 True）时执行循环体内的代码，否则结束循环。

循环体内则是那些需要重复执行的代码，比如重复打印一句话，重复处理一堆文件，重复填写一系列信息等等。

在编程中，一个靠自身控制无法终止的程序称为 死循环。我们经常会因为粗心，导致写出 死循环。因此，写代码的时候一定要细心，想清楚逻辑再写。

# while循环语法结构
# while + 条件表达式：代码块
# 三要素：设定初始值  设定循环条件 初始值要自增长（增加或减少）
# while True: # 死循环
#     print(1)
# i = 1
# while i < 10: # 一直满足i<10,同样也是死循环
#     print(1)
i = 0
while i < 10:   # 当i增加到不满足i < 10的条件时，就推出循环
    print(i)
    i += 1	# 先打印再自增长
else:
    print("循环结束")   # 退出循环提示

# 输出结果
0
1
2
3
4
5
6
7
8
9
循环结束

7. while循环练习

# 求100以内(包括100)所有偶数之和
sum = 0
i = 0
while i < 100:
    i += 2
    sum += i
print(sum)

# 一张纸的厚度大约是 0.08mm，对折多少次之后能达到珠穆朗玛峰的高度（8848.13 米）？
mount = 8848130
paper = 0.08
n = 0
while paper < mount:
	paper *= 2
	n += 1
print('需要对折' + str(n) + '次')

# 需用到列表和模块的基础知识
# 实现彩票抽奖机，其规则是：随机生成6个0-99之间的数（包括0和99）放到列表里作为本期彩票中奖号码
# 导入模块（后续学习详细介绍）
from random import randint

# 用循环生成 6 个随机数放到列表里作为中奖号码
random_list = []
i = 0
while i < 6:
  # randint(0, 99) 随机生成 0-99 之间的数，包括 0 和 99
  number = randint(0, 99)
  random_list.append(number)
  i += 1
print('本期彩票中奖号码为'+str(random_list))

8. 循环嵌套

和条件判断语句类似，循环语句也可以嵌套，即一个循环（内层循环）可以在另一个循环（外层循环）的循环体之内。表示执行第一次外层循环时，需要执行完毕内层循环退出内层循环之后，再继续执行下一次外层循环，以此类推，直到外层循环结束再退出整个循环。

循环嵌套适用于当内层循环的循环条件与外层循环条件密切相关的情景。

# 打印
'''
*****
*****
*****
*****
*****
'''
i = 0
while i < 5:
    j = 0
    while j < 5:
        print("*", end='')	# 连接*在一行
        j += 1
    print()	# 打印空用于换行
    i += 1

# 打印
'''
*****
****
***
**
*
'''
i = 0
while i < 5:
    j = 0
    while j < 5-i:
        print("*", end='')
        j += 1
    print('')
    i += 1

# 打印（注意每行末尾不能有空格）
'''
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
'''
i = 0
while i < 5:
    j = 0
    while j < i:
        print(j+1, end=' ')
        j += 1
    print(j+1, end='\n')
    i += 1

九九乘法表

# 打印九九乘法表（注意每行末尾不能有空格）
'''
1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
'''
# 方法一：
i = 0
while i < 9:
    i += 1
    j = 0
    while j < i-1:
        j += 1
        print(f"{j}*{i}={i*j}", end='\t')
    print(f"{j+1}*{i}={i*(j+1)}", end='\n')

# 方法二：
print('\n'.join(['\t'.join(['%s*%s=%s' % (j, i, i*j) for j in range(1, i+1)]) for i in range(1, 10)]))

9. break和continue

break 语句用于 结束循环，常和条件判断一起使用，在特定条件下结束循环。

在 while 循环 和 for 循环 里分别这样写(for循环之后学习会详细介绍)：

举个例子：

# while 循环
i = 0
while i < 5:
  i = i + 1
  if i == 3:
    break  # 注意此处有缩进
  print(i)
print('循环结束')
# 逐行输出：1 2 循环结束

# for 循环
for i in range(5):
  i = i + 1
  if i == 3:
    break  # 注意此处有缩进
  print(i)
print('循环结束')
# 逐行输出：1 2 循环结束

可以看到，break 语句在 while 循环 里和 for 循环 里的作用一样，都是用于提前结束循环，后续循环代码不再执行。

我们不会傻傻地把 while 循环 的循环条件写成 True，除非有意而为之。当有了 break 语句之后，我们可以在特定条件下跳出 “死循环”（这里不算严格意义上的死循环）。

i = 0
while True:
  if i == 5:
    break
  print(i)
  i = i + 1
print('循环结束')
# 逐行输出：0 1 2 3 4 循环结束

上面的循环在 i 等于 5 时执行 break 语句结束循环，所以即使循环条件一直为 True 也不会造成“死循环”。上面的代码相当于将循环条件放到了循环体中，用 if 语句和 break 语句来判断并终止循环。

continue 语句和 break 语句有着类似的作用，它用于 跳过当前循环，常和条件判断一起使用，在特定情况下跳过当前循环体中的剩余语句，继续进行下一轮循环。

在 while 循环 和 for 循环 里分别这样写：

举个例子：

# while 循环
i = 0
while i < 5:
  i = i + 1
  if i == 3:
    continue  # 注意此处有缩进
  print(i)
print('循环结束')
# 逐行输出：1 2 4 5 循环结束

# for 循环
for i in range(5):
  i = i + 1
  if i == 3:
    continue  # 注意此处有缩进
  print(i)
print('循环结束')
# 逐行输出：1 2 4 5 循环结束

可以看到，continue 语句在 while 循环 里和 for 循环 里的作用一样，当执行到 continue 语句时，continue 语句之后的代码都被跳过了，直接进入了下一轮的循环。

continue 语句和 break 语句都用于循环。break 语句用于结束循环；continue 语句用于在特定条件下跳过当前循环体中的剩余语句，继续进行下一轮循环。所以 continue 语句不能跳出 “死循环”。

# continue语句不能跳出“死循环”的例子
i = 0
while i < 10:
    if i == 3:
        continue
    print(i)
    i += 1
else:
    print("循环结束")
# 逐行输出 0 1 2
# 当i等于3时，因continue语句不再进行当前循环体剩余语句进行下一轮循环判断，而i < 10始终为true。
# 所以该代码同样陷入了死循环，只是没有一直打印数值而已

10. Python练习

2020/11/20

第一题：求1000以内所有的水仙花数

水仙花数：也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。

# 方法一：
num = 100
# 使用while循环
while num < 1000:
    a = num // 100  # 百位
    b = (num % 100) // 10  # 十位
    c = (num % 100) % 10  # 个位
    # 不用条件判断
    (a ** 3 + b ** 3 + c ** 3 == num) and print(num)
    num += 1

# 方法二：
# 使用for循环
for num in range(100, 1000):
    a = num // 100  # 百位
    b = (num % 100) // 10  # 十位
    c = num % 10  # 个位
    # 使用条件判断
    if pow(a, 3) + pow(b, 3) + pow(c, 3) == num:
        print(num)

# 方法三：
for num in range(100, 1000):
    a, b, c = num // 100, num % 100 // 10, num % 10
    (a ** 3 + b ** 3 + c ** 3 == num) and print(num)

# 方法四（字符串）：
for num in range(100, 1000):
    a = str(num)
    (int(a[0]) ** 3 + int(a[1]) ** 3 + int(a[2]) ** 3 == num) and print(num)

# 方法五：
print(*[a ** 3 + b ** 3 + c ** 3 for a in range(1, 10) for b in range(0, 10) for c in range(0, 10) if a * 100 + b * 10 + c == a ** 3 + b ** 3 + c ** 3], sep='\n')

第二题：获取用户输入的任意数，判断其是否是质数?

质数：又称素数，指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数（也可定义为只有1与该数本身两个因数的数）。简单来说就是，只能除以1和自身的数（需要大于1）就是质数。举个例子，5这个数，从2开始一直到4，都不能被它整除，只有1和它本身（5）才能被5整除，所以5就是一个典型的质数。

# 方法一：
num = int(input("请输入一个数字: "))
# 质数大于 1
if num > 1:
    # 查看因子，使用for循环
    for i in range(2, int(1+num**0.5)):
        if (num % i) == 0:
            print(num, "不是质数")
            print(i, "乘于", num // i, "是", num)
            break
    else:
        print(num, "是质数")
# 如果输入的数字小于或等于 1，不是质数
else:
    print(num, "不是质数")

# 方法二：
num = int(input("请输入一个数字: "))
if num > 1:
    # 使用while循环
    i = 2
    while i*i <= num:
        if num % i == 0:
            print(num, "不是质数")
            print(i, "乘于", num // i, "是", num)
            break
        i += 1
    else:
        print(num, "是质数")
else:
    print(num, "不是质数")

第三题：

猜拳游戏

• 出拳 玩家：手动输入 电脑：随机输入
• 判断输赢： 玩家获胜 电脑获胜 平局

# 方法一
import random

your_choice = int(input('请选择:石头(0) 剪刀(1) 布(2)：'))

NPC_choice = random.randint(0, 2)
if your_choice in range(3):
    print(f'电脑选择：{NPC_choice}')
    if (your_choice + 1) % 3 == NPC_choice:
        print('玩家获胜')
    elif your_choice == NPC_choice:
        print("平局")
    else:
        print('电脑获胜')
else:
    print('输入有误')

# 方法二
import random

choices = ['石头', '剪刀', '布']

your_choice = input('请输入石头、剪刀或布：')
if your_choice in choices:
    print('你出了' + your_choice)
    your_index = choices.index(your_choice)
    NPC_choice = choices[int(random.random() * len(choices))]
    print('电脑出了' + NPC_choice)
    NPC_index = choices.index(NPC_choice)
    if your_index == NPC_index:
        print('平局')
    # elif NPC_index - your_index == 1 or (NPC_index == 0 and your_index == 2):
    elif (your_index + 1) % 3 == NPC_index:
        print('玩家获胜')
    else:
        print('电脑获胜')
else:
    print('输入有误')

# 方法三
import random

choices = ['石头', '剪刀', '布']
# 所有获胜的情形
win = [
    ['石头', '剪刀'],
    ['剪刀', '布'],
    ['布', '石头']
]

your_choice = input('请输入石头、剪刀或布：')

if your_choice in choices:
    NPC_choice = random.choice(choices)
    if [your_choice, NPC_choice] in win:
        print('你出了%s，电脑出了%s\n玩家获胜' % (your_choice, NPC_choice))
    elif your_choice == NPC_choice:
        print('你出了%s，电脑出了%s\n平局' % (your_choice, NPC_choice))
    else:
        print('你出了%s，电脑出了%s\n电脑获胜' % (your_choice, NPC_choice))
else:
    print('输入有误')