Python đại diện nhị phân

Sử dụng numpy pack/unpackbits, chúng là những người bạn tốt nhất của bạn

Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
       [ 7],
       [23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)

Các số dấu phẩy động được biểu diễn trong phần cứng máy tính dưới dạng phân số cơ số 2 (nhị phân). Ví dụ: phân số thập phân

0.333

0.333

Thật không may, hầu hết các phân số thập phân không thể được biểu diễn chính xác dưới dạng phân số nhị phân. Hệ quả là, nói chung, các số dấu phẩy động thập phân bạn nhập chỉ gần đúng với các số dấu phẩy động nhị phân thực sự được lưu trữ trong máy

Vấn đề dễ hiểu hơn lúc đầu ở cơ sở 10. Xét phân số 1/3. Bạn có thể tính gần đúng dưới dạng phân số cơ số 10

0.3

hoặc tốt hơn,

0.33

hoặc tốt hơn,

0.333

và như thế. Cho dù bạn sẵn sàng viết ra bao nhiêu chữ số, kết quả sẽ không bao giờ chính xác là 1/3, mà sẽ là một xấp xỉ ngày càng tốt hơn của 1/3

Theo cách tương tự, cho dù bạn sẵn sàng sử dụng bao nhiêu chữ số cơ số 2, thì giá trị thập phân 0. 1 không thể biểu diễn chính xác dưới dạng phân số cơ số 2. Trong cơ số 2, 1/10 là phân số lặp lại vô hạn

0.0001100110011001100110011001100110011001100110011...

Dừng lại ở bất kỳ số bit hữu hạn nào và bạn nhận được xấp xỉ. Trên hầu hết các máy hiện nay, số float được xấp xỉ bằng cách sử dụng phân số nhị phân với tử số sử dụng 53 bit đầu tiên bắt đầu bằng bit quan trọng nhất và với mẫu số là lũy thừa của hai. Trong trường hợp 1/10, phân số nhị phân là

0.333

Nhiều người dùng không biết về giá trị gần đúng do cách hiển thị các giá trị. Python chỉ in một giá trị thập phân gần đúng với giá trị thập phân thực của xấp xỉ nhị phân được máy lưu trữ. Trên hầu hết các máy, nếu Python in giá trị thập phân thực của xấp xỉ nhị phân được lưu trữ cho 0. 1, nó sẽ phải hiển thị

________số 8

Đó là nhiều chữ số hơn hầu hết mọi người thấy hữu ích, vì vậy Python giữ cho số lượng chữ số có thể quản lý được bằng cách hiển thị một giá trị được làm tròn thay thế

>>> 1 / 10
0.1

Chỉ cần nhớ, mặc dù kết quả được in trông giống như giá trị chính xác là 1/10, nhưng giá trị được lưu trữ thực tế là phân số nhị phân có thể biểu thị gần nhất

Điều thú vị là có nhiều số thập phân khác nhau có cùng phân số nhị phân gần đúng nhất. Ví dụ: các số

0.333

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

0.333

0.0001100110011001100110011001100110011001100110011...

Trong lịch sử, dấu nhắc Python và hàm

0.0001100110011001100110011001100110011001100110011...

0.0001100110011001100110011001100110011001100110011...

0.333

Lưu ý rằng đây là bản chất của dấu phẩy động nhị phân. đây không phải là lỗi trong Python và nó cũng không phải là lỗi trong mã của bạn. Bạn sẽ thấy cùng một thứ trong tất cả các ngôn ngữ hỗ trợ số học dấu phẩy động của phần cứng của bạn (mặc dù một số ngôn ngữ có thể không hiển thị sự khác biệt theo mặc định hoặc trong tất cả các chế độ đầu ra)

Để có kết quả dễ chịu hơn, bạn có thể muốn sử dụng định dạng chuỗi để tạo ra một số lượng hạn chế các chữ số có nghĩa

0.333

Điều quan trọng là phải nhận ra rằng đây thực sự là một ảo ảnh. bạn chỉ đơn giản là làm tròn hiển thị giá trị thực của máy

Một ảo ảnh có thể sinh ra một ảo ảnh khác. Ví dụ, kể từ 0. 1 không chính xác là 1/10, tổng ba giá trị của 0. 1 có thể không mang lại chính xác 0. 3, một trong hai

0.333

Ngoài ra, kể từ 0. 1 không thể tiến gần hơn đến giá trị chính xác của 1/10 và 0. 3 không thể tiến gần hơn đến giá trị chính xác của 3/10, thì việc làm tròn trước bằng hàm

0.0001100110011001100110011001100110011001100110011...

0.333

Mặc dù các số không thể được thực hiện gần hơn với các giá trị chính xác dự định của chúng, nhưng hàm

0.0001100110011001100110011001100110011001100110011...

0.333

Số học dấu phẩy động nhị phân có nhiều bất ngờ như thế này. Vấn đề với “0. 1” được giải thích chi tiết chính xác bên dưới, trong phần “Lỗi trình bày”. Xem The Perils of Floating Point để có tài khoản đầy đủ hơn về những bất ngờ phổ biến khác

Như đã nói ở gần cuối, “không có câu trả lời dễ dàng. ” Tuy nhiên, đừng quá cảnh giác với dấu phẩy động. Các lỗi trong thao tác dấu phẩy động của Python được kế thừa từ phần cứng dấu phẩy động và trên hầu hết các máy theo thứ tự không quá 1 phần trong 2**53 cho mỗi thao tác. Điều đó là quá đủ cho hầu hết các nhiệm vụ, nhưng bạn cần lưu ý rằng đó không phải là số học thập phân và mọi thao tác float có thể gặp lỗi làm tròn mới

Mặc dù vẫn tồn tại các trường hợp bệnh lý, nhưng đối với hầu hết việc sử dụng thông thường số học dấu phẩy động, bạn sẽ thấy kết quả cuối cùng mà bạn mong đợi nếu bạn chỉ cần làm tròn phần hiển thị kết quả cuối cùng của mình thành số chữ số thập phân mà bạn mong đợi.

0.0001100110011001100110011001100110011001100110011...

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Đối với các trường hợp sử dụng yêu cầu biểu diễn số thập phân chính xác, hãy thử sử dụng mô-đun

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

Một dạng số học chính xác khác được hỗ trợ bởi mô-đun

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

If you are a heavy user of floating point operations you should take a look at the NumPy package and many other packages for mathematical and statistical operations supplied by the SciPy project. See .

Python cung cấp các công cụ có thể hữu ích trong những trường hợp hiếm hoi khi bạn thực sự muốn biết giá trị chính xác của số float. Phương thức

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

0.33

Vì tỷ lệ này là chính xác nên nó có thể được sử dụng để tạo lại giá trị ban đầu một cách dễ dàng

0.33

Phương thức

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

0.33

Biểu diễn thập lục phân chính xác này có thể được sử dụng để tái tạo lại chính xác giá trị float

0.33

Vì biểu diễn là chính xác nên rất hữu ích để chuyển các giá trị một cách đáng tin cậy qua các phiên bản khác nhau của Python (độc lập với nền tảng) và trao đổi dữ liệu với các ngôn ngữ khác hỗ trợ cùng định dạng (chẳng hạn như Java và C99)

Một công cụ hữu ích khác là hàm

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

0.33

0.33

0.33

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

0.33

0.33

0.33

0.333

0.333

0.333

0.333