【Python作业】数字反转+计算题+求100以内的完数+最大公约数与最小公倍数

Python 作业题目：

一、第一题：数字反转

# 一：输入一个整数，将各位数字反转后输出。
# 例如：输入1234，输出4321
# 例如：输入-1234，输出-4321
# 例如：输入2000，输出2

class Solution:
    def __init__(self, num):
        # isNegative 用于标记num是否为负数
        self.isNegative = num < 0
        # 如果num为负数，先把负号去掉，再为结果添加负号
        self.num = num if num >= 0 else -num

    def output(self, number):
        # 如果初始化时用户输入的是负数，那么在输出结果这里再添加负号
        return number if not self.isNegative else -number

    # 方法一：数学运算
    def my_reverse_by_calc(self):
        result = 0
        # 将self.num拷贝一份给_num，用于后面的循环，以免污染self.num
        _num = self.num
        while _num != 0:
            # 从个位开始取出数字，依次添加到result的个位、十位、百位...
            result = result * 10 + _num % 10
            _num //= 10
        return self.output(result)

    # 方法二：字符串反转
    def my_reverse_by_str(self):
        return self.output(int(str(self.num)[::-1]))

    # 方法三：列表
    def my_reverse_by_list(self):
        result = []
        # 将self.num拷贝一份给_num，用于后面的循环，以免污染self.num
        _num = self.num
        while _num != 0:
            # 从个位开始取出数字，依次添加到result的数组中，最后再用join()方法拼接成字符串
            result.append(str(_num % 10))
            _num //= 10
        return self.output(int("".join(result)))

    # 方法四：递归
    def my_reverse_by_recursion(self):

        # 嵌套函数 recursion()，用于递归
        def recursion(number):
            if number < 10:
                return number
            else:
                # 先运算 10 ** (len(str(num)) - 1)，再与 num % 10 的结果相乘
                return (number % 10) * (10 ** (len(str(number)) - 1)) + recursion(number // 10)

        return self.output(recursion(self.num))

    # 方法五：列表反转（列表推导式）
    def my_reverse_by_list_comprehension(self):
        _list = list(str(self.num))
        # 数组自带的reverse()方法，可以直接反转数组
        _list.reverse()
        return self.output(int("".join(_list)))

    # 方法六：字符串中对称字符俩俩互换
    def my_reverse_by_flip(self):
        _list = list(str(self.num))
        for i in range(len(_list) // 2):
            _list[i], _list[-i - 1] = _list[-i - 1], _list[i]
        return self.output(int("".join(_list)))


if __name__ == '__main__':
    try:
        num = int(input("请输入一个整数："))
    except ValueError:
        print("输入错误！")
    else:
        # 实例化解决方案类
        solution = Solution(num)
        print("方法一（数学运算）：", solution.my_reverse_by_calc())
        print("方法二（字符串反转）：", solution.my_reverse_by_str())

        try:
            print("方法三（列表）：", solution.my_reverse_by_list())  # 输入0时，故意报错不处理，用于展示异常处理
        except Exception as e:
            print("【ERROR】方法三（列表）报错内容：", e)

        print("方法四（递归）：", solution.my_reverse_by_recursion())
        print("方法五（列表反转）：", solution.my_reverse_by_list_comprehension())
        print("方法六（字符串中对称字符俩俩互换）：", solution.my_reverse_by_flip())
        

第二题：计算题

# 二：计算题
# 方法一（展开式）：
_sum = 0
for i in range(1, 100):
    if i % 2 != 0:
        _sum += i ** 2
    else:
        _sum -= i ** 2
print("方法一（展开式）：", _sum)

# 方法二（一行列表推导式）：
print("方法二（一行列表推导式）：", sum([(i ** 2 if (i % 2 != 0) else -(i ** 2)) for i in range(1, 100)]))

# 方法三（一行匿名函数）：
print("方法三（一行匿名函数）：", sum([(lambda i: i ** 2 if (i % 2 != 0) else -(i ** 2))(i) for i in range(1, 100)]))


# 方法四（递归）：
def getSum(num):
    # 递归终止条件
    if num == 1:
        return 1

    if num % 2 != 0:
        return num ** 2 + getSum(num - 1)
    else:
        return -(num ** 2) + getSum(num - 1)


print("方法四（递归）：", getSum(100 - 1))

第三题：找出100以内的所有完数

# 三：找出100以内的所有完数
# 方法一（for循环）：
def isPerfectNumberByFor(num):
    _list = []
    for i in range(1, 100):
        _sum = 0
        for j in range(1, i):
            if i % j == 0:
                # 把所有完数加起来求和
                _sum += j
        if _sum == i:
            # 满足完数和等于本身的条件
            _list.append(i)
    return _list


print("方法一（for循环）：", isPerfectNumberByFor(100))

# 方法二（一行列表推导式）：
print("方法二（一行列表推导式）：", [i for i in range(1, 100) if sum([j for j in range(1, i) if i % j == 0]) == i])

# 方法三（一行匿名函数）：
print("方法三（一行匿名函数）：",
      [i for i in range(1, 100) if sum([(lambda j: j if i % j == 0 else 0)(j) for j in range(1, i)]) == i])


# 方法四（递归）：
def isPerfectNumberByRecursive(num):
    if num == 1:
        # 递归终止条件
        return []
    _sum = 0
    for i in range(1, num):
        if num % i == 0:
            _sum += i
    return isPerfectNumberByRecursive(num - 1) + ([num] if _sum == num else [])


print("方法四（递归）：", isPerfectNumberByRecursive(100))

第四题：最大公约数与最小公倍数

# 四：输入两个正整数m和n，求其最大公约数和最小公倍数。

# 获取最大公约数（用较大的数除以较小的数，将小的一个数作为下一轮的较大的数，
# 余数作为下一轮的较小的数，直到余数为0，此时的较小的数即为最大公约数）
def getGCD(num1, num2):
    if num1 < num2:
        num1, num2 = num2, num1
    while num1 % num2 != 0:
        num1, num2 = num2, num1 % num2
    return num2


# 递归方法实现最大公约数
def getGCD_byRecursion(num1, num2):
    if num1 < num2:
        num1, num2 = num2, num1
    if num2 == 0:
        return num1
    else:
        return getGCD_byRecursion(num2, num1 % num2)


if __name__ == "__main__":
    try:
        m = int(input("请输入第一个正整数："))
        n = int(input("请输入第二个正整数："))
        if m <= 0 or n <= 0:
            # 如果输入的数不是正整数，则抛出异常
            raise ValueError
    except ValueError:
        print("输入错误，请输入正整数！")
    else:
        # 正常运行……

        # 具名函数：获取最大公约数
        print("最大公约数为：", getGCD(m, n))
        # 匿名函数：获取最小公倍数（最小公倍数 = 两数之积 / 最大公约数）
        print("最小公倍数为：", (lambda num1, num2: (num1 * num2) // getGCD(num1, num2))(m, n))
        # 递归函数
        print("最大公约数为（递归实现）：", getGCD_byRecursion(m, n))