1. 题目

自己第一时间想到的答案

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        ans = 0

        flag = False
        if x < 0:
            flag = True
            x = -x

        while x != 0:
            ans = ans * 10 + x % 10
            x = ( x - (x % 10) ) / 10
        
        if ans > 2** 31-1 or ans < - (2**31):
            return 0
        
        if flag:
            return -ans
        return ans

看题解意识到Python可以直接将数值转化为字符串，那么就有了更暴力的方法！

专属于Python的暴力算法

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """

        str_x = str(x)
        
        # 判断负数
        if str_x[0] == '-':
            str_x = str_x[-1:0:-1]
            ans = int(str_x)
            ans = -ans
        else:
            str_x = str_x[::-1]
            ans = int(str_x)
        
        if ans > 2**31-1 or ans < -(2**31):
            return 0
        return ans

法一的优化

def reverse_better(
        self, 
        x: int) -> int:
       
        
        y, res = abs(x), 0
        # 则其数值范围为 [−2^31,  2^31 − 1]
        boundry = (1<<31) -1 if x>0 else 1<<31
        while y != 0:
            res = res*10 +y%10
            if res > boundry :
                return 0
            y //=10
        return res if x >0 else -res

反思复盘

python关于位运算和赋值的操作:

• (a & b)
  按位与运算符：参与运算的两个值，如果两个相应位都为 1，则该位的结果为 1，否则为 0 。
  输出结果 12 ，二进制解释： 0000 1100
• (a | b)
  按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
  输出结果 61 ，二进制解释： 0011 1101
• (a ^ b)
  按位异或运算符：当两对应的二进位相异时，结果为 1
  输出结果 49 ，二进制解释： 0011 0001
• (~a )
  按位取反运算符：对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1 。~x 类似于 -x-1
  输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
• a << 2
  左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补 0。
  输出结果 240 ，二进制解释： 1111 0000
• a >> 2
  右移动运算符：把 ">>" 左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
  输出结果 15 ，二进制解释： 0000 1111

python 赋值运算符：

• *= 乘法赋值运算符 c *= a 等效于 c = c * a
• /= 除法赋值运算符 c /= a 等效于 c = c / a
• %= 取模赋值运算符 c %= a 等效于 c = c % a
• **= 幂赋值运算符 c **= a 等效于 c = c ** a
• //= 取整除赋值运算符 c //= a 等效于 c = c // a