Skip to content

05.md

Latest commit

 

History

History
563 lines (400 loc) · 29.6 KB

05.md

File metadata and controls

563 lines (400 loc) · 29.6 KB

五、探究性问题分析

在本章中，我们将深入探讨问题分析，同时使用我们所学的一些知识，如逻辑推理、布尔逻辑和算法设计。我们将在本章中完成问题定义、分解和分析。

在本章中，我们将介绍以下主题：

  • 理解问题定义
  • 学习分解问题
  • 分析问题

为了进一步理解问题，我们需要看一个更复杂的问题并定义它，这样我们就可以开始算法设计过程。在本章中，您将学习如何定义问题并将其分解以设计算法。通过这样做，您还将了解 Python 中的词典。阅读本章后，您将能够使用计算思维过程来设计和创建解决复杂问题的算法。

技术要求

您将需要最新版本的 Python 来运行本章中的代码。您可以在此处找到本章中使用的完整源代码：https://github.com/PacktPublishing/Applied-Computational-Thinking-with-Python/tree/master/Chapter05

理解问题定义

正如我们在第 2 章计算思维元素中所讨论的，计算思维使用四个元素来解决问题：

  • 问题分解：这是分解数据的过程。
  • 模式识别：这是发现相似性或模式的过程。
  • 抽象：该元素处理对模式的概括。
  • 算法设计：这是我们定义解决问题的指令集的地方。

在本节中，为了进一步了解如何分析问题，我们将分析一个更大的问题，并完成创建算法所需的步骤。为了能够创建算法，我们必须分析问题并清楚地确定我们试图解决的问题。也就是说，*我们的算法是用来做什么的？**我们为什么要建造它？*查看问题的分解，然后定义我们需要什么，最终将为我们提供更好的算法。

我们将在下一节中解决一个问题。

问题 5A——建立在线商店

让我们来看看下面的问题。你正在开一家网上商店。它还处于初级阶段，但您将有三种不同类型的项目可用。它们是钥匙链、水瓶和 t 恤。对于此特定问题，我们将经历三个步骤：

  1. 做出假设
  2. 要考虑的事情
  3. 制作字典

我们将在接下来的部分中查看前面的步骤。

作出假设

让我陈述一下我们将要使用的商店的一些假设：

  • 这是一家提供物品供客户与其客户分享的公司。
  • 每个项目都可以有徽标和/或个性化信息，如姓名、电子邮件和电话号码。

现在我们将进入下一节，这是要考虑的事情。

需要考虑的事情

现在让我们来看看在我们开始使用算法之前需要考虑的一些事情：

  • 物品是否个性化？
  • 个性化会按字符、行或项目收费吗？
  • 当客户批量购买时，价格是固定的还是变动的？
  • 如果客户订购多种商品，是否会有折扣？
  • 每件商品的底价是多少？

前面的几点并不是我们可以讨论的唯一问题。但当我们分解问题时，我们将开始考虑这些问题。

在我们这样做之前，让我们谈谈如何在程序中包含每个项目的信息。如果您还记得第 3 章理解算法和算法思维，我们可以使用Python中的字典来保存我们的项目菜单。在这种情况下，我们有钥匙链、水瓶和 t 恤衫。

编纂词典

在我们研究这个问题所呈现的复杂性并分解这些信息之前，我们可以构建自己的词典。我们可以将字典中每个项目的价格设置为基价（不包含任何定制或折扣的价格），如下所示：

  • 每个钥匙链的成本：$0.75
  • 每件 t 恤价格：8.50 美元
  • 每个水瓶的费用：$10.00

现在让我们来建立字典。请记住，您可以在不使用字典的情况下执行此操作，但创建字典允许您在以后更新定价（如有必要）。您还可以创建函数来解决此问题。我们用逻辑和字典来解决这个问题。以下代码显示了如何构建字典：

ch5_storeDictionary.py

online_store = {
    'keychain': 0.75,
    'tshirt': 8.50,
    'bottle': 10.00
    }
print(online_store)

从前面的代码片段中，请记住这里不需要print()函数，但我经常使用它，以确保代码在我继续构建算法时正常工作。还请注意，变量的名称-keychain、tshirt和bottle被简化。

以下是该输出的外观：

{'keychain': 0.75, 'tshirt': 8.5, 'bottle': 10.0}

输出告诉我的是，每个变量的价格都被正确保存。我正在使用这个print函数来测试我的字典，并确保它在我开始处理我需要的字典之前正确运行。

这有助于我们编写代码并在代码的多个区域重用变量。拥有这些简单且易于识别的变量将允许我们在不增加错误的情况下更改和添加算法。

在本节中，我们了解到问题分析和定义有助于我们确定如何最好地设计解决方案。请记住，当我们研究问题时，无论是在编写算法之前还是在算法内部，我们使用的定义对于我们的设计和最终产品都是至关重要的。现在让我们来看问题的分解。

学习分解问题

当我们分解问题时，我们正在确定我们需要算法提供什么。最终用户需要看到一些无缝的东西。参见图 5.1中的流程图；这是帮助我们设计算法的基本决策流程图。

让我们先做另一个假设，如果用户输入超过 10，价格会更低。在这种情况下，我们只做小于 10 或大于等于 10 的事情。但是，如果需要进一步细分，可以添加更多案例，例如：

  • 小于或等于 10
  • 大于 10 且小于或等于 50
  • 大于或等于 50

你需要多少箱子就有多少。对于这个算法，我们将把它保留为两种情况，因为我们还必须包括个性化成本，我们不想创建一个过于复杂的算法。

下图显示了算法的流程图：

Figure 5.1 – Initial decision-making flowchart

图 5.1–初始决策流程图

如上图所示，这不是完整的流程图。在我们做出关于 t 恤衫的决定后，我们需要继续讨论瓶子。我们如何编写算法将取决于我们想要输出什么。现在，我们正在向用户提供他们从您创建的在线商店退房时获得的信息。

在下一节中，让我们使用前面的流程图创建一个算法。

将流程图转换为算法

图 5.1中的图表允许我们查看我们正在编写的算法的决策过程。在编写算法时，我们想看一下以下要点：

  • 字典和输入：输入可以是算法内输入，也可以是用户输入；字典是在算法中构建的。这意味着，要使用字典，我们必须在算法中定义它，然后才能使用它。
  • 成本：这是每个项目的基本成本。
  • 个人化成本：此成本加在基础成本上。

在接下来的章节中，我们将详细介绍前面的几点。

建立字典并提供输入

在我们添加任何复杂因素之前，让我们先看看如何获取每件商品的价格，并以基价使用它。我们需要清点每件物品的数量。以下代码向您展示了这一点：

ch5_StoreQuantilities.py

online_store = {
    'keychain': 0.75,
    'tshirt': 8.50,
    'bottle': 10.00
    }
keychain = online_store['keychain']
tshirt = online_store['tshirt']
bottle = online_store['bottle']
choicekey = int(input('How many keychains will you be purchasing? If not purchasing keychains, enter 0\. '))
choicetshirt = int(input('How many t-shirts will you be purchasing? If not purchasing t-shirts, enter 0\. '))
choicebottle = int(input('How many t-shirts will you be purchasing? If not purchasing water bottles, enter 0\. '))
print('You are purchasing ' + str(choicekey) + ' keychains, ' + str(choicetshirt) + ' t-shirts, and ' + str(choicebottle) + ' water bottles.')

从前面的代码片段中，注意我们在字典下面添加了变量。这将在以后有用。这些变量被命名为choicekey、choicetshirt和choicebottle。命名变量允许我们根据需要返回变量并更改代码。在这种情况下，每个变量都要求运行程序的人员输入，以获取他们订购的钥匙链、t 恤衫和瓶子的数量。同样，有多种方法可以解决这个问题，但我们正在使用我们迄今为止学到的知识来创建算法解决方案。

当我们运行前面的3钥匙链、0t 恤和10水瓶代码时，这是我们的输出：

How many keychains will you be purchasing? If not purchasing keychains, enter 0\. 3
How many t-shirts will you be purchasing? If not purchasing t-shirts, enter 0\. 0
How many t-shirts will you be purchasing? If not purchasing water bottles, enter 0\. 10
You are purchasing 3 keychains, 0 t-shirts, and 10 water bottles.

如您所见，我们有一个程序，它接受用户输入，然后向用户确认他们对每个项目所做的选择。

让我们看下一节关于成本的内容。

改变成本

现在，让我们加入成本的变化。假设客户购买的物品超过 10 件，那么更新后的成本如下：

  • 钥匙链：0.65 美元
  • T 恤衫：8 美元
  • 水瓶：8.75 美元

要进行上述更改，我们可以让程序更新成本差异，如下代码所示：

ch5_storeCost.py

online_store = {
    'keychain': 0.75,
    'tshirt': 8.50,
    'bottle': 10.00
    }
choicekey = int(input('How many keychains will you be purchasing? If not purchasing keychains, enter 0\. '))
choicetshirt = int(input('How many t-shirts will you be purchasing? If not purchasing t-shirts, enter 0\. '))
choicebottle = int(input('How many t-shirts will you be purchasing? If not purchasing water bottles, enter 0\. '))
print('You are purchasing ' + str(choicekey) + ' keychains, ' + str(choicetshirt) + ' t-shirts, and ' + str(choicebottle) + ' water bottles.')
if choicekey > 9:
    online_store['keychain'] = 0.65
if choicetshirt > 9:
    online_store['tshirt'] = 8.00
if choicebottle > 9:
    online_store['bottle'] = 8.75
keychain = online_store['keychain']
tshirt = online_store['tshirt']
bottle = online_store['bottle']
print(online_store)

现在我们已经更新了代码，我想打印出我的进度，以确保代码正常工作并且发生了更改。在本例中，我希望确保如果总数大于 10，成本将更新。（也就是说，当客户订购超过 10 件物品时，它会将每个物品的成本更新为较低的成本。）前面代码的输出如下：

How many keychains will you be purchasing? If not purchasing keychains, enter 0\. 10
How many t-shirts will you be purchasing? If not purchasing t-shirts, enter 0\. 14
How many t-shirts will you be purchasing? If not purchasing water bottles, enter 0\. 10
You are purchasing 10 keychains, 14 t-shirts, and 10 water bottles.
{'keychain': 0.65, 'tshirt': 8.0, 'bottle': 8.75}

您现在可以从前面的输出中看到，字典已经根据用户提供的总数更新了值。

现在我们需要继续并提供成本。我们可以提供项目总成本或全部购买的总成本，或者两者都提供（让我们同时提供）。请看以下代码段：

ch5_storeTotals.py

keychain = online_store['keychain']
tshirt = online_store['tshirt']
bottle = online_store['bottle']
print('You are purchasing ' + str(choicekey) + ' keychains, ' + str(choicetshirt) + ' t-shirts, and ' + str(choicebottle) + ' water bottles.')

前面的代码片段被添加了，这样我们就可以有一个print语句来确认用户的输入。通过在代码末尾打印该语句，我们可以与用户一起检查程序是否能够正确读取数字，以及用户输入的数字是否正确。

我们可以继续代码以添加每个项目的成本：

ch5_storeTotals.py

totalkey = choicekey * keychain
totaltshirt = choicetshirt * tshirt
totalbottle = choicebottle * bottle
grandtotal = totalkey + totaltshirt + totalbottle
print('Keychain total: $' + str(totalkey))
print('T-shirt total: $' + str(totaltshirt))
print('Water bottle total: $' + str(totalbottle))
print('Your order total: $' + str(grandtotal))

前面代码段末尾的print语句提供了每个项目总计以及完整订单总计的明细。在请求所有项目的输入后，代码将打印每个项目的成本小计。上述代码的结果如下：

How many keychains will you be purchasing? If not purchasing keychains, enter 0\. 10
How many t-shirts will you be purchasing? If not purchasing t-shirts, enter 0\. 7
How many t-shirts will you be purchasing? If not purchasing water bottles, enter 0\. 14
You are purchasing 10 keychains, 7 t-shirts, and 14 water bottles.
Keychain total: $6.5
T-shirt total: $59.5
Water bottle total: $122.5
Your order total: $188.5

现在我们已经有了没有个性化的商品的总数，如果订购，我们需要能够考虑个性化的成本。

在下一节中，我们来看看个人化成本是什么，以及在继续之前我们需要做出的决定。

添加个性化

现在，让我们将钥匙链、t 恤衫和水瓶的个性化限制为二进制问题，即用户是否想要个性化。我们没有考虑个性化的分层成本，你可能已经看到了。若您想添加层，您需要做出更多的决定，比如选择字体的成本、个性化设置的长度等等。我们现在将放弃这些，但是可以随意添加到这段代码中，以解决这些类型的定制。让我们为个性化添加另一个假设：

  • 钥匙链 1.00 美元
  • t 恤衫 5 美元
  • 水瓶 7.50 美元

我们需要创建前面的条件，然后将它们实现到我们的变量中。让我们分部分来看看代码。下面的文件包含我们要分解的每个部分。

回想一下，我们的算法首先要求输入他们购买的物品数量。以下代码段采用用户输入，以便考虑个性化：

ch5_storePersonalize.py

perskey = input('Will you personalize the keychains for an additional $1.00 each? Type yes or no. ')
perstshirt = input('Will you personalize the t-shirts for an additional $5.00 each? Type yes or no. ')
persbottle = input('Will you personalize the water bottles for an additional $7.50 each? Type yes or no. ')
if perskey == ('yes' or 'Yes'):
    online_store['keychain'] = online_store['keychain'] + 1.00
if perstshirt == ('yes' or 'Yes'):
    online_store['tshirt'] = online_store['tshirt'] + 5.00
if persbottle == ('yes' or 'Yes'):
    online_store['bottle'] = online_store['bottle'] + 7.50
keychain = online_store['keychain']
tshirt = online_store['tshirt']
bottle = online_store['bottle']
totalkey = choicekey * keychain
totaltshirt = choicetshirt * tshirt
totalbottle = choicebottle * bottle
grandtotal = totalkey + totaltshirt + totalbottle

前面的代码片段询问用户关于个性化的二进制问题。获取输入后，代码根据用户输入做出一些决定，并定义keychain、tshirt和bottle变量以及选择的总计。然后，以下代码段使用总计打印出每项购买的信息以及最终总计：

print('Keychain total: $' + str(totalkey))
print('T-shirt total: $' + str(totaltshirt))
print('Water bottle total: $' + str(totalbottle))
print('Your order total: $' + str(grandtotal))

从前面的代码中，请注意，keychain、tshirt和bottle变量是在我们所有基于总数和个性化的定制之后定义的。记住，在算法设计中，顺序很重要。如果我们在程序中较早地找到这些变量，那么随后的条件（如个性化）将不会影响这些变量。

因此，为了能够获得变量所需的一切，我们需要在定义影响变量的一些条件（如自定义）之后定义变量。请看前面的代码，注意变量的位置。通过更改变量的定义位置，查看最终结果是否发生变化，您可以随意使用代码。

以下是钥匙链决策过程的可视化流程图：

Figure 5.2 – Keychain decision-making flowchart

图 5.2–钥匙链决策流程图

如上图所示，这仅适用于钥匙链。我们需要对另外两个变量重复这个过程。在图中，您可以看到项目的决策过程。首先，用户指出购买的物品数量，然后他们是否会对其进行个性化设置。

根据每个答案，由程序计算总数。例如，如果没有个性化设置，则在决策树中更快地计算总数。我们可以使用函数重写这个程序（正如我前面提到的），以简化一些过程。目前，我们重点学习如何分解问题、分析条件，以及如何设计考虑多个决策的算法。记住完成其他项目的图表，以便在设计算法时更容易编写决策过程。

在本节中，我们学习了如何使用流程图创建算法。我们还学习了如何为我们的算法构建字典。

在我们继续之前，让我们看看分析问题的过程。当我们创建这个算法的时候，我们在分解问题的时候就这样做了。然而，在下一章之前我们应该考虑问题分析的一些关键部分。

分析问题

在分析问题时，我们可以记住一些步骤，以帮助我们确保创建最佳算法：

  • 清楚地阅读并理解问题。
  • 确定解决方案的主要目的。
  • 确定问题的约束条件。
  • 确定决策流程。
  • 建立可能解决问题的算法。
  • 确定问题的最佳算法工具。
  • 经常对算法进行测试。
  • 验证该算法是否为已识别的问题提供了解决方案。

如果我们回到我们的问题，我们在本章中经历了这个过程：

  • 我们有一家网上商店，里面有三种商品。
  • 项目成本取决于购买的数量。
  • 商品价格也取决于个性化定制。
  • 我们创建了流程图来帮助我们识别决策过程以及如何对其进行编码。
  • 我们通过代码行验证代码，代码行允许我们多次检查算法是否生成正确的响应。
  • 我们根据需要重新访问并重新排序代码片段。
  • 我们验证了算法的输出与我们确定的问题一致。

前面的过程需要重复，也就是说，这不是一个线性过程。有时我们会编写一个算法，然后重新查看决策流程图，进行调整，然后再次处理该算法。

当我们着眼于更大的问题时，在多个停止点分析我们的问题的必要性变得更加明显。我们应该在测试前编写数百行代码吗？不！想象一下，有 300 行代码，却在第 20 行上发现了一个错误，该错误在算法的其余部分中一直存在。

在每一个可能的进度点进行测试将使我们能够抓住可能导致我们长期损失的小错误。记住，第一次尝试就写一个完美的算法几乎是不可能的。我们都会犯错误，无论大小，所以我们必须继续测试和分析我们的进步。

在离开本章之前，让我们再看一个问题，并再次经历这个过程。

问题 5B–分析一个简单的游戏问题

你想设计一个数字猜谜游戏。用户必须猜测一个随机数。

让我们从定义问题开始，在本例中，这是一个游戏。让我们确定已知信息：

  • 计算机需要随机选择一个数字。
  • 用户需要输入一个数字。
  • 计算机必须检查用户的输入是否与随机生成的数字匹配。

*现在，这还不够！如果我第一次没有比赛，我会输吗？我有多少机会？随机数是介于 1 和 10 之间还是介于 1 和 500 之间？*在开始编码之前，我们必须做出一些决定。让我们添加一些参数：

  • 数字在 1 到 100 之间。
  • 用户将有 5 次机会猜测。
  • 计算机会告诉用户答案是过高还是过低。

现在我们有了这些参数，我们可以创建一个决策流程图：

Figure 5.3 – Decision flowchart for guessing game

图 5.3–猜谜游戏的决策流程图

从前面的图表中可以看出，该图表并不完整。这是因为我们将使用一些逻辑使过程重复 5 次。我们马上就谈。现在，请注意决定。首先，程序生成一个数字（但不显示）。然后用户输入一个猜测，该猜测要么正确，要么不正确。如果正确，那么用户将赢得游戏。如果答案不正确，那么程序会让用户知道答案是太低还是太高，并询问新的猜测。然后，该过程将根据需要重复进行。现在，让我们编写算法。

首先，让我们生成随机数，让用户猜测它。为随机生成的数字和用户输入添加一个print()函数，以便您可以看到信息正常工作。请记住，我们将在稍后取出这些代码，但作为问题分析过程的一部分，不断检查和重新检查代码是很重要的。以下代码将执行相同的操作：

ch5_ 猜测 1.py

import random as rand
compnumber = rand.randint(1, 100)
print(compnumber)
usernumber = int(input('Choose a number between 1 and 100\. You'll get 5 guesses or you lose! '))
print(usernumber)

您将从前面的代码中注意到，导入的random模块。我们还将其作为rand导入。那只是为了节省时间和空间。在 Python 中导入模块时，可以对其重命名。random模块为我们提供了一种方法，可以在我们选择的范围内生成数字。

rand.randint(1, 100)代码行包括1和100。这些是随机数生成器的端点或限制。rand函数是指前面提到的模块，randint（a，b）是指a和b之间的随机整数（包括a和b。

将代码运行几次，查看计算机生成的数字每次是如何变化的。以下几点显示了三个测试用例：

  • The following is test case 1 of the preceding code:

    27
Choose a number between 1 and 100\. You'll get 5 guesses or you lose! 10
10

    从前面的输出可以看出，27是计算机生成的随机数，10是用户输入的。

  • The following is test case 2 results of the previous code:

    68
Choose a number between 1 and 100\. You'll get 5 guesses or you lose! 65
65

    从前面的代码输出可以看出，68是compnumber变量的值，而用户（me）输入了数字65。如此接近，却又如此遥远！

  • The following is test case 3 output:

    50
Choose a number between 1 and 100\. You'll get 5 guesses or you lose! 23
23

    从前面的输出可以看出，计算机选择了数字50，而用户输入了23。

对于这个游戏的最终版本，我们不会打印出计算机号码。那就是作弊！现在，我们只是在测试。

让我们继续添加一个条件，不管第一个猜测是否正确。为此，我们必须验证compnumber == usernumber。在进入额外的重复和逻辑之前，我们将再次测试这一点，所以我们只会说如果这是真的，那么你赢了；如果为假，则您将失去：

ch5_ 猜测 2.py

import random as rand
compnumber = rand.randint(1, 100)
usernumber = int(input('Choose a number between 1 and 100\. You'll get 5 guesses or you lose! '))
if compnumber == usernumber:
    print('You win!')
else:
    print('You lose!')

就说我第一次试的时候失败了。不过，在我赢之前，我不会运行它，因为这可能需要 100 次或更多的尝试。以下是运行程序时的情况：

Choose a number between 1 and 100\. You'll get 5 guesses or you lose! 35
You lose!

现在让我们讨论一下重复一行代码。我们给用户 5 次猜测。我们如何在 Python 中做到这一点？

在 Python 中，我们可以使用for循环来迭代代码。我们知道我们有 5 次猜测，所以我们必须使用类似于for number in range(5):的东西来开始逻辑，如下代码所示：

ch5_ 猜 3.py

import random as rand
compnumber = rand.randint(1, 100)
i = 5
for number in range(5):
    usernumber = int(input('Choose a number between 1 and 100\. You have ' + str(i) + ' guesses left. '))
    if compnumber == usernumber:
        print('You win!')
    else:
        i = i - 1
print('You're out of guesses! You lose! ')

从前面的代码中，您是否注意到i*变量？*我们使用该变量，以便用户知道他们还剩下多少猜测。因此，如果我们有 5 次猜测，代码将从i = 5开始；然后，如果用户错了，它将使用行i = i – 1，这会提醒用户他们现在还有 4 次猜测，以此类推。看看运行该程序时会发生什么：

Choose a number between 1 and 100\. You have 5 guesses left. 14
Choose a number between 1 and 100\. You have 4 guesses left. 98
Choose a number between 1 and 100\. You have 3 guesses left. 48
Choose a number between 1 and 100\. You have 2 guesses left. 12
Choose a number between 1 and 100\. You have 1 guesses left. 54
You're out of guesses! You lose!

现在，我们不是很公平。正如前面提到的一样，我们希望在用户每次尝试猜测时给他们一个提示。现在我们有了检查它们是否相等的条件，我们可以添加一个elif条件来检查它们是大还是小。下面的代码显示了这一点：

ch5_ 猜测 4.py

import random as rand
compnumber = rand.randint(1, 100)
i = 5
for number in range(5):
    usernumber = int(input('Choose a number between 1 and 100\. You have ' + str(i) + ' guesses left. '))
    if compnumber == usernumber:
        print('You win!')
        exit()
    elif compnumber > usernumber:
        print('Your number is too small!')
        i = i - 1
    elif compnumber < usernumber:
        print('Your number is too large!')
        i = i - 1
print('You're out of guesses! You lose! ')

前面的代码现在向用户提供了一些反馈。如果数量大于计算机生成的数量，则用户收到反馈'Your number is too large!'，如果用户数量小于计算机生成的数量，则用户收到反馈'Your number is too small!'。如果用户赢了，我们还使用了一个exit()代码。那是因为我们希望比赛在我们获胜时停止。

这给了我们赢得这场比赛的机会，看看现在的输出是什么样子的：

Choose a number between 1 and 100\. You have 5 guesses left. 50
Your number is too small!
Choose a number between 1 and 100\. You have 4 guesses left. 75
Your number is too large!
Choose a number between 1 and 100\. You have 3 guesses left. 65
Your number is too small!
Choose a number between 1 and 100\. You have 2 guesses left. 70
Your number is too large!
Choose a number between 1 and 100\. You have 1 guesses left. 68
You win!

现在看看当我们输掉比赛时会发生什么：

Choose a number between 1 and 100\. You have 5 guesses left. 10
Your number is too small!
Choose a number between 1 and 100\. You have 4 guesses left. 40
Your number is too large!
Choose a number between 1 and 100\. You have 3 guesses left. 20
Your number is too small!
Choose a number between 1 and 100\. You have 2 guesses left. 30
Your number is too small!
Choose a number between 1 and 100\. You have 1 guesses left. 35
Your number is too large!
You're out of guesses! You lose!

正如你所看到的，你会得到不同的最终信息。我承认我花了很多时间才赢得一场比赛，所以我可以得到下面的结果，但是你可以看到第二个猜测是正确的：

Choose a number between 1 and 100\. You have 5 guesses left. 10
Your number is too small!
Choose a number between 1 and 100\. You have 4 guesses left. 90
You win!

我们将用最后一个算法停止这个游戏。如果我们愿意的话，我们实际上可以让这场比赛变得更好，但它完成了我们需要它完成的任务。你可以考虑在游戏中做出的一些变化如下：

  • 添加一个选项，提醒用户已经猜到的数字。
  • 添加一个选项，提醒用户他们忽略了以前的提示（因此，如果用户给出的数字太小，而给出的数字更小，计算机会提醒他们）。

我相信你可以尝试更多的定制。但现在，我们解决了这个问题并遵循了在分析问题时应该考虑的要点：

  1. 我们阅读并理解了这个问题。
  2. 我们确定了创建计算机玩家与用户玩家猜谜游戏的目的。
  3. 我们确定了问题的约束条件—数字的范围、猜测的次数，并提供了提示。
  4. 我们创建了一个决策流程图。
  5. 我们为这个问题编写并建立了一个算法。
  6. 我们研究了如何创建一个简单的算法，该算法可以迭代，而不必单独编写每个条件。
  7. 我们在多个点上测试了算法。
  8. 我们验证了该算法在赢和输的情况下都能准确运行。

在这里，你看不到的是我在使用所示算法之前所经历的错误数量。在编写过程中，我必须使用前面的步骤来帮助我识别错误，检查最佳算法，并迭代程序。这是一个我们将继续使用的过程。

总结

在本章中，我们讨论了问题的定义、分解和分析。我们使用问题来帮助我们完成识别问题、将问题分解为相关部分、识别约束以及分析算法的过程。我们使用流程图帮助我们了解设计算法时的决策以及如何组织想法。

我们学会了经常测试我们的算法。这为我们提供了早期识别错误的技能和理解，而不是等到我们有太多的代码行，这使得识别这些错误变得很困难。我们使用了一个在线商店和一个猜谜游戏来帮助我们理解 Python 中的一些可用功能。在整个过程中，我们使用布尔代码验证输入，使用嵌套的if语句，并学习如何使用字典解决所提出的问题。

此外，我们还获得了一个使用用户输入和变量的算法字典的机会。使用该算法使我们能够灵活地定义一些变量，并在运行该算法或在该算法内编辑变量。

在下一章中，我们将深入讨论解决方案过程和设计，深入研究更复杂的问题和 Python 语言。