Pandas столбец списков, создать строку для каждого элемента списка

163

У меня есть dataframe, где некоторые ячейки содержат списки нескольких значений. Вместо того, чтобы хранить несколько значений в ячейке, я бы хотел расширить фрейм данных, чтобы каждый элемент в списке получил свою собственную строку (с такими же значениями во всех других столбцах). Так что если у меня есть:

import pandas as pd
import numpy as np

df = pd.DataFrame(
    {'trial_num': [1, 2, 3, 1, 2, 3],
     'subject': [1, 1, 1, 2, 2, 2],
     'samples': [list(np.random.randn(3).round(2)) for i in range(6)]
    }
)

df
Out[10]: 
                 samples  subject  trial_num
0    [0.57, -0.83, 1.44]        1          1
1    [-0.01, 1.13, 0.36]        1          2
2   [1.18, -1.46, -0.94]        1          3
3  [-0.08, -4.22, -2.05]        2          1
4     [0.72, 0.79, 0.53]        2          2
5    [0.4, -0.32, -0.13]        2          3

Как мне преобразовать в длинную форму, например:

   subject  trial_num  sample  sample_num
0        1          1    0.57           0
1        1          1   -0.83           1
2        1          1    1.44           2
3        1          2   -0.01           0
4        1          2    1.13           1
5        1          2    0.36           2
6        1          3    1.18           0
# etc.

Индекс не важен, можно установить существующие столбцы в качестве индекса, а окончательный порядок не важен.

python pandas list Marius
источник

11

Из панды 0,25 вы также можете использовать, df.explode('samples')чтобы решить эту проблему. explodeможет поддерживать только взрыв одного столбца на данный момент.

cs95

48

lst_col = 'samples'

r = pd.DataFrame({
      col:np.repeat(df[col].values, df[lst_col].str.len())
      for col in df.columns.drop(lst_col)}
    ).assign(**{lst_col:np.concatenate(df[lst_col].values)})[df.columns]

Результат:

In [103]: r
Out[103]:
    samples  subject  trial_num
0      0.10        1          1
1     -0.20        1          1
2      0.05        1          1
3      0.25        1          2
4      1.32        1          2
5     -0.17        1          2
6      0.64        1          3
7     -0.22        1          3
8     -0.71        1          3
9     -0.03        2          1
10    -0.65        2          1
11     0.76        2          1
12     1.77        2          2
13     0.89        2          2
14     0.65        2          2
15    -0.98        2          3
16     0.65        2          3
17    -0.30        2          3

PS здесь вы можете найти немного более общее решение

ОБНОВЛЕНИЕ: некоторые объяснения: IMO, самый простой способ понять этот код, это попытаться выполнить его шаг за шагом:

в следующей строке мы повторяем значения в одном столбце, Nгде N- длина соответствующего списка:

In [10]: np.repeat(df['trial_num'].values, df[lst_col].str.len())
Out[10]: array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3], dtype=int64)

это может быть обобщено для всех столбцов, содержащих скалярные значения:

In [11]: pd.DataFrame({
    ...:           col:np.repeat(df[col].values, df[lst_col].str.len())
    ...:           for col in df.columns.drop(lst_col)}
    ...:         )
Out[11]:
    trial_num  subject
0           1        1
1           1        1
2           1        1
3           2        1
4           2        1
5           2        1
6           3        1
..        ...      ...
11          1        2
12          2        2
13          2        2
14          2        2
15          3        2
16          3        2
17          3        2

[18 rows x 2 columns]

используя np.concatenate()мы можем сгладить все значения вlist column ( samples) и получить одномерный вектор:

In [12]: np.concatenate(df[lst_col].values)
Out[12]: array([-1.04, -0.58, -1.32,  0.82, -0.59, -0.34,  0.25,  2.09,  0.12,  0.83, -0.88,  0.68,  0.55, -0.56,  0.65, -0.04,  0.36, -0.31])

положить все это вместе:

In [13]: pd.DataFrame({
    ...:           col:np.repeat(df[col].values, df[lst_col].str.len())
    ...:           for col in df.columns.drop(lst_col)}
    ...:         ).assign(**{lst_col:np.concatenate(df[lst_col].values)})
Out[13]:
    trial_num  subject  samples
0           1        1    -1.04
1           1        1    -0.58
2           1        1    -1.32
3           2        1     0.82
4           2        1    -0.59
5           2        1    -0.34
6           3        1     0.25
..        ...      ...      ...
11          1        2     0.68
12          2        2     0.55
13          2        2    -0.56
14          2        2     0.65
15          3        2    -0.04
16          3        2     0.36
17          3        2    -0.31

[18 rows x 3 columns]

Использование pd.DataFrame()[df.columns]гарантирует, что мы выбираем столбцы в исходном порядке ...

MaxU
источник

3

Это должен быть принятый ответ. В настоящее время принятый ответ намного, намного медленнее по сравнению с этим.

Ирэн

1

Я не могу понять, как это исправить: TypeError: Невозможно привести данные массива из dtype ('float64') к dtype ('int64') в соответствии с правилом safe

Грег

1

Это единственный ответ, который сработал для меня из 10+, найденных за целый час поиска стеков. Спасибо MaxU 🙏

olisteadman

1

Обратите внимание, что это удаляет строки, которые имеют пустой список lst_colполностью; чтобы сохранить эти строки и заполнить их lst_colс np.nan, вы можете просто сделать df[lst_col] = df[lst_col].apply(lambda x: x if len(x) > 0 else [np.nan])перед использованием этого метода. Очевидно , .maskне будет возвращать списки, следовательно .apply.

Чарльз Дэвис,

Это отличный ответ, который должен быть принят. Хотя это ответ уровня черной магии, и я, например, был бы признателен за некоторые объяснения того, что на самом деле делают эти шаги.

ifly6

129

Чуть дольше, чем я ожидал:

>>> df
                samples  subject  trial_num
0  [-0.07, -2.9, -2.44]        1          1
1   [-1.52, -0.35, 0.1]        1          2
2  [-0.17, 0.57, -0.65]        1          3
3  [-0.82, -1.06, 0.47]        2          1
4   [0.79, 1.35, -0.09]        2          2
5   [1.17, 1.14, -1.79]        2          3
>>>
>>> s = df.apply(lambda x: pd.Series(x['samples']),axis=1).stack().reset_index(level=1, drop=True)
>>> s.name = 'sample'
>>>
>>> df.drop('samples', axis=1).join(s)
   subject  trial_num  sample
0        1          1   -0.07
0        1          1   -2.90
0        1          1   -2.44
1        1          2   -1.52
1        1          2   -0.35
1        1          2    0.10
2        1          3   -0.17
2        1          3    0.57
2        1          3   -0.65
3        2          1   -0.82
3        2          1   -1.06
3        2          1    0.47
4        2          2    0.79
4        2          2    1.35
4        2          2   -0.09
5        2          3    1.17
5        2          3    1.14
5        2          3   -1.79

Если вы хотите последовательный индекс, вы можете применить reset_index(drop=True)к результату.

обновление :

>>> res = df.set_index(['subject', 'trial_num'])['samples'].apply(pd.Series).stack()
>>> res = res.reset_index()
>>> res.columns = ['subject','trial_num','sample_num','sample']
>>> res
    subject  trial_num  sample_num  sample
0         1          1           0    1.89
1         1          1           1   -2.92
2         1          1           2    0.34
3         1          2           0    0.85
4         1          2           1    0.24
5         1          2           2    0.72
6         1          3           0   -0.96
7         1          3           1   -2.72
8         1          3           2   -0.11
9         2          1           0   -1.33
10        2          1           1    3.13
11        2          1           2   -0.65
12        2          2           0    0.10
13        2          2           1    0.65
14        2          2           2    0.15
15        2          3           0    0.64
16        2          3           1   -0.10
17        2          3           2   -0.76

Роман Пекар
источник

Спасибо, даже первый шаг подачи заявки на получение каждого элемента в отдельном столбце - огромная помощь. Я смог придумать немного другой способ сделать это, но все еще есть немало шагов. Видимо, это не так просто сделать в Пандах!

Мариус

1

Отличный ответ. Вы можете немного его сократить, заменив df.apply(lambda x: pd.Series(x['samples']),axis=1)на df.samples.apply(pd.Series).

Денис Голомазов

1

Примечание для читателей: это ужасно страдает от проблем с производительностью. Смотрите здесь для более эффективного решения с использованием NumPy.

cs95

2

Каково решение, когда количество выборок не одинаково для всех рядов?

СараДата

@SarahData Используйте df.explode()как показано здесь.

cs95,

64

Панды> = 0,25

Методы Series и DataFrame определяют .explode()метод, который разбивает списки на отдельные строки. См. Раздел «Документы» в разделе « Взрыв столбца в виде списка» .

df = pd.DataFrame({
    'var1': [['a', 'b', 'c'], ['d', 'e',], [], np.nan], 
    'var2': [1, 2, 3, 4]
})
df
        var1  var2
0  [a, b, c]     1
1     [d, e]     2
2         []     3
3        NaN     4

df.explode('var1')

  var1  var2
0    a     1
0    b     1
0    c     1
1    d     2
1    e     2
2  NaN     3  # empty list converted to NaN
3  NaN     4  # NaN entry preserved as-is

# to reset the index to be monotonically increasing...
df.explode('var1').reset_index(drop=True)

  var1  var2
0    a     1
1    b     1
2    c     1
3    d     2
4    e     2
5  NaN     3
6  NaN     4

Обратите внимание, что это также обрабатывает смешанные столбцы списков и скаляров, а также соответственно пустые списки и NaN (это недостаток repeatрешений на основе).

Тем не менее, вы должны отметить, что explodeработает только на одном столбце (на данный момент).

PS: если вы хотите взорвать столбец строк , вам нужно сначала разделить разделитель, а затем использовать explode. Смотрите этот (очень) связанный ответ от меня.

cs95
источник

8

Наконец, взорваться () для панд!

Кай

2

Ну наконец то! Mindblown! Отличный ответ от @MaxU выше, но это делает вещи намного проще.

пристрастился

12

Вы также можете использовать pd.concatи pd.meltдля этого:

>>> objs = [df, pd.DataFrame(df['samples'].tolist())]
>>> pd.concat(objs, axis=1).drop('samples', axis=1)
   subject  trial_num     0     1     2
0        1          1 -0.49 -1.00  0.44
1        1          2 -0.28  1.48  2.01
2        1          3 -0.52 -1.84  0.02
3        2          1  1.23 -1.36 -1.06
4        2          2  0.54  0.18  0.51
5        2          3 -2.18 -0.13 -1.35
>>> pd.melt(_, var_name='sample_num', value_name='sample', 
...         value_vars=[0, 1, 2], id_vars=['subject', 'trial_num'])
    subject  trial_num sample_num  sample
0         1          1          0   -0.49
1         1          2          0   -0.28
2         1          3          0   -0.52
3         2          1          0    1.23
4         2          2          0    0.54
5         2          3          0   -2.18
6         1          1          1   -1.00
7         1          2          1    1.48
8         1          3          1   -1.84
9         2          1          1   -1.36
10        2          2          1    0.18
11        2          3          1   -0.13
12        1          1          2    0.44
13        1          2          2    2.01
14        1          3          2    0.02
15        2          1          2   -1.06
16        2          2          2    0.51
17        2          3          2   -1.35

Наконец, если вам нужно, вы можете отсортировать базу по первым трем столбцам.

behzad.nouri
источник

1

Это работает, только если вы априори знаете, какой будет длина списков и / или если они будут иметь одинаковую длину?

Chill2Macht

9

Пытаясь пошагово поработать над решением Романа Пекара, чтобы лучше понять его, я придумал собственное решение, которое использует, meltчтобы избежать путаницы в стеке и сбросе индексов. Я не могу сказать, что это, очевидно, более ясное решение, хотя:

items_as_cols = df.apply(lambda x: pd.Series(x['samples']), axis=1)
# Keep original df index as a column so it's retained after melt
items_as_cols['orig_index'] = items_as_cols.index

melted_items = pd.melt(items_as_cols, id_vars='orig_index', 
                       var_name='sample_num', value_name='sample')
melted_items.set_index('orig_index', inplace=True)

df.merge(melted_items, left_index=True, right_index=True)

Вывод (очевидно, теперь мы можем отбросить столбец исходных образцов):

                 samples  subject  trial_num sample_num  sample
0    [1.84, 1.05, -0.66]        1          1          0    1.84
0    [1.84, 1.05, -0.66]        1          1          1    1.05
0    [1.84, 1.05, -0.66]        1          1          2   -0.66
1    [-0.24, -0.9, 0.65]        1          2          0   -0.24
1    [-0.24, -0.9, 0.65]        1          2          1   -0.90
1    [-0.24, -0.9, 0.65]        1          2          2    0.65
2    [1.15, -0.87, -1.1]        1          3          0    1.15
2    [1.15, -0.87, -1.1]        1          3          1   -0.87
2    [1.15, -0.87, -1.1]        1          3          2   -1.10
3   [-0.8, -0.62, -0.68]        2          1          0   -0.80
3   [-0.8, -0.62, -0.68]        2          1          1   -0.62
3   [-0.8, -0.62, -0.68]        2          1          2   -0.68
4    [0.91, -0.47, 1.43]        2          2          0    0.91
4    [0.91, -0.47, 1.43]        2          2          1   -0.47
4    [0.91, -0.47, 1.43]        2          2          2    1.43
5  [-1.14, -0.24, -0.91]        2          3          0   -1.14
5  [-1.14, -0.24, -0.91]        2          3          1   -0.24
5  [-1.14, -0.24, -0.91]        2          3          2   -0.91

Marius
источник

6

Для тех, кто ищет вариант ответа Романа Пекара, в котором не нужно именовать столбцы вручную:

column_to_explode = 'samples'
res = (df
       .set_index([x for x in df.columns if x != column_to_explode])[column_to_explode]
       .apply(pd.Series)
       .stack()
       .reset_index())
res = res.rename(columns={
          res.columns[-2]:'exploded_{}_index'.format(column_to_explode),
          res.columns[-1]: '{}_exploded'.format(column_to_explode)})

Чарльз Дэвис
источник

4

Я нашел самый простой способ:

Преобразовать samples столбец в DataFrame
Соединение с оригинальным дф
плавление

Показанный здесь:

    df.samples.apply(lambda x: pd.Series(x)).join(df).\
melt(['subject','trial_num'],[0,1,2],var_name='sample')

        subject  trial_num sample  value
    0         1          1      0  -0.24
    1         1          2      0   0.14
    2         1          3      0  -0.67
    3         2          1      0  -1.52
    4         2          2      0  -0.00
    5         2          3      0  -1.73
    6         1          1      1  -0.70
    7         1          2      1  -0.70
    8         1          3      1  -0.29
    9         2          1      1  -0.70
    10        2          2      1  -0.72
    11        2          3      1   1.30
    12        1          1      2  -0.55
    13        1          2      2   0.10
    14        1          3      2  -0.44
    15        2          1      2   0.13
    16        2          2      2  -1.44
    17        2          3      2   0.73

Стоит отметить, что это могло сработать только потому, что в каждом испытании было одинаковое количество образцов (3). Что-то более умное может быть необходимо для испытаний с разными размерами выборки.

Майкл Сильверстейн
источник

2

Очень поздний ответ, но я хочу добавить это:

Быстрое решение с использованием ванильного Python, которое также заботится о sample_numстолбце в примере OP. В моем большом наборе данных с более чем 10 миллионами строк и результатом с 28 миллионами строк это занимает всего около 38 секунд. Принятое решение полностью ломается с таким количеством данных и приводит к тому, что memory errorв моей системе имеется 128 ГБ ОЗУ.

df = df.reset_index(drop=True)
lstcol = df.lstcol.values
lstcollist = []
indexlist = []
countlist = []
for ii in range(len(lstcol)):
    lstcollist.extend(lstcol[ii])
    indexlist.extend([ii]*len(lstcol[ii]))
    countlist.extend([jj for jj in range(len(lstcol[ii]))])
df = pd.merge(df.drop("lstcol",axis=1),pd.DataFrame({"lstcol":lstcollist,"lstcol_num":countlist},
index=indexlist),left_index=True,right_index=True).reset_index(drop=True)

Khris
источник

2

Также очень поздно, но вот ответ от Karvy1, который хорошо сработал для меня, если у вас нет панд> = версия 0.25: https://stackoverflow.com/a/52511166/10740287

Для приведенного выше примера вы можете написать:

data = [(row.subject, row.trial_num, sample) for row in df.itertuples() for sample in row.samples]
data = pd.DataFrame(data, columns=['subject', 'trial_num', 'samples'])

Тест скорости:

%timeit data = pd.DataFrame([(row.subject, row.trial_num, sample) for row in df.itertuples() for sample in row.samples], columns=['subject', 'trial_num', 'samples'])

1,33 мс ± 74,8 мкс на цикл (среднее ± стандартное отклонение из 7 циклов, 1000 циклов в каждом)

%timeit data = df.set_index(['subject', 'trial_num'])['samples'].apply(pd.Series).stack().reset_index()

4,9 мс ± 189 мкс на цикл (среднее ± стандартное отклонение из 7 циклов, по 100 циклов в каждом)

%timeit data = pd.DataFrame({col:np.repeat(df[col].values, df['samples'].str.len())for col in df.columns.drop('samples')}).assign(**{'samples':np.concatenate(df['samples'].values)})

1,38 мс ± 25 мкс на цикл (среднее ± стандартное отклонение из 7 циклов, 1000 циклов в каждом)

Реми Петреманд
источник

1

import pandas as pd
df = pd.DataFrame([{'Product': 'Coke', 'Prices': [100,123,101,105,99,94,98]},{'Product': 'Pepsi', 'Prices': [101,104,104,101,99,99,99]}])
print(df)
df = df.assign(Prices=df.Prices.str.split(',')).explode('Prices')
print(df)

Попробуйте это в pandas> = 0.25 версия

Тапас
источник

1

Нет необходимости, .str.split(',')потому что Pricesэто уже список.

Орен

Pandas столбец списков, создать строку для каждого элемента списка

Ответы:

Панды> = 0,25