Преобразовать байты в строку

Мы можем декодировать объект bytes для создания строки, используя bytes.decode(encoding='utf-8', errors='strict') Для документации. Нажмите здесь

Python3 пример:

byte_value = b"abcde"
print("Initial value = {}".format(byte_value))
print("Initial value type = {}".format(type(byte_value)))
string_value = byte_value.decode("utf-8")
# utf-8 is used here because it is a very common encoding, but you need to use the encoding your data is actually in.
print("------------")
print("Converted value = {}".format(string_value))
print("Converted value type = {}".format(type(string_value)))

Вывод:

Initial value = b'abcde'
Initial value type = <class 'bytes'>
------------
Converted value = abcde
Converted value type = <class 'str'>

ПРИМЕЧАНИЕ. В Python3 тип кодировки по умолчанию — utf-8. Таким образом, <byte_string>.decode("utf-8") можно также записать как <byte_string>.decode()

вы хотите декодировать байт в строку

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

Если у вас возникла эта ошибка:

'кодек utf-8 не может декодировать байт 0x8a'

, то для преобразования байтов в строку лучше использовать следующий код:

bytes = b"abcdefg"
string = bytes.decode("utf-8", "ignore") 

Наслаждайтесь!

Декодировать с помощью .decode(). Это расшифрует строку. Передайте 'utf-8') как внутреннее значение.

Попробуйте использовать этот; эта функция игнорирует все двоичные файлы без набора символов (например, utf-8) и возвращает чистую строку. Он протестирован на python3.6 и выше.

def bin2str(text, encoding = 'utf-8'):
    """Converts a binary to Unicode string by removing all non Unicode char
    text: binary string to work on
    encoding: output encoding *utf-8"""

    return text.decode(encoding, 'ignore')

Здесь функция принимает двоичный файл и декодирует его (преобразует двоичные данные в символы с использованием предопределенного набора символов Python, а аргумент ignore игнорирует все данные, не являющиеся набором символов, из вашего двоичного файла и, наконец, возвращает желаемое значение string .

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

попробуйте это

bytes.fromhex('c3a9').decode('utf-8') 

Для вашего конкретного случая «запустить команду оболочки и получить ее вывод в виде текста вместо байтов» в 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's stdout

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

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

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 МБ.

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

Поскольку этот вопрос на самом деле касается вывода subprocess, у вас есть более прямые подходы. Самым современным было бы использование subprocess.check_output и передача text=True (Python 3.7+) для автоматического декодирования stdout с использованием системной кодировки по умолчанию:

text = subprocess.check_output(["ls", "-l"], text=True)

Для Python 3.6, Popen принимает кодировку ключевое слово:

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

При работе с данными из систем 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)

скопирует исходный файл.

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

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

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

>>> my_byte_str
b'Hello World'

>>> str(my_byte_str, 'utf-8')
'Hello World'

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

def byte_to_str(bytes_or_str):
    if isinstance(bytes_or_str, bytes): # Check if it's 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

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

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, которые могут содержать символы Unicode, отличные от ASCII, в строку Python

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

b'hello'.decode()

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

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

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

b'hello'.decode(encoding)

, где encoding - желаемая кодировка.

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

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

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

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

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

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

command_stdout.decode()

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

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

Если вы не знаете кодировку, то для чтения двоичного ввода в строку в 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'))

Подробнее см. Поддержка Unicode в Python .

ОБНОВЛЕНИЕ 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'))

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

command_stdout = Popen(['ls', '-l'], stdout=PIPE, universal_newlines=True).communicate()[0]

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

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

Думаю, это простой способ:

>>> bytes_data = [112, 52, 52]
>>> "".join(map(chr, bytes_data))
'p44'

Думаю, вам действительно нужно это:

>>> 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 (или прочитать ее здесь).

Вам необходимо декодировать байтовую строку и преобразовать ее в символьную строку (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)