Ottenere una mappa () per restituire un elenco in Python 3.x

Sto cercando di mappare un elenco in esadecimale e quindi utilizzare l'elenco altrove. In Python 2.6, questo è stato facile:

A: Python 2.6:

>>> map(chr, [66, 53, 0, 94])
['B', '5', '\x00', '^']

Tuttavia, in Python 3.1, quanto sopra restituisce un oggetto mappa.

B: Python 3.1:

>>> map(chr, [66, 53, 0, 94])
<map object at 0x00AF5570>

Come recuperare l'elenco mappato (come in A sopra) su Python 3.x?

In alternativa, c'è un modo migliore per farlo? Il mio oggetto elenco iniziale ha circa 45 elementi e id mi piace convertirli in esadecimali.

Fai questo:

list(map(chr,[66,53,0,94]))

In Python 3+, molti processi che ripetono su iterabili restituiscono gli stessi iteratori. Nella maggior parte dei casi, questo finisce per risparmiare memoria e dovrebbe rendere le cose più veloci.

Se alla fine tutto ciò che farai è iterare su questo elenco, non è necessario nemmeno convertirlo in un elenco, perché puoi ancora iterare l' mapoggetto in questo modo:

# Prints "ABCD"
for ch in map(chr,[65,66,67,68]):
    print(ch)

Nuovo e pulito in Python 3.5:

[*map(chr, [66, 53, 0, 94])]

Grazie alle generalizzazioni aggiuntive di disimballaggio

AGGIORNARE

Sempre alla ricerca di modi più brevi, ho scoperto che questo funziona anche:

*map(chr, [66, 53, 0, 94]),

Il disimballaggio funziona anche in tuple. Nota la virgola alla fine. Questo lo rende una tupla di 1 elemento. Cioè, è equivalente a(*map(chr, [66, 53, 0, 94]),)

È più breve di un solo carattere dalla versione con le parentesi di elenco, ma, a mio avviso, è meglio scrivere, perché inizi subito con l'asterisco - la sintassi di espansione, quindi sento che è più morbido nella mente. :)

Perché non lo stai facendo:

[chr(x) for x in [66,53,0,94]]

Si chiama comprensione elenco. Puoi trovare molte informazioni su Google, ma ecco il link alla documentazione di Python (2.6) sulla comprensione dell'elenco . Potresti essere più interessato aTuttavia , alla documentazione di Python 3 .

La funzione della mappa di ritorno alla lista ha il vantaggio di salvare la digitazione, specialmente durante le sessioni interattive. È possibile definire la lmapfunzione (sull'analogia di python2 imap) che restituisce l'elenco:

lmap = lambda func, *iterable: list(map(func, *iterable))

Quindi chiamare lmapinvece di mapfarà il lavoro: lmap(str, x)è più breve di 5 caratteri (in questo caso il 30%) di list(map(str, x))ed è sicuramente più breve di [str(v) for v in x]. È possibile creare funzioni simili perfilter .

C'è stato un commento alla domanda originale:

Suggerirei di rinominare Getting map () per restituire un elenco in Python 3. * come si applica a tutte le versioni di Python3. C'è un modo per fare questo? - meawoppl 24 gennaio alle 17:58

Si è possibile farlo, ma è una pessima idea. Solo per divertimento, ecco come puoi ( ma non dovresti ) farlo:

__global_map = map #keep reference to the original map
lmap = lambda func, *iterable: list(__global_map(func, *iterable)) # using "map" here will cause infinite recursion
map = lmap
x = [1, 2, 3]
map(str, x) #test
map = __global_map #restore the original map and don't do that again
map(str, x) #iterator

Convertire il mio vecchio commento per una migliore visibilità: per un "modo migliore per farlo" senza del maptutto, se i tuoi input sono noti per essere ordinali ASCII, è generalmente molto più veloce convertire bytese decodificare, a la bytes(list_of_ordinals).decode('ascii'). Questo ti dà uno strdei valori, ma se hai bisogno di un valore listper mutabilità o simili, puoi semplicemente convertirlo (ed è ancora più veloce). Ad esempio, nei ipythonmicrobenchmark che convertono 45 input:

>>> %%timeit -r5 ordinals = list(range(45))
... list(map(chr, ordinals))
...
3.91 µs ± 60.2 ns per loop (mean ± std. dev. of 5 runs, 100000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... [*map(chr, ordinals)]
...
3.84 µs ± 219 ns per loop (mean ± std. dev. of 5 runs, 100000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... [*bytes(ordinals).decode('ascii')]
...
1.43 µs ± 49.7 ns per loop (mean ± std. dev. of 5 runs, 1000000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... bytes(ordinals).decode('ascii')
...
781 ns ± 15.9 ns per loop (mean ± std. dev. of 5 runs, 1000000 loops each)

Se lo lasci come a str, ci vuole circa il 20% del tempo delle mapsoluzioni più veloci ; anche convertendo nuovamente in elenco è ancora meno del 40% della mapsoluzione più veloce . La conversione in blocco tramite bytese bytes.decodequindi la conversione in blocco indietro per listrisparmiare molto lavoro, ma come notato, funziona solo se tutti i tuoi input sono ordinali ASCII (o ordinali in un byte specifico per codifica locale per carattere, ad es latin-1.).

list(map(chr, [66, 53, 0, 94]))

map (func, * iterables) -> map object Crea un iteratore che calcola la funzione usando gli argomenti di ciascuno degli iterabili. Si interrompe quando il più breve iterabile è esaurito.

"Crea un iteratore"

significa che restituirà un iteratore.

"che calcola la funzione usando gli argomenti di ciascuno degli iterabili"

significa che la funzione next () dell'iteratore prenderà un valore per ogni iterabile e li passerà a un parametro posizionale della funzione.

Quindi ottieni un iteratore dalla mappa () funtion e jsut lo passa alla funzione built-in list () o usa la comprensione dell'elenco.

Oltre alle risposte di cui sopra Python 3, possiamo semplicemente creare un valore listdi risultato da un mapas

li = []
for x in map(chr,[66,53,0,94]):
    li.append(x)

print (li)
>>>['B', '5', '\x00', '^']

Possiamo generalizzare con un altro esempio in cui sono stato colpito, le operazioni sulla mappa possono anche essere gestite in modo simile come in un regexproblema, possiamo scrivere la funzione per ottenere listelementi da mappare e ottenere il set di risultati allo stesso tempo. Ex.

b = 'Strings: 1,072, Another String: 474 '
li = []
for x in map(int,map(int, re.findall('\d+', b))):
    li.append(x)

print (li)
>>>[1, 72, 474]

Puoi provare a ottenere un elenco dall'oggetto mappa semplicemente ripetendo ogni elemento nell'oggetto e memorizzandolo in una variabile diversa.

a = map(chr, [66, 53, 0, 94])
b = [item for item in a]
print(b)
>>>['B', '5', '\x00', '^']

Utilizzando la comprensione dell'elenco in Python e l'utilità di base delle funzioni della mappa, si può fare anche questo:

chi = [x for x in map(chr,[66,53,0,94])]