如何使用Python逻辑检查回文

我正在用Python检查回文。对于循环密集型的，我的代码非常

在我看来，当人们从C语言转向Python语言时，最大的错误就是试图用Python来实现C逻辑，这使得程序运行缓慢，而且它没有充分利用语言

我在网站上看到。搜索“C-style for”，Python没有C-style for循环。可能已经过时了，但我认为这意味着Python有自己的方法

我试着四处看看，找不到很多最新的（Python 3）建议。如何在Python中解决回文挑战，而不使用for循环

我在课堂上用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

def isPalindrome（n）：
lst=[int（n）表示str（n）中的n]
l=len（lst）
如果l==0 | | l==1：
返回真值
elif len（lst）%2==0:
适用于范围（l）内的k
#####
其他：
而（k一种确定给定值是否为回文的python方法：

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

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")

说明：


我们正在检查
n
的字符串表示是否等于
n
[：：-1]
切片负责反转字符串
之后，我们使用
==
python最棒的部分是你可以用它来做的事情。你不必为字符串使用索引

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

它只是简单地反转n，并检查它们是否相等。
n[：：-1]
反转n（-1表示减量）

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

关于上述内容，您希望使用
xrange
而不是range（因为range将创建一个实际列表，而xrange是一个快速生成器）

我对问题3的看法

在Python之前，我学习了C语言，我只是阅读了文档，并使用控制台对其进行了操作（通过处理Project Euler问题：）
一种替代非常不直观的
[：-1]
语法的方法是：

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

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

'.join（）
再次将这些字符连接在一起，中间没有任何内容。
下面是一个示例，它接受用户的输入并检查输入是否为回文：

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

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")

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

优化代码

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

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

输出：
0

输出：
-一,

解释：
搜索字符串时，返回的值是字符串起始位置的值

因此，当您执行
word.find（word[：：-1]）
时，它会在
0
位置查找
nepalapen
，并且
[：-1]
反转
nepalapen
位置
0
处仍然是
nepalapen
，因此返回
0

现在，当我们搜索
nepalapend
然后将
nepalapend
反转为
dnepalapen
时，它会呈现一个
FALSE
语句
nepalapend
被反转为
dnepalapen
，导致搜索无法找到
nepalapend
，结果是一个值
-1
，表示字符串不存在找到了


另一种方法是打印trueif回文else打印false

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

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

输出：
TRUE
这里是一个不区分大小写的函数，因为上面所有的解决方案都区分大小写

def Palindrome(string): 

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

此函数将返回一个布尔值。
在为python学习Watterloo课程时，会提出与“Lesseon”相同的问题，请在此处查找信息：


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

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

该函数称为isAlindrome（S），需要字符串“S”。
默认情况下，返回值为TRUE，以便对第一条if语句进行初始检查

之后，for循环运行字符串长度的一半，以检查位于“i”位置的字符串“S”中的字符前后是否相同。
如果情况并非如此，则函数停止，输出FALSE并返回FALSE

Cheers.kg
我知道这个问题不久前已经得到了回答，我对入侵表示歉意。不过，我也在研究用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)

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

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))

重新导入
规则=[
lambda s:any（x.isupper（）表示s中的x），
lambda s:不是s.isalpha（）
]
def是回文：
如果有（规则中规则的规则）：
s=re.sub（r'[^\w]'，''，s）.lower（）
如果长度小于2：
返回真值
如果s[0]！=s[-1]：
返回错误
返回是_回文（s[1:-1]）
string=‘我们不是在前进吗，我们很少，在新时代前进吗？’
打印（是_回文（字符串））

对于上面的输入，输出为
True
。
也许您可以试试这个：

list=input('enter a string:')

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

我刚刚找到了一个更简单的方法，只有一行

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

你在用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"

就记录而言，对于那些寻找更具算法性的方法来验证给定字符串是否为回文的人，有两种方法可以实现相同的效果（使用
while
和
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

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

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

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

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

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")

#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]

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')

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

#!/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")

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

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

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

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

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

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