Hướng dẫn how do you take long integers in python 3? - làm thế nào để bạn lấy số nguyên dài trong python 3?

Python 2 sẽ tự động đặt loại dựa trên kích thước của giá trị. Một hướng dẫn về các giá trị tối đa có thể được tìm thấy dưới đây.

Giá trị tối đa của int mặc định trong python 2 là 65535, bất cứ thứ gì trên đó sẽ dài

Ví dụ:

>> print type[65535]

>>> print type[65536*65536]

Trong Python 3, kiểu dữ liệu dài đã bị xóa và tất cả các giá trị số nguyên được xử lý bởi lớp INT. Kích thước mặc định của INT sẽ phụ thuộc vào kiến ​​trúc CPU của bạn.

Ví dụ:

• Các hệ thống 32 bit Kiểu dữ liệu mặc định cho số nguyên sẽ là 'INT32'
• Hệ thống 64 bit Kiểu dữ liệu mặc định cho số nguyên sẽ là 'int64'

Các giá trị tối đa/tối đa của từng loại có thể được tìm thấy bên dưới:

• Int8: [-128.127]
• Int16: [-32768.32767]
• Int32: [-2147483648,2147483647]
• Int64: [-9223372036854775808,9223372036854775807]
• Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
• UINT8: [0,255]
• UINT16: [0,65535]
• UINT32: [0,4294967295]
• UINT64: [0,18446744073709551615]
• UINT128: [0,340282366920938463463374607431768211455]

Nếu kích thước của INT của bạn vượt quá các giới hạn được đề cập ở trên, Python sẽ tự động thay đổi loại của nó và phân bổ nhiều bộ nhớ hơn để xử lý sự gia tăng này trong các giá trị tối đa/tối đa. Trong trường hợp trong Python 2, nó sẽ chuyển đổi thành 'Long', giờ đây nó chỉ chuyển đổi thành kích thước tiếp theo của int.

Ví dụ: Nếu bạn đang sử dụng hệ điều hành 32 bit, giá trị tối đa của bạn sẽ là 2147483647 theo mặc định. Nếu giá trị từ 2147483648 trở lên được gán, loại sẽ được thay đổi thành Int64.

Có nhiều cách khác nhau để kiểm tra kích thước của INT và đó là phân bổ bộ nhớ. Lưu ý: Trong Python 3, sử dụng phương thức loại tích hợp [] sẽ luôn trả về

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

10000000000000000000000000000000000000000001

Khi bạn mã hóa bằng ngôn ngữ cấp thấp như C, bạn lo lắng về việc chọn đúng loại dữ liệu và vòng loại cho số nguyên của bạn; Ở mỗi bước, bạn cần phải suy nghĩ nếu

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

Trong C, khi bạn cố gắng tính toán 220000 bằng hàm

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

#include 
#include 

int main[void] {
  printf["%Lf\n", powl[2, 20000]];
  return 0;
}

$ ./a.out
inf

Nhưng đối với Python, nó là một miếng bánh 🎂

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

Python phải làm một cái gì đó đẹp trong nội bộ để hỗ trợ các số nguyên có kích thước tùy ý và hôm nay chúng tôi tìm ra những gì dưới mui xe!

Đại diện và định nghĩa

Một số nguyên trong Python là một cấu trúc C được xác định như sau

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

Các loại khác có

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

>>> 2 ** 20000
39802768403379665923543072061912024537047727804924259387134 ...
...
... 6021 digits long ...
...
6309376

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

Điều này chỉ ra rằng một số nguyên, giống như

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
    digit ob_digit[1];
};

Đây là một số trường meta trong cấu trúc

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

4, được sử dụng để đếm tham chiếu [thu gom rác], nhưng chúng tôi sẽ yêu cầu một bài viết riêng. Trường mà chúng tôi sẽ tập trung vào là

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

5 và ở một mức độ nào đó

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

6.

Giải mã

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

5

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

10000000000000000000000000000000000000000001

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

Nói chung, trong các ngôn ngữ cấp thấp như C, độ chính xác của các số nguyên được giới hạn ở mức 64 bit, nhưng Python thực hiện các số nguyên chính xác tùy ý. Vì Python 3, tất cả các số nguyên được biểu diễn dưới dạng bignum và chúng chỉ bị giới hạn bởi bộ nhớ có sẵn của hệ thống máy chủ.

Giải mã

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

6

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

Kho

Một cách ngây thơ để lưu trữ một số nguyên chữ số là bằng cách thực sự lưu trữ một chữ số thập phân trong một mục của mảng và sau đó các hoạt động như bổ sung và trừ có thể được thực hiện giống như toán học lớp.

Với cách tiếp cận này, một số

struct _longobject {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
    digit ob_digit[1];
};

Cách tiếp cận này không hiệu quả vì chúng ta sẽ sử dụng tăng 32 bit chữ số [

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;

Vì vậy, chúng ta có thể làm tốt hơn không? Để chắc chắn, nếu không, bài viết này sẽ không giữ chỗ trên internet. Hãy đi sâu vào cách Python lưu trữ một số nguyên siêu dài.

Cách pythonic

Thay vì chỉ lưu trữ một chữ số thập phân trong mỗi mục của mảng

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

Trong hệ thống số thập lục phân, cơ sở là 16 ~ 24 Điều này có nghĩa là mỗi "chữ số" của một số thập lục phân dao động từ 0 đến 15 của hệ thống thập phân. Tương tự đối với Python, "Digit" nằm trong cơ sở 230, điều đó có nghĩa là nó sẽ dao động từ 0 đến 230 - 1 = 1073741823 của hệ thống thập phân.

Bằng cách này, Python sử dụng hiệu quả hầu hết tất cả không gian được phân bổ 32 bit mỗi chữ số và giữ cho chính nó tháo vát và vẫn thực hiện các hoạt động như bổ sung và trừ như toán học lớp.

Tùy thuộc vào nền tảng, Python sử dụng các mảng số nguyên không dấu 32 bit với các chữ số 30 bit hoặc các mảng số nguyên không dấu 16 bit với các chữ số 15 bit. Nó đòi hỏi một vài bit để thực hiện các hoạt động sẽ được thảo luận trong một số bài viết trong tương lai.

Ví dụ: 1152921504606846976

Như đã đề cập, đối với Python, một "chữ số" là cơ sở 230 do đó nếu bạn chuyển đổi

struct _longobject {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
    digit ob_digit[1];
};

struct _longobject {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
    digit ob_digit[1];
};

1152921504606846976 = 1 * [230] 2 + 0 * [230] 1 + 0 * [230] 0 = 1 * [230]2 + 0 * [230]1 + 0 * [230]0

Vì

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

struct _longobject {
    PyObject ob_base;
    Py_ssize_t ob_size; /* Number of items in variable part */
    digit ob_digit[1];
};

Cấu trúc

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

• struct _longobject {
      PyObject_VAR_HEAD
      digit ob_digit[1];
  };
  

  6 là

  ...
      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;
      }
      for [; i < size_a; ++i] {
          carry += a->ob_digit[i];
          z->ob_digit[i] = carry & PyLong_MASK;
          carry >>= PyLong_SHIFT;
      }
      z->ob_digit[i] = carry;
  ...
  

  0

• struct _longobject {
      PyObject_VAR_HEAD
      digit ob_digit[1];
  };
  

  5 là

  ...
      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;
      }
      for [; i < size_a; ++i] {
          carry += a->ob_digit[i];
          z->ob_digit[i] = carry & PyLong_MASK;
          carry >>= PyLong_SHIFT;
      }
      z->ob_digit[i] = carry;
  ...
  

  2

Tôi đã tạo ra một bản demo sẽ xuất hiện theo cách mà Python đang lưu trữ các số nguyên trong nội bộ và cũng có tham chiếu đến các thành viên cấu trúc như

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[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;
    }
    for [; i < size_a; ++i] {
        carry += a->ob_digit[i];
        z->ob_digit[i] = carry & PyLong_MASK;
        carry >>= PyLong_SHIFT;
    }
    z->ob_digit[i] = carry;
...

Hoạt động trên các số nguyên siêu dài

Bây giờ chúng ta có một ý tưởng công bằng về cách Python hỗ trợ và thực hiện các số nguyên chính xác tùy ý của nó để hiểu làm thế nào các hoạt động toán học khác nhau xảy ra với chúng.

Phép cộng

Các số nguyên vẫn tồn tại "khôn ngoan về chữ số", điều này có nghĩa là sự bổ sung cũng đơn giản như những gì chúng ta học được ở trường lớp và mã nguồn của Python cho chúng ta thấy rằng đây chính xác là cách nó được thực hiện. Hàm có tên X_ADD trong Tệp LongObject.c thực hiện việc bổ sung hai số.

...
    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;
    }
    for [; i < size_a; ++i] {
        carry += a->ob_digit[i];
        z->ob_digit[i] = carry & PyLong_MASK;
        carry >>= PyLong_SHIFT;
    }
    z->ob_digit[i] = carry;
...

Đoạn mã ở trên được lấy từ hàm

...
    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;
    }
    for [; i < size_a; ++i] {
        carry += a->ob_digit[i];
        z->ob_digit[i] = carry & PyLong_MASK;
        carry >>= PyLong_SHIFT;
    }
    z->ob_digit[i] = carry;
...

Mọi thứ trở nên thú vị khi kết quả của việc bổ sung là một số âm. Dấu hiệu của

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

6 là dấu hiệu của số nguyên, có nghĩa là, nếu bạn có số âm thì

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

6 sẽ âm. Giá trị tuyệt đối của

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

6 sẽ xác định số chữ số trong

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};

5.

Phép trừ

Tương tự như cách bổ sung được thực hiện, phép trừ cũng xảy ra theo chữ số. Hàm có tên x_sub trong Tệp LongObject.c thực hiện phép trừ hai số.

10000000000000000000000000000000000000000001

Đoạn mã ở trên được lấy từ hàm

10000000000000000000000000000000000000000001

Phép nhân

Một lần nữa, một cách ngây thơ để thực hiện phép nhân sẽ là những gì chúng ta học được trong toán học lớp nhưng nó sẽ không hiệu quả. Python, để giữ cho mọi thứ hiệu quả thực hiện thuật toán Karatsuba nhân lên hai số N-chữ số N trong các bước cơ bản O [NLOG23].

Thuật toán hơi phức tạp nằm ngoài phạm vi của bài viết này nhưng bạn có thể tìm thấy việc triển khai của nó trong các hàm k_mul và k_lopsided_mul trong tệp longobject.c.

Bộ phận và các hoạt động khác

Tất cả các hoạt động trên số nguyên được xác định trong tệp longoBject.c và nó rất đơn giản để định vị và theo dõi từng cái. CẢNH BÁO: Sẽ mất một thời gian để hiểu chi tiết từng người một số bỏng ngô trước khi bạn bắt đầu lướt qua.

Tối ưu hóa các số nguyên thường được sử dụng

Python preall phân biến các số nguyên nhỏ trong phạm vi từ -5 đến 256. Phân bổ này xảy ra trong quá trình khởi tạo và vì chúng tôi không thể cập nhật số nguyên [tính bất biến] các số nguyên được phân tách này là đơn lẻ và được tham chiếu trực tiếp thay vì phân bổ lại. Điều này có nghĩa là mỗi khi chúng ta sử dụng/tạo ra một số nguyên nhỏ, python thay vì phân bổ lại chỉ trả về tham chiếu của một cái được phân bổ.

Tối ưu hóa này có thể được truy tìm trong macro

10000000000000000000000000000000000000000001

Bài tiểu luận này được truyền cảm hứng rất nhiều, và ở một mức độ nào đó được sao chép, từ bài viết của Artem Golubin - Python Internals: Triển khai số nguyên chính xác tùy ý. Trong trường hợp bạn muốn có một lần lặn sâu chi tiết về các số nguyên Cpython hoặc Cpython Internals nói chung, tôi khuyên bạn nên kiểm tra chuỗi nội bộ CPython của Artem Golubin.

Cảm ơn Artem Golubin cho tất cả các bài viết nội bộ Cpython tuyệt vời. Bài tiểu luận này được truyền cảm hứng rất nhiều, và ở một mức độ nào đó được sao chép, từ bài viết của Artem Golubin - Python Internals: Triển khai số nguyên chính xác tùy ý. Trong trường hợp bạn muốn có một lần lặn sâu chi tiết về các số nguyên Cpython hoặc Cpython Internals nói chung, tôi khuyên bạn nên xem loạt nội bộ CPython của Artem Golubin.

Cảm ơn Artem Golubin cho tất cả các bài viết nội bộ Cpython tuyệt vời.

Làm thế nào để bạn xử lý một số nguyên dài trong Python?

Làm thế nào để Python lưu trữ số nguyên dài?

Một số nguyên có thể lớn như thế nào trong Python 3?

Có tồn tại lâu trong Python 3?