Ho un codice che si aspetta strma gestirà il caso di essere passato bytesnel modo seguente:

if isinstance(data, bytes):
    data = data.decode()

Sfortunatamente, questo non funziona nel caso di bytearray. Esiste un modo più generico per verificare se un oggetto è byteso bytearray, o devo semplicemente controllare entrambi? È hasattr('decode')così brutto come penso che sarebbe?

Ci sono alcuni approcci che potresti usare qui.

Digitazione di anatra

Poiché Python è digitato a papera , potresti semplicemente fare quanto segue (che sembra essere il modo solitamente suggerito):

try:
    data = data.decode()
except (UnicodeDecodeError, AttributeError):
    pass

Potresti usare hasattrcome descrivi, tuttavia, e probabilmente andrebbe bene. Questo, ovviamente, presuppone che il .decode()metodo per l'oggetto dato restituisca una stringa e non abbia effetti collaterali negativi.

Personalmente raccomando l'eccezione o il hasattrmetodo, ma qualunque cosa tu usi dipende da te.

Usa str ()

Questo approccio è raro, ma è possibile:

data = str(data, "utf-8")

Sono consentite altre codifiche, proprio come con il protocollo buffer .decode(). È inoltre possibile passare un terzo parametro per specificare la gestione degli errori.

Funzioni generiche a invio singolo (Python 3.4+)

Python 3.4 e versioni successive includono un'elegante funzionalità chiamata funzioni generiche a invio singolo, tramite functools.singledispatch . Questo è un po 'più prolisso, ma è anche più esplicito:

def func(data):
    # This is the generic implementation
    data = data.decode()
    ...

@func.register(str)
def _(data):
    # data will already be a string
    ...

Puoi anche creare gestori speciali per oggetti bytearraye bytesse lo desideri.

Attenzione : le funzioni di invio singolo funzionano solo sul primo argomento! Questa è una caratteristica intenzionale, vedere PEP 433 .

Puoi usare:

isinstance(data, (bytes, bytearray))

A causa della diversa classe di base viene utilizzata qui.

>>> bytes.__base__
<type 'basestring'>
>>> bytearray.__base__
<type 'object'>

Controllare bytes

>>> by = bytes()
>>> isinstance(by, basestring)
True

Però,

>>> buf = bytearray()
>>> isinstance(buf, basestring)
False

I codici precedenti sono testati con python 2.7

Sfortunatamente, sotto Python 3.4, sono gli stessi ...

>>> bytes.__base__
<class 'object'>
>>> bytearray.__base__
<class 'object'>

>>> content = b"hello"
>>> text = "hello"
>>> type(content)
<class 'bytes'>
>>> type(text)
<class 'str'>
>>> type(text) is str
True
>>> type(content) is bytes
True

Questo codice non è corretto a meno che tu non sappia qualcosa che noi non sappiamo:

if isinstance(data, bytes):
    data = data.decode()

Non conosci (sembra) la codifica di data. Stai assumendo che sia UTF-8 , ma potrebbe essere sbagliato. Dato che non conosci la codifica, non hai testo . Hai byte, che potrebbero avere qualsiasi significato sotto il sole.

La buona notizia è che la maggior parte delle sequenze casuali di byte non sono UTF-8 valide, quindi quando si interrompe, si interromperà rumorosamente ( errors='strict'è l'impostazione predefinita) invece di fare silenziosamente la cosa sbagliata. La notizia ancora migliore è che la maggior parte di quelle sequenze casuali che sono UTF-8 valide sono anche ASCII valide, che ( quasi ) tutti sono d'accordo su come analizzare comunque.

La cattiva notizia è che non esiste un modo ragionevole per risolvere questo problema. Esiste un modo standard per fornire informazioni sulla codifica: utilizzare strinvece di bytes. Se un codice di terze parti ti ha consegnato un oggetto byteso bytearraysenza ulteriori informazioni o contesto, l'unica azione corretta è fallire.

Ora, supponendo che tu conosca la codifica, puoi usare functools.singledispatchqui:

@functools.singledispatch
def foo(data, other_arguments, ...):
    raise TypeError('Unknown type: '+repr(type(data)))

@foo.register(str)
def _(data, other_arguments, ...):
    # data is a str

@foo.register(bytes)
@foo.register(bytearray)
def _(data, other_arguments, ...):
    data = data.decode('encoding')
    # explicit is better than implicit; don't leave the encoding out for UTF-8
    return foo(data, other_arguments, ...)

Questo non funziona con i metodi e datadeve essere il primo argomento. Se queste restrizioni non funzionano per te, usa invece una delle altre risposte.

Dipende da cosa vuoi risolvere. Se vuoi avere lo stesso codice che converte entrambi i casi in una stringa, puoi semplicemente convertire prima il tipo in bytese poi decodificare. In questo modo, è una battuta:

#!python3

b1 = b'123456'
b2 = bytearray(b'123456')

print(type(b1))
print(type(b2))

s1 = bytes(b1).decode('utf-8')
s2 = bytes(b2).decode('utf-8')

print(s1)
print(s2)

In questo modo, la risposta per te potrebbe essere:

data = bytes(data).decode()

Ad ogni modo suggerisco di scrivere 'utf-8'esplicitamente al decode, se non vi interessa risparmiare pochi byte. Il motivo è che la prossima volta che tu o qualcun altro leggerai il codice sorgente, la situazione sarà più evidente.

Ci sono due domande qui e le risposte sono diverse.

La prima domanda, il titolo di questo post, è qual è il modo corretto per determinare se un oggetto è un oggetto simile a byte in Python? Questo include un certo numero di tipi predefiniti ( bytes, bytearray, array.array, memoryview, altri?) Ed eventualmente anche tipi definiti dall'utente. Il modo migliore che conosco per verificarli è provare a crearne uno memoryview:

>>> memoryview(b"foo")
<memory at 0x7f7c43a70888>
>>> memoryview(u"foo")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: memoryview: a bytes-like object is required, not 'str'

Nel corpo del post originale, tuttavia, sembra che la domanda sia invece: Come faccio a verificare se un oggetto supporta decode ()? La risposta di @ elizabeth-myers a questa domanda è ottima. Notare che non tutti gli oggetti simili a byte supportano decode ().

Il test if isinstance(data, bytes)o if type(data) == bytes, ecc. Non funziona in Python 2, dove una semplice stringa ASCII supera il test di! Poiché utilizzo sia Python 2 che Python 3, per ovviare a questo faccio il seguente controllo:

if str(type(data)).find("bytes") != -1: print("It's <bytes>")

È un po 'brutto, ma fa il lavoro che fa la domanda e funziona sempre, nel modo più semplice.