二级python——计算思维：自顶向下和自底向上

计算思维

• 实证思维：以实验和验证为特征
• 逻辑思维：以推理和演绎为特征
• 计算思维：以设计和构造为特征

计算思维的本质：抽象（Abstraction）和自动化（Automation）

自顶向下的设计方法

一个总问题开始，试图把它表达为很小的问题组成的解决办法，进而可以很容易的解决
“大事化小，小事化了”

实例

步骤

1. 打印程序的介绍性信息
2. 获得程序需要的参数probA， probB， n
3. 利用球员A和B的能力值（获胜概率）模拟n次比赛
4. 输出结果
   
   这就是自顶向下的顶层设计，程序框架出来了，大的问题化成了一个个具体的小问题

顶层设计

# 自定向下第一步——顶层设计
# --------先将整体思路设计出----------------------
def main():
    # 输出介绍信息
    printIntro()
    
    # 获取用户输入
    probA, probB, n = getInputs() # 能力值（获胜概率）和次数
    
    # 模拟n次比赛
    winsA, winsB = simNGames(n, probA, probB)
    
    # 输出结果
    printSummary(winsA, winsB)
    
main()

输出介绍信息

# 开始向下设计
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行时，需要输入A和B的能力值（0~1），模拟比赛次数")

获取参数输入

def getInputs():
    a = eval(input("请输入选手A的能力值（0~1）："))
    b = eval(input("请输入选手B的能力值（0~1）："))
    n = eval(input("请输入模拟次数："))
    return a, b ,n

程序核心：比赛过程

def simNGames(n, probA, probB):
    """程序核心：模拟比赛过程"""
    winsA, winsB = 0, 0 # 各赢多少次
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB) # 单次比赛
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB

def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0 # 得分
    serving = "A" # 发球方
    
    while not gameOver(scoreA, scoreB):
        random_win = random.randint(0, 1)
        if serving == "A":
            if random_win < probA: # 发球方是否赢得了比分
                scoreA += 1
            else:
                serving = "B"
        else:
            if random_win < probB:
                scoreB += 1
            else:
                serving = "A"
    return scoreA, scoreB

def gameOver(a, b):
    return a==15 or b==15 # 谁先到15分就赢下单次比赛

代码

import random

# 开始向下设计
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行时，需要输入A和B的能力值（0~1），模拟比赛次数")
    
def getInputs():
    a = eval(input("请输入选手A的能力值（0~1）："))
    b = eval(input("请输入选手B的能力值（0~1）："))
    n = eval(input("请输入模拟次数："))
    return a, b ,n

# ---------游戏过程-----------------------------------------
def simNGames(n, probA, probB):
    """程序核心：模拟比赛过程"""
    winsA, winsB = 0, 0 # 各赢多少次
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB) # 单次比赛
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB

def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0 # 得分
    serving = "A" # 发球方
    
    while not gameOver(scoreA, scoreB):
        random_win = random.randint(0, 1)
        if serving == "A":
            if random_win < probA: # 发球方是否赢得了比分
                scoreA += 1
            else:
                serving = "B"
        else:
            if random_win < probB:
                scoreB += 1
            else:
                serving = "A"
    return scoreA, scoreB

def gameOver(scoreA, scoreB):
    return scoreA==15 or scoreB==15 # 谁先到15分就赢下单次比赛

# ------------------------------------------------
def printSummary(winsA, winsB):
    n = winsA + winsB
    print("竞技分析开始，一共模拟了{}次比赛".format(n))
    print("选手A获胜{}场".format(winsA))
    print("选手B获胜{}场".format(winsB))
    
"""自顶向下设计方法"""

# 自定向下第一步——顶层设计
# --------先将整体思路设计出----------------------
def main():
    # 输出介绍信息
    printIntro()
    
    # 获取用户输入
    probA, probB, n = getInputs() # 能力值和次数
    
    # 模拟n次比赛
    winsA, winsB = simNGames(n, probA, probB)
    
    # 输出结果
    printSummary(winsA, winsB)
    
main()

这个程序模拟两个选手A和B的某种竞技比赛
程序运行时，需要输入A和B的能力值（0~1），模拟比赛次数
请输入选手A的能力值（0~1）： 0.5
请输入选手B的能力值（0~1）： 0.45
请输入模拟次数： 10
竞技分析开始，一共模拟了10次比赛
选手A获胜3场
选手B获胜7场

自底向上

• 开展测试的最好办法也是将程序分成小部分逐个测试
• 执行中等规模程序的最好办法就是从结构图最底层开始，逐步向上升，先运行和测试一个基本函数，再测试由基本函数组成的整体函数，有助于定位错位

将上面代码保存为 Match,py

>>> import Match
>>> Match.gameOver(10, 1)
False
>>> Match.gameOver(15, 10)
True
>>> # 说明gameOver是正确的
>>> Match.simOneGame(0.45, 0.5)
(9, 15)
>>> Match.simOneGame(0.45, 0.5)
(15, 5)
>>># 说明simOneGame正确的