Перелічити розуміння у вкладеному списку?

У мене цей вкладений список:

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

Тепер те, що я хочу зробити, - це перетворити кожен елемент у списку для плавання. Моє рішення таке:

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

Але чи можна це зробити, використовуючи розуміння вкладеного списку, правда?

що я зробив:

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

Але тоді результат - це купа 100 з сумою 2400.

будь-яке рішення, пояснення були б дуже вдячні. Дякую!

Ось як це можна зробити з розумінням вкладеного списку:

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

Це дасть вам список списків, схожий на те, що ви починали, за винятком плавців замість рядків. Якщо ви хочете одного плоского списку, ви б використовували [float(y) for x in l for y in x].

Ось як перетворити вкладені для циклу в розуміння вкладеного списку:

Ось як працює розуміння вкладеного списку:

            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]

Для вашого випадку це буде щось подібне.

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]

Не впевнений, який саме бажаний результат, але якщо ви використовуєте розуміння списку, порядок слід за порядком вкладених циклів, який у вас є назад. Тому я отримав те, що, на вашу думку, ви хочете:

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

Принцип полягає в тому: використовуйте той самий порядок, який ви використовували при написанні його, як вкладений для циклів.

Оскільки я тут трохи запізнююся, але мені хотілося поділитися тим, як насправді працює розуміння списку, особливо розуміння вкладеного списку:

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

насправді те саме, що:

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

А тепер розуміння вкладеного списку:

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

те саме, що;

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)

вихід:

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

Якщо вам не подобаються розуміння вкладених списків, ви також можете скористатися функцією карти ,

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

У мене була подібна проблема для вирішення, тому я натрапив на це питання. Я зробив порівняння виступу Ендрю Кларка та відповіді Нараяна, яким я хотів би поділитися.

Основна різниця між двома відповідями полягає в тому, як вони перебираються над внутрішніми списками. Один з них використовує вбудовану карту , а інший використовує розуміння списку. Функція карти має незначну перевагу у порівнянні з аналогічним списком, якщо вона не вимагає використання лямбда . Отже в контексті цього питанняmap має бути трохи краще, ніж розуміння списку.

Давайте зробимо показник ефективності, щоб побачити, чи справді це правда. Для всіх цих тестів я використовував python версії 3.5.0. У першому наборі тестів я хотів би, щоб елементів у списку було 10 та змінювали кількість списків від 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

У наступному наборі тестів я хотів би збільшити кількість елементів у списках до 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

Давайте зробимо хоробрий крок і змінимо кількість елементів у списках, щоб бути 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

З цього тесту ми можемо зробити висновок, що mapв цій справі є корисність для продуктивності порівняно із розумінням списку. Це також застосовується, якщо ви намагаєтесь подати на будь-який intабо str. Для невеликої кількості списків, що мають менше елементів на список, різниця незначна. Для більших списків, що містять більше елементів у списку, можна mapзамість розуміння списку використовувати, але це повністю залежить від потреб додатків.

Однак я особисто вважаю, що розуміння списку є більш зрозумілим та ідіоматичним, ніж map. Це стандарт фактичного в пітоні. Зазвичай люди більш досвідчені та зручні (особливо для початківців) у використанні розуміння списку, ніж map.

Так, ви можете зробити це з таким кодом:

l = [[float(y) for y in x] for x in 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']]

map(lambda x:map(lambda y:float(y),x),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]]

Найкращий спосіб зробити це, на мою думку, - використовувати itertoolsпакет 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]

Так, ви можете зробити наступне.

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

Цього можна досягти, використовуючи розуміння списку:

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