Конвертировать байты в строку

Я использую этот код для получения стандартного вывода из внешней программы:

>>> from subprocess import *
>>> command_stdout = Popen(['ls', '-l'], stdout=PIPE).communicate()[0]

Метод connect() возвращает массив байтов:

>>> command_stdout
b'total 0\n-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file1\n-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file2\n'

Однако я бы хотел работать с выводом как с обычной строкой Python. Чтобы я мог напечатать это так:

>>> print(command_stdout)
-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file1
-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file2

Я думал, что для этого нужен метод binascii.b2a_qp(), но когда я попробовал его, я снова получил тот же байтовый массив:

>>> binascii.b2a_qp(command_stdout)
b'total 0\n-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file1\n-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file2\n'

Как мне преобразовать значение байта обратно в строку? Я имею в виду, используя "батареи" вместо того, чтобы делать это вручную. И я бы хотел, чтобы с Python 3 все было в порядке.

+1873
источник поделиться
19 ответов

Вам необходимо декодировать объект байтов для создания строки:

>>> b"abcde"
b'abcde'

# utf-8 is used here because it is a very common encoding, but you
# need to use the encoding your data is actually in.
>>> b"abcde".decode("utf-8") 
'abcde'
+3051
источник

Вам необходимо декодировать строку байтов и превратить ее в символьную строку (Unicode).

На Python 2

encoding = 'utf-8'
'hello'.decode(encoding)

или

unicode('hello', encoding)

На Python 3

encoding = 'utf-8'
b'hello'.decode(encoding)

или

str(b'hello', encoding)
+170
источник
другие ответы

Связанные вопросы


Похожие вопросы

Я думаю, что так легко

bytes_data = [112, 52, 52]
"".join(map(chr, bytes_data))
>> p44
+158
источник

Если вы не знаете кодировку, то для чтения двоичного ввода в строку в Python 3 и Python 2-совместимом способе используйте древнюю MS-DOS CP437 кодировку:

PY3K = sys.version_info >= (3, 0)

lines = []
for line in stream:
    if not PY3K:
        lines.append(line)
    else:
        lines.append(line.decode('cp437'))

Поскольку кодировка неизвестна, ожидайте, что неанглийские символы будут переводиться в символы cp437 (английские символы не переводятся, поскольку они совпадают в большинстве однобайтовых кодировок и UTF-8).

Декодировать произвольный двоичный ввод в UTF-8 небезопасно, потому что вы можете получить это:

>>> b'\x00\x01\xffsd'.decode('utf-8')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 2: invalid
start byte

То же самое относится к latin-1, который был популярен (по умолчанию?) для Python 2. Посмотрите недостающие точки в Макете кодовой страницы - именно там Python задыхается от дурной славы ordinal not in range.

ОБНОВЛЕНИЕ 20150604: Ходят слухи, что в Python 3 существует стратегия ошибок surrogateescape для кодирования содержимого в двоичные данные без потери данных и сбоев, но для проверки производительности и надежности необходимы тесты преобразования, [binary] -> [str] -> [binary].

ОБНОВЛЕНИЕ 20170116: Благодаря комментарию Nearoo - также есть возможность сократить все неизвестные байты с помощью обработчика ошибок backslashreplace. Это работает только для Python 3, поэтому даже при таком обходном пути вы все равно получите противоречивый вывод из разных версий Python:

PY3K = sys.version_info >= (3, 0)

lines = []
for line in stream:
    if not PY3K:
        lines.append(line)
    else:
        lines.append(line.decode('utf-8', 'backslashreplace'))

Подробнее см. в поддержке Юникода Pythons.

ОБНОВЛЕНИЕ 20170119: я решил внедрить декодирование с косой чертой, работающее как для Python 2, так и для Python 3. Оно должно быть медленнее, чем решение cp437, но оно должно давать идентичные результаты для каждой версии Python.

# --- preparation

import codecs

def slashescape(err):
    """ codecs error handler. err is UnicodeDecode instance. return
    a tuple with a replacement for the unencodable part of the input
    and a position where encoding should continue"""
    #print err, dir(err), err.start, err.end, err.object[:err.start]
    thebyte = err.object[err.start:err.end]
    repl = u'\\x'+hex(ord(thebyte))[2:]
    return (repl, err.end)

codecs.register_error('slashescape', slashescape)

# --- processing

stream = [b'\x80abc']

lines = []
for line in stream:
    lines.append(line.decode('utf-8', 'slashescape'))
+77
источник

В Python 3 кодировкой по умолчанию является "utf-8", поэтому вы можете напрямую использовать:

b'hello'.decode()

что эквивалентно

b'hello'.decode(encoding="utf-8")

С другой стороны, в Python 2 кодировка по умолчанию соответствует строковому кодированию по умолчанию. Таким образом, вы должны использовать:

b'hello'.decode(encoding)

где encoding - нужная кодировка.

Примечание: поддержка аргументов ключевых слов была добавлена в Python 2.7.

+69
источник

Я думаю, что вы действительно хотите это:

>>> from subprocess import *
>>> command_stdout = Popen(['ls', '-l'], stdout=PIPE).communicate()[0]
>>> command_text = command_stdout.decode(encoding='windows-1252')

Ответ аарона был верным, за исключением того, что вам нужно знать, какую кодировку использовать. И я считаю, что Windows использует "Windows-1252". Это имеет значение только в том случае, если в вашем контенте есть какие-то необычные (не ASCII) символы, но тогда это изменит ситуацию.

Кстати, тот факт, что это имеет значение, является причиной того, что Python перешел на использование двух разных типов для двоичных и текстовых данных: он не может магически преобразовывать между ними, потому что он не знает кодировку, пока вы не скажете это! Единственный способ узнать это - прочитать документацию по Windows (или прочитать ее здесь).

+38
источник

Установите universal_newlines в значение True, то есть

command_stdout = Popen(['ls', '-l'], stdout=PIPE, universal_newlines=True).communicate()[0]
+29
источник

Хотя ответ @Aaron Maenpaa просто работает, недавно пользователь спросил:

Есть ли более простой способ? 'fhand.read(). decode ("ASCII")' [...] Это так долго!

Ты можешь использовать:

command_stdout.decode()

decode() имеет стандартный аргумент:

codecs.decode(obj, encoding='utf-8', errors='strict')

+19
источник

Поскольку этот вопрос фактически задает вопрос о выводе subprocess, у вас есть более прямой подход, поскольку Popen принимает ключевое слово кодирования (в Python 3. 6+):

>>> from subprocess import Popen, PIPE
>>> text = Popen(['ls', '-l'], stdout=PIPE, encoding='utf-8').communicate()[0]
>>> type(text)
str
>>> print(text)
total 0
-rw-r--r-- 1 wim badger 0 May 31 12:45 some_file.txt

Общий ответ для других пользователей - декодировать байты в текст:

>>> b'abcde'.decode()
'abcde'

Без аргументов будет использоваться sys.getdefaultencoding(). Если ваши данные не sys.getdefaultencoding(), то вы должны явно указать кодировку в вызове decode:

>>> b'caf\xe9'.decode('cp1250')
'café'
+15
источник

Чтобы интерпретировать последовательность байтов как текст, вы должны знать соответствующая кодировка символов:

unicode_text = bytestring.decode(character_encoding)

Пример:

>>> b'\xc2\xb5'.decode('utf-8')
'µ'

Команда ls может выдавать вывод, который нельзя интерпретировать как текст. Имена файлов в Unix может быть любая последовательность байтов, кроме слэша b'/' и нуля b'\0':

>>> open(bytes(range(0x100)).translate(None, b'\0/'), 'w').close()

Попытка декодировать такой суппорт байтов с использованием кодировки utf-8 повышает UnicodeDecodeError.

Это может быть хуже. Декодирование может завершиться сбоем молча и вызвать моджибаке если вы используете неправильную несовместимую кодировку:

>>> '—'.encode('utf-8').decode('cp1252')
'â€''

Данные повреждены, но ваша программа не знает о сбое произошло.

В общем, какая кодировка символов не используется в самой последовательности байтов. Вы должны сообщить эту информацию вне группы. Некоторые результаты более вероятны, чем другие, и поэтому существует модуль chardet, который может угадать кодировку символов. Один скрипт Python может использовать несколько кодировок символов в разных местах.


Вывод ls можно преобразовать в строку Python, используя os.fsdecode() функция, которая преуспевает даже для неразборчивого имена файлов (используется sys.getfilesystemencoding() и surrogateescape обработчик ошибок включен Unix):

import os
import subprocess

output = os.fsdecode(subprocess.check_output('ls'))

Чтобы получить оригинальные байты, вы можете использовать os.fsencode().

Если вы передадите параметр universal_newlines=True, то subprocess использует locale.getpreferredencoding(False) для декодирования байтов, например, это может быть cp1252 в Windows.

Чтобы декодировать поток байтов на лету, io.TextIOWrapper() можно использовать: пример.

Различные команды могут использовать разные кодировки символов для своих например, внутренняя команда dir (cmd) может использовать cp437. Расшифровать его вывод, вы можете передать кодировку явно (Python 3. 6+):

output = subprocess.check_output('dir', shell=True, encoding='cp437')

Имена файлов могут отличаться от os.listdir() (который использует Windows Unicode API), например, '\xb6' можно заменить на '\x14' - Python's кодек cp437 отображает b'\x14' на управляющий символ U + 0014 вместо U + 00B6 (¶). Для поддержки имен файлов с произвольными символами Unicode см. Декодирование вывода PowerShell, возможно, содержащего символы не-ASCII Unicode, в строку Python

+13
источник

Если вы хотите получить следующее, попробовав decode():

AttributeError: у объекта 'str' нет атрибута 'decode'

Вы также можете указать тип кодировки прямо в приведении:

>>> my_byte_str
b'Hello World'

>>> str(my_byte_str, 'utf-8')
'Hello World'
+8
источник

При работе с данными из систем Windows (с окончанием строки \r\n) мой ответ:

String = Bytes.decode("utf-8").replace("\r\n", "\n")

Зачем? Попробуйте это с многострочным Input.txt:

Bytes = open("Input.txt", "rb").read()
String = Bytes.decode("utf-8")
open("Output.txt", "w").write(String)

Все окончания вашей строки будут удвоены (до \r\r\n), что приведет к лишним пустым строкам. Функции чтения текста в Python обычно нормализуют окончания строк, поэтому в строках используется только \n. Если вы получаете двоичные данные из системы Windows, у Python нет шансов сделать это. Таким образом,

Bytes = open("Input.txt", "rb").read()
String = Bytes.decode("utf-8").replace("\r\n", "\n")
open("Output.txt", "w").write(String)

будет копировать ваш оригинальный файл.

+5
источник

Я сделал функцию для очистки списка

def cleanLists(self, lista):
    lista = [x.strip() for x in lista]
    lista = [x.replace('\n', '') for x in lista]
    lista = [x.replace('\b', '') for x in lista]
    lista = [x.encode('utf8') for x in lista]
    lista = [x.decode('utf8') for x in lista]

    return lista
+4
источник

Из sys - Системные параметры и функции:

Для записи или чтения двоичных данных из/в стандартные потоки используйте базовый двоичный буфер. Например, чтобы записать байты в стандартный вывод, используйте sys.stdout.buffer.write(b'abc').

+2
источник

Для Python 3 это гораздо более безопасный и питонский подход для преобразования из byte в string:

def byte_to_str(bytes_or_str):
    if isinstance(bytes_or_str, bytes): # Check if it in bytes
        print(bytes_or_str.decode('utf-8'))
    else:
        print("Object not of byte type")

byte_to_str(b'total 0\n-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file1\n-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file2\n')

Выход:

total 0
-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file1
-rw-rw-r-- 1 thomas thomas 0 Mar  3 07:03 file2
+2
источник
def toString(string):    
    try:
        return v.decode("utf-8")
    except ValueError:
        return string

b = b'97.080.500'
s = '97.080.500'
print(toString(b))
print(toString(s))
+1
источник

Если вы хотите преобразовать любые байты, а не просто строку, преобразованную в байты:

with open("bytesfile", "rb") as infile:
    str = base64.b85encode(imageFile.read())

with open("bytesfile", "rb") as infile:
    str2 = json.dumps(list(infile.read()))

Однако это не очень эффективно. Это превратит изображение 2 МБ в 9 МБ.

+1
источник

Я сделал функцию для очистки списка

def cleanLists(self, lista):
    lista = [x.strip() for x in lista]
    lista = [x.replace('\n', '') for x in lista]
    lista = [x.replace('\b', '') for x in lista]
    lista = [x.encode('utf8') for x in lista]
    lista = [x.decode('utf8') for x in lista]

    return lista
0
источник

Для вашего конкретного случая "запустить команду оболочки и получить ее вывод в виде текста вместо байтов", в Python 3.7 вы должны использовать subprocess.run и передать text=True (а также capture_output=True чтобы захватить вывод)

command_result = subprocess.run(["ls", "-l"], capture_output=True, text=True)
command_result.stdout  # is a 'str' containing your program stdout

text раньше назывался universal_newlines и был изменен (хорошо, с псевдонимом) в Python 3.7. Если вы хотите поддерживать версии Python до 3.7, передайте universal_newlines=True вместо text=True

0
источник

Посмотрите другие вопросы по меткам или Задайте вопрос