Python 编写的阿姆斯特朗数程序

如何使用 While 循环、For 循环、函数和递归编写 Python 语言的阿姆斯特朗数程序？我们还展示了在 1 到 n 之间打印阿姆斯特朗数的程序。

Python 阿姆斯特朗数：如果一个给定的正整数等于其各位数字的 N 次幂之和，那么它就是一个阿姆斯特朗数——例如，370。

370 的各位数字 = 3

370 = 3³ + 7³ + 0³ = 27 + 343 + 0 = 370

Python 编写的阿姆斯特朗数程序算法步骤

以下步骤展示了检查阿姆斯特朗数的常用方法。

  1. 用户需要输入任意数字。
  2. 计算各位数字的总数（例如，370 表示 3）。
  3. 将给定的整数分解为各位数字（例如，将 370 分解为 3、7 和 0）。
  4. 计算每个数字的 n 次幂并求和。
  5. 将原始值与总和值进行比较。
  6. 如果完全匹配，则为阿姆斯特朗数；否则，不是。

使用 While 循环的 Python 编写的阿姆斯特朗数程序

此程序允许用户输入任何正整数。然后，此 Python 程序代码使用 While 循环检查数字是否为阿姆斯特朗数。

# Using While Loop
Number = int(input("Please Enter the Number to Check: "))

Sum = 0
Times = 0

Temp = Number
while Temp > 0:
    Times = Times + 1
    Temp = Temp // 10

Temp = Number
while Temp > 0:
    Reminder = Temp % 10
    Sum = Sum + (Reminder ** Times)
    Temp //= 10

if Number == Sum:
    print("%d is Armstrong." %Number)
else:
    print("%d is Not." %Number)
Python Program for Armstrong Number Using While Loop

此 Python 阿姆斯特朗数程序允许用户输入任何正整数并将其赋给一个变量。

接下来，我们将原始值赋给 Temp 变量。这有助于保留我们的原始值，然后对 Temp 变量进行所有操作。

第一个 While 循环确保给定的数字大于 0。while 循环内的语句将其分解并计算给定整数中的各位数字。如果您不理解 程序 逻辑，请参阅 Python 中的“查找总位数”文章。

阿姆斯特朗数程序的第二个 While 循环确保给定的整数大于 0。让我们看看这个 while 循环的迭代工作原理

while Temp > 0: Reminder = Temp % 10 Sum = Sum + (Reminder ** Times) Temp //= 10

此 Python 阿姆斯特朗数程序的用户输入值为 = 9474 且 Sum = 0

Temp = Number
Temp = 9474

第一次迭代

Reminder = Temp %10
Reminder = 9474 % 10 = 4

Sum = Sum + pow (Reminder, Times)

对于此阿姆斯特朗数程序示例，Times = 4，因为 9474 中的总位数 = 4。所以，

Sum = 0 + (4 * 4 * 4 * 4) => 0 + 256 => Sum = 256

Temp = Temp /10 => 9474 /10
Temp = 947

注意：如果数字位数是 5，则 Reminder 乘以 5 次。

第二次迭代：从第一次迭代的阿姆斯特朗数检查程序中，Temp 和 Sum 的值已更改为 Temp = 163，Sum = 256。

Reminder = 947 % 10 = 7

Sum = 256 + (7 * 7 * 7 * 7) => 256 + 2401 => 2657

Temp = 163 /10 = 94

第三次迭代：从第二次迭代开始，Temp = 94，Sum = 2657。

Reminder = 94 % 10 = 4

Sum = 2657 + (4 * 4 * 4 * 4) => 2657 + 256 => 2913

Temp = 94 /10 = 9

Python 编写的阿姆斯特朗数第四次迭代：从第三次迭代开始，Temp = 9，Sum = 2913

Reminder = 9 % 10 = 0

Sum = 2913 + (9 * 9 * 9 * 9) => 2913 + 6561 => 9474

Temp = 9/10 = 0

这里，Temp = 0，所以 while 循环条件失败。

if(9474 == 9474)，条件检查用户输入的数字是否与 Sum 完全相等。如果此条件为 True，则为阿姆斯特朗数；否则，不是。

注意：如果您发现数字小于 1000，则删除用于计算整数中数字数量的 while 循环，然后替换以下代码

Sum = Sum + (Reminder ** Times);

With

Sum = Sum + (Reminder * Reminder * Reminder)

为了避免第一个 while 循环，在此阿姆斯特朗数代码中，我们使用了 str() 函数将数字转换为字符串，并使用 len() 函数 来查找总位数。

Num = int(input("Enter the Value : "))

numText  = str(Num)
l = len(str(Num))

Sum = 0

Temp = Num
while Temp > 0:
    Reminder = Temp % 10
    Sum = Sum + (Reminder ** l)
    Temp //= 10
Enter the Value : 8208
8208 is Armstrong.

Python 编写的查找阿姆斯特朗数程序（使用 For 循环）

此程序允许用户输入任何正整数，然后使用 For 循环检查数字是否为阿姆斯特朗数。

# Using For Loop
Num = int(input("Please Enter the Value : "))

Sum = 0
Times = 0
           
Temp = Num
while Temp > 0:
    Times = Times + 1
    Temp = Temp // 10

Temp = Num
for n in range(1, Temp + 1):
    Reminder = Temp % 10
    Sum = Sum + (Reminder ** Times)
    Temp //= 10

if Num == Sum:
    print("%d is Armstrong Number." %Num)
else:
    print("%d is Not." %Num)

我们将上面示例中的 While 循环替换为了 For 循环。如果您不理解 for 循环，请参考“For 循环”文章。

如果我们把数字转换为字符串，len() 函数 将获取总位数，for 循环将逐个读取字符。因此，我们可以避免额外的 while 循环来查找余数和从数字中移除最后一位。

Num = int(input("\nPlease Enter the Value : "))

numText  = str(Num)
l = len(numText)

Sum = 0

for n in numText:
    Sum = Sum + int(n) ** l

if Num == Sum:
    print("\n %d is Armstrong Number.\n" % Num)
else:
    print("\n %d is Not.\n" % Num)
Please Enter the Value : 407

 407 is Armstrong Number.

使用列表推导式的阿姆斯特朗数

在此示例代码中，我们使用了列表推导式和 math log10 函数来检查阿姆斯特朗数。

  • digits = [int(i) for i in str(num)] – 我们使用 列表推导式 来读取每个单独的数字并创建一个包含这些数字的列表。
  • 使用 len(digits) 或 int(math.log10(num))。两者都将返回总位数。
  • sum([d ** length for d in digits]) – 它将计算每个数字的 length（总位数）次幂。sum() 函数计算列表的总和。
import math

num = int(input("Enter a number: "))

digits = [int(i) for i in str(num)]

#length =len(digits)
length = 1 + int(math.log10(num))

sum = sum([d ** length for d in digits])

if num == sum:
   print(num,"is an Armstrong number.")
else:
   print(num,"is not.")
Enter a number: 9992
9992 is not.

Enter a number: 8208
8208 is an Armstrong number.

Python 编写的检查阿姆斯特朗数程序（使用函数）

此程序允许用户输入任何正整数，然后使用函数检查数字是否为阿姆斯特朗数。

# Using Functions
def ArmFind(val):
    total = 0
    Times = 0

    # Calculating individual digits
    tm = val
    while tm > 0:
        Times = Times + 1
        tm = tm // 10


    tm = val
    for n in range(1, tm + 1):
        Reminder = tm % 10
        total = total + (Reminder ** Times)
        tm //= 10
    return total


#User Input
val = int(input("Please Enter to Find : "))

if (val == ArmFind(val)):
    print("%d is Armstrong Number." %val)
else:
    print("%d is Not." %val)

在此阿姆斯特朗数程序示例中，我们定义了以下函数来执行所有必要的计算并返回 Sum。

def ArmFind(val):

当编译器到达 If 语句 中的以下代码时，编译器会立即跳转到上面指定的函数。

ArmFind(val)

我们已经在上面的示例中解释了逻辑。

Python 编写的检查阿姆斯特朗数程序（使用递归）

它允许我们输入任何正整数。接下来，使用递归或递归函数概念，此程序检查数字是否为阿姆斯特朗数。

# using Recursive functions
total = 0
Times = 0

def Count_Of_Digits(value):
    global Times
    if(value > 0):
        Times = Times + 1
        Count_Of_Digits(value // 10)
    return Times

def ArmFind(value, Times):
    global total
    if(value > 0):
        Reminder = value % 10
        total = total + (Reminder ** Times)
        ArmFind(value //10, Times)
    return total

value = int(input("Please Enter the value : "))

Times = Count_Of_Digits(value)
total = ArmFind(value, Times)
if (value == total):
    print("%d is Armstrong Number." %value)
else:
    print("%d is Not." %value)
Program for Armstrong Number using Recursion

在此阿姆斯特朗数程序示例中，我们定义了两个递归函数。以下函数接受整数值作为参数值，并递归地计算整数中的总各位数字。

def Count_Of_Digits(value):

以下函数接受两个整数值作为参数值。它执行所有必要的计算并返回 Sum。

def ArmFind(value, Times):

此 Python 阿姆斯特朗数程序中的以下语句有助于使用更新后的值递归调用函数。如果您错过此语句，它将在完成第一行后终止。例如，

ArmFind(value//10, Times)

Number = 153

则输出 = 27

让我们看看上面指定函数中的 If 语句

if (value > 0) 检查给定值是否大于 0。对于递归函数，在递归使用函数之前放置一个条件至关重要。否则，我们会陷入无限执行（与无限循环相同）。

Python 编写的查找 1 到 n 之间的阿姆斯特朗数程序

此程序允许您输入最小值和最大值。然后，此 Python 程序在最小值和最大值之间查找并返回阿姆斯特朗数。

此程序中的前两个语句允许用户输入最小值和最大值。For 循环有助于在 Minimum 和 Maximum 变量之间迭代。迭代从 Minimum 开始，然后不会超过 Maximum 变量。

if(n == tot) -- 条件，检查该整数中每个数字的 N 次幂之和是否等于给定值。当条件为 True 时，是；否则，不是。如果此条件为 True，则它将该整数作为结果打印出来。

Minimum = int(input("Please Enter the Minimum : "))
Maximum = int(input("Please Enter the Maximum : "))

for n in range(Minimum, Maximum + 1):
    tot = 0
    Times = 0
           
    tp = n
    while tp > 0:
        Times = Times + 1
        tp = tp // 10

    tp = n
    while tp > 0:
        Rem = tp % 10
        tot = tot + (Rem ** Times)
        tp //= 10
    if n == tot:
        print(n)

10 到 10000 之间的阿姆斯特朗数列表输出。

Python Program to Print Armstrong Numbers from 1 to N