Converter bytes em uma sequência

Estou usando esse código para obter saída padrão de um programa externo:

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

O método communic () retorna uma matriz de bytes:

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

No entanto, eu gostaria de trabalhar com a saída como uma string Python normal. Para que eu pudesse imprimi-lo assim:

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

Eu pensei que é para isso que serve o método binascii.b2a_qp () , mas quando tentei, obtive a mesma matriz de bytes novamente:

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

Como faço para converter o valor de bytes novamente em string? Quero dizer, usando as "baterias" em vez de fazê-lo manualmente. E eu gostaria que tudo estivesse bem com o Python 3.

Você precisa decodificar o objeto bytes para produzir uma string:

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

Você precisa decodificar a sequência de bytes e transformá-la em uma sequência de caracteres (Unicode).

No Python 2

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

ou

unicode('hello', encoding)

No Python 3

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

ou

str(b'hello', encoding)

Eu acho assim fácil:

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

Se você não conhece a codificação, para ler a entrada binária na cadeia de caracteres de maneira compatível com Python 3 e Python 2, use a antiga codificação CP437 do MS-DOS :

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

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

Como a codificação é desconhecida, espere que símbolos não ingleses sejam traduzidos para caracteres de cp437(caracteres ingleses não são traduzidos, porque correspondem na maioria das codificações de byte único e UTF-8).

A decodificação de entrada binária arbitrária para UTF-8 não é segura, pois você pode obter o seguinte:

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

O mesmo se aplica a latin-1, que era popular (o padrão?) Para o Python 2. Veja os pontos que faltam no Codepage Layout - é onde o Python se engasga com o famoso ordinal not in range.

ATUALIZAÇÃO 20150604 : Há rumores de que o Python 3 tem a surrogateescapeestratégia de erro para codificar coisas em dados binários sem perda de dados e falhas, mas precisa de testes de conversão [binary] -> [str] -> [binary]para validar o desempenho e a confiabilidade.

ATUALIZAÇÃO 20170116 : Graças ao comentário de Nearoo - também há a possibilidade de cortar com escape todos os bytes desconhecidos com o backslashreplacemanipulador de erros. Isso funciona apenas para o Python 3, portanto, mesmo com essa solução alternativa, você ainda terá resultados inconsistentes de diferentes versões do 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'))

Veja Suporte Unicode do Python para obter detalhes.

ATUALIZAÇÃO 20170119 : Decidi implementar a decodificação de escape de barra que funciona tanto para o Python 2 quanto para o Python 3. Deve ser mais lento que a cp437solução, mas deve produzir resultados idênticos em todas as versões do 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'))

No Python 3 , a codificação padrão é "utf-8", então você pode usar diretamente:

b'hello'.decode()

que é equivalente a

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

Por outro lado, no Python 2 , a codificação é padronizada com a codificação de string padrão. Portanto, você deve usar:

b'hello'.decode(encoding)

onde encodingestá a codificação que você deseja.

Nota: o suporte a argumentos de palavras-chave foi adicionado no Python 2.7.

Eu acho que você realmente quer isso:

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

A resposta de Aaron estava correta, exceto que você precisa saber qual codificação usar. E eu acredito que o Windows usa 'windows-1252'. Só importa se você tiver alguns caracteres incomuns (não ASCII) em seu conteúdo, mas isso fará a diferença.

By the way, o fato de que ele faz questão é a razão que Python se mudou para usando dois tipos diferentes de dados binários e texto: não pode converter magicamente entre eles, porque não sei a codificação, a menos que você diga a ele! A única maneira que você saberia é ler a documentação do Windows (ou leia aqui).

Defina universal_newlines como True, ou seja,

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

Enquanto a resposta de @Aaron Maenpaa simplesmente funciona, um usuário perguntou recentemente :

Existe alguma maneira mais simples? 'fhand.read (). decode ("ASCII")' [...] É tanto tempo!

Você pode usar:

command_stdout.decode()

decode()tem um argumento padrão :

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

Para interpretar uma sequência de bytes como um texto, é necessário conhecer a codificação de caracteres correspondente:

unicode_text = bytestring.decode(character_encoding)

Exemplo:

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

lsO comando pode produzir uma saída que não pode ser interpretada como texto. Os nomes de arquivo no Unix podem ter qualquer sequência de bytes, exceto barra b'/'e zero b'\0':

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

Tentando decodificar essa sopa de bytes usando a codificação utf-8 aumenta UnicodeDecodeError.

Pode ser pior. A decodificação pode falhar silenciosamente e produzir mojibake se você usar uma codificação incompatível incorreta:

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

Os dados estão corrompidos, mas seu programa permanece inconsciente de que ocorreu uma falha.

Em geral, qual codificação de caracteres usar não é incorporada na própria sequência de bytes. Você precisa comunicar essas informações fora da banda. Alguns resultados são mais prováveis ​​que outros e, portanto chardet, existe um módulo que pode adivinhar a codificação de caracteres. Um único script Python pode usar várias codificações de caracteres em locais diferentes.

lsA saída pode ser convertida em uma string Python usando a os.fsdecode() função que é bem-sucedida mesmo para nomes de arquivos não codificáveis (usa sys.getfilesystemencoding()e surrogateescapemanipulador de erros no Unix):

import os
import subprocess

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

Para obter os bytes originais, você pode usar os.fsencode().

Se você passar universal_newlines=Trueparâmetro, em seguida, subprocessusa locale.getpreferredencoding(False)para decodificar bytes por exemplo, pode ser cp1252no Windows.

Para decodificar o fluxo de bytes em tempo real, io.TextIOWrapper() pode ser usado: exemplo .

Comandos diferentes podem usar codificações de caracteres diferentes para sua saída, por exemplo, diro comando interno ( cmd) pode usar o cp437. Para decodificar sua saída, você pode transmitir a codificação explicitamente (Python 3.6+):

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

Os nomes dos arquivos podem diferir de os.listdir()(que usa a API Unicode do Windows), por exemplo, '\xb6'podem ser substituídos '\x14'pelos mapas de codec cp437 do Python b'\x14'para controlar o caractere U + 0014 em vez de U + 00B6 (¶). Para dar suporte a nomes de arquivos com caracteres Unicode arbitrários, consulte Decodificar a saída do PowerShell que possivelmente contém caracteres Unicode não ASCII em uma sequência Python

Como essa pergunta está realmente perguntando sobre a subprocesssaída, você tem uma abordagem mais direta disponível, pois Popenaceita uma palavra-chave de codificação (no 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

A resposta geral para outros usuários é decodificar bytes para texto:

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

Sem argumento, sys.getdefaultencoding()será usado. Se seus dados não estiverem sys.getdefaultencoding(), você deve especificar a codificação explicitamente na decodechamada:

>>> b'caf\xe9'.decode('cp1250')
'café'

Se você deve obter o seguinte, tente decode():

AttributeError: o objeto 'str' não possui atributo 'decode'

Você também pode especificar o tipo de codificação diretamente em uma conversão:

>>> my_byte_str
b'Hello World'

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

Ao trabalhar com dados de sistemas Windows (com \r\nterminações de linha), minha resposta é

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

Por quê? Tente isso com uma entrada multilinha:

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

Todas as terminações de sua linha serão dobradas (para \r\r\n), resultando em linhas vazias extras. As funções de leitura de texto do Python normalmente normalizam as terminações de linha, para que as strings sejam usadas apenas \n. Se você receber dados binários de um sistema Windows, o Python não terá chance de fazer isso. Portanto,

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

irá replicar seu arquivo original.

Eu criei uma função para limpar uma lista

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

Para Python 3, essa é uma abordagem muito mais segura e Python para converter de bytepara 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')

Resultado:

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

From sys - parâmetros e funções específicos do sistema :

Para gravar ou ler dados binários de / para os fluxos padrão, use o buffer binário subjacente. Por exemplo, para escrever bytes em stdout, use sys.stdout.buffer.write(b'abc').

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

Para o seu caso específico de "executar um comando shell e obter sua saída como texto em vez de bytes", no Python 3.7, você deve usar subprocess.rune passar text=True(além capture_output=Truede capturar a saída)

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

textcostumava ser chamado universal_newlinese foi alterado (bem, com alias) no Python 3.7. Se você deseja suportar versões do Python anteriores à 3.7, passe em universal_newlines=Truevez detext=True

Se você deseja converter bytes, não apenas a string convertida em bytes:

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

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

Isso não é muito eficiente, no entanto. Ele transformará uma imagem de 2 MB em 9 MB.

tente isso

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