话不多说，就是开始练习，因为之前编程的经验比较少，怎么办，就像马化腾一样，先抄袭，只有抄袭完成了之后，你才会获得你自己的知识
总体思路是先抄袭，再领悟。最后一定要自己默写打一次。不然没印象
案例1：求最长的回文数

class Solution:
    def longestPalindrome(self, s: str) -> str:
        def huiwenshu(s, l, r):
            while l >= 0 and r < len(s) and s[l] == s[r]:
                l -= 1
                r += 1
            return s[l + 1:r]

        res = ''
        for i in range(len(s)):
            sub1 = huiwenshu(s, i, i)
            sub2 = huiwenshu(s, i, i + 1)
            res = sub1 if len(sub1) > len(res) else res
            res = sub2 if len(sub2) > len(res) else res
        return res

a=Solution()
f=a.longestPalindrome('abcdcda')
print(f)

案例二

class Solution:
    def isPalindrome(self, x: int) -> bool:
         return str(x) == str(x)[::-1]

案例三：

class Solution:
    def mySqrt(self, x: int) -> int:
        left,right = 0,x
        while left <= right:
            mid = (left + right)//2
            if mid * mid == x:
                return mid
            elif mid * mid > x:
                if (mid-1)*(mid-1) <= x:
                    return mid-1
                right = mid -1
            else:
                if (mid+1) * (mid+1) > x:
                    return mid
                left = mid + 1
        return left

class Solution: def addStrings(self, num1: str, num2: str) -> str: return str(int(num1)+int(num2))

class Solution:
def findTheDifference(self, s: str, t: str) -> str:
res = 0
for i in s+t:
res ^= ord(i)
return chr(res)

`# Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

class Solution:
def isSymmetric(self, root: Optional[TreeNode]) -> bool:
if not root:
return True
def jugde(left,right):
if not left and not right:
return True
if not left or not right:
return False
if left.val != right.val:
return False
return jugde(left.left,right.right) and jugde(left.right, right.left)
return jugde(root.left, root.right)`