Phân chia nhị phân Python

Tại sao sử dụng nhị phân?

Có vô số cách biểu diễn số. Từ thời cổ đại, con người đã phát triển các ký hiệu khác nhau, chẳng hạn như chữ số La Mã và chữ tượng hình Ai Cập. Most modern civilizations use positional notation, which is efficient, flexible, and well suited for doing arithmetic

Một tính năng đáng chú ý của bất kỳ hệ thống vị trí nào là cơ sở của nó, đại diện cho số chữ số có sẵn. Mọi người thường thích hệ đếm cơ số 10, còn được gọi là hệ thập phân, bởi vì nó hoạt động tốt với việc đếm trên đầu ngón tay

Mặt khác, máy tính coi dữ liệu là một loạt các số được biểu thị trong hệ thống cơ số hai chữ số, thường được gọi là hệ thống nhị phân. Such numbers are composed of only two digits, zero and one

Note. Trong sách toán, cơ sở của một chữ số thường được biểu thị bằng một chỉ số xuất hiện bên dưới đường cơ sở một chút, chẳng hạn như 4210

Ví dụ: số nhị phân 100111002 tương đương với 15610 trong hệ cơ số mười. Vì có mười chữ số trong hệ thập phân—từ 0 đến 9—nên thường cần ít chữ số hơn để viết cùng một số trong cơ số mười so với cơ số hai

Ghi chú. You can’t tell a numeral system just by looking at a given number’s digits

For example, the decimal number 10110 happens to use only binary digits. Nhưng nó đại diện cho một giá trị hoàn toàn khác so với đối tác nhị phân của nó, 1012, tương đương với 510

Hệ thống nhị phân yêu cầu nhiều không gian lưu trữ hơn hệ thống thập phân nhưng ít phức tạp hơn nhiều khi triển khai trong phần cứng. Mặc dù bạn cần nhiều khối xây dựng hơn nhưng chúng dễ tạo hơn và có ít loại hơn. Điều đó giống như chia mã của bạn thành nhiều phần mô-đun hơn và có thể tái sử dụng

Tuy nhiên, quan trọng hơn, hệ thống nhị phân hoàn hảo cho các thiết bị điện tử, giúp dịch các chữ số thành các mức điện áp khác nhau. Vì điện áp thích dao động lên xuống do nhiều loại nhiễu khác nhau, nên bạn muốn giữ khoảng cách vừa đủ giữa các điện áp liên tiếp. Nếu không, tín hiệu có thể bị méo

By employing only two states, you make the system more reliable and resistant to noise. Ngoài ra, bạn có thể tăng điện áp, nhưng điều đó cũng sẽ làm tăng mức tiêu thụ điện năng, điều mà bạn chắc chắn muốn tránh

Nhị phân hoạt động như thế nào?

Hãy tưởng tượng trong một khoảnh khắc rằng bạn chỉ có hai ngón tay để đếm. Bạn có thể đếm một số không, một và hai. Nhưng khi bạn hết ngón tay, bạn cần ghi lại số lần bạn đã đếm đến hai và sau đó bắt đầu lại cho đến khi bạn đếm lại hai

DecimalFingersEightsFoursTwosOnesBinary010✊000002110☝️000112210✌️0010102310✌️+☝️0011112410✌️✌️01001002510✌️✌️+☝️01011012610✌️✌️+✌️01101102710✌️✌️+✌️+☝️01111112810✌️✌️✌️✌️100010002910✌️✌️✌️✌️+☝️1001100121010✌️✌️✌️✌️+✌️1010101021110

Mỗi lần bạn viết ra một cặp ngón tay khác, bạn cũng cần nhóm chúng theo lũy thừa của hai, đây là cơ sở của hệ thống. Ví dụ: để đếm đến mười ba, bạn sẽ phải sử dụng cả hai ngón tay của mình sáu lần rồi sử dụng một ngón tay nữa. Các ngón tay của bạn có thể được sắp xếp thành một tám, một bốn và một một

Những lũy ​​thừa của hai tương ứng với các vị trí chữ số trong một số nhị phân và cho bạn biết chính xác bit nào sẽ bật. Chúng phát triển từ phải sang trái, bắt đầu từ bit ít quan trọng nhất, xác định xem số đó là chẵn hay lẻ

Ký hiệu vị trí giống như đồng hồ đo quãng đường trong ô tô của bạn. Khi một chữ số ở một vị trí cụ thể đạt đến giá trị tối đa của nó, là một trong hệ thống nhị phân, nó sẽ chuyển sang 0 và một chữ số sẽ chuyển sang bên trái. Điều này có thể có hiệu ứng xếp tầng nếu đã có một số chữ số ở bên trái của chữ số

Cách máy tính sử dụng nhị phân

Bây giờ bạn đã biết các nguyên tắc cơ bản của hệ thống nhị phân và tại sao máy tính sử dụng nó, bạn đã sẵn sàng tìm hiểu cách chúng biểu diễn dữ liệu với nó

Trước khi bất kỳ phần thông tin nào có thể được sao chép ở dạng kỹ thuật số, bạn phải chia nhỏ thông tin đó thành các số và sau đó chuyển đổi chúng sang hệ thống nhị phân. Ví dụ: văn bản thuần túy có thể được coi là một chuỗi ký tự. Bạn có thể gán một số tùy ý cho mỗi ký tự hoặc chọn mã hóa ký tự hiện có, chẳng hạn như ASCII, ISO-8859-1 hoặc UTF-8

Trong Python, các chuỗi được biểu diễn dưới dạng mảng các điểm mã Unicode. Để tiết lộ các giá trị thứ tự của chúng, hãy gọi

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Các số kết quả xác định duy nhất các ký tự văn bản trong không gian Unicode, nhưng chúng được hiển thị ở dạng thập phân. Bạn muốn viết lại chúng bằng các chữ số nhị phân

Ký tự Điểm mã thập phân Điểm mã nhị phân€836410100000101011002u1171011101012r1141011100102o1111011011112

Lưu ý rằng độ dài bit, là số chữ số nhị phân, thay đổi rất nhiều giữa các ký tự. Ký hiệu euro [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Ghi chú. Đây là cách bạn có thể kiểm tra độ dài bit của bất kỳ số nguyên nào trong Python

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nếu không có một cặp dấu ngoặc đơn xung quanh số, nó sẽ được coi là một chữ số dấu phẩy động với dấu thập phân

Độ dài bit thay đổi có vấn đề. Ví dụ: nếu bạn đặt các số nhị phân đó cạnh nhau trên một đĩa quang, thì bạn sẽ có một dòng dài các bit không có ranh giới rõ ràng giữa các ký tự

100000101011001110101111001011011112

Một cách để biết cách diễn giải thông tin này là chỉ định các mẫu bit có độ dài cố định cho tất cả các ký tự. Trong điện toán hiện đại, đơn vị thông tin nhỏ nhất, được gọi là octet hoặc byte, bao gồm 8 bit có thể lưu trữ 256 giá trị riêng biệt

Bạn có thể đệm các điểm mã nhị phân của mình bằng các số 0 đứng đầu để biểu thị chúng dưới dạng byte

Ký tự Điểm mã thập phân Điểm mã nhị phân€83641000100000 101011002u1171000000000 011101012r1141000000000 011100102o1111000000000 011011112

Bây giờ mỗi ký tự chiếm hai byte hoặc 16 bit. Tổng cộng, văn bản gốc của bạn có kích thước gần gấp đôi, nhưng ít nhất nó được mã hóa một cách đáng tin cậy

Bạn có thể sử dụng mã hóa Huffman để tìm các mẫu bit rõ ràng cho mọi ký tự trong một văn bản cụ thể hoặc sử dụng mã hóa ký tự phù hợp hơn. Ví dụ: để tiết kiệm dung lượng, UTF-8 cố ý ưu tiên các chữ cái Latinh hơn các ký hiệu mà bạn ít có khả năng tìm thấy trong văn bản tiếng Anh

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Được mã hóa theo tiêu chuẩn UTF-8, toàn bộ văn bản chiếm 6 byte. Vì UTF-8 là một siêu tập hợp của ASCII, nên các chữ cái

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Các loại thông tin khác có thể được số hóa tương tự như văn bản. Hình ảnh raster được tạo thành từ các pixel, với mỗi pixel có các kênh biểu thị cường độ màu dưới dạng số. Dạng sóng âm thanh chứa các số tương ứng với áp suất không khí tại một khoảng thời gian lấy mẫu nhất định. Các mô hình ba chiều được xây dựng từ các hình dạng hình học được xác định bởi các đỉnh của chúng, v.v.

Vào cuối ngày, mọi thứ đều là một con số

Bitwise AND

Toán tử AND theo bit [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Mẫu bit kết quả là giao điểm của các đối số của toán tử. Nó có hai bit được bật ở các vị trí mà cả hai toán hạng đều là một. Ở tất cả những nơi khác, ít nhất một trong các đầu vào có bit 0

Về mặt số học, điều này tương đương với tích của hai giá trị bit. Bạn có thể tính toán AND theo chiều bit của các số a và b bằng cách nhân các bit của chúng tại mọi chỉ số i

Đây là một ví dụ cụ thể

Biểu thức Giá trị nhị phân Giá trị thập phân ____113110011100215610

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Một nhân với một cho một, nhưng bất cứ điều gì nhân với 0 sẽ luôn dẫn đến kết quả bằng 0. Ngoài ra, bạn có thể lấy tối thiểu hai bit trong mỗi cặp. Lưu ý rằng khi các toán hạng có độ dài bit không bằng nhau, toán hạng ngắn hơn sẽ tự động được đệm bằng các số 0 ở bên trái

Bitwise HOẶC

Toán tử OR theo bit [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Mẫu bit kết quả là sự kết hợp của các đối số của toán tử. Nó có năm bit được bật khi một trong hai toán hạng có một. Chỉ có sự kết hợp của hai số 0 mới cho số 0 ở đầu ra cuối cùng

Số học đằng sau nó là sự kết hợp của tổng và tích của các giá trị bit. Để tính toán OR theo bit của các số a và b, bạn cần áp dụng công thức sau cho các bit của chúng tại mọi chỉ số i

Đây là một ví dụ hữu hình

Biểu thức Giá trị nhị phân Giá trị thập phân ____113110011100215610

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nó gần giống như tổng của hai bit nhưng được kẹp ở đầu cao hơn để nó không bao giờ vượt quá giá trị của một. Bạn cũng có thể lấy tối đa hai bit trong mỗi cặp để có kết quả tương tự

Bitwise XOR

Không giống như bitwise AND, OR và NOT, toán tử XOR bitwise [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nó đánh giá hai điều kiện loại trừ lẫn nhau và cho bạn biết liệu một trong số chúng có được đáp ứng hay không. Ví dụ: một người có thể là trẻ vị thành niên hoặc người lớn nhưng không thể đồng thời là cả hai. Ngược lại, một người không phải là trẻ vị thành niên cũng không phải là người lớn thì không thể. Sự lựa chọn là bắt buộc

Tên XOR là viết tắt của từ “độc quyền hoặc” vì nó thực hiện phân tách độc quyền trên các cặp bit. Nói cách khác, mỗi cặp bit phải chứa các giá trị bit đối lập để tạo ra một

Trực quan, đó là sự khác biệt đối xứng của các đối số của toán tử. Có ba bit được bật trong kết quả mà cả hai số có giá trị bit khác nhau. Các bit ở các vị trí còn lại bị triệt tiêu vì chúng giống nhau

Tương tự như toán tử OR theo bit, phép tính số học của XOR liên quan đến tổng. Tuy nhiên, trong khi bit OR kẹp các giá trị tại một, thì toán tử XOR bao quanh chúng bằng một tổng modulo hai

Modulo là hàm của hai số—số bị chia và số chia—thực hiện phép chia và trả về phần dư của nó. Trong Python, có một toán tử modulo tích hợp được biểu thị bằng dấu phần trăm [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Một lần nữa, bạn có thể xác nhận công thức bằng cách xem ví dụ

Biểu thức Giá trị nhị phân Giá trị thập phân ____113110011100215610

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Tổng của hai số 0 hoặc hai số một chia cho hai sẽ được một số nguyên, vì vậy kết quả có số dư bằng 0. Tuy nhiên, khi bạn chia tổng của hai giá trị bit khác nhau cho hai, bạn sẽ nhận được một phân số có phần còn lại là một. Một công thức đơn giản hơn cho toán tử XOR là hiệu giữa giá trị lớn nhất và giá trị nhỏ nhất của cả hai bit trong mỗi cặp

Bitwise KHÔNG

Toán tử logic bitwise cuối cùng là toán tử NOT bitwise [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Các bit đảo ngược là phần bù của một, biến số 0 thành số 1 và số 1 thành số 0. Nó có thể được biểu diễn bằng số học dưới dạng phép trừ các giá trị bit riêng lẻ từ một

Đây là một ví dụ hiển thị một trong những số được sử dụng trước đây

Biểu thức Giá trị nhị phân Giá trị thập phân ____113110011100215610

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Mặc dù toán tử NOT bitwise dường như là đơn giản nhất trong số chúng, nhưng bạn cần hết sức thận trọng khi sử dụng nó trong Python. Mọi thứ bạn đã đọc cho đến nay đều dựa trên giả định rằng các số được biểu diễn bằng số nguyên không dấu

Ghi chú. Các kiểu dữ liệu không dấu không cho phép bạn lưu trữ các số âm như -273 vì không có khoảng trống cho dấu trong mẫu bit thông thường. Cố gắng làm như vậy sẽ dẫn đến lỗi biên dịch, ngoại lệ thời gian chạy hoặc tràn số nguyên tùy thuộc vào ngôn ngữ được sử dụng

Mặc dù có nhiều cách để mô phỏng số nguyên không dấu, nhưng Python không hỗ trợ chúng nguyên bản. Điều đó có nghĩa là tất cả các số đều có một dấu hiệu ngầm gắn liền với chúng cho dù bạn có chỉ định hay không. Điều này cho thấy khi bạn thực hiện KHÔNG theo chiều bit của bất kỳ số nào

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Thay vì 9910 như mong đợi, bạn nhận được giá trị âm. Lý do cho điều này sẽ trở nên rõ ràng khi bạn tìm hiểu về các biểu diễn số nhị phân khác nhau. Hiện tại, giải pháp khắc phục nhanh là tận dụng toán tử AND theo bit

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Đó là một ví dụ hoàn hảo về bitmask mà bạn sẽ khám phá trong một trong các phần sắp tới

Dịch trái

Toán tử dịch trái theo chiều bit [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Dịch chuyển một bit sang trái một vị trí sẽ nhân đôi giá trị của nó. Ví dụ: thay vì số hai, bit sẽ chỉ số bốn sau khi dịch chuyển. Di chuyển nó sang bên trái hai vị trí sẽ tăng gấp bốn lần giá trị kết quả. Khi bạn cộng tất cả các bit thành một số nhất định, bạn sẽ nhận thấy rằng nó cũng được nhân đôi với mỗi vị trí được thay đổi

Biểu thức Giá trị nhị phân Giá trị thập phân ____113110011123910

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nói chung, dịch chuyển các bit sang trái tương ứng với việc nhân một số với lũy thừa hai, với số mũ bằng với số vị trí được dịch chuyển

Dịch trái từng là một kỹ thuật tối ưu hóa phổ biến vì dịch chuyển bit là một lệnh đơn lẻ và tính toán rẻ hơn so với số mũ hoặc tích. Tuy nhiên, ngày nay, các trình biên dịch và trình thông dịch, bao gồm cả Python, hoàn toàn có khả năng tối ưu hóa mã của bạn đằng sau hậu trường

Ghi chú. Không sử dụng toán tử dịch chuyển bit làm phương tiện tối ưu hóa sớm trong Python. Bạn sẽ không thấy sự khác biệt về tốc độ thực thi, nhưng chắc chắn bạn sẽ làm cho mã của mình khó đọc hơn

Trên giấy, mẫu bit do dịch chuyển trái sẽ dài hơn ở nhiều vị trí khi bạn dịch chuyển nó. Điều đó cũng đúng với Python nói chung vì cách nó xử lý các số nguyên. Tuy nhiên, trong hầu hết các trường hợp thực tế, bạn sẽ muốn giới hạn độ dài của mẫu bit là bội số của tám, là độ dài byte tiêu chuẩn

Ví dụ: nếu bạn đang làm việc với một byte đơn, thì việc dịch chuyển nó sang bên trái sẽ loại bỏ tất cả các bit vượt ra ngoài ranh giới bên trái của nó

Nó giống như nhìn vào một luồng bit không giới hạn thông qua một cửa sổ có độ dài cố định. Có một vài thủ thuật cho phép bạn làm điều này trong Python. Ví dụ: bạn có thể áp dụng mặt nạ bit với toán tử AND theo chiều bit

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Dịch chuyển 3910 ba vị trí sang trái sẽ trả về một số cao hơn giá trị tối đa mà bạn có thể lưu trữ trên một byte đơn. Phải mất chín bit, trong khi một byte chỉ có tám. Để cắt bớt một bit thừa ở bên trái, bạn có thể áp dụng một bitmask với giá trị phù hợp. Nếu bạn muốn giữ nhiều hoặc ít bit hơn, thì bạn sẽ cần sửa đổi giá trị mặt nạ cho phù hợp

Ca phải

Toán tử dịch phải theo chiều bit [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Mỗi khi bạn dịch chuyển một chút sang phải một vị trí, bạn sẽ giảm một nửa giá trị cơ bản của nó. Di chuyển cùng một bit sang bên phải hai vị trí sẽ tạo ra một phần tư giá trị ban đầu, v.v. Khi bạn cộng tất cả các bit riêng lẻ, bạn sẽ thấy quy tắc tương tự áp dụng cho số mà chúng đại diện

Biểu thức Giá trị nhị phân Giá trị thập phân ____113110011101215710

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Giảm một nửa số lẻ chẳng hạn như 15710 sẽ tạo ra một phân số. Để thoát khỏi nó, toán tử shift phải sẽ tự động kết quả. Nó hầu như giống như phép chia tầng bằng lũy ​​thừa hai

Một lần nữa, số mũ tương ứng với số lượng vị trí dịch chuyển sang phải. Trong Python, bạn có thể tận dụng một toán tử chuyên dụng để thực hiện phân chia tầng

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Cả toán tử dịch chuyển phải theo chiều bit và toán tử chia tầng đều hoạt động theo cùng một cách, ngay cả đối với các số âm. Tuy nhiên, phép chia sàn cho phép bạn chọn bất kỳ ước số nào và không chỉ là lũy thừa của hai. Sử dụng dịch chuyển phải theo chiều bit là một cách phổ biến để cải thiện hiệu suất của một số phép chia số học

Ghi chú. Bạn có thể tự hỏi điều gì sẽ xảy ra khi bạn hết bit để chuyển. Ví dụ: khi bạn thử đẩy nhiều vị trí hơn số bit trong một số

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Khi không còn bit nào được bật, bạn sẽ bị mắc kẹt với giá trị bằng 0. Số không chia cho bất cứ thứ gì sẽ luôn trả về số không. Tuy nhiên, mọi thứ trở nên phức tạp hơn khi bạn chuyển sang phải một số âm vì bit dấu ẩn cản trở

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Quy tắc ngón tay cái là, bất kể dấu hiệu là gì, kết quả sẽ giống như phép chia sàn cho một số lũy thừa của hai. Sàn của một phân số âm nhỏ luôn là trừ một, và đó là những gì bạn sẽ nhận được. Đọc tiếp để được giải thích chi tiết hơn

Cũng giống như toán tử dịch trái, mẫu bit thay đổi kích thước của nó sau khi dịch phải. Mặc dù di chuyển các bit sang phải làm cho chuỗi nhị phân ngắn hơn, nhưng điều đó thường không thành vấn đề vì bạn có thể đặt bao nhiêu số 0 trước chuỗi bit tùy thích mà không thay đổi giá trị. Ví dụ: 1012 giống như 01012 và 000001012 cũng vậy, miễn là bạn đang xử lý các số không âm

Đôi khi, bạn sẽ muốn giữ một độ dài bit nhất định sau khi thực hiện dịch chuyển sang phải để căn chỉnh nó với một giá trị khác hoặc để khớp với một nơi nào đó. Bạn có thể làm điều đó bằng cách áp dụng một bitmask

Nó chỉ cắt ra những bit mà bạn quan tâm và điền vào mẫu bit với các số 0 đứng đầu nếu cần

Việc xử lý các số âm trong Python hơi khác so với cách tiếp cận truyền thống để dịch chuyển bit. Trong phần tiếp theo, bạn sẽ kiểm tra điều này chi tiết hơn

Số học vs Dịch chuyển logic

Bạn có thể phân loại thêm các toán tử dịch chuyển bit thành toán tử dịch chuyển số học và logic. Mặc dù Python chỉ cho phép bạn thực hiện phép dịch chuyển số học, nhưng bạn nên biết cách các ngôn ngữ lập trình khác triển khai các toán tử dịch chuyển bit để tránh nhầm lẫn và bất ngờ

Sự khác biệt này xuất phát từ cách chúng xử lý bit dấu, thường nằm ở cạnh ngoài cùng bên trái của chuỗi nhị phân có dấu. Trong thực tế, nó chỉ liên quan đến toán tử dịch chuyển phải, điều này có thể khiến một số bị đảo dấu, dẫn đến tràn số nguyên

Ghi chú. Ví dụ, Java và JavaScript phân biệt toán tử dịch phải logic bằng một dấu lớn hơn bổ sung [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Thông thường, một bit dấu bật cho biết các số âm, giúp giữ các thuộc tính số học của một chuỗi nhị phân

Giá trị thập phân Giá trị nhị phân đã kýSign BitSignMeaning-100101001110021-Số âm28100001110020+Số dương hoặc số không

Nhìn từ bên trái vào hai dãy nhị phân này, bạn có thể thấy rằng bit đầu tiên của chúng mang thông tin về dấu hiệu, trong khi phần còn lại bao gồm các bit độ lớn, giống nhau cho cả hai số

Ghi chú. Các giá trị thập phân cụ thể sẽ phụ thuộc vào cách bạn quyết định biểu thị các số có dấu ở dạng nhị phân. Nó khác nhau giữa các ngôn ngữ và thậm chí còn phức tạp hơn trong Python, vì vậy bạn có thể tạm thời bỏ qua nó. Bạn sẽ có hình dung rõ hơn khi đến phần biểu diễn số nhị phân bên dưới

Dịch chuyển phải hợp lý, còn được gọi là dịch chuyển phải không dấu hoặc dịch chuyển phải không điền, di chuyển toàn bộ chuỗi nhị phân, bao gồm cả bit dấu và lấp đầy khoảng trống kết quả ở bên trái bằng số 0

Chú ý thông tin về dấu của số bị mất. Bất kể dấu ban đầu là gì, nó sẽ luôn tạo ra một số nguyên không âm vì bit dấu được thay thế bằng 0. Miễn là bạn không quan tâm đến các giá trị số, thì một phép dịch phải hợp lý có thể hữu ích trong việc xử lý dữ liệu nhị phân cấp thấp

Tuy nhiên, vì các số nhị phân có dấu thường được lưu trữ trên một chuỗi bit có độ dài cố định trong hầu hết các ngôn ngữ nên nó có thể làm cho kết quả bao quanh các giá trị cực đoan. Bạn có thể thấy điều này trong công cụ Java Shell tương tác

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Số kết quả thay đổi dấu của nó từ âm sang dương, nhưng nó cũng bị tràn, kết thúc rất gần với số nguyên tối đa của Java

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Con số này thoạt nhìn có vẻ tùy ý, nhưng nó liên quan trực tiếp đến số lượng bit mà Java phân bổ cho kiểu dữ liệu

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nó sử dụng 32 bit để lưu trữ các số nguyên có dấu trong biểu diễn bù hai. Khi bạn lấy bit dấu ra, bạn còn lại 31 bit, có giá trị thập phân tối đa bằng 231 - 1 hoặc 214748364710

Mặt khác, Python lưu trữ các số nguyên như thể có vô số bit theo ý của bạn. Do đó, một toán tử dịch phải hợp lý sẽ không được xác định rõ trong Python thuần túy, do đó, nó bị thiếu trong ngôn ngữ. Tuy nhiên, bạn vẫn có thể mô phỏng nó

Một cách để làm như vậy là tận dụng các kiểu dữ liệu không dấu có sẵn trong C được hiển thị thông qua mô-đun

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Họ cho phép bạn nhập một số âm nhưng không gắn bất kỳ ý nghĩa đặc biệt nào với bit dấu. Nó được xử lý giống như phần còn lại của các bit cường độ

Mặc dù chỉ có một số loại số nguyên không dấu được xác định trước trong C, khác nhau về độ dài bit, nhưng bạn có thể tạo một hàm tùy chỉnh trong Python để xử lý các độ dài bit tùy ý

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Thao tác này chuyển đổi chuỗi bit có dấu thành chuỗi không dấu và sau đó thực hiện phép dịch phải số học thông thường

Tuy nhiên, vì các chuỗi bit trong Python không cố định về độ dài nên chúng không thực sự có bit dấu. Hơn nữa, chúng không sử dụng biểu diễn bù hai truyền thống như trong C hoặc Java. Để giảm thiểu điều đó, bạn có thể tận dụng thao tác modulo, thao tác này sẽ giữ nguyên các mẫu bit ban đầu cho các số nguyên dương trong khi bao quanh các số nguyên âm một cách thích hợp

Phép dịch phải số học [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nói cách khác, nó lấp đầy khoảng trống ở bên trái bằng bất kỳ bit dấu nào. Kết hợp với biểu diễn bổ sung của hai nhị phân đã ký, điều này dẫn đến một giá trị chính xác về mặt số học. Bất kể số đó là dương hay âm, một phép dịch phải số học tương đương với phép chia sàn

Như bạn sắp tìm hiểu, Python không phải lúc nào cũng lưu trữ các số nguyên ở dạng nhị phân bù hai đơn giản. Thay vào đó, nó tuân theo một chiến lược thích ứng tùy chỉnh hoạt động giống như cường độ ký hiệu với số lượng bit không giới hạn. It converts numbers back and forth between their internal representation and two’s complement to mimic the standard behavior of the arithmetic shift

Unsigned Integers

In programming languages like C, you choose whether to use the signed or unsigned flavor of a given numeric type. Unsigned data types are more suitable when you know for sure that you’ll never need to deal with negative numbers. By allocating that one extra bit, which would otherwise serve as a sign bit, you practically double the range of available values

It also makes things a little safer by increasing the maximum limit before an overflow happens. However, overflows happen only with fixed bit-lengths, so they’re irrelevant to Python, which doesn’t have such constraints

The quickest way to get a taste of the unsigned numeric types in Python is to use the previously mentioned

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Since there’s no sign bit in such integers, all their bits represent the magnitude of a number. Passing a negative number forces Python to reinterpret the bit pattern as if it had only the magnitude bits

Signed Integers

The sign of a number has only two states. If you ignore zero for a moment, then it can be either positive or negative, which translates nicely to the binary system. Yet there are a few alternative ways to represent signed integers in binary, each with its own pros and cons

Probably the most straightforward one is the sign-magnitude, which builds naturally on top of unsigned integers. When a binary sequence is interpreted as sign-magnitude, the most significant bit plays the role of a sign bit, while the rest of the bits work the same as usual

Binary SequenceSign-Magnitude ValueUnsigned Value00101010242104210101010102-421017010

A zero on the leftmost bit indicates a positive [

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Tại sao bit ngoài cùng bên trái?

Nó giữ nguyên chỉ mục bit, do đó, giúp duy trì khả năng tương thích ngược của trọng số bit được sử dụng để tính giá trị thập phân của chuỗi nhị phân. Tuy nhiên, không phải mọi thứ về độ lớn của dấu hiệu đều tuyệt vời như vậy

Ghi chú. Các biểu diễn nhị phân của các số nguyên đã ký chỉ có ý nghĩa đối với các chuỗi bit có độ dài cố định. Mặt khác, bạn không thể biết vị trí của bit dấu. Tuy nhiên, trong Python, bạn có thể biểu diễn số nguyên bằng bao nhiêu bit tùy thích

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Cho dù đó là bốn bit hay tám bit, bit dấu sẽ luôn được tìm thấy ở vị trí ngoài cùng bên trái

Phạm vi giá trị mà bạn có thể lưu trữ trong mẫu bit biên độ ký hiệu là đối xứng. Nhưng điều đó cũng có nghĩa là bạn sẽ có hai cách để truyền đạt số không

Chuỗi nhị phân Giá trị độ lớn ký Giá trị không dấu000000002+010010100000002-01012810

Về mặt kỹ thuật, số 0 không có ký hiệu, nhưng không có cách nào để không bao gồm một ký hiệu trong cường độ ký hiệu. Mặc dù có một số 0 mơ hồ không phải là lý tưởng trong hầu hết các trường hợp, nhưng đó không phải là phần tồi tệ nhất của câu chuyện. Nhược điểm lớn nhất của phương pháp này là số học nhị phân cồng kềnh

Khi bạn áp dụng số học nhị phân tiêu chuẩn cho các số được lưu trữ ở ký hiệu, nó có thể không mang lại cho bạn kết quả như mong đợi. Ví dụ: cộng hai số có cùng độ lớn nhưng ngược dấu sẽ không làm cho chúng bị triệt tiêu

Biểu thức Chuỗi nhị phân Giá trị ký-độ lớn

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Tổng của 42 và -42 không tạo ra số 0. Ngoài ra, bit chuyển đổi đôi khi có thể truyền từ độ lớn sang bit dấu, đảo ngược dấu hiệu và mang lại kết quả không mong muốn

Để giải quyết những vấn đề này, một số máy tính đời đầu đã sử dụng biểu diễn bổ sung của một người. Ý tưởng là thay đổi cách các số thập phân được ánh xạ tới các chuỗi nhị phân cụ thể để chúng có thể được cộng lại một cách chính xác. Để tìm hiểu sâu hơn về phần bổ sung của một người, bạn có thể mở rộng phần bên dưới

Phần bù của một ngườiHiển thị/Ẩn

Trong phần bù của một số, các số dương giống như trong độ lớn của dấu hiệu, nhưng các số âm có được bằng cách lật các bit của số dương bằng cách sử dụng một bit NOT

Dãy dương Dãy âm Giá trị độ lớn000000002111111112±010000000012111111102±110000000102111111012±210⋮⋮⋮011111112100000002±12710

Điều này giữ nguyên ý nghĩa ban đầu của bit dấu, vì vậy các số dương vẫn bắt đầu bằng số 0 nhị phân, trong khi số âm bắt đầu bằng số nhị phân. Tương tự như vậy, phạm vi của các giá trị vẫn đối xứng và tiếp tục có hai cách biểu thị số không. Tuy nhiên, chuỗi nhị phân của các số âm trong phần bù của một người được sắp xếp theo thứ tự ngược lại so với độ lớn của dấu

Một số bổ sung-magnitudedecimal value111111112100000002-010111111102100000012-110111111012100000102-210

Nhờ đó, giờ đây bạn có thể cộng hai số một cách đáng tin cậy hơn vì bit dấu không cần xử lý đặc biệt. Nếu một chuyển đổi bắt nguồn từ bit dấu, nó sẽ được đưa trở lại ở cạnh phải của chuỗi nhị phân thay vì chỉ bị loại bỏ. Điều này đảm bảo kết quả chính xác

Tuy nhiên, các máy tính hiện đại không sử dụng phần bù một để biểu diễn các số nguyên vì có một cách thậm chí còn tốt hơn được gọi là phần bù hai. Bằng cách áp dụng một sửa đổi nhỏ, bạn có thể loại bỏ hai số 0 và đơn giản hóa số học nhị phân trong một lần. Để khám phá phần bù của hai chi tiết hơn, bạn có thể mở rộng phần bên dưới

Phần bù của haiHiển thị/Ẩn

Khi tìm các chuỗi bit có giá trị âm trong phần bù hai, mẹo là thêm một vào kết quả sau khi phủ định các bit

Dãy dươngSố bù một [NOT]Số bù hai [NOT+1]000000002111111112000000002000000012111111102111111112000000102111110121111111102⋮⋮⋮0111110001000

Điều này đẩy chuỗi bit của các số âm xuống một vị trí, loại bỏ dấu trừ 0 khét tiếng. Thay vào đó, một dấu trừ hữu ích hơn sẽ chiếm lấy mẫu bit của nó

Là một tác dụng phụ, phạm vi các giá trị có sẵn trong phần bù của hai trở nên không đối xứng, với giới hạn dưới là lũy thừa của hai và giới hạn trên là số lẻ. Ví dụ: số nguyên có dấu 8 bit sẽ cho phép bạn lưu trữ các số từ -12810 đến 12710 trong phần bù hai

Hai bổ sung bổ sung Giá trị bổ sung100000002N/A-12810100000012100000002-12710100000102100000012-12610

Một cách khác để nói rằng bit quan trọng nhất mang cả dấu và một phần của độ lớn số

Bit 7 Bit 6 Bit 5 Bit 4 Bit 3Bit 2Bit 1Bit 0-2726252423222120-1286432168421

Lưu ý dấu trừ bên cạnh trọng lượng bit ngoài cùng bên trái. Lấy một giá trị thập phân từ một chuỗi nhị phân như thế chỉ là vấn đề thêm các cột thích hợp. Ví dụ: giá trị của 110101102 trong biểu diễn bù hai 8 bit giống với tổng. -12810 + 6410 + 1610 + 410 + 210 = -4210

Với biểu diễn bổ sung của cả hai, bạn không còn phải lo lắng về bit chuyển tiếp trừ khi bạn muốn sử dụng nó như một cơ chế phát hiện tràn, điều này khá gọn gàng.

Có một số biến thể khác của biểu diễn số có dấu, nhưng chúng không phổ biến bằng

Số dấu phẩy động

Tiêu chuẩn IEEE 754 xác định biểu diễn nhị phân cho các số thực bao gồm các bit dấu, số mũ và phần định trị. Không đi sâu vào quá nhiều chi tiết kỹ thuật, bạn có thể coi nó như một ký hiệu khoa học cho các số nhị phân. The decimal point “floats” around to accommodate a varying number of significant figures, except it’s a binary point

Hai loại dữ liệu phù hợp với tiêu chuẩn đó được hỗ trợ rộng rãi

1. Độ chính xác đơn. 1 bit dấu, 8 bit số mũ, 23 bit định trị
2. Độ chính xác gấp đôi. 1 sign bit, 11 exponent bits, 52 mantissa bits

Python’s

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

The number Pi [π] has the following binary representation in single precision when rounded to five decimal places

SignExponentMantissa02100000002. 100100100001111110100002

The sign bit works just like with integers, so zero denotes a positive number. For the exponent and mantissa, however, different rules can apply depending on a few edge cases

First, you need to convert them from binary to the decimal form

• Exponent. 12810
• Mantissa. 2-1 + 2-4 + … + 2-19 = 29926110/52428810 ≈ 0. 57079510

The exponent is stored as an unsigned integer, but to account for negative values, it usually has a bias equal to 12710 in single precision. You need to subtract it to recover the actual exponent

Mantissa bits represent a fraction, so they correspond to negative powers of two. Additionally, you need to add one to the mantissa because it assumes an implicit leading bit before the radix point in this particular case

Putting it all together, you arrive at the following formula to convert a floating-point binary number into a decimal one

When you substitute the variables for the actual values in the example above, you’ll be able to decipher the bit pattern of a floating-point number stored in single precision

Đây rồi, miễn là Pi đã được làm tròn đến năm chữ số thập phân. You’ll learn how to display such numbers in binary later on

Fixed-Point Numbers

While floating-point numbers are a good fit for engineering purposes, they fail in monetary calculations due to their limited precision. For example, some numbers with a finite representation in decimal notation have only an infinite representation in binary. That often results in a rounding error, which can accumulate over time

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

In such cases, you’re better off using Python’s

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

However, it includes all digits, not just the fractional ones

Note. If you’re working with rational numbers, then you might be interested in checking out the

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

If you can’t or don’t want to use a fixed-point data type, a straightforward way to reliably store currency values is to scale the amounts to the smallest unit, such as cents, and represent them with integers

Interned Integers

In CPython, very small integers between -510 and 25610 are interned in a global cache to gain some performance because numbers in that range are commonly used. In practice, whenever you refer to one of those values, which are singletons created at the interpreter startup, Python will always provide the same instance

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Both variables have the same identity because they refer to the exact same object in memory. That’s typical of reference types but not immutable values such as integers. However, when you go beyond that range of cached values, Python will start creating distinct copies during variable assignment

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Despite having equal values, these variables point to separate objects now. But don’t let that fool you. Python will occasionally jump in and optimize your code behind the scenes. Ví dụ: nó sẽ lưu vào bộ đệm một số xuất hiện trên cùng một dòng nhiều lần bất kể giá trị của nó là gì

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Variables

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Note. Thực tập là một chi tiết triển khai của trình thông dịch CPython, có thể thay đổi trong các phiên bản sau, vì vậy đừng dựa vào nó trong các chương trình của bạn

Thật thú vị, có một cơ chế thực tập chuỗi tương tự trong Python, khởi động cho các văn bản ngắn chỉ bao gồm các chữ cái ASCII. Nó giúp tăng tốc độ tra cứu từ điển bằng cách cho phép so sánh các khóa của chúng theo địa chỉ bộ nhớ hoặc con trỏ C, thay vì theo từng ký tự chuỗi riêng lẻ

Số nguyên có độ chính xác cố định

Integers that you’re most likely to find in Python will leverage the C

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Các máy tính hiện đại thường sử dụng kiến ​​trúc 64-bit, vì vậy điều này sẽ chuyển thành số thập phân giữa -263 và 263 - 1. Bạn có thể kiểm tra giá trị lớn nhất của số nguyên có độ chính xác cố định trong Python theo cách sau

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Nó rất lớn. Khoảng 9 triệu lần số lượng các ngôi sao trong thiên hà của chúng ta, vì vậy nó đủ để sử dụng hàng ngày. Mặc dù giá trị tối đa mà bạn có thể vắt ra từ loại

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Arbitrary-Precision Integers

Bạn có nhớ bài hát K-pop nổi tiếng “Gangnam Style” đã trở thành hit trên toàn thế giới vào năm 2012 không? . Ngay sau đó, rất nhiều người đã xem video khiến bộ đếm lượt xem tràn ngập. YouTube không có lựa chọn nào khác ngoài việc nâng cấp bộ đếm của họ từ số nguyên có chữ ký 32 bit lên số nguyên 64 bit

Điều đó có thể mang lại nhiều khoảng trống cho quầy xem, nhưng thậm chí còn có những con số lớn hơn không phải là hiếm trong cuộc sống thực, đặc biệt là trong thế giới khoa học. Tuy nhiên, Python có thể xử lý chúng một cách dễ dàng

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Số này có năm mươi hai chữ số thập phân. Sẽ mất ít nhất 170 bit để biểu diễn nó ở dạng nhị phân với cách tiếp cận truyền thống

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Vì chúng vượt quá giới hạn mà bất kỳ loại C nào cũng phải cung cấp, nên các số thiên văn như vậy được chuyển đổi thành một hệ thống vị trí có độ lớn ký hiệu, có cơ sở là 230. Vâng, bạn đã đọc dúng điều đó. Trong khi bạn có mười ngón tay, Python có hơn một tỷ

Một lần nữa, điều này có thể khác nhau tùy thuộc vào nền tảng bạn hiện đang sử dụng. When in doubt, you can double-check

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Điều này sẽ cho bạn biết có bao nhiêu bit được sử dụng trên mỗi chữ số và kích thước tính bằng byte của cấu trúc C bên dưới. Để có được cùng têntuple trong Python 2, thay vào đó, bạn nên tham khảo thuộc tính

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Mặc dù việc chuyển đổi này giữa các số nguyên có độ chính xác cố định và độ chính xác tùy ý được thực hiện liền mạch trong Python 3, nhưng đã có lúc mọi thứ trở nên rõ ràng hơn. Để biết thêm thông tin, bạn có thể mở rộng hộp bên dưới

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Trước đây, Python đã định nghĩa rõ ràng hai loại số nguyên riêng biệt

1. số nguyên đơn giản
2. Số nguyên dài

Loại đầu tiên được mô phỏng theo loại C

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Đối với số lượng lớn hơn, bạn phải sử dụng loại thứ hai không có giới hạn. Python sẽ tự động thăng cấp số nguyên đơn giản thành số nguyên dài nếu cần

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Tính năng này đã ngăn chặn lỗi tràn số nguyên. Lưu ý chữ cái

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Cuối cùng, cả hai loại đã được thống nhất để bạn không phải suy nghĩ về nó nữa

Cách biểu diễn như vậy giúp loại bỏ các lỗi tràn số nguyên và tạo ảo giác về độ dài bit vô hạn, nhưng nó đòi hỏi nhiều bộ nhớ hơn. Ngoài ra, việc thực hiện số học bignum chậm hơn so với với độ chính xác cố định vì nó không thể chạy trực tiếp trong phần cứng mà không có lớp mô phỏng trung gian

Một thách thức khác là giữ hành vi nhất quán của các toán tử bit trên các loại số nguyên thay thế, điều này rất quan trọng trong việc xử lý bit dấu. Nhớ lại rằng các số nguyên có độ chính xác cố định trong Python sử dụng biểu diễn phần bù của hai tiêu chuẩn từ C, trong khi các số nguyên lớn sử dụng độ lớn của dấu hiệu

Để giảm thiểu sự khác biệt đó, Python sẽ thực hiện chuyển đổi nhị phân cần thiết cho bạn. Nó có thể thay đổi cách biểu diễn một số trước và sau khi áp dụng toán tử bitwise. Đây là một nhận xét có liên quan từ mã nguồn CPython, giải thích điều này chi tiết hơn

Bitwise operations for negative numbers operate as though on a two’s complement representation. Vì vậy, hãy chuyển đổi các đối số từ độ lớn của dấu hiệu thành phần bù của hai và chuyển đổi kết quả trở lại độ lớn của dấu hiệu ở cuối. [Nguồn]

Nói cách khác, các số âm được coi là chuỗi bit bổ sung của hai khi bạn áp dụng toán tử bitwise trên chúng, mặc dù kết quả sẽ được hiển thị cho bạn ở dạng ký hiệu. Tuy nhiên, có nhiều cách để mô phỏng bit dấu và một số loại không dấu trong Python

Converting

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

173 to Binary

To reveal the bits making up an integer number in Python, you can print a formatted string literal, which optionally lets you specify the number of leading zeros to display

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Alternatively, you can call

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

This global built-in function returns a string consisting of a binary literal, which starts with the prefix

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

You can use such literals verbatim in your code, too

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Các ký tự số nguyên khác có sẵn trong Python là các ký tự thập lục phân và bát phân, mà bạn có thể nhận được bằng các hàm

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Notice how the hexadecimal system, which is base sixteen, takes advantage of letters

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

You can express the same value in different ways using any of the mentioned integer literals

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Choose the one that makes the most sense in context. For example, it’s customary to express bitmasks with hexadecimal notation. On the other hand, the octal literal is rarely seen these days

All numeric literals in Python are case insensitive, so you can prefix them with either lowercase or uppercase letters

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

This also applies to floating-point number literals that use scientific notation as well as complex number literals

Converting Binary to

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

173

Once you have your bit string ready, you can get its decimal representation by taking advantage of a binary literal

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

This is a quick way to do the conversion while working inside the interactive Python interpreter. Unfortunately, it won’t let you convert bit sequences synthesized at runtime because all literals need to be hard-coded in the source code

Note. You might be tempted to evaluate Python code with

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Calling

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

The first argument is a string of digits, while the second one determines the base of the numeral system. Unlike a binary literal, a string can come from anywhere, even a user typing on the keyboard. For a deeper look at

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Các mục đích sử dụng khác của

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

There are other ways to call

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

Tính năng này làm cho nó trở thành một mẫu phổ biến trong bộ sưu tập

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True

>>>

>>> def call[x]:
..     print[f"call[{x=}]"]
..     return x
...
>>> call[False] or call[True]  # Both operands evaluated
call[x=False]
call[x=True]
True
>>> call[True] or call[False]  # Only the left operand evaluated
call[x=True]
True