search

Làm cách nào để thay đổi mã hóa của chuỗi trong python?

Ngày đăng: 07/02/2023
Trả lời: 0
Lượt xem: 108

Xử lý mã hóa ký tự trong Python hoặc bất kỳ ngôn ngữ nào khác đôi khi có vẻ khó khăn. Những nơi như Stack Overflow có hàng nghìn câu hỏi bắt nguồn từ sự nhầm lẫn về các ngoại lệ như 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
6 và 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
7. 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
8 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ợ Unicode của Python rất mạnh mẽ và mạnh mẽ, nhưng phải mất một thời gian để thành thạo

Show

Hướng dẫn này khác biệt bởi vì nó không phải là ngôn ngữ bất khả tri mà thay vào đó, có chủ ý lấy Python làm trung tâm. Bạn vẫn sẽ nhận được phần mở đầu không liên quan đến ngôn ngữ, nhưng sau đó, bạn sẽ đi sâu vào các hình minh họa bằng Python, với các đoạn văn bản nặng được giữ ở mức tối thiểu. Bạn sẽ 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 khái niệm về mã hóa ký tự và hệ thống đánh số
  • Hiểu cách mã hóa phát huy tác dụng với 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    9 và 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    0 của Python
  • Biết về hỗ trợ trong Python cho các hệ thống đánh số thông qua các dạng khác nhau của 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    1 chữ
  • Làm quen với các hàm tích hợp sẵn của Python liên quan đến mã hóa ký tự và hệ thống đánh số

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

Ghi chú. Bài viết này là Python 3 trung tâm. Cụ thể, tất cả các ví dụ về mã trong hướng dẫn này được tạo từ một CPython 3. 7. 2 shell, mặc dù tất cả các phiên bản nhỏ của Python 3 sẽ hoạt động (hầu hết) giống nhau trong cách xử lý văn bản của chúng

Nếu bạn vẫn đang sử dụng Python 2 và bị đe dọa bởi sự khác biệt trong cách Python 2 và Python 3 xử lý dữ liệu văn bản và dữ liệu nhị phân, thì hy vọng hướng dẫn này sẽ giúp bạn thực hiện chuyển đổi

Tải xuống miễn phí. Nhận một chương mẫu từ Thủ thuật Python. Cuốn sách chỉ cho bạn các phương pháp hay nhất về Python với các ví dụ đơn giản mà bạn có thể áp dụng ngay lập tức để viết mã Pythonic + đẹp hơn

Mã hóa ký tự là gì?

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

Cho dù bạn là người tự học hay có kiến ​​thức cơ bản về khoa học máy tính, rất có thể bạn đã nhìn thấy 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ì đây 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ữ thường tiếng Anh. từ a đến z
  • Các chữ cái tiếng Anh viết hoa. A đến Z
  • Một số dấu câu và kí hiệu. 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    2 và 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    3, để đặt tên cho một cặp vợ chồng
  • 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
    4), cũng như một dòng mới, xuống dòng, tab ngang, tab dọc và một vài thứ khác
  • Một số ký tự không in được. các ký tự như xóa lùi, 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    5, không thể được in theo nghĩa đen theo cách mà chữ A có thể

Vì 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, đó là cách dịch các ký tự (chẳng hạn như chữ cái, dấu chấm 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à bit. Mỗi ký tự có thể được mã hóa thành một chuỗi bit duy nhất. Đừng lo lắng nếu bạn không nắm vững khái niệm về bit, vì chúng ta sẽ sớm tìm hiểu về chúng

Các danh mục khác nhau được phác thảo đại diện cho các nhóm ký tự. Mỗi ký tự đơn có một điểm mã tương ứng mà bạn có thể coi như 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

Phạm vi điểm mã Lớp từ 0 đến 31Ký tự điều khiển/không in được32 đến 64Dấu câu, ký hiệu, số và khoảng trắng65 đến 90Các chữ cái trong bảng chữ cái tiếng Anh viết hoa từ 91 đến 96Cá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
797 đến 122Các chữ cái trong bảng chữ cái tiếng Anh viết thường từ 123 đến 126Cá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
8 và 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
9127Kiểm soát/không phải

Toàn bộ bảng ASCII chứa 128 ký tự. Bảng này nắm bắt bộ ký tự hoàn chỉnh mà ASCII cho phép. Nếu bạn không thấy một ký tự ở đây, thì đơn giản là bạn không thể diễn đạt ký tự đó dưới dạng văn bản in theo sơ đồ mã hóa ASCII

Bảng ASCIIHiển thị/Ẩn

Code PointCharacter (Name)Code PointCharacter (Name)0NUL (Null)64

>>> n_bits_required(110)
7
11SOH (Start of Heading)65
>>> n_bits_required(110)
7
22STX (Start of Text)66
>>> n_bits_required(110)
7
33ETX (End of Text)67
>>> n_bits_required(110)
7
44EOT (End of Transmission)68
>>> n_bits_required(110)
7
55ENQ (Enquiry)69
>>> n_bits_required(110)
7
66ACK (Acknowledgment)70
>>> n_bits_required(110)
7
77BEL (Bell)71
>>> n_bits_required(110)
7
88BS (Backspace)72
>>> n_bits_required(110)
7
99HT (Horizontal Tab)73
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
010LF (Line Feed)74
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
111VT (Vertical Tab)75
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
212FF (Form Feed)76
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
313CR (Carriage Return)77
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
414SO (Shift Out)78
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
515SI (Shift In)79
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
616DLE (Data Link Escape)80
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
717DC1 (Device Control 1)81
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
818DC2 (Device Control 2)82
>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128
919DC3 (Device Control 3)83
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
020DC4 (Device Control 4)84
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
121NAK (Negative Acknowledgment)85
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
222SYN (Synchronous Idle)86
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
323ETB (End of Transmission Block)87
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
424CAN (Cancel)88
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
525EM (End of Medium)89
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
626SUB (Substitute)90
>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'
727ESC (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
628FS (File Separator)92
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
729GS (Group Separator)93
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
030RS (Record Separator)94
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
131US (Unit Separator)95
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
232SP (Space)96
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
333
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
497
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
534
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
698
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
735
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
899
>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
936
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
0100
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
137
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
2101
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
338
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
4102
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
539
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
6103
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
740
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
8104
>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17
941
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
00105
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
0142
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
02106
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
0343
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
04107
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
0544
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
06108
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
0745
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
08109
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
0946
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
10110
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
1147
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
12111
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
1348
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
14112
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
1549
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
16113
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
1750
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
18114
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
1951
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
20115
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
2152
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
22116
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
2353
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
24117
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
2554
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
26118
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
2755
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
28119
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
2956
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
30120
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
3157
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
32121
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
3358
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
34122
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
3559
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
36123
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
860
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
38124
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
961
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
40125
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
4162
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
42126
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
4363
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
44127DEL (delete)

Loại bỏ các quảng cáo

Mô-đun >>> import string >>> s = "What's wrong with ASCII?!?!?" >>> s.rstrip(string.punctuation) 'What's wrong with ASCII' 45

Mô-đun Python 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
45 là một điểm dừng thuận tiện cho các hằng chuỗi nằm trong bộ ký tự ASCII

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

# From lib/python3.7/string.py

whitespace = ' \t\n\r\v\f'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_letters = ascii_lowercase + ascii_uppercase
digits = '0123456789'
hexdigits = digits + 'abcdef' + 'ABCDEF'
octdigits = '01234567'
punctuation = r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
printable = digits + ascii_letters + punctuation + whitespace

Hầu hết các hằng số này phải tự ghi lại tên định danh của chúng. Chúng tôi sẽ sớm đề cập đến những gì 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
47 và 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
48

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

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'

Ghi chú. 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
49 bao gồm tất cả 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
50. Điều này hơi khác với một phương pháp khác để kiểm tra xem một ký tự có được coi là có thể in được hay không, cụ thể là 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
51, phương pháp này sẽ cho bạn biết rằng không có ký tự nào trong số 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
52 được coi là có thể in được

Sự khác biệt tinh tế là do định nghĩa. 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
51 coi thứ gì đó có thể in được nếu “tất cả các ký tự của nó được coi là có thể in được trong 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
54. ”

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

Bây giờ là thời điểm tốt để ôn lại một chút, đơn vị thông tin cơ bản nhất mà máy tính biết

Một bit là tín hiệu chỉ có hai trạng thái có thể. Có nhiều cách khác nhau để biểu diễn một cách tượng trưng một chút mà tất cả đều có nghĩa giống nhau

  • 0 hoặc 1
  • "có hay không"
  • >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    55 hoặc 
    >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    56
  • "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ẽ chỉ 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ể biểu thị từng số trong số cơ số 10 này bằng 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 ở dạng thập phân

DecimalBinary (Compact)Binary (Padded Form)0000000000110000000121000000010311000000114100000001005101000001016110000001107111000001118100000001000910010000100110101000001010

Lưu ý rằng khi số thập phân n tăng lên, bạn cần nhiều bit quan trọng hơn để biểu thị ký tự được thiết lập và bao gồm cả số đó

Đây là một cách tiện dụng để biểu diễn các chuỗi ASCII dưới dạng 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 các khoảng trắng ở giữa các chuỗi 8 bit, mỗi ký tự đại diện cho một ký tự

>>> 

>>> 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'

Ghi chú. 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
57 đã được giới thiệu trong Python 3. 7

Chuỗi f 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
58 sử dụng Python, đây là cách chỉ định định dạng cho các trường thay thế trong chuỗi định dạng

  • Phía bên trái của dấu hai chấm, 

    >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    59, là đối tượng thực có giá trị sẽ được định dạng và chèn vào đầu ra. Sử dụng hàm Python 
    >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    60 cung cấp cho bạn điểm mã cơ sở 10 cho một ký tự 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    9

  • Phía bên tay phải của dấu hai chấm là định dạng định dạng. 

    >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    62 có nghĩa là chiều rộng 8, đệm 0 và hàm 
    >>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17
    7 như một dấu hiệu để xuất số kết quả trong cơ số 2 (nhị phân)

Thủ thuật này chủ yếu chỉ để giải trí và nó sẽ thất bại nặng nề đối với bất kỳ ký tự nào mà bạn không thấy có trong bảng ASCII. Chúng ta sẽ thảo luận về cách mã hóa khác khắc phục sự cố này sau

Loại bỏ các quảng cáo

Chúng tôi cần thêm bit

Có một công thức cực kỳ quan trọng liên quan đến định nghĩa của một bit. Cho một số bit, n, số lượng các giá trị riêng biệt có thể có có thể được biểu diễn trong n bit là 2n

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits

Đây là ý nghĩa của nó

  • 1 bit sẽ cho phép bạn thể hiện 21 == 2 giá trị có thể
  • 8 bit sẽ cho phép bạn thể hiện 28 == 256 giá trị có thể
  • 64 bit sẽ cho phép bạn thể hiện 264 == 18.446.744.073.709.551.616 giá trị có thể

Có một hệ quả tất yếu cho công thức này. được cung cấp một phạm vi các giá trị riêng biệt có thể, làm thế nào chúng ta có thể tìm thấy số bit, n, cần thiết để phạm vi được biểu diễn đầy đủ?

Đây là những gì hiệu quả

>>> 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8

Lý do bạn cần sử dụng mức trần trong 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
64 là để tính đến các giá trị không phải là lũy thừa sạch của 2. Giả sử bạn cần lưu trữ một bộ ký tự gồm 110 ký tự. Ngây thơ, điều này sẽ mất __64_______ 65 bit, nhưng không có thứ gọi là 0. 781 bit. 110 giá trị sẽ yêu cầu 7 bit, không phải 6, với các vị trí cuối cùng là không cần thiết

>>> 

>>> n_bits_required(110)
7

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

>>> 

>>> n_bits_required(128)  # 0 through 127
7
>>> n_possible_values(7)
128

Vấn đề với điều này là các máy tính hiện đại không lưu trữ nhiều thứ trong các khe cắm 7 bit. Chúng lưu lượng theo đơn vị 8 bit, thường được gọi là byte

Ghi chú. Trong suốt hướng dẫn này, tôi giả định rằng một byte đề cập đến 8 bit, như nó đã có từ những năm 1960, chứ không phải là một số đơn vị lưu trữ khác. Bạn có thể gọi đây là một octet nếu bạn thích

Điều này có nghĩa là không gian lưu trữ được sử dụng bởi ASCII trống một nửa. Nếu không rõ tại sao lại như vậy, hãy xem lại bảng thập phân sang nhị phân ở trên. Bạn có thể biểu thị các số 0 và 1 chỉ bằng 1 bit hoặc bạn có thể sử dụng 8 bit để biểu thị 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ỉ bằng 2 bit hoặc 00 đến 11 hoặc bạn có thể sử dụng 8 bit để biểu thị chúng lần lượt là 00000000, 00000001, 00000010 và 00000011. Điểm mã ASCII cao nhất, 127, chỉ yêu cầu 7 bit quan trọng

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

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
66 chuyển đổi các chuỗi ASCII thành một đại diện 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9 byte, trong đó mỗi ký tự tiêu thụ một byte

>>> 

>>> make_bitseq("bits")
'01100010 01101001 01110100 01110011'

Việc sử dụng không đúng mức các byte 8 bit của ASCII do các máy tính hiện đại cung cấp đã dẫn đến một nhóm mã hóa không chính thức, xung đột mà mỗi ký tự bổ sung được chỉ định sẽ được sử dụng với 128 điểm mã khả dụng còn lại được cho phép trong sơ đồ mã hóa ký tự 8 bit

Các mã hóa khác nhau này không chỉ xung đột với nhau mà bản thân mỗi mã hóa này vẫn là một đại diện hoàn toàn không hoàn chỉnh của các ký tự trên thế giới, bất kể thực tế là chúng đã sử dụng một bit bổ sung.

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

Loại bỏ các quảng cáo

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

Trong phần 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 khoảng từ 0 đến 127

Phạm vi số này được biểu thị bằng số thập phân (cơ số 10). Đó là cách mà bạn, tôi và phần còn lại của con người chúng ta đã quen đếm, không có lý do gì phức tạp hơn việc chúng ta có 10 ngón tay

Nhưng cũng có những hệ thống đánh số khác đặc biệt phổ biến trong toàn bộ mã nguồn CPython. Mặc dù “số bên dưới” giống nhau, nhưng tất cả các hệ thống đánh số chỉ là những cách khác nhau để biểu thị cùng một số

Nếu tôi hỏi bạn chuỗi 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
68 đại diện cho số nào, bạn sẽ có lý khi nhìn tôi một cách kỳ lạ trước khi trả lời rằng nó đại diện cho số mười một

Tuy nhiên, biểu diễn chuỗi này có thể biểu thị các số cơ bản khác nhau trong các hệ thống đánh số khác nhau. Ngoài số 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 đây

  • nhị phân. cơ sở 2
  • bát phân. cơ sở 8
  • Thập lục phân (hex). cơ sở 16

Nhưng điều đó có ý nghĩa gì đối với chúng ta khi nói rằng, trong một hệ thống đánh số nhất định, các số được biểu diễn trong cơ số N?

Đây là cách tốt nhất mà tôi biết để nói rõ điều này có nghĩa là gì. đó là số lượng ngón tay mà bạn có thể tin tưởng trong hệ thống đó

Nếu bạn muốn có phần giới thiệu đầy đủ hơn nhưng vẫn nhẹ nhàng về các hệ thống đánh số, Charles Petzold’s Code là một cuốn sách cực kỳ hay, khám phá chi tiết nền tảng của mã máy tính

Một cách để chứng minh cách các hệ thống đánh số khác nhau giải thích cùng một điều là sử dụng hàm tạo 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
69 của Python. Nếu bạn chuyển 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9 đến 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
69, Python sẽ mặc định cho rằng chuỗi biểu thị một số trong cơ số 10 trừ khi bạn nói khác đi

>>> 

>>> int('11')
11
>>> int('11', base=10)  # 10 is already default
11
>>> int('11', base=2)  # Binary
3
>>> int('11', base=8)  # Octal
9
>>> int('11', base=16)  # Hex
17

Có một cách phổ biến hơn để nói với Python rằng số nguyên của bạn được nhập vào một cơ số khác 10. Python chấp nhận các dạng chữ của mỗi trong số 3 hệ thống đánh số thay thế ở trên

Type of LiteralPrefixExamplen/an/a

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
72Binary literal
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
73 or 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
74
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
75Octal literal
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
76 or 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
77
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
78Hex literal
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
79 or 
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
80
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
81

Tất cả đều là các dạng con của số nguyên. Bạn có thể thấy rằng những điều này tạo ra kết quả tương tự, tương ứng, như các cuộc gọi đến ____64_______69 với các giá trị _______64___83 không mặc định. Tất cả họ chỉ là 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
1 đối với Python

>>> 

>>> 11
11
>>> 0b11  # Binary literal
3
>>> 0o11  # Octal literal
9
>>> 0x11  # Hex literal
17

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

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
1

DecimalBinaryOctalHex

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
14
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
87
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
88
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
89
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
16
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
91
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
92
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
93
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
18
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
95
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
96
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
97
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
20
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
75
>>> 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'
00
>>> 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'
01
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
22
>>> 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'
03
>>> 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'
04
>>> 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'
05
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
24
>>> 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'
07
>>> 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'
08
>>> 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'
09
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
26
>>> 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'
11
>>> 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'
12
>>> 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'
13
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
28
>>> 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'
15
>>> 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'
16
>>> 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'
17
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
30
>>> 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'
19
>>> 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'
20
>>> 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'
21
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
32
>>> 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'
23
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
78
>>> 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'
25
>>> 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'
26
>>> 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'
27
>>> 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'
28
>>> 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'
29
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
72
>>> 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'
31
>>> 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'
32
>>> 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'
33
>>> 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'
34
>>> 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'
35
>>> 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'
36
>>> 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'
37
>>> 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'
38
>>> 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'
39
>>> 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'
40
>>> 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'
41
>>> 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'
42
>>> 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'
43
>>> 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'
44
>>> 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'
45
>>> 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'
46
>>> 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'
47
>>> 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'
48
>>> 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'
49
>>> 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'
50
>>> 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'
51
>>> 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'
52
>>> 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'
53
>>> 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'
54
>>> 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'
55
>>> 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'
56
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
81
>>> 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'
58
>>> 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'
59
>>> 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'
60
>>> 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'
61
>>> 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'
62
>>> 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'
63
>>> 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'
64
>>> 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'
65
>>> 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'
66
>>> 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'
67
>>> 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'
68
>>> 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'
69

Số nguyên trong nguồn CPythonHiển thị/Ẩn

Thật ngạc nhiên là mức độ phổ biến của các biểu thức này trong Thư viện chuẩn Python. Nếu bạn muốn tự mình xem, hãy điều hướng đến bất kỳ vị trí nào trong thư mục 

>>> 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'
70 của bạn và kiểm tra việc sử dụng các ký tự hex như thế này

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
0

Điều này sẽ hoạt động trên bất kỳ hệ thống Unix nào có 

>>> 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'
71. Bạn có thể sử dụng 
>>> 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'
72 để tìm kiếm chữ bát phân hoặc “\b0b” để tìm kiếm chữ nhị phân

Đối số cho việc sử dụng các cú pháp văn học 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
1 thay thế này là gì? . Ba hệ thống số thay thế này đôi khi đưa ra cách thể hiện các giá trị theo cách thân thiện với máy tính. Ví dụ: số 65536 hoặc 216, chỉ là 10000 ở dạng thập lục phân hoặc 
>>> 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'
74 dưới dạng chữ thập lục phân Python

Loại bỏ các quảng cáo

Nhập Unicode

Như bạn đã thấy, vấn đề với ASCII là nó gần như không phải là một tập hợp các ký tự đủ lớn để phù hợp với tập hợp ngôn ngữ, phương ngữ, ký hiệu và nét vẽ của thế giới. (Nó thậm chí không đủ lớn cho riêng tiếng Anh. )

Unicode về cơ bản phục vụ cùng một mục đích như ASCII, nhưng nó chỉ bao gồm một cách, cách, cách tập hợp các điểm mã lớn hơn. Có một số mã hóa xuất hiện theo trình tự thời gian giữa ASCII và Unicode, nhưng chúng không thực sự đáng được đề cập vì Unicode và một trong các sơ đồ mã hóa của nó, UTF-8, đã được sử dụng chủ yếu.

Hãy nghĩ về Unicode như một phiên bản đồ sộ của bảng ASCII—một phiên bản có 1.114.112 điểm mã có thể. Đó là 0 đến 1.114.111 hoặc 0 đến 17 * (216) - 1 hoặc 

>>> 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'
75 thập lục phân. Trên thực tế, ASCII là tập hợp con hoàn hảo của Unicode. 128 ký tự đầu tiên trong bảng Unicode tương ứng chính xác với các ký tự ASCII mà bạn mong đợi một cách hợp lý.

Vì lợi ích của việc chính xác về mặt kỹ thuật, bản thân Unicode không phải là một mã hóa. Thay vào đó, Unicode được triển khai bằng các mã hóa ký tự khác nhau mà bạn sẽ sớm thấy. Unicode tốt hơn nên được coi là một bản đồ (chẳng hạn như 

>>> 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'
76) hoặc bảng cơ sở dữ liệu 2 cột. Nó ánh xạ các ký tự (như 
>>> 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'
77, 
>>> 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'
78 hoặc thậm chí 
>>> 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'
79) thành các số nguyên dương, khác biệt. Mã hóa ký tự cần cung cấp thêm một chút

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

Ghi chú. Thế giới mã hóa ký tự là một trong nhiều chi tiết kỹ thuật chi tiết mà một số người thích soi mói. Một chi tiết như vậy là chỉ có 1.111.998 điểm mã Unicode thực sự có thể sử dụng được, do một số lý do cổ xưa.

Unicode so với UTF-8

Không mất nhiều thời gian để mọi người nhận ra rằng tất cả các ký tự trên thế giới không thể gói gọn trong một byte. Rõ ràng là 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ự

Ở trên, bạn cũng đã thấy rằng Unicode về mặt kỹ thuật không phải là 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 cách lấy 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ột bảng mã. Đó là nơi UTF-8 và các sơ đồ mã hóa khác phát huy tác dụng. Tiêu chuẩn Unicode (bản đồ các ký tự tới 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ư những người anh em họ ít được sử dụng hơn của nó, UTF-16 và UTF-32, là các định dạng mã hóa để biểu thị 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 ta sẽ thảo luận về UTF-16 và UTF-32 trong giây lát, nhưng UTF-8 đã chiếm thị phần lớn nhất cho đến nay

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

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

Loại 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9 của Python 3 được dùng để biểu thị văn bản mà con người có thể đọc được và có thể chứa bất kỳ ký tự Unicode nào

Ngược lại, loại 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
0 đại diện cho dữ liệu nhị phân hoặc chuỗi các byte thô, về bản chất không có mã hóa được đính kèm với nó

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

Làm cách nào để thay đổi mã hóa của chuỗi trong python?
Mã hóa vs giải mã (Hình ảnh. Trăn thật)

Trong 

>>> 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 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'
83, tham số 
>>> 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 là 
>>> 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'
85 theo mặc định, mặc dù việc chỉ định nó thường an toàn hơn và rõ ràng hơn

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
1

Kết quả của 

>>> 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'
86 là một đối tượng. Cả ký tự byte (chẳng hạn như 
>>> 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'
88) và biểu diễn byte chỉ cho phép các ký tự ASCII

Đây là lý do tại sao, khi gọi ________123_____89, 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'
90. Chuỗi 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'
92 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'
93 ở dạng hex

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
2

Nghĩa là, ký tự 

>>> 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'
94 yêu cầu hai byte để biểu diễn nhị phân theo UTF-8

Ghi chú. Nếu bạn nhập 

>>> 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'
95, có thể bạn sẽ thấy giá trị mặc định là 
>>> 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'
96. Hãy cẩn thận khi loại trừ điều này và chỉ sử dụng 
>>> 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'
97, vì mặc định trong Windows trước Python 3. 6

Loại bỏ các quảng cáo

Trăn 3. Tất tay trên Unicode

Python 3 hoàn toàn phù hợp với Unicode và UTF-8 cụ thể. Đây là ý nghĩa của nó

  • Mã nguồn Python 3 được mặc định là UTF-8. Điều này có nghĩa là bạn không cầ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'
    98 ở đầu tệp 
    >>> 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'
    99 trong Python 3

  • Tất cả văn bản (_______0_______9) 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 (_______4_______0). Loại 

    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    9 có thể chứa bất kỳ ký tự Unicode bằng chữ nào, chẳng hạn như 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    03, tất cả sẽ được lưu trữ dưới dạng Unicode

  • , có nghĩa là 

    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    04 hợp lệ nếu điều này làm bạn thích

  • Mô-đun 

    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    05 của Python mặc định là cờ 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    06 thay vì 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    07. Điều này có nghĩa là, chẳng hạn, 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    08 khớp với các ký tự từ Unicode, không chỉ các ký tự 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'
    84 mặc định trong 
    >>> 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'
    86 và 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    11 là UTF-8

Có một thuộc tính khác có nhiều sắc thái hơn, đó là _____123_______84 mặc định cho _____________13 tích hợp sẵn phụ thuộc vào nền tảng và phụ thuộc vào giá trị của ________14

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
3

Một lần nữa, bài học ở đây là hãy cẩn thận khi đưa ra các giả định khi nói đến tính phổ biến của UTF-8, ngay cả khi đó là mã hóa chiếm ưu thế. Rõ ràng trong mã của bạn không bao giờ gây hại

Một byte, hai byte, ba byte, bốn

Một tính năng quan trọng là UTF-8 là mã hóa có độ dài thay đổi. Thật hấp dẫn để tìm hiểu điều này có nghĩa là gì, nhưng nó đáng để đi sâu vào

Nghĩ lại phần về ASCII. Mọi thứ trong vùng đất mở rộng ASCII đều yêu cầu tối đa một byte dung lượng. Bạn có thể nhanh chóng chứng minh điều này bằng biểu thức trình tạo sau

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
4

UTF-8 khá khác biệt. Một ký tự Unicode nhất định có thể chiếm bất kỳ đâu từ một đến bốn byte. Đây là một ví dụ về một ký tự Unicode duy nhất chiếm bốn byte

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
5

Đâ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
15

  • Độ dài của một ký tự Unicode dưới dạng Python 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    9 sẽ 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 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    0 sẽ nằm trong khoảng từ 1 đến 4

Bảng dưới đây tóm tắt những loại ký tự chung phù hợp với từng nhóm độ dài byte

Phạm vi thập phân Phạm vi Hex Bao gồm những gì Ví dụ 0 đến 127

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
18 đến 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
19U. S. ASCII
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
20, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
21, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
22, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
23128 to 2047
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
24 to 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
25Most Latinic alphabets*
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
26, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
27, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
28, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
292048 to 65535
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
30 to 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
31Additional parts of the multilingual plane (BMP)**
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
32, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
33, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
34, 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
3565536 to 1114111
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
36 to 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
37Other***
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
38

* Chẳng hạn như tiếng Anh, tiếng Ả Rập, tiếng Hy Lạp và tiếng Ailen
**Một lượng lớn ngôn ngữ và ký hiệu—hầu hết là tiếng Trung, tiếng Nhật và tiếng Hàn theo số lượng (cũng như bảng chữ cái ASCII và Latinh)
*** Các ký tự tiếng Trung, tiếng Nhật, tiếng Hàn và tiếng Việt bổ sung, cùng với nhiều biểu tượng và biểu tượng cảm xúc khác

Ghi chú. Để không đánh mất bức tranh toàn cảnh, có một bộ tính năng kỹ thuật bổ sung của UTF-8 không được đề cập ở đây vì chúng hiếm khi hiển thị đối với người dùng Python

Chẳng hạn, UTF-8 thực sự sử dụng các mã tiền tố cho biết số lượng byte trong một chuỗi. Điều này cho phép bộ giải mã cho biết byte nào thuộc về nhau trong mã hóa có độ dài thay đổi và cho phép byte đầu tiên đóng vai trò là chỉ báo về số lượng byte trong chuỗi tiếp theo

Bài viết UTF-8 của Wikipedia không né tránh các chi tiết kỹ thuật và luôn có Tiêu chuẩn Unicode chính thức để bạn đọc thoải mái.

Thế còn UTF-16 và UTF-32 thì sao?

Hãy quay lại với hai biến thể mã hóa khác, UTF-16 và UTF-32

Sự khác biệt giữa những điều này và UTF-8 là đáng kể trong thực tế. Dưới đây là ví dụ về mức độ khác biệt lớn với chuyển đổi khứ hồi

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
6

Trong trường hợp này, mã hóa bốn chữ cái Hy Lạp bằng UTF-8 và sau đó giải mã trở lại văn bản bằng UTF-16 sẽ tạo ra một văn bản 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9 bằng một ngôn ngữ hoàn toàn khác (tiếng Hàn)

Kết quả sai rõ ràng như thế này có thể xảy ra khi cùng một mã hóa không được sử dụng hai chiều. Hai biến thể giải mã cùng một đối 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 có thể tạo ra kết quả thậm chí không cùng ngôn ngữ

Bảng này tóm tắt phạm vi hoặc số byte theo UTF-8, UTF-16 và UTF-32

Mã hóaByte trên mỗi ký tự (Bao gồm)Độ dài thay đổiUTF-81 đến 4CóUTF-162 đến 4CóUTF-324Không

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

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
7

Lý do cho điều này là các điểm mã trong phạm vi 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
44 đến 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
45 (2048 đến 65535 ở dạng thập phân) chiếm ba byte trong UTF-8 so với chỉ hai byte trong UTF-16

Tôi hoàn toàn không khuyên bạn nên nhảy lên tàu UTF-16, bất kể bạn có hoạt động bằng ngôn ngữ có các ký 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ẽ để sử dụng UTF-8 là, trong thế giới mã hóa, đó là

Chưa kể, đó là năm 2019. bộ nhớ máy tính rẻ, vì vậy việc tiết kiệm 4 byte bằng cách sử dụng UTF-16 được cho là không đáng

Loại bỏ các quảng cáo

Các chức năng tích hợp sẵn của Python

Bạn đã vượt qua phần khó khăn. Đã đến lúc sử dụng những gì bạn đã thấy cho đến nay trong Python

Python có một nhóm các hàm tích hợp có liên quan theo một cách nào đó đến các hệ thống đánh số và mã hóa ký tự

Chúng có thể được nhóm hợp lý với nhau dựa trên mục đích của chúng

  • def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    46, 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    47, 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    50 và 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    52 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
    9. Đầu tiên, 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    46, tạo ra một đại diện duy nhất ASCII của một đối tượng, với các ký tự không phải ASCII được thoát ra. Ba phần còn lại lần lượt biểu diễn nhị phân, thập lục phân và bát phân của một số nguyên. Đây chỉ là những đại diện, không phải là một thay đổi cơ bản trong đầu vào

  • def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    48, 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    54 và 
    >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    69 là các phương thức khởi tạo lớp cho các kiểu tương ứng của 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, 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    9 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. Mỗi người đều đưa ra 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
    67 có lẽ phổ biến hơn, bạn cũng có thể thấy 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    68

  • >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    60 và 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    49 là nghịch đảo của nhau trong đó hàm 
    >>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
    60 của Python chuyển đổi một ký tự 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    9 thành điểm mã cơ sở 10 của nó, trong khi 
    def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
    49 thì ngược lại

Dưới đây là một cái nhìn chi tiết hơn về từng chức năng trong số chín chức năng này

HàmChữ kýChấp nhậnKiểu trả vềMục đích

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
46
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
75Varies_______0_______9ASCII chỉ đại diện cho một đối tượng, với các ký tự không phải ASCII được thoát
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
47
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
78
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
79
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9Biểu diễn nhị phân của một số nguyên, với tiền tố 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
81
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
48
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
83

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
84

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
85

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
86Khác nhau_______4_______0Cưỡng chế (chuyển đổi) đầu vào thành 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
0, dữ liệu nhị phân thô
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
49
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
90
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
91

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
92

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
93_______0_______9Chuyển đổi một điểm mã số nguyên thành một ký tự Unicode duy nhất
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
50
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
96
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
79
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9Biểu diễn thập lục phân của một số nguyên, với tiền tố 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
99
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
69
>>> 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
02Khác nhau
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
1Cưỡng chế (chuyển đổi) đầu vào thành 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
1
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
52
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
06
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
79
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9Biểu diễn bát phân của một số nguyên, với tiền tố 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
09
>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
60
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
11
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
12

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
13
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
1Chuyển đổi một ký tự Unicode thành điểm mã số nguyên của nó_______0_______54
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
16

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
17Khác nhau_______0_______9Cưỡng chế (chuyển đổi) đầu vào thành 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9, văn bản

Bạn có thể mở rộng phần bên dưới để xem một số ví dụ về từng chức năng

Ví dụ. ascii()Hiện/Ẩn

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
46 cung cấp cho bạn biểu diễn đối tượng chỉ ở dạng ASCII, với các ký tự không phải ASCII được thoát

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
8

Ví dụ. bin()Hiện/Ẩn

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
47 cung cấp cho bạn biểu diễn nhị phân của một số nguyên, với tiền tố 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
81

>>> 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
9

Ví dụ. bytes()Hiện/Ẩn

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
48 buộc đầu vào thành 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
0, đại diện cho dữ liệu nhị phân thô

>>> 

>>> 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'
0

Ví dụ. chr()Hiện/Ẩn

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
49 chuyển đổi một điểm mã số nguyên thành một ký tự Unicode

>>> 

>>> 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'
1

Ví dụ. hex()Hiện/Ẩn

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
50 đưa ra biểu diễn thập lục phân của một số nguyên, với tiền tố 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
99

>>> 

>>> 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'
2

Ví dụ. int()Hiện/Ẩn

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
69 ép buộc đầu vào thành 
>>> 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ùy ý diễn giải đầu vào trong một cơ sở nhất định

>>> 

>>> 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'
3

Ví dụ. ord()Hiện/Ẩn

Hàm 

>>> import string

>>> s = "What's wrong with ASCII?!?!?"
>>> s.rstrip(string.punctuation)
'What's wrong with ASCII'
60 của Python chuyển đổi một ký tự Unicode thành điểm mã số nguyên của 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'
4

Ví dụ. str()Hiện/Ẩn

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
54 ép đầu vào thành 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9, đại diện cho văn bả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'
5

Chuỗi chữ Python. Cách để lột da một con mèo

Thay vì sử dụng phương thức khởi tạo 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
54, thông thường người ta sẽ gõ một ____________9 theo nghĩa đen

>>> 

>>> 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'
6

Điều đó có vẻ đủ dễ dàng. Nhưng khía cạnh thú vị của mọi thứ là vì Python 3 hoàn toàn lấy Unicode làm trung tâm, bạn có thể “gõ” các ký tự Unicode mà bạn có thể thậm chí sẽ không tìm thấy trên bàn phím của mình. Bạn có thể sao chép và dán quyền này vào trình thông dịch viên Python 3

>>> 

>>> 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'
7

Bên cạnh việc đặt các ký tự Unicode thực tế, không thoát trong bảng điều khiển, còn có nhiều cách khác để nhập 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ề. Cá nhân tôi đã phải đọc phần này khoảng một, hai hoặc có thể chín lần để nó thực sự thấm nhuần.

Một phần của những gì nó nói là có tới 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à nhập ký 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 các phương pháp khác để nhận và đại diện cho các ký tự phát huy tác dụng. Đây là danh sách đầy đủ

Escape SequenceMeaningHow To Express 

>>> 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'
77
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
36Character with octal value 
>>> 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
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
39Character with hex value 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
40
>>> 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
42Character named 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
43 in the Unicode database
>>> 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
45Character with 16-bit (2-byte) hex value 
>>> 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
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
48Character with 32-bit (4-byte) hex value 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
49
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
50

Đây là một số bằng chứng và xác nhận ở trê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'
8

Bây giờ, có hai lưu ý chính

  1. Không phải tất cả các biểu mẫu này đều phù hợp với tất cả các ký tự. Biểu 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
    51, đơn giản là sẽ không khớp với mã thoát 2 chữ số hex 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    39. Điểm mã cao nhất mà bạn có thể đưa 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
    53 (
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    54). Tương tự như vậy đố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
    36, nó sẽ chỉ hoạt động đến 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    56 (
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    57)

  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
    58, 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    59 và 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    60, số lượng chữ số được yêu cầu chính xác như được hiển thị trong các ví dụ này. Điều này có thể khiến bạn bối rối vì cách mà các bảng Unicode thường hiển thị mã cho các ký tự, với một 
    >>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
    61 ở đầu và số lượng ký tự hex có thể thay đổi. Điều quan trọng là các bảng Unicode thường không đệm các mã này

Chẳng hạn, nếu bạn tham khảo bảng unicode. com để biết thông tin về chữ cái 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
62, 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
63

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
45 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
48?

>>> 

>>> 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'
9

Điều này cũng có nghĩa là biểu 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
48 là chuỗi thoát duy nhất có khả năng chứa bất kỳ ký tự Unicode nào

Ghi chú. Đây là một chức năng ngắn để chuyển đổi các chuỗi trông giống như 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
69 thành thứ mà Python có thể làm việc với. Nó 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
70

>>> 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
0

Loại bỏ các quảng cáo

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

Cho đến nay, bạn đã thấy bốn mã hóa ký tự

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

Có rất nhiều cá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 truyền siêu văn bản (HTTP), mỗi. Windows có biến thể Latin-1 của riêng mình được gọi là cp1252

Ghi chú. ISO-8859-1 vẫn còn rất nhiều trong tự nhiên. Thư viện 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
71 tuân theo RFC 2616 “đến từng chữ cái” trong việc sử dụng nó làm mã hóa mặc định cho nội dung của phản hồi HTTP hoặc HTTPS. Nếu từ “văn bản” được tìm thấy trong tiêu đề 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
72 và không có mã hóa nào khác được chỉ định, thì 
>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
71

Nó nằm sâu trong tài liệu về 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
74, là một phần của Thư viện chuẩn của Python

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

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
75. Nếu bạn có một 
def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
9 đã được giải mã và muốn nhanh chóng nhận được biểu diễn của chữ Unicode đã thoát của nó, thì bạn có thể chỉ định mã hóa này trong 
>>> 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

>>> 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
1

Bạn biết họ nói gì về giả định…

Chỉ vì Python đưa ra giả định mã hóa UTF-8 cho các tệp và mã mà bạn tạo không có nghĩa là bạn, lập trình viên, nên hoạt động với cùng một giả định đối với dữ liệu ngoài

Hãy nói điều đó một lần nữa bởi vì đó là một quy tắc để sống theo. khi bạn nhận được dữ liệu nhị phân (byte) từ nguồn của bên thứ ba, cho dù đó là từ tệp hay qua mạng, cách tốt nhất là kiểm tra xem dữ liệu đó có chỉ định mã hóa không. Nếu không, thì bạn phải hỏi

Tất cả I/O xảy ra theo byte, không phải văn bản và byte chỉ là số 1 và số 0 đối với máy tính cho đến khi bạn thông báo cho máy tính biết cách khác bằng cách thông báo mã hóa cho máy tính

Đây là một ví dụ về nơi mọi thứ có thể đi sai. Bạn đã đăng ký một API sẽ gửi cho bạn công thức nấu ăn trong ngày, bạn sẽ nhận được công thức này vào 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
0 và luôn giải mã bằng cách 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
79 mà không gặp vấn đề gì. Vào ngày đặc biệt này, một phần của công thức trông như thế này

>>> 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
2

Có vẻ như công thức yêu cầu một ít bột mì, nhưng chúng tôi không biết bao nhiêu

>>> 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
3

ồ ồ. Có một 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
6 phiền phức có thể cắn bạn khi bạn đưa ra các giả định về mã hóa. Bạn kiểm tra với máy chủ API. Xin thưa, dữ liệu thực sự được gửi qua mã hóa bằng tiếng Latin-1

>>> 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
4

chúng ta đi thôi. Trong , mỗi ký tự khớp với một byte đơn, trong khi ký tự “¼” chiếm hai byte trong UTF-8 (

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
81)

Bài học ở đây là có thể nguy hiểm khi giả sử mã hóa bất kỳ dữ liệu nào được chuyển cho bạn. Ngày nay, nó thường là UTF-8, nhưng đó là một tỷ lệ nhỏ các trường hợp mà nó không làm nổ tung mọi thứ

Nếu bạn thực sự cần phải bỏ tàu và đoán mã hóa, thì hãy xem thư viện 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
82, sử dụng phương pháp từ Mozilla để đưa ra phỏng đoán có cơ sở về văn bản được mã hóa mơ hồ. Điều đó nói rằng, một công 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
82 nên là phương án cuối cùng của bạn, không phải là phương án đầu tiên của bạn

Loại bỏ các quảng cáo

Vụn vặt. >>> from math import ceil, log >>> def n_bits_required(nvalues: int) -> int: .. return ceil(log(nvalues) / log(2)) >>> n_bits_required(256) 8 84

Chúng tôi sẽ thiếu sót nếu không đề cập đến 

>>> from math import ceil, log

>>> def n_bits_required(nvalues: int) -> int:
..     return ceil(log(nvalues) / log(2))

>>> n_bits_required(256)
8
84 từ Thư viện chuẩn Python, cho phép bạn tương tác và tra cứu trên Cơ sở dữ liệu ký tự Unicode (UCD)

>>> 

def n_possible_values(nbits: int) -> int:
    return 2 ** nbits
5

kết thúc

Trong bài viết này, bạn đã giải mã chủ đề rộng lớn và ấn tượng của mã hóa ký tự trong Python

Bạn đã bao phủ rất nhiều nền tảng ở đây

  • Các khái niệm cơ bản về 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 trong Python
  • Các chức năng tích hợp sẵn của Python liên quan đến hệ thống mã hóa và đánh số ký tự
  • Xử lý văn bản so với dữ liệu nhị phân của Python 3

Bây giờ, hãy tiếp tục 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. Mức tối thiểu tuyệt đối mà mọi nhà phát triển phần mềm hoàn toàn phải biết về Unicode và bộ ký tự (Không có lý do gì. )
  • David Zentgraf. Điều mà mọi lập trình viên hoàn toàn cần biết về mã hóa và bộ ký tự để làm việc với văn bản
  • mozilla. Một cách tiếp cận tổng hợp để phát hiện ngôn ngữ/mã hóa
  • Wikipedia. UTF-8
  • John Skeet. Unicode và. MẠNG LƯỚI
  • Charles Petzold. Mã số. Ngôn ngữ ẩn của phần cứng và phần mềm máy tính
  • Nhóm làm việc về mạng, RFC 3629. UTF-8, định dạng chuyển đổi của ISO 10646
  • Chuẩn kỹ thuật Unicode #18. Biểu thức chính quy Unicode

Tài liệu Python có hai trang về chủ đề này

Đánh dấu là đã hoàn thành

Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Unicode trong Python. Làm việc với mã hóa ký tự

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Làm cách nào để thay đổi mã hóa của chuỗi trong python?

Gửi cho tôi thủ thuật Python »

Giới thiệu về Brad Solomon

Làm cách nào để thay đổi mã hóa của chuỗi trong python?
Làm cách nào để thay đổi mã hóa của chuỗi trong python?

Brad là một kỹ sư phần mềm và là thành viên của Nhóm hướng dẫn Python thực sự

» Thông tin thêm về Brad

Mỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là

Làm cách nào để thay đổi mã hóa của chuỗi trong python?

Alex

Làm cách nào để thay đổi mã hóa của chuỗi trong python?

Aldren

Làm cách nào để thay đổi mã hóa của chuỗi trong python?

Joanna

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Chuyên gia Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Làm thế nào để UTF

Làm cách nào để chuyển đổi chuỗi thành UTF-8 trong Python? .
string1 = "apple" string2 = "Preeti125" string3 = "12345" string4 = "pre@12"
sợi dây. mã hóa (mã hóa = 'UTF-8', lỗi = 'nghiêm ngặt')
# chuỗi unicode string = 'pythön. ' # mã hóa mặc định thành utf-8 string_utf = string. encode() print('Phiên bản được mã hóa là. ', string_utf)

Cách chuyển đổi chuỗi thành UTF

Để chuyển đổi Chuỗi thành UTF-8, chúng tôi sử dụng phương thức getBytes() trong Java . Phương thức getBytes() mã hóa một Chuỗi thành một chuỗi byte và trả về một mảng byte. trong đó charsetName là bộ ký tự cụ thể mà Chuỗi được mã hóa thành một mảng byte.

Mã hóa =' UTF là gì

UTF-8 là một trong những bảng mã được sử dụng phổ biến nhất và Python thường mặc định sử dụng nó. UTF là viết tắt của “ Định dạng chuyển đổi Unicode ”, và '8' có nghĩa là các giá trị 8 bit được sử dụng trong mã hóa.

Làm cách nào để chuyển đổi chuỗi thành Unicode trong Python?

Cho một Chuỗi, hãy chuyển các ký tự của nó thành ký tự unicode. .
Đầu vào. test_str = 'gfg'
đầu ra. \u0067\u0066\u0067
Giải trình. Kết quả thay đổi thành chuỗi unicode
Đầu vào. test_str = 'himani'
đầu ra. \u0068\u0069\u006D\u0061\u006E\u0069
Giải trình. Kết quả thay đổi thành chuỗi unicode

programming python

Bài Viết Liên Quan

Tìm hiểu chung về văn bản nghị luận năm 2024
Tìm hiểu chung về văn bản nghị luận năm 2024

mẹo hay
Sử lý lỗi không lăng được chuột trong sketchup năm 2024
Sử lý lỗi không lăng được chuột trong sketchup năm 2024

mẹo hay Công Nghệ Chuột
Bài tập tìm hằng số cân bằng hoá 11 năm 2024
Bài tập tìm hằng số cân bằng hoá 11 năm 2024

mẹo hay Khỏe Đẹp Bài tập
Băn khoăn có nghĩa là gì năm 2024
Băn khoăn có nghĩa là gì năm 2024

là ai Hỏi Đáp Là gì Ngôn ngữ Nghĩa là gì
Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024
Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024

mẹo hay
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Món Ngon Bánh
Họ tiếng nhật của bạn là gì năm 2024
Họ tiếng nhật của bạn là gì năm 2024

là ai Hỏi Đáp Là gì
Ý nghĩa của header from top là gì năm 2024
Ý nghĩa của header from top là gì năm 2024

mẹo hay Hỏi Đáp Là gì Top List Top Header la gì Footer la gì
Tự học tiếng anh như thế nào hiệu quả năm 2024
Tự học tiếng anh như thế nào hiệu quả năm 2024

mẹo hay Hỏi Đáp Thế nào Học Tốt Học Tiếng anh Học tiếng Anh
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Khỏe Đẹp Cơ thể
Tuổi đinh mão xây nhà năm nào tốt năm 2024
Tuổi đinh mão xây nhà năm nào tốt năm 2024

mẹo hay Xây Đựng Xây Nhà
Khoán chi đến sản phẩm cuối cùng là gì năm 2024
Khoán chi đến sản phẩm cuối cùng là gì năm 2024

là ai Hỏi Đáp Là gì
Các yếu tố cấu thành văn hóa tổ chức năm 2024
Các yếu tố cấu thành văn hóa tổ chức năm 2024

mẹo hay
Thế nào là số vô tỉ cho ví dụ năm 2024
Thế nào là số vô tỉ cho ví dụ năm 2024

mẹo hay Hỏi Đáp Thế nào Ví dụ
Quà trung thu tiếng anh là gì năm 2024
Quà trung thu tiếng anh là gì năm 2024

là ai Hỏi Đáp Là gì Học Tốt Tiếng anh Mid-Autumn gift
Đẻ mổ tối đa được bao nhiêu lần năm 2024
Đẻ mổ tối đa được bao nhiêu lần năm 2024

bao nhieu Hỏi Đáp Bao nhiêu
Thiết kế quán trà sữa bao nhiêu tiền năm 2024
Thiết kế quán trà sữa bao nhiêu tiền năm 2024

bao nhieu Hỏi Đáp Bao nhiêu Món Ngon Trà sữa
Top nước hoa hồng se khít lỗ chân lông năm 2024
Top nước hoa hồng se khít lỗ chân lông năm 2024

mẹo hay Top List Top
Lỗi nồi chiên không dầu philips tiếng kêu rất to năm 2024
Lỗi nồi chiên không dầu philips tiếng kêu rất to năm 2024

mẹo hay
Daylight is coming like a rentless milkman upstairs là gì năm 2024
Daylight is coming like a rentless milkman upstairs là gì năm 2024

là ai Hỏi Đáp Là gì

Quảng Cáo

Có thể bạn quan tâm

Bóng đèn cực tím 1m2 công suất bao nhiêu watt năm 2024
1 tháng trước . bởi TrackingTrilogy
Cơ sở của giá trị hàng hóa là gì năm 2024
1 tháng trước . bởi Fast-foodLineage
Cách sửa lỗi trong speakers properties ko hiện enhancement năm 2024
1 tháng trước . bởi MilitaryTracing
Giải bài tập toán lớp 5 tập 2 bài 163 năm 2024
1 tháng trước . bởi ThoughtlessEnclosure
Miracle in cell number 7 review năm 2024
1 tháng trước . bởi UndeniableFiring
Mục tiêu bài học chi tiết đánh giá được năm 2024
1 tháng trước . bởi ThunderousFlask
Asias next top model 5 tap 6 năm 2024
1 tháng trước . bởi HorribleBattling
Cầu gỗ lim huế bao nhiêu tiền năm 2024
1 tháng trước . bởi YieldingSwimmer
Cân bằng sinh học là gì cho ví dụ năm 2024
1 tháng trước . bởi UmbilicalProceeding
Tổng hợp kiến thức toán ôn thi đại học năm 2024
1 tháng trước . bởi ImpossibleEquation

Toplist được quan tâm

#1
Top 7 sự tích hồ gươm - ngữ văn lớp 6 2023
5 tháng trước
#2
Top 7 gdcd 6 bài 1 kết nối tri thức 2023
5 tháng trước
#3
Top 7 ý nghĩa của xây dựng gia đình văn hóa 2023
5 tháng trước
#4
Top 6 mẫu hợp đồng mượn đất làm nhà xưởng 2023
5 tháng trước
#5
Top 3 tổng tài biến thái tôi yêu anh tập 27 2023
5 tháng trước
#6
Top 6 kết thực phim mỹ nhân vô lệ 2023
5 tháng trước
#7
Top 9 trong những câu thơ sau câu nào sử dụng thành ngữ 2023
5 tháng trước
#8
Top 8 đề tài và chủ de của tác phẩm tắt đèn 2023
5 tháng trước
#9
Top 5 tiểu sử của thầy thích pháp hòa 2023
5 tháng trước

Quảng cáo

Xem Nhiều

Hệ số lương 1.78 tương ứng ngạch nào năm 1996 năm 2024
5 ngày trước
Bánh rau câu sinh nhật chứa bao nhiêu calo năm 2024
1 tuần trước
Tự học tiếng anh như thế nào hiệu quả năm 2024
1 tuần trước
Bài tập tìm hằng số cân bằng hoá 11 năm 2024
3 ngày trước
Họ tiếng nhật của bạn là gì năm 2024
1 tuần trước
Băn khoăn có nghĩa là gì năm 2024
4 ngày trước
Tìm hiểu chung về văn bản nghị luận năm 2024
2 ngày trước
Anh bộ đội cụ hồ gốc bỉ là gì năm 2024
1 ngày trước
Cơ thể con người năm hiến máu bao nhiêu lần năm 2024
1 tuần trước
Ý nghĩa của header from top là gì năm 2024
1 tuần trước

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

DMCA.com Protection Status
Bản quyền © 2021 Học Tốt Inc.