python整型为空的情况_深度剖析凭什么python中整型不会溢出

前言

不溢出的整型的可行性

[longintrepr.h]

struct _longobject {

PyObject_VAR_HEAD

int *ob_digit;

};

长整型的保存形式

ob_digit[0] = 789;

ob_digit[1] = 456;

ob_digit[2] = 123;

#define PyLong_SHIFT 15

#define PyLong_BASE ((digit)1 << PyLong_SHIFT)

#define PyLong_MASK ((digit)(PyLong_BASE - 1))

长整型的运算

ob_digit[2]

ob_digit[1]

ob_digit[0]

加数a

23

934

543

加数b

+

454

632

结果z

24

389

175

[longobject.c]

static PyLongObject * x_add(PyLongObject *a, PyLongObject *b) {

int size_a = len(a), size_b = len(b);

PyLongObject *z;

int i;

int carry = 0; // 进位

// 确保a是两个加数中较大的一个

if (size_a < size_b) {

// 交换两个加数

swap(a, b);

swap(&size_a, &size_b);

}

z = _PyLong_New(size_a + 1); // 申请一个能容纳size_a+1个元素的长整型对象

for (i = 0; i < size_b; ++i) {

carry += a->ob_digit[i] + b->ob_digit[i];

z->ob_digit[i] = carry & PyLong_MASK; // 掩码

carry >>= PyLong_SHIFT; // 移除低15位, 得到进位

}

for (; i < size_a; ++i) { // 单独处理a中高位数字

carry += a->ob_digit[i];

z->ob_digit[i] = carry & PyLong_MASK;

carry >>= PyLong_SHIFT;

}

z->ob_digit[i] = carry;

return long_normalize(z); // 整理元素个数

}

乘法运算

操作

ob_digit[2]

ob_digit[1]

ob_digit[0]

乘数a

23

934

543

乘数b

*

454

632

结果z

15

126

631

176

10

866

282

522

结果z

10

881

409

153

176

// 为方便理解，会与cpython中源码部分稍有不同

static PyLongObject * x_mul(PyLongObject *a, PyLongObject *b)

{

int size_a = len(a), size_b = len(b);

PyLongObject *z = _PyLong_New(size_a + size_b);

memset(z->ob_digit, 0, len(z) * sizeof(int)); // z 的数组清 0

for (i = 0; i < size_b; ++i) {

int carry = 0; // 用一个int保存元素之间的乘法结果

int f = b->ob_digit[i]; // 当前乘数b的元素

// 创建一个临时变量，保存当前元素的计算结果，用于累加

PyLongObject *temp = _PyLong_New(size_a + size_b);

memset(temp->ob_digit, 0, len(temp) * sizeof(int)); // temp 的数组清 0

int pz = i; // 存放到临时变量的低位

for (j = 0; j < size_a; ++j) {

carry = f * a[j] + carry;

temp[pz] = carry & PyLong_MASK; // 取低15位

carry = carry >> PyLong_SHIFT; // 保留进位

pz ++;

}

if (carry){ // 处理进位

carry += temp[pz];

temp[pz] = carry & PyLong_MASK;

carry = carry >> PyLong_SHIFT;

}

if (carry){

temp[pz] += carry & PyLong_MASK;

}

temp = long_normalize(temp);

z = x_add(z, temp);

}

return z

}

总结

[longobject.c]

PyObject * PyLong_FromString(const char *str, char **pend, int base)

{

}

参考

附录

# 例子中的表格中，数组元素最多存放3位整数，因此这边设置1000

# 对应的取低位与取高位也就变成对 1000 取模和取余操作

PyLong_SHIFT = 1000

PyLong_MASK = 999

# 以15位长度的二进制

# PyLong_SHIFT = 15

# PyLong_MASK = (1 << 15) - 1

def long_normalize(num):

"""

去掉多余的空间，调整数组的到正确的长度

eg: [176, 631, 0, 0] ==> [176, 631]

:param num:

:return:

"""

end = len(num)

while end >= 1:

if num[end - 1] != 0:

break

end -= 1

num = num[:end]

return num

def x_add(a, b):

size_a = len(a)

size_b = len(b)

carry = 0

# 确保 a 是两个加数较大的，较大指的是元素的个数

if size_a < size_b:

size_a, size_b = size_b, size_a

a, b = b, a

z = [0] * (size_a + 1)

i = 0

while i < size_b:

carry += a[i] + b[i]

z[i] = carry % PyLong_SHIFT

carry //= PyLong_SHIFT

i += 1

while i < size_a:

carry += a[i]

z[i] = carry % PyLong_SHIFT

carry //= PyLong_SHIFT

i += 1

z[i] = carry

# 去掉多余的空间，数组长度调整至正确的数量

z = long_normalize(z)

return z

def x_mul(a, b):

size_a = len(a)

size_b = len(b)

z = [0] * (size_a + size_b)

for i in range(size_b):

carry = 0

f = b[i]

# 创建一个临时变量

temp = [0] * (size_a + size_b)

pz = i

for j in range(size_a):

carry += f * a[j]

temp[pz] = carry % PyLong_SHIFT

carry //= PyLong_SHIFT

pz += 1

if carry: # 处理进位

carry += temp[pz]

temp[pz] = carry % PyLong_SHIFT

carry //= PyLong_SHIFT

pz += 1

if carry:

temp[pz] += carry % PyLong_SHIFT

temp = long_normalize(temp)

z = x_add(z, temp) # 累加

return z

a = [543, 934, 23]

b = [632, 454]

print(x_add(a, b))

print(x_mul(a, b))