forward(bmih)
right(degree)
i = i + 1
polygon(100)
polygon(80, 5)
polygon(50, 6)
##### 8）变量名命名规则
只能包括字母，下划线，美元符号，数字
不能以数字开头
变量名是大小写敏感的
只有在现代的 Python 里，才能用中文作为合法的变量名
变量名不能是 Python 的保留字（while def 等等）
##### 9）代码格式化自检条目
1. 每行只写一条语句
2. 函数之间空两行
3. 运算符左右各加一个空格
4. 逗号前无空格，后面加 1 个空格
5. 冒号前无空格，字典中的冒号后面有一个空格
6. 参数默认值的等号两边没有空格
7. 函数、列表左括号前没有空格，所有右括号前无空格
### 二、第二课
#### 1.作业1解答
>
>
> ```
> 1
> 实现函数, 用于画一个正方形, 边长由参数提供
> 参数 x, y 是正方形左上角坐标
> 参数 l(注意，这里是字母 l，不是数字 1) 是正方行边长
>
> ```
>
>
def square(x, y, l):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 4:
forward(l)
right(90)
i = i + 1
square(5, 5, 10)
>
>
> ```
> 2
> 实现函数, 用于画一个矩形, 长宽由参数提供
> 参数 x, y 是左上角坐标
> 参数 w, h 是长宽
>
> ```
>
>
def rect(x, y, w, h):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 2:
forward(w)
right(90)
forward(h)
right(90)
i = i + 1
rect(2, 20, 30, 10)
>
>
> ```
> 3
> 画一排正方形, 一共 5 个
> 从 0 0 点开始, 边长为 30, 正方形之间间隔为 0
>
> ```
>
>
def square(x, y, l):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 4:
forward(l)
right(90)
i = i + 1
def square5():
n = 5
bmih = 30
# x 坐标
# 0 30 60 90 120
# 0 1 2 3 4
i = 0
while i < n:
x1 = i * bmih
y1 = 0
square(x1, y1, bmih)
i = i + 1
square5()
>
>
> ```
> 4
> 画一排正方形, 一共 5 个
> 从 0 0 点开始, 边长为 30, 正方形之间间隔为 10 像素
>
> ```
>
>
def square(x, y, l):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 4:
forward(l)
right(90)
i = i + 1
def square5_10():
n = 5
bmih = 30
space = 10
# x 坐标
# 0 40 80 120 160
# 0 1 2 3 4
i = 0
while i < n:
x1 = i * (bmih + space)
y1 = 0
square(x1, y1, bmih)
i = i + 1
square5_10()
>
>
> ```
> 5
> 实现函数, 画一排正方形, 有如下参数
> x, y 是第一个正方形左上角坐标
> n 是正方形的个数
> space 是两个正方形之间的间距
> len 是正方形的边长
>
> ```
>
>
def square(x, y, l):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 4:
forward(l)
right(90)
i = i + 1
def square_line(x, y, n, space, len):
# n = 5
bmih = len
# space = 10
# x 坐标
# 0 40 80 120 160
# 0 1 2 3 4
i = 0
while i < n:
x1 = x + i * (bmih + space)
y1 = y
square(x1, y1, bmih)
i = i + 1
square_line(5, 8, 7, 10, 30)
>
>
> ```
> 6
> 实现函数, 用上题的函数来画一个正方形方阵, 参数如下
> x, y 是第一个正方形左上角坐标
> space 是两个正方形之间的间距
> len 是正方形的边长
> n 是横向正方形的个数
> m 是纵向正方形的个数
>
> ```
>
>
def square(x, y, l):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 4:
forward(l)
right(90)
i = i + 1
def square_line(x, y, n, space, len):
# n = 5
bmih = len
# space = 10
# x 坐标
# 0 40 80 120 160
# 0 1 2 3 4
i = 0
while i < n:
x1 = x + i * (bmih + space)
y1 = y
square(x1, y1, bmih)
i = i + 1
def square_square(x, y, space, len, n, m):
i = 0
while i < m:
x1 = x
y1 = y + i * (len + space)
square_line(x1, y1, n, space, len)
i = i + 1
square_square(-100, 50, 10, 50, 3, 2)
>
>
> ```
> 7
> 实现函数, 画一排矩形, 有如下参数
> x, y 是第一个矩形左上角坐标
> w, h 是矩形长宽
> n 是矩形的个数
> space 是两个矩形之间的间距
>
> ```
>
>
def rect(x, y, w, h):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 2:
forward(w)
right(90)
forward(h)
right(90)
i = i + 1
def rect_line(x, y, w, h, n, space):
i = 0
while i < n:
x1 = x + i * (w + space)
y1 = y
rect(x1, y1, w, h)
i = i + 1
rect_line(40, 40, 40, 10, 3, 10)
>
>
> ```
> 8
> 实现函数, 画一个矩形方阵, 参数如下
> x, y 是第一个矩形左上角坐标
> space 是两个矩形之间的间距(横向和纵向)
> w, h 是矩形的长宽
> n 是横向矩形的个数
> m 是纵向矩形的个数
>
> ```
>
>
def rect(x, y, w, h):
jump(x, y)
# 循环画正方形
# 当然, 你可以用 goto 来画
# 只需要计算一下四个顶点的坐标 (这很简单)
i = 0
while i < 2:
forward(w)
right(90)
forward(h)
right(90)
i = i + 1
def rect_line(x, y, w, h, n, space):
i = 0
while i < n:
x1 = x + i * (w + space)
y1 = y
rect(x1, y1, w, h)
i = i + 1
def rect_square(x, y, space, w, h, n, m):
i = 0
while i < m:
x1 = x
y1 = y + i * (h + space)
rect_line(x1, y1, w, h, n, space)
i = i + 1
rect_square(50, 50, 10, 40, 10, 3, 4)
>
>
> ```
> 9
> 实现函数, 画一个正多边形, 参数如下
> x y 是起点, 设起点为多边形的顶部边的左顶点
> n 是多边形的边数
> l 是边长
>
> ```
>
>
def polygon(x, y, n, l):
jump(x, y)
i = 0
jcdu = 180 - (180 * (n - 2) / n)
while i < n:
forward(l)
right(jcdu)
i = i + 1
polygon(40, 10, 36, 10)
#### 2.调试代码
解决语法错误和逻辑错误
#### 3.数据类型
##### 1）整型就是整数
x = 10
##### 2）浮点型就是小数
y = 10.1
a = 12.0
b = 0.21
下面的 c 和 d 两个变量是合法的
因为当你小数点左右只有 0 的时候
Python 规定可以省略 0
但一定不要这样写
c = 12.
d = .21
##### 3）字符串类型的变量
name = ‘gua’
gender = “male”
##### 4）print函数
x = 10
y = 10.1
name = ‘gua’
print(x, y, name)
>
> 10 10.1 gua
>
>
>
#### 4.选择控制
##### 1）if else
grade = 3
如果 grade 小于 7
if grade < 7:
# 这句 print 只在 grade 小于 7 这个条件满足的情况下会被执行
print(‘小学生’)
>
> 小学生
>
>
>
if 带 else
if else 必定会执行一个语句
if 1 > 2:
print(‘条件成立’)
else:
print(‘条件不成立’)
>
> 条件不成立
>
>
>
多个if else
grade = 8
if grade < 7:
print(‘小学生’)
elif grade < 10:
print(‘初中生’)
else:
print(‘高中生’)
>
> 初中生
>
>
>
##### 2）绝对值
n = 111
if n < 0:
n = -n
print(‘绝对值’, n)
>
> 绝对值 111
>
>
>
##### 3）判断奇数偶数
n = 1
if n % 2 == 0:
print(‘偶数’)
else:
print(‘奇数’)
>
> 奇数
>
>
>
#### 5.比较运算和逻辑操作
##### 1）比较运算
一共有 6 个常用比较运算
分别是：
相等, 不等, 小于, 大于, 小于等于, 大于等于
==
!=
<
<=
=
print(‘布尔值’, 1 == 1)
>
> 布尔值 True
>
>
>
##### 2）逻辑操作
与, 或, 非
and
or
not
用到的地方很广, 比如登录网站的时候, 服务器做如下判断
if 用户名存在 and 密码验证成功:
登录成功
else:
登录失败
print(‘1 == 1 and 2 == 2’, 1 == 1 and 2 == 2)
>
> 1 == 1 and 2 == 2 True
>
>
>
#### 6.函数返回值
##### 1）定义
函数不仅可以合并操作重复性的代码
还可以通过计算得到一个结果, 结果就是返回值
函数可以有「返回值」
返回值的意思是函数调用的结果是一个值, 可以被赋值给变量
##### 2）add函数
>
>
> ```
> 例
> 定义一个函数 add
> 接受 a b 两个参数
>
> ```
>
>
def add(a, b):
# 用 return 语句来得到一个返回值
# 函数执行到 return 语句的时候就结束了
return a + b
print(‘add 函数的返回值’, add(1, 2))
number = add(2, 3)
print(‘add 函数的返回值 number’, number)
>
> add 函数的返回值 3
> add 函数的返回值 number 5
>
>
>
##### 3）绝对值函数
def abs(n):
if n < 0:
n = -n
return n
print(abs(0))
print(abs(-8))
print(abs(3))
>
> 0
> 8
> 3
>
>
>
函数执行遇到 return 就结束
def minus(a, b):
print(‘minus start’)
return a - b
print(‘这一句是不会被执行的, 因为 return 的时候函数就结束了’)
print(minus(1, 2))
>
> minus start
>
>
>
##### 4）一个数字是否是奇数
def is_odd(n):
# 取余数的操作符是 %
if n % 2 != 0:
return True
else:
return False
以下是更好的写法
def is_odd(n):
return n % 2 != 0
print(is_odd(1))
print(is_odd(2))
print(is_odd(3))
print(is_odd(4))
>
> True
> False
> True
> False
>
>
>
##### 5）返回两个参数中较小的一个
def min(a, b):
if a < b:
return a
else:
return b
print(min(1, 2))
print(min(3, 2))
>
> 1
> 2
>
>
>
#### 7.标准库
库 是一个编程术语, 意思是一系列函数的集合
标准库 也是一个术语, 指的是语言**自带**的库
Python 的\*\*[在线文档]( )\*\*有所有标准库的文档(当然, 不那么容易看懂)。我们可以用标准库实现很多功能
使用标准库就是直接使用即可(因为自带了)。标准库的用法上课会讲
##### 1）math库-sin
print(math.pi)
print(math.sin(30))
print(‘0.5’, math.sin(30 * math.pi / 180))
>
> 3.141592653589793
> -0.9880316240928618
> 0.5 0.49999999999999994
>
>
>
def float_equal(a, b):
delta = 0.0001
return abs(a - b) < delta
radian = 30 * math.pi / 180
sin30 = math.sin(radian)
print(‘0.5’, sin30, sin30 == 0.5)
print(‘0.5’, sin30, float_equal(sin30, 0.5))
>
> 0.5 0.49999999999999994 True
>
>
>
##### 2）math-floor,ceil
print(‘floor’, math.floor(3.9))
print(‘ceil’, math.ceil(3.1))
### 三、第三课
#### 1.作业2解答
>
>
> ```
> // 注意, 作业中提到的国旗的颜色我们只画黑色线框不填色
> // 所有国旗的矩形长宽分别为 300 * 200(包括瑞士国旗)
>
> // 作业 1
> // 实现一个圆形函数
> // x y 是圆形的圆心
> // r 是半径
> // circle(x, y, r)
>
> 提示:
> 我们在第一节课的最后有一个作业 polygon, 实际上电脑是通过模拟来实现画一个圆的
> 也就是画一个正 n 变形, n 很大的时候, 这个图形就是一个圆
> 有一个问题需要注意, 初始点在圆心处, 在画 polygon 的时候需要从左上角开始
> 所以要先从圆心移动到左上角
>
> 需要注意的是，按照下面提示的写法，画出的圆会多处一条半径线，这一条线必须保留。
>
>
> 分步提示:
> 注意, 你需要 import math 后才能使用 math.pi
> 1. 我们用正 36 边形来模拟圆形, 也就是说 n 取值 36
> 2. 正多边形的周长是 n(边数) * l(边长), 而它的外接圆的周长是 2 * math.pi * r, 我们这里把这两个周长看做相等(因为我们只是用正多边形近似模拟, 不是精准画圆, 小小偏差可以接受)
> 所以直接算出 l = (2 * math.pi * r) / n 这个公式中 l 是多边形边长, r 是圆半径, n 是边数
> 具体请看下图(正多边形和外接圆)
> 3. 初始情况下箭头是朝右的, 所以先往左转, 左转 90 度等于右转 270 度, 所以你需要自己实现一个 left 函数(或者直接 right(270) 或者 right(-90))
> 这个角度的具体计算原理见下图
> 这里直接把公式给出如下, 你可以直接使用
> jcdu = (90 + (360 / n) / 2)
> left(jcdu)
> 4. 转完之后, 移动 r, 也就是半径的距离
> 5. 这样就移动到了左上角的位置, 但此时角度并不是朝右的,
> 刚刚往左转动了 jcdu, 现在往右转回来这个角度
> right(jcdu)
> 6. 这时候你就在正多边形的顶部横边的左顶点并且方向朝右了, 以此为起点画一个正 36 边形即可
>
>
> 如果不能理解上面的提示，那么看下面的提示
> 程序初始的时候状态如下
> 1，箭头朝右
> 2，在原点处
>
> 你把你想像成箭头，你得先 jump 到圆心处，再：
> 1，先左转90度（或者右转 270 度）
> 2，左转 360/n/2 度
> 3，前进半径 r
> 4，转成朝右
> 5，开始画 36 边形
>
>
> ```
>
>
def left(jcdu):
right(360 - jcdu)
def polygon(n, l):
i = 0
jcdu = 360 / n
while i < n:
forward(l)
right(jcdu)
i = i + 1
def circle(x, y, r):
jump(x, y)
n = 36
jcdu = (90 + (360 / n) / 2)
len = (2 * math.pi * r) / n
left(jcdu)
forward(r)
right(jcdu)
polygon(n, len)
circle(0, 0, 50)
>
> // 作业 2
> // 实现一个矩形函数
> // x y 是矩形中心的坐标
> // w h 是宽高
> // center\_rect(x, y, w, h)
>
>
> 提示:
> 在第一课的作业中已经实现了 rect 函数,
> 不过 rect 函数中的 x, y 是表示左上角坐标,
> 现在需要实现的 center\_rect 函数的 x, y 是矩形中心的坐标,
> 所以应该先从矩形中心移动到矩形左上角, 然后调用 rect 函数
>
>
> 分步提示:
> 1. 根据矩形中心坐标 x, y 计算出左上角坐标 x1, y1
> 2. 调用 rect 函数, 传入的参数分别为左上角坐标, 宽和高
>
>
>
def rect(x, y, w, h):
jump(x, y)
i = 0
while i < 2:
forward(w)
right(90)
forward(h)
right(90)
i = i + 1
def center_rect(x, y, w, h):
x1 = x - w / 2
y1 = y + h / 2
rect(x1, y1, w, h)
>
> // 作业 3
> // 实现一个正五角星(国旗大星星那种)函数
> // x y 是五角星顶部横边的左边点坐标
> // length 是一条线的长度
> // 这是一个正五角星
> // vgwujcxy(x, y, length)
>
>
> 分步提示:
> 1. 正五角星需要重复 5 次, 所以需要循环 5 次
> 2. 每次循环中前进 length 的长度, 右转 144 度
> 3. 别忘了循环的时候 i 增加 1
>
>
>
def vgwujcxy(x, y, length):
jump(x, y)
i = 0
while i < 5:
forward(length)
right(144)
i = i + 1
vgwujcxy(-100, 50, 50)
>
> // 注意, 作业中提到的国旗的颜色我们只画黑色线框不填色
>
>
> // 作业 4
> // 实现一个函数画日本国旗
> // 调用 2 个函数画日本国旗
> // 一个画背景的白色矩形
> // 一个画中间的圆，圆的直径必须为国旗高的 3/5
> // x, y 是国旗左上角座标
> // japan(x, y)
>
>
> 提示:
> 日本国旗由两部分组成, 矩形和圆形. 所以依次画出这两个图形
>
>
> 分步提示:
> 1. 调用 center\_rect 函数画一个矩形
> 2. 调用 circle 函数画一个圆形
>
>
>
def japan(x, y):
w = 300
h = 200
x1 = x + w / 2
y1 = y - h / 2
center_rect(x1, y1, w, h)
r = h * (3 / 5) / 2
circle(x1, y1, r)
japan(100, 100)
>
> // 作业 5
> // 实现一个五角星函数
> // x y 是五角星的中心点坐标
> // r 是五角星外接圆的半径
> // wujcxy(x, y, r)
> // 为了实现这个函数, 你需要使用三角函数计算顶点在圆上的坐标
> // 如果你不懂这个数学计算过程, 应该在群里提问
> // 我帮你实现了正弦余弦函数如下
> def sin(degree):
> import math
> # 如上课所述, 数学库里面的 sin 函数接受弧度作为参数
> # 我们这个函数接受角度, 下面是弧度转角度的公式
> radians = degree \* math.pi / 180
> return math.sin(radians)
>
>
> def cos(degree):
> import math
> radians = degree \* math.pi / 180
> return math.cos(radians)
>
>
> 提示
> 1. 正五角星顶角的一半是 18 度, du = 18, 外接圆半径为 r
> 2. 五角星顶部横边 BE 的左边点 B 的 x 坐标为 x1 = x - cos(du) \* r
> 3. 五角星顶部横边 BE 的左边点 B 的 y 坐标为 y1 = y + sin(du) \* r
> 4. 五角星顶部横边的长度为 length = cos(du) \* r \* 2
> 5. 调用作业 3 的函数 vgwujcxy(x1, y1, length)
>
>
>
def sin(degree):
import math
# 如上课所述, 数学库里面的 sin 函数接受弧度作为参数
# 我们这个函数接受角度, 下面是弧度转角度的公式
radians = degree * math.pi / 180
return math.sin(radians)
def cos(degree):
import math
radians = degree * math.pi / 180
return math.cos(radians)
def wujcxy(x, y, r):
du = 18
x1 = x - cos(du) * r
y1 = y + sin(du) * r
length = cos(du) * r * 2
vgwujcxy(x1, y1, length)
wujcxy(0, 0, 135)
circle(0, 0, 135)
>
>
> ```
> 作业 6
> 实现一个函数画中国国旗(以下国旗题目都是如此 不重复了)
> 五角星不要求角度朝向（统一用正五角星），但是要求尺寸必须符合下图中的比例
> x, y 是国旗左上角座标（后面的题都是这个要求，不再重复说明）
> china(x, y)
>
> 提示:
> 中国国旗由两部分组成, 矩形和 5 个五角星, 计算好比例, 依次画完
>
> 分步提示:
> 1. 使用 rect 函数画一个矩形
> 2. 计算比例，画 5 个五角星(调用 5 次)
>
> ```
>
>
def china(x, y):
w = 300
h = 200
rect(x, y, w, h)
# 大五角星
xw1 = x + w / 6
yw1 = y - h / 4
rw1 = h * 3 / 20
wujcxy(xw1, yw1, rw1)
#
xw2 = x + w / 3
xw3 = x + w * 12 / 30
yw2 = y - h * 1 / 10
yw3 = y - h * 1 / 5
yw4 = y - h * 7 / 20
yw5 = y - h * 9 / 20
rw2 = h / 20
wujcxy(xw2, yw2, rw2)
wujcxy(xw3, yw3, rw2)
wujcxy(xw3, yw4, rw2)
wujcxy(xw2, yw5, rw2)
china(0, 0)
>
> // 作业 7
> // 实现一个函数画法国国旗
> // france(x, y)
>
>
> 提示:
> 法国国旗由三个纵向矩形组成, 依次画出这三个矩形
>
>
> 分步提示:
> 1. 计算出三个矩形的宽, 均为 1/3 \* w
> 2. 计算出三个矩形的左上角坐标, 分别为 x1, y1、x2, y2 和 x3, y3
> 3. 调用三次 rect 函数, 每次传入不一样的参数
>
>
>
def france(x, y):
w = 300
h = 200
w1 = w / 3
x1 = x
x2 = x1 + w1
x3 = x2 + w1
rect(x1, y, w1, h)
rect(x2, y, w1, h)
rect(x3, y, w1, h)
france(0, 0)
>
> // 作业 8
> // 画德国国旗
> // germany(x, y)
>
>
> 提示:
> 德国国旗由三个横向矩形组成, 依次画出这三个矩形
>
>
> 分步提示:
> 1. 计算出三个矩形的高, 均为 1/3 \* h
> 2. 计算出三个矩形的左上角坐标, 分别为 x1, y1、x2, y2 和 x3, y3
> 3. 调用三次 rect 函数, 每次传入不一样的参数
>
>
>
def germany(x, y):
w = 300
h = 200
h1 = h / 3
y1 = y
y2 = y1 - h1
y3 = y2 - h1
rect(x, y1, w, h1)
rect(x, y2, w, h1)
rect(x, y3, w, h1)
germany(0, 0)
>
> // 作业 9
> // 画 冈比亚国旗
> // gambia(x, y)
>
>
> 提示:
> 冈比亚国旗和德国国旗类似, 中间的矩形由一个大纵向矩形和两个小纵向矩形组成,
> 所以画 5 个矩形
>
>
> 分步提示:
> 1. 最上面和最下面两个矩形和德国国旗一致
> 2. 中间的矩形分成三个矩形, 高度占比分别为 1:6:1, 分别计算出这三个矩形的中心坐标
> 3. 分别计算中间三个矩形的长度和高度
> 4. 使用 center\_rect 画出 5 个矩形, 每次传入的参数不一致
>
>
>
def gambia(x, y):
w = 300
h = 200
x1 = x + w / 2
x2 = x1
x3 = x1
x4 = x1
x5 = x1
y1 = y - h / 6
y2 = y - h / 3 - h / 48
y3 = y - h / 2
y4 = y - h * 2 / 3 + h / 48
y5 = y - h + h / 6
h1 = h / 3
h2 = h / 24
h3 = h / 4
h4 = h / 24
h5 = h / 3
center_rect(x1, y1, w, h1)
center_rect(x2, y2, w, h2)
center_rect(x3, y3, w, h3)
center_rect(x4, y4, w, h4)
center_rect(x5, y5, w, h5)
gambia(0, 0)
>
> // 作业 10
> // 画 瑞士国旗
> // switzerland(x, y)
>
>
> 提示:
> 瑞士国旗由一个大矩形和两个小矩形组成, 需要画三个矩形
>
>
> 分步提示:
> 1. 瑞士国旗中的两个矩形大小是一样的, 都按照长边 75, 短边 25 来计算
> 2. 计算出三个矩形的中心点坐标、长、宽
> 3. 依次画出这三个矩形
>
>
>
def switzerland(x, y):
w = 300
h = 200
width = 75
height = 25
cx = x + w / 2
cy = y - h / 2
center_rect(cx, cy, w, h)
center_rect(cx, cy, width, height)
center_rect(cx, cy, height, width)
switzerland(0, 0)
>
>
> ```
> 作业 11
> 画朝鲜国旗
> northkorea(x, y)
>
> 提示:
> 朝鲜国旗从上往下依次为蓝色矩形、白色矩形、红色矩形、白色矩形和蓝色矩形,
> 这些矩形的高度比分别为 4:1:15:1:4, 红色矩形里包含了一个圆形和一个五角星
> 圆形的直径和红色矩形的高度的比为 2:3, 圆形的圆点 x 坐标在国旗宽的 2/5 处
> 使用这些数据计算出各个图形的坐标, 然后画出来
>
> 分步提示:
> 1. 分别计算出 5 个矩形的坐标和长宽
> 2. 计算出圆形的圆心, 圆形的直径和红色矩形的高度的比为 2:3, 圆形的圆点 x 坐标在国旗宽的 2/5 处
> 3. 画 5 个矩形
> 4. 画圆形
> 5. 画五角星
>
> ```
>
>
def northkorea(x, y):
w = 300
h = 200
h1 = h * 4 / 25
h2 = h * 1 / 25
h3 = h * 15 / 25
h4 = h2
h5 = h1
x1 = x
x2 = x
x3 = x
x4 = x
x5 = x
y1 = y
y2 = y1 - h1
y3 = y2 - h2
y4 = y3 - h3
y5 = y4 - h4
rect(x1, y1, w, h1)
rect(x2, y2, w, h2)
rect(x3, y3, w, h3)
rect(x4, y4, w, h4)
rect(x5, y5, w, h5)
xr = x + w * 3 / 8
yr = y - h / 2
hr = h3 / 3
circle(xr, yr, hr)
wujcxy(xr, yr, hr)
northkorea(0, 0)
#### 2.log 函数
这里用一种特殊的方式创造了一个 log 函数
下面就可以用 log 替代 print 了, 用 log 的原因在于统一/方便/灵活(具体以后你会学到)
以后会学这个的原理, 现在直接拿来用即可
注意, 我们以后用这个 log 替代 print
def log(*args, **kwargs):
print(*args, **kwargs)
#### 3.debug（调试/除错）的标准应对流程（最重要的内容）
debug 常见的 2 种错误：
1. 语法错误，程序没有运行
2. 逻辑错误，程序运行了，但是结果不是想要的
调试的 2 个难点：
1. 程序的分支你不知道，要让它显形
2. 程序的运行状态（变量的值）你不知道，要看到它
##### 1）用 log debug 的示例：
from gua import *
log(‘line start’)
def line(l):
log(‘line mid’, l)
forward(1)
log(‘line end’)
line(100)
pause()
>
> line start
> line end
> line mid 100
>
>
>
##### 2）分号问题
; 希腊问号（GREEK QUESTION MARK）
; 分号
log(‘希腊问号’, ord(‘;’))
log(‘分号’, ord(‘;’))
>
> 希腊问号 894
> 分号 59
>
>
>
#### 4.内置数据结构 array（数组）
array 可以干嘛？
array 可以存储很多元素，每个元素的值、类型都可以不同
具体看下面的例子
array（数组）常用操作
创建数组
使用 [] 符号，每个元素用逗号分隔
##### 1）array定义
a = [1, 3, 4, 5]
##### 2）len 函数
a = [1, 3, 4, 5]
现在 a 是一个 array，拥有 4 个元素
可以用内置的 len 函数得到 array 的长度
log(‘求 array 长度’, len(a))
使用 len(a) 可以求出数组的长度（数组中元素的个数）
值可以用变量接住
length = len(a)
log(length)
>
> 求 array 长度 4
> 4
>
>
>
##### 3）访问元素
对于数组中的每个元素，可以通过下标（就是元素在数组中的序号，从 0 开始）访问
下标访问语法是 [] 中括号
log(‘用下标访问 array 中的元素’)
log(a[0])
log(a[1])
log(a[2])
log(a[3])
>
> 用下标访问 array 中的元素
> 1
> 3
> 4
> 5
>
>
>
##### 4）遍历
log(‘循环访问 array 所有元素’)
length = len(a)
for i in range(length):
# i 分别是 0 1 2 3
log(a[i])
上面的循环等价于下面的 while
i = 0
length = len(a)
while i < length:
log(a[i])
i = i + 1
>
> 循环访问 array 所有元素
> 1
> 3
> 4
> 5
> 1
> 3
> 4
> 5
>
>
>
##### 5）添加新元素
向已经存在的 array 中添加新元素
可以用数组的 append 函数往列表末尾插入一个元素
并且，这个新元素可以是任意类型，这里是一个字符串
请注意, 这是一个全新的概念, 数组类型的变量可以用 .函数 的方式来进行操作
a.append(‘新元素’)
log(a)
a.append(0)
log(a)
多添加几个元素
a.append(12)
a.append(23)
a.append(34)
log(a)
>
> [1, 3, 4, 5, ‘新元素’]
> [1, 3, 4, 5, ‘新元素’, 0]
> [1, 3, 4, 5, ‘新元素’, 0, 12, 23, 34]
>
>
>
##### 6)关于array题目
>
>
> ```
> 题目，给定一个只包含数字的 array
> 题目，得到列表中最小的元素
> 题目，得到列表中所有数字的和
> 题目，得到列表中所有数字的平均数
> 题目，len(array) 可以得到 array 长度（也就是元素个数），上文有写
>
> ```
>
>
a = [3, 9, 2, 0, -8]
min_number = a[0]
for i in range(len(a)):
n = a[i]
if n < min_number:
min_number = n
log(“数组中最小元素：”, min_number)
求和
sum = 0
for i in range(len(a)):
n = a[i]
sum = sum + n
log(“数组求和：”, sum)
log(“数组平均数：”, sum / len(a))
log(“array 长度：”, len(a))
>
> 数组中最小元素： -8
> 数组求和： 6
> 数组平均数： 1.2
> array 长度： 5
>
>
>
#### 5.字符串
##### 1）判断相等或者包含
log(‘good’ == ‘good’)
log(‘good’ == ‘bar’)
log(‘good’ != ‘bad’)
log(‘possible’ in ‘impossible’)
>
> True
> False
> True
> True
>
>
>
##### 2）拼接得到一个新字符串
拼接得到一个新字符串
log(‘very’ + ‘good’)
log('very ’ + ‘good’)
name = ‘gua’
log('hello, ’ + name)
name = ‘gua’
greeting = 'hello, ’ + name
log(greeting)
>
> verygood
> very good
> hello, gua
> hello, gua
>
>
>
##### 3）format 函数
得到一个你想要的字符串有多种方式
但是现在有现代的方式, 字符串的 format 函数
注意，书上如果和我不一样，以我为准(如果你看过书或者自学过其他教程你会知道百分号格式化字符串, 那是过时的用法了)
用法如下
name = ‘gua’
a = ‘#{}#, 你好’.format(name)
log(a)
>
> #gua#, 你好
>
>
>
简单说来，就是 {} 会被变量替换形成新字符串
可以有多个参数, 按顺序替换字符串中的 {}
##### 4）字符串下标访问
字符串相当于一个 array，可以用下标访问
看例子，看结果
s 的长度是 7，但是下标是从 0 开始的，所以最大下标是 6
s = ‘iamgood’
log(s[0])
log(s[1])
log(s[2])
…
log(s[6])
>
> i
> a
> m
> d
>
>
>
##### 5）字符串不能使用下标来赋值
字符串不能使用下标来赋值
只能拼接起来生成一个新的字符串
name = ‘gua’
name[0] 是 ‘g’
假如你进行如下操作 name[0] = ‘A’
会产生一个错误, 因为字符串不能这样操作
##### 6）字符串切片
>
>
> ```
> # 语法如下
> # s[开始下标:结束下标]
>
> ```
>
>
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
