Hướng dẫn how do i print raw data in python? - làm cách nào để in dữ liệu thô trong python?

Xin hãy cẩn thận rằng vấn đề được xác định không rõ ràng. Hàm

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

1 tích hợp sẽ cung cấp cho bạn biểu diễn chính tắc của chuỗi dưới dạng chuỗi theo nghĩa đen, như thể hiện trong các câu trả lời khác. Tuy nhiên, đó có thể không phải là những gì bạn muốn.

Đối với mỗi chuỗi ngoại trừ chuỗi trống, có nhiều cách chỉ định nội dung chuỗi. Ngay cả một cái gì đó đơn giản như

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

2 có thể được viết là

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

3 hoặc

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

4 hoặc

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

5. Tất cả những thứ này là cùng một chuỗi (và đó là bỏ qua sự lựa chọn của các trích dẫn kèm theo).the same string (and that's ignoring the choice of enclosing quotes).

Sự lựa chọn của Python không phải lúc nào cũng là những gì bạn có thể mong đợi. Newlines sẽ được biểu diễn dưới dạng

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

6, nhưng các ký tự backspace chẳng hạn sẽ được biểu diễn dưới dạng mã hex, không phải là

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

7. Mặt khác, ngay cả những nhân vật thực sự lạ mắt như biểu tượng cảm xúc rất có thể được bao gồm theo nghĩa đen, không trốn thoát.not as

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

7. On the other hand, even really fancy characters like emoji may very well be included literally, not escaped.

---

Nếu bạn muốn thay đổi hành vi đó, bạn sẽ phải tự viết nó, sau khi xác định các quy tắc cụ thể bạn muốn áp dụng. Một công cụ hữu ích cho việc này là phương thức chuỗi

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

8, có thể chỉ cần áp dụng ánh xạ cho từng điểm mã Unicode trong đầu vào. Chuỗi ClassMethod

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

9 có thể giúp tạo ra một ánh xạ như vậy, nhưng điều đó vẫn không đủ sức mạnh - bạn bị mắc kẹt khi đưa ra một bộ mã cụ thể để dịch (và bản dịch của chúng), và sau đó mọi thứ không được chỉ định đều chỉ còn lại.

Nếu bạn muốn chuyển đổi một lượng lớn điểm mã theo cách theo một loại mẫu nào đó, bạn có thể viết một hàm cho điều đó. Tuy nhiên, việc xử lý các trường hợp đặc biệt hoặc nhiều khối riêng của các điểm mã Unicode, có thể kết thúc với rất nhiều logic phân nhánh tẻ nhạt.

Đây là nỗ lực của tôi để có được những điều tốt nhất của cả hai thế giới. Chúng tôi tạo một lớp con Dict thực hiện

s = 'Hi\nHello'
print(s)

0 để gửi đến một chức năng xử lý một phạm vi ký tự thích hợp và lưu trữ kết quả. Chúng tôi khởi tạo nó bằng một bản đồ hoặc ánh xạ của các giá trị được mã hóa cứng (theo hàm cơ sở

s = 'Hi\nHello'
print(s)

1),

s = 'Hi\nHello'
print(s)

2 cung cấp các cặp ____23 (

s = 'Hi\nHello'
print(s)

4 sẽ được sử dụng để tính toán kết quả cho các ký tự có giá trị số rơi trong

s = 'Hi\nHello'
print(s)

5) và

s = 'Hi\nHello'
print(s)

6 Một lần nữa theo hàm cơ sở

s = 'Hi\nHello'
print(s)

1). Chúng tôi sẽ chấp nhận các ký tự Unicode làm khóa, mặc dù

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

8 sẽ vượt qua các giá trị điểm mã số; Vì vậy, chúng tôi cũng cần dịch trong hàm tạo.

class strtrans(dict):
    def __init__(self, iterable_or_mapping, *args, **kwargs):
        self._handlers = args
        temp = dict(iterable_or_mapping, **kwargs)
        super().__init__({ord(k): v for k, v in temp.items()})
    def __missing__(self, value):
        self[value] = value # if no handler, leave the character untouched
        for func, r in self._handlers:
            if value in r:
                self[value] = func(value)
                break
        return self[value] # not missing any more.

Hãy kiểm tra nó:

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

Chuỗi RAW Python được tạo bằng tiền tố một chuỗi theo nghĩa đen với ‘r, hoặc‘ r. Chuỗi thô Python coi Backslash (\) là một ký tự theo nghĩa đen. Điều này rất hữu ích khi chúng tôi muốn có một chuỗi chứa dấu gạch chéo ngược và don không muốn nó được coi là một nhân vật thoát.

Chuỗi Raw Python

Hãy nói rằng chúng tôi muốn tạo một chuỗi hi \ nhello trong Python. Nếu chúng ta cố gắng gán nó cho một chuỗi bình thường, \ n sẽ được coi là một dòng mới.Hi\nHello in python. If we try to assign it to a normal string, the \n will be treated as a new line.

s = 'Hi\nHello'
print(s)

Đầu ra:

Hi
Hello

Hãy cùng xem chuỗi RAW giúp chúng ta coi việc đánh dấu dấu gạch chéo ngược như một nhân vật bình thường như thế nào.

raw_s = r'Hi\nHello'
print(raw_s)

Đầu ra:

s = 'Hi\nHello'
print(s)

9 Hãy để xem một ví dụ khác trong đó nhân vật theo sau là dấu gạch chéo ngược không có ý nghĩa đặc biệt nào.

>>> s = 'Hi\xHello'
  File "", line 1
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \xXX escape

Chúng tôi đã gặp lỗi vì Python không biết cách giải mã ‘\ x, vì nó không có ý nghĩa đặc biệt nào. Hãy để xem cách chúng ta có thể tạo cùng một chuỗi bằng các chuỗi thô.

>>> s = r'Hi\xHello'
>>> print(s)
Hi\xHello

Nếu bạn đang ở trên bảng điều khiển Python và tạo một chuỗi thô như dưới đây.

>>> r'Hi\xHello'
'Hi\\xHello'

Don Tiết bị nhầm lẫn với đầu ra có hai dấu gạch chéo ngược. Nó chỉ để hiển thị nó như một chuỗi Python bình thường, trong đó dấu gạch chéo ngược đang bị thoát ra.

Chuỗi và trích dẫn Python Raw

Khi một dấu gạch chéo ngược được theo sau bởi một trích dẫn trong một chuỗi thô, nó đã thoát ra. Tuy nhiên, dấu gạch chéo ngược cũng vẫn còn trong kết quả. Vì tính năng này, chúng tôi có thể tạo ra một chuỗi RAW của dấu gạch chéo ngược. Ngoài ra, một chuỗi thô có thể có một số ít các dấu gạch chéo ngược ở cuối. Một số chuỗi thô không hợp lệ là:

r'\'  # missing end quote because the end quote is being escaped
r'ab\\\'  # first two backslashes will escape each other, the third one will try to escape the end quote.

Hãy cùng xem xét một số ví dụ chuỗi thô hợp lệ với các trích dẫn.

raw_s = r'\''
print(raw_s)

raw_s = r'ab\\'
print(raw_s)

raw_s = R'\\\"'  # prefix can be 'R' or 'r'
print(raw_s)

Output:

>>> hardcoded = {'\n': '\\n', '\t': '\\t', '\b': '\\b'}
>>> # Using the `.format` method bound to a string is a quick way
>>> # to get a callable that accepts the input number and formats it in.
>>> # For uppercase, use :02X instead of :02x etc.
>>> backslash_x = ('\\x{:02x}'.format, range(256))
>>> backslash_u = ('\\u{:04x}'.format, range(256, 65536))
>>> backslash_U = ('\\U{:08x}'.format, range(65536, 0x110000))
>>> mapping = strtrans(hardcoded, backslash_x, backslash_u, backslash_U)
>>> test = '\n\t\b\x01\u4EBA\U0001F60A'
>>> print(test.translate(mapping)) # custom behaviour - note lowercase output
\n\t\b\x01\u4eba\U0001f60a
>>> print(repr(test)) # canonical representation, with enclosing quotes
'\n\t\x08\x01人😊'
>>> print(test) # your terminal's rendering may vary!

       人😊

0

Đó là tất cả để giới thiệu nhanh chuỗi Raw Python.

Bạn có thể kiểm tra toàn bộ tập lệnh Python và nhiều ví dụ về Python từ Kho lưu trữ GitHub của chúng tôi.

Làm thế nào để bạn in một biến chuỗi trong Python Raw?

Làm thế nào để bạn nhập dữ liệu thô vào Python?

%S và %d có nghĩa là gì trong Python?

Làm thế nào để bạn in các chuỗi thô trong Python mà không có báo giá?