wake-up-neo.net

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)
123
Vincent

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

51
Chang She

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
92
MaxU

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
83
DMulligan
33

Ä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
12
inodb

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

6
cs95

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
5
jlln

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
4
Ted Petrou

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

3
piRSquared

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.

2

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"})
2
cgels

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
1
Shahar Katz

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"])
1
Pavel

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)

 Speed

Spitzenspeicherauslastung: (weniger ist besser)

 Peak memory usage

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.

1
krassowski

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
0
Naga Kiran

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

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

enter image description here

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.

0
Harsha Reddy