面向孩子们的-Python-入门指南-三-

面向孩子们的 Python 入门指南（三）

原文：Introduction to Python for Kids

协议：CC BY-NC-SA 4.0

九、听从我的命令！

在前一章中，我们学习了所有关于字符串的知识，以及如何使用它们来创建字母和数字的字符串，如何以我们想要的任何方式操作字符串，如何从用户那里获得输入并将其转换成我们想要的数据类型，以及如何根据我们的喜好格式化输出(尤其是在打印语句中)。

在这一章中，让我们看看如何用“if 和 else”语句来命令我们的计算机。

真或假

在编程中，真或假决定了你的程序走向。如果“某事”是真的，就做“某事”。如果是假的，就做“别的”。你可以用前面的“条件”创建许多程序。

所以，要给你的系统下命令，你需要三样东西(图 9-1 )。

图 9-1

条件及其结果

1. 将由 Python 评估的条件

2. 真或假的结果

3. 根据结果决定下一步发生什么的语法，即根据结果指向两种结果之一的语法

先看结果真假。“真”和“假”也是 Python 中的值。它们被称为布尔值。就像我们有我们的字符串和数字一样，我们可以将布尔值赋给变量，将它们转换成另一种值类型，找到它的类型(布尔值)，等等。你想看看怎么做吗？

让我们为本章创建一个新的脚本文件。我创建了一个名为 condition.py 的文件。我将在本章中使用和重用这个文件。真和假需要用大写的 T 和 F 来写，否则你会得到一个错误，所以请记住这一点。

让我们创建变量“a”和“b”并给它们赋值“真”和“假”。

a = True
b = False
print('a is {} & b is {}'.format(a,b))

当您运行前面的代码时，您将得到这样的结果:

= RESTART: C:/Users/aarthi/AppData/Local/Programs/Python/Python38-32/condition.py
a is True & b is False

好了，现在我们知道如何使用布尔值了。但是它们到底是什么呢？您知道布尔实际上只是 1 和 0 吗？O:

哦，是的，你的真被你的计算机读为 1，假被你的计算机读为 0。你的电脑是一个非常简单的生物。它将你发送给它的所有复杂、怪异的代码和脚本转换成非常简单的基于 1 和 0 的值。真值和假值都转换为它们的基数-1 和 0。

我们何不验证一下这是不是真的？如果我把布尔值转换成整数，我应该得到 1 或 0。

a = True
a = int(a)
b = False
b= int(b)
print('a is {} & b is {}'.format(a,b))

我修改了前面的代码，并插入了整数转换。让我们看看我们得到了什么:

= RESTART: C:/Users/aarthi/AppData/Local/Programs/Python/Python38-32/condition.py
a is 1 & b is 0

看那个！True 转换为 1，False 转换为 0！

同样，您可以使用 bool()方法将数字和字符串转换为布尔值。任何不是空字符串或数字 0 的值都将返回 True。是的，即使是负数也会返回 True！我们为什么不测试一下呢？

我将在我的 Shell 中直接测试相同的内容。

1 转换为 True。

>>> bool(1)
True

0 转换为 False。

>>> bool(0)
False

一个包含某些内容的字符串会转换为 True。对于内部只有一个空格的字符串也是如此。

>>> bool('hi there!')
True

空字符串转换为 False。

>>> bool('')
False

Python 中有一个值“None”。它基本上意味着里面什么都没有。如果将“None”赋给一个变量，该变量中的值将被替换为空值。自然，“无”会转换为 False。

>>> bool(None)
False

在后面的章节中，我们将会看到更多的叫做列表、元组和集合的值。当我们这样做时，您会注意到，包含某些内容的列表、元组和集合会转换为 True，而空列表、元组和集合会转换为 false。

比较并决定

好了，我们已经看过结果了。但是我们如何得到它们呢？我们需要返回这些结果的条件，不是吗？Python 有很多条件你可以用！你想看看吗？我要再次提醒你这里的数学课。

还记得大于号(>)和小于号(

是的，你可以用那些符号作为你的条件！为什么我们不在我们的壳里测试它们呢？

3 大于 5 吗？

>>> 3 > 5
False

没有。

>>> 3 < 5
True

但是 3 比 5 小吗？哦，是的！

快看，成功了！你甚至可以测试是否相等。两个数相等吗？只要用两个等号代替一个，就可以了！

>>> 3 == 3
True

太好了。

您还可以使用不等于运算符来查看两个值是否不相等！=，像这样:

>>> 2 != 2
False

2 不等于 2 吗？不，它们是相等的，所以你得到一个假的。

你也可以用字符串来做这个，不仅仅是数字。

>>> 'hello' == 'Hello'
False

我们有一个错误。你能猜到原因吗？没错。Python 是区分大小写的，所以“H”不等于“H”。

您可以使用< =符号检查某个值是否小于或等于另一个值，从而简化计算。

>>> 2 <= 2
True

前面的代码为真，因为即使 2 不小于 2，它也肯定等于 2，并且由于其中一个条件为真，因此结果为真。

同样，您可以使用> =符号检查某个值是否大于或等于另一个值。

>>> 3 >= 5
False

3 既不大于也不等于 5，因此结果为假。

如果发生这种情况，请执行以下操作(命令！)

我们现在知道所有关于“真”、“假”和条件的事情。下一步是什么？当然是命令！

Python 中有一个漂亮的小工具可以用来发出命令。这就是所谓的“如果”陈述。你能猜出它是做什么的吗？给你个提示:跟“如果”有关。:P

到目前为止，您已经知道了如何创建条件以及如何解释它们的结果(真或假)，现在让我们将所有这些放在一起给出一个命令。

事实上这很简单。简单地说，这就是“if”语句的作用:它检查一个条件，如果该条件为真，那么它执行一条或多条语句。如果这不是真的，那么这些语句将不会被执行，你的程序将会进入下一行代码。

让我快速演示一下“if”语句是如何工作的，以便你更好地理解它(图 9-2 )。

图 9-2

“如果”语句

“if”语句的语法如下:

if comparison:
      lines of code

“if”有一个小“I”，if 语句内的语句要写缩进，基本就是空格/制表符。比较后的冒号“:”也是必需的。如果您不缩进“内部”代码行，那么 Python 不会知道这些代码行属于“If”语句，并且只应在条件为真时执行。所以，记得缩进，好吗？

好了，现在我们知道了 if 语句是如何工作的，让我们来测试一下。如果某人的年龄小于 5 岁，我想印“你是个小孩”。就这样。

我们如何做到这一点？嗯……条件可能是age < 5或类似的东西。如果我想把 5 岁包括在这个列表中，那么我可以把它列为age <= 5。我可以在我的声明中包含一个打印声明，基本上就是说“你是一个小孩子”。应该可以了，对吧？我们来测试一下！

age = input("What's your age? ")
age = int(age)
if age <= 5:
    print("You're a little kid :)")

我创建了一个变量 age，从用户那里获得输入，并将默认字符串转换成整数，这样就可以与数字进行比较。

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\condition.py
What's your age? 5
You're a little kid :)

耶，成功了！您已经在 Python 中执行了第一个条件命令。庆祝的时间到了。

现在，我要你给出任何一个大于 5 的数字，看看你会得到什么。

你试过吗？你什么也得不到，对吗？嗯，那不理想。让我们在下一节解决这个问题吧！

不然呢？

我们看到，如果条件为真，我们可以执行“if”语句的内部语句。但如果不是真的，什么都不会发生。但是如果我想发生什么呢？如果孩子大于 5 岁，那么我希望打印出“你是一个大孩子”。我该怎么做？

“if”语句伴随着“else”语句。如果“if”语句为假，它们就会被执行。让我来说明这是如何工作的(图 9-3 )。

图 9-3

“if else”语句

else 语句的语法非常简单:

else:
      inner lines of code

您应该在“else”后面加上一个冒号，因为这次我们不需要检查条件。同样，就像你的“if”语句一样，把你的内部代码行放在缩进、制表符或空格之后。

现在让我们来测试一下这是如何工作的！

age = input("What's your age? ")
age = int(age)
if age <= 5:
    print("You're a little kid! :)")
else:
    print("You're a big kid! :)")

现在让我们假设年龄为 8 岁，看看我们的程序会做什么:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\condition.py
What's your age? 8
You're a big kid! :)

哇哦！

不止一个条件！O:

你知道，有时候，事情不只是黑与白，对吗？如果有人超过 5 岁，他们不一定还是孩子。如果他们超过 12 岁，他们就是青少年了。如果他们超过 18 岁，他们就是成年人了。但是我们的项目没有考虑所有这些。嗯…不完整，你不觉得吗？让我们解决这个问题。

有一种叫做“elif”的语句可以插入到“if”和“else”语句之间。你能猜出 elif 是做什么的吗？名字里就有，不是吗？如果某个值为假，那么我们将检查第二个条件，看看和是否为真。在用 else 语句结束之前，可以像这样一个接一个地堆叠任意数量的 elif 语句。让我来说明这是如何工作的。

elif 语句的语法(在 if 之后，else 之前)如下(图 9-4 ):

图 9-4

“if elif else”语句

elif condition:
     Inner lines of code

让我们现在测试一下我们的 elifs，好吗？我将创建一个主要的“if”条件来测试 if age <= 5(小孩)。如果这不是真的，我们将包括另一个测试是否age <= 12(大孩子)的条件。我们将包含第三个条件来测试age <= 19(青少年)，最后包含第四个条件来测试age >= 20(成人)。

好的，听起来不错，但是 else 语句是用来做什么的呢？else 语句将捕捉所有其他内容。例如，如果您的用户错误地输入了一个字符串或任何其他非数字值，那么您的 else 语句将“捕捉”到这一点，并要求他们重新运行程序。够清楚了吗？我们要不要用代码写这个，看看是否可行？好吧。

age = input("What's your age? ")
age = int(age)
if age <= 5:
    print("You're a little kid! :)")
elif age <= 12:
    print("You're a big kid! :)")
elif age <= 19:
    print("You're a teenager! :)")
elif age >= 20:
    print("Wow, you're an adult already!")
else:
    print("Looks like you've not entered a number. Please re-run the program")

我将运行年龄为 13 岁的前面几行代码。

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\condition.py
What's your age? 13
You're a teenager! :)

现在，我要你每次用不同的年龄值(数字或其他)运行这个程序，看看你得到了什么。你为什么不试着也给一根绳子呢？玩得开心！

迷你项目-猜数字游戏

这将是一个简单的小游戏。我们不会在这里使用“ Turtle ”，但是你可以随意在游戏的任何部分使用它。

所以，游戏是这样工作的:当游戏开始时，程序会生成一个 1 到 10 之间的数字(包括 1 和 10)。然后，用户有三次猜对数字的机会。如果他们猜对了任何一个数字，他们就赢了。否则，他们就输了。简单吧？我们试试吧！

1. 我们先导入“随机”模块。我们需要这个模块，因为我们将在游戏开始时生成一个 1 到 10 之间的数字，用户需要猜这个数字。

2. 让我们从打印一条介绍游戏的消息开始。然后，让我们生成我们的随机数。我们将使用“随机”模块的 randrange()方法。你还记得这个方法吗？它从该范围内生成一个随机数，不包括该范围内的最后一个数。我们需要一个介于 1 和 10 之间的数字，所以范围是 1，11。

   print('Guess a number and win!')
   number = random.randrange(1,11)
   
   

3. 然后，让我们从用户那里得到第一个猜测。输入通常是字符串，所以我们先把它们转换成整数。

   guess1 = input('Guess a number between 1 and 10 - Your first try: ')
   guess1 = int(guess1)
   
   

4. 现在，我们将开始我们的比较。如果第一次猜测与数字相等，则打印一条成功消息。如果没有，开始一个“else”语句。在 else 语句中，重新开始。得到第二个猜测，在“else”中，开始一个内部“if”语句，检查第二个猜测是否与要猜测的数字相同。

   if(guess1 == number):
       print('You guessed it right! :)')
   else:
       guess2 = input('Guess again - Your second try: ')
       guess2 = int(guess2)
       if(guess2 == number):
           print('You guessed it right! :)')
   
   

5. 我们将在第三次尝试中做同样的事情。

   else:
       guess3 = input('Guess again - Your final try: ')
       guess3 = int(guess3)
       if(guess3 == number):
          print('You guessed it right! :)')
   
   

6. 最后，最后一个“else”语句。如果他们在三次尝试后仍然没有猜中，那么程序将运行最后的“else”语句并打印一条悲伤的消息。☹，为什么我们不告诉他们号码是多少？他们可能想知道，对吗？

7. 而且，就是这样！一个简单的小程序。

   else:
       print('Sorry! You used up all your tries! :(')
       print('The number was {}'.format(number))
   
   

import random

不如我们来看看这个游戏行不行？让我们运行上面的代码，我们将得到这个:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\condition.py
Guess a number and win!
Guess a number between 1 and 10 - Your first try: 5
Guess again - Your second try: 7
You guessed it right! :)

第二次试就猜到了！哇哦！

让我们再试一次:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\condition.py
Guess a number and win!
Guess a number between 1 and 10 - Your first try: 10
Guess again - Your second try: 6
Guess again - Your final try: 3
Sorry! You used up all your tries! :(
The number was 2

哎呀，这次我错过了。数字是 2。☹

情况越积越多！

有时，您可能希望同时检查多个条件。或者你可能希望你的情况与它的实际情况相反。

Python 为您提供了两个选项来实现这一点。这些被称为逻辑操作符，你可以用它们来组合条件语句(比较)并得出最终的真或假结果。迷茫？不要这样。我会解释的。

第一个是 和 运算符。如果在两个或更多比较上使用“与”运算符，那么条件将返回 true 只有如果 所有 比较都为 true。

语法如下:

(comparison1) and (comparison2)

您也可以编写不带括号的比较，执行仍然会正常进行(比较优先于逻辑操作符)，但是包含它们以使执行顺序更清晰总是一个好的做法。

让我解释一下“and”操作符是如何工作的。英语中“and”是什么意思？包容一切，围绕“和”，对吗？所以，当你在两个或更多的条件周围使用这个语句时，只有当它周围的所有条件都为真时，最后的结果才为真。如果其中一个条件为假，那么即使另一个条件为真，你也会得到一个假的结果。我为什么不用一个例子来解释这个呢？(图 9-5 )

图 9-5

“与”语句及其结果

你现在明白“和”是怎么运作的了吧？

接下来，您有了 或 运算符。这是怎么回事？很简单，真的。在英语中，“或”是“非此即彼”的意思，我说的对吗？因此，如果“或”运算符周围的任一条件为真，则整个语句为真。

如果在两个或更多比较上使用“或”运算符，那么如果这些比较中的任何一个为真，则条件将返回真。

**语法如下:

(comparison1) or (comparison2)

让我来说明“或”语句是如何工作的(图 9-6 )。

图 9-6

“或”语句及其结果

最后，还有 而不是 运算符。这里没什么好猜的。很简单，不是吗？“not”运算符只是颠倒了结果。如果比较的结果为真，那么在比较语句中使用“not”运算符将返回假，反之亦然。

语法如下:

not(comparison)

您也可以在其他逻辑语句中使用“not”运算符:

not((comparison1) and (comparison2))

在编程中，你需要确保你总是关闭括号。在前面的语法中，我们用两组括号将每个比较括起来，中间是“and”运算符，另一组括号将所有比较括起来。

让我们通过在 Python Shell 中测试这些语句来结束本章:

>>> (5 > 3) and (4 < 3)
False

5 大于 3，但 4 不小于 3。如果我们使用“或”操作符，

>>> (5 > 3) or (4 < 3)
True

我们得到一个真值，因为其中一个比较为真。

现在就来结合逻辑语句吧！我们为什么不用数学运算来做比较，让事情变得复杂一点呢？

>>> ((5 > 3) or (4 < 3)) and ((3 + 2) == 5)
True

花一分钟仔细阅读前面的陈述。先看看括号的位置。我用括号将每个操作(大于、小于和加法)括起来，一个括号包含“或”语句，另一个括号包含等于操作。如果我漏掉了其中的一个括号，我要么会得到一个错误，要么运算的顺序会被打乱，我的答案会是错误的。

现在让我们测试“not”运算符。

>>> not(5 > 3)
False

5 > 3 是真的，但是因为我在比较中使用了“not”操作符，所以得到了一个假的。

>>> not((5 > 3) or (4 < 3))
False

“或”运算的结果为真，因为其中一个语句为真，但由于我对所有语句都使用了“非”，所以最终结果为假。

>>> (5 > 3) and (not(4 < 3))
True

原来，前面的操作返回 false 是因为 4 < 3 is not true. But I used “not” on 4 < 3, which made the final result of the comparison True. So 为真，而 True 为真。

我要在这里停止测试，但我要你全力以赴！为什么不把所有你知道的数学运算符与比较运算符和逻辑运算符结合起来呢？尝试不同的组合，看看你会得到什么。编程就是要实验。实验去吧！

摘要

在这一章中，我们学习了如何命令我们的电脑做我们想做的事情。我们学习了布尔值和条件以及它们的结果。然后，我们继续学习“if”、“else”和“elif”语句，以及如何使用它们来命令我们的计算机。最后，我们看了“and”、“or”和“not”以及它们的用法。像往常一样，我们也做了一些小项目。

在下一章，让我们看看用循环来自动化我们的程序。你会发现在用海龟创建图形时，这是一种受欢迎的解脱。**

十、自动化一点

在前一章中，我们学习了所有关于条件、if、else 和 elif 语句的知识，以及如何组合多个条件来创建复杂的命令。

在这一章中，让我们看看循环的自动化，如何使用 for 和 while 循环来自动化图形的创建，如何用 break 语句提前结束循环，等等。在这一章中，我们将会看到许多丰富多彩和有趣的迷你项目。

魔法圈！

Python 的神奇和奇妙是永无止境的，循环是其中的佼佼者！还记得我们为了在 turtle 中绘制一个简单的小图形而编写的大量代码吗？你想要更简单的方法来做同样的事情吗？如果您可以用四到五行代码一个接一个地画出数百个方块，那会怎么样？那只是一个例子。如果你想在海龟身上打印出 1 到 100 的数字，又是 4 到 5 行代码，该怎么办呢？这是 100 条打印语句，但我们只用了四行代码就完成了。怎么会？这就是循环的力量。

使用循环，你可以让你的程序重复相同的动作任意次。您想打印 1 到 100 之间的内容吗？可以创建一个自动化代码，从 1 开始，打印 1，然后 1 加 1，就是 2；打印出来，并再次递增；等等。

看图 10-1 。我们有一堆代码行。存在一个范围，只要该范围为真，我们就运行相同的代码行。该范围从一个数字开始，每次循环重复时递增 1。一旦达到设定的数量，我们就停止运行“循环”。每次运行这些相同的代码行，就称为一次迭代。在我们的例子中，我们将有 100 次这样的迭代来打印 1 到 100。

图 10-1

循环——插图

Python 中有两种类型的循环，我们将同时研究这两种循环。我还将通过许多迷你项目来展示这些循环的威力。你对开始感到兴奋吗？我知道我是！循环是真正的交易。你已经成功一半了！

对于循环

For 循环是最常用的循环。他们不只是迭代给定的次数。是的，他们确实是这样做的，但是你可以使用“for 循环”来迭代字符串、列表和许多类似的复杂数据。

在这一章中，我们将只研究在给定的数字范围内使用 for 循环，或者用一个字符串作为范围。一旦我们将来看到复杂的数据类型，比如列表和字典，让我们重温一下 for 循环，以及如何在这些数据类型中使用它们，好吗？

好吧，那我们开始吧！

让我们继续前面的例子。我想打印从 1 到 100 的数字。你已经看过插图了。你知道需要什么。让我们先看看如何在一个范围内写一个 for 循环，然后让我们试着解决我们的问题，好吗？

语法非常简单。您必须以“for”关键字开始语法，并在整个语法中使用小写字母。然后，您需要创建一个临时变量。它可以是一个“x”(随机的，未知的数字)或一个“I”(表示迭代)，或者它可以是你想要的任何变量名。该变量将在每次迭代的范围内存储您的当前数字。

所以，如果你的范围是从 1 到 5，假设我们把临时变量命名为“x”。

Iteration 1 : x is 1
Iteration 2 : x is 2
Iteration 3 : x is 3
Iteration 4 : x is 4
Iteration 5 : x is 5

当 x 达到 5 时，我们的循环停止执行。你知道这是怎么回事吗？

此外，你的数值范围可以是任何东西，真的，只要它有连续性。如果您给定的范围是 range(1，6)，那么这意味着您希望每次迭代的 x 值从 1 到 5。忽略范围内的最后一个数字。

别忘了你的结肠！就像在你的“if”语句中一样，你的“for”语句以一个冒号结尾，并且它里面的代码行应该放在一个缩进后面。

所以，语法应该是这样的:

for x in range(1,6):
    lines of code

我知道，我知道。都有点混乱，太理论化了。我们来看一堆例子，好吗？

我的问题陈述是什么来着？我想打印从 1 到 100 的数字，对吗？范围应该是 range(1，101 ),因为我希望包含 100，并且我只需要在循环中包含一个 print 语句。

代码应该是这样的:

for x in range(1,101):
    print(x)

运行前面的代码，您会得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
1
2
3
.
.
.
97
98
99
100

我的代码打印了全部内容，但是我不认为我们在这一章中有足够的空间来打印所有内容，所以这里是它的“剪切”版本。你有没有运行代码看看？很神奇，对吧？你只用了两行代码就完成了所有这些。仅此而已。 即 是循环往复的力量。

只有当我想打印范围内的所有内容时，这才有效。如果我只想打印偶数，该怎么办？我可以给出一个我力所能及的条件来实现它。

假设我的范围是这样的:range(2,101,2)

我基本上要求我的代码从 2 到 100 打印，但是对于每一次迭代，我希望“x”的当前值增加 2 而不是 1。

因此，x 在第一次迭代中是 2，在第二次迭代中是 4，依此类推。我们要测试这个吗？

for x in range(2,101,2):
    print(x)

当我运行前面的代码时，我会得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
2
4
6
8
10
.
.
.
94
96
98
100

如果你希望每次的增量都是 3，那么把 3 作为第三个参数，以此类推。

for 循环中的 If 语句

或者，我可以使用我们在第五章学到的模数运算符来过滤掉我不想要的数字。所以，如果我只想打印 off 数，那么我可以做一个 x % 2 运算，每当我得到 1 的结果时，我就可以确认当前数是奇数并打印出来。

1 % 2是1

2 % 2是0

3 % 2 又是 1

你看到模式了吗？让我们试试这个！

for x in range(1,101):
    if (x % 2) == 1:
        print(x)

现在你知道如何在 for 循环中使用 if 语句了。同样，也可以在 if 循环中使用 for 语句。

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
1
3
5
7
.
.
.
93
95
97
99

嵌套 for 循环

您也可以在 for 循环中创建 for 循环。这些被称为嵌套 for 循环。为了演示嵌套循环是如何工作的，我将在本节末尾创建一个为每次迭代打印星号的模式，作为一个迷你项目。

但在我们开始之前，我想介绍一个印刷概念。你有没有注意到每个新的打印语句是如何写在新的一行中的？这是默认的。但是如果我们不想那样呢？如果我们希望下一条 print 语句与前一条语句在同一行，该怎么办？您可以使用" end = "语法来实现这一点。

print('Hello', end = " ")
print('there!')

如果您运行前面的代码行，您将得到以下结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
Hello there!

end = " "告诉您的 print 语句用一个空格结束 print 语句，并指示 IDLE 在空格后立即打印下一个 print 语句，而不是在新的一行中。

现在你知道了如何操作 print 语句，让我们回到嵌套循环。

实际上，语法非常简单。假设我想连续打印 123 个数字，一个接一个，重复十次。因此，外部循环的范围为(1，11)，内部 for 循环的范围为(1，4)，print 语句只出现在内部 for 循环中，因为我们只需要打印出 1、2 和 3。我们来测试一下，好吗？

for x in range(1,11):
    for i in range(1,4):
        print(i, end = "")

在前面的代码行中，我没有在 end =后面加空格，因为我希望 1、2 和 3 一个接一个地打印出来。另一方面，如果我给出这样的结果:end = "，那么我会在每一行得到 1，2，3 这样的结果。你可以随心所欲地设计这个。尝试使用其他特殊字符来操纵结果。

当我运行前面的代码时，我得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
123123123123123123123123123123

哎呀，出问题了！那是什么？好吧，我们从来没有打破界限，不是吗？我们需要在每一行都写完之后这样做，这样我们就可以在下一行重复同样的事情，我说的对吗？让我来。

Python 中有一段代码可以让您创建一个新行。它叫做\n，它类似于我们在想把单引号和双引号排除在代码之外时使用的反斜杠，还记得吗？所以我只需要在内部 for 循环结束后添加另一行代码。

for x in range(1,6):
    for i in range(1,4):
        print(i, end = "")
    print("\n")

你看到凹痕了吗？第一个打印语句在内部 for 循环中，第二个打印语句在外部 for 循环中。缩进会影响 Python 代码的成败，所以要非常小心，好吗？如果我在第一行的同一行写第二个 print 语句，那么 Python 会认为我想要在每个数字都被打印出来之后，而不是在每一行都被打印出来之后再写一行。那就完全不同了，不是吗？

当我运行前面的代码时，我得到了这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
123

123

123

123

123

或者，您可以用一个空的 print()结束外部的 for 循环，您将得到一个新行，因为默认情况下 print 语句会生成新行。

迭代字符串

与“while”循环相比，for 循环的优点在于它们迭代的是事物，而不仅仅是数字范围。例如，您可以迭代字符串中的每个字母。你想尝尝吗？

让我创建一个变量“a ”,并在其中放置一个字符串“Hello there”。然后，我将使用相同的语法，但这一次，我将只提到“a”，它包含字符串，而不是范围。

a = 'Hello there!'
for x in a:
    print(x)

让我们看看我们得到了什么:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
H
e
l
l
o

t
h
e
r
e
!

看那个！每一行都印上了每个字符。很整洁，是吧？想想像这样强大的东西的所有可能性！

While 循环

既然您已经彻底探索了“for”循环，而“循环是小菜一碟，相信我。与 for 循环不同，while 循环会一直执行循环中的语句，只要条件为真。还记得你的“如果”声明吗？与此类似，但这里有一个额外的迭代元素。

语法非常简单:

initialize
while condition:
    lines of code
    increment

语法有点混乱，不是吗？我举个例子解释一下。实际上，它类似于 for 循环，只是稍微长一点。在 for 循环中，我们给出一个范围。假设我们的范围从 1 开始，那么在我们的“while”循环中，我们需要用范围的开始来初始化我们的临时变量，如下所示:

x = 1

然后，我们需要条件。假设我们希望范围在 11 处结束，这意味着它需要从 1 迭代到 10，因此我们可以给出这样的条件:

while x < 11:

或者，你也可以让你的条件 x <= 10。你可以自由地用你的“while”循环来做这件事。

最后，你需要你的代码行。它可以是任何东西，真的，它可以是任何数量的语句行。但是就像你的“for”循环一样，内部代码行需要在缩进之后。

这是我们目前掌握的情况:

x = 1
while x < 11:
    print(x)

但是如果我们在这里结束循环，我们会创建一个永无止境的循环。“x”将始终为 1，并且将始终小于 11，因此条件将始终为真，循环将永远不会停止执行。那很危险。所以我们需要循环在某一点停止，对吗？这就是增量的来源。用你想要的任何数字增加 x，所以在某一点，循环结束。

这是我们最后的代码:

x = 1
while x < 11:
    print(x)
    x += 1

让我们运行前面的代码:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
1
2
3
4
5
6
7
8
9
10

完美！

中止任务！中断并继续

打破，然后继续。不难猜到这些是做什么的，是吗？“break”语句中断循环，不管您的范围或条件是否为真。

for x in range(1,11):
    if(x == 5):
        break
    print(x)
print('Loop broke :(')

在前面的代码行中，我在中间劫持了我的 for 循环。当 x 为 5 时，我要求循环中断，执行行将立即跳转到循环后的行，这是打印“循环中断了☹".”的打印语句让我们测试一下这是否可行。

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
1
2
3
4
Loop broke :(

看那个。我甚至没有得到 5 分，因为我的 break 语句在我的 print 语句之上。☹:这就是“休息”的方式。

但是，另一方面,“continue”语句只是跳过特定的迭代，仍然执行其余的迭代。这次我们为什么不用 while 循环来测试呢？让我们用同样的例子，但是这一次，当 x 为 5 时，我想要一个 continue。

x = 1
while x < 11:
    if x == 5:
        x += 1
        continue
    print(x)
    x += 1
print('5 was skipped!')

仔细阅读前面的代码行。你注意到什么了吗？我在 continue 语句之前包含了另一个 increment 语句。为什么？还记得我告诉过你我们需要小心 while 循环中的无限循环吗？如果我继续循环，那么 x 会一直停留在 5，因为在每次迭代中，我的程序会检查 x 是否为 5，它会一直为真，因为增量不会发生。所以虽然循环可能很棘手。小心点。

让我们运行我们的代码:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\numbers.py
1
2
3
4
6
7
8
9
10
5 was skipped!

是的，的确如此。5 被跳过！

你现在是循环专家了。恭喜你自己！

迷你项目-猜数字游戏版本 2

我们将再次尝试上一章的“猜数字”游戏，但这一次，我们将引入自动化的魔力。

像往常一样，用户可以试三次，但每次失败时，他们都会得到一个提示，告诉他们自己的猜测是高于还是低于要猜测的数字:

1. 让我们先导入 random 模块，因为我们将从中生成要猜测的数字。

2. 让我们打印出一条消息，然后在 1 到 10 的范围内生成一个随机整数(整数)。范围中的最后一个数字是 11，因为 randrange()不考虑这一点。

   print('Welcome to Guess a Number Game!')
   number = random.randrange(1,11)
   
   

3. 接下来，让我们创建一个运行三次迭代的 for 循环(范围为 1，4，从 1 到 3)。对于每次迭代，要求用户输入一个 1 到 10 之间的数字。获取输入，并将其转换为整数。

   for i in range(1,4):
       guess = input('Enter a number between 1 and 10: ')
       guess = int(guess)
   
   

4. 一旦进入，我们将开始我们的比较。首先，我需要检查最后一次迭代，因为如果我们已经到了最后一次尝试，他们仍然没有猜对，我们需要停止游戏。那么，让我们检查一下“I”的值是否为 3，猜测是否仍然不对。打印一条“对不起”的信息，告诉他们号码是多少。

   if(i == 3 and number != guess):
       print('Sorry! You used up all your tries! :(')
       print('The number was {}'.format(number))
   
   

5. 但是，如果他们在最后一次尝试中猜对了，那么打印成功消息。

   elif(i == 3 and number == guess):
       print('You guessed it right! :)')
   
   

6. 现在我们已经完成了检查，让我们创建一个“else”语句来包含前两次尝试的代码。

import random

对于前两次尝试，检查当前猜测是否是错误的。如果是，那么在检查“猜测”是小于还是大于要猜测的数字之后，打印一条消息。如果他们在任何一次尝试中都猜对了，那么打印一条成功消息并中断 for 循环，因为我们不需要更多的迭代。

如果在第三次迭代中，你不需要“break”语句，因为这将是循环的最后一次迭代。

else:
    if(number != guess):
        if(guess < number):
            print('You guessed a lesser number. Try higher.')
        else:
            print('You guessed a higher number. Try lower.')
    else:
        print('You guessed it right! :)')
        break

就这样！很简单，不是吗？让我们看看它现在是否工作。

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\condition.py
Welcome to Guess a Number Game!
Enter a number between 1 and 10: 10
You guessed a higher number. Try lower.
Enter a number between 1 and 10: 5
You guessed a higher number. Try lower.
Enter a number between 1 and 10: 3
You guessed it right! :)

我最后一次猜对了。咻！

有趣的小游戏，你不觉得吗？和朋友一起试试吧！根据需要增加或减少尝试次数或范围。为此疯狂吧！？IndexRangeEnd ID="ITerm14 "？>

迷你项目-自动化您的广场

这将是一个简单的项目。我们将在 Turtle 中自动化我们的 square。

我要创建一个 for 循环。我将范围设为 1:5，这样它会迭代四次来绘制正方形的四条边。我将在整个循环中重复向前 100 点和向右 90 度。

import turtle
s = turtle.getscreen()
t = turtle.Turtle()
t.pensize(5)
t.color('Red','Green')
t.begin_fill()
for x in range(1,5):
    t.forward(100)
    t.right(90)
t.end_fill()
t.hideturtle()
turtle.hideturtle()

让我们运行前面的代码。看那个！我们有我们的正方形(图 10-2 )，我们只写了之前写的几行的一小部分。

图 10-2

自动化广场

迷你项目-自动化任何基本形状

在这个项目中，我们将自动化我们给程序的任何形状。所以，你只要输入边数和边的角度，你的程序就会为你画出相关的形状。很酷，对吧？我们开始吧！

图 10-3

四边和 90 度角-正方形

1. 我们先设置一下 turtle。

   import turtle
   s = turtle.getscreen()
   t = turtle.Turtle()
   
   

2. 我打算把笔的尺寸设为 5，这样我们的形状看起来会更好。我们的钢笔的颜色将是蓝色，形状的填充颜色将是橙色。

   t.pensize(5)
   t.color('Blue','Orange')
   
   

3. 接下来，让我获取边数和角度作为输入，并将其转换为整数。

   sides = input("How many sides does your shape have?")
   sides = int(sides)
   angle = input("What's the angle between the sides?")
   angle = int(angle)
   
   

4. 现在，让我们开始画画。从 begin_fill 开始，然后打开一个从 0 到 sides–1 的 for 循环(给 0，sides 作为范围)。这意味着，如果 sides 的值为 5，循环将运行五次，并将为循环的每次迭代绘制一条边。

   t.begin_fill()
   for x in range(0,sides):
   
   

5. 在 for 循环中，让我们创建一个“if”语句来检查我们是否到达了最后一面。如果有，那么我们将把笔带回家(0，0)并打破循环。

   if(x == sides-1):
       t.home()
       break
   
   

6. 在余下的迭代中，我们将把笔向前推 100 点，并以给定的角度将笔的方向改为正确的方向。

   t.forward(100)
   t.right(angle)
   
   

7. “for”循环到此结束。让我们通过结束填充和隐藏海龟来结束这个程序。

   t.end_fill()
   t.hideturtle()
   turtle.hideturtle()
   
   

8. Let’s give our inputs as 4 and 90:

   = RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\drawTurtle.py
   How many sides does your shape have? 4
   What's the angle between the sides? 90
   
   

   输入输出后，单击 Enter。查看turtle屏幕，您将看到如图 10-3 所示的图像。

那是一个正方形！

1. 现在，3 和 60(图 10-4 ):

   = RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\drawTurtle.py
   
   

你的形状有几条边？3

两边之间的角度是多少？60

图 10-4

边 3 和角 60——三角形

一个等边三角形！

1. 现在，6 和 60(图 10-5 ):

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\drawTurtle.py

你的形状有几条边？6

两边之间的角度是多少？60

图 10-5

六边形和 60 度角-六边形

六边形，不错！

尝试用 5 和 60 得到五边形，用 8 和 45 得到八边形，用不同的值做实验，看看你得到了什么。玩得开心！

迷你项目-自动绘制曼荼罗设计

在这个项目中，我们将自动绘制一个合适的曼荼罗设计。很简单，你会明白的！

1. 我们先设置一下 turtle。

   import turtle
   s = turtle.getscreen()
   t = turtle.Turtle()
   
   

2. 我要把笔的速度设为 0，这样它就能画得很快。笔的大小是 5，笔的颜色是红色。

   t.speed(0)
   t.pensize(5)
   t.pencolor('Red')
   
   

3. 接下来，让我们打开一个 for 循环，我准备让它循环 7 次(范围 0，7)。现在，我已经通过反复试验得出了这个 for 循环中的所有值。你可以随心所欲地改变它们，看看你会得到什么，好吗？

4. 在 for 循环的每次迭代中，我都要画一个 100 点的圆，然后左转 50 度。

   t.circle(100)
   t.left(50)
   
   

5. 就这样！如果你现在运行这个程序，你会看到你的曼荼罗设计。但是我们为什么不更进一步，在设计里面画一个圆呢？将钢笔大小更改为 7，转到位置–10，–50(通过试错找到)，将钢笔颜色更改为蓝色，绘制半径为 50 的圆。最后，把乌龟藏起来。

   t.pensize(7)
   t.penup()
   t.goto(-10,-50)
   t.pendown()
   t.pencolor('Blue')
   t.circle(50)
   t.hideturtle()
   turtle.hideturtle()
   
   

for i in range(0,7):

运行前面的代码，你会得到这个(图 10-6 )。

图 10-6

简单的循环曼荼罗设计

那看起来很漂亮！尝试改变值和颜色，看看你会得到什么。

迷你项目-弧形螺旋

在这个项目中，我们将演示 Python 中的 setheading()方法。我们要画圆弧螺线！你会明白的。

1. 让我们先设置一下turtle。

   import turtle
   s = turtle.getscreen()
   t = turtle.Turtle()
   
   

2. 首先，我将把当前的标题(方向)打印到 Shell。当我们开始的时候你会看到它是 0。让我们也改变笔的大小为 5 和速度为 5，所以它画得有点快。

   print(t.heading())
   t.pensize(5)
   t.speed(5)
   
   

3. 我要把起始角度设为 0。

4. 然后，我将打开一个运行 12 次的 for 循环，因为我想展示圆弧中一个圆的 12 个角。

angle = 0

图 10-8

四分之一圆螺旋

1. 每次循环运行，我都会画一个半径为 100 的半圆。在半圆的末端，我会写下当前的方向。然后我会把我的笔移回到起点，这样它就为下一个弧做好了准备。

   t.circle(100,180)
   t.write(t.heading())
   t.penup()
   t.home()
   t.pendown()
   
   

2. 最后，我将在循环的每次迭代中增加 30°的角度，并将航向设置为那个特定的角度。

   angle += 30
   t.setheading(angle)
   
   

3. Run the preceding code, and you’ll get this (Figure 10-7).

   

   图 10-7

   半圆螺旋

4. 将圆的角度改为 90 度画四分之一圆(圆弧)，就得到这个(图 10-8 )。

for i in range(12):

如果你愿意，你可以删除文字，在所有的东西上画一个圈，并且使它也成为一个新的曼荼罗设计！

摘要

在这一章中，我们学习了如何通过使用循环在你的程序中实现入门级的自动化。我们学习了 for 循环、while 循环和 ranges，以及如何用 break 和 continue 语句操作循环。我们也用本章学到的概念创建了许多迷你项目。

在下一章，让我们看看如何用 Python 的内置数据结构在一个变量中存储多个值和不同种类的值。

十一、很多很多的信息！

在前一章中，我们学习了所有关于用 for 和 while 循环自动化代码的知识。我们还查看了 break 和 continue 语句，并创建了许多丰富多彩的迷你项目。

在这一理论密集的章节中，让我们看看 Python 提供的各种内置数据结构。让我们看看如何使用这些数据结构在单个变量中一次存储多个值，并看看在现实世界的程序中使用这些数据结构的实际例子。

存储多个值

到目前为止，我们只是一次存储一个值。当然，我们可以改变值，但是我们不能在同一个地方存储两个值。那不是有点不方便吗？假设我想存储六个不同的颜色值，这样我就可以在我的代码中一个接一个地使用它们。

我该怎么做？我可能会这样做:

color1 = 'Red'
color2 = 'Orange'
color3 = 'Blue'
color4 = 'Yellow'
color5 = 'Green'
color6 = 'Violet'

然后，每当我想在代码中使用这些值时，我就必须记住并引用它们。哇…这是一个漫长的过程。

如果我能把所有六种颜色存储在同一个地方，同一个变量里，会怎么样？它看起来有点像图 11-1 。

图 11-1

同一变量中有多个值

这在 Python 中叫做 数据结构 。看看数据是如何构造(组织)和存储的？因此得名。有四种这样的预制数据结构可用于在同一位置存储多个值。您节省了许多代码行和时间，并且您的代码也更加高效。您也可以存储不同类型的数据。同一个数据结构可以存储字符串、数字和布尔值。

访问这些数据也很容易。在访问字符串中的单个字符时，你只需要遵循和我们使用的格式相似的格式。我一会儿会谈到这一点。

让我先向您展示四种数据结构:

• 列表 : Python 确实是一门简单易学的语言，不是吗？这种语言使用的关键字非常容易记忆。名单就是这样。这是一个信息列表，不过是 点了 。列表中的单个值可以被 改变 ，并且列表中的 允许其中有重复值 。

• 元组:元组类似于列表。唯一的区别是 的值一旦固定 就不能更改。这意味着您也不能添加或删除值。

• 集合:集合不同于元组的列表，是 无序的 ，没有索引可以从中访问特定的值。它 也不允许重复的值 ，因为这些值是无序的。

• 字典:顾名思义，字典将值以 字:描述 格式存储。字典也是无序的，但是它们可以改变，在 Python 中被称为“键”的“单词”充当索引，通过它可以访问值(描述)。

你现在可能正眯着眼睛看这本书。完全不用担心。乍一看，这些数据结构令人生畏。他们绝对不是。我将在下一节用有趣且容易理解的例子来解释它们，你很快就会明白所有的事情。

列表

让我们先来看看列表。创建它们非常容易。用逗号分隔要存储在列表中的多个值，并用方括号([])将所有内容括起来，这样就有了一个列表。你想尝尝吗？

让我们把前面例子中写的六行代码转换成一个列表，好吗？

colors = ['Red', 'Orange', 'Blue', 'Yellow', 'Green', 'Violet']

前面的例子中只有字符串(因此有引号)，但是您可以创建一个只有数字的列表，或者只有布尔值，或者两个或更多的组合。根据你的需要创造你想要的东西。

你现在可能正眯着眼睛看这本书。一点也不担心。乍一看，这些数据结构令人生畏。他们绝对不是。我会轻松有趣地解释它们:

a = [1, 'Hello', True, False, 34.5, '*']

前面的代码是异类值(不同数据类型)的列表。

访问列表中的值

好，我们有一个值列表。我们如何访问它们？你想猜猜吗？你已经知道了。

是的，有索引，就像我们对琴弦做的那样。列表中第一个值的索引为 0，第二个值的索引为 1，依此类推。

假设我想在列表“a”中访问并打印第三个值。它在索引 2 处。

print(a[2])

运行前面的代码，您将得到这样的结果:

= RESTART: C:/Users/aarthi/AppData/Local/Programs/Python/Python38-32/dataStructures.py
True

成功访问！

你可以做负索引，就像你对字符串做的那样。因此，要访问列表中的最后一个元素(值),我只需给出-1。

print(a[-1])

运行前面的代码，您将得到这样的结果:

= RESTART: C:/Users/aarthi/AppData/Local/Programs/Python/Python38-32/dataStructures.py
*

有效！耶！

切一个单子！

如果负索引和访问有效，就像字符串一样，那么使用范围提取列表的一部分也应该有效，对吗？我们来测试一下。

假设我想提取第二个到第五个值，索引为 1 到 4。我的范围应该是 1:5，因为范围中的最后一个数字不包括在内。

print(a[1:5])
['Hello', True, False, 34.5]

哦，是的，它起作用了！那么通过负指数提取应该也可以，对吗？假设我想要从负的第三个索引中提取所有内容。

print(a[-6:-3])

你已经知道负指数是如何工作的了，对吗？如果我运行前面的代码，我会得到这样的结果:

[1, 'Hello', True]

您也可以更改值。假设我想将第二个值(字符串)改为一个数字。然后，我必须访问第二个值(第一个索引),并给它赋值。

a[1] = 100
print(a)

让我们打印整个列表，看看现在发生了什么变化:

= RESTART: C:/Users/aarthi/AppData/Local/Programs/Python/Python38-32/dataStructures.py
[1, 100, True, False, 34.5, '*']

列表操作着火了！

您有许多预定义的方法，可以用来以多种方式操作您的列表。还记得我们在你的琴弦上看到的方法吗？你会发现其中一些在这里也重复了。你准备好玩你的列表了吗？没错。

像往常一样，您可以使用 len()方法找到字符串的长度:

a = [1, 'Hello', True, False, 34.5, '*']
print(len(a))

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
6

没错。我们的列表长度是 6。有效。

对于我们将在本章中学习的每一种数据结构，你都有一个完整的方法列表。因此，我将把你链接到 Python 文档中的页面，那里列出了所有这些方法及其解释。

就是这里: https://docs.python.org/3/tutorial/datastructures.html 。

也就是说，让我们看看本章中一些最重要的方法，好吗？

复制并追加

append()方法在列表末尾追加或添加一个元素:

 a.append('new')
print(a)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[1, 'Hello', True, False, 34.5, '*', 'new']

copy 方法创建列表的副本，该副本可以赋给任何变量以创建复制的列表:

b = a.copy()
print("List b contains: {}".format(b))

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
List b contains: [1, 'Hello', True, False, 34.5, '*', 'new']

清点并清除

列表可以有重复的值，对吗？假设我们有一个数字列表，其中的数字是重复的，我想检查一个特定的数字在列表中出现了多少次。我可以使用“计数”方法来实现这一点。

l = [1,2,1,1,4,5,3,5,3,2]
print(l.count(1))

我以列表名“l”开始语法，然后是方法名“count”，然后我提到了我想要计数的值(1)。如果它是一个字符串，我会用引号引起来。让我们运行前面的代码，我们将得到这个:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
3

我们得到了正确的答案！数字 1 在列表中出现了三次。

您可以使用“清除”方法清除整个列表。

l.clear()
print(l)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[]

我们现在有一个空名单了！

串联

您可以使用“extend”方法来连接或联接两个列表。

list1 = [1,2,3,4,5]
list2 = [6,7,8,9]
list1.extend(list2)
print(list1)

正如您在前面的代码中看到的，您希望首先列出的列表元素排在最前面，然后是句点(".")，然后是“extend”方法，然后在括号内，您可以提到您想要加入第一个列表的列表的名称。

让我们运行前面的代码，我们将得到这个:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[1, 2, 3, 4, 5, 6, 7, 8, 9]

看那个！完美地结合在一起，并且按照我们想要的顺序。

在您的列表中搜索

“index”方法返回您正在搜索的值的第一个实例的索引。例如，如果您想在一个列表中查找数字 3，但是它重复了两次，那么只返回第一次出现的数字 3 的索引。让我举个例子:

list1 = [1,2,3,2,3,1,3]
print(list1.index(3))

当您运行前面的代码时，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
2

看那个！3 在列表中出现了三次，但我们只得到前 3 个的索引。太好了。

但是如果你愿意，你可以缩小搜索范围。如果我想在列表的后半部分找到 3，也许从第三个索引开始呢？您也可以将搜索的开始和结束指定为参数。让我告诉你怎么做:

print(list1.index(3,3,6))

我让我的程序从索引 3 到 5 中搜索 3。你知道这些东西是怎么运作的吧？该范围中的最后一个值将不包括在内。所以，如果最后一个值是 5，那么你的程序只会搜索到第五个索引。

当我运行前面的代码时，我会得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
4

看那个！我们得到了列表中 3 的第二个实例的索引。很好！

添加和删除元素

您知道如何使用方括号将元素添加到列表中，也可以使用相同的方法更改元素。但是，如果我想在列表中间插入元素，以便其他值仍然存在，但只是进一步移动，该怎么办呢？

您可以使用 insert 方法来实现这一点。方法中的第一个参数是您想要值的位置，第二个参数是您想要添加的值。

colors = ['Red', 'Orange', 'Blue']
colors.insert(1,'Green')
print(colors)

我在第一个索引中添加了值“Green”。现在‘桔子’应该再推一步。让我们检查一下，好吗？

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
['Red', 'Green', 'Orange', 'Blue']

是的，成功了！

默认情况下，pop()方法删除列表中的最后一个元素。如果你给了一个位置(索引),它会移除那个位置的元素。

让我们尝试删除前面列表中的第二个元素，也就是我们刚刚插入的元素，好吗？

colors.pop(1)
print(colors)

当我们运行整个代码时，我们会得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
['Red', 'Green', 'Orange', 'Blue']
['Red', 'Orange', 'Blue']

看那个！列表最初有四个元素，我们使用 pop()方法成功地删除了第二个元素。

或者，您也可以使用 remove()方法。唯一的区别是您可以指定想要删除的确切元素。

我们的列表目前有['红色'，'橙色'，'蓝色']。我不想要蓝色了。为什么我们不试着移除它？

colors.remove('Blue')
print(colors)

让我们看看它是否有效:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
['Red', 'Orange']

耶！成功了。

有点太长了，不是吗？别担心！我们快完成了。那就用一个有趣的小项目来分散我们的注意力，好吗？

反转和排序

还有一种方法叫做 reverse()方法。你能猜出它是做什么的吗？没错。它反转列表中的元素。我们试试吧！

li = [1,2,3,4,5]
li.reverse()
print(li)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[5, 4, 3, 2, 1]

成功！

最后(是的，最后)，还有另一个方法叫做 sort()方法，它按照字母顺序对元素进行排序。

默认情况下，排序按升序进行。

colors = ['Red', 'Orange', 'Blue', 'Yellow', 'Green', 'Violet']
colors.sort()
print(colors)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
['Blue', 'Green', 'Orange', 'Red', 'Violet', 'Yellow']

就像魔法一样！O:

这适用于数字吗？

li = [1,4,3,6,2,8,7,9,5]
li.sort()
print(li)

当您运行上面的代码时，您会得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[1, 2, 3, 4, 5, 6, 7, 8, 9]

呵呵，管用。

但是如果我想按降序排序呢？在这种情况下，我将修改 sort()函数调用，如下所示:

li.sort(reverse=True)
print(li)

当您给定参数 reverse=True 时，您的程序将按降序对列表进行排序。默认值是 reverse=False，它按升序对列表进行排序。默认某件事发生的时候，不需要作为论据来提。

让我们运行前面的代码，我们将得到这个:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[9, 8, 7, 6, 5, 4, 3, 2, 1]

很好…我的列表现在是降序排列。Python 让我们几乎可以做任何事情，不是吗？

列表更有趣！

您可以使用“in”关键字检查列表中是否存在某些内容:

print('Hello' in a)

在前面的代码行中，我们询问了字符串“Hello”是否是列表的一部分。

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
False

结果是假的。我们将第二个值从“Hello”更改为 100，还记得吗？所以，“你好”不再是列表的一部分。与 Python 中的所有内容一样，这些搜索也是区分大小写的。所以，“你好”不同于“你好”，如果字符串是“你好！”，那么你需要搜索整个东西。部分搜索不起作用。让我展示给你看:

a[1] = 'Hello there!'
print('Hello' in a)

我已经将第二个值更改为“Hello there！”，当我在列表“a”中搜索“Hello”时，让我看看我得到了什么:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
False

看那个。它仍然是假的，因为你没有用正确的词搜索。

现在你知道列表是如何工作的了，我想回到之前的话题。还记得“for”循环吗？记住我的承诺，当我教你关于列表的时候，我会重温 for 循环。我们现在在这里！

您可以使用 for 循环遍历列表。很简单。只需创建您的列表，然后将其替换为一个范围，如下所示:

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

结果是这样的:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
1
2
3
4
5

或者，您也可以直接指定列表，如下所示:

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

用前面的代码行修改并运行您的代码，您会注意到您会得到相同的结果。

除了“extend”方法之外，您还可以使用“+”运算符连接两个列表，就像您处理字符串一样，如下所示:

list1 = [1,2,3,4,5]
list2 = [6,7,8,9]
list1 += list2
print(list1)

或者，您可以创建一个新变量，并将 list1 + list2 的值赋给它。两个都行。

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[1, 2, 3, 4, 5, 6, 7, 8, 9]

“clear”方法只是清除列表。但是如果你使用“del”关键字，你可以删除整个列表。你想要检查吗？

让我们删除前面的列表，好吗？

del list1
print(list1)

当我尝试在删除 list1 后打印它时，我会得到一个错误，如下所示:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
Traceback (most recent call last):
  File "C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py", line 10, in <module>
    print(list1)
NameError: name 'list1' is not defined

看那个！“列表 1”已经完全从我们的程序中删除了。

您也可以对列表中的元素进行同样的操作。

a = [1, 'Hello', True, False, 34.5, '*']
del a[2]
print(a)

我已经让我的程序删除了列表中的第三个元素。让我们打印，我们会得到这个:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
[1, 'Hello', False, 34.5, '*']

第三个值“True”不再存在于列表“a”中。

迷你项目——多色自动星形

在这个项目中，我要用 Python 画一个星星，但是每一面都要有不同的颜色。这就是我的清单出现的地方。我将创建一个包含五种颜色的列表，并在其中运行一个 for 循环。对于 For 循环的每一次迭代， Turtle 都会用列表中的新颜色画出星星的一边。

让我们看看是怎么做的，好吗？

1. 我将从设置 Turtle 的常用代码行开始:

2. 我将设置笔的大小为 5，这样我的图像看起来很好。

import turtle
s = turtle.getscreen()
t = turtle.Turtle()

1. 接下来，我将创建一个名为“colors”的变量，并为它分配一个由五种颜色组成的列表，“红色”、“棕色”、“绿色”、“蓝色”和“橙色”。我已经给了你一个颜色列表的链接，所以选择你喜欢的颜色。

t.pensize(5)

1. 接下来，我将创建一个临时变量 x，它通过 for 循环遍历整个列表:

colors = ['Red', 'Brown', 'Green', 'Blue', 'Orange']

1. 对于循环的每一次迭代，我的笔的颜色都会变成临时变量“x”中的当前颜色。我会让我的turtle向前移动 200 点，然后右转 144 点，因为一颗星星的外角是 144 度，我需要转那么多才能得到一颗合适的星星。

for x in colors:

1. 这结束了我的 for 循环和缩进。最后，我要把我的乌龟藏起来。

t.pencolor(x)
t.forward(200)
t.right(144)

t.hideturtle()
turtle.hideturtle()

当你运行前面的代码时，你会得到这个(图 11-2 )。

图 11-2

多色星

没错。我们拿到了。为什么不试试不同颜色或不同形状的呢？或者，你可以尝试在每次迭代中随机选择颜色？你已经知道怎么做了(我已经教过你了)，所以继续尝试吧。

元组

现在我们已经详细地看了列表，你会发现剩下的三个数据结构很容易理解，所以我将快速地浏览它们，好吗？

正如我之前提到的，元组类似于列表。唯一的区别是，它是有序的(就像一个列表，有索引和所有)，但不可改变的(不像一个列表)。这对我们意味着什么？这只是意味着你不能添加、删除或改变列表中的元素。

现在这是一个扫兴的人！这是否意味着元组没有列表酷？确切地说，我不会这么说。你知道，你可能需要创建一个列表，你不希望任何人以后操纵，我说的对吗？类似于“只读”列表？在这些情况下，元组是您最好的朋友。否则，100%去做一个列表。

您可以创建带括号的元组，元组项用逗号分隔，如下所示:

t1 = ('Red', True, 2, 5.0)
print(t1)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
('Red', True, 2, 5.0)

元组中的大多数内容都遵循与列表相同的格式，所以我只列出它们，我希望你们在自己的计算机上尝试一下。这是我们的小活动，好吗？

就像处理列表一样，可以用方括号访问元组中的元素。

t1[1]将返回第二个元素，True。元组就像列表一样被索引，其中第一个索引是 0。

就像列表一样，可以使用负索引来访问元组中的值。因此，t1[–1]将返回列表中的最后一个元素。

您也可以使用索引对元组进行切片。

如果您想要提取第二个到第四个值(最后一个)，那么您可以指定 t1[1:4])或者只指定 t1[1:]，因为我们无论如何都想要第一个索引中的所有内容。

如果你想用负索引写同样的东西，你可以这样做:t1[–3:]因为你想要从–3 到元组末尾的所有东西。

可以使用 len(t1)方法获得元组的长度，并使用“in”关键字检查元组中是否有内容，就像处理列表一样。你为什么不试试看？

然后是你的“for”循环。您也可以循环遍历元组。过程是一样的。

for x in t1:
    print(x)

为什么不运行前面的代码，检查循环是否适用于元组？

到目前为止，元组看起来像写在括号内的列表。他们到底有什么用？还记得我说过元组是不可改变的吗？我们还没有尝试过改变元素或者添加元素到我们的元组中，不是吗？让我们试试。

我将尝试将第二个元素的值从 False 改为 True。

t1[1] = False

让我们运行我们的代码，我们会得到这个:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
Traceback (most recent call last):
  File "C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py", line 4, in <module>
    t1[1] = False
TypeError: 'tuple' object does not support item assignment

糟糕，我们出错了！元组不支持项赋值，这意味着它们的元素不能被改变。

尝试向元组添加新元素。访问第四个索引(第五个元素)并添加一些内容。当你这样做的时候，你会发现你遇到了同样的错误。

这是元组最重要的用途。您可以创建不可更改的列表，用于存储不应更改的敏感信息。如果你创建一个程序来存储你同学的身份证号码会怎么样？你不想改变这些，是吗？然后将它们存储在一个元组中。就这么简单！

但是，就像在您的列表中一样，您可以使用“del”关键字删除整个元组，就像这样:

del t1

如果你现在尝试访问 t1，你会得到一个错误。

元组也有方法，但是它们只有很少的方法可以用来访问元素，而且没有方法可以操作元素或元组本身。

“count”方法返回一个值在元组中重复的次数。记住，元组可以有重复的值，就像列表一样。

“index”方法返回元组中值的位置(索引)。

t1 = ('Red', True, 2, 5.0)
print(t1.index(5.0))

当您运行前面的代码时，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
3

没错。5.0 在第三个索引中(第四个位置)。

tuple 到此为止。很简单，不是吗？接下来让我们看看列表中的下一个数据结构。

设置

你还记得我跟你说过的关于布景的事吗？它们是无序的，不能有重复的值。真是祸不单行。但是电视也有其用途。你想看看吗？

太好了。你在花括号里写集合，像这样:

colors = {'Red', 'Orange', 'Blue'}

前面的代码是一组颜色“红色”、“橙色”和“蓝色”。

但是！集合是无序的。那么，这些价值真的会像我们创造的那样出现吗？你想要检查吗？

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'Blue', 'Orange', 'Red'}

哇，看那个！顺序变了。你能再运行一次程序并告诉我你得到了什么吗？

顺序又变了，不是吗？这有多酷？

但是我们现在确实有一个问题。集合是无序的。那么，如果我们不知道索引，我们如何访问元素呢？我们如何向集合中添加元素？我们如何在特定的位置插入元素？不幸的是，有些事情你不能用集合来做，任何与秩序相关的事情都属于集合。

所以，你不能用方括号来寻找一个特定位置的元素。但是，您可以使用“in”关键字来检查某个元素是否存在于集合中:

print('Red' in colors)

运行前面的代码，你会得到真。

你也可以遍历集合，就像你处理列表和元组一样。

for i in colors:
    print(i)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
Orange
Blue
Red

但是在不知道索引的情况下，如何向集合中添加元素呢？有一个 add()方法可以用来添加单个元素，尽管您不知道它们最终会出现在哪里。

colors.add('Green')
print(colors)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'Blue', 'Green', 'Orange', 'Red'}

多有趣啊。我们在布景中加入了“绿色”，它最终出现在第二个位置。再次运行程序，你会在别的地方找到它。

如果我想向我的颜色集中添加多种颜色，该怎么办？我可以通过使用“update()”方法来节省空间。

在方括号内创建一个值列表，并将其放在括号内。让我尝试将“绿色”和“黄色”都添加到我的集合中:

colors.update(['Green','Yellow'])
print(colors)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'Red', 'Yellow', 'Blue', 'Orange', 'Green'}

看看绿色和黄色的结局。:D

就像列表一样，您也可以使用 len()方法来查找列表的长度。

现在，让我们看看操纵集合的其他方法，好吗？我将只列出与我们在列表中看到的相似的那些。

在列表中，pop()方法移除一个随机值，而不是最后一个值。您可以使用 remove()方法通过将特定值作为参数来移除它。

或者，也可以使用“discard()”方法删除特定的元素。discard 和 remove 之间的唯一区别是，如果提到的元素不存在，discard 不会引发错误。这在现实编程中很重要。当运行一个程序时，你不希望因为一行代码出错而导致程序停止执行。

clear()方法清除集合，copy()方法复制列表。

您可以使用“del”关键字删除整个集合，但不能使用它来删除特定的元素，因为它们没有您可以访问的固定索引。

最后，我们来看看连接集。您可以使用“union()”或“update()”方法连接两个集合。

colors = {'Red', 'Orange', 'Blue'}
colors1 = {'Green', 'Yellow'}

假设我们有两个集合，colors 和 colors1 有各自的值，我们希望将它们合并到 colors 集合中。

您可以使用 union()方法。它用两个集合中的值创建一个新集合。

colors2 = colors.union(colors1)
print(colors2)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'Yellow', 'Green', 'Red', 'Blue', 'Orange'}

但是 update 只是用两个集合中的值更新语法中的第一个集合。如果打印出语法中的第二组，您会注意到它没有变化。更新只是改变第一组。

colors.update(colors1)
print(colors)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'Orange', 'Yellow', 'Red', 'Blue', 'Green'}

我们也完成了布景。耶！你现在已经成为相当专业的 Python 程序员了。

字典

这个列表中的最后一个数据结构是字典。让我们快速完成它，然后回去做一些更有趣的迷你项目，你同意吗？是啊！

所以，字典是无序的，但是它们是有索引的，并且可以改变。我喜欢字典的一点是，它们可以用来模拟现实世界的东西。你想看吗？

字典也是在花括号内创建的，但是在花括号内，您需要提到 key:value 对中的值。这里的“关键”是索引。

因为我想让我的字典模拟真实世界的对象，所以我将创建一个代表一个人的特征的字典:他们的姓名、年龄、眼睛颜色、头发颜色等等。

我是这样做的:

person1 = {"name":"Susan","age":9,"pet":"Barky","hair":"black","eyes":"blue"}

我已经创建了一本字典“person1”。她的名字叫苏珊，她 9 岁了，她的宠物叫巴克利，她有黑色的头发和蓝色的眼睛。看起来很棒，不是吗？

现在，让我们来操作这本字典。您可以像这样使用“键”来访问值:

print(person1["name"])

或者

print(person1.get("name"))

记住，你必须在任何地方都用引号括起来。

运行这两行代码中的任何一行，您都会得到相同的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
Susan

她的名字！

您也可以更改值。苏珊实际上是 8 岁，不是 9 岁！快，让我们在她伤心之前纠正她的年龄！

person1["age"] = 8
print(person1)

运行这个程序，您将得到以下结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'name': 'Susan', 'age': 8, 'pet': 'Barky', 'hair': 'black', 'eyes': 'blue'}

很好！

您也可以用同样的方式添加一个新的键:值对。让我们添加一个键，性别，并使其为女性。

person1["gender"] = 'female'
print(person1)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'name': 'Susan', 'age': 9, 'pet': 'Barky', 'hair': 'black', 'eyes': 'blue', 'gender': 'female'}

这是添加的，耶！

您可以使用“in”关键字检查某个键是否存在。

print('pet' in person1)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
True

是的，“宠物”是字典的关键词之一。

就像往常一样，你可以使用“len”方法找到字典的长度。

以下将删除字典:

del person1

person1.clear()将字典清空。

您可以使用 copy()方法来复制字典。

像往常一样，您可以循环遍历字典，但是因为我们的字典有一个键和值，所以我们可以用不同的方式进行循环。

让我们先创建一个更小的字典:

person1 = {"name":"Susan","age":8}

让我们先遍历所有的键并打印出来:

for i in person1:
    print(i)

这应该会打印出所有的键:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
name
age

没错。

如果你想要这些值，只要改变“我”的位置，就像这样:

for i in person1:
    print(person1[i])

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
Susan
8

我们现在只得到值。喔！

或者，可以使用 items()方法循环访问键和值，如下所示:

for i,j in person1.items():
    print("{} = {}".format(i,j))

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
name = Susan
age = 8

很好！

在结束之前，我们再看最后一件事。pop()删除给定的 key:value 对，而 popitem()删除字典中的最后一项。

person1.pop("name")
print(person1)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'age': 8}

年龄是唯一剩下的关键！☹

让我们再次重写字典，这一次，尝试 popitem()。

person1.popitem()
print(person1)

运行前面的代码，您将得到这样的结果:

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
{'name': 'Susan'}

现在，‘名字’是唯一剩下的关键！

字典到此为止！

迷你项目——永不落幕的色彩

又一个简单的项目！我们将在 1 秒钟后随机改变背景颜色，同时在海龟屏幕上打印当前颜色。

扭曲？我们将使用一个名为“时间”的新包来使海龟屏幕在每次颜色变化之间暂停。准备好了吗？我们走吧！

1. 所以，就像我说的，我们需要“时间”和“海龟”模块。两个都导入吧。

   import time
   import turtle
   
   

2. 接下来，我们像往常一样设置 turtle。

   s = turtle.getscreen()
   t = turtle.Turtle()
   
   

3. 设置好之后，让我们将刚刚创建的笔移动到我们希望它书写颜色的位置。这就是重点——80，0。

   t.penup()
   t.goto(-80,0)
   t.pendown()
   
   

4. 现在，让我们创建一个颜色字典。这次我将创建一个字典而不是一个列表，因为我将使键的值(颜色)大写，这样我就可以把它们写在屏幕上。

   colors = {'RED':'Red', 'BROWN':'Brown', 'GREEN':'Green', 'BLUE':'Blue', 'ORANGE':'Orange'}
   
   

5. 在我们开始画画之前，让我们把乌龟藏起来。当你运行这个程序时，你就会明白为什么了。

   t.hideturtle()
   turtle.hideturtle()
   
   

6. 现在，有趣的部分来了。我们希望这个项目永无止境，记得吗？所以，很明显我们需要一个循环，但是什么样的循环呢？我们如何创建一个永无止境的循环？还记得我说过如果我们不小心的话,“while”循环可以永远运行下去吗？也就是说，如果条件没有在某一点变为假。

如果我们真的这么做了呢？如果我们让 while 循环的条件为“真”,那会怎么样？然后，如果在 while 循环中没有 break 语句，那么它将永远运行下去。

1. 简单！接下来，让我们创建一个 for 循环来遍历“颜色”字典。

#never ending loop
while True:

1. 对于每次迭代，让我们将海龟屏幕的背景色改为 For 循环中的下一种颜色(值)。另外，让我们用 Arial 字体，50 磅，粗体字来写键值(x)。

   turtle.bgcolor(colors[x])
   t.write(x,font=('Arial',50,'bold'))
   
   

2. 现在，在每次颜色变化之后，在下一次颜色变化(用于循环迭代)发生之前，我们需要 0.5 秒的延迟或间隙。这就是“时间”包的用武之地。它有一个名为 sleep()的内置函数，这个函数会在提到的秒数内暂停循环。在我们的例子中，它是 0.5。

for x in colors:

1. 好的，从技术上来说应该是这样，但是如果我们不去管它，那么你会注意到你的海龟在旧文本上写下一个文本，事情会继续变得混乱。你为什么不试试看？

time.sleep(0.5)

你的 turtle 包自带了一个 clear()函数，可以清空屏幕。那么，我们为什么不在改变下一种颜色和绘制下一个文本之前清空屏幕呢？

t.clear()

就这样！让我们现在运行这个，我们会得到这个(图 11-3 )。

图 11-3

永不落幕的颜色

你会注意到程序在“颜色”字典中无限循环。很甜蜜，是吧？

迷你项目-姓氏和名字颠倒

在这个项目中，这是我想要发生的:当我输入一个名字，例如，Susan Smith，我希望我的程序返回它的反转，即，Smith，Susan。

这与其说是一个迷你项目，不如说是一个难题。逻辑很简单:

1. 让我们通过获取名称作为输入来启动程序。条件是他们的名和姓需要用一个空格隔开。这很重要。你会明白为什么。

   name = input('Please Enter your first and last name, separated by a space: ')
   
   

2. 正如我所说的，字符串输入的格式对于程序的运行非常重要。所以，我要计算字符串中单个空格的个数。如果没有，或者不止一个，那么程序会停止并显示一条错误消息。

   让我们先创建一个变量 count，并将其赋值为 0。

3. 接下来，让我们创建一个 for 循环，遍历刚刚得到的字符串。只要有一个空格，我们就加 1 来计数。

   for i in name:
       if i == ' ':
           count += 1
   
   

4. 如果计数只有 1，那么我们就可以开始了。让我们使用 split 方法将字符串转换成列表，其中名字和姓氏被分隔成单独的列表项，使用单个空格作为分隔符。

   if count == 1:
       #Convert string to list, where the condition is the space
       l = name.split(' ')
   
   

5. 接下来，我们来倒排一下。

   #Reverse list
   l.reverse()
   
   

6. 最后，让我们在列表的第一个位置插入一个带空格的逗号，这样当我们连接所有内容时，我们就得到我们想要的确切格式。

   #Add a comma, with a space, in the first position of the list
   l.insert(1,', ')
   
   

7. 现在让我们用一个空字符串作为连接条件将列表连接成一个字符串。这样，所有的东西都粘在一起，唯一分隔姓和名的是“，”。

   #Join a list into a string
   name = ''.join(l)
   
   

8. 最后，打印所有内容。

count = 0

1. 如果计数不是 1，则打印一条错误消息。

   else:
       print('Please Enter your name in the correct format')
   
   

print('Your reversed name is: {}'.format(name))

现在，让我们运行程序！

= RESTART: C:\Users\aarthi\AppData\Local\Programs\Python\Python38-32\dataStructures.py
Please Enter your first and last name, separated by a space: Susan Smith
Your reversed name is: Smith, Susan

完美！

摘要

在本章中，我们深入探讨了 Python 提供的四种预定义数据结构，即列表、集合、元组和字典。我们研究了如何创建、删除、操作它们，等等。最后，我们看了如何在程序中使用它们，以及为什么它们在真实的编程场景中有用。

在下一章中，让我们暂时放下所有的学习，开始创作吧！我们将创建许多迷你项目。