Python刷题：流程控制（下）

本日刷的是PythonTip的Python 入门挑衅中的题，团体难度不高，得当小白练手以及巩固知识点。下面会举行具体解说。

---

逐日一句

在无人问津的角落里，
默默积极的人独自发光，
孤独是他们奋斗路上的常客，
却也是结果他们的气力。

---

目录
逐日一句
21.天然数求和
22.一个整数的全部因子
23.判断质数
24.一个整数有多少位？
25.不要3的倍数
26.直到用户输入0
27.打印正整数
28.斐波那契数列
29.打印小于n的斐波那契数
30.判断完全平方数
总结

---

21.天然数求和

   写一个步伐来：盘算前N个天然数的总和。
  

• 获取一个变量 n 的整数输入。
  
• 运行一个从 1 到 n 的循环。
  
• 在这个循环中，盘算从1到 n 的全部数字的总和。
  
• 打印结果。
  

  输入格式：一个整数
  剖析：
第一步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个整数 n。
2.由于输入的是字符串，将其转换为整数类型，存储在 n 变量中。这是由于我们要对 n 举行计数利用，使用整数可以精确表现数目。
第二步：盘算总和
1.初始化一个变量 sum_total 为 0，用于存储从 1 到 n 的数字总和。
2.使用 for 循环从 1 迭代到 n，可以使用 for i in range(1, n + 1) 如许的语句，其中 i 是迭代变量，range(1, n + 1) 会天生从 1 到 n 的整数序列（包罗 1 和 n）。
3.在 for 循环内部，将 i 的值累加到 sum_total 中。每次迭代，sum_total 的值会更新为其原有的值加上当前迭代变量 i 的值，实现求和利用。
第三步：输出结果
使用 print() 函数将存储在 sum_total 中的总和结果打印出来，以便用户查察从 1 到 n 的天然数总和。
代码如下：

1. n = int(input())
2.   
3. # 初始化累加器
4. add = 0
5.    
6. # 循环
7. for i in range (1,n+1):
8.     # 增加i到累加器
9.     add = add + i
10.   
11. # 打印结果
12. print(add)

复制代码

22.一个整数的全部因子

   写一个步伐: 打印出一个数字的全部因子。
  

• 获取一个整数输入并将其分配给number变量。
  
• 创建一个 "for" 循环，从1到 number 举行循环。
  
• 在这个循环中，查抄number是否能完全被i整除（余数0）。
  
• 如果是，则打印i的值。
  

  输入格式：一个正整数
  剖析：
第一步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 number 变量中。由于我们要对这个数字举行因子的盘算，使用整数类型可以确保盘算的精确性。
第二步：创建并实行 for 循环
1.使用 for 循环从 1 迭代到 number。可以使用 for i in range(1, number + 1) 如许的语句，其中 i 是迭代变量，range(1, number + 1) 会天生从 1 到 number 的整数序列（包罗 1 和 number）。
2.在 for 循环内部，查抄 number 是否能被 i 整除，也就是盘算 number 除以 i 的余数是否为 0。可以使用取余运算符 % 来盘算余数，即 number % i == 0。
第三步：输出因子
如果 number 除以 i 的余数为 0，说明 i 是 number 的一个因子，使用 print() 函数将 i 的值打印出来，如许就可以找到并输出 number 的全部因子。
代码如下：

1. number = int(input())
3. # 循环
4. for i in range (1,number+1):
5.     # 判断i是否能整除 number
6.     # 如果是，打印i
7.     if number % i == 0:
8.         print(i)

复制代码

23.判断质数

   写一个步伐: 判断一个数字是否是质数。
  质数是一个只能被1或其自己整除的数字。比方，7，5，19，等等。
  

• 输入一个数字并赋值给变量 number。
  
• 判断number 可否被从2到number的某一个数字整除。
  
• 如果该数可以被除，则打印 "不是质数"。否则，打印 "质数"。
  

  输入格式：一个整数
  剖析：
第一步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 number 变量中。这是由于我们要对这个数字举行质数的判断，使用整数类型便于后续的整除运算。
第二步：判断是否为质数
1.起首，思量特别环境，如果 number 小于便是 1，它不是质数，直接打印 "不是质数"。
2,.对于 number 大于 1 的环境，使用 for 循环从 2 迭代到 number - 1。可以使用 for i in range(2, number) 如许的语句，其中 i 是迭代变量，range(2, number) 会天生从 2 到 number - 1 的整数序列（包罗 2 但不包罗 number）。
3.在 for 循环内部，查抄 number 是否能被 i 整除，也就是盘算 number 除以 i 的余数是否为 0。可以使用取余运算符 % 来盘算余数，即 number % i == 0。
4.如果 number 除以 i 的余数为 0，说明 number 能被 i 整除，那么它不是质数，使用 print() 函数打印 "不是质数"，并使用 break 语句停止循环，由于已经确定该数不是质数，无需继续查抄。
5.如果 for 循环正常竣事（即没有被 break），说明 number 不能被 2 到 number - 1 中的任何数整除，它是质数，使用 print() 函数打印 "质数"。
代码如下：

1. number = int(input())
3. # 标记number是否为质数，0是，1 不是
4. flag = 0
6. # 创建一个2到`number`的循环。不包括`number`。
7. for i in range (2,number):
8.     # 判断循环过程的数是否能被`number`整除。
9.     # 如果是，则设置标志位，表明不是质数
10.     if number % i ==0:
11.         flag = 1
13. # 打印是否是质数。
14. if flag == 0:
15.     print("质数")
16. else:
17.     print("不是质数")

复制代码

24.一个整数有多少位？

   编写一个步伐来盘算一个数字的位数。
  

• 输入一个整数并存储在number变量中。
  
• 创建一个整数变量count并将数值0赋给它。
  
• 创建一个while循环，只要number未便是0就循环。
  
• 循环中，每次可以将number整除10，得到商，从而去掉末了一个数字。
  
• count增长1。
  
• 在循环外，打印count的值。
  

  假设： 假设用户总是输入一个正数。
  输入格式：一个整数
  剖析：
第一步：获取输入
1,.使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 number 变量中。这是由于我们要对该数字举行位数的盘算，使用整数便于后续的数学运算。
第二步：初始化计数器
创建一个整数变量 count 并将其初始化为 0。这个变量将用于计数数字的位数。
第三步：使用 while 循环盘算位数
1.使用 while 循环，只要 number 未便是 0 就实行循环体。
2.在循环内部，将 number 除以 10 取整（使用 // 运算符），得到的商存储回 number 变量中。如许每次循环会去掉 number 的末了一位数字。
3.每次循环时，将 count 的值加 1，用于纪录数字的位数。
第四步：输出结果
在 while 循环竣事后，使用 print() 函数将 count 的值打印出来，显示输入数字的位数。
代码如下：

1. number = int(input())
3. count = 0
5. # 如果number不等于0，就循环。
6. while number != 0:
7.     # 除以10。
8.     number = number // 10
10.     # 位数增加1
11.     count += 1
13. # 打印结果
14. print(count)

复制代码

25.不要3的倍数

   写一个步伐：打印从1到n的全部数字，除了3的倍数。
  

• 运行一个从i = 1到n的for循环。
  
• 查抄 i是否能完全被3整除。
  
• 如果i能被3整除，跳过这个循环，进入下一个迭代。
  
• 打印i的值。
  

  输入格式：一个整数
  剖析：
第一步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 n 变量中。由于我们要确定打印数字的范围，使用整数类型可以精确表树模围的上限。
第二步：创建并实行 for 循环
1.使用 for 循环从 1 迭代到 n。可以使用 for i in range(1, n + 1) 如许的语句，其中 i 是迭代变量，range(1, n + 1) 会天生从 1 到 n 的整数序列（包罗 1 和 n）。
第三步：查抄并处理惩罚数字
1.在 for 循环内部，使用取余运算符 % 来查抄 i 是否能被 3 整除，即 i % 3 == 0。
2.如果 i 能被 3 整除，使用 continue 语句跳过当前迭代，直接进入下一个迭代，不实行后续的打印利用。
3.如果 i 不能被 3 整除，使用 print() 函数将 i 的值打印出来，如许就可以打印出从 1 到 n 中除了 3 的倍数以外的全部数字。
代码如下：

1. n = int(input())
3. # 循环
4. for i in range (1, n+1):
5.     # 是否能被3整除
6.     if i % 3 == 0:
7.         # 如果是，跳过
8.         continue
9.     # 打印
10.     print(i)

复制代码

26.直到用户输入0

   写一个步伐：打印数字，直到用户输入0则制止。
  

• 运行一个始终为 True 的 while 循环。
  
• 在这个循环中，用户输入一个整数值，并把它存储在number变量中。
  
• 判断该值是否为0。
  
• 如果输入值是0，则停止循环。
  
• 否打印全部 number的值。
  

  输入格式：多个整数
  剖析：
第一步：设置循环
使用 while True 创建一个无穷循环，由于要连续吸收用户输入，直到输入为 0 才制止。
第二步：获取用户输入
1.在 while 循环内部，使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 number 变量中。这是为了对用户输入的数字举行判断和处理惩罚。
第三步：查抄输入并处理惩罚
1.使用 if 语句查抄 number 的值是否为 0。
2.如果 number 为 0，使用 break 语句停止 while 循环，由于输入为 0 时步伐应该制止吸收和打印数字。
3.如果 number 不为 0，使用 print() 函数将 number 的值打印出来，以显示用户输入的非零数字。
代码如下：

1. # 一直为真的循环
2. while True:
3.     # 输入一个数字
4.     number = int(input())
5.    
6.     # 如果是0停止循环
7.     if number == 0:
8.         break
10.     # 打印数字
11.     print(number)

复制代码

27.打印正整数

   编写一个步伐：打印正整数数字。
  

• 运行一个条件为真的循环while True:
  
• 在每次循环中，输入一个整数值，并将其存储在number变量中。
  
• 查抄number是否小于0。如果是，跳过当前迭代。
  
• 查抄number是否便是0。如果是，停止循环。
  
• 如果用户输入的是一个正数，打印全部number的值。
  

  输入格式：多个整数
  剖析：
第一步：设置循环
使用 while True 创建一个无穷循环，由于步伐须要不断吸收用户的输入，直到满足停止条件。
第二步：获取用户输入
1.在 while 循环内部，使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 number 变量中。如许做是为了方便后续对输入数字举行巨细比力和其他处理惩罚。
第三步：查抄输入数字并举行相应处理惩罚
1.使用 if 语句查抄 number 是否小于 0。
2.如果 number 小于 0，使用 continue 语句跳过当前迭代，直接进入下一次迭代，不举行后续的利用。
3.使用另一个 if 语句查抄 number 是否便是 0。
4.如果 number 便是 0，使用 break 语句停止 while 循环，由于当输入为 0 时，步伐须要制止运行。
5.如果 number 是正数（既不小于 0 也未便是 0），使用 print() 函数将 number 的值打印出来，如许用户输入的正整数将被输出。
代码如下：

1. # 一直为真的循环
2. while True:
3.     # 输入一个数字
4.     number = int(input())
6.     # 判断是否小于0
7.     if number < 0 :
8.       continue
10.     # 判断是否等于0
11.     if number == 0 :
12.       break
13.   
14.     # 打印数字
15.     print(number)

复制代码

28.斐波那契数列

   写一个步伐：打印斐波那契数列。
  提示:斐波那契数列是一系列的数字，其中下一个数字是前面两个数字的和。比方：
  1 1 2 3 5 8 ...
  任务:
  

• 输入一个整数，并将其存储在n中。
  
• 界说两个整数变量t1和t2，其值均为1。
  
• 使用一个for循环，从i = 1到n，包罗n举行循环。
  
• 在每个循环中
  
  
  • 打印t1的值。
    
  • 界说 result 为 t1 和 t2 之和。
    
  • 将 t2 的值分配给 t1。
    
  • 将 result 的值分配给 t2。
    
  
  

  输入格式：一个正整数
  剖析：
第一步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个正整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 n 变量中。这是由于 n 将决定斐波那契数列的长度，使用整数可以精确表现数列的项数。
第二步：初始化变量
1.界说两个整数变量 t1 和 t2，并将它们的值初始化为 1。这是斐波那契数列的前两项，后续的项将基于这两项盘算得出。
第三步：使用 for 循环天生斐波那契数列
1.使用 for 循环从 1 迭代到 n。可以使用 for i in range(1, n + 1) 如许的语句，其中 i 是迭代变量，range(1, n + 1) 会天生从 1 到 n 的整数序列（包罗 1 和 n）。
2.在 for 循环内部：
(1).起首，使用 print() 函数打印 t1 的值，由于 t1 是当前斐波那契数列的项。
(2).盘算 result，它是 t1 和 t2 的和，使用 result = t1 + t2。
(3).将 t2 的值赋给 t1，这是将当前项更新为前一项，为下一个数的盘算做准备。
(4).将 result 的值赋给 t2，这是将 result 作为下一项的盘算结果存储起来，用于下一次迭代。
代码如下：

1. n = int(input())
2. t1 = 1
3. t2 = 1
4. result = 0
6. # 1到n的循环
7. for i in range(1,n+1):
8.     # 打印t1
9.     print(t1)
10.   
11.     # 定义result为t1和t2之和
12.     result = t1 + t2
14.     # 将 `t2` 的值分配给 `t1`
15.     t1 = t2
17.     # 将 `result` 的值分配给 `t2`
18.     t2 = result

复制代码

29.打印小于n的斐波那契数

   写一个步伐：打印全部小于n的斐波那契数。
  提示: 斐波那契数列是一系列的数字，其中一个数字是末了两个数字的相加。好比说：
  1 1 2 3 5 ...
  任务：
  

• 继承用户的整数输入，并将其存储在n中。
  
• 界说两个整数变量t1和t2，其值均为1。
  
• 当t1小于n时，运行循环。
  
• 在每个循环中，打印t1的值。
  
• 同时，界说result 变量为t1和t2之和。
  
• 将t2的值分配给t1。
  
• 将 result 的值分配给 t2。
  

  输入格式：一个正整数
  剖析：
第一步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个正整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 n 变量中。由于我们要根据这个数字 n 来确定打印斐波那契数的范围，使用整数可以更精确地举行比力和盘算。
第二步：初始化变量
界说两个整数变量 t1 和 t2，并将它们的值初始化为 1。这是斐波那契数列的前两项，后续的项将基于这两项盘算得出。
第三步：使用循环打印小于 n 的斐波那契数
1.使用 while 循环，循环条件为 t1 < n。只要 t1 的值小于 n，就会不停实行循环。
2.在 while 循环内部：
(1).起首，使用 print() 函数打印 t1 的值，由于 t1 是当前斐波那契数。
(2).盘算 result，它是 t1 和 t2 的和，使用 result = t1 + t2。
(3).将 t2 的值赋给 t1，这是将当前项更新为前一项，为下一个数的盘算做准备。
(4).将 result 的值赋给 t2，这是将 result 作为下一项的盘算结果存储起来，用于下一次迭代。
代码如下：

1. n = int(input())
2. t1 = 1
3. t2 = 1
4. result = 0
6. #循环
7. while t1 < n:
8.     # 打印t1
9.     print(t1)
10.   
11.     # 定义result 为t1和t2之和
12.     result = t1 +t2
14.     # 将t2的值分配给t1
15.     t1 =t2
17.     # 将result的值分配给t2
18.     t2 = result

复制代码

30.判断完全平方数

   写一个步伐：判断一个数字是否是完全平方数。
  

• 导入math模块。
  
• 获取一个整数输入，并存储在number变量中。
  
• 使用sqrt()函数找到该数字的平方根，并将其分配给square_root变量。
  
• 使用%运算符得对1取余，盘算出的平方根的余数，并把它赋给check_remainder。
  
• 如果余数便是0，打印 完全平方数。
  
• 否则打印非完全平方数。
  

  输入格式：一个整数
  剖析：
第一步：导入模块
起首，使用 import math 导入 math 模块。这个模块提供了很多数学函数，其中 sqrt() 函数将用于盘算数字的平方根。
第二步：获取输入
1.使用 input() 函数从用户处获取一个输入，表现一个整数。
2.由于输入的是字符串，将其转换为整数类型，存储在 number 变量中。这是由于我们要对这个数字举行完全平方数的判断，使用整数类型可以保证盘算的精确性。
第三步：盘算平方根并查抄余数
1.使用 math.sqrt() 函数盘算 number 的平方根，并将结果存储在 square_root 变量中。
2.使用取余运算符 % 盘算 square_root 对 1 取余的结果，并将其存储在 check_remainder 变量中。
第四步：判断并输出结果
1.使用 if 语句查抄 check_remainder 是否便是 0。
2.如果 check_remainder 便是 0，说明 number 是完全平方数，使用 print() 函数打印 "完全平方数"。
3.否则，说明 number 不是完全平方数，使用 print() 函数打印 "非完全平方数"。
代码如下：

1. # 导入math模块
2. import math
4. number = int(input())
6. # 计算平方根
7. square_root = math.sqrt(number)
9. # 对1取余
10. check_remainder = number % square_root
12. # 如果余数等于0，打印"完全平方数"；否则打印"非完全平方数"
13. if check_remainder == 0:
14.     print("完全平方数")
15. else:
16.      print("非完全平方数")

复制代码

总结

以上这些标题极为根本，对于语法学习尚处入门阶段的小白而言，是检测自身语法是否达标的抱负之选。
连续更新~