python中的回文数

试图找到最大的回文，即两个三位数的乘积。在我查找更高效、更重要的工作解决方案之前，您能告诉我我的代码出了什么问题吗？我只是不断地得到空位

def palindrome():
    n = 100
    m = 100
    palind = []
    while n<=999:
        while m<=999:
            prod = n * m
            if str(prod) == str(prod)[::-1] and prod > palind[0]:
                palind.pop(0)
                palind.append(prod)
            return palind
            m = m + 1
        n = n + 1
        return palind

print palindrome()

def palindrome（）：
n=100
m=100
palind=[]
而
每次迭代外部while循环后，您都不会重新初始化
m=100

你很早就回来了。删除内部循环中的
return
语句

最后一个
return
语句不应位于外部while循环内

您从未初始化过
palind
列表（感谢@user2357112）

建议：

不要使用列表来维护最大的数字。一个简单的变量就足够了

在同一个表达式中，不必将数字转换为字符串两次。将字符串化的数字存储在变量中

使用
range
函数循环数字

如果我写这个程序，我会这样做

from itertools import product
def palindrome():
    numbers, result = range(1000, 100, -1), -1
    for num1, num2 in product(numbers, repeat = 2):
        prod  = num1 * num2
        sprod = str(prod)
        if sprod == sprod[::-1] and prod > result:
            result = prod
    return result

print palindrome()   # 906609

当无法返回i*j>所记录的最大值且正确返回906609时，此选项会缩短操作时间（注意，如果您使用的是python 2，则以下选项对您适用，但您更愿意使用
xrange
而不是
range
，以避免在内存中创建不必要的列表）：

这条捷径很重要，因为如果给出一个非常大的数字，可能需要相当长的时间才能返回：

>>> palindrome(upto=100000000)
9999000000009999L

我还创建了一个生成器，它可以命中从0到999的每个组合，并返回906609

def palindrome(upto=1000):
    return max(i*j for i in range(upto) for j in range(upto) 
                if str(i*j) == str(i*j)[::-1])

但在运行此回文时，如中所示：

>>> palindrome(upto=100000000)

完整的搜索将搜索所有100000000^2，并且花费的时间太长

我最初是这样写的，我的想法是它可以简化并避免迭代所有可能的组合，但这是不正确的，它返回88888:

def palindrome():
    start = 999
    largest = 0
    for i in range(start, 0, -1): # decreasing from 999
        if i * 999 < largest:
            return largest
        for j in range(start, i, -1): # decreasing from 999 to i
            if str(i*j) == str(i*j)[::-1]:
                largest = i*j

但是结果不是单调递减的（也就是说，不能保证每个结果都比前一个结果小。）
您有3个问题

问题1：早归

while n<=999:
    while m<=999:
        prod = n * m
        if str(prod) == str(prod)[::-1] and prod > palind[0]:
            palind.pop(0)
            palind.append(prod)
        # Here
        return palind
        m = m + 1
    n = n + 1
    # And here
    return palind

假设您的程序正在运行，并且找到了第一个回文。它试图将其与
palind[0]
进行比较，但没有
palind[0]
！您需要获取第一个回文，而不尝试将其与不存在的回文进行比较。让我们来解决这个问题

问题3：未重置
m

palind = None
while n<=999:
    while m<=999:
        prod = n * m
        if str(prod) == str(prod)[::-1]:
            if palind is None or prod > palind:
                palind = prod
        m = m + 1
    n = n + 1
return palind

这可能不是问题的答案，但如果您希望得到介于范围之间的回文数，您可以这样做

def getPalindrome(lower, upper):
  listPalind = []
  for n in range(lower, upper):
    if str(n) == str(n)[::-1]:
      listPalind.append(n)
  return listPalind

# Usage
print(getPalindrome(100, 300))

# Results
[101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292]

def是回文的：
如果s==s[：-1]：
返回真值
其他：
返回错误
palind=[]
对于范围（1001000）内的i：
对于范围（1001000）内的j：
乘积=i*j
如果是回文（str（product））：
palind.append（产品）
返回最大值（palind）

#结果:
906609
这是三个问题中的一个。@user2357112希望我现在发现了所有三个；）<代码>页[0]

未初始化。（我在写的答案中把你的2和3作为一个问题。）@user2357112我在下一节中提出了这个建议。他根本不需要列表。当它第一次尝试查看

palind[0]

时，它将成为

indexer

，因为

palind[0]

不存在。如果你使用像PyCharm这样的工具，它将使调试这样的东西变得更容易。现在似乎可以工作了。下限包含，上限独占可能更有意义。你说得对！这肯定不能回答问题。正如你们所看到的，op已经知道了这个检查数字是否是palyndromes的诀窍。这是为其他来自谷歌的用户，比如我。欢迎来到StackOverflow！虽然此代码可用于解决问题中讨论的任务，但它不能回答实际问题：问题中的代码有什么问题。您好！虽然这段代码可以解决这个问题，但如何以及为什么解决这个问题将真正有助于提高您的帖子质量，并可能导致更多的投票。请记住，你是在将来回答读者的问题，而不仅仅是现在提问的人。请在回答中添加解释，并说明适用的限制和假设。

while n<=999:
    while m<=999:
        prod = n * m
        if str(prod) == str(prod)[::-1] and prod > palind[0]:
            palind.pop(0)
            palind.append(prod)
        # Here
        return palind
        m = m + 1
    n = n + 1
    # And here
    return palind

while n<=999:
    while m<=999:
        prod = n * m
        #                                           Here  v
        if str(prod) == str(prod)[::-1] and prod > palind[0]:
            palind.pop(0)
            palind.append(prod)
        m = m + 1
    n = n + 1
return palind

palind = None
while n<=999:
    while m<=999:
        prod = n * m
        if str(prod) == str(prod)[::-1]:
            if palind is None or prod > palind:
                palind = prod
        m = m + 1
    n = n + 1
return palind

palind = None
for n in xrange(100, 1000):
    for m in xrange(100, 1000):
        prod = n * m
        if str(prod) == str(prod)[::-1]:
            if palind is None or prod > palind:
                palind = prod
return palind

def isPalindrome(self, x: int):
    temp = 0
    x1 = x
    while x > 0:
        y = x % 10
        temp = temp * 10 + y
        x = x//10

    if(temp == x1):
        return True
    else:
        return False

def getPalindrome(lower, upper):
  listPalind = []
  for n in range(lower, upper):
    if str(n) == str(n)[::-1]:
      listPalind.append(n)
  return listPalind

# Usage
print(getPalindrome(100, 300))

# Results
[101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292]