自学Python之Udacity28天入门课程笔记

第一节小乌龟和第一行代码

import turtle
fred = turtle.Turtle()
fred.color(“red”)
fred.forward(100)
fred.right(135)
fred.forward(140)
fred.right(135)
fred.forward(100)
你可能根本不知道这段代码的含义是什么，完全没关系！在下面的几个页面中，你将尝试该代码，以便知道它的原理。

将这段代码粘贴到 workspace 中之后，点击运行按钮。

你在上面粘贴的代码行是一个程序 — 让计算机去执行的一组指令。在此示例中，该程序告诉计算机在屏幕上画一个三角形。

术语：程序是面向计算机的一组指令。程序由代码行组成。每行告诉计算机关于这些指令的一个特定细节信息。

在这节课，你将编写程序来向 turtle 发出指令，使它们创建不同的形状和图形。你可以将 turtle 看做虚拟机器人，它们知道如何在屏幕上绘制线条，可以遵守 forward、back、left 和 right 等命令。（稍后我们将解释它们为何叫做“turtle”）。
你可以编辑上述代码中的指令。实验代码是了解它的工作原理的很好方式。请尝试更改数字。可以通过复制粘贴重复某些指令！始终记得重新按下运行，看看代码的运行效果如何。

不能犯错 — 当你遇到错误消息时，可以使用撤消命令（在 Windows 上是 Ctrl+Z，在 Mac 上是 ⌘+Z）撤消修改。你可以随意撤消多次，一直恢复到原始起始代码状态。
为何要使用 turtle？
学习编程的方式多种多样。很多编程课程首先都会从在终端窗口里显示文本的程序开始。但是如果只能看到一个文本输出页面，通常很难判断程序正在执行什么操作。对于 turtle，你可以观看它逐渐构建一个模式或形状，从而查看程序正在执行什么操作。

学习编程不仅仅是学习 Python 等编程语言的语法，主要是学习思考模式、重复、流程和信息的思维方式。turtle 使我们能够可视化这些过程。

为何称为“turtle”？
“turtle graphics”这个概念是在上世纪六十年代由计算机教育家 Seymour Papert 提出来的。一开始，turtle 是一个实际机器人，半球形的外壳看起来像海龟的外壳。该机器人拿着一个笔并且能够在一张大纸上画画。随着计算机越来越便宜，图形效果越来越好，turtle 机器人通常被替换成了屏幕上的版本，就像我们在这门课程中使用的虚拟机器人一样。

术语： 单词 “yellow” 和 “green” 称为字符串。字符串 或 串 (String) 是由数字、字母、下划线组成的一串字符。它是编程语言中表示文本的数据类型。我们称"yellow" 这样一串代码为字符串。

在之后的课程中，我们将详细讲解字符串是什么，以及它们的原理。暂时只需知道你可以区分字符串和代码的其他部分，因为它们位于引号内。
术语：此代码中出现的数字（例如 1、90 和 100）都属于整数。整数是一个没有分数或小数部分的整数。整数可以是正数、零或负数（例如 -5）。
术语：[1, 2, 3, 4, 5] 和 [7, 2, 1, 0, 9] 属于列表。在 Python 中，列表放入方括号里，并且用逗号分隔各项。

到目前为止，我们在列表中看到的项目都一直是数字（具体而言是整数）。但是也可以将其他数据放入列表里。例如，可以将字符串放入列表里，如下所示：

[“hello”, “yellow”, “stuff”, “things”]
( 你可能不知道应该尝试什么角度或者怎样计算角度——没关系！你可以用不同的角度做实验，看看你得到了什么形状。通常你可以通过反复试验来解决问题。需要说明的是，我们不是在测试你的数学能力！)
❤️ 错误消息是你的好帮手
错误消息的目的是告诉你哪里可能出错了，并指向检测到问题的代码部分（通常是行号）。

这是 Python 等编程语言与 HTML 不同的方面之一。当浏览器读取 HTML 时，它通常会忽视错误。如果你输入 而不是

并非所有语言都区分大小写。例如，你可能注意到了，在 HTML 中，你通常可以不用大写或小写，网页看起来还是一样的。

? 注释
下面是我们刚刚查看的方形绘制代码，但是添加了其他内容：

导入 turtle 模块。
import turtle

创建叫做 amy 的新 turtle。
amy = turtle.Turtle()

设置 amy 的颜色。
amy.color(“yellow”)

使 amy 画一个方形
amy.forward(100)
amy.right(90)
amy.forward(100)
amy.right(90)
amy.forward(100)
amy.right(90)
amy.forward(100)
注意，这段代码包含几行以 # 符号开头的内容。这些行是注释— 它们只是供人类读者查看。不会影响到代码的运行方式。

术语：在代码中，注释是针对人类读者的消息。计算机在读取代码时，会忽略注释。在 Python 中，注释行以 # 开头。

注释能够使程序更容易理解。我们在上述示例代码中添加的大部分注释都相对很明显，通过阅读代码就能看明白（至少对有经验的程序员来说是这样）。但是在很多情况下，一行代码的作用并不明显，在这些情况下，注释就很有帮助。

注释代码

使用注释还可以轻松地实验代码。如果你想暂时“关闭”某些代码，使其不会运行，但是并不想真的删除代码，你可以在代码行前面添加一个 #。这样将使这行代码变成注释，以便 Python 运行程序时忽略该代码。
注意，默认情况下，Python 将从上到下按顺序运行每行代码。意味着程序中的代码行顺序可以使程序变化很大。
练习 — 使用变量 (1/2)
能够将值赋值给变量

favorite_color = “cyan”
然后使用此变量在代码的其他位置执行操作

mary.color(favorite_color)

? turtle 能执行什么操作？
此页面将复习你在这门课程中到目前为止使用的不同 turtle 方法。

如果你有一个叫做 lola 的 turtle，那么 …

移动
lola.forward(n) 告诉 turtle 向前移动 n 个像素。 lola.back(n) 告诉 turtle 向后移动 n 个像素。 n 还可以是负数，这样动作就会颠倒过来。 lola.forward(100) 和 lola.back(-100) 执行的操作一样。 lola.speed(s) 设置 turtle 的速度。速度 0 最快。

转向
lola.right(a) 告诉 turtle 按照 a 角度转向。 lola.left(a) 告诉 turtle 按照 a 角度左转。 a 也可以是负数，这样转向就会颠倒过来。 lola.left(-45) 和 lola.right(45) 执行的操作一样。

turtle 从画布的中心开始，指向你的右侧。 转向始终相对于 turtle 当前的朝向。

绘制
lola.penup() 告诉 turtle 抬笔，因此在移动时不会绘制图形。 lola.pendown() 告诉 turtle 再次落笔，因此会绘制图形。 lola.width(n) 将 turtle 的线条粗细更改为 n 个像素。 lola.color(colorname) 将 turtle 的颜色更改为特定名称的颜色。 颜色用字符串命名，例如 “red”、“white” 或 “chartreuse”。 你还可以使用十六进制颜色，例如 “#ff0000”、"#ffffff" 或 “#7fff00”。

turtle 一开始笔是落下的，颜色为 “black”，粗细为 1 个像素。

隐藏和显示
lola.hideturtle() 告诉 turtle 隐藏自己，因此只显示绘制的图形。 lola.showturtle() 告诉 turtle 取消隐藏自己。

官方参考资料
你可以在 turtle 模块的 Python 文档中查找更全面的 turtle 方法参考文档。

? 三种错误

根据我的经验，编程中会出现三大类型的错误：语法错误、用法错误和逻辑错误。

语法错误就像拼写错误
第一个是语法错误。也就是写的代码在语言语法上不合理。在 Python 中，如果只写了 )，但是前面没有 (，则存在语法错误。如果 for 循环里忘了 :，则也存在语法错误。

import turtle
alison = turtle.Turtle()
for angle in [15, 30, 45] # missing colon 缺少冒号
alison.right 90) # missing parenthesis 缺少括号
语法错误就像拼写错误。当你学习新的语言时，很可能会犯很多语法错误。但是当你熟练该语言后，错误就会少了。

用法错误就像不合理的答案
第二种错误可以称之为用法错误。当你要求计算机执行不合理的操作时，就存在用法错误。例如，alison.forward(“orange”) 是用法错误。完全符合语法，但是 forward 方法要求提供数字（表示像素距离），而不是字符串。turtle 无法向前移动 “orange” 像素。

这种错误就相当于说的话很奇怪，或者答案不合理：

问：今天午餐你要吃什么？

答：从纽约到伦敦的距离。

问：你最喜欢的颜色是什么颜色？

答：企鹅。

你不能吃距离；企鹅不是颜色。对于这些问题来说，这些答案不合理，就像 “orange” 不能作为 forward 方法的输入一样。

Python 的 NameError 和 TypeError 消息通常都是这种类型的错误。你之前见到的 ZeroDivisionError 也算是这种错误。

逻辑错误就像提出错误的要求
最后，第三种错误是逻辑错误。程序能正常运行 — 没有崩溃 — 但是行为和你想要的不一样，因为你所写的和你想要的不一样。这就和人们常常说道“计算机并非按照你所想的去操作，而是按照你告诉它的指令去操作。”一个意思。

缩进可能很麻烦

代码可能会出错的地方是循环缩进。如果你发现某些代码行运行的次数超出（或少于）预期了，仔细检查下循环缩进情况。

? 用变量进行算术运算
正如 Kelly 所演示的，你可以将数字赋值给变量：

some_number = 2
然后在表达式里使用该变量：

amy.forward(50 * some_number)
因为 some_number 的值为 2，因此 amy 将向前移动 50 * 2 或 100 个像素。

这个示例比较简单，我们再看一个更有趣的示例：

for side in [1, 2, 3, 4]:
amy.forward(10 * side)
amy.right(90)
循环每次运行时，叫做 side 的变量将从列表中获得新的数字。因此 10 * side 每次结果将不一样！
绘制螺旋
import turtle
t = turtle.Turtle()
t.color(“cyan”)

for side in range(19):
t.forward(side*10)
t.right(120)
形参是变量
形参并不是什么高级概念，它就是变量。具体而言，它是函数定义的第一行里的变量。

例如，下面是 spiral 函数定义的第一行：

def spiral(sides):
因为变量 sides 位于函数定义里，因此称为形参。就是这么简单。我们希望将这种变量与普通变量区分开，因此使用了不同的术语。

实参就是输入
实参也不是什么高级概念，它只是我们传递给函数的输入。

例如，以下代码行 …

spiral(100)
… 调用 spiral 函数，并将数字 100 传递给它作为输入。在此上下文中，我们将 100 称为实参。

等等，“传递”是什么意思？
我们刚刚提到 spiral(100) 将“传递数字 100 作为输入”。是什么意思？

当我们提到它“传递”此实参时，是指它将此数字赋值给相应的形参。在此示例中，它将 100 赋值给 sides 形参。

和赋值语句很像，例如：

sides = 100
因此“向函数传递实参”其实就是向变量赋值的另一种方式
形参 … 还是实参？
在实践中，不同的程序员并非始终会一致地使用术语“实参”和“形参”，有时候他们也会混用。有些程序员直接不用“实参”一词，而是说成“形式参数”和“实际参数”。

如果大家都保持一致，肯定更好（也更不容易让人困惑）！但是，叫什么并不重要，重要的是理解它们是什么，有什么作用：当我们调用函数时，我们向其传递输入（通常称为实参），这些输入被赋值给函数定义里的变量（通常称为形参）。

如果你理解了核心概念，就没问题了！（如果有点不确定，别担心，我们将有很多练习机会。）
练习 — 多个实参
我们使 draw_square 函数更灵活，使我们不仅能指定方形的大小，而且能指定颜色。

为此，我们需要更改函数，使其接受两个实参。当我们指定能够接受多个实参的函数时，我们只需用逗号分隔变量名即可，如下所示：

def draw_square(length, color):
? 局部（内部）变量
在函数内部定义的变量称为局部变量。局部变量只能在定义它的函数里使用。函数外部的代码无法引用这些变量。如果尝试调用的话，将停止运行并显示 NameError。

术语：变量作用域是定义函数所在的程序文本。在函数里定义的变量是局部变量，只能由该函数内的代码引用。在任何函数外的变量具有全局作用域。

? 变量：变量来自哪里？
很多变量是由赋值语句创建的，例如 intensity = 10。但是还可以通过其他方式创建变量。你在这门课程中已经见过很多种方式。

每个 for 循环都会创建一个变量，例如 for step in dance: 中的 step 变量。如果该循环在函数内，则该变量是局部变量。
每个 import 语句都会创建全局变量，然后使用该变量引用导入的模块。例如，语句 import turtle 在内存里创建了 turtle 模块的副本，并创建一个叫做 turtle 的变量，用来引用该数据。然后，当你需要引用该模块时，你可以在代码中使用 turtle。换句话说，import turtle 语句创建了一个变量，其名称是 turtle，值是 turtle 模块本身。
每个函数定义都会创建一个变量。函数名称（例如上方的 bounce 和 boogie）都是变量！创建了这些变量后，我们就可以在之后需要时引用该函数（例如调用函数时）。
当函数有形参时，例如上方代码里的 something，这些形参是该函数的局部变量。
import 语句和函数定义通常会创建全局变量 … 除非它们发生在函数定义里，这时候就是局部变量。

下面这种情况很罕见，但符合语法 —

def square():
import turtle
tle = turtle.Turtle()
def bend():
tle.forward(100)
tle.right(90)
for step in range(4):
bend()
在这种情况下，模块变量 turtle 和函数 bend 都是函数 square 的局部变量。

? 谨慎缩进！

Python 根据代码的缩进判断代码结构。例如，下面这两段代码区别很大：

for side in [25, 50, 25, 50]:
t.forward(side)
t.right(90)
for side in [25, 50, 25, 50]:
t.forward(side)
t.right(90)
区别在于代码行 t.right(90) 是否位于循环内。在第一种情况下，位于循环内；因此 turtle 将绘出矩形。在第二种情况下，不在循环内；因此 turtle 将持续向前移动四次，仅在最后右转。

某些缩进错误将导致 Python 显示错误消息（稍后你就会见到）。其他缩进错误（例如使本应位于循环内的代码位于循环外）不会抛出错误，它们只是导致代码执行的操作和预期的不一样！
任何其他名称的 turtle …?
习题 1/2
下面是有所不同的代码：

import turtle
romeo = turtle.Turtle()
montague = Romeo
你认为它将执行什么操作？
使 Romeo 和 montague 都引用相同的底层 turtle 对象。
在上面的代码中，我们遇到了熟悉的赋值语句 romeo = turtle.Turtle()，它会创建新的 turtle 对象，并命名为 romeo。

但是，然后出现了第二个赋值语句 montague = romeo。注意，romeo 引用的是一个 turtle 对象，因此这行只是为该 turtle 对象设定第二个名称 montague。

传递turtle

import turtle

def square(some_turtle):
for side in range(4):
some_turtle.forward(100)
some_turtle.right(90)

mark = turtle.Turtle()
mark.color(“violet”)
mark.speed(8)
for petal in range(6):
square(mark)
mark.right(60)
import turtle

romeo = turtle.Turtle()
romeo.color(“violet”)
romeo.speed(8)

函数调用函数

def draw_square(some_turtle):
for side in range(4):
some_turtle.forward(100)
some_turtle.right(90)

def draw_flower(some_turtle):
for petal in range(6):
draw_square(some_turtle)
some_turtle.right(60)
some_turtle.hideturtle()

draw_flower(romeo)
函数调用函数
在上面的代码中，请注意，我们有一个函数，它在调用另一个函数。我们调用 draw_flower 函数，然后它又调用了 draw_square 函数。

这在编程中很常见。实际上，有些程序几乎完全是由调用其他函数的函数组成。

这种方法很常见，因为它有很大的优势。例如，我们可以在这个程序中添加其他的代码，用 draw_square 函数来做点别的事情（而不是画花）。通过将不同的任务分解到不同的函数中，可以让代码使用更方便，也更灵活。

传递不同 turtle

关于 draw_flower 函数，需要注意的一个关键问题是：我们可以将 turtle 传递给函数。当我们调用 draw_flower 时，可以传递给它一个 turtle（比如 romeo），只需将这个 turtle 分配给 some_turtle 参数就可以了。

当函数运行时，some_turtle 将引用与 romeo 相同的底层 turtle 对象。(我们说的是 “当函数运行时”，因为 some_turtle 是一个局部变量；它在函数之外是无法识别的)

等等，我们为什么要这么做呢？为什么不能在任何时候都使用 romeo 呢？为什么要用 some_turtle 参数呢?

好吧，如果我们在任何时候都使用 romeo ，那么花朵就总是由同一只乌龟画的。通过为 turtle 使用一个参数，我们可以对 任意 turtle 使用 draw_flower 函数。

相关习题

![在这里插入图片描述](https://img-blog.csdnimg.cn/20190719122806631.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzA4Mjc0

if/else

for side in range(4):
if side == 1:
jack.color(“blue”)
else:
jack.color(“yellow”)
jack.forward(100)
jack.right(90)
这就是 if/else 语句， if 语句的变体，它的工作原理是检查条件 side == 1，如果为真（true），则运行 if 语句下面包含的代码；但如果条件为假（false），则运行 else 语句下面所包含的代码。

模运算

正如 Karl 在视频中所说的，模运算符 % 会进行除法运算，并返回该运算的 余数。

为了更好的使用 取模运算，你需要熟练掌握 除法运算 及其 余数 的关系。我们不会涉及太高深的数学（毕竟那不是重点），但也让我们来做一些习题，来确保你已经掌握了基础知识吧。

习题 1/8
7 除以 3 是多少?

(请你想一想， “7 中包含多少个 3 ？” 或者 “7 由几组 3 构成，并且还剩多少？”)

2，余数为1

怎样得出取模运算的结果
如果你在代码中看到，类似 7 % 3 这样的语句，这样才能得出它的结果呢？ 这个表达式得出的数字是几呢？

这里有一种思考的方法：

1. 数字 7 中有多少组 3 ?
   7 等于 3 + 3 + 1。 所以 7 中有两组 3。（另外一种方法是，问问自己，3 乘以多少等于 7 ）

2. 一旦我们将 7 尽可能的分成了 3 个一组，那么剩下来的是多少呢？
   在这个例子中，还余下的数字是 1 。我们不能把 1 再分成3个一组。所以 1 是余数。所以，表达式 7 % 3 的结果取值为 1。

还是不能理解余数？
如果你能理解以上关于余数的讲解，那就太棒了！但是这些确实有点绕。如果你觉得还是没能完全明白，需要更深入的学习除法和余数。可以看看可汗学院的 这个视频 它们还提供了 一些练习，你可以尝试一下。

注意，这里最重要的概念并不是数学，而是 我们需要一种方法来创建重复任务，而取模运算正好给我们提供了这样一种方法。
你发现其中的规律了吗？如果 a % b 中 b 更大，那么余数就是 a。

例如：

7 % 10 的运算结果是 7
7 % 100 的运算结果是 7
7 % 1000 的运算结果是 7

所有这些例子中，右边的数字都更大，所以结果就是左边的数字。

习题 4/8
使用 模运算符 的常见方法是将它用于 递增的数字 序列。例如，我们可以先用 1 % 5，再用 2 % 5， 然后 3 % 5，以此类推。

亲自尝试，并观察递增序列的运算结果，对理解模运算很有帮助。
这一次，你发现规律了吗？如果数字能够被 2 整除，则余数为 0，那么模运算的结果就是 0。

下面的表格，表示对于不同的 x 值，x % 2 和 x % 3 的值是多少。请观察这些值，随着 x 不断的增大，是如何重复变化的。

x x % 2 x % 3
0 0 0
1 1 1
2 0 2
3 1 0
4 0 1
5 1 2
6 0 0
7 1 1
… … …

模运算的用法？

在实际编程中，我们如何运用模运算呢？其中一种方法是：模运算经常与 for 和 if语句一起使用。这有一个例子：

for n in range(12):
if n % 3 == 0:
draw_triangle()
else:
draw_square()
这个循环将运行 12 次。当 n 等于 0，3，6，或 9 时，模运算的结果为 0。这意味着函数 draw_triangle 将被调用。当 n 等于 1，2，4，5，7，8，10，或 11 时，函数 draw_square 将会被调用。

也就是说，它的运行结果与下面的代码相同（但是比下面的代码短的多）

draw_triangle()
draw_square()
draw_square()

draw_triangle()
draw_square()
draw_square()

draw_triangle()
draw_square()
draw_square()

draw_triangle()
draw_square()
draw_square()
再次重申，请记得用模运算来创建重复动作

返回值

return 语句（返回语句）的基础其实非常简单。例如，这里有一个简单的函数，它的全部内容，就是返回一个数字 10：

def simple_function():
return 10

distance = simple_function()
当我们说它 “返回数字 10” 时，其实是说：这段代码的运行结果，与将 simple_function() 这个函数调用替换成数字 10 ，效果是一样的。

也就是说，这段代码：

distance = simple_function()
与这段代码是等价的：

distance = 10
所以 return 语句会接受一个值，并将其返回到调用函数的位置。
函数中多个返回语句只执行第一个return，其他的均为无效语句
但在if/else 语句中可以有两个有效的返回语句

? 向循环里传入实参

正如你之前见到的，当你针对列表或范围创建 for 循环时，循环变量将从列表或范围里获得值。

for angle in [0, 15, 30, 45]:
zoom(angle)
下面有一个包含四个数字的列表，以及遍历该列表的循环。在循环里， zoom 函数被调用。每次遍历列表时，都用不同的数字调用该函数。此代码和以下代码的效果完全一样：

angle = 0
zoom(angle)
angle = 15
zoom(angle)
angle = 30
zoom(angle)
angle = 45
zoom(angle)
#️⃣ 实参数量
你已经见过接受不同数量的实参的函数。例如，turtle 上的 forward 方法仅接受一个实参：如果 mark 是 turtle，那么 mark.forward(10, 20) 将出错。

这意味着，如果你更改函数接受的实参数量，还需要更改调用该函数的每一处代码。

什么是 if 语句？

此页面将复习你在 Python 中到目前为止见过的各种复合语句。有三种复合语句：for 循环、函数定义 def 和 if 语句。

所有这些语句都具有几个共同点。复合语句的第一行始终以该语句的关键字开头：for、def 或 if。第一行始终以冒号 : 结尾。复合语句的剩余代码行属于代码块，都按照相同的空格数量缩进。

for 循环
for 循环针对列表或范围中的每项重复代码块一次。代码重复次数等于列表或范围的项目数。循环具有循环变量，它按顺序等于每个项目。

for item in [1, 17, -34, “bears”]:

code goes here

this code runs four times

范围函数 range() 对 for 循环来说很有用，因此你不用写出很长的数字列表。

martin = turtle.Turtle()
for num in range(17):

martin will go 0 pixels, turn, go 1 pixel, turn, etc.

martin.forward(num)
martin.right(90)
函数定义
函数定义以关键字 def 开头，然后是函数名称和带括号的参数列表。

def spin(tur, howfast):
tur.speed(howfast)
tur.right(360)
当 Python 看到函数定义时，它不会立即运行里面的代码。当你想要 Python 运行函数时，需要调用该函数，并向其传递参数值：

balthazar = turtle.Turtle()
spin(balthazar, 5)
if 和 else 条件语句
if 关键字表示条件语句。它具有条件，即真假问题。if 语句里的代码块可能会运行&#