阿尔法python习题整理（全）_阿尔法编程python答案

第二章 Python基本语法元素

温度转换

温度的刻画有两个不同体系：摄氏度（Celsius）和华氏度（Fahrenheit）。‬

编程实现：将用户输入的华氏度转换为摄氏度，或将输入的摄氏度转换为华氏度。‬

转换算法如下：（C表示摄氏度、F表示华氏度）‬

C = ( F - 32 ) / 1.8‬
F = C * 1.8 + 32‬
1
2

TempStr = input("请输入带有符号的温度值:")
if TempStr[-1] in ['F','f']:
    C = (eval(TempStr[0:-1])-32)/1.8
    print("{:.2f}C".format(C))
    #print("C{:.2f}".format(C))
elif TempStr[-1] in ['C','c']:
    F = 1.8*eval(TempStr[0:-1])+32
    print("{:.2f}F".format(F))
else:
    print("输入格式错误")
1
2
3
4
5
6
7
8
9
10

注释所有行

使用注释，使得下面所有的代码不在控制台显示。

#print('我是第一行')
#print('我是第二行')
'''print('我是第三行')
print('我是第四行')
print('我是第五行')
'''
1
2
3
4
5
6

BMI

# 1.创建表示身高的变量 height 并赋值 1.8
height = 1.8

# 2.创建表示体重的变量 weight 并赋值 81
weight = 81

# 3.创建表示BMI值的变量 bmi 并计算
bmi = 81/(height*height)

# 4.将 bmi 打印输出
print(bmi)
1
2
3
4
5
6
7
8
9
10
11

汇率兑换程序

人民币和美元是世界上通用的两种货币之一，按照温度转换程序的设计思路，以1 美元 = 7 人民币的汇率编写一个美元和人民币的双向兑换程序。

要求如下：

(1) 输入输出的人民币采用大写的 RMB 开头，金额可以是整数或小数，如：RMB123 指人民币123元；

(2) 输入输出的美元采用大写的 USD 开头，金额可以是整数或小数，如：USD20 指美元 20 元；

(3) 输出保留小数点后两位，方法为：print("%.2f" % a)。输入格式错误时，输出提示：输入格式错误；

(4) 使用 input() 获得输入时，不要增加提示字符串。

TempStr=input("请输入带字符的金额")
if TempStr[0:3] in 'RMB':
    #D = int(eval(TempStr[0:-1])/6)
    a = float(TempStr[3:])
    a = a/7
    print("USD%.2f" % a)
elif TempStr[0:3] in 'USD':
    #R = int(eval(TempStr[0:-1])*6)
    r = float(TempStr[3:])
    r = r*7
    print("RMB%.2f" % r)
else:
    print("输入格式错误")
1
2
3
4
5
6
7
8
9
10
11
12
13

冰墩墩

import turtle

turtle.title('BingDunDun（阿尔法编程）')

turtle.speed(10)  # 速度
#左手
turtle.penup()
turtle.goto(177, 112)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(80)
turtle.circle(-45, 200)
turtle.circle(-300, 23)
turtle.end_fill()

# 左手内

turtle.penup()
turtle.goto(182, 95)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(95)
turtle.pendown()
turtle.circle(-37, 160)
turtle.circle(-20, 50)
turtle.circle(-200, 30)
turtle.end_fill()

# 轮廓

# 头顶

turtle.penup()
turtle.goto(-73, 230)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(20)
turtle.circle(-250, 35)

# 左耳

turtle.setheading(50)
turtle.circle(-42, 180)

# 左侧

turtle.setheading(-50)
turtle.circle(-190, 30)
turtle.circle(-320, 45)

# 左腿

turtle.circle(120, 30)
turtle.circle(200, 12)
turtle.circle(-18, 85)
turtle.circle(-180, 23)
turtle.circle(-20, 110)
turtle.circle(15, 115)
turtle.circle(100, 12)

# 右腿

turtle.circle(15, 120)
turtle.circle(-15, 110)
turtle.circle(-150, 30)
turtle.circle(-15, 70)
turtle.circle(-150, 10)
turtle.circle(200, 35)
turtle.circle(-150, 20)

# 右手

turtle.setheading(-120)
turtle.circle(50, 30)
turtle.circle(-35, 200)
turtle.circle(-300, 23)

# 右侧

turtle.setheading(86)
turtle.circle(-300, 26)

# 右耳

turtle.setheading(122)
turtle.circle(-53, 160)
turtle.end_fill()

# 右耳内

turtle.penup()
turtle.goto(-130, 180)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-28, 160)
turtle.setheading(210)
turtle.circle(150, 20)
turtle.end_fill()

# 左耳内

turtle.penup()
turtle.goto(90, 230)
turtle.setheading(40)
turtle.begin_fill()
turtle.pendown()
turtle.circle(-30, 170)
turtle.setheading(125)
turtle.circle(150, 23)
turtle.end_fill()

# 右手内

turtle.penup()
turtle.goto(-180, -55)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(-120)
turtle.pendown()
turtle.circle(50, 30)
turtle.circle(-27, 200)
turtle.circle(-300, 20)
turtle.setheading(-90)
turtle.circle(300, 14)
turtle.end_fill()

# 左腿内

turtle.penup()
turtle.goto(108, -168)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-115)
turtle.circle(110, 15)
turtle.circle(200, 10)
turtle.circle(-18, 80)
turtle.circle(-180, 13)
turtle.circle(-20, 90)
turtle.circle(15, 60)
turtle.setheading(42)
turtle.circle(-200, 29)
turtle.end_fill()

# 右腿内

turtle.penup()
turtle.goto(-38, -210)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-155)
turtle.circle(15, 100)
turtle.circle(-10, 110)
turtle.circle(-100, 30)
turtle.circle(-15, 65)
turtle.circle(-100, 10)
turtle.circle(200, 15)
turtle.setheading(-14)
turtle.circle(-200, 27)
turtle.end_fill()

# 右眼

# 眼圈

turtle.penup()
turtle.goto(-64, 120)
turtle.begin_fill()
turtle.pendown()
turtle.setheading(40)
turtle.circle(-35, 152)
turtle.circle(-100, 50)
turtle.circle(-35, 130)
turtle.circle(-100, 50)
turtle.end_fill()

# 眼珠

turtle.penup()
turtle.goto(-47, 55)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(25, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 62)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 68)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-47, 86)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 左眼

# 眼圈

turtle.penup()
turtle.goto(51, 82)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-32, 152)
turtle.circle(-100, 55)
turtle.circle(-25, 120)
turtle.circle(-120, 45)
turtle.end_fill()

# 眼珠

turtle.penup()
turtle.goto(79, 60)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(24, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 64)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 70)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 88)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 鼻子

turtle.penup()
turtle.goto(37, 80)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.circle(-8, 130)
turtle.circle(-22, 100)
turtle.circle(-8, 130)
turtle.end_fill()

# 嘴

turtle.penup()
turtle.goto(-15, 48)
turtle.setheading(-36)
turtle.begin_fill()
turtle.pendown()
turtle.circle(60, 70)
turtle.setheading(-132)
turtle.circle(-45, 100)
turtle.end_fill()

# 彩虹圈

turtle.penup()
turtle.goto(-135, 120)
turtle.pensize(5)
turtle.pencolor("cyan")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-165, 150)
turtle.circle(-130, 78)
turtle.circle(-250, 30)
turtle.circle(-138, 105)
turtle.penup()
turtle.goto(-131, 116)
turtle.pencolor("slateblue")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-160, 144)
turtle.circle(-120, 78)
turtle.circle(-242, 30)
turtle.circle(-135, 105)
turtle.penup()
turtle.goto(-127, 112)
turtle.pencolor("orangered")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-155, 136)
turtle.circle(-116, 86)
turtle.circle(-220, 30)
turtle.circle(-134, 103)
turtle.penup()
turtle.goto(-123, 108)
turtle.pencolor("gold")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-150, 136)
turtle.circle(-104, 86)
turtle.circle(-220, 30)
turtle.circle(-126, 102)
turtle.penup()
turtle.goto(-120, 104)
turtle.pencolor("greenyellow")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-145, 136)
turtle.circle(-90, 83)
turtle.circle(-220, 30)
turtle.circle(-120, 100)
turtle.penup()

# 爱心

turtle.penup()
turtle.goto(220, 115)
turtle.pencolor("brown")
turtle.pensize(1)
turtle.fillcolor("brown")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(36)
turtle.circle(-8, 180)
turtle.circle(-60, 24)
turtle.setheading(110)
turtle.circle(-60, 24)
turtle.circle(-8, 180)
turtle.end_fill()

# 五环

turtle.penup()
turtle.goto(-5, -170)
turtle.pendown()
turtle.pencolor("blue")
turtle.circle(6)
turtle.penup()
turtle.goto(10, -170)
turtle.pendown()
turtle.pencolor("black")
turtle.circle(6)
turtle.penup()
turtle.goto(25, -170)
turtle.pendown()
turtle.pencolor("brown")
turtle.circle(6)
turtle.penup()
turtle.goto(2, -175)
turtle.pendown()
turtle.pencolor("lightgoldenrod")
turtle.circle(6)
turtle.penup()
turtle.goto(16, -175)
turtle.pendown()
turtle.pencolor("green")
turtle.circle(6)
turtle.penup()

turtle.pencolor("black")
turtle.goto(-16, -160)
turtle.write("BEIJING 2022", font=('Arial', 10, 'bold italic'))
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
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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405

求圆面积周长

输入圆的半径r，计算圆的面积(area)和周长(circumference)。

注意: 所有数保留两位小数。π 取值 3.14。方法为：print("%.2f" % a)。

#请使用 input() 输入圆的半径 r

r = float(input("请输入半径："))

#请计算圆的面积和周长，并将计算结果输出
area=3.14*r*r;
circumference=3.14*2*r;
print("面积:%.2f" %area);
print("周长:%.2f" %circumference);
1
2
3
4
5
6
7
8
9

同切圆绘制

import turtle
turtle.pensize(2)
turtle.circle(8)
turtle.circle(32)
turtle.circle(64)
turtle.circle(100)
1
2
3
4
5
6

五角星绘制

from turtle import *

fillcolor("red")
begin_fill()
while True:
    forward(150)
    right(144)
    if distance(0, 0) < 1:
        break
end_fill()
done()
1
2
3
4
5
6
7
8
9
10
11

温度转换

温度的刻画有两个不同体系：摄氏度（Celsius）和华氏度（Fahrenheit）。‬

编程实现：将用户输入的华氏度转换为摄氏度，或将输入的摄氏度转换为华氏度。‬

TempStr = input("请输入带有符号的温度值:")

if TempStr[-1] in ['F','f']:
      C=(eval(TempStr[0:-1])-32)/1.8
      print("转换后的温度是%.2fC" %C)
elif TempStr[-1] in ['C','c']:
      F=1.8*eval(TempStr[0:-1])+32
      print("转换后的温度是{:.2f}F".format(F))
else:
      print("输入格式错误")
1
2
3
4
5
6
7
8
9
10

打印数据类型

num1 = 30
num2 = 7
num3 = num1/num2
# 在下面将 num3 转换成 int 类型，使得最终输出是 <class 'int'>
num3=int(num1/num2)
print(type(num3))
1
2
3
4
5
6

交换变量值

num1 = int(input())
num2 = int(input())

# 请不要修改源代码最上面2行

# 请在下面交换 num1, num2 两个变量的值

num1,num2=num2,num1
1
2
3
4
5
6
7
8

计算器

# 请使用 input() 输入两个数 num1, num2
num1=float(input())
num2=float(input())
# 请分别计算 num1,num2 的和(summation)、差(difference)、积(product)、商(quotient)，并将计算结果输出
summation=num1+num2
difference=num1-num2
product=num1*num2
quotient=num1/num2
print("和为:%.2f" %summation)
print("差为:%.2f" %difference)
print("积为:%.2f" %product)
print("商为:%.2f" %quotient)
1
2
3
4
5
6
7
8
9
10
11
12

输入身高体重并计算BMI

# 请使用 input 获取键盘输入
height=float(input('请输入年龄:'))
# 请使用 input 获取键盘输入
weight=float(input('请输入体重:'))
bmi = weight / (height ** 2)
print(bmi)
1
2
3
4
5
6

Hello World的条件输出

请用程序实现

获得用户输入的一个整数num，参考该整数值，打印输出"Hello World"。

要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) 如果输入值是 0，直接输出"Hello World"‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) 如果输入值大于 0，以两个字符一行方式输出"Hello World"（空格也是字符）‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(3) 如果输入值小于 0，以垂直方式输出"Hello World"

# 请使用 input() 输入一个整数 num
num=int(input())
# 请对num进行判断
if num==0:
    print("Hello World")
elif num>0:
    print("He\nll\no \nWo\nrl\nd")
else:
    print("H\ne\nl\nl\no\n \nW\no\nr\nl\nd")
1
2
3
4
5
6
7
8
9

第三章 基本图形绘制

绘制玫瑰花

import turtle

turtle.setup(350, 600)

alpha = turtle.Turtle()
alpha.penup()
alpha.left(90)
alpha.fd(200)
alpha.pendown()
alpha.right(90)

alpha.fillcolor("red")
alpha.begin_fill()
alpha.circle(10, 180)
alpha.circle(25, 110)
alpha.left(50)
alpha.circle(60, 45)
alpha.circle(20, 170)
alpha.right(24)
alpha.fd(30)
alpha.left(10)
alpha.circle(30, 110)
alpha.fd(20)
alpha.left(40)
alpha.circle(90, 70)
alpha.circle(30, 150)
alpha.right(30)
alpha.fd(15)
alpha.circle(80, 90)
alpha.left(15)
alpha.fd(45)
alpha.right(165)
alpha.fd(20)
alpha.left(155)
alpha.circle(150, 80)
alpha.left(50)
alpha.circle(150, 90)
alpha.end_fill()

alpha.left(150)
alpha.circle(-90, 70)
alpha.left(20)
alpha.circle(75, 105)
alpha.setheading(60)
alpha.circle(80, 98)
alpha.circle(-90, 40)

alpha.left(180)
alpha.circle(90, 40)
alpha.circle(-80, 98)
alpha.setheading(-83)

alpha.fd(30)
alpha.left(90)
alpha.fd(25)
alpha.left(45)
alpha.fillcolor("green")
alpha.begin_fill()
alpha.circle(-80, 90)
alpha.right(90)
alpha.circle(-80, 90)
alpha.end_fill()

alpha.right(135)
alpha.fd(60)
alpha.left(180)
alpha.fd(85)
alpha.left(90)
alpha.fd(80)

alpha.right(90)
alpha.right(45)
alpha.fillcolor("green")
alpha.begin_fill()
alpha.circle(80, 90)
alpha.left(90)
alpha.circle(80, 90)
alpha.end_fill()

alpha.left(135)
alpha.fd(60)
alpha.left(180)
alpha.fd(60)
alpha.right(90)
alpha.circle(200, 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
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

蟒蛇绘制

import turtle
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(20)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
  turtle.circle(40,80)
  turtle.circle(-40,80)
turtle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

正方型绘制

import turtle

alpha = turtle.Turtle()
alpha.color('red')
alpha.forward(100)
alpha.left(90)
# 完善代码，画一个正方形。
alpha.forward(100)
alpha.left(90)
alpha.forward(100)
alpha.left(90)
alpha.forward(100)
alpha.left(90)
1
2
3
4
5
6
7
8
9
10
11
12
13

八边形

import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(100)
    t.left(45)
1
2
3
4
5

八角形

import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(150)
    t.left(135)
1
2
3
4
5

叠边形

import turtle as t
t.pensize(2)
for i in range(9):
    f.td(150)
    t.left(80)
1
2
3
4
5

使用循环绘制五角星

import turtle

alpha = turtle.Turtle()

steps = 100

angle1 = (180 * (5 - 2)) / 5
angle2 = 180 - angle1
angle = 2 * angle2

for i in range(5):
    alpha.fd(60)
    alpha.right(angle)
1
2
3
4
5
6
7
8
9
10
11
12
13

风轮绘制

import turtle as t
t.pensize(3)
for i in range(4):
    t.fd(150)
    t.right(90)
    t.circle(-150,45)
    t.right(90)
    t.fd(150)
    t.right(45)
t.done()
    alpha.right(angle)
1
2
3
4
5
6
7
8
9
10
11

第四章 基本数据类型

从尾到头

编写程序实现，将数字倒序输出。

输入一个小于 500 的三位整数，将这个整数乘 2 得到一个新的数，将这个新的数从尾到头倒序输出。

# 从键盘输入一个三位数
num = int(input("请输入一个小于500的三位整数"))
# 将其乘 2 后倒序输出
num1 = str(num*2)
i = len(num1)
while(i>0):
    print(num1[i-1],end="")
    i = i-1

1
2
3
4
5
6
7
8
9

抹零

现有小区停车收费规则如下，每小时收 1 元，1 小时内免费，不足一小时按 1 小时算。

# 请输入停车时长
hour = float(input("请输入停车时间:"))

# 请计算需要收取的停车费
if hour<1:
     print("收费0元")
else:
     print("收费{:.0f}元".format(int(hour)))    
1
2
3
4
5
6
7
8

实现加密器

编程实现：输入一个整数num，将输入的数字进行加密，并将加密后的结果输出。

以下为加密的规则：

1. 加密结果 = (整数 * 10 + 5) / 2 + 3.14159
2. 加密结果仍为一整数

# 请使用 input() 输入一个整数 num
num = int(input("请输入一个整数："))

# 请对数字 num 进行加密，并将加密结果输出
print(int((num*10+5)/2+3.14159)
1
2
3
4
5

判断奇偶数

# 请使用 input() 输入一个整数 num
num=int(input("请输入一个整数"))
# 请判断这个数是奇数还是偶数
if num%2==0:
   print("even")
else:
   print("odd")
1
2
3
4
5
6
7

公倍数

# 请使用 input() 输入一个正整数 num
num=int(input())
# 请判断这个正整数是否是 5 和 7 的公倍数
if num%5==0 and num%7==0:
   print("yes")
else:
   print("no")
1
2
3
4
5
6
7

判断平闰年

# 请使用 input() 输入一个年份 year
year=int(input())
# 请判断这个年份是否为闰年
if (year%4==0) and (year%100!=0) or (year%400==0):
   print("leap year")
else:
   print("common year")
1
2
3
4
5
6
7

天天向上的力量第一问

计算千分之一的力量。

要求如下：

(1) 计算一年 365 天，每天进步千分之一，累计进步到多少，并将计算结果输出。

(2) 计算一年 365 天，每天退步千分之一，累计剩下多少，并将计算结果输出。

(3) 输出时，在一行内输出进步的结果和退步的结果。

解1

dayup=pow(1.001,365)
daydown=pow(0.999,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
1
2
3

解2

dayup = 1
daydown = 1
daystep = 0.001
for i in range(365):
    dayup = dayup * (1 + daystep)
for i in range(365):
    daydown = daydown * (1 - daystep)
print("向上：{:.2f}".format(dayup),end="")
print("向下：{:.2f}".format(daydown),end="")
1
2
3
4
5
6
7
8
9

天天向上的力量第二问

计算千分之五和百分之一的力量。

要求如下：

(1) 计算一年 365 天，每天进步千分之五或百分之一，累计进步到多少，并将计算结果输出。

(2) 计算一年 365 天，每天退步千分之五或百分之一，累计剩下多少，并将计算结果输出。

(3) 输出时，在一行内输出进步的结果和退步的结果。

解1

dayfactor=0.005
dayup=pow(1+dayfactor,365)
daydown=pow(1-dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
1
2
3
4

解2

dayup1 = 1
dayup2 = 1
daydown1 = 1
daydown2 = 1
daystep1 = 0.005
daystep2 = 0.01
for i in range(365):
    dayup1 = dayup1 * (1 + daystep1)
    dayup2 = dayup2 * (1 + daystep2)
for i in range(365):
    daydown1 = daydown1 * (1 - daystep1)
    daydown2 = daydown2 * (1 - daystep2)
print("向上：{:.2f}".format(dayup1),end=" ")
print("{:.2f}".format(dayup2),end=" ")
print("向下：{:.2f}".format(daydown1),end=" ")
print("{:.2f}".format(daydown2),end="")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

天天向上的力量第三问

工作日的力量。

要求如下：

(1) 一年 365 天，一周 5 个工作日，每天进步 1%；

(2) 一年 365 天，一周 2 个休息日，每天退步 1%；

(3) 计算按照工作日和休息日的进步或退步情况，经过一年 365 天后，累计剩下多少，并将计算结果输出。

(4) 输出时，在一行内输出计算的结果。

dayup = 1.0
dayfactor = 0.01
for i in range(365):
    if i % 7 in [6, 0]:
           dayup = dayup * (1 - dayfactor)
    else:
        dayup = dayup * (1 + dayfactor)
print("工作日的力量:{:.2f}".format(dayup))        
1
2
3
4
5
6
7
8

天天向上的力量第四问

工作日模式要努力到什么水平，才能与每天努力进步 1% 一样？‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

• A君: 一年 365 天，每天进步 1%，不停歇，365天之后，达到37.78 ‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬
• B君: 一年 365 天，每周工作 5 天休息 2 天，休息日每天退步 1%，那么工作日应该多努力才能追上Ａ君呢？

请用程序实现

计算要使 B君 和 A君 一年后的进步程度一样，那么 B君 每天需要进步的值，并将计算结果输出。

要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(1) ‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬一年 365 天，以第 0 天的能力值为基数，记为 1.0；‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) ‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬当好好学习时，能力值相比前一天提高 1%；当没有学习时，由于遗忘等原因能力值相比前一天下降 1%；

(3) 输出保留小数点后三位，冒号后有一个空格。如：工作日的努力参数是: 0.019。

def dayUP(df):
    dayup=1
    for i in range(365):
        if i%7 in [6,0]:
            dayup = dayup*(1-0.01)
        else:
            dayup = dayup*(1+df)
    return dayup

dayfactor = 0.01
while dayUP(dayfactor)<37.78:
    dayfactor += 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))
1
2
3
4
5
6
7
8
9
10
11
12
13

删除字符

删除预置代码中字符串string中的一部分。

要求如下：

(1) 分两行输入两个整数，第一个整数表示字符串 string 的索引 begin，第二个整数表示需要删除的长度 length。

(2) 将字符串 string 中，从索引 begin 开始，长为 length 的子字符串删除。

(3) 输出字符串 string 删除后剩下的部分。

string = 'abcdefghijklmnopqrstuvwxyz'

# 请使用 input() 输入索引 begin 和长度 length
begin = int(input("请输入索引开始值："))
length = int(input("请输入长度："))

# 请将字符串 string 中，从索引 begin 开始，长为 length 的字符串删除，并将剩下的字符串内容输出
remain=string[:begin]+string[begin+length:]
print(remain)
1
2
3
4
5
6
7
8
9

插入字符

已知字符串 s ，请将另一个字符串 sub 添加到字符串 s 的指定索引位置中，并将添加后的 s 输出。

s = 'abcdefghijklmnopqrstuvwxyz'
sub = input("请输入要添加的字符串")
pos = int(input())
str1 = list(s)
str1.insert(pos,sub)
for i in range(len(str1)):
    print(str1[i],end="")
1
2
3
4
5
6
7

你中无我

给定两个字符串 s1, s2，删除字符串 s1 中的属于 s2 的字符，并输出结果。

str1 = input("请输入第一个字符串")
str2 = input("请输入第二个字符串")
for i in str1:
    if i not in str2:
        print(i,end="")
1
2
3
4
5

拼接最大字符

输入两个长度相等的字符串，将两字符串中相同索引中较大的字符组成一个新的字符串并输出，使用 ASCII 码来比较字符大小。

# 请使用 input() 输入两个字符串 string1, string2
string1=input()
string2=input()
# 请分别比较两个字符串中的每一个字符，将大的字符拼接成一个新的字符串，并输出
str1=list(string1)
str2=list(string2)
str=""
for i in range(len(string1)):
if str1[i]>=str2[i]:
   str=str+str1[i] 
else:
   str=str+str2[i]
print(str)
1
2
3
4
5
6
7
8
9
10
11
12
13

单词转换

请用程序实现：输入一段英文文本 text，将文本中的单词分别按照 全部小写、全部大写 和 标题化 格式输出。

# 请使用 input() 输入一段文本 text
text = input("输入文本")

# 请将文本中的单词分别按照 全部小写、全部大写 和 标题化 格式输出
print("全部小写：",text.lower())
print("全部大写：",text.upper())
print("标题化：",text.title())

1
2
3
4
5
6
7
8

统计词量

输入一段仅由英文字母、空格组成的文本，并通过split()方法统计这段文本中的单词数量，并将统计结果输出。

# 请使用 input() 输入一断文本 text
text = input('')

# 请统计这段文本中的单词数量，并将统计结果输出
num = len(text.split())
print(num)
1
2
3
4
5
6

回文字符串

输入一个字符串，判断它是否为回文字符串。如果是回文字符串，输出yes；如果不是回文字符串，输出no。

str = input("请输入一个字符串")
#逆序形成新的字符串str1
str1 = str[::-1]
if (str == str1):
   print("yes")
else:
   print("no")
1
2
3
4
5
6
7

过滤敏感字符

请用程序实现：输入一段英文文本 text，将其中出现的敏感词改为***(三个星号)，并将更改后的内容输出。

注意：敏感字符包括 “fuck”、“shit”、“bitch”，其他的暂不考虑。

# 请使用 input() 输入一段英文文本 text
text = input()

# 请将文本中出现的敏感词改为`***`，并将更改后的内容输出
text = text.replace('fuck','***')
text = text.replace('shit','***')
text = text.replace('bitch','***')
print(text)
1
2
3
4
5
6
7
8

时间格式化

获取当前时间，并将获取到的时间按照年-月-日 时:分:秒的格式打印输出。

import time
t = time.gmtime()
print(time.strftime('%Y-%m-%d %H-%M-%S',t))
1
2
3

文本进度条

import time
scale=50
print("执行开始".center(scale//2,"-"))
start=time.perf_counter()
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    dur=time.perf_counter()-start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='')
    time.sleep(0.1)
print("\n"+"执行速度".center(scale//2,'-'))

1
2
3
4
5
6
7
8
9
10
11
12
13

第五章 程序控制结构

年龄换算

狗是人类的好朋友，一只狗大约可以生存 15 至 20 年，狗狗在 2 岁时，已经成年。为了对狗的年龄有个直观认识，有一个简单的换算办法能将狗的年龄换算为人类的年龄：

狗狗 1 岁时，相当于人类 15 岁，2 岁时相当于人类 24 岁，此后，狗狗每长 1 岁，都相当于人长 4 岁。

请用程序实现：输入狗狗的年龄，计算并输出对应的人类的年龄。

# 请使用 input() 输入狗狗的年龄
age=int(input())
# 计算相对人的岁数，并将结果输出
if age==1:
    print("15")
elif age==2:
    print("24")
else:
    ages=24+(age-2)*4
    print("%d" %ages)
1
2
3
4
5
6
7
8
9
10

判断平闰年

如果一个年份可以被 4 整除且不能被 100 整除，或者可以被 400 整除，那么这个年份就是闰年。

劣：

# 请使用 input() 输入一个年份 year
year = int(input())

# 请判断这个年份是否为闰年
if year%400==0:
    print("leap year")
else:
    if year%100==0:
        print("common year")
    else:
        if year%4==0:
            print("leap year")
        else:
            print("common year")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

优：

# 请使用 input() 输入一个年份 year
year = int(input("输入年份"))
# 请判断这个年份是否为闰年
if (year%4==0 and year%100!=0) or year % 400==0:
    print("leap year")
else:
    print("common year")
1
2
3
4
5
6
7

考试评级

输入一个表示考试成绩score的整数，判断该成绩属于哪个级别，并将判断结果输出。

劣：

# 请使用 input() 输入考试成绩 score
score = int(input('请输入考试成绩: '))

# 请判断成绩属于哪个级别
if score<59:
    print("E")
elif score>=60 and score<=69:
    print("D")
elif score>=70 and score<=79:
    print("C")
elif score>=80 and score<=89:
    print("B")
elif score>=90 and score<=100:
    print("A")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

优：

# 请使用 input() 输入考试成绩 score
score = int(input('请输入考试成绩: '))

# 请判断成绩属于哪个级别
if score<60:
    print("E")
elif score<70:
    print("D")
elif score<80:
    print("C")
elif score<90:
    print("B")
else:
    print("A")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

大小写转换

a、b、c、d这样的52个字母（包括大写）在计算机中存储时也要使用二进制数来表示。

标准ASCII码使用7位二进制数（剩下的1位二进制为0）来表示所有的大写和小写字母，如下图所示，可以看出字母对应大小写的差值为32。来进行大小写转换吧。

注意：python 中，使用 ord() 函数将 字符 转换成其对应的 ASCII 码；使用 chr() 函数将 ASCII 码转换成其对应的字符。

判断1：

# 请使用 input() 输入一个英文字母 char
char = input()

# 请实现英文字母的大小写转化
if ord(char)>96:
    char = chr(ord(char)-32)
else:
    char = chr(ord(char)+32)
print(char)
1
2
3
4
5
6
7
8
9

判断2：

# 请使用 input() 输入一个英文字母 char
char=input("输入一个英文字母")
if ord(char)>=ord('A') and ord(char)<=ord('Z'):
    print(chr(ord(char)+32))
else:
    print(chr(ord(char)-32))

# 请实现英文字母的大小写转化
1
2
3
4
5
6
7
8

判断位数并打印各位的值

输入一个不多于五位的正整数num，求出它是几位数，将结果输出，并将每一位的数字都打印出来。

注意: 位数和每位的数字分两行打印。

字典：

# 请使用 input() 输入一个不多于五位的正整数 num
num = input()
wei = {
    1: '一',
    2: '二',
    3: '三',
    4: '四',
    5: '五'
}

# 请计算这个正整数的位数，并将每一位的数字都打印出来。
print(wei[len(num)])
for i in range(len(num)):
    print(num[i],end=" ")
    i += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

if分支：

num=str(input("输入一个数字"))
lens=len(num)
if len(num)==1:
    print("一")
elif len(num)==2:
    print("二")
elif len(num)==3:
    print("三")
elif len(num) == 4:
    print("四")
elif len(num) == 5:
    print("五")
i=0
while i<len(num):
    print(num[i],end=" ")
    i+=1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

判断回文数

输入一个五位数，判断它是否是回文数。如果是，输出yes；如果不是，输出no。

解1

num = input()
a = num[:1]
b = num[1:2]
c = num[2:3]
d = num[3:4]
e = num[4:5]
if a==e and b==d:
    print("yes")
else:
    print("no")
1
2
3
4
5
6
7
8
9
10

解2

str = input("请输入一个字符串")
#逆序形成新的字符串str1
str1 = str[::-1]
if (str == str1):
   print("yes")
else:
   print("no")
1
2
3
4
5
6
7

地铁车票

输入乘坐人数(per_num)和乘坐站数(sta_num)，计算购买地铁车票需要的总金额，并将计算结果输出。

注意: 如果「乘坐人数」和「乘坐站数」为0或负数，输出error。

少判断：

# 请使用 input() 输入乘坐的人数 per_num 和站数 sta_num
per_num = int(input())
sta_num = int(input())

# 请判断输入的人数和站数是否正确，计算购买车票的总金额，并将计算结果输出
if per_num <=0 or sta_num <= 0:
    print("error")
elif sta_num<5:
    print(per_num*3)
elif sta_num<10:
    print(per_num*4)
else:
    print(per_num*5)
1
2
3
4
5
6
7
8
9
10
11
12
13

多判断：

# 请使用 input() 输入乘坐的人数 per_num 和站数 sta_num
# 请判断输入的人数和站数是否正确，计算购买车票的总金额，并将计算结果输出
per_num=int(input("乘坐的人数"))
sta_num=int(input("站数"))
if per_num<=0 or sta_num<=0:
    print("error")
elif sta_num<=4 and sta_num>=1:
    print(per_num*3)
elif sta_num <= 9 and sta_num >= 5:
    print(per_num*4)
elif sta_num >= 9:
    print(per_num*5)
1
2
3
4
5
6
7
8
9
10
11
12

判断星期

每个星期对应的英语单词都不同，星期一到星期天的单词分别为：monday、tuesday、wednesday、thursday、friday、saturday、sunday。请用程序实现

输入单词的前两个字符，判断输入的单词是星期几，并输出对应的单词；如果输入的字符不匹配，则输出error。

字典：

# 请使用 input() 输入单词的前两个字母 chars
chars = input()
pd = {
    'mo': 'monday',
    'tu': 'tuesday',
    'we': 'wednesday',
    'th': 'thursday',
    'fr': 'friday',
    'sa': 'saturday',
    'su': 'sunday',
}   

# 请判断输入的是星期几，并输出对应的单词
if chars in pd.keys():
    print(pd[chars])
else:
    print("error")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

if分支：

# 请使用 input() 输入单词的前两个字母 chars
chars = input()
# 请判断输入的是星期几，并输出对应的单词
if chars=='mo':
    print("monday")
elif chars=='tu':
    print("tuesday")
elif chars=='we':
    print("wednesday")
elif chars=='th':
    print("thursday")
elif chars=='fr':
    print("friday")
elif chars=='sa':
    print("saturday")
elif chars=='su':
    print("sunday")
else:
    print("error")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

身体质量指数BMI

BMI ：Body Mass Index 国际上常用的衡量人体肥胖和健康程度重要标准，主要用于统计分析‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬。BMI 的计算公式为 BMI = 体重(kg) / (身高(m) * 身高(m))。请用程序实现

获取用户输入的体重和身高值，计算并给出国际和国内的 BMI 分类。

嵌套if：

height = float(input())
weight = float(input())

# 计算bmi值并将判断结果输出
bmi = weight / height**2
print("BMI数值为:%.2f"%bmi)
if bmi<18.5:
    a = b = '偏瘦'
elif bmi<25:
    a = '正常'
    if bmi<24:
        b = a
    else:
        b = '偏胖'
elif bmi<30:
    a = '偏胖'
    if bmi<28:
        b = a
    else:
        b = '肥胖'
else:
    a = b = '肥胖'
print("BMI指标为:国际'%s', 国内'%s'"%(a,b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

多if：

height = float(input())
weight = float(input())
BMI=weight/pow(height,2)
print(f"BMI数值为：{BMI:.2f}")
A='s'
B='s'
if BMI<18.5:
    A=B='偏瘦'
elif 18.5<=BMI<25:
    A='正常'
elif 25<=BMI<30:
    A='偏胖'
elif BMI>=30:
    A='肥胖'
if 18.5<=BMI<24:
    B='正常'
elif 24<=BMI<28:
    B='偏胖'
elif BMI>=28:
    B='肥胖'
print(f"BMI指标为：国际'{A}',国内'{B}'")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

乞丐

丐帮帮主去天桥乞讨，并把每天乞讨的钱都存起来。设帮主存款初始为 0，且不使用这笔钱。

第一天乞讨了 1 块钱；第二天乞讨了 2 块钱；第三天乞讨了 4 块钱；第四天乞讨了 8 块钱；以此类推。

# 请使用 input() 输入一个天数 day
day = int(input("请输入一个天数: "))
 
# 计算帮主这些天的总收入，并将每天的总收入输出
for i in range(1,day+1):
    s = 2 ** i - 1
    print(s)
1
2
3
4
5
6
7

水仙花数

"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如 153 = 1³ + 5³ + 3³，所以 153 是一个水仙花数。

请用程序实现，输入一个三位数，找出100~num(含)中的所有水仙花数，并将找出的水仙花数从小到大输出，每行输出1个数

for循环：

# 请使用 input() 输入一个三位数 num
num = int(input('请输入一个三位数: '))

# 请找出 100 - num(含) 中的所有水仙花数，并将找出的水仙花数输出
for i in range(100,num+1):
    a = int(i/100)
    b = int(i/10)%10
    c = i%10
    if i == c**3+b**3+a**3:
        print(i)
1
2
3
4
5
6
7
8
9
10

while循环：

# 请使用 input() 输入一个三位数 num
num = int(input('请输入一个三位数: '))
# 请找出 100 - num(含) 中的所有水仙花数，并将找出的水仙花数输出
s=100
while s<=num:
    ge=s%10
    shi=s//10%10
    bai=s//100
    if pow(ge,3)+pow(shi,3)+pow(bai,3)==s:
        print(s)
    s+=1
1
2
3
4
5
6
7
8
9
10
11

篮球弹跳

篮球从一定高度向下掉落，每一次弹起的高度，都是前一次高度的一半。一次掉落和一次弹起极为一次弹跳。假设篮球初始高度为10米。请用程序实现

输入篮球弹跳的次数num，计算num次后篮球所在的高度，并将计算结果输出。

# 请使用 input() 输入弹跳的次数 num

num=int(input("请输入弹跳的次数： "))
result=10
for i in range(0,num):
    result=result/2
print(result)

# 请计算弹跳 num 次后的篮球高度，并将结果输出
1
2
3
4
5
6
7
8
9

阶乘

请用程序实现，输入一个正整数num，计算这个正整数的阶乘，并将计算结果输出。

# 请使用 input() 输入一个正整数 num
num = int(input('请输入正整数: '))
 
# 请计算这个正整数的阶乘，并将计算结果输出
sum = 1
 
if num == 0:
    print("0的阶乘是1")
elif num < 0:
    print("负数没有阶乘")
else:
    for i in range(1,num + 1):
        sum = sum * i
    print(sum)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

猴子摘桃

一只猴子摘桃子, 第一天摘了两个桃, 以后每天摘的是前一天的两倍还多一个.

请用程序实现，输入一个天数day，计算第day天它摘的个数，并将结果输出。

# 请使用 input() 输入一个天数 day
day = int(input('请输入一个天数: '))
# 请计算第 day 天猴子摘的桃子个数，并将结果输出
i=2
res=2
while i<=day:
    res=2*res+1
    i+=1
print(res)
1
2
3
4
5
6
7
8
9

冰雹猜想

输入一个大于1的正整数num; 如果num为偶数, 就将它变为num / 2; 如果num为奇数, 就将它变为3 * num + 1; 直到num为1时停止。并将每一次运算的结果输出。

# 请使用 input() 输入一个整数 num
num = int(input("请输入一个整数: "))

# 编写程序验证冰雹猜想
while num !=1:
    if num%2==0:
            num = num // 2
            print(num)
    else:
            num = 3*num+1
            print(num)
1
2
3
4
5
6
7
8
9
10
11

忽略倍数

输入一个整数num，循环打印1(含)~num(含)中的整数，如果是3的倍数或5的倍数，则忽略。

# 请使用 input() 输入一个整数 num
num = int(input('请输入一个整数: '))

# 请打印 1(含) - num(含) 中的整数，如果是 3 的倍数或 5 的倍数，则忽略
for i in range(1,num+1):
    if i%3!=0 and i%5!=0: 
        print(i)  
1
2
3
4
5
6
7

素数

「质数」又称素数，有无限个。素数定义为在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的数称为素数。

例如17就是素数，因为它不能被2 - 16的任一整数整除。

请用程序实现: 输入一个大于 1 的整数num，输出1~num(含)中的所有的素数（每行输出1个素数，从小到大排列）

少语句：

# 请使用 input() 输入一个整数 num
num = int(input('请输入一个整数: '))
j = 1
# 输出 1 - num(含) 中的所有的素数
for i in range(num+1):
    for j in range(2,i):
        if i%j==0:
            break;
    if j==i-1:
        print(i)
1
2
3
4
5
6
7
8
9
10

增加判定：

请使用 input() 输入一个整数 num
num = int(input('请输入一个整数: '))
for i in range(2,num+1):
    fg=0
    for j in range(2,i-1):
        if i%j==0:
            fg=1
            break
    if fg==0:
        print(i)
# 输出 1 - num(含) 中的所有的素数
1
2
3
4
5
6
7
8
9
10
11

九九乘法表

str输出：

# 请在此处编写你的程序
for i in range(1,10):
    for j in range(1,i+1):
        print(str(j)+'x'+str(i)+'='+str(i*j),end=' ')
    print()
1
2
3
4
5

%输出：

# 请在此处编写你的程序
for i in range(1,10):
    for j in range(1,i+1):
        print('%sx%s=%s'%(i,j,i*j),end = " ")
    print()
1
2
3
4
5

随机密码生成

‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬以整数 17 为随机数种子，获取用户输入整数 N 为长度，产生 3 个长度为 N 位的密码，密码的每位是一个数字。每个密码单独一行输出。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

注意: 产生密码采用random.randint()函数。

# 请在...补充代码
import random

def genpwd(length):
    a = 10 ** (length - 1)
    b = 10 ** length - 1
    return "{}".format(random.randint(a,b))
length = eval(input())
#seed() 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。
random.seed(17)
#设置该种子后 每次随机出现的序列都是相同的
for i in range(3):
    print(genpwd(length))
1
2
3
4
5
6
7
8
9
10
11
12
13

猜数字

使用 python 实现猜数字游戏，即系统随机生成一个整数，通过 input() 函数，输入整数，根据系统给出的提示猜数字。

要求：

• 随机生成一个 1 - 100 之间的整数。
• 7 次猜数字的机会，如果没有猜正确，游戏结束。
• 输入字母 q，则退出游戏。

# 导入random模块
import random
# 生成随机数，并赋值给num变量
num = random.randint(1, 100)
# 定义 guess_chances 变量，初始化猜的次数
guess_chances = 7
print('您只有7次猜数字的机会哦！')
# 循环输入的次数
for i in range(1, guess_chances + 1):
    print('这是第' + str(i) + '次猜数字')
    # 实现对输入数字的判断
    guess=input("请输入数字：")
    if guess.isdigit():
        guess=int(guess)
        if guess<num:
            print('您输入的数字太小了，您还有'+str(guess_chances-i)+'次机会，请重新输入！')
        elif guess>num:
            print('您输入的数字太大了，您还有'+str(guess_chances-i)+'次机会，请重新输入！')
        elif guess==num:
            print('恭喜您猜对了！')
            break
        elif guess=='q':
            print("退出游戏")
            break
        else:
            print("输入的内容必须为整数")
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

圆周率的计算

求解圆周率可以采用蒙特卡罗方法，在一个正方形中撒点，根据在 1/4 圆内点的数量占总撒点数的比例计算圆周率值。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

请用程序实现：请以 123 作为随机数种子，获得用户输入的撒点数量，编写程序输出圆周率的值，保留小数点后 6 位。

解1

#调用random函数，并且使用了perf_counter这个函数，是可以用来计时的一部分
from random import random
from time import perf_counter
#定义变量，当作抛洒点的总数量
DARTS = 1000 * 1000
#撒在圆内部点为0
hits = 0.0
start = perf_counter()
for i in range(1,DARTS+1):
    x,y = random(),random()
    dist = pow(x ** 2 + y ** 2,0.5)
    if dist <= 1.0:
        hits = hits + 1
pi = 4 * (hits / DARTS)
print("圆周率值是:{}".format(pi))
print("运行时间是:{:.5f}s".format(perf_counter() - start))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

解2

import random
m = int(input())
# 统计落在圆内点的数量
n = 0
random.seed(123)
for i in range(m):
    # 随机生成-1到1之间的小数
    x = random.uniform(-1,1)
    y = random.uniform(-1,1)
    # 生成的点到圆心之间的距离
    len = pow(x**2+y**2,0.5)
    # 生成的点在圆内
    if len < 1:
        n += 1
#由于圆面积/正方形面积 = π/4 即π等于4*正方形面积 
pi = 4*(n/m)
print("%.6f"%pi)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

求π的近似值

输入精度 e，使用格雷戈里公式求 π 的近似值，精确到最后一项的绝对值小于 e.

输入格式:输入在一行中给出精度 e

输出格式:对于给定的输入，在一行中输出π的近似值。

解1

e = float(input())
# 请根据 e 计算 pi 的近似值
x=-1
n=2
result=1
while(1/(2*n-3)>=e):
    result = result+x*(1/(2*n-1))
    x=x*(-1)
    n=n+1
count=4*result
print(count)
1
2
3
4
5
6
7
8
9
10
11

解2

e = float(input())

# 请根据 e 计算 pi 的近似值
x = 0
n = 1
while True:      #不断循环去找出条件符合的结果
    x = x + pow(-1,n + 1) * (1/(2 * n - 1))   #格雷戈里公式
    if(e > abs(1/(2 * n - 1))):		
        break    #满足条件跳出循环
    else:
        n += 1
print(x*4)
1
2
3
4
5
6
7
8
9
10
11
12

解3

e = float(input())
#请根据e计算pi 的近似值sum = 0
item= 1time = 1
while item >= e:
    item = (1.6 / (2 *time - 1))
    sum += (1 if time % 2 != 0 else -1)*itemtime += 1
pi = sum *4
print(pi)
1
2
3
4
5
6
7
8

第六章 函数和代码复用

打招呼函数

用函数给某个人打招呼。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

"""
打招呼函数
要求：
1. 定义函数 say_hello
2. 有 1 个参数 name 表示要给谁打招呼
3. 实现函数功能，即在控制台打印：`你好，<name>，认识你很高兴！`（注：name 是函数的参数）
"""
def say_hello(name):
    print("你好，{}，认识你很高兴！".format(name))
say_hello("张三")
1
2
3
4
5
6
7
8
9
10

能否组成三角形函数

判断三条线段能否构成一个三角形，需要满足两条规则：

• 三角形的三条边长必须大于零。
• 任意两边之和必须大于第三边。

用函数判断三个数字能否构成三角形，并将判断结果返回。

参数说明 a, b, c均为整数。

"""
编写 is_triangle 函数，此函数有 3 个参数，分别为3个数字，
判断这3个数字所代表的边长能否组成一个三角形
"""
def is_triangle(a, b, c):
    """请实现函数"""
    if(a<=0 or b<=0 or c<=0):
        return -1
    else:
        if a+b>c and a+c>b and b+c>a:
            return 1
        else:
            return 0    
# 调用函数验证三边能否组成三角形    
print(is_triangle(3, 4, 5))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

计算n个自然数的立方和

编程实现：定义一个函数，其功能是计算 n 个自然数的立方和，如下图所示。

1. 定义函数 sumOfSeries
2. 有 1 个参数 n 表示自然数的个数
3. 有 1 个返回值，返回自然数的立方和
4. 调用函数，使函数执行后在控制台打印：‘和为：xx’

# 定义立方和的函数
def sumOfSeries(num):
    sum = 0
    for i in range(1,num+1):
        sum+= pow(i,3)
    return sum

# 调用函数
print("和为：",sumOfSeries(5)) 
1
2
3
4
5
6
7
8
9

简单计算器实现

编程题

请用程序实现

用函数实现 加、减、乘、除 的运算。

参数说明

num1,num2均为整数，表示需要进行计算的两个数字。

返回值说明

四个函数的返回值，均为执行对应操作后计算出来的值。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

# 定义加法函数 addition
def addition (num1, num2):
    return num1+num2

# 定义减法函数 subtraction
def subtraction (num1, num2):
    return num1-num2

# 定义乘法函数 multiplication
def multiplication (num1, num2):
    return num1*num2

# 定义除法函数 division
def division (num1, num2):
    return num1/num2

print(addition(3, 4))
print(subtraction(3, 4))
print(multiplication(3, 4))
print(division(12, 4))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

转换秒为时间

编程题

1 天有 86400 秒，那么 100000 秒相当于多长时间呢？

编程实现：完善函数convert_from_seconds，将一个指定的秒数转换为[天, 时, 分, 秒]的数据格式，并将其返回。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

解1

# 定义一个 convert_from_seconds 函数, 参数 seconds, 返回表示时间的列表
def convert_from_seconds (seconds):
    day = seconds // 86400
    hour = seconds % 86400  // 3600
    minutes = seconds// 60 % 60
    s = seconds % 60
    return [day,hour,minutes,s]
1
2
3
4
5
6
7

解2

#解2
def convert_from_seconds1 (seconds):
    #day,h,m,s
    int(seconds)
    day=seconds//86400
    h=(seconds-day*86400)//3600
    m=(seconds-day*86400-h*3600)//60
    s=(seconds-day*86400-h*3600-m*60)
    return [day,h,m,s]

print(convert_from_seconds(100000))
1
2
3
4
5
6
7
8
9
10
11

最大公约数

编程题

编程实现：按下面的要求，输出两个正整数的最大公约数。

• 定义函数 common_divisor(num1, num2)，该函数返回两个正整数的最大公约数；函数有两个参数，分别对应两个正整数；有1个返回值，代表求得的最大公约数。
• 接收两个输入值，调用函数 common_divisor，输出最大公约数。

# 定义并实现函数 common_divisor
def common_divisor(num1, num2):
    if num1 % num2 ==0:
        return num2
    else:
        if num1>num2:
            return common_divisor(num2,num1%num2)
        elif num1<num2:
            return common_divisor(num2,num1)

# 获取输入值，调用函数，输出最大公约数
num1=int(input("请输入第一个数"))
num2=int(input("请输入第二个数"))
result = common_divisor(num1, num2)
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

杨辉三角

编程题

杨辉三角，又称贾宪三角形、帕斯卡三角形，是二项式系数在三角形中的一种几何排列。以下是杨辉三角的前十行：

                  1
                1   1
              1   2   1
            1   3   3   1
          1   4   6   4   1
        1   5   10  10  5   1
      1   6   15  20  15  6   1
    1   7   21  35  35  21  7   1
  1   8   28  56  70  56  28  8   1
1   9   36  84  126 126 84  36  9   1
1
2
3
4
5
6
7
8
9
10

由上可以看出:

1. 每行端点与结尾的数为 1
2. 每个数等于它上方两数之和
3. 每行数字左右对称，且由 1 开始逐渐变大
4. 第 n 行的数字有 n 项

# 定义函数 pascal_triangle 接受参数 num，并返回杨辉三角第 num 行
def pascal_triangle(num):
    r=[1]
    for i in range(1,num):
        r.insert(0,0)
        for j in range(i):
            r[j] = r[j]+r[j+1]
    return r

# 调用函数
result = pascal_triangle(3)
print(result)
1
2
3
4
5
6
7
8
9
10
11
12

线性查找

编程题

线性查找指按一定的顺序检查列表中每一个元素，直到找到所要寻找的特定值为止示。

编程实现：定义一个函数，其功能是线性查找列表中的元素，如下图所示。请按下面的要求实现。

• 定义线性查找函数 linear_searching(list,size,target)，接收三个参数 要进行查找的列表(list)、列表长度(size)、目标元素(target)，在 list 中查找 target，如果 target 在 list 中则将 target 的位置（索引+1）返回；否则返回数字 -1。
• 列表元素已给出，接收输入的目标元素值，调用函数 linear_searching，输出查找结果，如果查到，则输出“该元素在第几个位置”；如果未查到，则输出“该元素不在列表

# 定义函数 linear_searching 接受参数 list, size, target，并将查找结果返回
def linear_searching(list,size,target):
    for i in range(size):
        if list[i]==target:
            return i+1
    return -1
        

# 输入目标元素值，调用函数，输出结果
l=[1,2,3,12,-10]
size = len(l)
target = int(input("输入目标元素"))
index = linear_searching(l,size,target)
if index == -1:
    print("该元素不在列表中")
else:
    print("该元素在第{}个位置".format(index))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

七段数码管绘制

编程题

七段数码管是一种展示数字的有效方式。

(1) 使用 time 库获得系统当前时间，格式如下：20190411‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(2) 绘制对应的七段数码管‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

(3) 数码管风格不限‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬

import turtle

def drawLine (draw):
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)
    
def drawDigit (digit):
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    
def drawDate (date):
    for i in date:
        drawDigit (eval(i))
        
def main ():
    turtle.setup(800,350)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate('20200609')
    turtle.hideturtle()
    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

斐波那契数列计算

编程题

形如1，1，2，3，5，8......的数列，被称之为斐波那契数列。这个数列的特点是从第三个数字开始，每个数字都等于前两个数字之和。

请用程序实现

用函数实现，计算斐波那契数列某项的值，并将计算结果返回。

函数定义

def fbi (num):
    pass
1
2

num是一个整数，表示斐波那契数列的项数。

返回值说明

函数返回一个整数，该整数为斐波那契数列第 num 项的值。

# 定义一个 fbi 函数，参数 num，返回斐波那契数列第 num 项的值。
def fbi(num):
    if num==1:
        return 1
    elif num==2:
        return 1
    else:
        return fbi(num-2)+fbi(num-1)

# 调用函数
print(fbi(20))
1
2
3
4
5
6
7
8
9
10
11

汉诺塔实践

编程题

请用程序实现

用函数实现汉诺塔的移动步骤拆解。

函数定义

def hanoi (n, src, dst, mid):
    pass
1
2

参数说明

• n是整数，表示圆柱 A 上面的圆盘个数。
• src是大写字母A，表示最左边的圆柱。
• dst是大写字母C，表示最右边的圆柱。
• mid是大写字母B，表示中间的圆柱。

返回值说明

此函数没有返回值，调用函数后函数输出圆盘移动的步骤。

# 请在...补充一行或多行代码
count = 0

def hanoi (n, src, dst, mid):
    global count
    if n == 1:
        count += 1
        print("{}: {}->{}".format(count, src, dst))
        
    else:
        hanoi(n-1,src,mid,dst)
        count += 1
        print("{}: {}->{}".format(count, src, dst))
       
        hanoi(n-1, mid, dst, src)
hanoi(3, "A", "C", "B")
print(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

合法的用户名

编程题

有一些网站注册用户时，会对用户名长度进行限制，比如要求用户名的长度必须在6(含)~18(含)位之间。

请用程序实现

用函数实现对注册用户名的合法性进行检查。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

函数定义

def check_username (username):
    pass
1
2

参数说明

username是一个任意长度的字符串，表示待检查的用户名。

返回值说明

如果用户名长度在6(含)~18(含)，则用户名有效，返回True；否则返回False。

"""
实现 check_username 函数，检查 username 是否有效
username 长度在 6-18 位之间，返回 True，否则返回 False
"""
def check_username(username):
    length = len(username)
    if length>=6 and length<=18:
        return True
    else:
        return False
# 调用函数
result = check_username('lisi')
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13

科赫雪花小包裹

编程题

科赫曲线，也叫雪花曲线。绘制科赫曲线。

请补充编程模板中代码，完成功能：获得用户输入的整数level，作为阶，绘制level阶科赫曲线。

# 请在...补充一行或多行代码

import turtle


def koch(size, n):
    if n==0:
        turtle.fd(size)
    else:
        for angle in [0,60,-120,60]:
            turtle.left(angle)
            koch(size/3,n-1)



def main(level):
    turtle.setup(600, 600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    #level=2
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()


try:
    level = eval(input("请输入科赫曲线的阶: "))
    main(level)
except:
    print("输入错误")

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

密码的强度

编程题

密码是账户的重要安全保障，涉及到安全问题，太简单的密码容易被猜到或破解。

请用程序实现

用函数实现一个校验密码强度的函数，用于提醒用户在注册时，密码是否足够安全。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

以下为密码强度校验规则：

1. 密码长度在 6 位及以上，强度 +1，在 8 位及以上，强度 +2，12 位及以上，强度 +4
2. 有大写字母，强度 +2
3. 除字母外，还包含数字，强度 +2
4. 有除字母、数字以外字符强度 +2

"""
实现密码强度计算函数:
1. 实现函数 passworld_strength 返回 0-10 的数值，表示强度，数值越高，密码强度越强
2. 密码长度在 6 位及以上，强度 +1，
   在 8 位及以上，强度 +2，
   在 12 位及以上，强度 +4
3. 有大写字母，强度 +2
4. 除字母外，还包含数字，强度 +2
5. 有除字母、数字以外字符，强度 +2
"""

def password_strength(pwd):
    intensity=0
    if len(pwd)>=12:
        intensity+=4
    elif 8<=len(pwd)<12:
        intensity+=2
    elif 6<=len(pwd)<8:
        intensity+=1
    pwdlist=list(pwd)
    for i in range(len(pwd)):
        if 'A'<=pwdlist[i]<='Z':
            intensity+=2
            break
    for i in range(len(pwd)):
        if 'A'<=pwdlist[i]<='Z' or 'a'<=pwdlist[i]<='z':
            for j in range(len(pwd)):
                if '0'<=pwdlist[j]<='9':
                    intensity+=2
                    break
        break
    for i in range(len(pwd)):
        if ('null'<=pwdlist[i]<'0') or ('9'<pwdlist[i]<='@') or ('Z'<pwdlist[i]<='`') or ('z'<pwdlist[i]<='~'):
            intensity+=2
            break
    return intensity
pwd1=str(input())
print(password_strength(pwd1))


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

藏头诗

poem1 = [
    "芦花丛中一扁舟",
    "俊杰俄从此地游",
    "义士若能知此理",
    "反躬难逃可无忧"
]

poem2 = [
    "我画蓝江水",
    "爱晚亭上枫",
    "秋月溶溶照",
    "香烟袅袅绕"
]


def acrostic(poems):
    string= ''
    for poem in poems:
        string+=poem[0]
    return string

print(acrostic(poem1))
print(acrostic(poem2))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

统计指定字符出现次数函数

编程题

用函数实现，统计字符串中指定字符出现的次数。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

解1

"""
统计字符串 string 中出现字符 char 的次数，并返回；
char 是长度为 1 的字符串。
"""
def sum_char(string, char):
    k = 0
    for i in range(len(string)):
        if char == string[i]:
            k = k+1
    return k
print(sum_char('hello,world','o'))

1
2
3
4
5
6
7
8
9
10
11
12

解2

描述

Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

count()方法语法：

str.count(sub, start= 0,end=len(string))
1

参数

• sub – 搜索的子字符串
• start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

str = "hello_world"
char = 'l'
print(str.count(char))
1
2
3

文件扩展名

编程题

文件扩展名是操作系统用来标记文件类型的一种机制。通常来说，一个扩展名是跟在主文件名后面的，由一个分隔符(.)分隔。

请用程序实现

用函数实现，将文件的扩展名获取出来。

函数定义

def file_ext (filename):
    pass
1
2

参数说明

filename是一个字符串，表示文件名。

返回值说明

如果 filename 有扩展名，则函数返回该 filename 的扩展名，否则返回文件名错误。请调用函数测验函数代码逻辑是否正确，不要获取键盘输入值。

"""
获取文件扩展名
说明：实现 file_ext 函数，该函数接受一个表示文件名的字符串参数 filename，返回它的扩展名
"""
def file_ext(filename):
    for i in range(len(filename)):
        if filename[i] == '.':
            return filename[i+1:]
filename = input()
print(file_ext(filename))
1
2
3
4
5
6
7
8
9
10

插入排序

编程题

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

定义一个函数，其功能是进行插入排序，如下图所示。请编写函数完成要求。

# 定义函数 insertion_sort 接受参数 list_sort，并返回插入排序结果。
def insertion_sort(list_sort):
    for i in range(len(list_sort)):
        j = i 
        # 和有序表中的每个一样元素进行比较 从最后一个开始
        while j > 0:
            if list_sort[j] < list_sort[j-1]:
                list_sort[j],list_sort[j-1] = list_sort[j-1],list_sort[j]
                j -= 1
            else:
                break
    return list_sort
list_sort = [9,8,8,7,6,5,4,3,2,1]
print(insertion_sort(list_sort))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

选择排序

编程题

选择排序（Selection sort）是一种简单直观的排序算法。

它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，

然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

# 定义函数 selection_sort 接受参数 list_sort，并返回选择排序结果。
def selection_sort(list_sort):
    for i in range(len(list_sort)):
        for j in range(i,len(list_sort)):
            if list_sort[i] > list_sort[j]:
                    list_sort[i], list_sort[j] = list_sort[j], list_sort[i]
    return list_sort             
list_sort = [9, 8, 7, 6, 5, 4, 3, 2, 1]
print(selection_sort(list_sort))            
1
2
3
4
5
6
7
8
9

冒泡排序

编程题

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

# 定义函数 bubble_sort 接受参数 list_sort，并返回冒泡排序结果
def bubble_sort(list_sort):
    n = len(list_sort)
    for i in range(n):
        for j in range(0,n-i-1):
            if list_sort[j] > list_sort[j+1]:
                    list_sort[j], list_sort[j+1] = list_sort[j+1], list_sort[j]
    return list_sort
sort = [2,4,2,8,4,6,1]
print(bubble_sort(sort))
1
2
3
4
5
6
7
8
9
10

二分查找

编程题

二分搜索是一种在有序数组中查找某一特定元素的搜索算法。

搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；

如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。

这种搜索算法每一次比较都使搜索范围缩小一半。

定义一个函数，其功能是进行二分查找，如下图所示。请编写函数完成要求。

# 定义函数 binary_search 接受参数 list_sort, size, targer，并将查找结果返回
def binary_search(list_sort, size, targer):
    middle = size//2
    if targer == list_sort[middle]:
        return middle
    elif targer>=list_sort[middle]:
        for i in range(middle,size):
            if targer == list_sort[i]:
                return i
            return -1
    else:
         for i in range(0,middle):
            if targer == list_sort[i]:
                return i
            return -1
              
list_sort =[1,2,3,5,6,7,8]
print(binary_search(list_sort,7,6))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

第七章 组合数据类型

集合运算

程序中已经存在 manager 集合存储公司所有的经理名字，technician 集合存储所有的技术员的名字。

请编写代码按照下面的要求，生成新的集合。

1. 将既是经理又是技术员的职员保存到集合 set1 中，并输出
2. 将是经理但不是技术员的职员保存到集合 set2 中，并输出
3. 将是技术员但不是经理的职员保存到集合 set3 中，并输出
4. 将身兼一职的职员保存到集合 set4 中，并输出
5. 判断 张飞 是否是经理，如果是经理，输出「yes」；不是输出「no」
6. 求经理和技术员有几人，并将结果输出

# 将既是经理又是技术员的职员保存到集合 set1 中，并输出
set1 = manager & technician
print(set1)
# 将是经理但不是技术员的职员保存到集合 set2 中，并输出
set2 = manager - technician
print(set2)
# 将是技术员但不是经理的职员保存到集合 set3 中，并输出
set3 = technician - manager
print(set3)
# 将身兼一职的职员保存到集合 set4 中，并输出
set4 = manager ^ technician
print(set4)
# 判断 张飞 是否是经理
set5 = {"张飞"}
if "张飞" in manager:
    print("「yes」")
else:
    print("「no」")
print(set5)
# 求出经理和技术员有几人，并将结果输出
print(len(manager | technician))
# |去除了两个集合之中重复的元素 只保留1个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

集合的关系

请通过集合操作符判断集合 set1和set2的子集关系，具体要求如下：

1. 若set1＜set2，则输出set1是set2的子集；
2. 若set1>set2，则输出set1包含set2；
3. 若set1=set2一样，则输出set1和set2互为子集。
4. 否则输出 set1和set2无关

解1

# 创建两个集合
set1 = {2, 3, 4, 5, 6}
set2 = {2, 4, 6}

# 判断两集合关系
if set1 < set2:
    print("set1是set2的子集")
elif set1 > set2:
    print("set1包含set2")
elif set1 == set2:
    print("set1和set2互为子集")
else:
    print("ser1和set2无关")
1
2
3
4
5
6
7
8
9
10
11
12
13

解2

#issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
set1 = {2, 3, 4, 5, 6}
set2 = {2, 4, 6}
if (set1.issubset(set2) and set2.issuperset(set1)) or set1 == set2 == null:
    print('set2是set1的真超集，set1是set2的真子集')
elif set2.issubset(set1) and set1.issuperset(set2):
    print('set1是set2的真超集，set2是set1的真子集')
elif set1 == set2:
    print('set1和set2互为子集')
else:
    print('set1和set2没有关系')
1
2
3
4
5
6
7
8
9
10
11

集合综合练习

已知某学校的某次考试成绩分班级保存在集合 score1, score2, score3, score4, score5 中，5个集合都已存在，可直接使用。

请用集合解决以下问题：

1. 突然发现 score1 的数据格式为列表，请将 score1 转换为集合，并将集合 score1 输出
2. 使用 add() 方法将数据 10 添加到集合 score2 中，并将集合 score2 输出
3. 使用 update() 方法将数据 {11, 12, 13} 添加到集合 score3 中，并将集合 score3 输出
4. 使用 remove() 方法将数据 83 从集合 score4 中删除，并将集合 score4 输出
5. 使用 clear() 方法将集合 score5 中的数据清空，并将集合 score5 输出

# 将 score1 转换为集合
score1 = set(score1) 
print(score1)
# 将 10 添加到 score2 中
score2.add(10)
print(score2)
# 将 {11, 12, 13} 添加到 score3 中
score3.update({11,12,13})
print(score3)
# 将 83 从 score4 中删除
score4.remove(83)
print(score4)
# 将 score5 清空
score5.clear()
print(score5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

添加元素方法

add 元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作

update 添加元素，且参数可以是列表，元组，字典等

移除元素方法

**remove **元素 x 从集合 s 中移除，如果元素不存在，则会发生错误

discard 如果元素不存在，不会发生错误

pop 随机删除集合中的一个元素 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

元组元素抓7

请用程序实现：找出元组 tuple_pre 中元素是 7 的倍数或个位为 7 的数，并将计算结果输出。

注意：元组 tuple_pre 已存在，可以直接使用 tuple_pre。

解1

tuple_pre = (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)

# 请计算元组 tuple_pre 中元素是7的倍数及个位为7的数，并将计算结果输出
for i in range(len(tuple_pre)):
    if tuple_pre[i] % 7 == 0 or tuple_pre[i] % 10 == 7:
        print(tuple_pre[i])
1
2
3
4
5
6

解2

tuple_pre = (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)
# 请计算元组 tuple_pre 中元素是7的倍数及个位为7的数，并将计算结果输出
for i in tuple_pre:
    if i % 7 == 0 or i % 10 == 7:
        print(i)
1
2
3
4
5

元组解包

“*” 的使用。在对一个元组进行解包时，变量的数量必须和元组中的元素数量一致，也可以在变量前边添加一个 * 号，这样变量将会获取元组中所有剩余的元素。

my_tuple = 10, 20, 30, 40

# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a, b, *c = my_tuple
print('1. a =', a, 'b =', b, 'c =', c)

a, *b, c = my_tuple
print('2. a =', a, 'b =', b, 'c =', c)

*a, b, c = my_tuple
print('3. a =', a, 'b =', b, 'c =', c)

a, b, *c = [1, 2, 3, 4, 5, 6, 7]
print('4. a =', a, 'b =', b, 'c =', c)

a, b, *c = 'hello world'
print('5. a =', a, 'b =', b, 'c =', c)

# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

升序降序

编写程序，将列表中的前10个元素升序排列，后10个元素降序排列，并输出结果。

解1

# 打印输出 list_pre
print(list_pre)
# 请对上面列表中的元素进行排序
list_pre[:10] = sorted(list_pre[:10])
list_pre[10:] = sorted(list_pre[10:],reverse=True)
print(list_pre)
1
2
3
4
5
6

解2

# 打印输出 list_pre
print(list_pre)
# 请对上面列表中的元素进行排序
list1 = list_pre[0:10]
list1.sort()
list2 = list_pre[-10:]
list2.sort(reverse=True)
print(list1+list2)
1
2
3
4
5
6
7
8

截取部分元素

将列表list_pre中的部分元素截取到列表list_new中。

在两行中分别输入两个非负整数，表示需要截取的索引段，且第一个数小于第二个数。

list_pre = [23, 7, 54, 53, 36, 42, 2, 24, 76, 70, 18, 35, 44, 1, 9, 6, 8, 75, 49]

# 请使用 input() 输入两个正整数 begin, end
begin = int(input('请输入第一个索引: '))
end = int(input('请输入第二个索引: '))

# 将列表 list_pre 中下标从 begin(含) 到 end(含) 的元素截取到列表 list_new 中，并将 list_new 输出
list_new = list_pre[begin:end+1]
print(list_new)
1
2
3
4
5
6
7
8
9

判断元素是否在列表中存在

请用程序实现：判断指定元素是否存在于列表 list_test 中。

注意：要求分别用 for 循环与 in 关键字完成练习，列表 list_test 已存在，可以直接使用 list_test。

# 打印输出 list_test
print(list_test)
 
# 使用for循环判断元素 4 是否存在于 list_test 列表中
 
print("查看 4 是否在列表中 ( 使用循环 ) : ") 
  
for i in list_test: 
    if(i == 4) : 
        print ("存在") 
        
# 使用in关键字判断元素 4 是否存在于 list_test 列表中
 
print("查看 4 是否在列表中 ( 使用 in 关键字 ) : ") 
 
if 4 in list_test: 
    print ("存在") 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

头尾对调

请用程序实现：将列表 list_ht 中的头尾两个元素对调，并将对调的结果输出。

# 打印输出 list_ht
print(list_ht)

# 将列表 list_ht 中的头尾两个元素对调，并将对调的结果输出
list_ht[0],list_ht[-1] = list_ht[-1],list_ht[0]
print(list_ht)
1
2
3
4
5
6

翻转列表

请用程序实现，将列表 list_reverse 翻转，并将翻转后的列表输出。

# 打印输出 list_reverse
print(list_reverse)

# 将列表翻转
list_reverse.reverse()
print(list_reverse)
1
2
3
4
5
6

指定元素对调

请用程序实现，将列表list_swap 中所指定的元素对调到列表的尾部，并输出对调后的列表，如下图所示。

# 打印输出 list_swap
print(list_swap)

# 将列表 list_swap 中的第1、2个元素对调到列表的尾部
for i in range(2):
    temp = list_swap[0]
    for i in range(6):
        list_swap[i] = list_swap[i + 1]
    list_swap[6] = temp
print(list_swap)
1
2
3
4
5
6
7
8
9
10

约瑟夫生者死者小游戏

编程题

一条船上有 num 个人(num为偶数)，超载了，需要一半的人下船。于是人们排成一排，排队的位置即为他们的编号。他们从头开始从 1 开始报数，数到某个数字的人下船，并且下一个人又从 1 开始报数，如此循环，直到船上只有原来一半人为止。

请用程序实现：输入表示船上总人数的偶数 num 和需要下船的特殊数字 special_num，输出下船人的编号。

num = int(eval(input("请输入船上的总人数:")))
special_num = int(eval(input("请输入需要下船的特殊数字:")))
people = []
for i in range(1,num+1):
    people.append(i)
longth= int(num/2)
repo = 1
while(len(people)>longth):
    if repo != special_num:
        pp = people.pop(0)
        people.append(pp)
    else:
        pp = people.pop(0)
        print(pp)
        repo = 0
    repo = repo + 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

计算列表元素之和

已存在定义好的列表list_sum，请计算列表list_sum中的所有元素之和，并将计算结果输出。

# 请计算列表 list_sum 中的所有元素之和，并将计算结果输出
sum = 0
for i in list_sum:
    sum = sum+i
print(sum)
1
2
3
4
5

计算总分和平均分

小明刚结束期末考试，他将自己各科的分数保存到了列表scores中，现在，请帮他进行如下计算：

• 计算总分，并将计算结果保存到变量total_score中
• 计算平均分，并将计算结果保存到变量avg_score中

# 小明的期末考试成绩分数如下：

scores = [95, 69, 98, 74, 64, 72, 53, 92, 83]

# 请计算小明的总分、平均分，并保存至变量 total_score, avg_score 中

total_score=0
for i in scores:
    total_score += i
avg_score = total_score/9
print(total_score)
print(avg_score)
1
2
3
4
5
6
7
8
9
10
11
12

添加用户

users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923"
}
users["zhangsan"] ="zs123456"
users["lisi"] = "si123456"
1
2
3
4
5
6
7

模拟用户登录

用键盘模拟用户输入，判断输入的用户名或密码是否正确，并输出登录信息。

• 如果输入的用户名存在，且密码正确，则输出success
• 如果输入的用户名存在，但密码不正确，则输出password error
• 如果输入的用户名不存在，则输出not found

users = {
    "alpha": "alpha123",
    "beta": "betaisverygood",
    "gamma": "1919191923",
    "zhangsan": "123456",
    "lisi": "123456",
    "admin": "ADMIN",
    "root": "Root123"
}
 
username = input()
password = input()
 
if username not in users:
    print("not found")
elif users[username] != password:
    print("password error")
else:
    print("success")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第八章 文件和数据格式化

读取文件并显示不以 # 开头的所有行

读取当前目录下的 data.txt 文件，显示除了以 # 开头的行以外的所有行

# 读取 data.txt 并将其中非井号（#）开头的行打印到控制台标准输出中
#创建一个空的列表
new = []
#文件以只读方式打开
text = open('data.txt','r')
#从文件读出所有行赋给text列表
contents = text.readlines()
#遍历contents列表
for i in contents:
    #若列表内容开始不为#
    if i.startswith('#') == False:
        #将列表内容添加到new列表中去
        new.append(i)
#关闭文件 释放文件使用授权
text.close()
#将序列中的元素以指定的字符(换行符)连接生成一个新的字符串输出
print('\n'.join(new))        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

读取文件中的数字并排序输出

已知文本文件 data.txt 中存放了若干数字，每个数字之间以空格分隔。

请编程读取文件中所有的数字，并以从大到小的方式输出到控制台，输出方式为每个数字之间用空格分隔。

"""
编程读取 data.txt 文件
并以从大到小的方式输出到控制台
"""
#以只读方式打开文件
f = open("data.txt", "r", encoding='utf8')
#读入文件内容返回字符串存储在s之中
s = f.read()
#将s进行字符串分割
l = s.split(' ')
#生成器表达式 int函数取整数 每一个x均来自于l字符串
l = [int(x) for x in l]
#排序从小到大
l.sort()
#字符串的反转
l.reverse()
print(' '.join([str(x) for x in l]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

生成器表达式实例

 s=input('请输入4个数,用英文逗号分隔:')
 l=s.split(',')
 l=[int(x) for x in l]
 print('最大值:',max(l),'最小值:',min(l))
1
2
3
4

统计文件中关键字出现的次数

综合项目

读取当前目录下的 data.txt 文件，请编程统计关键字中国出现的次数，并输出到控制台。

data.txt 内容

['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人']
1

输出

3
1

"""
读取 data.txt 中的内容
统计关键字中国出现的次数，输出至控制台
"""
text = open('data.txt')
s = text.readlines()
k = 0
text.close()

#count()函数：统计在字符串/列表/元组中某个字符出现的次数，可以设置起始位置或结束位置
for i in s:
    k +=i.count("中国")
print(k)
1
2
3
4
5
6
7
8
9
10
11
12
13

读取文件进行大小写转换

已知文本文件 data.txt 中存放了若干字母，每个字母之间以空格分隔。

请编程读取文件中所有的字母，把其中的大写字母变成小写字母，小写字母变成大写字母，将转化后的字母写到一个新文件result.txt中。

data.txt 内容

a b c D E f z
1

result.txt 内容

A B C d e F Z
1

"""
读取 data.txt 中空格分隔的字母列表，
并将字母进行大小写转化，然后输出至 result.txt
"""
a = open("data.txt")
c = a.readlines()
a.close()
g = " ".join(c)  # 将列表转化为字符串
g = g.swapcase() # 将字符串大小写进行转化
print(g)
f = open("result.txt","w")  # 写入文件
f.write(g)
f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14

对文件内容加密

综合项目

已知文本文件 data.txt 中存放有若干英文字符，每个字符之间以空格分隔，请将该文件中每个英文字母加密后写到一个新文件secret.txt中。

加密规则是：将A变成B，B变成C，…,Y变成Z, Z变成A, a变成b，b变成c，…. y变成z, z变成a,其他字符不变。

data.txt 内容

A B 1 a Y Z
1

secret.txt

B C 1 b Z A
1

"""
读取 data.txt 中空格分隔的字符列表，
并将字符按加密规则进行加密，输出至 secret.txt
"""
f = open("data.txt","r")
content = f.read()
newStr = ""
for i in content:
    temp = ord(i)
    if temp in range(65,91):
        #字母是z 返回a 
        if temp == 90:
            char1 = chr(temp-25)
            newStr += char1
        else:
            char2 = chr(temp + 1)
            newStr += char2 
    elif temp in range(97,123):
        if temp ==122:
            char3 = chr(temp-25)
            newStr += char3
        else:
            char4 = chr(temp + 1)
            newStr += char4
    else:
         newStr = newStr + i
f.close()
f2 = open("secret.txt",'w+')
f2.write(newStr)
f2.seek(0)
for line in f2:
    print(line)
f2.close()
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

文件拷贝

综合项目

已知文本文件 data.txt 中存放了若干内容。

请编程在当前目录下产生一个相同文件的副本data_cp.txt，实现文件的拷贝功能。

"""
编程实现文件拷贝功能
"""
strNew = ''
text = open('data.txt')
content = text.readlines()
for i in content:
    strNew = strNew + i
text.close()
text2 = open('data_cp.txt','w+')
text2.write(strNew)
text2.close()
1
2
3
4
5
6
7
8
9
10
11
12

统计文件行数

已知文本文件 data.txt 中每行包含一段英文。

请编程读取文件中的全部内容，统计行数，并按要求输出至控制台。

"""
请编程读取文件中的全部内容,
统计行数，并按要求输出至控制台。
"""
s = open('data.txt')
context = s.readlines()
k = 0
for i in context:
    k = k+1 
s.close()
print(k)
1
2
3
4
5
6
7
8
9
10
11

统计文件中以P开头的总行数

已知文本文件 data.txt 中每行包含一段英文。

请编程读取文件中的全部内容，统计文件中以大写字母P开头的总行数，并按要求输出至控制台。

"""
请编程读取文件中的全部内容,
统计以大写P开头的总行数，并按要求输出至控制台。
"""
s = open('data.txt')
context = s.readlines()
k = 0
for i in context:
    if i.startswith('P'):
          k = k+1 
s.close()
print(k)
1
2
3
4
5
6
7
8
9
10
11
12