Teilen Sie den Pandas-Datenframe-String-Eintrag in getrennte Zeilen
Ich habe einen pandas dataframe, in dem eine Spalte von Textzeichenfolgen durch Kommas getrennte Werte enthält. Ich möchte jedes CSV-Feld aufteilen und pro Eintrag eine neue Zeile erstellen. Zum Beispiel sollte ab werden:
In [7]: a
Out[7]:
var1 var2
0 a,b,c 1
1 d,e,f 2
In [8]: b
Out[8]:
var1 var2
0 a 1
1 b 1
2 c 1
3 d 2
4 e 2
5 f 2
Bisher habe ich verschiedene einfache Funktionen ausprobiert, aber die .apply-Methode scheint nur eine Zeile als Rückgabewert zu akzeptieren, wenn sie auf einer Achse verwendet wird, und ich kann .transform nicht dazu bringen, zu funktionieren. Anregungen wären sehr dankbar!
Beispieldaten:
from pandas import DataFrame
import numpy as np
a = DataFrame([{'var1': 'a,b,c', 'var2': 1},
{'var1': 'd,e,f', 'var2': 2}])
b = DataFrame([{'var1': 'a', 'var2': 1},
{'var1': 'b', 'var2': 1},
{'var1': 'c', 'var2': 1},
{'var1': 'd', 'var2': 2},
{'var1': 'e', 'var2': 2},
{'var1': 'f', 'var2': 2}])
Ich weiß, dass dies nicht funktionieren wird, weil wir DataFrame-Metadaten verlieren, indem wir numpy durchgehen, aber es sollte Ihnen einen Eindruck davon vermitteln, was ich versucht habe:
def fun(row):
letters = row['var1']
letters = letters.split(',')
out = np.array([row] * len(letters))
out['var1'] = letters
a['idx'] = range(a.shape[0])
z = a.groupby('idx')
z.transform(fun)
Wie wäre es mit so etwas:
In [55]: pd.concat([Series(row['var2'], row['var1'].split(','))
for _, row in a.iterrows()]).reset_index()
Out[55]:
index 0
0 a 1
1 b 1
2 c 1
3 d 2
4 e 2
5 f 2
Dann müssen Sie nur noch die Spalten umbenennen
UPDATE2: generischere vektorisierte Funktion, die für mehrere normal- und mehrere list-Spalten funktioniert
def explode(df, lst_cols, fill_value='', preserve_index=False):
# make sure `lst_cols` is list-alike
if (lst_cols is not None
and len(lst_cols) > 0
and not isinstance(lst_cols, (list, Tuple, np.ndarray, pd.Series))):
lst_cols = [lst_cols]
# all columns except `lst_cols`
idx_cols = df.columns.difference(lst_cols)
# calculate lengths of lists
lens = df[lst_cols[0]].str.len()
# preserve original index values
idx = np.repeat(df.index.values, lens)
# create "exploded" DF
res = (pd.DataFrame({
col:np.repeat(df[col].values, lens)
for col in idx_cols},
index=idx)
.assign(**{col:np.concatenate(df.loc[lens>0, col].values)
for col in lst_cols}))
# append those rows that have empty lists
if (lens == 0).any():
# at least one list in cells is empty
res = (res.append(df.loc[lens==0, idx_cols], sort=False)
.fillna(fill_value))
# revert the original index order
res = res.sort_index()
# reset index if requested
if not preserve_index:
res = res.reset_index(drop=True)
return res
Demo:
Mehrere list-Spalten - Alle list-Spalten müssen in jeder Zeile die gleiche Anzahl von Elementen haben:
In [134]: df
Out[134]:
aaa myid num text
0 10 1 [1, 2, 3] [aa, bb, cc]
1 11 2 [] []
2 12 3 [1, 2] [cc, dd]
3 13 4 [] []
In [135]: explode(df, ['num','text'], fill_value='')
Out[135]:
aaa myid num text
0 10 1 1 aa
1 10 1 2 bb
2 10 1 3 cc
3 11 2
4 12 3 1 cc
5 12 3 2 dd
6 13 4
ursprüngliche Indexwerte beibehalten:
In [136]: explode(df, ['num','text'], fill_value='', preserve_index=True)
Out[136]:
aaa myid num text
0 10 1 1 aa
0 10 1 2 bb
0 10 1 3 cc
1 11 2
2 12 3 1 cc
2 12 3 2 dd
3 13 4
Konfiguration:
df = pd.DataFrame({
'aaa': {0: 10, 1: 11, 2: 12, 3: 13},
'myid': {0: 1, 1: 2, 2: 3, 3: 4},
'num': {0: [1, 2, 3], 1: [], 2: [1, 2], 3: []},
'text': {0: ['aa', 'bb', 'cc'], 1: [], 2: ['cc', 'dd'], 3: []}
})
CSV-Spalte:
In [46]: df
Out[46]:
var1 var2 var3
0 a,b,c 1 XX
1 d,e,f,x,y 2 ZZ
In [47]: explode(df.assign(var1=df.var1.str.split(',')), 'var1')
Out[47]:
var1 var2 var3
0 a 1 XX
1 b 1 XX
2 c 1 XX
3 d 2 ZZ
4 e 2 ZZ
5 f 2 ZZ
6 x 2 ZZ
7 y 2 ZZ
mit diesem kleinen Trick können wir eine CSV-ähnliche Spalte in eine list-Spalte konvertieren:
In [48]: df.assign(var1=df.var1.str.split(','))
Out[48]:
var1 var2 var3
0 [a, b, c] 1 XX
1 [d, e, f, x, y] 2 ZZ
UPDATE:generischer vektorisierter Ansatz (funktioniert auch für mehrere Spalten):
Ursprünglicher DF:
In [177]: df
Out[177]:
var1 var2 var3
0 a,b,c 1 XX
1 d,e,f,x,y 2 ZZ
Lösung:
lassen Sie uns zunächst CSV-Zeichenfolgen in Listen konvertieren:
In [178]: lst_col = 'var1'
In [179]: x = df.assign(**{lst_col:df[lst_col].str.split(',')})
In [180]: x
Out[180]:
var1 var2 var3
0 [a, b, c] 1 XX
1 [d, e, f, x, y] 2 ZZ
Jetzt können wir das machen:
In [181]: pd.DataFrame({
...: col:np.repeat(x[col].values, x[lst_col].str.len())
...: for col in x.columns.difference([lst_col])
...: }).assign(**{lst_col:np.concatenate(x[lst_col].values)})[x.columns.tolist()]
...:
Out[181]:
var1 var2 var3
0 a 1 XX
1 b 1 XX
2 c 1 XX
3 d 2 ZZ
4 e 2 ZZ
5 f 2 ZZ
6 x 2 ZZ
7 y 2 ZZ
ALTE Antwort:
Inspiriert durch die @AFinkelstein-Lösung wollte ich es etwas verallgemeinert machen, das auf DF mit mehr als zwei Spalten und so schnell, fast so schnell wie die AFinkelstein-Lösung angewendet werden kann.
In [2]: df = pd.DataFrame(
...: [{'var1': 'a,b,c', 'var2': 1, 'var3': 'XX'},
...: {'var1': 'd,e,f,x,y', 'var2': 2, 'var3': 'ZZ'}]
...: )
In [3]: df
Out[3]:
var1 var2 var3
0 a,b,c 1 XX
1 d,e,f,x,y 2 ZZ
In [4]: (df.set_index(df.columns.drop('var1',1).tolist())
...: .var1.str.split(',', expand=True)
...: .stack()
...: .reset_index()
...: .rename(columns={0:'var1'})
...: .loc[:, df.columns]
...: )
Out[4]:
var1 var2 var3
0 a 1 XX
1 b 1 XX
2 c 1 XX
3 d 2 ZZ
4 e 2 ZZ
5 f 2 ZZ
6 x 2 ZZ
7 y 2 ZZ
Nach schmerzhaften Experimenten, um etwas schneller als die akzeptierte Antwort zu finden, bekam ich dies zum Laufen. Es lief ungefähr 100x schneller auf dem Dataset, auf dem ich es ausprobierte.
Wenn jemand einen Weg kennt, dies eleganter zu gestalten, ändern Sie auf jeden Fall meinen Code. Ich konnte keinen Weg finden, der funktioniert, ohne die anderen Spalten, die Sie behalten möchten, als Index festzulegen und dann den Index zurückzusetzen und die Spalten umzubenennen, aber ich kann mir vorstellen, dass noch etwas anderes funktioniert.
b = DataFrame(a.var1.str.split(',').tolist(), index=a.var2).stack()
b = b.reset_index()[[0, 'var2']] # var1 variable is currently labeled 0
b.columns = ['var1', 'var2'] # renaming var1
Hier ist eine -Funktion, die ich für diese allgemeine Aufgabe geschrieben habe. Es ist effizienter als die Variablen Seriesstack. Spaltenreihenfolge und Namen werden beibehalten.
def tidy_split(df, column, sep='|', keep=False):
"""
Split the values of a column and expand so the new DataFrame has one split
value per row. Filters rows where the column is missing.
Params
------
df : pandas.DataFrame
dataframe with the column to split and expand
column : str
the column to split and expand
sep : str
the string used to split the column's values
keep : bool
whether to retain the presplit value as it's own row
Returns
-------
pandas.DataFrame
Returns a dataframe with the same columns as `df`.
"""
indexes = list()
new_values = list()
df = df.dropna(subset=[column])
for i, presplit in enumerate(df[column].astype(str)):
values = presplit.split(sep)
if keep and len(values) > 1:
indexes.append(i)
new_values.append(presplit)
for value in values:
indexes.append(i)
new_values.append(value)
new_df = df.iloc[indexes, :].copy()
new_df[column] = new_values
return new_df
Mit dieser Funktion ist die _/ursprüngliche Frage so einfach wie:
tidy_split(a, 'var1', sep=',')
Ähnliche Frage als: pandas: Wie teile ich Text in einer Spalte in mehrere Zeilen auf?
Du könntest es tun:
>> a=pd.DataFrame({"var1":"a,b,c d,e,f".split(),"var2":[1,2]})
>> s = a.var1.str.split(",").apply(pd.Series, 1).stack()
>> s.index = s.index.droplevel(-1)
>> del a['var1']
>> a.join(s)
var2 var1
0 1 a
0 1 b
0 1 c
1 2 d
1 2 e
1 2 f
Pandas> = 0,25
Serien- und DataFrame-Methoden definieren eine .explode() -Methode, die Listen in separate auflöst Reihen. Weitere Informationen finden Sie im Dokumentabschnitt zu Auflösen einer listenähnlichen Spalte .
Da Sie eine Liste von durch Kommas getrennten Zeichenfolgen haben, teilen Sie die Zeichenfolge durch Kommas, um eine Liste der Elemente zu erhalten, und rufen Sie dann explode in dieser Spalte auf.
df = pd.DataFrame({'var1': ['a,b,c', 'd,e,f'], 'var2': [1, 2]})
df
var1 var2
0 a,b,c 1
1 d,e,f 2
df.assign(var1=df['var1'].str.split(',')).explode('var1')
var1 var2
0 a 1
0 b 1
0 c 1
1 d 2
1 e 2
1 f 2
Beachten Sie, dass explode (vorerst) nur für eine einzelne Spalte gilt .
NaNs und leere Listen erhalten die Behandlung, die sie verdienen, ohne dass Sie durch die Reifen springen müssen, um es richtig zu machen.
df = pd.DataFrame({'var1': ['d,e,f', '', np.nan], 'var2': [1, 2, 3]})
df
var1 var2
0 d,e,f 1
1 2
2 NaN 3
df['var1'].str.split(',')
0 [d, e, f]
1 []
2 NaN
df.assign(var1=df['var1'].str.split(',')).explode('var1')
var1 var2
0 d 1
0 e 1
0 f 1
1 2 # empty list entry becomes empty string after exploding
2 NaN 3 # NaN left un-touched
Dies ist ein schwerwiegender Vorteil gegenüber ravel + repeat -basierten Lösungen (die leere Listen vollständig ignorieren und NaNs unterdrücken) .
Ich habe eine Lösung für Dataframes mit beliebiger Spaltenanzahl gefunden (wobei gleichzeitig immer nur die Einträge einer Spalte getrennt werden).
def splitDataFrameList(df,target_column,separator):
''' df = dataframe to split,
target_column = the column containing the values to split
separator = the symbol used to perform the split
returns: a dataframe with each entry for the target column separated, with each element moved into a new row.
The values in the other columns are duplicated across the newly divided rows.
'''
def splitListToRows(row,row_accumulator,target_column,separator):
split_row = row[target_column].split(separator)
for s in split_row:
new_row = row.to_dict()
new_row[target_column] = s
row_accumulator.append(new_row)
new_rows = []
df.apply(splitListToRows,axis=1,args = (new_rows,target_column,separator))
new_df = pandas.DataFrame(new_rows)
return new_df
Hier ist eine ziemlich unkomplizierte Nachricht, die die split-Methode von Pandas str-Accessor verwendet und dann NumPy verwendet, um jede Zeile in ein einzelnes Array zu glätten.
Die entsprechenden Werte werden abgerufen, indem die nicht aufgeteilte Spalte mit np.repeat so oft wie möglich wiederholt wird.
var1 = df.var1.str.split(',', expand=True).values.ravel()
var2 = np.repeat(df.var2.values, len(var1) / len(df))
pd.DataFrame({'var1': var1,
'var2': var2})
var1 var2
0 a 1
1 b 1
2 c 1
3 d 2
4 e 2
5 f 2
TL; DR
import pandas as pd
import numpy as np
def explode_str(df, col, sep):
s = df[col]
i = np.arange(len(s)).repeat(s.str.count(sep) + 1)
return df.iloc[i].assign(**{col: sep.join(s).split(sep)})
def explode_list(df, col):
s = df[col]
i = np.arange(len(s)).repeat(s.str.len())
return df.iloc[i].assign(**{col: np.concatenate(s)})
Demonstration
explode_str(a, 'var1', ',')
var1 var2
0 a 1
0 b 1
0 c 1
1 d 2
1 e 2
1 f 2
Erstellen wir einen neuen Datenrahmen d, der Listen enthält
d = a.assign(var1=lambda d: d.var1.str.split(','))
explode_list(d, 'var1')
var1 var2
0 a 1
0 b 1
0 c 1
1 d 2
1 e 2
1 f 2
Allgemeine Kommentare
Ich verwende np.arange mit repeat, um Indexpositionen für Datenrahmen zu erstellen, die ich mit iloc verwenden kann.
FAQ
Warum verwende ich nicht loc?
Da der Index möglicherweise nicht eindeutig ist und loc verwendet wird, wird jede Zeile zurückgegeben, die einem abgefragten Index entspricht.
Warum verwenden Sie nicht das values-Attribut und schneiden dieses ab?
Wenn beim Aufruf von values die Gesamtheit des Datenrahmens in einem zusammenhängenden "Block" enthalten ist, gibt Pandas eine Ansicht des Arrays zurück, das der "Block" ist. Andernfalls müssen Pandas ein neues Array zusammenstellen. Dieses Array muss beim Cobbling einen einheitlichen dtype haben. Dies bedeutet oft, dass Sie ein Array mit dtype zurückgeben, das object ist. Indem Sie iloc anstelle des Attributs values verwenden, kann ich mich nicht damit abfinden.
Warum verwenden Sie assign?
Wenn ich assign unter Verwendung des gleichen Spaltennamens verwende, den ich explodiere, überschreibe ich die vorhandene Spalte und bewahre ihre Position im Datenrahmen.
Warum wiederholen sich die Indexwerte?
Durch die Verwendung von iloc für wiederholte Positionen zeigt der resultierende Index dasselbe wiederholte Muster. Wiederholen Sie für jedes Element die Liste oder den String.
Dies kann mit reset_index(drop=True) zurückgesetzt werden
Für Streicher
Ich möchte die Saiten nicht vorzeitig spalten. Stattdessen zähle ich das Vorkommen des sep-Arguments. Ich gehe davon aus, dass die Länge der Ergebnisliste um eins größer wäre als die Anzahl der Trennzeichen, wenn ich teilen würde.
Ich verwende dann diese sep, um join die Zeichenketten dann split.
def explode_str(df, col, sep):
s = df[col]
i = np.arange(len(s)).repeat(s.str.count(sep) + 1)
return df.iloc[i].assign(**{col: sep.join(s).split(sep)})
Für Listen
Ähnlich wie bei Strings, außer dass ich Vorkommen von sep nicht zählen muss, da es bereits aufgeteilt ist.
Ich benutze Numpys concatenate, um die Listen zusammenzufassen.
import pandas as pd
import numpy as np
def explode_list(df, col):
s = df[col]
i = np.arange(len(s)).repeat(s.str.len())
return df.iloc[i].assign(**{col: np.concatenate(s)})
Basierend auf der ausgezeichneten @ DMulligans Lösung ist hier eine generische vektorisierte Funktion (keine Schleifen), die eine Spalte eines Datenrahmens in mehrere Zeilen aufteilt und sie wieder mit dem ursprünglichen Datenrahmen verbindet. Es verwendet auch eine große generische change_column_order-Funktion aus dieser Antwort .
def change_column_order(df, col_name, index):
cols = df.columns.tolist()
cols.remove(col_name)
cols.insert(index, col_name)
return df[cols]
def split_df(dataframe, col_name, sep):
orig_col_index = dataframe.columns.tolist().index(col_name)
orig_index_name = dataframe.index.name
orig_columns = dataframe.columns
dataframe = dataframe.reset_index() # we need a natural 0-based index for proper merge
index_col_name = (set(dataframe.columns) - set(orig_columns)).pop()
df_split = pd.DataFrame(
pd.DataFrame(dataframe[col_name].str.split(sep).tolist())
.stack().reset_index(level=1, drop=1), columns=[col_name])
df = dataframe.drop(col_name, axis=1)
df = pd.merge(df, df_split, left_index=True, right_index=True, how='inner')
df = df.set_index(index_col_name)
df.index.name = orig_index_name
# merge adds the column to the last place, so we need to move it back
return change_column_order(df, col_name, orig_col_index)
Beispiel:
df = pd.DataFrame([['a:b', 1, 4], ['c:d', 2, 5], ['e:f:g:h', 3, 6]],
columns=['Name', 'A', 'B'], index=[10, 12, 13])
df
Name A B
10 a:b 1 4
12 c:d 2 5
13 e:f:g:h 3 6
split_df(df, 'Name', ':')
Name A B
10 a 1 4
10 b 1 4
12 c 2 5
12 d 2 5
13 e 3 6
13 f 3 6
13 g 3 6
13 h 3 6
Beachten Sie, dass der ursprüngliche Index und die Reihenfolge der Spalten beibehalten werden. Es funktioniert auch mit Datenrahmen, die einen nicht sequentiellen Index haben.
Die Zeichenfolge-Funktion kann ein optionales boolesches Argument 'expand' annehmen.
Hier ist eine Lösung, die dieses Argument verwendet:
a.var1.str.split(",",expand=True).set_index(a.var2).stack().reset_index(level=1, drop=True).reset_index().rename(columns={0:"var1"})
die Antwort von MaxU wurde mit MultiIndex-Unterstützung aktualisiert
def explode(df, lst_cols, fill_value='', preserve_index=False):
"""
usage:
In [134]: df
Out[134]:
aaa myid num text
0 10 1 [1, 2, 3] [aa, bb, cc]
1 11 2 [] []
2 12 3 [1, 2] [cc, dd]
3 13 4 [] []
In [135]: explode(df, ['num','text'], fill_value='')
Out[135]:
aaa myid num text
0 10 1 1 aa
1 10 1 2 bb
2 10 1 3 cc
3 11 2
4 12 3 1 cc
5 12 3 2 dd
6 13 4
"""
# make sure `lst_cols` is list-alike
if (lst_cols is not None
and len(lst_cols) > 0
and not isinstance(lst_cols, (list, Tuple, np.ndarray, pd.Series))):
lst_cols = [lst_cols]
# all columns except `lst_cols`
idx_cols = df.columns.difference(lst_cols)
# calculate lengths of lists
lens = df[lst_cols[0]].str.len()
# preserve original index values
idx = np.repeat(df.index.values, lens)
res = (pd.DataFrame({
col:np.repeat(df[col].values, lens)
for col in idx_cols},
index=idx)
.assign(**{col:np.concatenate(df.loc[lens>0, col].values)
for col in lst_cols}))
# append those rows that have empty lists
if (lens == 0).any():
# at least one list in cells is empty
res = (res.append(df.loc[lens==0, idx_cols], sort=False)
.fillna(fill_value))
# revert the original index order
res = res.sort_index()
# reset index if requested
if not preserve_index:
res = res.reset_index(drop=True)
# if original index is MultiIndex build the dataframe from the multiindex
# create "exploded" DF
if isinstance(df.index, pd.MultiIndex):
res = res.reindex(
index=pd.MultiIndex.from_tuples(
res.index,
names=['number', 'color']
)
)
return res
Ich habe folgende Lösung für dieses Problem gefunden:
def iter_var1(d):
for _, row in d.iterrows():
for v in row["var1"].split(","):
yield (v, row["var2"])
new_a = DataFrame.from_records([i for i in iter_var1(a)],
columns=["var1", "var2"])
Ich habe nur die exzellente Antwort von jiln von oben verwendet, musste aber erweitert werden, um mehrere Spalten aufzuteilen. Ich dachte, ich würde teilen.
def splitDataFrameList(df,target_column,separator):
''' df = dataframe to split,
target_column = the column containing the values to split
separator = the symbol used to perform the split
returns: a dataframe with each entry for the target column separated, with each element moved into a new row.
The values in the other columns are duplicated across the newly divided rows.
'''
def splitListToRows(row, row_accumulator, target_columns, separator):
split_rows = []
for target_column in target_columns:
split_rows.append(row[target_column].split(separator))
# Seperate for multiple columns
for i in range(len(split_rows[0])):
new_row = row.to_dict()
for j in range(len(split_rows)):
new_row[target_columns[j]] = split_rows[j][i]
row_accumulator.append(new_row)
new_rows = []
df.apply(splitListToRows,axis=1,args = (new_rows,target_column,separator))
new_df = pd.DataFrame(new_rows)
return new_df
Ich habe mit Out-of-Memory-Erfahrungen zu kämpfen, indem ich meine Listen auf verschiedene Art und Weise aufgelöst habe. Deshalb habe ich einige Benchmarks erstellt, die mir bei der Entscheidung, welche Antworten zu erwarten sind, helfen. Ich habe fünf Szenarien mit unterschiedlichen Verhältnissen der Listenlänge zur Anzahl der Listen getestet. Teilen Sie die Ergebnisse unten:
Zeit: (Weniger ist besser, klicken Sie, um die große Version anzuzeigen)
Spitzenspeicherauslastung: (weniger ist besser)
Schlussfolgerungen:
- @ MaxUs Antwort (Update 2), Codename Verketten bietet in fast allen Fällen die beste Geschwindigkeit, während die Speicherauslastung des Peek-Speichers niedrig bleibt.
- siehe @ DMulligans Antwort (Codename stack), wenn Sie viele Zeilen mit relativ kleinen Listen verarbeiten müssen und sich einen höheren Peakspeicher leisten können.
- die akzeptierte @ Changs Antwort funktioniert gut für Datenrahmen mit wenigen Zeilen, aber sehr großen Listen.
Vollständige Details (Funktionen und Benchmarking-Code) finden Sie in dieser GitHub Gist . Bitte beachten Sie, dass das Benchmark-Problem vereinfacht wurde und nicht die Aufteilung von Strings in die Liste beinhaltete - was bei den meisten Lösungen ähnlich war.
Es besteht die Möglichkeit, den Datenrahmen aufzuteilen und zu zerlegen, ohne die Struktur des Datenrahmens zu ändern
Eingang:
var1 var2
0 a,b,c 1
1 d,e,f 2
#Get the indexes which are repetative with the split
df = df.reindex(df.index.repeat(df.var1.str.split(',').apply(len)))
#Assign the split values to dataframe column
df['var1'] = sum(df.drop_duplicates(keep='first')['var1'].str.split(','),[])
Aus:
var1 var2
0 a 1
0 b 1
0 c 1
1 d 2
1 e 2
1 f 2
Eine andere Lösung, die Python Copy-Paket verwendet
import copy
new_observations = list()
def pandas_explode(df, column_to_explode):
new_observations = list()
for row in df.to_dict(orient='records'):
explode_values = row[column_to_explode]
del row[column_to_explode]
if type(explode_values) is list or type(explode_values) is Tuple:
for explode_value in explode_values:
new_observation = copy.deepcopy(row)
new_observation[column_to_explode] = explode_value
new_observations.append(new_observation)
else:
new_observation = copy.deepcopy(row)
new_observation[column_to_explode] = explode_values
new_observations.append(new_observation)
return_df = pd.DataFrame(new_observations)
return return_df
df = pandas_explode(df, column_name)
Hier gibt es viele Antworten, aber ich bin überrascht, dass niemand die eingebaute Funktion pandas explode erwähnt hat. Überprüfen Sie den folgenden Link: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.explode.html#pandas.DataFrame.explode
Aus irgendeinem Grund konnte ich nicht auf diese Funktion zugreifen, daher habe ich den folgenden Code verwendet:
import pandas_explode
pandas_explode.patch()
df_zlp_people_cnt3 = df_zlp_people_cnt2.explode('people')
Oben ist ein Beispiel meiner Daten. Wie Sie sehen können, hatte die Spalte people eine Reihe von Personen, und ich habe versucht, sie zu explodieren. Der von mir angegebene Code funktioniert für Listentypdaten. Versuchen Sie also, Ihre durch Kommas getrennten Textdaten in das Listenformat zu bringen. Da mein Code integrierte Funktionen verwendet, ist er auch viel schneller als das Anpassen/Anwenden von Funktionen.
Hinweis: Möglicherweise müssen Sie pandas_explode mit pip installieren.