programming python

Hướng dẫn charset python - bộ ký tự trăn

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để làm sâu sắc thêm sự hiểu biết của bạn: Unicode in Python: Làm việc với mã hóa ký tự This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Unicode in Python: Working With Character Encodings This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Unicode in Python: Working With Character Encodings

Nội dung chính ShowShow

  • Những gì một nhân vật mã hóa?
  • Mô -đun >>> import string >>> s = "What's wrong with ASCII?!?!?" >>> s.rstrip[string.punctuation] 'What's wrong with ASCII' 43
  • Một chút bồi dưỡng
  • "có hay không"
  • Bao gồm tất cả các cơ sở: các hệ thống số khác
  • Nhập Unicode
  • Unicode vs UTF-8
  • Mã hóa và giải mã trong Python 3
  • Đây là lý do tại sao, khi gọi >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 80, tương thích ASCII >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 81 được phép được biểu diễn như nó là, nhưng N với Tilde được thoát đến >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 82. Trình tự trông lộn xộn đó đại diện cho hai byte, >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 83 và >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 84 trong hex:
  • Đây là lý do tại sao, khi gọi >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 80, tương thích ASCII >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 81 được phép được biểu diễn như nó là, nhưng N với Tilde được thoát đến >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 82. Trình tự trông lộn xộn đó đại diện cho hai byte, >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 83 và >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 84 trong hex:
  • def n_possible_values[nbits: int] -> int: return 2 ** nbits 06 đến def n_possible_values[nbits: int] -> int: return 2 ** nbits 07
  • Tôi không phải là bất kỳ phương tiện nào khuyến nghị bạn nhảy lên tàu UTF-16, bất kể bạn có hoạt động bằng ngôn ngữ mà các nhân vật thường nằm trong phạm vi này hay không. Trong số các lý do khác, một trong những lập luận mạnh mẽ cho việc sử dụng UTF-8 là, trong thế giới mã hóa, đó là một ý tưởng tuyệt vời để hòa nhập với đám đông.
  • Một khía cạnh gây tò mò khác của gia đình UTF là UTF-8 sẽ không phải lúc nào cũng chiếm ít không gian hơn UTF-16. Điều đó có vẻ phản trực giác về mặt toán học, nhưng nó hoàn toàn có thể:
  • Các mã hóa khác có sẵn trong Python
  • Bạn biết những gì họ nói về các giả định
  • Tỷ lệ cược và kết thúc: >>> from math import ceil, log >>> def n_bits_required[nvalues: int] -> int: ... return ceil[log[nvalues] / log[2]] >>> n_bits_required[256] 8 67
  • Tài nguyên
  • Các nhân vật trong Python là gì?
  • Set [] trong Python là gì?
  • Định danh tập hợp nhân vật là gì?
  • Đó không phải là một bộ nhân vật Python?

Xử lý mã hóa ký tự trong Python hoặc bất kỳ ngôn ngữ nào khác có thể có vẻ đau đớn. Những nơi như Stack Overflow có hàng ngàn câu hỏi xuất phát từ sự nhầm lẫn về các ngoại lệ như 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
4 và 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
5. Hướng dẫn này được thiết kế để xóa sương mù 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
6 và minh họa rằng làm việc với dữ liệu văn bản và nhị phân trong Python 3 có thể là một trải nghiệm suôn sẻ. Hỗ trợ của Python sườn Unicode rất mạnh mẽ và mạnh mẽ, nhưng phải mất một thời gian để làm chủ.

Hướng dẫn này là khác nhau bởi vì nó không phải là ngôn ngữ-bất khả tri mà thay vào đó là cố tình trung tâm. Bạn vẫn sẽ nhận được một đoạn mồi không liên tục ngôn ngữ, nhưng sau đó bạn sẽ đi sâu vào các hình minh họa trong Python, với các đoạn văn nặng về văn bản được giữ ở mức tối thiểu. Bạn có thể thấy cách sử dụng các khái niệm mã hóa ký tự trong mã Python trực tiếp.

Đến cuối hướng dẫn này, bạn sẽ:

  • Nhận tổng quan về khái niệm về mã hóa ký tự và hệ thống đánh số
  • Hiểu cách mã hóa xuất hiện với Python từ 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    7 và 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    8
  • Biết về sự hỗ trợ trong Python cho các hệ thống đánh số thông qua các hình thức khác nhau của nó
  • Làm quen với các chức năng tích hợp Python, liên quan đến mã hóa ký tự và hệ thống đánh số

Các hệ thống mã hóa và đánh số ký tự được kết nối chặt chẽ đến mức chúng cần được đề cập trong cùng một hướng dẫn hoặc nếu không thì việc điều trị của một trong hai sẽ hoàn toàn không đủ.

Những gì một nhân vật mã hóa?

Có hàng chục nếu không phải hàng trăm mã hóa nhân vật. Cách tốt nhất để bắt đầu hiểu những gì chúng là bao gồm một trong những mã hóa nhân vật đơn giản nhất, ASCII.

Cho dù bạn tự học hay có nền tảng khoa học máy tính chính thức, rất có thể bạn đã thấy một bảng ASCII một hoặc hai lần. ASCII là một nơi tốt để bắt đầu tìm hiểu về mã hóa ký tự vì nó là một mã hóa nhỏ và có chứa. [Quá nhỏ, hóa ra.]

Nó bao gồm những điều sau đây:

  • Chữ cái chữ thường chữ cái: a đến z: a through z: a through z
  • Chữ hoa chữ hoa: a đến z: A through Z: A through Z
  • Một số dấu câu và biểu tượng: 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    0 và 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    1, để đặt tên cho một cặp vợ chồng: 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    0 and 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    1, to name a couple    : 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    0 and 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    1, to name a couple
  • Các ký tự khoảng trắng: Một không gian thực tế [
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    2], cũng như một dòng mới, trả về vận chuyển, tab ngang, tab dọc và một vài cái khác: an actual space [
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    2], as well as a newline, carriage return, horizontal tab, vertical tab, and a few others    : an actual space [
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    2], as well as a newline, carriage return, horizontal tab, vertical tab, and a few others
  • Một số ký tự không thể in: các ký tự như Backspace, 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    3, có thể được in theo nghĩa đen theo cách mà chữ A có thể: characters such as backspace, 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    3, that can’t be printed literally in the way that the letter A can    : characters such as backspace, 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    3, that can’t be printed literally in the way that the letter A can

Vậy một định nghĩa chính thức hơn về mã hóa ký tự là gì?

Ở cấp độ rất cao, nó có một cách dịch các ký tự [như chữ cái, dấu câu, ký hiệu, khoảng trắng và ký tự điều khiển] sang số nguyên và cuối cùng là các bit. Mỗi ký tự có thể được mã hóa thành một chuỗi các bit duy nhất. Đừng lo lắng nếu bạn run rẩy về khái niệm bit, bởi vì chúng tôi sẽ sớm nhận được chúng.

Các loại khác nhau được phác thảo đại diện cho các nhóm ký tự. Mỗi ký tự duy nhất có một điểm mã tương ứng, mà bạn có thể nghĩ là chỉ là một số nguyên. Các ký tự được phân đoạn thành các phạm vi khác nhau trong bảng ASCII:code point, which you can think of as just an integer. Characters are segmented into different ranges within the ASCII table:code point, which you can think of as just an integer. Characters are segmented into different ranges within the ASCII table:

Phạm vi điểm mãLớp
0 đến 31 Ký tự điều khiển/không in
32 đến 64 Dấu câu, biểu tượng, số và không gian
65 đến 90 Chữ cái chữ cái chữ hoa
91 đến 96 Các biểu đồ bổ sung, chẳng hạn như 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
4 và 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
5
97 đến 122 Chữ cái chữ cái chữ thường chữ cái
123 đến 126 Các biểu đồ bổ sung, chẳng hạn như 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
6 và 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
7
127 Kiểm soát/ký tự không thể in [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
8]

Toàn bộ bảng ASCII chứa 128 ký tự. Bảng này ghi lại bộ ký tự hoàn chỉnh mà ASCII cho phép. Nếu bạn không thấy một nhân vật ở đây, thì bạn chỉ cần thể hiện nó dưới dạng văn bản in theo sơ đồ mã hóa ASCII.character set that ASCII permits. If you don’t see a character here, then you simply can’t express it as printed text under the ASCII encoding scheme.character set that ASCII permits. If you don’t see a character here, then you simply can’t express it as printed text under the ASCII encoding scheme.

Điểm mãTên nhân vật]Điểm mãTên nhân vật]
0 Nul [null] 64 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
9
1 Soh [bắt đầu tiêu đề] 65 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
90
2 STX [bắt đầu văn bản] 66 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
91
3 ETX [kết thúc văn bản] 67 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
92
4 EOT [kết thúc truyền tải] 68 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
93
5 ENQ [Yêu cầu] 69 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
94
6 ACK [xác nhận] 70 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
95
7 Bel [Bell] 71 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
96
8 BS [Backspace] 72 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
97
9 HT [tab ngang] 73 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
98
10 LF [nguồn cấp dữ liệu] 74 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
99
11 VT [tab dọc] 75 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
90
12 FF [nguồn cấp dữ liệu mẫu] 76 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
91
13 Cr [Quay trở lại] 77 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
92
14 Vì vậy [dịch chuyển ra] 78 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
93
15 Si [Shift In] 79 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
94
16 DLE [Escape liên kết dữ liệu] 80 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
95
17 DC1 [Điều khiển thiết bị 1] 81 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
96
18 DC2 [Điều khiển thiết bị 2] 82 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
97
19 DC3 [Điều khiển thiết bị 3] 83 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
98
20 DC4 [Điều khiển thiết bị 4] 84 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
99
21 NAK [xác nhận tiêu cực] 85 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
90
22 Syn [nhàn rỗi đồng bộ] 86 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
91
23 ETB [Kết thúc khối truyền] 87 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
92
24 Có thể [hủy] 88 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
93
25 Em [kết thúc trung bình] 89 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
94
26 Phụ [thay thế] 90 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
95
27 ESC [Escape] 91 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
4
28 FS [Bộ phân cách tệp] 92 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
5
29 GS [phân tách nhóm] 93 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
98
30 RS [Bộ phân cách ghi] 94 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
99
31 Hoa Kỳ [phân tách đơn vị] 95 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
90
32 SP [không gian] 96 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
91
33 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
92 		97 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
93
34 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
94 		98 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
95
35 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
96 		99 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
97
36 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
98 		100 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
99
37 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
90 		101 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
91
38 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
92 		102 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
93
39 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
94 		103 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
95
40 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
96 		104 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
97
41 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
98 		105 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
99
42 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
900 		106 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
901
43 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
902 		107 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
903
44 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
904 		108 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
905
45 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
906 		109 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
907
46 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
908 		110 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
909
47 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
910 		111 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
911
48 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
912 		112 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
913
49 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
914 		113 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
915
50 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
916 		114 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
917
51 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
918 		115 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
919
52 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
920 		116 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
921
53 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
922 		117 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
923
54 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
924 		118 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
925
55 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
926 		119 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
927
56 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
928 		120 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
929
57 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
930 		121 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
931
58 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
932 		122 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
933
59 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
934 		123 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
6
60 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
936 		124 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
7
61 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
938 		125 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
939
62 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
940 		126 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
941
63 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
942 		127 Del [xóa]

Mô -đun >>> import string >>> s = "What's wrong with ASCII?!?!?" >>> s.rstrip[string.punctuation] 'What's wrong with ASCII' 43

Mô-đun Python sườn 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
943 là một cửa một cửa thuận tiện cho các hằng số chuỗi rơi vào bộ ký tự ASCII.

Ở đây, cốt lõi của mô -đun trong tất cả vinh quang của nó:

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
13

Hầu hết các hằng số này nên tự ghi chép trong tên định danh của chúng. Chúng tôi sẽ bao gồm những gì 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
945 và 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
946 trong thời gian ngắn.

Bạn có thể sử dụng các hằng số này để thao tác chuỗi hàng ngày:

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
9

Một chút bồi dưỡng

Bây giờ là thời điểm tốt cho việc bồi dưỡng ngắn về bit, đơn vị thông tin cơ bản nhất mà máy tính biết.bit, the most fundamental unit of information that a computer knows.bit, the most fundamental unit of information that a computer knows.

Một chút là một tín hiệu chỉ có hai trạng thái có thể. Có nhiều cách khác nhau để thể hiện một chút một chút mà tất cả đều có nghĩa là cùng một điều:

  • 0 hoặc 1
  • "có hay không"
  • >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    947 hoặc 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    948
  • "bật hoặc tắt"

Bảng ASCII của chúng tôi từ phần trước sử dụng những gì bạn và tôi sẽ gọi các số [0 đến 127], nhưng những gì được gọi chính xác hơn là các số trong cơ sở 10 [thập phân].

Bạn cũng có thể thể hiện từng số cơ sở này với một chuỗi bit [cơ sở 2]. Dưới đây là các phiên bản nhị phân từ 0 đến 10 trong thập phân:

Số thập phânNhị phân [nhỏ gọn]Nhị phân [dạng đệm]
0 0 00000000
1 1 00000001
2 10 00000010
3 11 00000011
4 100 00000100
5 101 00000101
6 110 00000110
7 111 00000111
8 1000 00001000
9 1001 00001001
10 1010 00001010

Lưu ý rằng khi số thập phân N tăng, bạn cần các bit quan trọng hơn để thể hiện ký tự được thiết lập và bao gồm cả số đó.significant bits to represent the character set up to and including that number.significant bits to represent the character set up to and including that number.

Ở đây, một cách tiện dụng để đại diện cho các chuỗi ASCII như các chuỗi bit trong Python. Mỗi ký tự từ chuỗi ASCII được mã hóa giả thành 8 bit, với khoảng trắng ở giữa các chuỗi 8 bit mà mỗi người đại diện cho một ký tự duy nhất:

>>> 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
19

Một chút bồi dưỡng

  • Bây giờ là thời điểm tốt cho việc bồi dưỡng ngắn về bit, đơn vị thông tin cơ bản nhất mà máy tính biết.

  • Một chút là một tín hiệu chỉ có hai trạng thái có thể. Có nhiều cách khác nhau để thể hiện một chút một chút mà tất cả đều có nghĩa là cùng một điều:

0 hoặc 1

"có hay không"

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
947 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
948
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits

"bật hoặc tắt"

  • Bảng ASCII của chúng tôi từ phần trước sử dụng những gì bạn và tôi sẽ gọi các số [0 đến 127], nhưng những gì được gọi chính xác hơn là các số trong cơ sở 10 [thập phân].
  • Bạn cũng có thể thể hiện từng số cơ sở này với một chuỗi bit [cơ sở 2]. Dưới đây là các phiên bản nhị phân từ 0 đến 10 trong thập phân:
  • Số thập phân

Nhị phân [nhỏ gọn]

Nhị phân [dạng đệm]

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8

Một chút bồi dưỡng

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9

Bây giờ là thời điểm tốt cho việc bồi dưỡng ngắn về bit, đơn vị thông tin cơ bản nhất mà máy tính biết.

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9

Một chút là một tín hiệu chỉ có hai trạng thái có thể. Có nhiều cách khác nhau để thể hiện một chút một chút mà tất cả đều có nghĩa là cùng một điều:byte.

0 hoặc 1

"có hay không"

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
947 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
948
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits

"bật hoặc tắt"

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9

Bảng ASCII của chúng tôi từ phần trước sử dụng những gì bạn và tôi sẽ gọi các số [0 đến 127], nhưng những gì được gọi chính xác hơn là các số trong cơ sở 10 [thập phân].

Bạn cũng có thể thể hiện từng số cơ sở này với một chuỗi bit [cơ sở 2]. Dưới đây là các phiên bản nhị phân từ 0 đến 10 trong thập phân:

Số thập phân

Nhị phân [nhỏ gọn]

Nhị phân [dạng đệm]

Tất cả điều này phục vụ để chứng minh một khái niệm: ASCII, nói đúng, một mã 7 bit. Bảng ASCII mà bạn đã thấy ở trên chứa 128 điểm và ký tự mã, bao gồm từ 0 đến 127. Điều này đòi hỏi 7 bit:

Vấn đề với điều này là các máy tính hiện đại don don lưu trữ nhiều thứ trong các khe 7 bit. Họ lưu lượng truy cập theo đơn vị 8 bit, được gọi là một byte.byte.

Điều này có nghĩa là không gian lưu trữ được ASCII sử dụng là nửa trống. Nếu nó không rõ lý do tại sao điều này, hãy nghĩ lại bảng thập phân đến nhị phân từ trên cao. Bạn có thể diễn đạt số 0 và 1 chỉ với 1 bit hoặc bạn có thể sử dụng 8 bit để diễn đạt chúng lần lượt là 00000000 và 00000001.

Bạn có thể biểu thị các số từ 0 đến 3 chỉ với 2 bit hoặc 00 đến 11 hoặc bạn có thể sử dụng 8 bit để diễn đạt chúng dưới dạng 00000000, 00000001, 00000010 và 00000011, tương ứng. Điểm mã ASCII cao nhất, 127, chỉ yêu cầu 7 bit đáng kể.

Biết được điều này, bạn có thể thấy rằng 

  • >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    957 chuyển đổi chuỗi ASCII thành đại diện 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    7 của byte, trong đó mọi nhân vật tiêu thụ một byte:    : base 2
  • ASCII, việc sử dụng không đúng cách các byte 8 bit được cung cấp bởi các máy tính hiện đại đã dẫn đến một gia đình mã hóa không chính thức, mâu thuẫn mà mỗi ký tự bổ sung được chỉ định sẽ được sử dụng với 128 điểm mã có sẵn còn lại được phép trong sơ đồ mã hóa ký tự 8 bit.: base 8
  • Không chỉ các mã hóa khác nhau này đụng độ với nhau, mà mỗi người trong số chúng vẫn là một đại diện không hoàn chỉnh của các nhân vật thế giới, bất kể thực tế là họ đã sử dụng thêm một bit.: base 16

Trong những năm qua, một nhân vật mã hóa Mega-Scheme đã đến để cai trị tất cả. Tuy nhiên, trước khi chúng tôi đến đó, hãy để nói chuyện trong một phút về các hệ thống đánh số, đây là một nền tảng cơ bản của các sơ đồ mã hóa ký tự.

Bao gồm tất cả các cơ sở: các hệ thống số khác

Trong cuộc thảo luận về ASCII ở trên, bạn đã thấy rằng mỗi ký tự ánh xạ tới một số nguyên trong phạm vi từ 0 đến 127.

Phạm vi số này được thể hiện trong thập phân [cơ sở 10]. Đó là cách mà bạn, tôi và những người còn lại của chúng ta đã quen với việc đếm, không có lý do phức tạp hơn chúng ta có 10 ngón tay.

Nhưng có những hệ thống đánh số khác cũng đặc biệt phổ biến trong suốt mã nguồn CPython. Mặc dù số cơ bản của người Viking là giống nhau, nhưng tất cả các hệ thống đánh số chỉ là những cách khác nhau để thể hiện cùng một số.

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9

Nếu tôi hỏi bạn số nào chuỗi literal forms of each of the 3 alternative numbering systems above:

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
959 đại diện cho, bạn sẽ đúng khi cho tôi một cái nhìn kỳ lạ trước khi trả lời rằng nó đại diện cho mười một.Tuy nhiên, biểu diễn chuỗi này có thể diễn đạt các số cơ bản khác nhau trong các hệ thống đánh số khác nhau. Ngoài thập phân, các lựa chọn thay thế bao gồm các hệ thống đánh số phổ biến sau:Nhị phân: cơ sở 2: base 2
Octal: Cơ sở 8: base 8n/a 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
963
Nhị phân nhị phân 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
964 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
965 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
966
Nghĩa đen của bát phân 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
967 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
968 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
969
Hex theo nghĩa đen 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
970 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
971 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
972

Tất cả đều là các dạng phụ của các chữ số nguyên. Bạn có thể thấy rằng chúng tạo ra các kết quả tương tự, tương ứng, khi các cuộc gọi đến 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 với các giá trị không mặc định 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974. Tất cả họ chỉ là 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 cho Python:integer literals. You can see that these produce the same results, respectively, as the calls to 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 with non-default 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974 values. They’re all just 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 to Python:integer literals. You can see that these produce the same results, respectively, as the calls to 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 with non-default 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974 values. They’re all just 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 to Python:

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
9

Ở đây, cách bạn có thể nhập các loại tương đương nhị phân, bát phân và thập lục phân của các số thập phân từ 0 đến 20. Bất kỳ loại nào hoàn toàn có giá trị trong shell thông dịch viên Python hoặc mã nguồn và tất cả đều hoạt động để loại 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9: Số thập phânNhị phânBát phânHex
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
912 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
978 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
979 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
980 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
914 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
982 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
983 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
984 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
916 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
986 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
987 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
988 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
918 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
966 		Nghĩa đen của bát phân 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
967 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
968 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
969 		Hex theo nghĩa đen 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
970 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
971 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
972
Tất cả đều là các dạng phụ của các chữ số nguyên. Bạn có thể thấy rằng chúng tạo ra các kết quả tương tự, tương ứng, khi các cuộc gọi đến 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 với các giá trị không mặc định 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974. Tất cả họ chỉ là 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 cho Python:integer literals. You can see that these produce the same results, respectively, as the calls to 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 with non-default 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974 values. They’re all just 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 to Python:		>>>Ở đây, cách bạn có thể nhập các loại tương đương nhị phân, bát phân và thập lục phân của các số thập phân từ 0 đến 20. Bất kỳ loại nào hoàn toàn có giá trị trong shell thông dịch viên Python hoặc mã nguồn và tất cả đều hoạt động để loại 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9: 		Số thập phânNhị phânBát phân
Hex
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
912 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
978 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
979 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
980 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
914 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
982 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
983 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
984 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
916 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
969 		Hex theo nghĩa đen 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
970 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
971 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
972 		Tất cả đều là các dạng phụ của các chữ số nguyên. Bạn có thể thấy rằng chúng tạo ra các kết quả tương tự, tương ứng, khi các cuộc gọi đến 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 với các giá trị không mặc định 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974. Tất cả họ chỉ là 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 cho Python:integer literals. You can see that these produce the same results, respectively, as the calls to 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 with non-default 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974 values. They’re all just 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 to Python:
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
963 		>>>Ở đây, cách bạn có thể nhập các loại tương đương nhị phân, bát phân và thập lục phân của các số thập phân từ 0 đến 20. Bất kỳ loại nào hoàn toàn có giá trị trong shell thông dịch viên Python hoặc mã nguồn và tất cả đều hoạt động để loại 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9:
Số thập phânNhị phânBát phânHex
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
912 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
978 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
979 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
980 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
914 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
982 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
983 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
984 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
916 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
986 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
987 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
988 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
918 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
992 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
920 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
994 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
995 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
996 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
922 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
972
Tất cả đều là các dạng phụ của các chữ số nguyên. Bạn có thể thấy rằng chúng tạo ra các kết quả tương tự, tương ứng, khi các cuộc gọi đến 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 với các giá trị không mặc định 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974. Tất cả họ chỉ là 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 cho Python:integer literals. You can see that these produce the same results, respectively, as the calls to 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 with non-default 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
974 values. They’re all just 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9 to Python:		>>>Ở đây, cách bạn có thể nhập các loại tương đương nhị phân, bát phân và thập lục phân của các số thập phân từ 0 đến 20. Bất kỳ loại nào hoàn toàn có giá trị trong shell thông dịch viên Python hoặc mã nguồn và tất cả đều hoạt động để loại 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9: 		Số thập phânNhị phânBát phân
Hex
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
912 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
978 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
979 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
980 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
914 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
982 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
983 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
984 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
916 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
986 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
987 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
988 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
918 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
992 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
920 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
994 Unicode itself is not an encoding. Rather, Unicode is implemented by different character encodings, which you’ll see soon. Unicode is better thought of as a map [something like a 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1967] or a 2-column database table. It maps characters [like 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1968, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1969, or even 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1970] to distinct, positive integers. A character encoding needs to offer a bit more.

Unicode chứa hầu như mọi nhân vật mà bạn có thể tưởng tượng, bao gồm cả những người không thể in bổ sung. Một trong những mục yêu thích của tôi là dấu hiệu từ phải sang trái, có mã điểm 8207 và được sử dụng trong văn bản với cả các tập lệnh ngôn ngữ từ trái sang phải và từ phải, chẳng hạn như một bài viết có chứa cả đoạn văn tiếng Anh và tiếng Ả Rập .

Unicode vs UTF-8

Nó đã không mất nhiều thời gian để mọi người nhận ra rằng tất cả các nhân vật trên thế giới không thể được đóng gói thành một byte. Nó rõ ràng từ đó rằng các mã hóa hiện đại, toàn diện hơn sẽ cần sử dụng nhiều byte để mã hóa một số ký tự.

Bạn cũng thấy ở trên rằng Unicode không phải là một mã hóa ký tự toàn diện. Tại sao vậy?

Có một điều mà Unicode không nói với bạn: Nó không cho bạn biết làm thế nào để có được các bit thực tế từ văn bản chỉ các điểm mã. Nó không cho bạn biết đủ về cách chuyển đổi văn bản thành dữ liệu nhị phân và ngược lại.

Unicode là một tiêu chuẩn mã hóa trừu tượng, không phải là mã hóa. Đó là nơi mà UTF-8 và các chương trình mã hóa khác xuất hiện. Tiêu chuẩn Unicode [Bản đồ các ký tự cho các điểm mã] xác định một số mã hóa khác nhau từ bộ ký tự đơn của nó.

UTF-8 cũng như anh em họ ít sử dụng hơn, UTF-16 và UTF-32, là các định dạng mã hóa để đại diện cho các ký tự Unicode dưới dạng dữ liệu nhị phân của một hoặc nhiều byte trên mỗi ký tự. Chúng tôi sẽ thảo luận về UTF-16 và UTF-32 trong một khoảnh khắc, nhưng UTF-8 đã chiếm phần chia sẻ lớn nhất của chiếc bánh.

Điều đó đưa chúng ta đến một định nghĩa đã quá hạn lâu. Nó có nghĩa là gì, chính thức, để mã hóa và giải mã?encode and decode?encode and decode?

Mã hóa và giải mã trong Python 3

Loại Python 3 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 có nghĩa là đại diện cho văn bản có thể đọc được của con người và có thể chứa bất kỳ ký tự Unicode nào.

Loại 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8, ngược lại, đại diện cho dữ liệu nhị phân hoặc chuỗi byte thô, bản chất không có mã hóa được gắn vào nó.

Mã hóa và giải mã là quá trình đi từ cái này sang cái khác:

Mã hóa so với giải mã [Hình ảnh: Python thật]

Trong 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1973 và 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1974, tham số 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1975 là 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1976 theo mặc định, mặc dù nó thường an toàn hơn và không rõ ràng hơn để chỉ định nó:

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
91

Kết quả của 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1977 là một đối tượng 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8. Cả hai byte theo nghĩa đen [như 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1979] và các biểu diễn của byte chỉ cho phép các ký tự ASCII.

Đây là lý do tại sao, khi gọi 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1980, tương thích ASCII 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1981 được phép được biểu diễn như nó là, nhưng N với Tilde được thoát đến 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1982. Trình tự trông lộn xộn đó đại diện cho hai byte, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1983 và 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1984 trong hex:

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
92

Kết quả của 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1977 là một đối tượng 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8. Cả hai byte theo nghĩa đen [như 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1979] và các biểu diễn của byte chỉ cho phép các ký tự ASCII.

Đây là lý do tại sao, khi gọi

Đó là, ký tự 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1985 yêu cầu hai byte cho biểu diễn nhị phân của nó theo UTF-8.

  • Python 3: All-in on unicode

  • Python 3 là tất cả trên Unicode và UTF-8 cụ thể. Ở đây, điều đó có nghĩa là gì:

  • Mã nguồn Python 3 được coi là UTF-8 theo mặc định. Điều này có nghĩa là bạn không cần 

    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    1986 ở đầu các tệp 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    1987 trong Python 3.

  • Tất cả văn bản [

    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    7] là Unicode theo mặc định. Văn bản unicode được mã hóa được biểu diễn dưới dạng dữ liệu nhị phân [
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    8]. Loại 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    7 có thể chứa bất kỳ ký tự unicode theo nghĩa đen nào, chẳng hạn như 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    1991, tất cả chúng sẽ được lưu trữ dưới dạng Unicode.

  • Python 3 chấp nhận nhiều điểm mã Unicode trong các định danh, có nghĩa là 

    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    1992 là hợp lệ nếu điều này tạo ra sự ưa thích của bạn.

Mô -đun Python từ 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1993 mặc định là cờ 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1994 thay vì 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1995. Điều này có nghĩa là, ví dụ, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1996 phù hợp với các ký tự từ Unicode, không chỉ các chữ cái ASCII.

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
93

Kết quả của 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1977 là một đối tượng 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8. Cả hai byte theo nghĩa đen [như 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1979] và các biểu diễn của byte chỉ cho phép các ký tự ASCII.

Đây là lý do tại sao, khi gọi >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 80, tương thích ASCII >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 81 được phép được biểu diễn như nó là, nhưng N với Tilde được thoát đến >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 82. Trình tự trông lộn xộn đó đại diện cho hai byte, >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 83 và >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 84 trong hex:

Đó là, ký tự 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1985 yêu cầu hai byte cho biểu diễn nhị phân của nó theo UTF-8.variable-length encoding. It’s tempting to gloss over what this means, but it’s worth delving into.variable-length encoding. It’s tempting to gloss over what this means, but it’s worth delving into.

Python 3: All-in on unicode

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
94

Kết quả của 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1977 là một đối tượng 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8. Cả hai byte theo nghĩa đen [như 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1979] và các biểu diễn của byte chỉ cho phép các ký tự ASCII.

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
95

Kết quả của 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1977 là một đối tượng 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8. Cả hai byte theo nghĩa đen [như 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1979] và các biểu diễn của byte chỉ cho phép các ký tự ASCII.
  • Đây là lý do tại sao, khi gọi >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 80, tương thích ASCII >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 81 được phép được biểu diễn như nó là, nhưng N với Tilde được thoát đến >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 82. Trình tự trông lộn xộn đó đại diện cho hai byte, >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 83 và >>> def make_bitseq[s: str] -> str: ... if not s.isascii[]: ... raise ValueError["ASCII only allowed"] ... return " ".join[f"{ord[i]:08b}" for i in s] >>> make_bitseq["bits"] '01100010 01101001 01110100 01110011' >>> make_bitseq["CAPS"] '01000011 01000001 01010000 01010011' >>> make_bitseq["$25.43"] '00100100 00110010 00110101 00101110 00110100 00110011' >>> make_bitseq["~5"] '01111110 00110101' 84 trong hex:
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    1985 yêu cầu hai byte cho biểu diễn nhị phân của nó theo UTF-8.variable-length encoding. It’s tempting to gloss over what this means, but it’s worth delving into.

Python 3: All-in on unicode

Python 3 là tất cả trên Unicode và UTF-8 cụ thể. Ở đây, điều đó có nghĩa là gì:Mã nguồn Python 3 được coi là UTF-8 theo mặc định. Điều này có nghĩa là bạn không cần 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1986 ở đầu các tệp 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1987 trong Python 3.Python 3 chấp nhận nhiều điểm mã Unicode trong các định danh, có nghĩa là 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1992 là hợp lệ nếu điều này tạo ra sự ưa thích của bạn.
Mô -đun Python từ 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1993 mặc định là cờ 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1994 thay vì 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1995. Điều này có nghĩa là, ví dụ, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1996 phù hợp với các ký tự từ Unicode, không chỉ các chữ cái ASCII. 		Mặc định 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1975 trong 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1977 và 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1999 là UTF-8. 		Có một thuộc tính khác có nhiều sắc thái hơn, đó là mặc định 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1975 cho 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
01 tích hợp phụ thuộc vào nền tảng và phụ thuộc vào giá trị của 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
02: 		Một lần nữa, bài học ở đây là cẩn thận về việc đưa ra các giả định khi nói đến tính phổ quát của UTF-8, ngay cả khi đó là mã hóa chiếm ưu thế. Không bao giờ đau khi được rõ ràng trong mã của bạn.
Một byte, hai byte, ba byte, bốn Một tính năng quan trọng là UTF-8 là một mã hóa có độ dài thay đổi. Nó rất hấp dẫn để che giấu ý nghĩa của điều này, nhưng nó đáng để đi sâu vào. Nghĩ lại phần trên ASCII. Tất cả mọi thứ trong nhu cầu đất đai mở rộng nhiều nhất là một byte không gian. Bạn có thể nhanh chóng chứng minh điều này với biểu thức máy phát sau: UTF-8 khá khác nhau. Một ký tự unicode nhất định có thể chiếm bất cứ nơi nào từ một đến bốn byte. Ở đây, một ví dụ về một ký tự unicode duy nhất chiếm bốn byte:
Đây là một tính năng tinh tế nhưng quan trọng của 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
03: 		Độ dài của một ký tự unicode duy nhất là Python 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 sẽ luôn luôn là 1, bất kể nó chiếm bao nhiêu byte. 		Độ dài của cùng một ký tự được mã hóa thành 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8 sẽ ở bất cứ đâu trong khoảng từ 1 đến 4. 		Bảng dưới đây tóm tắt những loại ký tự chung nào phù hợp với mỗi nhóm có độ dài byte:
Phạm vi thập phân Phạm vi hex Những gì bao gồm Ví dụ

0 đến 127 **A huge array of languages and symbols—mostly Chinese, Japanese, and Korean by volume [also ASCII and Latin alphabets] ***Additional Chinese, Japanese, Korean, and Vietnamese characters, plus more symbols and emojis
**A huge array of languages and symbols—mostly Chinese, Japanese, and Korean by volume [also ASCII and Latin alphabets]
***Additional Chinese, Japanese, Korean, and Vietnamese characters, plus more symbols and emojis

def n_possible_values[nbits: int] -> int: return 2 ** nbits 06 đến def n_possible_values[nbits: int] -> int: return 2 ** nbits 07

Hoa Kỳ ASCII

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
08, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
09, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
10, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
11

>>>

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
96

128 đến 2047

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
12 đến 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
13

Hầu hết các bảng chữ cái Latin*

Mã hóaByte trên mỗi ký tự [bao gồm]Chiều dài thay đổi
UTF-8 1 đến 4 Đúng
UTF-16 2 đến 4 Đúng
UTF-16 4 2 đến 4

UTF-32

Không

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
97

Một khía cạnh gây tò mò khác của gia đình UTF là UTF-8 sẽ không phải lúc nào cũng chiếm ít không gian hơn UTF-16. Điều đó có vẻ phản trực giác về mặt toán học, nhưng nó hoàn toàn có thể:

>>>

128 đến 2047

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
12 đến 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
13

Hầu hết các bảng chữ cái Latin*

Mã hóa

Byte trên mỗi ký tự [bao gồm]

  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    34
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    35
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    36
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    37
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    38
  • >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    960
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    40
  • >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    951
  • def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    42

Chiều dài thay đổi

  • UTF-8 are for obtaining a different representation of an input. Each one produces a

    1 đến 4

  • Đúng are class constructors for their respective types,

    UTF-16

  • 2 đến 4 34, 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    35, 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    38 và 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    40 là để có được một biểu diễn khác của đầu vào. Mỗi người tạo ra một 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    7. Đầu tiên, 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    34, tạo ra một đại diện chỉ ASCII của một đối tượng, với các ký tự không phải ASCII đã thoát ra. Ba phần còn lại cho các biểu diễn nhị phân, thập lục phân và phân bổ của một số nguyên, tương ứng. Đây chỉ là những đại diện, không phải là một thay đổi cơ bản trong đầu vào.     are inverses of each other in that the Python 

    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    951 function converts a 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    7 character to its base-10 code point, while 
    def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
    37 does the opposite.
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
36, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
42 và 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
960 là các hàm tạo lớp cho các loại tương ứng của chúng, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
8, 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 và 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
9. Mỗi người cung cấp các cách ép buộc đầu vào vào loại mong muốn. Chẳng hạn, như bạn đã thấy trước đó, trong khi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
55 có lẽ là phổ biến hơn, bạn cũng có thể thấy 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
56. 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
951 và 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
37 là nghịch đảo của nhau ở chỗ hàm Python 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
951 chuyển đổi ký tự 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 thành điểm mã cơ sở-10 của nó, trong khi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
37 thực hiện ngược lại.Ở đây, một cái nhìn chi tiết hơn về mỗi chín chức năng này:Hàm sốChữ kýChấp nhận
Loại trở lại Mục đích 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
34 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
34 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
34 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 		ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
34 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
63 		Thay đổi 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
98

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
99

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
190

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
191

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
192

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
193

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
195

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
71
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
72
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
73
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
74

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát ra 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
196

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
35 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
71
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
72
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
73
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
74 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
197

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
79
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
80
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
81 

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
89
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
90 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
00
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
01 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
04
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
05

ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII đã thoát raKhôngMột khía cạnh gây tò mò khác của gia đình UTF là UTF-8 sẽ không phải lúc nào cũng chiếm ít không gian hơn UTF-16. Điều đó có vẻ phản trực giác về mặt toán học, nhưng nó hoàn toàn có thể:
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
194 		>>>Bên cạnh việc đặt các ký tự Unicode thực tế, không được phân loại vào bảng điều khiển, có những cách khác để nhập các chuỗi Unicode.
Một trong những phần dày đặc nhất của tài liệu Python, là phần về phân tích từ vựng, cụ thể là phần về chuỗi và byte. Cá nhân, tôi đã phải đọc phần này về một, hai, hoặc có thể chín lần để nó thực sự chìm vào.Một phần của những gì nó nói là có tối đa sáu cách mà Python sẽ cho phép bạn nhập cùng một ký tự Unicode.Cách đầu tiên và phổ biến nhất là gõ chính nhân vật theo nghĩa đen, như bạn đã thấy. Phần khó khăn với phương pháp này là tìm các tổ hợp phím thực tế. Đó là nơi mà các phương pháp khác để nhận và đại diện cho các nhân vật phát huy tác dụng. Ở đây, danh sách đầy đủ:
Trình tự thoátNghĩa
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
32 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
33 		Ký tự với giá trị hex 16 bit [2 byte] 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
34 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
35 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
36 		Ký tự với giá trị hex 32 bit [4 byte] 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
37 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
38

Ở đây, một số bằng chứng và xác nhận của những điều trên:

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
198

Bây giờ, có hai cảnh báo chính:

  1. Không phải tất cả các hình thức này hoạt động cho tất cả các ký tự. Đại diện Hex của số nguyên 300 là 

    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    39, đơn giản là sẽ phù hợp với mã thoát 2-hex-chữ số 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    27. Điểm mã cao nhất mà bạn có thể siết chặt vào chuỗi thoát này là 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    41 [
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    42]. Tương tự đối với 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    24, nó sẽ chỉ hoạt động lên đến 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    44 [
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    45].

  2. Đối với 

    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    46, 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    47 và 
    >>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
    48, chính xác là nhiều chữ số được yêu cầu như được hiển thị trong các ví dụ này. Điều này có thể ném bạn cho một vòng lặp vì cách các bảng Unicode thường hiển thị các mã cho các ký tự, với số lượng ký tự hex hàng đầu và biến đổi. Điều quan trọng là các bảng Unicode thường không có các mã này.

Chẳng hạn, nếu bạn tham khảo unicode-table.com để biết thông tin về chữ gothic faihu [hoặc FEHU], 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
50, bạn sẽ thấy rằng nó được liệt kê là có mã 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
51.

Làm thế nào để bạn đặt điều này vào 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
33 hoặc 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
36? Chà, bạn có thể phù hợp với nó trong 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
33 bởi vì nó là một nhân vật 4 byte và sử dụng 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
36 để thể hiện nhân vật này, bạn sẽ cần phải bỏ qua trình tự:

Điều này cũng có nghĩa là mẫu 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
36 là chuỗi thoát duy nhất có khả năng giữ bất kỳ ký tự unicode nào.

Các mã hóa khác có sẵn trong Python

Cho đến nay, bạn đã thấy bốn mã hóa nhân vật:

  1. Ascii
  2. UTF-8
  3. UTF-16
  4. UTF-32

Có rất nhiều người khác ngoài kia.

Một ví dụ là Latin-1 [còn được gọi là ISO-8859-1], về mặt kỹ thuật là mặc định cho giao thức chuyển siêu văn bản [HTTP], mỗi RFC 2616. Windows có biến thể Latin-1 riêng được gọi là CP1252.

Danh sách đầy đủ các mã hóa được chấp nhận được chôn vùi trong tài liệu cho mô -đun 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
57, là một phần của thư viện tiêu chuẩn Python.

Có một mã hóa được công nhận hữu ích hơn để nhận thức được, đó là 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
58. Nếu bạn có một 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
7 được giải mã và muốn nhanh chóng nhận được một đại diện cho chữ Unicode đã thoát ra của nó, thì bạn có thể chỉ định mã hóa này trong 
def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1973:

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
199

Bây giờ, có hai cảnh báo chính:

Không phải tất cả các hình thức này hoạt động cho tất cả các ký tự. Đại diện Hex của số nguyên 300 là 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
39, đơn giản là sẽ phù hợp với mã thoát 2-hex-chữ số 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
27. Điểm mã cao nhất mà bạn có thể siết chặt vào chuỗi thoát này là 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
41 [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
42]. Tương tự đối với 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
24, nó sẽ chỉ hoạt động lên đến 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
44 [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
45].

Đối với 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
46, 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
47 và 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
48, chính xác là nhiều chữ số được yêu cầu như được hiển thị trong các ví dụ này. Điều này có thể ném bạn cho một vòng lặp vì cách các bảng Unicode thường hiển thị các mã cho các ký tự, với số lượng ký tự hex hàng đầu và biến đổi. Điều quan trọng là các bảng Unicode thường không có các mã này.

Chẳng hạn, nếu bạn tham khảo unicode-table.com để biết thông tin về chữ gothic faihu [hoặc FEHU],

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
0

Bây giờ, có hai cảnh báo chính:

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
1

Bây giờ, có hai cảnh báo chính:

Không phải tất cả các hình thức này hoạt động cho tất cả các ký tự. Đại diện Hex của số nguyên 300 là

>>>

def n_possible_values[nbits: int] -> int:
    return 2 ** nbits
2

Bây giờ, có hai cảnh báo chính:

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
64].

Không phải tất cả các hình thức này hoạt động cho tất cả các ký tự. Đại diện Hex của số nguyên 300 là 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
39, đơn giản là sẽ phù hợp với mã thoát 2-hex-chữ số 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
27. Điểm mã cao nhất mà bạn có thể siết chặt vào chuỗi thoát này là 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
41 [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
42]. Tương tự đối với 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
24, nó sẽ chỉ hoạt động lên đến 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
44 [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
45].

Đối với 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
46, 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
47 và 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
48, chính xác là nhiều chữ số được yêu cầu như được hiển thị trong các ví dụ này. Điều này có thể ném bạn cho một vòng lặp vì cách các bảng Unicode thường hiển thị các mã cho các ký tự, với số lượng ký tự hex hàng đầu và biến đổi. Điều quan trọng là các bảng Unicode thường không có các mã này.

Chẳng hạn, nếu bạn tham khảo unicode-table.com để biết thông tin về chữ gothic faihu [hoặc FEHU], 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
50, bạn sẽ thấy rằng nó được liệt kê là có mã 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
51.

>>>

Bây giờ, có hai cảnh báo chính:

Không phải tất cả các hình thức này hoạt động cho tất cả các ký tự. Đại diện Hex của số nguyên 300 là 

>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
39, đơn giản là sẽ phù hợp với mã thoát 2-hex-chữ số 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
27. Điểm mã cao nhất mà bạn có thể siết chặt vào chuỗi thoát này là 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
41 [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
42]. Tương tự đối với 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
24, nó sẽ chỉ hoạt động lên đến 
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
44 [
>>> from math import ceil, log

>>> def n_bits_required[nvalues: int] -> int:
...     return ceil[log[nvalues] / log[2]]

>>> n_bits_required[256]
8
45].

Đối với

  • Các khái niệm cơ bản của mã hóa ký tự và hệ thống đánh số
  • Số nguyên, nhị phân, bát phân, hex, str và byte theo nghĩa đen trong Python
  • Các chức năng tích hợp của Python, liên quan đến hệ thống mã hóa và đánh số ký tự
  • Python 3 Xử lý văn bản so với dữ liệu nhị phân

Bây giờ, đi ra và mã hóa!

Tài nguyên

Để biết thêm chi tiết về các chủ đề được đề cập ở đây, hãy xem các tài nguyên này:

  • Joel Spolsky: Tối thiểu tuyệt đối mỗi nhà phát triển phần mềm hoàn toàn, tích cực phải biết về các bộ unicode và ký tự [không có lý do!] The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets [No Excuses!] The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets [No Excuses!]
  • David Zentgraf: Điều mà mọi lập trình hoàn toàn cần biết về bộ mã hóa và bộ nhân vật để làm việc với văn bản What every programmer absolutely, positively needs to know about encodings and character sets to work with text What every programmer absolutely, positively needs to know about encodings and character sets to work with text
  • Mozilla: Một cách tiếp cận tổng hợp để phát hiện ngôn ngữ/mã hóa A composite approach to language/encoding detection A composite approach to language/encoding detection
  • Wikipedia: UTF-8 UTF-8 UTF-8
  • John Skeet: Unicode và .net Unicode and .NET Unicode and .NET
  • Charles Petzold: Mã: Ngôn ngữ ẩn của phần cứng và phần mềm máy tính Code: The Hidden Language of Computer Hardware and Software Code: The Hidden Language of Computer Hardware and Software
  • Nhóm làm việc mạng, RFC 3629: UTF-8, Định dạng chuyển đổi của ISO 10646 UTF-8, a transformation format of ISO 10646 UTF-8, a transformation format of ISO 10646
  • Tiêu chuẩn kỹ thuật Unicode #18: Các biểu thức chính quy Unicode Unicode Regular Expressions Unicode Regular Expressions

Các tài liệu Python có hai trang về chủ đề:

  • Những gì mới trong Python 3.0
  • Unicode Howto

Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để làm sâu sắc thêm sự hiểu biết của bạn: Unicode in Python: Làm việc với mã hóa ký tự This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Unicode in Python: Working With Character Encodings This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Unicode in Python: Working With Character Encodings

Các nhân vật trong Python là gì?

Giống như nhiều ngôn ngữ lập trình phổ biến khác, các chuỗi trong Python là các mảng byte đại diện cho các ký tự Unicode.Tuy nhiên, Python không có kiểu dữ liệu ký tự, một ký tự duy nhất chỉ đơn giản là một chuỗi có chiều dài 1. Giá đỡ vuông có thể được sử dụng để truy cập các phần tử của chuỗi.arrays of bytes representing unicode characters. However, Python does not have a character data type, a single character is simply a string with a length of 1. Square brackets can be used to access elements of the string.arrays of bytes representing unicode characters. However, Python does not have a character data type, a single character is simply a string with a length of 1. Square brackets can be used to access elements of the string.

Set [] trong Python là gì?

Phương thức SET [] được sử dụng để chuyển đổi bất kỳ điều kiện nào có thể lặp lại thành chuỗi các phần tử có thể lặp lại với các phần tử riêng biệt, thường được gọi là tập hợp.Tham số: Bất kỳ trình tự lặp lại như danh sách, tuple hoặc từ điển.Trả về: Một tập trống nếu không có phần tử nào được truyền.used to convert any of the iterable to sequence of iterable elements with distinct elements, commonly called Set. Parameters : Any iterable sequence like list, tuple or dictionary. Returns : An empty set if no element is passed.used to convert any of the iterable to sequence of iterable elements with distinct elements, commonly called Set. Parameters : Any iterable sequence like list, tuple or dictionary. Returns : An empty set if no element is passed.

Định danh tập hợp nhân vật là gì?

CDRA xác định các giá trị định danh bộ ký tự được mã hóa [CCSID] để xác định các điểm mã được sử dụng để biểu diễn các ký tự và để chuyển đổi các mã này [dữ liệu ký tự], khi cần thiết để lưu giữ ý nghĩa của chúng.to identify the code points used to represent characters, and to convert these codes [character data], as needed to preserve their meanings.to identify the code points used to represent characters, and to convert these codes [character data], as needed to preserve their meanings.

Đó không phải là một bộ nhân vật Python?

Giải thích: Chúng ta có thể thêm hình ảnh trong Python nhưng chúng không phải là bộ ký tự.add images in python but they aren't character sets.add images in python but they aren't character sets.

Bài Viết Liên Quan

Hướng dẫn redirect to previous page javascript - chuyển hướng đến trang trước javascript
Hướng dẫn where can i practice html css and javascript? - tôi có thể thực hành html css và javascript ở đâu?
Hướng dẫn python library path linux - đường dẫn thư viện python linux
2023 Subaru Crosstrek Hybrid price
Hướng dẫn can i use mongodb as api? - tôi có thể sử dụng mongodb làm api không?
Hướng dẫn can python take function as argument? - python có thể lấy chức năng làm đối số không?
Cài python trên kali linux
Hướng dẫn excel round down time to nearest hour - excel làm tròn thời gian xuống giờ gần nhất
60 giây ngày 30 tháng 6 năm 2023
Hướng dẫn what is the purpose of the def keyword in python? - mục đích của từ khóa def trong python là gì?
Hướng dẫn which of the following are false statements about lists in python - câu nào sau đây là sai về danh sách trong python
Hướng dẫn how do i keep font color in css? - làm cách nào để giữ màu phông chữ trong css?
Co opmart thốt nốt tuyển dụng 2023
Hướng dẫn can we learn python in 30 days? - chúng ta có thể học python trong 30 ngày không?
Hướng dẫn sum of two numbers in python using function - tổng hai số trong python sử dụng hàm
2023 chevy Tahoe Z71 Interior
Hướng dẫn find the average of largest and smallest numbers in an unsorted integer array in python - tìm giá trị trung bình của các số lớn nhất và nhỏ nhất trong một mảng số nguyên chưa sắp xếp trong python
Hướng dẫn việc làm python hcm
Hướng dẫn how do you condition a password in html? - làm thế nào để bạn điều kiện một mật khẩu trong html?
Hướng dẫn string output questions in python - câu hỏi xuất chuỗi trong python

Toplist mới

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
6 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
6 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
6 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
6 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
6 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
6 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
6 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
6 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
6 tháng trước

Bài mới nhất

Nghiệp vụ tín dụng ngân hàng là gì năm 2024
Bài tập cấu hình electron nguyên tử khó năm 2024
Ngày 14 3 là ngày gì năm 2024
Mục đích sử dụng đất 2l 19 năm là gì năm 2024
Top 10 luong cau thu cao nhat the gioi năm 2024
Quạt điều hòa air cooler của nước nào năm 2024
Phí chuyển đổi quỹ liên kết đơn vị là gì năm 2024
Các bài tập về câu điều ước có đáp án năm 2024
Kèo ft châu á 1x2 là gì năm 2024
Top 1 thịnh hành ngày 12 5 2023 năm 2024

Chủ Đề

programming Hỏi Đáp Toplist Là gì Mẹo Hay Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Top List bao nhieu bao nhiêu hướng dẫn Xây Đựng So Sánh Bài tập So sánh Tiếng anh Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Máy tính Tại sao Đại học Món Ngon Khoa Học