初中生学python教材推荐,初中生学python有多难

本篇文章给大家谈谈初中生学python教材推荐，以及初中生学python有多难，希望对各位有所帮助，不要忘了收藏本站喔。

今天博主给大家带来了一份大礼，Python环境搭建和安装包都已经打包好上传到百度云了，链接在文章结尾处！

扫码此处领取大家自行获取即可~~~

[[CSDN大礼包：《python安装包&全套学习资料》免费分享]]（安全链接，放心点击）

安装及配置

• 使用的编程地址：编程地址
• python基础相关文件安装：

pycharm配置环境

将原本pycharm中不可见的显示出，需要勾选以下三个：

用tab自动转化为4个空格：

设置行号：

python38相关文件目录：

一、第一课

1.主要内容

变量
循环
四则运算
函数
带参数的函数
多参数的函数
变量命名规则
代码规范

2.例子 1（在线编程网站中完成）

画一个边长为 101 像素的正三角形的代码如下
注意
1, 一条语句一行
2, 括号必须是英文字符(使用中文字符会报错误)

forward(101)
right(120)
forward(101)
right(120)
forward(101)
right(120)

效果图如下所示

3.在pycharm中完成第一课内容

1）gua.py文件

import turtle

s = turtle.Screen()
turtle.setup(width=0.433, height=0.633, startx=20, starty=40)

def jump(x, y):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()

def forward(l):
    turtle.forward(l)

def right(a):
    turtle.right(a)

def pause():
    turtle.done()

2）注释问题

单行注释：

# 注释
# # 开始到这一行的结束，都属于注释的一部分，是不会被程序识别的
# 除了在开头写注释之外，还可以在一行内进行注释，因为 # 到这一行的行末都是注释

多行注释：

"""
这是多行字符串，可以当做注释使用
可以换行
"""

3）相关作业

首先需要在py4课1板书.py中添加以下：

from gua import *

pause()

以下是几道作业题目及其相关代码，和最后的效果展示图。

作业 1
画一个边长为 10 像素的正三角形

forward(10)
right(120)
forward(10)
right(120)
forward(10)
right(120)

作业 2
画一个边长为 99 像素的正方形（用到变量）

x = 100
degree = 90

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 3
画一个长宽分别为 168, 99 像素的矩形

w = 168
h = 99
degree = 90

forward(w)
right(degree)
forward(h)
right(degree)
forward(w)
right(degree)
forward(h)
right(degree)

作业 4
画一个边长为 33 像素的正三角形

x = 33
degree = 120

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 5
画一个边长为 106 像素的正方形

x = 106
degree = 90

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 6
画一个长宽分别为 68, 59 像素的矩形

w = 68
h = 59
degree = 90

forward(w)
right(degree)
forward(h)
right(degree)
forward(w)
right(degree)
forward(h)
right(degree)

作业 7
画一个边长为 79 的正五边形
提示, 往右旋转 72 度

x = 79
degree = 72

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 8
画一个边长为 63 的正六边形
提示, 往右旋转 60 度
正 n 边形的内角和： (n - 2) * 180

x = 63
n = 6
# degree = 180 - (n - 2) * 180 / n
nzjc = (n - 2) * 180 / n
degree = 180 - nzjc

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 9
画一个边长为 159 的正七边形
提示, 往右旋转 52 度

x = 159
n = 7
# degree = 180 - (n - 2) * 180 / n
nzjc = (n - 2) * 180 / n
degree = 180 - nzjc

forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)
forward(x)
right(degree)

作业 10
画一个边长为 93 的正十边形
提示, 往右旋转 36

x = 93
n = 10
# degree = 180 - (n - 2) * 180 / n
nzjc = (n - 2) * 180 / n
degree = 180 - nzjc

# 循环
# 首先定义一个变量，用于计算循环的次数，一般是 i j k a b c
i = 0
# while 后面的语句是条件
# 当条件成立的时候，执行代码块内的语句
# 否则，结束循环
while i < n:
    forward(x)
    right(degree)
    # 注意，在 while 循环里，一定改变 i 的值
    # 否则循环永远不会结束
    i = i + 1

4）Python 中的四则运算

* 代表乘号
/ 代表除号
四则运算是有优先级的 + - 低于 * /

5）循环while

# 循环
# 首先定义一个变量，用于计算循环的次数，一般是 i j k a b c
i = 0
# while 后面的语句是条件
# 当条件成立的时候，执行代码块内的语句
# 否则，结束循环
while i < n:
    forward(x)
    right(degree)
    # 注意，在 while 循环里，一定改变 i 的值
    # 否则循环永远不会结束
    i = i + 1

6）函数

函数是用来消除大段重复代码的功能
主流的语言都有函数这个特性
函数是一段代码的疾患，用于重复使用一段代码

定义一个函数，画一个边长 100 像素的正三角形

def sjjcxy():
    n = 3
    x = 100
    nzjc = (n - 2) * 180 / n
    degree = 180 - nzjc

    i = 0
    while i < n:
        forward(x)
        right(degree)
        i = i + 1


sjjcxy()

以上是定义函数的方式，下面就可以使用了
注意，程序是按顺序执行的，所以定义要在使用前面
函数名 加上一对括号，表示调用函数（调用即为使用）

sjjcxy()
forward(50)
sjjcxy()

函数和其他变量一样，是可以赋值给另一个变量的

sjjc = sjjcxy
sjjc()

7）函数的参数可以增加灵活性

def sjjcxy(x):
    n = 3
    # x = 100
    nzjc = (n - 2) * 180 / n
    degree = 180 - nzjc

    i = 0
    while i < n:
        forward(x)
        right(degree)
        i = i + 1

sjjcxy(10)
sjjcxy(50)
sjjcxy(100)

def polygon(bmih, bmuu=3):
    # n = 3
    # x = 100
    n = bmuu
    nzjc = (n - 2) * 180 / n
    degree = 180 - nzjc

    i = 0
    while i < n:
        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 的**在线文档**有所有标准库的文档(当然, 不那么容易看懂)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[开始下标:结束下标]

slit1 = s[0:3]  # 'iam'
slit2 = s[1:3]  # 'am'
log("slit1:", slit1)
log("slit2:", slit2)

slit1: iam
slit2: am

# 省略开始下标参数意思是从 0 开始取
s[:3]  # 'iam'
slit3 = s[:3]
log("slit3:", slit3)

slit3: iam

s[2:]  # 'mgood'
slit4 = s[2:]
log("slit4:", slit4)

s1 = 'iamgood'[3:]
log("s1:", s1)

slit4: mgood
s1: good

6.变量作用域

def center_rect():
    x = 1
    ...


def rect():
    x = 100
    y = 100
    ...

四、第四课

0.扩展基础

1）log函数

def log(*args, **kwargs):
    print(*args, **kwargs)

2）range函数（不是从0开始）

# 从1开始遍历数组，并求乘积
def product(array):
    s = 1
    for i in range(1, len(array)):
        n = array[i]
        s = s * n
    return s

3）自动化测试

def ensure(condition, message):
    # condition 是布尔值
    # message 是一个 string，condition 不成立的时候被输出
    if not condition:
        log(message)
    else:
        log('测试成功！')


# 加强版 ensure 函数
def ensure_equal(a, b, message):
    if a != b:
        # log(message, a, b)
        log('{}, ({}) 不等于 ({})'.format(message, a, b))
    else:
        log('测试成功！')

1.作业3解答

0）例子 1 ： 求数组的和

def sum(array):
    # 先设置一个变量用来存数组的和
    s = 0
    for i in range(len(array)):
        # 用变量 n 保存元素的值
        n = array[i]
        # 累加到变量 s
        s = s + n
    # 循环结束, 现在 s 里面存的是数组中所有元素的和了
    return s

a = [1, 2, 3, 4]
log('sum', sum(a))

sum 10

1）array 的乘积

作业 1
参数是一个只包含数字的 array
求 array 的乘积
提示：
    通过遍历数组，然后累乘的方式计算数组的乘积，参考例子 1

分步提示：
    1. 先设置一个变量 s 用来存数组的乘积，初始值为 1
    2. 遍历数组，用变量 n 保存元素的值
    3. 累乘每次的变量 n 到变量 s
    4. 循环结束后，变量 s 里面存的是数组中所有元素的乘积, 返回变量 s（很重要，一定要 return s）product(array)

def product(array):
    # 先设置一个变量用来存数组的和
    s = 1
    for i in range(len(array)):
        # 用变量 n 保存元素的值
        n = array[i]
        # 累加到变量 s
        s = s * n
    # 循环结束, 现在 s 里面存的是数组中所有元素的和了
    return s

a = [1, 2, 3, 4]
log('pro', product(a))

pro 24

2）