Daftar pemahaman pada daftar bersarang?

Saya punya daftar bersarang ini:

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

Sekarang, yang ingin saya lakukan adalah mengonversi setiap elemen dalam daftar menjadi float. Solusi saya adalah ini:

newList = []
for x in l:
  for y in x:
    newList.append(float(y))

Tetapi dapatkah ini dilakukan dengan menggunakan pemahaman daftar bersarang, bukan?

apa yang saya lakukan adalah:

[float(y) for y in x for x in l]

Tapi kemudian hasilnya adalah sekelompok 100 dengan jumlah 2400.

solusi apa pun, sebuah penjelasan akan sangat dihargai. Terima kasih!

Inilah cara Anda melakukan ini dengan pemahaman daftar bersarang:

[[float(y) for y in x] for x in l]

Ini akan memberi Anda daftar daftar, mirip dengan apa yang Anda mulai dengan kecuali dengan float, bukan string. Jika Anda menginginkan satu daftar datar maka Anda akan menggunakannya [float(y) for x in l for y in x].

Berikut ini cara mengkonversi nested for loop ke nested listrehension:

Berikut adalah cara kerja pemahaman daftar bersarang:

            l a b c d e f
            ↓ ↓ ↓ ↓ ↓ ↓ ↓
In [1]: l = [ [ [ [ [ [ 1 ] ] ] ] ] ]
In [2]: for a in l:
   ...:     for b in a:
   ...:         for c in b:
   ...:             for d in c:
   ...:                 for e in d:
   ...:                     for f in e:
   ...:                         print(float(f))
   ...:                         
1.0

In [3]: [float(f)
         for a in l
   ...:     for b in a
   ...:         for c in b
   ...:             for d in c
   ...:                 for e in d
   ...:                     for f in e]
Out[3]: [1.0]

Untuk kasus Anda, itu akan menjadi seperti ini.

In [4]: new_list = [float(y) for x in l for y in x]

>>> l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]
>>> new_list = [float(x) for xs in l for x in xs]
>>> new_list
[40.0, 20.0, 10.0, 30.0, 20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0, 30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]

Tidak yakin apa output yang Anda inginkan, tetapi jika Anda menggunakan pemahaman daftar, urutan mengikuti urutan loop bersarang, yang Anda miliki mundur. Jadi saya mendapatkan apa yang saya pikir Anda inginkan:

[float(y) for x in l for y in x]

Prinsipnya adalah: gunakan urutan yang sama yang akan Anda gunakan dalam menuliskannya sebagai bersarang untuk loop.

Karena saya sedikit terlambat di sini tetapi saya ingin berbagi bagaimana sebenarnya pemahaman daftar bekerja terutama pemahaman daftar bersarang:

New_list= [[float(y) for x in l]

sebenarnya sama dengan:

New_list=[]
for x in l:
    New_list.append(x)

Dan sekarang daftar pemahaman bersarang:

[[float(y) for y in x] for x in l]

sama dengan;

new_list=[]
for x in l:
    sub_list=[]
    for y in x:
        sub_list.append(float(y))

    new_list.append(sub_list)

print(new_list)

keluaran:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Jika Anda tidak menyukai pemahaman daftar bersarang, Anda dapat menggunakan fungsi peta juga,

>>> from pprint import pprint

>>> l = l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']] 

>>> pprint(l)
[['40', '20', '10', '30'],
['20', '20', '20', '20', '20', '30', '20'],
['30', '20', '30', '50', '10', '30', '20', '20', '20'],
['100', '100'],
['100', '100', '100', '100', '100'],
['100', '100', '100', '100']]

>>> float_l = [map(float, nested_list) for nested_list in l]

>>> pprint(float_l)
[[40.0, 20.0, 10.0, 30.0],
[20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0],
[30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0],
[100.0, 100.0],
[100.0, 100.0, 100.0, 100.0, 100.0],
[100.0, 100.0, 100.0, 100.0]]

Saya memiliki masalah yang sama untuk dipecahkan sehingga saya menemukan pertanyaan ini. Saya melakukan perbandingan kinerja jawaban Andrew Clark dan narayan yang ingin saya bagikan.

Perbedaan utama antara dua jawaban adalah bagaimana mereka mengulangi daftar dalam. Salah satunya menggunakan peta builtin , sementara yang lain menggunakan daftar pemahaman. Fungsi peta memiliki sedikit keunggulan kinerja untuk pemahaman daftar yang setara jika tidak memerlukan penggunaan lambdas . Jadi dalam konteks pertanyaan ini mapharus melakukan sedikit lebih baik daripada pemahaman daftar.

Mari kita lakukan tolok ukur kinerja untuk melihat apakah itu benar. Saya menggunakan python versi 3.5.0 untuk melakukan semua tes ini. Pada set pertama pengujian saya ingin mempertahankan elemen per daftar menjadi 10 dan memvariasikan jumlah daftar dari 10-100.000

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10]"
>>> 100000 loops, best of 3: 15.2 usec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100]"
>>> 100000 loops, best of 3: 15.2 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*1000]"
>>> 1000 loops, best of 3: 1.43 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*1000]"
>>> 100 loops, best of 3: 1.91 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10000]"
>>> 100 loops, best of 3: 13.6 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10000]"
>>> 10 loops, best of 3: 19.1 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 164 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 216 msec per loop

Pada set tes berikutnya saya ingin meningkatkan jumlah elemen per daftar menjadi 100 .

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 110 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 151 usec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.11 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.5 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 11.2 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 16.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 134 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 171 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.32 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.7 sec per loop

Mari kita mengambil langkah berani dan memodifikasi jumlah elemen dalam daftar menjadi 1000

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 800 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 1.16 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 8.26 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 11.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 83.8 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 118 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 868 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 1.23 sec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 9.2 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 12.7 sec per loop

Dari tes ini kita dapat menyimpulkan bahwa mapmemiliki manfaat kinerja melebihi pemahaman daftar dalam hal ini. Ini juga berlaku jika Anda mencoba melakukan cast ke salah satu intatau str. Untuk sejumlah kecil daftar dengan lebih sedikit elemen per daftar, perbedaannya dapat diabaikan. Untuk daftar yang lebih besar dengan lebih banyak elemen per daftar orang mungkin ingin menggunakan mapalih-alih pemahaman daftar, tetapi itu benar-benar tergantung pada kebutuhan aplikasi.

Namun saya pribadi menemukan pemahaman daftar lebih mudah dibaca dan idiomatis daripada map. Ini adalah standar de-facto dalam python. Biasanya orang lebih mahir dan nyaman (khususnya pemula) dalam menggunakan pemahaman daftar daripada map.

Ya, Anda bisa melakukannya dengan kode seperti itu:

l = [[float(y) for y in x] for x in l]

Masalah ini dapat diselesaikan tanpa menggunakan untuk loop. Kode baris tunggal akan cukup untuk ini. Menggunakan Nested Map dengan fungsi lambda juga akan berfungsi di sini.

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

map(lambda x:map(lambda y:float(y),x),l)

Dan Daftar Keluaran adalah sebagai berikut:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Cara terbaik untuk melakukan ini menurut saya adalah dengan menggunakan itertoolspaket python .

>>>import itertools
>>>l1 = [1,2,3]
>>>l2 = [10,20,30]
>>>[l*2 for l in itertools.chain(*[l1,l2])]
[2, 4, 6, 20, 40, 60]

Ya, Anda dapat melakukan hal berikut.

[[float(y) for y in x] for x in l]

    deck = [] 
    for rank in ranks:
        for suit in suits:
            deck.append(('%s%s')%(rank, suit))

Ini dapat dicapai dengan menggunakan pemahaman daftar:

[deck.append((rank,suit)) for suit in suits for rank in ranks ]