Python 3.x'te liste döndürmek için harita () alma

Bir listeyi onaltılık olarak eşlemeye çalışıyorum ve sonra listeyi başka bir yerde kullanıyorum. Python 2.6'da bu kolaydı:

A: Python 2.6:

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

Ancak, Python 3.1, yukarıdaki bir harita nesnesi döndürür.

B: Python 3.1:

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

Python 3.x'te eşlenen listeyi ( yukarıdaki A'da olduğu gibi) nasıl alabilirim ?

Alternatif olarak, bunu yapmanın daha iyi bir yolu var mı? İlk liste nesnemde yaklaşık 45 öğe var ve bunları onaltılık biçime dönüştürmek istiyorum.

Bunu yap:

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

Python 3 + 'da, yinelenebilirler üzerinde yinelenen birçok işlem yineleyicileri kendileri döndürür. Çoğu durumda, bu bellek tasarrufu sağlar ve işleri daha hızlı hale getirmelidir.

Tek yapmanız gereken sonunda bu liste üzerinde tekrarlamaksa, listeye dönüştürmeye bile gerek yoktur, çünkü yine de mapnesne üzerinde tekrarlayabilirsiniz :

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

Python 3.5'te yeni ve temiz:

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

Sayesinde Ek Ambalajın açılması Genellemelerinin

GÜNCELLEME

Her zaman daha kısa yollar aramanın, bunun da işe yaradığını keşfettim:

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

Ambalajdan çıkarma tuples ile de çalışır. Sonunda virgül olduğuna dikkat edin. Bu onu 1 elemandan oluşan bir demet yapar. Yani,(*map(chr, [66, 53, 0, 94]),)

Liste parantezleri içeren sürümden sadece bir karakter daha kısadır, ancak bence, yazmak daha iyidir, çünkü yıldız işaretiyle (genişleme sözdizimi) hemen başlarsınız, bu yüzden akılda daha yumuşak olduğunu hissediyorum. :)

Bunu neden yapmıyorsunuz:

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

Buna liste kavraması denir. Google'da bol miktarda bilgi bulabilirsiniz, ancak liste anlaşmalarıyla ilgili Python (2.6) belgelerine bağlantı . Yine de Python 3 belgeseliyle daha fazla ilgilenebilirsiniz .

Liste geri dönen harita işlevi, özellikle etkileşimli oturumlarda yazmayı kaydetme avantajına sahiptir. Listeyi döndüren lmapişlevi (python2'lerin benzetmesinde) tanımlayabilirsiniz imap:

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

Sonra lmapyerine çağrı mapyapmak işi yapacak: lmap(str, x)5 karakter daha kısadır (bu durumda% 30) list(map(str, x))ve kesinlikle daha kısadır [str(v) for v in x]. Siz de benzer işlevler oluşturabilirsiniz filter.

Orijinal soruya bir yorum yapıldı:

Tüm Python3 sürümleri için geçerli olduğu için Python 3'te bir liste döndürmek için Harita almak () için bir yeniden adlandırma öneririm. Bunu yapmanın bir yolu var mı? - meawoppl 24 Ocak, 17:58

Bunu yapmak mümkündür, ama bu çok kötü bir fikir. Sadece eğlence için, bunu nasıl yapabilirsiniz ( ama yapmamalısınız ):

__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

Eski yorumumu daha iyi görünürlük için dönüştürme : "Bunu yapmanın daha iyi bir yolu" maptamamen olmadan , girdilerinizin ASCII ordinalleri olduğu biliniyorsa, genellikle bir la'ya dönüştürmek bytesve kodunu çözmek çok daha hızlıdır bytes(list_of_ordinals).decode('ascii'). Bu size strdeğerlerden birini getirir, ancak listdeğişebilirlik veya benzerine ihtiyacınız varsa , onu dönüştürebilirsiniz (ve yine de daha hızlıdır). Örneğin, ipython45 girişi dönüştüren mikro işaretlerde:

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

Bir olarak bırakırsanız str, en hızlı mapçözümlerin süresinin ~% 20'sini alır ; listeye geri dönse bile hala en hızlı mapçözümün % 40'ından az . Toplu dönüştürme bytesve bytes.decodedaha sonra toplu dönüştürme list, çok iş tasarrufu sağlar, ancak belirtildiği gibi, yalnızca tüm girişleriniz ASCII ordinalleri (veya karakter yerel ayarına özgü kodlama başına bir bayttaki ordinaller latin-1) olduğunda çalışır.

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

map (func, * iterables) -> map nesnesi Her yinelemeden bağımsız değişkenleri kullanarak işlevi hesaplayan bir yineleyici yapın. En kısa yinelenebilir bittiğinde durur.

"Yineleyici yap"

bir yineleyici döndüreceği anlamına gelir.

"yinelemelerin her birinden bağımsız değişkenler kullanarak işlevi hesaplar"

yineleyicinin sonraki () işlevinin her yinelenebilir öğenin bir değerini alacağı ve her birini işlevin bir konum parametresine geçireceği anlamına gelir.

Böylece map () işlevinden bir yineleyici alırsınız ve jsut list () yerleşik işlevine iletir veya liste kavrayışlarını kullanır.

Yukarıdaki cevaplara ek olarak Python 3, biz sadece bir yaratabilir listbir gelen sonuç değerlerinin mapolarak

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

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

Vurulduğum başka bir örnekle genelleştirebiliriz, haritadaki işlemler de regexproblem gibi benzer şekilde ele alınabilir, listeşlenecek öğeleri elde etmek ve aynı zamanda sonuç kümesi almak için işlev yazabiliriz . Ör.

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]

Nesnedeki her öğeyi yineleyerek ve farklı bir değişkende saklayarak harita nesnesinden bir liste almayı deneyebilirsiniz.

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

Python ve temel harita fonksiyonu yardımcı programında liste kavrayışı kullanarak, bunu da yapabilirsiniz:

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