Convertir bytes en una cadena

Necesita decodificar el objeto bytes para producir una cadena:

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

Debe decodificar la cadena de bytes y convertirla en una cadena de caracteres (Unicode).

En Python 2

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

or

unicode('hello', encoding)

En Python 3

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

or

str(b'hello', encoding)

Creo que de esta manera es fácil:

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

Si no conoce la codificación, entonces para leer la entrada binaria en una cadena en forma compatible con Python 3 y Python 2, use el antiguo MS-DOS CP437 codificación:

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

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

Debido a que la codificación es desconocida, espere que los símbolos que no estén en inglés se traduzcan a caracteres de cp437 (Los caracteres en inglés no se traducen porque coinciden en la mayoría de las codificaciones de un solo byte y UTF-8).

Decodificar una entrada binaria arbitraria a UTF-8 no es seguro, porque puede obtener esto:

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

Lo mismo se aplica a latin-1, que era popular (¿el predeterminado?) para Python 2. Vea los puntos faltantes en Diseño de página de códigos - es donde Python se ahoga con infames ordinal not in range.

ACTUALIZACIÓN 20150604: Hay rumores de que Python 3 tiene la surrogateescape estrategia de error para codificar cosas en datos binarios sin pérdida de datos y fallas, pero necesita pruebas de conversión, [binary] -> [str] -> [binary], para validar tanto el rendimiento como la fiabilidad.

ACTUALIZACIÓN 20170116: Gracias al comentario de Nearoo, también existe la posibilidad de eliminar todos los bytes desconocidos con backslashreplace manejador de errores. Eso funciona solo para Python 3, por lo que incluso con esta solución, seguirá obteniendo resultados inconsistentes de diferentes versiones de 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'))

Ver Soporte Unicode de Python para más detalles.

ACTUALIZACIÓN 20170119: Decidí implementar la decodificación de escape de barra que funciona tanto para Python 2 como para Python 3. Debería ser más lento que el cp437 solución, pero debería producir resultados idénticos en cada versión de 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'))

En Python 3, la codificación predeterminada es "utf-8", para que pueda usar directamente:

b'hello'.decode()

que es equivalente a

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

Por otra parte, en Python 2, la codificación tiene como valor predeterminado la codificación de cadena predeterminada. Por lo tanto, debes usar:

b'hello'.decode(encoding)

donde encoding es la codificación que desea.

Nota: Se agregó soporte para argumentos de palabras clave en Python 2.7.

Creo que realmente quieres esto:

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

La respuesta de Aaron fue correcta, excepto que necesitas saber que codificación para usar. Y creo que Windows usa 'windows-1252'. Solo importará si tiene algunos caracteres inusuales (no ASCII) en su contenido, pero entonces marcará la diferencia.

Por cierto, el hecho de que sí La cuestión es la razón por la que Python pasó a usar dos tipos diferentes para datos binarios y de texto: ¡no puede convertir mágicamente entre ellos, porque no conoce la codificación a menos que usted lo diga! La única forma en que USTED lo sabría es leer la documentación de Windows (o leerla aquí).

Establezca universal_newlines en True, es decir

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

Para interpretar una secuencia de bytes como texto, debe conocer la codificación de caracteres correspondiente:

unicode_text = bytestring.decode(character_encoding)

Ejemplo:

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

ls El comando puede producir una salida que no se puede interpretar como texto. Los nombres de archivo en Unix pueden ser cualquier secuencia de bytes excepto barra b'/' y cero b'\0':

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

Intentar decodificar tal sopa de bytes usando la codificación utf-8 aumenta UnicodeDecodeError.

Puede ser peor. La decodificación puede fallar silenciosamente y producir mojibake si usa una codificación incompatible incorrecta:

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

Los datos están dañados, pero su programa no se da cuenta de que se ha producido un error.

En general, qué codificación de caracteres usar no está incrustada en la propia secuencia de bytes. Tienes que comunicar esta información fuera de banda. Algunos resultados son más probables que otros y, por lo tanto, chardet existe un módulo que puede adivinar la codificación de caracteres. Una sola secuencia de comandos de Python puede usar múltiples codificaciones de caracteres en diferentes lugares.

ls la salida se puede convertir a una cadena de Python usando os.fsdecode() función que tiene éxito incluso para nombres de archivo no codificables (usa sys.getfilesystemencoding() y surrogateescape controlador de errores en Unix):

import os
import subprocess

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

Para obtener los bytes originales, puede usar os.fsencode().

Si pasa universal_newlines=True parámetro entonces subprocess usos locale.getpreferredencoding(False) para decodificar bytes, por ejemplo, puede ser cp1252 en Windows.

Para decodificar el flujo de bytes sobre la marcha, io.TextIOWrapper() puede ser usado: ejemplo.

Los diferentes comandos pueden usar diferentes codificaciones de caracteres para su salida, por ejemplo, dir comando internocmd) puede utilizar cp437. Para decodificar su salida, puede pasar la codificación explícitamente (Python 3.6+):

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

Los nombres de archivo pueden diferir de os.listdir() (que usa la API de Windows Unicode), por ejemplo, '\xb6' puede ser sustituido por '\x14'—Mapas del códec cp437 de Python b'\x14' para controlar el carácter U + 0014 en lugar de U + 00B6 (¶). Para admitir nombres de archivo con caracteres Unicode arbitrarios, consulte Decodificar la salida de PowerShell que posiblemente contenga caracteres Unicode no ASCII en una cadena de Python

Dado que esta pregunta en realidad es sobre subprocess salida, tiene enfoques más directos disponibles. El más moderno estaría usando subprocess.check_output y pasando text=True (Python 3.7+) para decodificar automáticamente stdout usando la codificación predeterminada del sistema:

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

Para Python 3.6, Popen acepta un codificación palabra clave:

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

La respuesta general a la pregunta del título, si no está tratando con la salida del subproceso, es descodificar bytes al texto:

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

Sin argumento sys.getdefaultencoding() se utilizará. Si sus datos no son sys.getdefaultencoding(), debe especificar la codificación explícitamente en el decode llamada:

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

Aunque la La respuesta de @Aaron Maenpaa simplemente funciona, un usuario pedido recientemente:

¿Hay alguna forma más sencilla? 'fhand.read (). decode ("ASCII")' [...] ¡Es tan largo!

Puedes usar:

command_stdout.decode()

decode() tiene un argumento estándar:

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

Si debe obtener lo siguiente al intentar decode():

AttributeError: el objeto 'str' no tiene atributo 'decode'

También puede especificar el tipo de codificación directamente en un reparto:

>>> my_byte_str
b'Hello World'

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

Hice una función para limpiar una 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

Al trabajar con datos de sistemas Windows (con \r\n finales de línea), mi respuesta es

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

¿Por qué? Intente esto con un Input.txt multilínea:

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

Todas las terminaciones de sus líneas se duplicarán (para \r\r\n), lo que genera más líneas vacías. Las funciones de lectura de texto de Python normalmente normalizan las terminaciones de línea para que las cadenas solo utilicen \n. Si recibe datos binarios de un sistema Windows, Python no tiene la oportunidad de hacerlo. Por lo tanto,

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

replicará su archivo original.

Para Python 3, este es un método mucho más seguro y Pitónico enfoque para convertir de byte a 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')

Salida:

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

Para tu soluciones caso de "ejecutar un comando de shell y obtener su salida como texto en lugar de bytes", en Python 3.7, debe usar subprocess.run y pasar text=True (tanto como capture_output=True para capturar la salida)

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

text solía ser llamado universal_newlines, y fue cambiado (bueno, con alias) en Python 3.7. Si desea admitir versiones de Python anteriores a la 3.7, pase universal_newlines=True en lugar de text=True

Desde sys: parámetros y funciones específicos del sistema:

Para escribir o leer datos binarios desde / hacia los flujos estándar, use el búfer binario subyacente. Por ejemplo, para escribir bytes en 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))

Si desea convertir bytes, no solo cadenas convertidas a bytes:

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

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

Sin embargo, esto no es muy eficaz. Convertirá una imagen de 2 MB en 9 MB.

prueba este

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