诺怡 Python 笔记

1. Message

  • 考试日期📅：9月28日
日程

2. 试课

2024-09-15 19:00:00

1. 八色卡 base card

  • 复现时间：20分钟

2. 要求说明

  1. 按要求画出色卡对应图形的形状，做好边线条（如有）和填充颜色处理；（不考虑自动产生的箭头）
  2. 长方形的长为100，宽为50；
  3. 长方形从下到上，填充颜色代码分别是 black；white；gray；边缘线颜色都是 black；
  4. 圆的半径是34；
  5. 圆从左到右，填充颜色代码分别是 (255,0,0)；(255,255,0)；(0,128,0)；其中中间的圆外边缘线颜色代码是 (128,128,128)；
  6. 五角星的间隔顶点的边长为68；
  7. 五角星从下到上，颜色代码分别为 (0,0,1)；(1,0.753,0.796)；
  8. A点坐标为 (0,0)；B点坐标为 (200,32)；C点坐标为 (270,32)；D点坐标为 (340,32)；E点坐标为 (420,32)；F点坐标为 (420,126)。

3. 图示

  • 图中包含一个长方形、三个圆形、两个五角星以及各个点标记(A, B, C, D, E, F)和坐标轴。
  • turtle.pensize(5) # 设置画笔的粗细为 5
  • turtle.pencolor('green') # 设置画笔颜色为绿色
  • 思路：
    • 先实现效果
    • 然后再拆分空行，便于找规律
    • 发现重复代码（重复的逻辑代码）——loop（循环实现）
  • 注意⚠️：
    • 列表创建语法不熟；
    • 变量命名不能和 Python 内置函数相同；
    • 函数使用要用 ()，不是 []；
    • 有点小粗心；
  1. 复习
    1. for 循环
    2. input()
    3. point: 画图
      1. 皇冠
    4. 使用 turtle 的 circle 画出多边形
1
2
3
4
5
6
7
8
import turtle as t
t.color('black','blue')
for i in range(12):
    t.begin_fill()
    t.circle(20+20*i,360,3)
    t.goto(0,0)
    t.left(15)
    t.end_fill()
五环 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import turtle as t
t.pensize(5)
t.pencolor('blak')
t.circle(60)
t.up()
t.goto(-120,0)
t.down()
t.pencolor('blue')
t.circle(60)
t.up()
t.goto(120,0)
t.down()
t.pencolor('red')
t.circle(60)
t.up()
t.goto(-60,-60)
t.down()
t.pencolor('yellow')
t.circle(60)
t.up()
t.goto(60,-60)
t.down()
t.pencolor('green')
t.circle(60)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import turtle  # 导入 turtle 模块

# 设置 turtle 的速度和画笔粗细
turtle.speed(2)  # 设置速度为 2
turtle.pensize(5)  # 设置画笔的粗细为 5

# 绘制第一个圆环（蓝色）
turtle.penup()  # 抬起画笔
turtle.goto(-120, 0)  # 移动到第一个圆环的位置
turtle.pendown()  # 放下画笔
turtle.pencolor('blue')  # 设置画笔颜色为蓝色
turtle.circle(60)  # 绘制半径为 60 的圆

# 绘制第二个圆环（黑色）
turtle.penup()  # 抬起画笔
turtle.goto(0, 0)  # 移动到第二个圆环的位置
turtle.pendown()  # 放下画笔
turtle.pencolor('black')  # 设置画笔颜色为黑色
turtle.circle(60)  # 绘制半径为 60 的圆

# 绘制第三个圆环（红色）
turtle.penup()  # 抬起画笔
turtle.goto(120, 0)  # 移动到第三个圆环的位置
turtle.pendown()  # 放下画笔
turtle.pencolor('red')  # 设置画笔颜色为红色
turtle.circle(60)  # 绘制半径为 60 的圆

# 绘制第四个圆环（黄色）
turtle.penup()  # 抬起画笔
turtle.goto(-60, -60)  # 移动到第四个圆环的位置
turtle.pendown()  # 放下画笔
turtle.pencolor('yellow')  # 设置画笔颜色为黄色
turtle.circle(60)  # 绘制半径为 60 的圆

# 绘制第五个圆环（绿色）
turtle.penup()  # 抬起画笔
turtle.goto(60, -60)  # 移动到第五个圆环的位置
turtle.pendown()  # 放下画笔
turtle.pencolor('green')  # 设置画笔颜色为绿色
turtle.circle(60)  # 绘制半径为 60 的圆

# 完成绘制，隐藏画笔箭头
turtle.hideturtle()
# 保持窗口打开，直到用户关闭
turtle.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import turtle  # 导入 turtle 模块

# 设置 turtle 的速度（2 代表较慢，范围是 0-10，数字越大速度越快）
turtle.speed(2)
# 设置画笔的粗细，单位为像素
turtle.pensize(5)

# 定义每个环的起始位置（相对于屏幕中心）
positions = [(-120, 0), (0, 0), (120, 0), (-60, -60), (60, -60)]
# 定义每个环的颜色，顺序为：蓝色、黑色、红色、黄色、绿色
colors = ['blue', 'black', 'red', 'yellow', 'green']

# 使用 zip 将位置和颜色结合起来，并进行迭代绘制五个环
for position, color in zip(positions, colors):
    turtle.penup()  # 抬起画笔，避免在移动过程中留下痕迹
    turtle.goto(position)  # 移动画笔到指定位置
    turtle.pendown()  # 放下画笔，准备开始绘制
    turtle.pencolor(color)  # 设置当前环的颜色
    turtle.circle(60)  # 绘制半径为 60 像素的圆

# 完成绘制，隐藏画笔箭头
turtle.hideturtle()
# 保持窗口打开，直到用户关闭
turtle.done()
1
2
3
4
5
6
7
8
9
10
import turtle as t
t.pensize(5)
color=['blue','black','red','yellow','green']
positions=[(-120,0),(0,0),(120,0),(-60,-60),(60,-60)]
for i in range(5):
    t.up()
    t.goto(positions[i])
    t.down()
    t.pencolor(color[i])
    t.circle(60)
  1. for 循环基础语法
1
2
3
4
5
6
colors = ['red', 'yellow', 'blue', 'orange']
for detail in colors:
    print(detail)

for index in range(4):
    print(colors[index])
  1. zip
1
2
3
4
5
6
7
8
positions = [(-120, 0), (0, 0), (120, 0), (-60, -60), (60, -60)]
colors = ['blue', 'black', 'red', 'yellow', 'green']

zip_data = zip(positions, colors)
print(list(zip_data))

# ---output---
[((-120, 0), 'blue'), ((0, 0), 'black'), ((120, 0), 'red'), ((-60, -60), 'yellow'), ((60, -60), 'green')]
1
2
3
4
5
6
7
a, b = (1, 200)
print(a)
print(b)

# ---output---
1
200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
positions = [(-120, 0), (0, 0), (120, 0), (-60, -60), (60, -60)]
colors = ['blue', 'black', 'red', 'yellow', 'green']

zip_data = zip(positions, colors)

for data in zip_data:
    print(data)
    
# ---output---
((-120, 0), 'blue')
((0, 0), 'black')
((120, 0), 'red')
((-60, -60), 'yellow')
((60, -60), 'green')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import turtle

turtle.speed(2)
turtle.pensize(5)

positions = [(-120, 0), (0, 0), (120, 0), (-60, -60), (60, -60)]
colors = ['blue', 'black', 'red', 'yellow', 'green']

zip_data = zip(positions, colors)

for data in zip_data:
    position, color = data
    turtle.up()
    turtle.goto(position)
    turtle.down()
    turtle.pencolor(color)
    turtle.circle(60)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import turtle

turtle.speed(2)
turtle.pensize(5)

positions = [(-120, 0), (0, 0), (120, 0), (-60, -60), (60, -60)]
colors = ['blue', 'black', 'red', 'yellow', 'green']

zip_data = zip(positions, colors)

for position, color in zip_data:
    turtle.up()
    turtle.goto(position)
    turtle.down()
    turtle.pencolor(color)
    turtle.circle(60)

3. for 循环语法集训

2024-09-17 15:10:00 
1
2
3
4
5
6
7
8
students_list = ["李雷", "韩梅梅", "马冬梅"]
for student in students_list:
    print(student)

# ---output---
李雷
韩梅梅
马冬梅
  • range(start, end, sep)
    • 默认从 0 开始
    • start: 开始的数
    • end: 结束的数(结束的数取不到)
    • sep: 间隔
1
2
3
4
5
6
7
8
9
10
11
12
13
14
for i in range(10):
    print(i)

# ---output---
0
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
for i in range(0, 10, 2):
    print(i)

# ---output---
0
2
4
6
8
1
2
3
4
5
6
7
8
9
for i in range(1, 10, 2):
    print(i)

# ---output---
1
3
5
7
9
1
2
3
4
5
6
7
8
student_list = ['李雷', '韩梅梅', '马冬梅']
for index in range(len(student_list)):
    print(student_list[index])

# ---output---
李雷
韩梅梅
马冬梅

操作如下列表，按要求输出目标结构：

  • student_list = ['李雷', '韩梅梅', '马冬梅']

  • 输出如下结果：

1
2
3
st1_李雷
st2_韩梅梅
st3_马冬梅
  • 代码：
1
2
3
4
5
student_list = ['李雷', '韩梅梅', '马冬梅']
index = 1
for student in student_list:
    print('st' + str(index) + '_' + student)
    index += 1  # index = index + 1
1
2
3
4
for i in range(10):
    print(i)
    if i > 5:
        break
1
2
3
4
for i in range(10):
    if i > 5:
        break
    print(i)
1
2
3
4
5
6
i = 0
while True:
    print(i)
    i = i + 1
    if i > 5:
        break
1
2
3
4
5
6
7
8
9
numbers = [10, 2, 31, 4, 5, 6, 7, 8, 9, 10]
# 把列表里面的元素，平方放回去
print("操作之前:", numbers)
index = 0
for n in numbers:
    numbers[index] = n ** 2
    index += 1
    
print("平方之后:", numbers)
1
2
3
4
5
6
7
8
numbers = [10, 2, 31, 4, 5, 6, 7, 8, 9, 10]
# 把列表里面的元素，平方放回去
print("操作之前:", numbers)

for index in range(len(numbers)):
    numbers[index] = numbers[index] ** 2

print("平方之后:", numbers)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import turtle

# 设置 turtle
t = turtle.Turtle()
t.speed(0)  # 设置速度为最快
turtle.bgcolor("white")  # 设置背景颜色
t.color("black")  # 设置画笔颜色

# 设置参数
angle = 170  # 旋转角度
line_length = 200  # 线的长度

# 逐步绘制图案
t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

t.forward(line_length)
t.right(angle)

# 隐藏 turtle
t.hideturtle()

# 完成绘制
turtle.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import turtle

# Set up the turtle
t = turtle.Turtle()
t.speed(0)  # Set the drawing speed to the fastest
turtle.bgcolor("white")  # Set background color
t.color("black")  # Set pen color

# Draw the pattern
num_lines = 36  # Number of lines in the pattern
angle = 170     # Angle to turn the turtle
line_length = 200  # Length of each line

for _ in range(num_lines):
    t.forward(line_length)
    t.right(angle)

# Hide the turtle
t.hideturtle()

# Finish the drawing
turtle.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
import turtle as t

t.fd(200)
t.left(72)
t.fd(200)
t.left(72)
t.fd(200)
t.left(72)
t.fd(200)
t.left(72)
t.fd(200)
t.left(72)
t.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import turtle

# 设置 turtle
t = turtle.Turtle()
t.speed(0)  # 设置速度为最快
turtle.bgcolor("white")  # 背景颜色
t.color("black")  # 画笔颜色

# 设置线的数量和角度
num_lines = 18  # 线的数量
initial_length = 50  # 初始线的长度
angle = 20  # 旋转的角度
length_increment = 10  # 每次增加的长度

# 逐条绘制线段
for i in range(num_lines):
    line_length = initial_length + i * length_increment  # 逐渐增加线的长度
    t.forward(line_length)
    t.backward(line_length)  # 返回起点
    t.right(angle)  # 旋转画笔

# 隐藏 turtle
t.hideturtle()

# 完成绘制
turtle.done()

1
2
3
4
5
6
7
8
9
10
11
import turtle as t

for n in range(18):
    t.forward(100 + 20 * n)
    t.left(20)
    t.goto(0, 0)
# 隐藏 turtle
t.hideturtle()

# 完成绘制
t.done()
  • 列表的索引：
    • 从左到右，下标从 0 开始；
    • 从右到左，下标从 -1 开始；
  1. 提取单个元素
1
2
3
4
5
6
7
8
9
10
11
12
numbers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
select = numbers[0]
print(select)

# 'd'
select = numbers[3]
print(select)

# 'j'(用三种方法实现)
print(numbers[8])
print(numbers[-1])
print(numbers[len(numbers) - 1])
  1. 提取多个元素
1
2
3
4
5
6
7
numbers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
select = numbers[0:3]
print(select)

# ['d', 'e', 'f', 'g']
select = numbers[3:7]
print(select)
  1. 提取不连续的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
numbers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
select = numbers[0:9:2]
print(select)

select = numbers[1:10:2]
print(select)

numbers = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
select = numbers[::2] # 如果是开头到结尾，就可以省略前两个
print(select)

select = numbers[1::2]
print(select)

4. 运算符复习

2024-09-18 20:08:23

算术运算符： 用于算术计算。

运算符 描述 例子
+ 加法运算符 1 + 1 = 2
- 减法运算符 2 - 1 = 1
* 乘法运算符 2 * 3 = 6
/ 除法运算符 9 / 3 = 3.0
** 指数运算符 2 ** 3 = 8
% 取余运算符，计算余数 9 % 2 = 1
// 除法取整运算符，计算商并去除其小数部分 9 // 2 = 4

tips: 9 / 2 = 4……1

1
2
3
4
5
6
7
8
9
odd_num = 0
even_num = 0
for i in range(101):
    if i % 2 == 0:
        even_num += i
    else:
        odd_num += i
print(odd_num)
print(even_num)
  1. 假设你有一个两位的整数，我们需要通过以下规则产生两个新的数字：
  • 第一个新数字是原数字的两位数中的各个数字的和；
  • 第二个新数字是原数字的反转（如原数字为 21，反转后的数字为 12）。
  1. 示例：

假设数字 num 为 91，那么你的代码应当输出两个数字：10（9和1的和）和19（91的反转）。

假设数字 num 为 26，那么你的代码应当输出两个数字：8（2和6的和）和62（26的反转）。

假设数字 num 为 18，那么你的代码应当输出两个数字：9（1和8的和）和81（18的反转）。

  1. 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 给定输入数字
num = 91  # 示例输入，可以更改为其他两位数

# 计算数字的十位和个位
first_digit = num // 10  # 使用整除运算符（//）获取十位数字
second_digit = num % 10  # 使用模运算符（%）获取个位数字

# 计算两个数字的和
sum_of_digits = first_digit + second_digit  # 将十位和个位数字相加

# 反转数字
reversed_number = (second_digit * 10) + first_digit  # 将个位数字放到十位，十位数字放到个位来反转数字

# 将计算结果保存在变量result中
result = (sum_of_digits, reversed_number)

# 输出结果
print(result)
  • 比较运算符：比较值的大小
运算符 描述 例子
> 判断第一个运算对象是否大于第二个运算对象 print(1 > 2)
< 判断第一个运算对象是否小于第二个运算对象 print(1 < 2)
>= 判断第一个运算对象是否大于或等于第二个运算对象 print(3 >= 3)
<= 判断第一个运算对象是否小于或等于第二个运算对象 print(3 <= 4)
== 判断两个运算对象是否相同 print(2 == 2)
!= 判断两个运算对象是否不相同 print(2 != 1)

试一试上面的例子，看看会输出上面结果？

在 Python 中，break 语句用于立即退出当前正在执行的循环，无论循环条件是否仍然为真。使用 break 可以提前结束循环，常用于当满足某个条件时不需要继续执行循环体的剩余部分。

注意：循环后的代码还是会继续执行的。

  1. for 循环代码示例
1
2
3
4
for i in range(10):
    print(i)
    if i > 5:
        break  # 循环遇到 break 就会结束
  1. while 循环代码示例，下面程序输出什么结果呢？
1
2
3
4
5
6
i = 0
while True:
    print(i)
    i = i + 1
    if i > 5:
        break

这段代码展示了一个无限循环（while True），它会一直执行，直到遇到 break 语句。这里，当变量 i 大于 5 时，循环会被中断。循环会打印从 0 到 5 的数字。

  1. 循环之后有代码的情况
1
2
3
4
5
for i in range(10):
    if i == 3:
        break
    print(i)
print('for 循环结束之后的代码，当你看见这句话时，表明这个 print 正常执行～')

continue 用于跳过当前循环的剩余部分，并直接进入下一次循环的判断。也就是说，当循环体内遇到 continue 语句时，会跳过该次循环中 continue 之后的代码，并直接进入下一次循环。

  1. for 循环代码示例
1
2
3
4
for i in range(1, 6):
    if i == 3:
        continue
    print(i)

在这个例子中，当 i 等于 3 时，continue 语句被触发，程序跳过了打印 3 的步骤，直接进入了下一次循环。因此输出中没有 3。

1
2
3
4
5
6
7
8
9
10
11
12
13
# 编写一个函数 sum_total ，实现用户传入两个整数参数，进行求和。
def sum_total(a, b, opt):
    if opt == '-':
        print(a + b)
    elif opt == '+':
        print(a + b)
    elif opt == '*':
        print(a * b)
    elif opt == '/':
        print(a / b)
    else:
        print("运算符错误")

🪧
公众号：AI悦创【二维码】

AI悦创·编程一对一

AI悦创·推出辅导班啦，包括「Python 语言辅导班、C++ 辅导班、java 辅导班、算法/数据结构辅导班、少儿编程、pygame 游戏开发、Web、Linux」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践等。当然，还有线下线上摄影课程、Photoshop、Premiere 一对一教学、QQ、微信在线，随时响应！微信：Jiabcdefh

C++ 信息奥赛题解，长期更新！长期招收一对一中小学信息奥赛集训，莆田、厦门地区有机会线下上门，其他地区线上。微信：Jiabcdefh

方法一：QQ

方法二：微信：Jiabcdefh