如下是用python编写的+-*/程序（仅仅计算小数据的，如何改位大数据的？）：

 class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero.")
        return a / b

>>> 123456789+123456789
246913578
>>> 123456789*123456789
15241578750190521
>>> 123456789-123456789
0
>>> 123456789/123
1003713.731707317
>>>

加法：
 def bigintAdd(num1, num2):
    if not (num1.isdigit() and num2.isdigit()):
        raise ValueError("输入必须是纯数字字符串")
    i, j, carry, result = len(num1)-1, len(num2)-1, 0, []
    while i >= 0 or j >= 0 or carry:
        digit1 = int(num1[i]) if i >= 0 else 0
        digit2 = int(num2[j]) if j >= 0 else 0
        total = digit1 + digit2 + carry
        current_digit = total % 10
        carry = total // 10
        result.append(str(current_digit))
        i, j = i-1, j-1
    return ''.join(reversed(result))

>>> 123456789123456789123456789123456789+123456789123456789123456789123456789
246913578246913578246913578246913578

乘法：
def multi(stra, strb):
    a, b = list(stra), list(strb)
    a.reverse()
    b.reverse()
    result = [0 for i in range(len(a)+len(b))]
    for i in range(len(a)):
        for j in range(len(b)):
            result[i+j] += int(a[i]) * int(b[j])
    return list2str(result)

>>> 123456789123456789*123456789123456789
15241578780673678515622620750190521

加法：
def xiangjia(a1, b1):
    lista = list(a1[::-1])  # 翻转
    listb = list(b1[::-1])
    list_resu = []
    yu9 = 0
    for x in range(max(len(a1), len(b1))):
        ax_temp = int(lista[x]) if x < len(a1) else 0
        bx_temp = int(listb[x]) if x < len(b1) else 0
        resu9 = (ax_temp + bx_temp + yu9) % 10  # 进位
        yu9 = (ax_temp + bx_temp + yu9) // 10  # 余数
        list_resu.append(resu9)
    if yu9 > 0:
        list_resu.append(yu9)  # 循环完了后，如果还有余数，继续添加
    resu8 = ''
    for x in list_resu[::-1]:
        resu8 += str(x)
    return resu8

>>> 123456789123456789+123456789
123456789246913578

大整数乘法
以下是使用Karatsuba算法实现的大整数乘法，时间复杂度为O(n^log3) 3：

def karatsuba(x, y):
    if x < 10 or y < 10:
        return x * y
    m = max(len(str(x)), len(str(y)))
    n = m // 2
    high1, low1 = divmod(x, 10**n)
    high2, low2 = divmod(y, 10**n)
    z0 = karatsuba(low1, low2)
    z1 = karatsuba((low1 + high1), (low2 + high2))
    z2 = karatsuba(high1, high2)
    return z2 * 10**(2*n) + (z1 - z2 - z0) * 10**n + z0

>>> 123456789123456789*123456789123456789
15241578780673678515622620750190521

大整数减法和除法
对于大整数减法和除法，Python内置的int类型已经可以处理任意精度的整数，因此可以直接使用减法和除法运算符。如果需要自定义实现，可以参考以下思路：

减法：可以参考加法的实现，通过逐位相减并处理借位来实现。
除法：可以通过反复减法或使用二分查找的方法来实现。

乘法：
def karatsuba(x, y):
    if x < 10 or y < 10:
        return x * y
    m = max(len(str(x)), len(str(y)))
    n = m // 2
    high1, low1 = divmod(x, 10**n)
    high2, low2 = divmod(y, 10**n)
    z0 = karatsuba(low1, low2)
    z1 = karatsuba((low1 + high1), (low2 + high2))
    z2 = karatsuba(high1, high2)
    return z2 * 10**(2*n) + (z1 - z2 - z0) * 10**n + z0

>>> 123456789123456789*123456789123456789
15241578780673678515622620750190521
>>> 15241578780673678515622620750190521*15241578780673678515622620750190521
232305723727482136736965112570594549331669488907280437155857798251441
>>> 232305723727482136736965112570594549331669488907280437155857798251441*232305723727482136736965112570594549331669488907280437155857798251441
53965949276549257017761341874357115688496019057002204542273375568377042520293152587800908606568787929667895103558105995220885237058576481
>>> 53965949276549257017761341874357115688496019057002204542273375568377042520293152587800908606568787929667895103558105995220885237058576481*53965949276549257017761341874357115688496019057002204542273375568377042520293152587800908606568787929667895103558105995220885237058576481
2912323681319087276896292896602061823733312760077444701315408185351057670087028244059979403230689993375265710789388323582471032007630069169906481764104780356006108341689962764227388619591723330616569843561003036207376308188058116846525184689310774374630718780053198126343361
>>> 2912323681319087276896292896602061823733312760077444701315408185351057670087028244059979403230689993375265710789388323582471032007630069169906481764104780356006108341689962764227388619591723330616569843561003036207376308188058116846525184689310774374630718780053198126343361*2912323681319087276896292896602061823733312760077444701315408185351057670087028244059979403230689993375265710789388323582471032007630069169906481764104780356006108341689962764227388619591723330616569843561003036207376308188058116846525184689310774374630718780053198126343361
8481629224771960626723572658049629659922293242642651320848400264729194286470027547461903038504039245219681022413851871269234243445772821409793321240670391074394602049974567896439640894467728176742989725456491558081800714584755103869173739764920604793586921520409624799244733302659390198338401581848877764605818032361565301063462318550057557001448042454905131917764530911077628737167882623910276001493871672482567594050283666818533776412716096410988137539110002299623388548291776443297091438736618176076812356335914362355999062685604199600868776321
>>>

大整数除法的Python代码
在Python中，整数可以任意大而不损失精度，因此可以直接使用整数除法运算符//和取余运算符%来实现大整数除法。以下是完整的Python代码示例：

def big_int_division(dividend, divisor):
    quotient = dividend // divisor
    remainder = dividend % divisor
    return quotient, remainder

# 示例用法
dividend = 10**40 + 23
divisor = 2

quotient, remainder = big_int_division(dividend, divisor)

print(f"Dividend: {dividend}")
print(f"Divisor: {divisor}")
print(f"Quotient: {quotient}")
print(f"Remainder: {remainder}")
复制
Python
代码解释
函数定义：big_int_division函数接受两个参数dividend（被除数）和divisor（除数）。
整数除法：使用//运算符计算商（quotient）。
取余运算：使用%运算符计算余数（remainder）。
返回结果：函数返回商和余数。
示例输出
对于给定的示例，输出结果如下：

Dividend: 1000000000000000000000000000000000000023
Divisor: 2
Quotient: 5000000000000000000000000000000000000011
Remainder: 1
复制
注意事项
Python的整数类型可以处理任意大的整数，不会出现溢出问题2。
如果需要处理非常大的整数，建议使用字符串输入，并在函数内部将其转换为整数进行处理。例如：
def big_int_division_from_string(dividend_str, divisor_str):
    dividend = int(dividend_str)
    divisor = int(divisor_str)
    quotient = dividend // divisor
    remainder = dividend % divisor
    return quotient, remainder

# 示例用法
dividend_str = "1000000000000000000000000000000000000023"
divisor_str = "2"

quotient, remainder = big_int_division_from_string(dividend_str, divisor_str)

print(f"Dividend: {dividend_str}")
print(f"Divisor: {divisor_str}")
print(f"Quotient: {quotient}")
print(f"Remainder: {remainder}")
复制
Python
这样可以确保输入的字符串被正确解析为大整数进行处理。

你可能还想知道
如何手动实现大整数除法算法?
（1）大整数除法，不用//和%的代码
（2）余数和商，手动模拟大整数除法代码
大整数除法性能优化方法?
（1）10^100的大整数除法，Python能处理吗?
（2）大整数除法，Python有内置优化库吗?

整除和求余：
def big_int_division(dividend, divisor):
    quotient = dividend // divisor
    remainder = dividend % divisor
    return quotient, remainder

>>> big_int_division(123456789123, 123456789)
(1000, 123)

整除示例：
>>> 123456789123//123456789
1000
>>>