诺怡 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)

  1. 打印 1 到 10：用 for 循环打印从 1 到 10 的数字。

    1
    2
    for i in range(1, 11):
        print(i)

  2. 打印偶数

    1
    2
    for i in range(2, 21, 2):
        print(i)

  3. 打印列表元素

    1
    2
    3
    fruits = ["apple", "banana", "cherry"]
    for fruit in fruits:
        print(fruit)

  4. 倒序打印数字

    1
    2
    for i in range(10, 0, -1):
        print(i)

  5. 累加器

    1
    2
    3
    4
    total_sum = 0
    for i in range(1, 101):
        total_sum += i
    print(total_sum)

  6. 计算平方

    1
    2
    3
    numbers = [1, 2, 3, 4, 5]
    for number in numbers:
        print(number ** 2)

  7. 简单九九乘法表

    1
    2
    3
    4
    for i in range(1, 10):
        for j in range(1, i + 1):
            print(f"{i} * {j} = {i * j}", end="  ")
        print()

  8. 计算列表元素的长度

    1
    2
    3
    words = ["dog", "cat", "elephant"]
    for word in words:
        print(len(word))

  9. 查找最大值

    1
    2
    3
    4
    5
    6
    numbers = [3, 5, 7, 2, 8]
    max_value = numbers[0]
    for num in numbers:
        if num > max_value:
            max_value = num
    print(max_value)

  10. 统计元音

    1
    2
    3
    4
    5
    6
    7
    s = "hello world"
    vowels = "aeiou"
    count = 0
    for char in s:
        if char in vowels:
            count += 1
    print(count)

  1. 斐波那契数列

    1
    2
    3
    4
    5
    n = 10
    a, b = 0, 1
    for _ in range(n):
        print(a)
        a, b = b, a + b

  2. 寻找质数

    1
    2
    3
    4
    5
    6
    7
    8
    for num in range(2, 101):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            print(num)

  3. 冒泡排序

    1
    2
    3
    4
    5
    6
    7
    arr = [5, 2, 9, 1, 5, 6]
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    print(arr)

  4. 列表翻转

    1
    2
    3
    4
    5
    lst = [1, 2, 3, 4, 5]
    reversed_list = []
    for i in range(len(lst)-1, -1, -1):
        reversed_list.append(lst[i])
    print(reversed_list)

  5. 计算阶乘

    1
    2
    3
    4
    5
    n = 5
    factorial = 1
    for i in range(1, n + 1):
        factorial *= i
    print(factorial)

  6. 倒置字符串

    1
    2
    3
    4
    5
    s = "abcdef"
    reversed_s = ""
    for char in s:
        reversed_s = char + reversed_s
    print(reversed_s)

  7. 矩阵转置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    matrix = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    transpose = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

    for i in range(len(matrix)):
        for j in range(len(matrix[0])):
            transpose[j][i] = matrix[i][j]

    print(transpose)

  8. 统计单词出现次数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    sentence = "the quick brown fox jumps over the lazy dog"
    words = sentence.split()
    word_count = {}
    for word in words:
        if word in word_count:
            word_count[word] += 1
        else:
            word_count[word] = 1
    print(word_count)

  9. 二进制转换

    1
    2
    3
    4
    5
    6
    decimal = 10
    binary = ""
    while decimal > 0:
        binary = str(decimal % 2) + binary
        decimal //= 2
    print(binary)

  10. 合并两个有序列表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    list1 = [1, 3, 5]
    list2 = [2, 4, 6]
    merged_list = []
    i = j = 0

    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            merged_list.append(list1[i])
            i += 1
        else:
            merged_list.append(list2[j])
            j += 1

    merged_list.extend(list1[i:])
    merged_list.extend(list2[j:])
    print(merged_list)

  1. 字母金字塔

    1
    2
    3
    n = 4
    for i in range(1, n + 1):
        print((chr(64 + i) + " ") * i)

  2. 蛇形矩阵

    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
    n = 3
    matrix = [[0] * n for _ in range(n)]
    num = 1
    left, right, top, bottom = 0, n - 1, 0, n - 1

    while left <= right and top <= bottom:
        for i in range(left, right + 1):
            matrix[top][i] = num
            num += 1
        top += 1

        for i in range(top, bottom + 1):
            matrix[i][right] = num
            num += 1
        right -= 1

        for i in range(right, left - 1, -1):
            matrix[bottom][i] = num
            num += 1
        bottom -= 1

        for i in range(bottom, top - 1, -1):
            matrix[i][left] = num
            num += 1
        left += 1

    for row in matrix:
        print(row)

  3. 找出所有回文数

    1
    2
    3
    for num in range(100, 1000):
        if str(num) == str(num)[::-1]:
            print(num)

  4. 统计字符频率

    1
    2
    3
    4
    5
    6
    7
    8
    s = "hello world"
    char_count = {}
    for char in s:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    print(char_count)

  5. 模拟骰子投掷

    1
    2
    3
    4
    5
    6
    7
    8
    import random

    rolls = [0] * 6
    for _ in range(100):
        roll = random.randint(1, 6)
        rolls[roll - 1] += 1

    print(rolls)

  6. 构建杨辉三角

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    n = 5
    triangle = []

    for i in range(n):
        row = [1] * (i + 1)
        for j in range(1, i):
            row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
        triangle.append(row)

    for row in triangle:
        print(row)

  7. 生成棋盘

    1
    2
    3
    4
    5
    6
    7
    8
    9
    size = 8
    for i in range(size):
        row = ""
        for j in range(size):
            if (i + j) % 2 == 0:
                row += "X "
            else:
                row += "O "
        print(row)

  8. 找出列表中出现频率最高的元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    lst = [1, 3, 2, 1, 5, 1, 3, 2, 3, 3]
    count_dict = {}

    for num in lst:
        if num in count_dict:
            count_dict[num] += 1
        else:
            count_dict[num] = 1

    max_count = max(count_dict.values())
    most_frequent = [k for k, v in count_dict.items() if v == max_count]
    print(most_frequent)

  9. 递归实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
       n = 10
       fib_series =

    [0, 1]
       for i in range(2, n):
           next_num = fib_series[i - 1] + fib_series[i - 2]
           fib_series.append(next_num)

       print(fib_series[n - 1])

  10. 文本冒泡排序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    text = "Sort these words by their length in ascending order"
    words = text.split()

    for i in range(len(words)):
        for j in range(0, len(words) - i - 1):
            if len(words[j]) > len(words[j + 1]):
                words[j], words[j + 1] = words[j + 1], words[j]

    print(" ".join(words))

这些代码涵盖了从简单的循环到更复杂的算法和数据结构操作，可以有效地帮助你理解和应用 for 循环。

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("运算符错误")

以下是10道Python基础函数练习题，涵盖了函数定义、参数传递、返回值等基础知识：

  1. 定义一个求和函数
    编写一个函数 sum_numbers，接受两个整数参数，返回它们的和。

    1
    2
    3
    def sum_numbers(a, b):
        # Your code here
        pass

  2. 计算列表中元素的平均值
    定义一个函数 average，接受一个列表作为参数，返回列表中所有元素的平均值。

    1
    2
    3
    def average(numbers):
        # Your code here
        pass

  3. 判断奇偶数
    编写一个函数 is_even，接受一个整数参数，返回 True 表示偶数，False 表示奇数。

    1
    2
    3
    def is_even(num):
        # Your code here
        pass

  4. 字符串反转
    定义一个函数 reverse_string，接受一个字符串参数，返回该字符串的反转结果。

    1
    2
    3
    def reverse_string(s):
        # Your code here
        pass

  5. 阶乘计算
    编写一个函数 factorial，接受一个正整数参数 n，返回 n 的阶乘。

    1
    2
    3
    def factorial(n):
        # Your code here
        pass

  6. 检查质数
    定义一个函数 is_prime，接受一个正整数参数，返回 True 表示质数，False 表示合数。

    1
    2
    3
    def is_prime(num):
        # Your code here
        pass

  7. 最大公约数
    编写一个函数 gcd，接受两个整数参数，返回它们的最大公约数。

    1
    2
    3
    def gcd(a, b):
        # Your code here
        pass

  8. 列表中最大值
    定义一个函数 find_max，接受一个列表作为参数，返回列表中的最大值。

    1
    2
    3
    def find_max(numbers):
        # Your code here
        pass

  9. 华氏温度转换为摄氏温度
    编写一个函数 fahrenheit_to_celsius，接受一个表示华氏温度的参数，返回对应的摄氏温度。

    1
    2
    3
    def fahrenheit_to_celsius(fahrenheit):
        # Your code here
        pass

  10. 斐波那契数列
    定义一个函数 fibonacci，接受一个正整数参数 n，返回斐波那契数列的前 n 项。

1
2
3
def fibonacci(n):
    # Your code here
    pass

5. 函数与 return

2024-09-19 20:31:53
  1. 先用基础语法实现；
  2. 改写成 for 循环实现；（如果可以用循环的话）
  3. 再改写成函数实现；

6. 递归

递归就是在函数内部，自己调用自己；

2024-09-21 19:23:46
  1. 求 n 的阶乘
  • 直接使用循环实现：
1
2
3
4
5
6
n = 9

total = 1
for i in range(1, n + 1):
    total *= i
print(total)
  1. 递归实现
1
2
3
4
5
6
7
def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(9))
  • 太阳花图案： 使用 turtle 模块绘制一个太阳花图案，花瓣数量可以设置为 6 到 12 之间，颜色渐变。
1
2
3
4
5
6
7
8
9
10
11
import turtle as t
t.speed(0)

def draw_flower(petals, radius):
    for _ in range(petals):
        t.circle(radius)
        t.left(360 / petals)

# 绘制花朵
draw_flower(12, 50)
t.done()
  • 螺旋线条： 利用递归或循环，绘制一个渐变的螺旋线条图形，随着线条变长，颜色从浅变深，线条逐渐变宽。

普通实现：

1
2
3
4
5
6
7
import turtle as t

t.speed(0)
for i in range(100):
    t.forward(i * 2)
    t.left(30)
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
28
import turtle as t  # 导入 turtle 模块，并将其别名为 t

# 定义递归函数来绘制螺旋形
def draw_spiral(n, step=0):
    """
    递归绘制螺旋形图案。
    
    参数:
    n -- 剩余递归次数，控制绘图的步数
    step -- 当前前进的步数，用于计算每次向前移动的距离
    
    递归终止条件:
    当 n == 0 时停止递归，结束绘制
    """
    if n == 0:
        return  # 递归终止条件，当 n == 0 时结束递归
    # 每次向前移动的距离为 step * 2，随着 step 增加，移动距离增大
    t.forward(step * 2)
    # 向左转 30 度，形成螺旋效果
    t.left(30)
    # 递归调用自身，减少剩余的步数 n，增加当前步数 step
    draw_spiral(n - 1, step + 1)

# 初始化 turtle 设置
t.speed(0)  # 设置 turtle 绘图的速度为最快
# 调用递归函数开始绘制螺旋图案，初始值为 100 步
draw_spiral(100)
t.done()  # 结束 turtle 绘图窗口
  • 基本实现：
1
2
3
4
5
6
7
8
9
import turtle as t

def draw_star(size):
    for _ in range(5):
        t.forward(size)
        t.right(144)


draw_star(100)
  • 递归实现
1
2
3
4
5
6
7
8
9
10
import turtle as t

def draw_star(size, edges=5):
    if edges > 0:
        t.forward(size)
        t.right(144)
        draw_star(size, edges - 1)

# 调用递归函数绘制五角星
draw_star(100)

7. 习题讲解

发布日期📅：2024-09-23 15:40:13
发布日期📅：2024-09-25 19:30:00

题目说明:

  1. 16 个正六边形大小相同，边长为 50；24 个等边三角形大小相同，边长为 50；
  2. 直线颜色代码为 “black”，正六边形颜色填充代码为 “red”，等边三角形颜色代码为 “blue”；
  3. 程序有效使用变量来调用图形相关数据；
  4. 程序中有效使用 for 循环语句的嵌套循环；
图片

思路：

  1. 正六边形内角和：720˚/6=120˚，所以 180˚ - 120˚ = 60˚。
  2. 画出正六边形：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import turtle as t

t.speed(0)  # 设置最快速度
# t.pendown()
t.forward(50)
t.left(60)
t.forward(50)
t.left(60)
t.forward(50)
t.left(60)
t.forward(50)
t.left(60)
t.forward(50)
t.left(60)
t.forward(50)
  1. 改写成 for 循环
1
2
3
4
5
6
7
import turtle as t

t.speed(0)  # 设置最快速度
# t.pendown()
for _ in range(6):
    t.forward(50)
    t.left(60)
  1. 画出多个正六边形

注意：画出多个正多边形，需要得到两条线的高！

分析 
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
import turtle as t

t.speed(0)  # 设置最快速度
t.pensize(2)  # 设置线条宽度
t.fillcolor('red')  # 设置填充颜色为红色
t.pencolor('black')  # 设置线条颜色为黑色

# 开始绘制网格的正六边形
for j in range(4):
    for k in range(4):
        t.begin_fill()  # 开始填充
        for i in range(6):
            t.fd(50)
            t.left(60)
        t.end_fill()  # 结束填充

        t.up()
        t.fd(100)  # 移动到下一个六边形的位置
        t.down()

    t.up()
    t.home()
    t.right(90)
    t.fd(86.6 * (j + 1))  # 根据网格调整纵向位置
    t.down()
    t.left(90)

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
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
import turtle as t  # 导入 turtle 模块并使用别名 t
import math  # 导入 math 模块以进行数学计算

# 设置 turtle 绘图的初始参数
t.speed(0)  # 设置 turtle 的绘图速度为最快（0 表示最快）
t.pensize(2)  # 设置绘图线条的宽度为 2 像素
t.fillcolor('red')  # 设置形状填充颜色为红色
t.pencolor('black')  # 设置绘图线条颜色为黑色

# 定义正六边形的边长
side_length = 50  # 六边形每一条边的长度为 50 像素
hex_height = math.sqrt(3) * side_length / 2  # 通过数学公式计算六边形的高度（三角函数计算）

# 函数：绘制正六边形
def draw_hexagon():
    t.begin_fill()  # 开始填充形状（将填充颜色设置为之前的红色）
    for _ in range(6):  # 正六边形有 6 条边，循环 6 次绘制每条边
        t.forward(side_length)  # 向前移动边长距离（绘制一条边）
        t.left(60)  # 向左转 60 度，准备绘制下一个边
    t.end_fill()  # 结束填充形状，六边形被完全填充红色

# 函数：绘制等边三角形并填充蓝色
def draw_triangle():
    t.fillcolor('blue')  # 设置等边三角形的填充颜色为蓝色
    t.begin_fill()  # 开始填充形状（填充蓝色）
    for _ in range(3):  # 等边三角形有 3 条边，循环 3 次绘制每条边
        t.forward(side_length)  # 向前移动边长距离（绘制一条边）
        t.left(120)  # 向左转 120 度，准备绘制下一个边
    t.end_fill()  # 结束填充形状，三角形被完全填充蓝色

# 函数：布置多个六边形的图案
def draw_pattern():
    for j in range(4):  # 外层循环控制行数，绘制 4 行六边形
        for k in range(4):  # 内层循环控制列数，绘制 4 列六边形
            draw_hexagon()  # 调用 draw_hexagon 函数绘制一个红色六边形
            t.up()  # 抬起画笔，不进行绘图，移动到下一个六边形的位置
            t.forward(100)  # 向前移动 100 像素，准备绘制下一个六边形
            t.down()  # 放下画笔，准备绘制下一个六边形

        t.up()  # 抬起画笔
        t.home()  # 将 turtle 移动到原点
        t.right(90)  # 向右旋转 90 度，准备向下移动
        t.forward(86.6 * (j + 1))  # 向下移动到下一行六边形的位置，86.6 为两行之间的垂直间距
        t.down()  # 放下画笔，准备绘制下一行六边形
        t.left(90)  # 向左旋转 90 度，使方向恢复到水平向右

# 函数：在六边形之间的空隙处绘制蓝色的等边三角形
def draw_triangles_in_gaps():
    for j in range(4):  # 外层循环控制行数
        for k in range(3):  # 内层循环控制每一行中的三角形数量
            # 计算三角形的绘制位置，使其位于六边形之间的空隙处
            t.up()  # 抬起画笔
            t.goto(50 + 100 * k, -43.3*6 + 86.6 * j)  # 根据计算确定三角形的位置
            t.setheading(0)  # 将方向设为水平向右
            t.down()  # 放下画笔，准备绘制三角形
            draw_triangle()  # 调用 draw_triangle 函数绘制一个蓝色等边三角形

    for j in range(4):  # 外层循环控制列数
        for k in range(3):  # 内层循环控制每一列中的三角形数量
            # 计算三角形的绘制位置，使其位于六边形之间的垂直空隙处
            t.up()  # 抬起画笔
            t.goto(100 + 100 * k, 86.6 * (j - 2))  # 根据计算确定三角形的位置
            t.setheading(180)  # 将方向设为水平向左
            t.down()  # 放下画笔，准备绘制三角形
            draw_triangle()  # 调用 draw_triangle 函数绘制一个蓝色等边三角形

# 开始绘制整个图案
draw_pattern()  # 调用函数绘制 4x4 的红色六边形图案
draw_triangles_in_gaps()  # 调用函数在六边形之间的空隙绘制蓝色三角形

# 完成绘图并保持窗口打开，直到用户关闭窗口
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
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
import turtle as t  # 导入 turtle 模块并使用别名 t

t.speed(0)  # 设置 turtle 的绘图速度为最快
t.up()  # 抬起画笔，不绘图
t.goto(50, 0)  # 移动 turtle 到 x=50, y=0 的位置
t.down()  # 放下画笔，开始绘图

# 绘制第一组三角形（正三角形）
for j in range(4):  # 外层循环控制行数，共绘制 4 行三角形
    for k in range(3):  # 内层循环控制每一行的三角形数量，每行 3 个三角形
        t.color('blue')  # 设置三角形的颜色为蓝色
        t.begin_fill()  # 开始填充形状
        for i in range(3):  # 循环 3 次，绘制正三角形
            t.fd(50)  # 向前移动 50 像素，绘制三角形的一条边
            t.left(120)  # 左转 120 度，准备绘制下一条边
        t.up()  # 抬起画笔，不绘图
        t.fd(100)  # 向前移动 100 像素，准备绘制下一个三角形
        t.down()  # 放下画笔，开始绘制下一个三角形
        t.end_fill()  # 结束填充
    t.up()  # 抬起画笔
    t.home()  # 返回到画布的原点
    t.goto(50, 0)  # 将 turtle 移动到 x=50, y=0 的初始位置
    t.right(90)  # 向右转 90 度
    t.fd(86.6 * (j + 1))  # 向下移动 86.6 像素乘以当前行数，进入下一行
    t.left(90)  # 向左转 90 度，恢复水平方向
    t.down()  # 放下画笔，准备绘制下一行的三角形

# 绘制第二组三角形（倒三角形）
t.up()  # 抬起画笔
t.goto(50, 86.6)  # 将 turtle 移动到 x=50, y=86.6 的位置
t.down()  # 放下画笔，开始绘图
for j in range(4):  # 外层循环控制行数，共绘制 4 行倒三角形
    for k in range(3):  # 内层循环控制每一行的三角形数量，每行 3 个倒三角形
        t.color('blue')  # 设置三角形的颜色为蓝色
        t.begin_fill()  # 开始填充形状
        for i in range(3):  # 循环 3 次，绘制倒三角形
            t.fd(50)  # 向前移动 50 像素，绘制三角形的一条边
            t.left(-120)  # 逆时针旋转 120 度，准备绘制下一条边
        t.up()  # 抬起画笔，不绘图
        t.fd(100)  # 向前移动 100 像素，准备绘制下一个倒三角形
        t.down()  # 放下画笔，开始绘制下一个倒三角形
        t.end_fill()  # 结束填充
    t.up()  # 抬起画笔
    t.home()  # 返回到画布的原点
    t.goto(50, 86.6)  # 将 turtle 移动到初始位置（x=50, y=86.6）
    t.right(90)  # 向右转 90 度
    t.fd(86.6 * (j + 1))  # 向下移动 86.6 像素乘以当前行数，进入下一行
    t.left(90)  # 向左转 90 度，恢复水平方向
    t.down()  # 放下画笔，准备绘制下一行的倒三角形

# 绘制红色六边形
t.up()  # 抬起画笔
t.home()  # 返回到画布的原点
t.down()  # 放下画笔，开始绘图
for j in range(4):  # 外层循环控制行数，共绘制 4 行六边形
    for k in range(4):  # 内层循环控制每一行的六边形数量，每行 4 个六边形
        t.color('red')  # 设置六边形的颜色为红色
        t.begin_fill()  # 开始填充形状
        for i in range(6):  # 循环 6 次，绘制六边形
            t.fd(50)  # 向前移动 50 像素，绘制六边形的一条边
            t.left(60)  # 左转 60 度，准备绘制下一条边
        t.end_fill()  # 结束填充
        t.up()  # 抬起画笔，不绘图
        t.fd(100)  # 向前移动 100 像素，准备绘制下一个六边形
        t.down()  # 放下画笔，准备绘制下一个六边形
    t.up()  # 抬起画笔
    t.home()  # 返回到画布的原点
    t.right(90)  # 向右转 90 度
    t.fd(86.6 * (j + 1))  # 向下移动 86.6 像素乘以当前行数，进入下一行
    t.down()  # 放下画笔
    t.left(90)  # 向左转 90 度，恢复水平方向

# 绘制没有填充的黑色六边形轮廓
t.up()  # 抬起画笔
t.color('black')  # 设置六边形轮廓颜色为黑色
t.home()  # 返回到画布的原点
t.down()  # 放下画笔，开始绘图
for j in range(4):  # 外层循环控制行数，共绘制 4 行六边形轮廓
    for k in range(4):  # 内层循环控制每一行的六边形轮廓数量，每行 4 个
        for i in range(6):  # 循环 6 次，绘制六边形轮廓
            t.fd(50)  # 向前移动 50 像素，绘制六边形的一条边
            t.left(60)  # 左转 60 度，准备绘制下一条边
        t.up()  # 抬起画笔，不绘图
        t.fd(100)  # 向前移动 100 像素，准备绘制下一个六边形轮廓
        t.down()  # 放下画笔，准备绘制下一个六边形轮廓
    t.up()  # 抬起画笔
    t.home()  # 返回到画布的原点
    t.right(90)  # 向右转 90 度
    t.fd(86.6 * (j + 1))  # 向下移动 86.6 像素乘以当前行数，进入下一行
    t.down()  # 放下画笔，准备绘制下一行六边形轮廓
    t.left(90)  # 向左转 90 度，恢复水平方向

题目说明：

有一个名为 exam_scores.csv 的文件，文件包含三列数据：第一列是学生（即学生姓名），第二列是日期（即考试日期，格式为 YYYY-MM-DD），第三列是分数（即考试分数，0-100 之间的整数）。

请使用 Python 进行简单的数据分析，完成以下任务（请确保代码简洁，注释明了）。

  1. 读取 exam_scores.csv 文件中的数据。
  2. 计算每个学生的平均考试分数。
  3. 使用 matplotlib 绘制折线图，横坐标为学生姓名，纵坐标为平均考试分数。
exam_scores.csv 数据 
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
学生,日期,分数
吴刚,2024-04-18,30
张伟,2024-01-17,72
陈杰,2024-03-15,43
王芳,2024-09-19,97
张伟,2024-03-13,36
周涛,2023-10-24,70
张伟,2024-07-26,44
周涛,2024-02-18,59
陈杰,2024-09-04,67
吴刚,2024-05-04,54
吴刚,2024-02-21,60
吴刚,2023-10-13,66
赵敏,2024-04-21,1
周涛,2024-01-17,98
赵敏,2024-03-09,57
张伟,2024-03-15,69
张伟,2024-02-19,34
刘强,2024-08-05,36
周涛,2024-08-25,63
吴刚,2023-11-28,12
陈杰,2024-03-31,43
张伟,2024-08-22,35
王芳,2024-09-07,77
刘强,2024-06-16,74
张伟,2024-03-13,69
李娜,2024-06-16,32
陈杰,2024-08-06,73
刘强,2024-07-10,73
刘强,2024-04-12,93
赵敏,2024-01-30,65
赵敏,2023-10-01,5
陈杰,2024-04-09,44
李娜,2024-01-01,65
孙丽,2024-08-25,19
吴刚,2023-10-31,98
杨洋,2024-06-10,20
赵敏,2024-09-02,84
陈杰,2024-03-05,50
赵敏,2024-06-16,35
李娜,2024-05-14,45
王芳,2023-09-30,62
杨洋,2024-04-21,75
陈杰,2024-05-19,65
孙丽,2023-10-24,38
陈杰,2024-04-10,26
陈杰,2023-09-30,35
赵敏,2023-11-07,11
杨洋,2024-07-05,81
杨洋,2024-01-15,43
王芳,2023-10-24,53
孙丽,2024-03-15,66
张伟,2024-08-22,76
周涛,2024-04-15,26
陈杰,2023-11-22,83
王芳,2024-07-06,50
吴刚,2024-05-04,70
李娜,2024-08-22,95
吴刚,2024-04-03,48
王芳,2024-03-21,80
赵敏,2023-10-01,3
孙丽,2024-04-21,71
王芳,2023-11-27,44
陈杰,2024-01-06,36
陈杰,2024-06-10,24
吴刚,2024-08-08,72
吴刚,2024-08-26,51
吴刚,2024-03-22,25
陈杰,2024-04-10,23
陈杰,2024-09-07,88
孙丽,2023-12-04,30
李娜,2024-09-02,51
刘强,2023-09-25,54
李娜,2024-01-28,88
杨洋,2024-02-18,12
吴刚,2023-11-28,35
刘强,2024-09-07,97
张伟,2024-06-10,70
刘强,2024-03-13,90
刘强,2023-11-27,74
杨洋,2024-02-22,92
陈杰,2024-01-01,18
吴刚,2024-01-01,76
吴刚,2024-07-16,1
赵敏,2023-11-07,13
张伟,2024-04-10,44
吴刚,2024-08-26,95
陈杰,2024-01-04,80
刘强,2024-04-21,95
张伟,2024-09-07,62
刘强,2023-10-24,51
杨洋,2023-09-25,13
孙丽,2024-09-02,98
王芳,2023-11-28,15
李娜,2023-09-30,0
赵敏,2024-04-12,75
王芳,2024-03-04,5
吴刚,2024-05-04,64
杨洋,2023-12-05,39
王芳,2024-07-26,40
张伟,2024-07-26,99

代码：

  1. 读取 exam_scores.csv 文件：
1
df_exam = pd.read_csv('exam_scores.csv')
  1. 计算每个学生的平均考试分数：
1
average_scores = df_exam.groupby('学生')['分数'].mean()
  1. 绘制折线图：
1
2
3
4
5
6
7
8
9
plt.figure(figsize=(10, 6))
average_scores.plot(kind='line', marker='o')
plt.title('学生平均考试分数')
plt.xlabel('学生')
plt.ylabel('平均分数')
plt.xticks(rotation=45)
plt.grid(True)
plt.tight_layout()
plt.show()
  1. 完整代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd
import matplotlib.pyplot as plt

# 1. 读取 exam_scores_chinese.csv 文件中的数据
df_exam = pd.read_csv('exam_scores.csv')

# 2. 计算每个学生的平均考试分数
average_scores = df_exam.groupby('学生')['分数'].mean()

# 3. 使用 matplotlib 绘制折线图，横坐标为学生姓名，纵坐标为平均考试分数
plt.figure(figsize=(10, 6))
average_scores.plot(kind='line', marker='o')  # 传入数据
plt.title('学生平均考试分数')
plt.xlabel('学生')
plt.ylabel('平均分数')
plt.xticks(rotation=45)
plt.grid(True)
plt.tight_layout()

# Show the plot
plt.show()

题目内容：

题目时间 10 分钟
题目说明
1. 7 个圆大小相同，半径为 50
2. 孤线颜色代码为 “black”，外圆颜色填充代码为 “red”，中心圆颜色代码为 “blue”，其他部分颜色为 “yellow”
3. 程序有效使用变量来调用图形相关数据
4. 程序中有效使用循环语句

小宇代码：

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
import turtle as t
t.speed(0)
t.up()
t.goto(-85,-85)
t.down()
t.color('yellow')
t.begin_fill()
t.fd(160)
t.left(90)
t.fd(160)
t.left(90)
t.fd(160)
t.left(90)
t.fd(160)
t.left(90)
t.end_fill()
t.home()
for i in range(6):
    t.up()
    t.fd(85)
    t.down()
    t.color('red')
    t.begin_fill()
    t.circle(50)
    t.end_fill()
    t.up()
    t.goto(0,0)
    t.left(60)
    t.down()
t.up()
t.goto(0,-50)
t.down()
t.color('blue')
t.begin_fill()
t.circle(50)
t.end_fill()

题目内容：

效果图
  1. 图中每条小线段的长度为20，相邻两个线段之间的夹角均为135度。
  2. 线段颜色代码为"red"。
  3. 线段粗细为5。
  4. 程序有效使用变量来调用图形相关数据。
  5. 程序中有效函数来精简代码。

注意：

  • 在比赛中，如果能直接使用循环/递归实现，那就直接使用循环实现，如果不能，就先使用基本的方法，看似很笨，但关键可以得分！
  • 不要被完美主义遮住眼睛，先实现，在优化。一步到位，一切将变得复杂！
    • 直接实现 for、函数很难，先实现基础的，咱们一笔一笔的话会吧，把一笔一笔画了好之后。再去适当的加空行来查找规律。（其实在一笔一笔画的时候，心中已经有规律了。不过别急，等思路特别清晰了再去尝试。当然，先实现基础版的，再改进这样比赛才会稳。
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
import turtle as t
t.speed(0)
# 设置笔的颜色
t.pensize(5)
t.pencolor('red')
# 第一个“入口”
t.left(90)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
# 第一个“八边形”
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
# 第二个“八边形”
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)

t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)

t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)

t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)

t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)

t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)

t.left(45)
t.forward(20)
t.left(45)
t.forward(20)

t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)
t.left(-45)
t.forward(20)

t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)
t.left(45)
t.forward(20)

t.left(-45)
t.forward(20)

小宇代码：

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
import turtle as t
t.color('red')
t.up()
t.goto(0,-100)
t.down()
t.speed(0)
t.pensize(5)
t.left(90)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)
t.fd(20)
t.left(-45)

8. 考前辅导

2024-09-26 19:04:57
  1. 策略：
    1. 不用一次做到最好，这是很难的。
    2. 微信时不时需要升级，为什么需要升级？——迭代，迭代的目的：达到更好的效果。
    3. 那么微信公司牛不——牛！他们不能一次性把微信开发到最好吗？——为什么不能一次性开发到最好？
      1. 人不是机器，达不到最好；
      2. 时代潮流；
      3. 思路、思维的提升是需要时间，想法的完善是需要时间的；
      4. 先走路才能学跑；
    4. 先基础的实现，再去详细的优化；
  2. 先做自己能快速解决并且有把握的，
    1. 题型一致的，分都一样；
    2. 自己会的题型做了；
  3. 对复杂题 or 困难题：
    1. 奔溃、悲伤、捉急——一着急会怎么样？
      1. 出错
      2. 心态
    2. 问题拆分思想：把大问题拆分成小问题，小问题解决了，大问题也就解决了。
      1. 生活中一个常见的例子是搬家：
        1. 搬家本身是个大问题，涉及很多方面，比如打包、运输、清洁、新房整理等。如果你直接去想如何完成整个搬家的过程，可能会感到很复杂、压力很大。但如果把它拆分成几个小任务：
          1. 打包：按房间或物品类别分别打包，比如先打包衣服、书籍、厨具等。
          2. 安排运输：联系搬家公司或租车，把打包好的物品运送到新家。
          3. 清洁：搬家后打扫旧房，或者提前清理新房。
          4. 整理新家：到了新家之后，按房间将物品分类摆放。
        2. 这样每一步都是可控且容易解决的小问题。随着每个小问题被逐一解决，整个搬家的大问题自然也就迎刃而解了。
    3. 结合实际：Question 4，破解方法：
      1. 一步步来；
      2. 结合实际，你自己拿手画的时候，你会怎么画；
    4. 问题转换思想：
      1. 把一个问题转换成另一种问题；
      2. 求一个不规则图形面积，代表：没有具体公式来计算；
  4. 多看看代码，培养阅读代码的习惯，增强观察力；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import turtle as t

t.bgcolor('black')
colors = ['red', 'blue', 'yellow', 'green']
index = 0
for i in range(400):
    if i == 4:
        i = i / 4
    t.forward(i * 2)
    t.left(90)
    if index > (len(colors) - 1):
        index = 0
    t.pencolor(colors[index])
    index += 1

9. 练习题

发布日期📅：2024-09-27 18:03:01

效果图 
1
2
3
4
5
6
7
8
9
10
import turtle as t

t.bgcolor('black')
t.speed(0)
for i in range(400):
    for j in range(4):
        colors = ['red', 'blue', 'yellow', 'green']
        t.color(colors[j])
        t.left(91)
        t.forward(5 * (i + 1))
效果图
  1. 斜三角形为顶角 120 度的等腰三角形，腰长为 100；
  2. 中间为等腰三角形腰，高为 150；
  3. 线粗为 3；
  4. 图形尽可能居于中央；
效果图
  1. 棋盘长 90；
  2. 圆与棋盘线相距 5；
  3. 叉与边线相距 5；
  4. 图形居于中央；

实现代码：

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
import turtle

# 函数：绘制井字棋的外边框
def draw_border():
    turtle.penup()  # 提起画笔，避免移动时留下痕迹
    turtle.goto(-150, 150)  # 将画笔移动到左上角，起始点为(-150, 150)
    turtle.pendown()  # 放下画笔，开始绘制
    for _ in range(4):  # 绘制正方形的四条边
        turtle.forward(300)  # 向前绘制300像素的边
        turtle.right(90)  # 每次右转90度，形成正方形

# 函数：绘制井字棋的内部网格
def draw_grid():
    # 绘制两条垂直线
    for i in range(2):  # 网格有两条垂直线
        turtle.penup()  # 提起画笔
        turtle.goto(100 * (i + 1) - 150, 150)  # 定位到垂直线的起点
        turtle.pendown()  # 放下画笔
        turtle.goto(100 * (i + 1) - 150, -150)  # 向下绘制垂直线，终点为棋盘底部

    # 绘制两条水平线
    for i in range(2):  # 网格有两条水平线
        turtle.penup()  # 提起画笔
        turtle.goto(-150, 100 * (i + 1) - 150)  # 定位到水平线的起点
        turtle.pendown()  # 放下画笔
        turtle.goto(150, 100 * (i + 1) - 150)  # 向右绘制水平线，终点为棋盘右边

# 函数：在指定位置绘制"O"
def draw_circle(x, y):
    turtle.penup()  # 提起画笔，避免移动时留下痕迹
    turtle.goto(x, y - 40)  # 定位到要绘制"O"的中心点，并将其向下移动半径距离
    turtle.pendown()  # 放下画笔
    turtle.circle(40)  # 以半径40像素绘制一个圆

# 函数：在指定位置绘制"X"
def draw_x(x, y):
    turtle.penup()  # 提起画笔，避免移动时留下痕迹
    turtle.goto(x - 40, y + 40)  # 定位到X的左上角
    turtle.pendown()  # 放下画笔
    turtle.goto(x + 40, y - 40)  # 绘制X的第一条斜线
    turtle.penup()  # 提起画笔
    turtle.goto(x - 40, y - 40)  # 定位到X的左下角
    turtle.pendown()  # 放下画笔
    turtle.goto(x + 40, y + 40)  # 绘制X的第二条斜线

# 主函数：控制程序流程
def main():
    turtle.speed(3)  # 设置画笔的速度，值越高越快，3为适中的速度
    turtle.pensize(5)  # 设置画笔粗细，5像素宽
    turtle.hideturtle()  # 隐藏画笔箭头（指针）

    # 绘制井字棋的外边框
    draw_border()
    
    # 绘制井字棋的内部网格
    draw_grid()
    
    # 在左上角绘制"O"，坐标为(-100, 100)
    draw_circle(-100, 100)
    
    # 在中央位置绘制"X"，坐标为(0, 0)
    draw_x(0, 0)
    
    # 保持窗口打开，等待用户手动关闭
    turtle.done()

# 运行主函数
main()

题目要求数据实现：

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
import turtle

# 函数：绘制井字棋的外边框
def draw_border():
    turtle.penup()
    turtle.goto(-45, 45)  # 将起点设置为相对中心的位置 (-45, 45)
    turtle.pendown()
    for _ in range(4):  # 绘制外边框的四条边
        turtle.forward(90)  # 每条边 90 像素
        turtle.right(90)

# 函数：绘制井字棋的内部网格
def draw_grid():
    # 绘制两条垂直线
    for i in range(2):
        turtle.penup()
        turtle.goto(30 * (i + 1) - 45, 45)  # 每条垂直线的起点 (-15, 45) 和 (15, 45)
        turtle.pendown()
        turtle.goto(30 * (i + 1) - 45, -45)  # 向下绘制垂直线，终点在(-15, -45) 和 (15, -45)

    # 绘制两条水平线
    for i in range(2):
        turtle.penup()
        turtle.goto(-45, 30 * (i + 1) - 45)  # 水平线的起点 (-45, -15) 和 (-45, 15)
        turtle.pendown()
        turtle.goto(45, 30 * (i + 1) - 45)  # 向右绘制水平线，终点为 (45, -15) 和 (45, 15)

# 函数：在指定位置绘制"O"，圆心与网格线保持5像素距离
def draw_circle(x, y):
    turtle.penup()
    turtle.goto(x, y - 10)  # 计算调整，使圆心与网格线有5像素间距（半径=10，半径-5）
    turtle.pendown()
    turtle.circle(10)  # 半径设为10像素的圆

# 函数：在指定位置绘制"X"，线与边线保持5像素距离
def draw_x(x, y):
    offset = 10 - 5  # 计算叉的线条与网格线保持5像素的距离
    turtle.penup()
    turtle.goto(x - offset, y + offset)  # X的左上角点与网格线有5像素距离
    turtle.pendown()
    turtle.goto(x + offset, y - offset)  # 绘制第一条对角线
    turtle.penup()
    turtle.goto(x - offset, y - offset)  # X的左下角点
    turtle.pendown()
    turtle.goto(x + offset, y + offset)  # 绘制第二条对角线

# 主函数：控制程序流程
def main():
    turtle.speed(3)  # 设置画笔的速度，3为适中的速度
    turtle.pensize(3)  # 设置画笔粗细，3像素宽
    turtle.hideturtle()  # 隐藏画笔箭头

    # 绘制井字棋的外边框
    draw_border()
    
    # 绘制井字棋的内部网格
    draw_grid()
    
    # 在左上角绘制"O"，位置为(-30, 30)
    draw_circle(-30, 30)
    
    # 在中央绘制"X"，位置为(0, 0)
    draw_x(0, 0)
    
    # 保持窗口打开，等待用户手动关闭
    turtle.done()

# 运行主函数
main()
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

# 函数：绘制圆圈
def draw_circle(radius, color):
    turtle.penup()
    turtle.goto(0, -radius)  # 将画笔移动到圆的起点
    turtle.pendown()
    turtle.color(color)  # 设置颜色
    turtle.begin_fill()
    turtle.circle(radius)  # 画圆
    turtle.end_fill()

# 函数：绘制五角星
def draw_star(size, color):
    turtle.penup()
    turtle.goto(-size / 2, size / 2 * 0.8)  # 定位到五角星的顶部
    turtle.setheading(0)  # 设置朝向为0度
    turtle.pendown()
    turtle.color(color)
    turtle.begin_fill()
    for _ in range(5):
        turtle.forward(size)
        turtle.right(144)  # 每个星角的角度为144度
    turtle.end_fill()

# 主函数：绘制美国队长的盾牌
def draw_captain_america_shield():
    turtle.speed(5)  # 设置画笔速度
    turtle.pensize(2)  # 设置画笔粗细

    # 绘制盾牌的同心圆
    draw_circle(150, "red")    # 外圈红色
    draw_circle(120, "white")  # 第二圈白色
    draw_circle(90, "red")     # 第三圈红色
    draw_circle(60, "blue")    # 中心圈蓝色

    # 在蓝色中心画五角星
    draw_star(60, "white")

    # 完成绘图，保持窗口打开
    turtle.hideturtle()
    turtle.done()

# 运行主函数
draw_captain_america_shield()

10. Other

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 as t
t.speed(0)
for i in range(4):
    list = ['red','white','red','blue']
    t.color(list[i])
    t.up()
    t.goto(0,-200)
    t.left(90)
    t.fd(30*i)
    t.left(-90)
    t.down()
    t.begin_fill()
    t.circle(200-i*30)
    t.end_fill()
t.home()
t.left(108)
t.up()
t.goto(60,-90)
t.down()
t.begin_fill()
for i in range(5):
    t.color('white')
    t.fd(205)
    t.left(144)
t.end_fill()
t.ht()
t.done()
🪧
公众号：AI悦创【二维码】

AI悦创·编程一对一

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

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

方法一：QQ

方法二：微信：Jiabcdefh