Python的除、整除、取余、四舍五入

1. 除 & 四舍五入

除用 / 表示
整数的除会显示一位小数

print(18 / 3)
6.0

出现无法除尽的数或者结果不准确的数，可使用四舍五入的方法进行处理

1.1 round

round的作用是四舍五入以及处理小数点位数

print(round(5.47834))
5 # 不输入参数的情况下默认输出整数

print(10 / 3)
3.3333333333333335 # 无法除尽

print(round(10 / 3, 4)) # 第二个参数的含义是保留的小数点位数
3.3333

1.2 floor

floor的含义为向下取整

print(math.floor(3.99999))
3

print(math.floor(-4.101))
-5

1.3 ceil

ceil则为向上取整

print(math.ceil(9.00001))
10

print(math.ceil(-40.9090909))
-40

2. 整除

经过整除后所得的数为除的结果的向下取整

print(16 / 3)
5.333333333333333

print(16 // 3)
5

print(-23 / 3)
-7.666666666666667

print(-23 // 3)
-8

3.取余

print(23 % 3)
2 # 3 * 7 + 2 = 23

print(-23 % 3)
1 # -8 * 3 + 1 = - 23

由上方结果可得出，无论被除数是正数还是负数，取余操作的结果均为正数
且取余操作的 商 * 被除数 = 小于被除数的最大整数，
例如在上方例子中 小于-23的最大整数为-24，所以商为-8，取余结果为 -23 - (-24) = 1

Leetcode 9. 回文数

根据以上内容，可以完成此题。
思路为以数学的方法反向重构目标数字。

def isPalindrome(self, x: int) -> bool:
    if x < 0:
        return False
    sub = x
    ans = 0
    while sub != 0:
        # rem为10的取余，即当前sub的最后一位数字
        rem = sub % 10
        # ans为最终反向重构的结果，每次迭代乘10（即进一位），再加上取余的结果rem
        ans = ans * 10 + rem
        # sub通过整除10的方法，移除最后一位数字
        sub = sub // 10
    # 比较重构结果ans与输入值x
    if ans == x:
        return True
    else:
        return False

Leetcode 8. 字符串转换整数 (atoi)

此题中需要注意的是对32 位有符号整数范围 [−2³¹, 2³¹ − 1]的操作

def myAtoi(self, s: str) -> int:
    INT_MAX = 2147483647 # 2^31^ − 1
    INT_MIN = -2147483648 # −2^31^
    start = 0
    ans = 0
    flag = 1
    n = len(s)
    if not s:
        return 0
    while start < n and s[start] == " ":
        start += 1
    if start == n:
        return 0
    if s[start] == "-":
        flag = -1
    if s[start] == "+" or s[start] == "-":
        start += 1
    while start < n and s[start].isdigit():
        tmp = int(s[start])
        # 当前结果ans为正数时，对比ans与INT_MAX整除10的结果
        # 若ans > INT_MAX // 10，则当执行ans = ans * 10 + tmp后，ans必定大于INT_MAX
        # 同样，如果ans == INT_MAX // 10, 当前遍历到的数字tmp若大于INT_MAX的最后一位7时，ans必定大于INT_MAX
        if flag == 1 and (ans > INT_MAX // 10 or (ans == INT_MAX // 10 and tmp > 7)):
            return INT_MAX
        # 当结果ans符号为负时，对比-ans与INT_MIN // 10 + 1，因为INT_MIN // 10 = -214748365
        # 若 -ans < INT_MIN // 10 + 1 (即小于-214748364)时，下次迭代 -ans必定小于INT_MIN
        # 同样，如果 -ans == INT_MIN // 10 + 1，tmp大于INT_MIN的最后一位8时，-ans必定小于INT_MIN
        if flag == -1 and (-ans < INT_MIN // 10 + 1 or (-ans == INT_MIN // 10 + 1 and tmp > 8)):
            return INT_MIN
        ans = ans * 10 + tmp
        start += 1
    return ans * flag