python - 如何使用 Python 逻辑检查回文

Question

我正在尝试使用 Python 检查回文。我拥有的代码非常for循环密集。

在我看来，人们从 C 到 Python 时犯的最大错误是尝试使用 Python 实现 C 逻辑，这使得事情运行缓慢，而且没有充分利用语言。

我在这个网站上看到。搜索“C-style for”，Python 没有 C-style for 循环。可能已经过时，但我将其解释为 Python 有自己的方法。

我试过环顾四周，我找不到太多最新的（Python 3）建议。如何在不使用 for 循环的情况下解决 Python 中的回文挑战？

我在课堂上用 C 语言完成了这个，但我想在 Python 中完成它，在个人基础上。问题出在欧拉项目，伟大的网站顺便说一句。

def isPalindrome(n):
    lst = [int(n) for n in str(n)]
    l=len(lst)
    if l==0 || l==1:
        return True
    elif len(lst)%2==0:
        for k in range (l)
        #####
    else:
        while (k<=((l-1)/2)):
            if (list[]):
                #####   

for i in range (999, 100, -1):
    for j in range (999,100, -1):
        if isPalindrome(i*j):
            print(i*j)
            break

我在这里遗漏了很多代码。五个哈希值只是对我自己的提醒。

具体问题：

1. 在 C 语言中，我会创建一个 for 循环，将索引 0 与索引 max 进行比较，然后将索引 0+1 与 max-1 进行比较，直到某些东西。如何在 Python 中最好地做到这一点？

2. 我的 for 循环（在 (999, 100, -1) 范围内），这是在 Python 中做的不好的方法吗？

3. 有人对我这个职位的人有什么好的建议、好的网站或资源吗？我不是程序员，我不渴望成为一名程序员，我只想学足够多的东西，这样当我写我的学士学位论文（电气工程）时，我不必在尝试的同时学习一门适用的编程语言以在项目中取得良好的效果。“如何从基本的 C 到 Python 的伟大应用”，诸如此类。

4. 任何能很好地解决这个问题的特定代码也将不胜感激，我需要学习好的算法。我设想了 3 种情况。如果该值为零或一位数，如果它是奇数长度，如果它是偶数长度。我本来打算写for循环...

PS：问题是：找到两个3位整数的最高值乘积，这也是一个回文。

Answer 1

确定给定值是否为回文的pythonic方法：

str(n) == str(n)[::-1]

解释：

• 我们正在检查 的字符串表示是否n等于 的反转字符串表示n
• 切片[::-1]负责反转字符串
• 之后，我们使用==

Answer 2

[::-1]相当不直观的语法的替代方法是：

>>> test = "abcba"
>>> test == ''.join(reversed(test))
True

该reversed函数返回 中字符的反向序列test。

''.join()将这些字符再次连接在一起，中间没有任何内容。

Answer 3

只是为了记录，对于那些寻找一种更算法的方法来验证给定字符串是否是回文的人，有两种实现相同的方法（使用while和for循环）：

def is_palindrome(word):

    letters = list(word)    
    is_palindrome = True
    i = 0

    while len(letters) > 0 and is_palindrome:       
        if letters[0] != letters[(len(letters) - 1)]:
            is_palindrome = False
        else:
            letters.pop(0)
            if len(letters) > 0:
                letters.pop((len(letters) - 1))

    return is_palindrome

还有....第二个：

def is_palindrome(word):

    letters = list(word)
    is_palindrome = True

    for letter in letters:
        if letter == letters[-1]:
            letters.pop(-1)
        else:
            is_palindrome = False
            break

    return is_palindrome

Answer 4

python 最棒的部分是你可以用它做的事情。您不必为字符串使用索引。

以下将起作用（使用切片）

def palindrome(n):
    return n == n[::-1]

它所做的只是简单地反转 n，并检查它们是否相等。 n[::-1]反转 n（-1 表示递减）

“2）我的 for 循环（在范围内（999、100、-1），这是在 Python 中做的不好的方法吗？”

关于上面，你想使用xrange而不是 range（因为 range 会创建一个实际的列表，而 xrange 是一个快速生成器）

我对问题 3 的看法

我在 Python 之前学习了 C，我只是阅读了文档，并使用控制台来玩弄它。（以及通过做 Project Euler 问题：）

Answer 5

如果是回文，则代码下方将打印0 ，否则将打印-1

优化代码

word = "nepalapen"
is_palindrome = word.find(word[::-1])
print is_palindrome

输出： 0

word = "nepalapend"
is_palindrome = word.find(word[::-1])
print is_palindrome

输出： -1

解释：

搜索字符串时，返回的值是字符串开始位置的值。

因此，当您这样做时，它会在位置word.find(word[::-1])找到并反转，它仍然在位置，因此会被返回。nepalapen0[::-1]nepalapennepalapen00

现在，当我们搜索nepalapend然后反转它时nepalapend，dnepalapen会呈现一条FALSE语句nepalapend被反转以dnepalapen导致搜索失败，nepalapend从而导致一个值-1指示未找到字符串。

---

另一种方法打印true if palindrome else print false

word = "nepalapen"
print(word[::-1]==word[::1])

输出： 真

Answer 6

还有一种功能方式：

def is_palindrome(word):
  if len(word) == 1: return True
  if word[0] != word[-1]: return False
  return is_palindrome(word[1:-1])

Answer 7

我知道这个问题已经回答了一段时间，我为入侵表示歉意。但是，我也在研究一种在 python 中这样做的方法，我只是想我会分享我这样做的方式如下，

word = 'aibohphobia'

word_rev = reversed(word)

def is_palindrome(word):
    if list(word) == list(word_rev):
        print'True, it is a palindrome'
    else:
        print'False, this is''t a plindrome'

is_palindrome(word)

Answer 8

我刚刚找到了更简单的方法。它只有 1 行。

is_palindrome = word.find(word[::-1])

Answer 9

这里是一个不区分大小写的函数，因为上述所有这些解决方案都是区分大小写的。

def Palindrome(string): 

  return (string.upper() == string.upper()[::-1]) 

该函数将返回一个布尔值。

Answer 10

为 python 做 Watterloo 课程，提出了与“课程”相同的问题，请在此处找到信息：

http://cscircles.cemc.uwaterloo.ca/13-lists/

作为一个新手，我通过以下方式解决了这个问题：

def isPalindrome(S):
    pali = True
    for i in range (0, len(S) // 2):
        if S[i] == S[(i * -1) - 1] and pali is True:
            pali = True
        else:
            pali = False
    print(pali)
    return pali

该函数称为isPalindrome(S)并且需要一个字符串"S"。默认情况下，返回值为TRUE，以对第一个 if 语句进行初始检查。

之后，for循环运行字符串长度的一半，以检查字符串“S”中“i”位置的字符从前面和后面是否相同。如果不是这种情况，函数就会停止，打印出 FALSE 并返回 false。

干杯.kg

Answer 11

如果字符串具有大写或非字母字符，则该函数将所有字符转换为小写并使用正则表达式删除所有非字母字符，最后它递归地应用回文检查：

import re

rules = [
    lambda s: any(x.isupper() for x in s),
    lambda s: not s.isalpha()
]


def is_palindrome(s):
    if any(rule(s) for rule in rules):
        s = re.sub(r'[^\w]', '', s).lower()
    if len(s) < 2:
        return True
    if s[0] != s[-1]:
        return False
    return is_palindrome(s[1:-1])


string = 'Are we not drawn onward, we few, drawn onward to new era?'

print(is_palindrome(string))

输出True用于上面的输入。

Answer 12

也许你可以试试这个：

list=input('enter a string:')

if (list==list[::-1]):
    print ("It is a palindrome")
else:
   print("it is not palindrome")

Answer 13

你在 python 中问回文。回文可以在字符串、数字和列表上执行。但是，我刚刚发布了一个简单的代码来检查字符串的回文。

# Palindrome of string
str=raw_input("Enter the string\n")
ln=len(str)
for i in range(ln/2) :
    if(str[ln-i-1]!=str[i]):
        break
if(i==(ln/2)-1):
    print "Palindrome"
else:
    print "Not Palindrome"

Answer 14

真正简单的方法是

word = str(raw_input(""))
is_palindrome = word.find(word[::-1])
if is_palindrome == 0:
    print True
else:
    print False

而这里的 if/else 只是为了花哨的外观。关于回文的问题是在亚马逊的 QA 采访中

Answer 15

假设一个字符串's'

palin = lambda s: s[:(len(s)/2 + (0 if len(s)%2==0 else 1)):1] == s[:len(s)/2-1:-1]  
# Test
palin('654456')  # True
palin('malma')   # False
palin('ab1ba')   # True

Answer 16

word = "<insert palindrome/string>"
reverse = word[::-1] 
is_palindrome = word.find(reverse)
print is_palindrome

这是 Udacity comp 101 第 1 章中的一个问题。回文给出 0 表示不给出 -1。它很简单，并且不使用循环。

Answer 17

我写了这段代码：

word = input("enter: ")
word = ''.join(word.split())`
for x in range(len(word)):
if list(word)[x] == ((list(word)[len(word)-x-1])):
if x+1 == len(word):
print("its pali")

它有效。它获取单词，然后删除空格并将其转换为列表，然后测试第一个字母是否等于最后一个字母，以及第二个字母是否等于最后一个字母，依此类推。

那么“如果 x+1 == len(word)”意味着由于 x 从 0 开始，它变为 1，然后每下一个 ..blah blah blah 它工作，所以它工作。

Answer 18

#compare 1st half with reversed second half
# i.e. 'abba' -> 'ab' == 'ba'[::-1]

def is_palindrome( s ):
   return True if len( s ) < 2 else s[ :len( s ) // 2 ] == s[ -( len( s ) // 2 ):][::-1]

Answer 19

您可以在 python 中使用 Deques 来检查回文

def palindrome(a_string): ch_dequeu = Deque() for ch in a_string: ch_dequeu.add_rear(ch) still_ok = True while ch_dequeu.size() > 1 and still_ok: first = ch_dequeu.remove_front() last = ch_dequeu.remove_rear() if first != last: still_ok = False return still_ok

class Deque: def __init__(self): self.items = [] def is_empty(self): return self.items == [] def add_rear(self, item): self.items.insert(0, item) def add_front(self, item): self.items.append(item) def size(self): return len(self.items) def remove_front(self): return self.items.pop() def remove_rear(self): return self.items.pop(0)

Answer 20

import string

word = input('Please select a word to test \n')
word = word.lower()
num = len(word)

x = round((len(word)-1)/2)
#defines first half of string
first = word[:x]

#reverse second half of string
def reverse_odd(text):
    lst = []
    count = 1
    for i in range(x+1, len(text)):

        lst.append(text[len(text)-count])
        count += 1
    lst = ''.join(lst)
    return lst

#reverse second half of string
def reverse_even(text):
    lst = []
    count = 1
    for i in range(x, len(text)):
        lst.append(text[len(text)-count])
        count += 1
    lst = ''.join(lst)
    return lst


if reverse_odd(word) == first or reverse_even(word) == first:
    print(string.capwords(word), 'is a palindrome')
else:
    print(string.capwords(word), 'is not a palindrome')

Answer 21

“算法”方式：

import math

def isPalindrome(inputString):
    if inputString == None:
        return False

    strLength = len(inputString)
    for i in range(math.floor(strLength)):
        if inputString[i] != inputString[strLength - 1 - i]:
            return False
    return True

Answer 22

如果您不想使用反向，还有另一种使用函数的方法

#!/usr/bin/python

A = 'kayak'

def palin(A):

    i = 0
    while (i<=(A.__len__()-1)):
        if (A[A.__len__()-i-1] == A[i]):
            i +=1
        else:
         return False

if palin(A) == False:

    print("Not a Palindrome")

else :

    print ("Palindrome")

Answer 23

递归看起来更漂亮！

def isPalindrome(x):
z = numToList(x)
length = math.floor(len(z) / 2)
if length < 2:
    if z[0] == z[-1]:
        return True
    else:
        return False
else:
    if z[0] == z[-1]:
        del z[0]
        del z[-1]
        return isPalindrome(z)
    else:
        return False

Answer 24

def is_palindrome(string):
   return string == ''.join([letter for letter in reversed(string)])

Answer 25

print ["Not a palindrome","Is a palindrome"][s == ''.join([s[len(s)-i-1] for i in range(len(s))])]

这是编写单行代码的典型方式

Answer 26

def pali(str1):
    l=list(str1)
    l1=l[::-1]
    if l1==l:
        print("yess")
    else:
        print("noo")
str1="abc"
a=pali(str1)
print(a)

Answer 27

我尝试使用这个：

def palindrome_numer(num):
num_str = str(num)
str_list = list(num_str)
if str_list[0] == str_list[-1]:
    return True
return False

它适用于一个数字，但我不知道是否是一个字符串

Answer 28

def isPalin(checkWord):
    Hsize = len(lst)/2
    seed = 1
    palind=True
    while seed<Hsize+1:
        #print seed,lst[seed-1], lst [-(seed)]
        if(lst[seed-1] != lst [-seed]):
            palind = False
            break
        seed = seed+1
    return palind

lst = 'testset'
print lst, isPalin(lst)    
lst = 'testsest'
print lst, isPalin(lst) 

输出

testset True
testsest False

Answer 29

查找和删除回文数的简单程序。

list1 =  [12, 45, 98, 76,21, 89, 63,36,10]
list2 = list1.copy()
list3 = list1.copy()
for i in list1:
    for j in list2:
        tmp = str(j)
        if str(i) == tmp[::-1]:
           list3.remove(j)
    list2=list3.copy()
print ("final list",list3)

Answer 30

最pythonic的方法确实是使用切片符号来反转已经提到的字符串：

def is_palindrome(string: str) -> bool:
    return string == string[::-1]

---

但在其他一些情况下（如技术面试），您可能必须编写一个“适当的”算法来找到回文。在这种情况下，以下应该可以解决问题：

def is_palindrome(string: str) -> bool:
    start = 0
    end = len(string) - 1
    
    while end >= start:
        if string[end] != string[start]:
            return False
        start += 1
        end -= 1
        
    return True

• 设置指向字符串开头和结尾的指针
• end超出时迭代start
• 如果end和start索引中的字符不匹配，那么这不是回文，否则继续比较
• 指针start加 1
• end将指针减1

---

测试用例：

import unittest

class Test(unittest.TestCase):

    palindromes = ['a', 'aa', 'aba', '12321']
    non_palindromes = ['ab', 'aab', 'cacacc']
    def test_is_palindrome(self):
        for case in self.palindromes:
            self.assertTrue(is_palindrome(case))

        for case in self.non_palindromes:
            self.assertFalse(is_palindrome(case))


if __name__ == '__main__':
    unittest.main()

Answer 31

您可以使用这个返回布尔值的单线：

str(x)==str(x)[::-1]

由于类型转换，这适用于单词和数字......

Answer 32

这是一个接受用户输入并检查输入是否为回文的示例：

name = input("Write your word here:  ")
input("Press <enter> to check if the word is a palindrome.")
if str(name) == str(name)[::-1]:
    print("True")
else:
    print("False")

但是，甚至不需要设置if/else语句。您可以直接打印逻辑比较的结果，如下所示：

name = input("Write your word here:  ")
input("Press <enter> to check if the word is a palindrome.")
print(str(name) == str(name)[::-1])

Answer 33

#!/usr/bin/python

str = raw_input("Enter a string ")
print "String entered above is %s" %str
strlist = [x for x in str ]
print "Strlist is %s" %strlist
strrev = list(reversed(strlist)) 
print "Strrev is %s" %strrev
if strlist == strrev :
   print "String is palindrome"
else :
   print "String is not palindrome"

Answer 34

这很容易

#palindrome
a=raw_input("enter the word")
b=a[::-1]
if a==b:
 print("enter word is palindrome")
else:`enter code here`
 print("not a palindrome")

谢谢