Python编程题集（第二部分循环语句）

目录

Demo27 打印数字I

Demo28 打印数字II

Demo29 打印数字III

Demo30 打印菱形I

Demo31 打印菱形II

Demo32 打印菱形III

Demo33 猜数字

Demo34 最大公约数I

Demo35 判断素数

Demo36 最小公倍数

Demo37 整数的素因子

Demo38 完全数

Demo39 前50个素数

Demo40 计算π

Demo41 计算e

Demo42 剪刀石头布II

Demo43 组合问题I

Demo44 组合问题II

Demo45 水仙花数

Demo46 青蛙跳台阶

Demo47 堆叠相加

Demo48 十进制转二进制

Demo49 二进制转十进制

Demo50 十进制转十六进制

Demo51 十六进制转十进制

Demo52 最长公共前缀

Demo53 子串出现的次数

Demo54 最长公共子串

Demo55 检测密码

Demo56 回文素数

Demo57 反素数

Demo58 双素数

Demo59 梅森素数

Demo60 平方根的近似求法

---

Demo27 打印数字I

题目描述

利用循环，寻找规律，打印如下数字模式：

模式A
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
模式B
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
模式C
             1
           2 1
        3 2 1
     4 3 2 1
   5 4 3 2 1
6 5 4 3 2 1
模式D
 1 2 3 4 5 6
    1 2 3 4 5
       1 2 3 4
          1 2 3
             1 2
               1

代码如下：

#模式A

layer = int(input("请输入你要输入的行数："))
for index in range(1, layer + 1 ):
    for j in range(1, index + 1):
        print(j, end = " ")
    print()



#模式B

layer = int(input("请输入你要输入的行数："))
for index in range(layer + 1 ):
    for j in range(1, layer - index + 1):
        print(j, end = " ")
    print()


#模式C
layer = int(input("请输入你要输入的行数："))

for index in range(1, layer + 1):
    for j in range(layer, 0, -1):
        if j <= index:
            print(j, end=" ")
        else:
            print(" ", end=" ")
    print()

# 模式D


layer = int(input("请输入你要输入的行数："))

for index in range(1, layer):
    for j in range(1, index):
        print(" ", end=" ")
    for k in range(1, layer - index + 2):
        print(k, end = " ")
    print()

Demo28 打印数字II

题目描述

利用循环，寻找规律，打印如下数字模式：

                  1
               2 1 2
            3 2 1 2 3
         4 3 2 1 2 3 4
      5 4 3 2 1 2 3 4 5
   6 5 4 3 2 1 2 3 4 5 6
7 6 5 4 3 2 1 2 3 4 5 6 7

代码如下：

# 输入行数
rows = int(input("请输入行数："))

# 外层循环控制行数
for i in range(1, rows+1):
    # 内层循环打印空格，根据行数和数字最大值来确定空格数量
    for j in range(rows-i):
        print("  ", end="")
    
    # 内层循环打印数字升序部分
    for k in range(i, 0, -1):
        print(k, end=" ")
    
    # 内层循环打印数字降序部分
    for l in range(2, i+1):
        print(l, end=" ")
    
    print()  # 换行

Demo29 打印数字III

题目描述

利用循环，寻找规律，打印如下数字模式：

                         1
                    1    2    1
                1    2    4    2    1
            1     2    4    8    4    2    1
        1    2    4    8    16    8    4    2    1
    1    2    4    8    16    32    16    8    4    2    1
1    2    4    8    16    32    64    32    16    8    4    2    1

代码如下：

# 输入行数
rows = int(input("请输入行数："))

# 外层循环控制行数
for i in range(rows):
    # 内层循环打印空格，根据行数和数字最大值来确定空格数量
    for j in range(rows - i - 1):
        print("     ", end="")

    # 内层循环打印左半部分数字
    for k in range(i + 1):
        num = 2 ** k
        print("{:5d}".format(num), end="")

    # 内层循环打印右半部分数字
    for l in range(i, 0, -1):
        num = 2 ** (l - 1)
        print("{:5d}".format(num), end="")

    print()  # 换行

Demo30 打印菱形I

题目描述

如下所示，是一个高度为9的菱形

    *
   * *
  * * *
 * * * *
* * * * *
 * * * *
  * * *
   * *
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

   *
 * *
* * *
 * *
  *

代码如下:

# #打印实心菱形


# 输入行数
rows = int(input("请输入行数："))

# 上半部分阶梯
for i in range(1, rows+1):
    # 打印空格，根据行数和当前行来确定空格数量
    for j in range(rows-i):
        print(" ", end="")
    
    # 打印星号，每一行的星号数量等于当前行数
    for j in range(i):
        print("*", end=" ")
    
    print()  # 换行

# 下半部分阶梯
for i in range(rows-1, 0, -1):
    # 打印空格，根据行数和当前行来确定空格数量
    for j in range(rows-i):
        print(" ", end="")
    
    # 打印星号，每一行的星号数量等于当前行数
    for j in range(i):
        print("*", end=" ")
    
    print()  # 换行

Demo31 打印菱形II

题目描述

如下所示，是一个高度为9的菱形

    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 * *
*   *
 * *
  *

代码如下：

#打印空心菱形

#控制台输入行数
layer = int(input("请输入你要输入的行数："))

#判断是不是奇函数
while layer % 2 == 0:
    layer = int(input("请输入奇数行："))

#打印上半部分
for i in range(1 , (layer // 2 + 2)):
    #打印空格
    for j in range(layer - i):
        print(" ", end = "")
    #打印星号（判断当前位置是否为首尾位置，如果是则打印星号，否则打印空格，）
    for j in range(2 * i - 1):
        if j == 0 or j == 2 * i - 2:
            print("*", end = "")
        else:
            print(" ", end = "")
    print()
#打印下半部分
for i in range(layer // 2, 0, -1):
    #打印空格

    for j in range(layer - i):
        print(" ", end = "")
    #打印星号（判断当前位置是否为首尾位置，如果是则打印星号，否则打印空格，）

    for j in range(2 * i - 1):
        if j == 0 or j == 2 * i - 2:
            print("*", end = "")
        else:
            print(" ", end = "")
    print()#换行

Demo32 打印菱形III

题目描述

如下所示，是一个高度为9的菱形

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

用户输入菱形高度n，并打印出该高度下的菱形

输入输出描述

输入高度n，n为奇数

输出该高度的菱形

示例

输入：

5

输出：

  *
 ***
*****
 ***
  *

代码如下：

#打印实心菱形
#输入行数

layer = int(input("请输入你要输入的行数："))
#如果输入的行数是偶数，我们则要求重新输入
while layer % 2 == 0:
    layer = int(input("请输入奇数行："))
#打印上半部分的金字塔
for i in range(1 , (layer // 2 + 2)):
#打印空格，根据行数和当前的行数来确定空格的数量
    for j in range(layer - i):
        print(" ", end = "")

#打印星号根据当前行数来确定星号数
    for j in range(2 * i - 1):
        print("*", end = "")
    print()

# 打印下半部分的金字塔
for i in range(layer // 2, 0, -1):
    print(" ", end = "")

#打印空格，根据行数和当前的行数来确定空格的数量

    for j in range(layer - i -1):
        print(" ", end = "")

#打印星号根据当前行数来确定星号数

    for j in range(2 * i - 1):
        print("*", end = "")
    print() #换行

Demo33 猜数字

题目描述

计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同

对于用户输入的数字，程序会提示它是过高还是过低

输入输出描述

每次输入一个整数

每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束

示例

输入：50

输出：高了

输入：25

输出：低了

输入：42

输出：高了

输入：39

输出：猜中了！答案就是39

代码如下：

import random


num1 = random.randint(1, 100)

while True:
    num2 = int(input("请输入你猜测的数字(1-100)："))
    if num2 > num1:
        print("高了")
    elif num2 < num1:
        print("低了")
    else:
        print(f"恭喜你，猜对了，答案就是{num2}")

Demo34 最大公约数I

题目描述

输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8

输入输出描述

输入两个数字

输出最大公约数

示例1

输入：

16 24

输出：

8

示例2

输入：

7 3

输出：

1

代码如下：

#短除法
num1, num2 = map(int, input("请依次输入两个正整数：").split(" "))
#初始的共约数为1
t = 1
for i in range(2, min(num1, num2)):
    #每次for循环迭代时，使用while循环判断两个数能不能被迭代变量整除
    while num1 % i ==0 and num2 % i ==0:
        t = t * i
        num1 = num1 / i
        num2 = num2 / i
        
print(f"最小公约数为{t}")


#欧几里得算法

num1, num2 = map(int, input("请依次输入两个正整数：").split(" "))
a = max(num1 , num2)
b = min(num1 , num2)
t = a % b
while t != 0:
    a = b
    b = t
    print(f"最大的公约数:{b}")
    break

Demo35 判断素数

题目描述

一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是

输入输出描述

输入一个大于1的正整数

输出Yes表示该数字是素数，否则输出No

示例1

输入：

9

输出：

No

示例2

输入：

11

输出：

Yes

代码如下：

def is_prime(n):
    if n <=1:
        return False
    for i in range(2, int(n**1/2) + 1):
        if n % i == 0:
            return False
    return True

num = int(input("请输入一个大于1的正整数："))

if is_prime(num):
    print("YES")
else:
    print("NO")

Demo36 最小公倍数

题目描述

输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15

输入输出描述

输入两个正整数

输出最小公倍数

示例1

输入：

3 9

输出：

9

示例2

输入：

4 6

输出：

12

代码如下：

def find_lcm(x , y):
    if x > y:
        greater = x
    else:
        greater = y
    while True:
        if greater % x==0 and greater % y ==0:
            lcm = greater
            break
        greater += 1
    return lcm

num1 , num2 = map(int, input("请依次输入两个整数：").split(" "))
lcm = find_lcm(num1 ,num2)
print(f"最小公倍数为：{lcm}")

Demo37 整数的素因子

题目描述

输入一个正整数，然后找出它所有的最小因子，也称之为素因子

输入输出描述

输入一个正整数

输出多行，每行输出一个素因子

示例1

输入：

120

输出：

2 2 2 3 5

解释：

2 * 2 * 2 *3 * 5 = 120

示例2

输入：

100

输出：

2 2 5 5

代码如下：

def find_prime_factors(num):
    factors = []
    i = 2
    while i*i <= num:
        if num % i != 0:
            i += 1
        else:
            num = num // i
            factors.append(i)
    if num > 1:
        factors.append(i)
    return factors
num = int(input("请输入一个正整数："))
prime_factors = find_prime_factors(num)
# for factors in prime_factors:
#     print(f"输出素因子为:{factors}")
print(f"输出素因子为:{prime_factors}")

Demo38 完全数

题目描述

如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数

例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1

输入输出描述

输入一个正整数

输出该数是否为完全数

示例1

输入：

6

输出：

Yes

示例2

输入：

9

输出：

No

代码如下：

def is_perfect_number(num):
    factors = []
    for i in range(1, num):
        if num % i == 0:
            factors.append(i)
    
    sum_of_factors = sum(factors)
    
    if sum_of_factors == num:
        return "YES"
    else:
        return "NO"

num = int(input("请输入一个正整数："))
print(is_perfect_number(num))

Demo39 前50个素数

题目描述

打印前50个素数，每打印10个素数换行

代码如下：

def is_prime(num):
    if num <= 1:
        return False
    for i in range(2, int(num ** 1/2) + 1):
        if num % i == 0:
            return False
    return True

count = 0
for num in range(1, 500):
    if is_prime(num):
        print(num, end = " ")
        count += 1
        if count % 10 ==0:
            print()
            if count >= 50:
                break

Demo40 计算π

题目描述

你可以使用下面的数列近似计算π

当i越大时，计算结果越近似于π

代码如下：

def approximate_pi(n):
    pi_approx = 0.0
    sign = 1
    for i in range(1, n + 1):
        term = sign / (2*i -1)
        pi_approx += term
        sign *= -1
    return 4 * pi_approx

n = int(input("请输入你要迭代的次数："))
approximate = approximate_pi(n)
print(f"π的近似值为{approximate}")

Demo41 计算e

题目描述

你可以使用下面的数列近似计算e

当i越大时，计算结果越近似于e

代码如下：

import math


def approximate_e(n):
    e_approx = 0.0
    factorial = 1
    for i in range(1, n):
        term = 1 / factorial
        e_approx += term
        factorial *= (i + 1)
    return e_approx + 1
n = int(input("请输入你要迭代的次数："))
approximate = approximate_e(n)
print(f"e的近似值为：{approximate}")
print(f"e的真实值为：{math.e}")

Demo42 剪刀石头布II

题目描述

延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者

代码如下：

import random


choices = ["石头", "剪刀", "布"]
#choices = {"石头":0, "剪刀":1, "步":2}
player_score = 0
computer_score = 0

while True:
    # 玩家进行选择
    player_choice = input("请出拳（石头、剪刀、布）：")
    
    # 随机生成计算机的选择
    computer_choice = random.choice(choices)
    
    # 判断胜负并更新分数
    if player_choice == computer_choice:
        print("平局！")
    elif (player_choice == "石头" and computer_choice == "剪刀") or \
         (player_choice == "剪刀" and computer_choice == "布") or \
         (player_choice == "布" and computer_choice == "石头"):
        print("你赢了！")
        player_score += 1
    else:
        print("你输了！")
        computer_score += 1
    
    # 显示当前分数
    print(f"当前分数：玩家 {player_score} - {computer_score} 计算机")
    
    if player_score == 3:
        print("玩家获胜！")
        break
    if computer_score == 3:
        print("计算机获胜！")
        break
    

    # 询问是否继续游戏
    play_again = input("是否继续游戏？（输入 y 继续，其他任意键退出）：")
    if play_again.lower() != "y":
        break

print("游戏结束！")

Demo43 组合问题I

题目描述

在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数

注：组合（a，b）与组合（b，a）算同一种组合，只记录一次

代码如下：

count = 0
for i in range(1, 8):
    for j in range(i + 1, 8):
        print(f"({i}, {j})")
        count += 1
print(f"有{count}种组合")

Demo44 组合问题II

题目描述

有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？

代码如下：

count = 0
for i in range(1,5):
    for j in range(1, 5):
        for k in range(1, 5):
            if i != j and i != k and j != k:
                print(f"{i}{j}{k}")
                count += 1
print(f"有{count}种组合")

Demo45 水仙花数

题目描述

水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$

编写程序，输出所有的水仙花数
代码如下： 

for i in range(100,1000):
    a = i // 100
    b = i % 100 // 10
    c = i % 10
    if a ** 3 + b ** 3 + c ** 3 == i:
        print(f"水仙花数有：{i}")

Demo46 青蛙跳台阶

题目描述

一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？

例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）

代码如下：

def jum_ways(n):

    if n == 1:
        return 1
    elif n == 2:
        return 2
    else :
        return jum_ways(n - 1) + jum_ways(n - 2)

n = int(input("请输入台阶数："))
print("不同的跳法数量为：")
print(jum_ways(n))

Demo47 堆叠相加

题目描述

现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$

例如：$2+22+222+2222+22222$，其中a为2，且有5组数字

输入输出描述

输入两个数据分别为数字a和组数n

输出按照堆叠相加模式算出的和

示例

输入：

3 4

输出：

3702

解释：

3 + 33 + 333 + 3333 = 3702

 代码如下：

def add_up(a, n):
    sum = 0
    num = a
    for i in range(n):
        sum += num
        num = num * 10 + a
    return sum 

a, n = map(int, input("请依次输入叠加的数字以及叠加的组数：").split(" "))
print("最终的总和为：")
print(add_up(a, n))

Demo48 十进制转二进制

题目描述

输入一个十进制正整数，输出其二进制形式

输入输出描述

输入一个十进制正整数

输出二进制字符串

示例

输入：

9

输出：

1001

代码如下：

def base_system_conversion(decimalism):
    binary =" "
    while decimalism > 0:
        remainder = decimalism % 2
        binary = str(remainder) + binary
        decimalism = decimalism // 2
    return binary
decimalism = int(input("请输入你想转换的十进制："))
print(f"转换后的二进制为:{base_system_conversion(decimalism)}")

Demo49 二进制转十进制

题目描述

输入一个二进制字符串，输出其对应的十进制数字

输入输出描述

输入一个二进制字符串

输出十进制数字

示例

输入：

1001

输出：

9

代码如下：

def base_system_conversion(binary):
    decimalism = 0
    binary_str = str(binary)
    binary_str = binary_str[::-1]  
    for i in range(len(binary_str)):
        if binary_str[i] == '1':
            decimalism += 2 ** i
    return decimalism

binary_input = input("请输入你想转换的二进制：")
print(f"转换后的十进制为: {base_system_conversion(binary_input)}")

Demo50 十进制转十六进制

题目描述

输入一个十进制正整数，输出其十六进制形式

输入输出描述

输入一个十进制正整数

输出十六进制字符串

示例

输入：

1233321

输出：

1e1b9

代码如下：

def base_system_conversion(decimal):
    hexadecimal = ""
    while decimal > 0:
        remainder = decimal % 16
        if remainder < 10:
            hexadecimal = str(remainder) + hexadecimal
        else:
            hexadecimal = chr(65 + remainder - 10) + hexadecimal
        decimal = decimal // 16
    return hexadecimal

decimal = int(input("请输入你想转换的十进制："))
print(f"转换后的十六进制为: {base_system_conversion(decimal)}")

Demo51 十六进制转十进制

题目描述

输入一个十六进制字符串，输出其对应的十进制数字

输入输出描述

输入一个十六进制字符串

输出十进制数字

示例

输入：

1e1b9

输出：

123321

代码如下：

def base_system_conversion(hexadecimal):
    decimal = 0
    power = len(hexadecimal) - 1
    for digit in hexadecimal:
        if digit.isdigit():
            decimal += int(digit) * (16 ** power)
        else:
            decimal += (ord(digit.upper()) - 55) * (16 ** power)
        power -= 1
    return decimal

hexadecimal = input("请输入你想转换的十六进制：")
print(f"转换后的十进制为: {base_system_conversion(hexadecimal)}")

Demo52 最长公共前缀

题目描述

给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写

输入输出描述

输入两行，分别表示s1和s2

输出前缀串

示例

输入：

abcdefg

abcdhko

输出：

abcd

代码如下：

def common_prefixes(s1, s2):
    common_prefixes = " "
    if len(s1) < len(s2):
        n = len(s1)
    else:
        n = len(s2)
    L1 = list(s1)
    L2 = list(s2)
    for i in range(n):
        if L1[i] == L2[i]:
            common_prefixes = common_prefixes + L1[i]
    return common_prefixes
s1 = input("请输入s1的字符串：")
s2 = input("请输入s2的字符串：")
common_prefixes = common_prefixes(s1, s2)
print(f"公共的字符前缀为：{common_prefixes}")

Demo53 子串出现的次数

题目描述

给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配

输入输出描述

输入两行字符串，分别为s1和s2，s2的长度小于等于s1

输出s2在s1中出现的次数

示例1

输入：

ABCsdABsadABCasdhjabcsaABCasd

ABC

输出：

3

示例2

输入：

AAAAAAAA

AAA

输出：

2

代码如下：

def occurrence_number(s1, s2):
    total_degree = 0  # 初始化计数器为0
    i = 0  # 设置字符串s1的索引i为0
    while i < len(s1) - len(s2) + 1:  # 当i小于等于s1长度减去s2长度加1时执行循环
        if s1[i:i+len(s2)] == s2:  # 如果s1中从索引i开始长度为s2的子串等于s2
            total_degree += 1  # 计数器加1
            i += len(s2)  # 将索引i移动s2的长度
        else:
            i += 1  # 否则将索引i移动1
    return total_degree  # 返回计数器的值

s1 = input("请输入s1的字符串：")  # 接收用户输入的s1字符串
s2 = input("请输入s2的字符串：")  # 接收用户输入的s2字符串

total = occurrence_number(s1, s2)  # 调用occurrence_number函数计算s2在s1中出现的次数
print(f"{s2}在{s1}中出现的次数为：{total}")  # 输出结果

Demo54 最长公共子串

题目描述

给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写

输入输出描述

输入两行字符串，分别为s1和s2

输出最长公共子串

示例

输入：

123ABCDEFG83hsad

iughABCDEFG23uy

输出：

ABCDEFG

代码如下：

def longest_common_substring(s1, s2):
    m = len(s1)
    n = len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]# 创建了一个名为dp的二维数组，其中每个内部列表都包含n+1个元素，并且初始值都为0。
    max_length = 0
    end_index = 0

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1 
                if dp[i][j] > max_length:
                    max_length = dp[i][j]
                    end_index = i
            else:
                dp[i][j] = 0

    return s1[end_index - max_length:end_index]

s1 = input("请输入s1的字符串：")
s2 = input("请输入s2的字符串：")

result = longest_common_substring(s1, s2)
print(f"最长公共子串为：{result}")

Demo55 检测密码

题目描述

一些网站会给密码强加一些规则：

（1）密码必须至少有8个字符

（2）密码只能包含英文字母和数字

（3）密码应该至少包含两个数字

（4）密码应该至少包含两个大写字母

如果密码符合规则，输出Yes；否则输出No

输入输出描述

输入一串密码

输出该密码是否符合规则

示例1

输入：

123456ab

输出：

No

示例2

输入：

123abcABC

输出：

Yes

代码如下：

import re


def check_password_rules(password):
    # 判断密码是否至少有8个字符
    if len(password) < 8:
        return "No" 

    # 判断密码是否只包含英文字母和数字
    # if not any(char.isdigit() for char in password):
    #     if not any(char.isalpha() for char in password):
    #         return "No"  
    if not re.match("^[A-Za-z0-9]+$", password):
        return "No"
    return "Yes"
    # 判断密码是否至少包含两个数字
    if "0" not in password and len(password) < 2:
        return "No"  
    # 判断密码是否至少包含两个大写字母
    if "A" not in password and len(password) < 2:
        return "No" 
    # 如果密码符合所有规则，返回"Yes"
    return "Yes"
password = input("请输入你的密码：") # 您要检查的密码
print(check_password_rules(password))

Demo56 回文素数

题目描述

回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数

输出显示前100个回文素数，每行显示10个

代码如下：

#判断素数：
def is_prime(n):
    if n <=1:
        return False
    for i in range(2, int(n**1/2) + 1):
        if n % i == 0:
            return False
    return True

#判断回文数：
def reverseNumber(n):
    num = str(n)
    m = num[::-1]
    if num == m:
        return n
count = 0
num = int(input("请输入一个大于1的正整数（给定一个范围）："))
for n in range(1, num + 1):
    if is_prime(n) and reverseNumber(n) == n:
        print(n, end = " ")
        count += 1
        if count % 10 ==0:
            print()
            if count >= 50:
                break

Demo57 反素数

题目描述

反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数

输出显示前100个反素数，每行显示10个

代码如下：

# 输出前100个反素数

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def find_inverse_primes(start, end):
    primes = []
    for i in range(start, end):
        if is_prime(i) and is_prime(int(str(i)[::-1])):
            primes.append(i)
    return primes

start = 1
end = 100
inverse_primes = find_inverse_primes(start, end)

for i in range(len(inverse_primes) // 10 + 1):
    print(" ".join(map(str, inverse_primes[i * 10:i * 10 + 10])))

Demo58 双素数

题目描述

双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数

输出显示小于1000的双素数

代码如下：​​​​​​​

def is_prime(n):
    if n <= 1:  
        return True
    for i in range(2, int(n ** (1 / 2) + 1)): 
        if n % i == 0:
            return False
    return True
def palindromic(num):
    return str(num) == str(num)[::-1]
def reverse_num(num):
    return int(str(num)[::-1])
def reverse_prime(number):
    i = 2
    count = 0
    while True:
        if not palindromic(i) and is_prime(i) and is_prime(reverse_num(i)):
            print(i, end=' ')  
            count = count + 1
            if count == number:
                break
        i = i + 1
if __name__ == "__main__":
    n = int(input())
    reverse_prime(n)

Demo59 梅森素数

如果一个素数可以写成$2^p-1$的形式，其中p是某个正整数，那么这个素数就称作梅森素数

输出p≤31的所有梅森素数

代码如下：

def is_prime(n):  
    if n <= 1:  
        return False  
    for i in range(2, int(n**0.5) + 1):  
        if n % i == 0:  
            return False  
    return True  
  
def find_mersenne_primes():  
    for p in range(2, 32):  
        n = 2**p - 1  
        if is_prime(n):  
            print(f"梅森素数在p = {p}: {n}")  
  
find_mersenne_primes()

Demo60 平方根的近似求法

有几种实现开平方$\sqrt{n}$的技术，其中一个称为巴比伦法

它通过使用下面公式的反复计算近似地得到：

当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值

lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行

编写代码，求解n的平方根的近似值

代码如下：​​​​​​​

# def sqrt_babylon(n):  
#     lastGuess = 1.0  
#     while True:  
#         nextGuess = (lastGuess + n / lastGuess) / 2.0  
#         if abs(nextGuess - lastGuess) < 0.0001:  
#             return nextGuess  
#         lastGuess = nextGuess
def sqrt_babylon(n):  
    # 验证输入是否为正数  
    if n < 0:  
        raise ValueError("输入必须为正数")  
      
    # 初始化初始猜测值为1.0  
    last_guess = 1.0  
      
    # 循环迭代直到满足精度要求  
    while True:  
        # 计算下一个猜测值  
        next_guess = (last_guess + n / last_guess) / 2.0  
          
        # 检查是否满足精度要求  
        if abs(next_guess - last_guess) < 0.0001:  
            # 返回最终猜测值  
            return next_guess  
          
        # 更新上一个猜测值  
        last_guess = next_guess
num = int(input("请输入你需要求解的数："))
n = sqrt_babylon(num)
print(f"计算后的近似值为：{n}")