Baytları bir dizeye dönüştürme

Harici bir programdan standart çıktı almak için bu kodu kullanıyorum:

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

Communications () yöntemi bir bayt dizisi döndürür:

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

Ancak, çıktı ile normal bir Python dizesi olarak çalışmak istiyorum. Böylece şöyle yazdırabilirim:

>>> 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 () yöntemi bunun için olduğunu düşündüm , ama denediğimde, yine aynı bayt dizisini aldım:

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

Bayt değerini dizeye nasıl geri dönüştürebilirim? Yani, manuel olarak yapmak yerine "pilleri" kullanmak. Ve Python 3 ile iyi olmasını istiyorum.

Bir dize oluşturmak için bayt nesnesinin kodunu çözmeniz gerekir:

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

Bayt dizgisinin kodunu çözmeniz ve bir karakter (Unicode) dizesine dönüştürmeniz gerekir.

Python 2'de

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

veya

unicode('hello', encoding)

Python 3'te

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

veya

str(b'hello', encoding)

Bu şekilde kolay olduğunu düşünüyorum:

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

Kodlamayı bilmiyorsanız, Python 3 ve Python 2 uyumlu şekilde dizeye ikili girişi okumak için eski MS-DOS CP437 kodlamasını kullanın:

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

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

Kodlama bilinmediğinden, İngilizce olmayan sembollerin karakterlerine çevrilmesini bekleyin cp437(İngilizce karakterler çevrilmez, çünkü çoğu tek bayt kodlama ve UTF-8 ile eşleşirler).

UTF-8'e keyfi ikili giriş kodunu çözmek güvenli değildir, çünkü bunu alabilirsiniz:

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

Aynı için de geçerlidir latin-1(? Varsayılan) eksik noktaları Python 2. See için popüler olan, Codepage Düzeni o rezil ile nerede Python jiklleler olduğunu - ordinal not in range.

GÜNCELLEME 20150604 : Python 3'ün surrogateescapeveri kaybı ve çökmesi olmadan verileri ikili verilere kodlamak için hata stratejisine sahip olduğu söylentileri var , ancak [binary] -> [str] -> [binary]hem performansı hem de güvenilirliği doğrulamak için dönüşüm testlerine ihtiyacı var .

GÜNCELLEME 20170116 : Nearoo'nun yorumu sayesinde - bilinmeyen tüm baytların backslashreplacehata işleyicisiyle kaçışını kesme olasılığı da var . Bu sadece Python 3 için geçerlidir, bu nedenle bu geçici çözümde bile farklı Python sürümlerinden tutarsız çıktı elde edersiniz:

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

Ayrıntılar için Python'un Unicode Desteğine bakın.

GÜNCELLEME 20170119 : Hem Python 2 hem de Python 3 için çalışan eğik çizgi kod çözme uygulamaya karar verdim. Çözümden daha yavaş olmalı cp437, ancak her Python sürümünde aynı sonuçları üretmelidir .

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

Python 3'te varsayılan kodlama "utf-8", böylece doğrudan şunları kullanabilirsiniz:

b'hello'.decode()

eşdeğer

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

Öte yandan, Python 2'de kodlama varsayılan olarak varsayılan dize kodlamasıdır. Bu nedenle, şunları kullanmalısınız:

b'hello'.decode(encoding)

encodingistediğiniz kodlama nerede .

Not: Python 2.7'de anahtar kelime bağımsız değişkenleri için destek eklendi.

Bence bunu gerçekten istiyorsun:

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

Aaron'un cevabı doğruydu, ancak hangi kodlamayı kullanacağınızı bilmeniz gerekiyor . Ve Windows'un 'windows-1252' kullandığına inanıyorum. Yalnızca içeriğinizde alışılmadık (ASCII olmayan) karakterler olması önemli olacaktır, ancak daha sonra bir fark yaratacaktır.

Bu arada, gerçeği yapar olsun sebebi Python ikili ve metin veri için iki farklı türleri kullanarak taşındı olmasıdır: Bunu söylemek sürece kodlamasını bilmez, çünkü aralarında sihirli dönüştürmek olamaz! SİZİN bilmenin tek yolu Windows belgelerini okumak (veya burada okumak).

Universal_newlines öğesini True olarak ayarlayın;

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

@Aaron Maenpaa'nın yanıtı çalışırken , bir kullanıcı yakın zamanda sordu :

Daha basit bir yolu var mı? 'fhand.read (). decode ("ASCII")' [...] Çok uzun!

Kullanabilirsiniz:

command_stdout.decode()

decode()Bir sahiptir standart bir tartışma :

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

Bayt dizisini metin olarak yorumlamak için, karşılık gelen karakter kodlamasını bilmeniz gerekir:

unicode_text = bytestring.decode(character_encoding)

Misal:

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

lskomutu metin olarak yorumlanamayan çıktılar üretebilir. Unix'teki dosya adları, eğik çizgi b'/'ve sıfır dışında herhangi bir bayt dizisi olabilir b'\0':

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

Utf-8 kodlama artışlarını kullanarak bu bayt çorbasının kodunu çözmeye çalışın UnicodeDecodeError.

Daha kötü olabilir. Yanlış uyumsuz kodlama kullanırsanız kod çözme sessizce başarısız olabilir ve mojibake üretebilir :

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

Veriler bozuk, ancak programınız bir hata oluştuğunun farkında değil.

Genel olarak, hangi karakter kodlamasının kullanılacağı bayt dizisinin kendisine gömülü değildir. Bu bilgiyi bant dışı olarak iletmeniz gerekir. Bazı sonuçlar diğerlerinden daha olasıdır ve bu nedenle karakter kodlamasını tahminchardet edebilen modül mevcuttur . Tek bir Python betiği farklı yerlerde birden çok karakter kodlaması kullanabilir.

lsçıktı, kod çözülemeyen dosya adlarıos.fsdecode() için bile başarılı olan bir işlev kullanılarak Python dizesine dönüştürülebilir ( Unix'te hata işleyicisi kullanır ve kullanır ):sys.getfilesystemencoding()surrogateescape

import os
import subprocess

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

Orijinal baytları almak için kullanabilirsiniz os.fsencode().

universal_newlines=TrueParametreyi geçerseniz , bayt kodunu çözmek için subprocesskullanır locale.getpreferredencoding(False), örneğin cp1252Windows'ta olabilir.

Bayt akışının anında kodunu çözmek için io.TextIOWrapper() kullanılabilir: örnek .

Farklı komutlar çıktıları için farklı karakter kodlamaları kullanabilirler, örneğin dirdahili komut ( cmd) cp437 kullanabilir. Çıktının kodunu çözmek için kodlamayı açıkça geçebilirsiniz (Python 3.6+):

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

Dosya farklı olabilir os.listdir()(Windows Unicode API kullanır), örneğin, '\xb6'ile ikame edilmiş olabilir '\x14'-Python en cp437 kodek haritalar b'\x14'kontrol karakteri U + 0014 yerine U +, 00B6 (¶) için. İsteğe bağlı Unicode karakterleri olan dosya adlarını desteklemek için bkz. Muhtemelen ASCII Unicode olmayan karakterler içeren PowerShell çıktısını Python dizesine kodlama

Bu soru aslında subprocessçıktıyı sorduğundan , Popenbir kodlama anahtar kelimesini kabul ettiğinden (Python 3.6+) daha doğrudan bir yaklaşımınız var :

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

Diğer kullanıcılar için genel cevap, baytların metne kodunu çözmektir:

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

Hiçbir argüman olmadan, sys.getdefaultencoding()kullanılacak. Verileriniz değilse sys.getdefaultencoding(), decodeçağrıda kodlamayı açıkça belirtmeniz gerekir :

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

Aşağıdakileri deneyerek almanız gerekiyorsa decode():

AttributeError: 'str' nesnesinin 'decode' özelliği yok

Kodlama türünü doğrudan bir yayında da belirleyebilirsiniz:

>>> my_byte_str
b'Hello World'

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

Windows sistemlerinden gelen verilerle çalışırken ( \r\nsatır sonlarıyla), cevabım

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

Neden? Bunu çok satırlı Input.txt ile deneyin:

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

Tüm satır sonlarınız iki katına çıkacak \r\r\nve bu da ekstra boş satırlara yol açacaktır . Python'un metin okuma işlevleri genellikle satır sonlarını normalleştirir, böylece dizeler yalnızca kullanır \n. Bir Windows sisteminden ikili veri alırsanız, Python'un bunu yapma şansı yoktur. Böylece,

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

orijinal dosyanızı çoğaltır.

Bir listeyi temizlemek için bir işlev yaptım

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

Python 3 için, bu çok daha güvenli ve olduğu Pythonic dönüştürmek için yaklaşım byteiçin 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')

Çıktı:

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

Gönderen sys - Sistem özgü parametreleri ve fonksiyonları :

Standart akışlardan / standart akışlara ikili veri yazmak veya okumak için temel ikili arabelleği kullanın. Örneğin, stdout'a bayt yazmak için kullanın 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))

Senin için belirli durumunda "bir kabuk komutunu çalıştırın ve yerine bayt metin olarak üretimini olsun", Python 3.7 üzerinde, kullanmak gerekir subprocess.runve geçmek text=True(yanı sıra capture_output=Trueçıkış yakalamak)

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

textuniversal_newlinesPython 3.7'de çağrıldı ve değiştirildi (iyi, takma). 3.7'den önceki Python sürümlerini desteklemek istiyorsanız, universal_newlines=Trueyerine geçmektext=True

Herhangi bir baytı dönüştürmek istiyorsanız, sadece bayta dönüştürülen dize değil:

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

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

Ancak bu çok verimli değildir. 2 MB'lık bir resmi 9 MB'ye dönüştürür.

bunu dene

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