Я знаю, что objectстолбцы typeзатрудняют преобразование данных с помощью pandasфункции. Когда я получил такие данные, первое, что пришло в голову, было «сгладить» или разложить столбцы.
Я использую pandasи pythonфункцию для этого типа вопроса. Если вас беспокоит скорость вышеперечисленных решений, проверьте ответ user3483203 , поскольку он использует numpyи большую часть времени numpyработает быстрее. Рекомендую, Cpythonи numbaесли скорость имеет значение.
Метод 0 [pandas> = 0.25]
Начиная с pandas 0.25 , если вам нужно взорвать только один столбец, вы можете использовать pandas.DataFrame.explodeфункцию:
df.explode('B')
A B
0 1 1
1 1 2
0 2 1
1 2 2
Учитывая фрейм данных с пустым listили a NaNв столбце. Пустой список не вызовет проблемы, но его NaNнеобходимо заполнитьlist
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [[1, 2], [1, 2], [], np.nan]})
df.B = df.B.fillna({i: [] for i in df.index}) # replace NaN with []
df.explode('B')
A B
0 1 1
0 1 2
1 2 1
1 2 2
2 3 NaN
3 4 NaN
Метод 1
apply + pd.Series (простой для понимания, но с точки зрения производительности не рекомендуется).
df.set_index('A').B.apply(pd.Series).stack().reset_index(level=0).rename(columns={0:'B'})
Out[463]:
A B
0 1 1
1 1 2
0 2 1
1 2 2
Метод 2
Используя repeatс DataFrameконструктором, воссоздайте фрейм данных (хорошо для производительности, не подходит для нескольких столбцов)
df=pd.DataFrame({'A':df.A.repeat(df.B.str.len()),'B':np.concatenate(df.B.values)})
df
Out[465]:
A B
0 1 1
0 1 2
1 2 1
1 2 2
Например, метод 2.1 помимо A у нас есть A.1 ..... An Если мы все еще используем метод ( метод 2 ), описанный выше, нам будет трудно воссоздавать столбцы один за другим.
Решение: joinили mergeс indexпоследующим "разложением" отдельных столбцов
s=pd.DataFrame({'B':np.concatenate(df.B.values)},index=df.index.repeat(df.B.str.len()))
s.join(df.drop('B',1),how='left')
Out[477]:
B A
0 1 1
0 2 1
1 1 2
1 2 2
Если вам нужен такой же порядок столбцов, как и раньше, добавьте reindexв конце.
s.join(df.drop('B',1),how='left').reindex(columns=df.columns)
Метод 3
воссоздайтеlist
pd.DataFrame([[x] + [z] for x, y in df.values for z in y],columns=df.columns)
Out[488]:
A B
0 1 1
1 1 2
2 2 1
3 2 2
Если более двух столбцов, используйте
s=pd.DataFrame([[x] + [z] for x, y in zip(df.index,df.B) for z in y])
s.merge(df,left_on=0,right_index=True)
Out[491]:
0 1 A B
0 0 1 1 [1, 2]
1 0 2 1 [1, 2]
2 1 1 2 [1, 2]
3 1 2 2 [1, 2]
Метод 4
с использованием reindex илиloc
df.reindex(df.index.repeat(df.B.str.len())).assign(B=np.concatenate(df.B.values))
Out[554]:
A B
0 1 1
0 1 2
1 2 1
1 2 2
#df.loc[df.index.repeat(df.B.str.len())].assign(B=np.concatenate(df.B.values))
Метод 5,
когда список содержит только уникальные значения:
df=pd.DataFrame({'A':[1,2],'B':[[1,2],[3,4]]})
from collections import ChainMap
d = dict(ChainMap(*map(dict.fromkeys, df['B'], df['A'])))
pd.DataFrame(list(d.items()),columns=df.columns[::-1])
Out[574]:
B A
0 1 1
1 2 1
2 3 2
3 4 2
Метод 6
с использованием numpyдля высокой производительности:
newvalues=np.dstack((np.repeat(df.A.values,list(map(len,df.B.values))),np.concatenate(df.B.values)))
pd.DataFrame(data=newvalues[0],columns=df.columns)
A B
0 1 1
1 1 2
2 2 1
3 2 2
Метод 7
с использованием базовой функции itertools cycleи chain: чистое решение на Python просто для удовольствия
from itertools import cycle,chain
l=df.values.tolist()
l1=[list(zip([x[0]], cycle(x[1])) if len([x[0]]) > len(x[1]) else list(zip(cycle([x[0]]), x[1]))) for x in l]
pd.DataFrame(list(chain.from_iterable(l1)),columns=df.columns)
A B
0 1 1
1 1 2
2 2 1
3 2 2
Обобщение на несколько столбцов
df=pd.DataFrame({'A':[1,2],'B':[[1,2],[3,4]],'C':[[1,2],[3,4]]})
df
Out[592]:
A B C
0 1 [1, 2] [1, 2]
1 2 [3, 4] [3, 4]
Функция самоопределения:
def unnesting(df, explode):
idx = df.index.repeat(df[explode[0]].str.len())
df1 = pd.concat([
pd.DataFrame({x: np.concatenate(df[x].values)}) for x in explode], axis=1)
df1.index = idx
return df1.join(df.drop(explode, 1), how='left')
unnesting(df,['B','C'])
Out[609]:
B C A
0 1 1 1
0 2 2 1
1 3 3 2
1 4 4 2
Развертывание по столбцам
Все вышеперечисленные методы говорят о вертикальном разложении и разнесении. Если вам нужно развернуть список по горизонтали , проверьте с помощью pd.DataFrameконструктора
df.join(pd.DataFrame(df.B.tolist(),index=df.index).add_prefix('B_'))
Out[33]:
A B C B_0 B_1
0 1 [1, 2] [1, 2] 1 2
1 2 [3, 4] [3, 4] 3 4
Обновленная функция
def unnesting(df, explode, axis):
if axis==1:
idx = df.index.repeat(df[explode[0]].str.len())
df1 = pd.concat([
pd.DataFrame({x: np.concatenate(df[x].values)}) for x in explode], axis=1)
df1.index = idx
return df1.join(df.drop(explode, 1), how='left')
else :
df1 = pd.concat([
pd.DataFrame(df[x].tolist(), index=df.index).add_prefix(x) for x in explode], axis=1)
return df1.join(df.drop(explode, 1), how='left')
Тестовый выход
unnesting(df, ['B','C'], axis=0)
Out[36]:
B0 B1 C0 C1 A
0 1 2 1 2 1
1 3 4 3 4 2
