Ik heb een dataframe:
s1 = pd.Series([5, 6, 7])
s2 = pd.Series([7, 8, 9])
df = pd.DataFrame([list(s1), list(s2)], columns = ["A", "B", "C"])
A B C
0 5 6 7
1 7 8 9
[2 rows x 3 columns]
En ik moet een eerste rij toevoegen [2, 3, 4] om te krijgen:
A B C
0 2 3 4
1 5 6 7
2 7 8 9
Ik heb het append()en concat()Functies, maar kan de juiste manier niet vinden.
Serie toevoegen / invoegen aan dataframe?
Antwoord 1, Autoriteit 100%
Wijs gewoon rij toe aan een bepaalde index, met loc:
df.loc[-1] = [2, 3, 4] # adding a row
df.index = df.index + 1 # shifting index
df = df.sort_index() # sorting by index
en u krijgt, zoals gewenst:
A B C
0 2 3 4
1 5 6 7
2 7 8 9
Zie in Pandas Documentatie Indexering: Instellen met vergroting .
Antwoord 2, Autoriteit 22%
Niet zeker hoe u concat()belt, maar het zou moeten werken zolang beide objecten van hetzelfde type zijn. Misschien is het probleem dat je je tweede vector naar een dataframe nodig hebt? Gebruik de DF die u de volgende werken voor mij hebt gedefinieerd:
df2 = pd.DataFrame([[2,3,4]], columns=['A','B','C'])
pd.concat([df2, df])
Antwoord 3, Autoriteit 16%
Een manier om dit te bereiken is
>>> pd.DataFrame(np.array([[2, 3, 4]]), columns=['A', 'B', 'C']).append(df, ignore_index=True)
Out[330]:
A B C
0 2 3 4
1 5 6 7
2 7 8 9
Over het algemeen is het het gemakkelijkst om dataframes toe te voegen, niet series. In uw geval, aangezien u wilt dat de nieuwe rij “bovenaan” staat (met start-id), en er geen functie pd.prepend()is, maak ik eerst het nieuwe dataframe en voeg vervolgens uw oude.
ignore_indexnegeert de oude lopende index in uw dataframe en zorgt ervoor dat de eerste rij daadwerkelijk begint met index 1in plaats van opnieuw te starten met index 0.
Typische disclaimer: Cetero censeo … het toevoegen van rijen is een behoorlijk inefficiënte operatie. Als je om prestaties geeft en er op de een of andere manier voor kunt zorgen dat je eerst een dataframe maakt met de juiste (langere) index en dan gewoon de extra rij invoegtin het dataframe, moet je dat zeker doen. Zie:
>>> index = np.array([0, 1, 2])
>>> df2 = pd.DataFrame(columns=['A', 'B', 'C'], index=index)
>>> df2.loc[0:1] = [list(s1), list(s2)]
>>> df2
Out[336]:
A B C
0 5 6 7
1 7 8 9
2 NaN NaN NaN
>>> df2 = pd.DataFrame(columns=['A', 'B', 'C'], index=index)
>>> df2.loc[1:] = [list(s1), list(s2)]
Tot nu toe hebben we wat je had als df:
>>> df2
Out[339]:
A B C
0 NaN NaN NaN
1 5 6 7
2 7 8 9
Maar nu kunt u de rij eenvoudig als volgt invoegen. Omdat de ruimte vooraf is toegewezen, is dit efficiënter.
>>> df2.loc[0] = np.array([2, 3, 4])
>>> df2
Out[341]:
A B C
0 2 3 4
1 5 6 7
2 7 8 9
Antwoord 4, autoriteit 10%
Ik heb een korte functie samengesteld die wat meer flexibiliteit biedt bij het invoegen van een rij:
def insert_row(idx, df, df_insert):
dfA = df.iloc[:idx, ]
dfB = df.iloc[idx:, ]
df = dfA.append(df_insert).append(dfB).reset_index(drop = True)
return df
wat verder kan worden ingekort tot:
def insert_row(idx, df, df_insert):
return df.iloc[:idx, ].append(df_insert).append(df.iloc[idx:, ]).reset_index(drop = True)
Dan zou je zoiets kunnen gebruiken als:
df = insert_row(2, df, df_new)
waarbij 2de indexpositie is in dfwaar u df_newwilt invoegen.
Antwoord 5, autoriteit 5%
We kunnen numpy.insert. Dit heeft het voordeel van flexibiliteit. U hoeft alleen de index op te geven waarin u wilt invoegen.
s1 = pd.Series([5, 6, 7])
s2 = pd.Series([7, 8, 9])
df = pd.DataFrame([list(s1), list(s2)], columns = ["A", "B", "C"])
pd.DataFrame(np.insert(df.values, 0, values=[2, 3, 4], axis=0))
0 1 2
0 2 3 4
1 5 6 7
2 7 8 9
Voor np.insert(df.values, 0, values=[2, 3, 4], axis=0), 0 vertelt de functie De plaats / index die u de nieuwe wilt plaatsen waarden.
Antwoord 6, Autoriteit 5%
Het is vrij eenvoudig om een rij toe te voegen aan een panda’s DataFrame:
-
Maak een normaal Python-woordenboek met dezelfde kolommen namen als uw
DataFrame; -
Gebruik
pandas.append()-methode en passeer de naam van uw Woordenboek, waar.append()een methode op dataframe-instanties is; -
Toevoegen
ignore_index=TrueRecht na uw woordenboeknaam.
Antwoord 7, Autoriteit 4%
Dit lijkt misschien overdreven eenvoudig, maar het is ongelooflijk dat een eenvoudige nieuwe rij-functie is niet ingebouwd. Ik heb veel gelezen over het toevoegen van een nieuwe DF aan het origineel, maar ik vraag me af of dit sneller zou zijn.
df.loc[0] = [row1data, blah...]
i = len(df) + 1
df.loc[i] = [row2data, blah...]
Antwoord 8, Autoriteit 4%
Hieronder zou de beste manier zijn om een rij in Pandas Dataframe in te voegen zonder een index te sorteren en te resetten:
import pandas as pd
df = pd.DataFrame(columns=['a','b','c'])
def insert(df, row):
insert_loc = df.index.max()
if pd.isna(insert_loc):
df.loc[0] = row
else:
df.loc[insert_loc + 1] = row
insert(df,[2,3,4])
insert(df,[8,9,0])
print(df)
Antwoord 9, Autoriteit 2%
Testen van een paar antwoorden Het is duidelijk dat het gebruik van pd.append()efficiënter is voor grote dataframes.
Als je de prestaties vergelijkt met dicten list, is de listefficiënter, maar voor kleine dataframes, met een dictzou geen probleem moeten zijn en iets leesbaarder.
1e – pd.append() + list
%%timeit
df = pd.DataFrame(columns=['a', 'b'])
for i in range(10000):
df = pd.concat([pd.DataFrame([[1,2]], columns=df.columns), df], ignore_index=True)
4,88 s± 47,1 ms per lus (gemiddelde ± standaard ontwikkeling van 7 runs, elk 1 lus)
2e – pd.append() + dict
%%timeit
df = pd.DataFrame(columns=['a', 'b'])
for i in range(10000):
df = df.append({'a': 1, 'b': 2}, ignore_index=True)
10,2 s± 41,4 ms per lus (gemiddelde ± standaard ontwikkeling van 7 runs, elk 1 lus)
3e – pd.DataFrame().loc + index operations
%%timeit
df = pd.DataFrame(columns=['a','b'])
for i in range(10000):
df.loc[-1] = [1,2]
df.index = df.index + 1
df = df.sort_index()
17,5 s± 37,3 ms per lus (gemiddelde ± standaard ontwikkeling van 7 runs, elk 1 lus)
Antwoord 10
concat()lijkt iets sneller te zijn dan het invoegen en opnieuw indexeren van de laatste rij.
Mocht iemand zich afvragen wat de snelheid is van twee topbenaderingen:
In [x]: %%timeit
...: df = pd.DataFrame(columns=['a','b'])
...: for i in range(10000):
...: df.loc[-1] = [1,2]
...: df.index = df.index + 1
...: df = df.sort_index()
17,1 s ± 705 ms per lus (gemiddelde ± standaard ontwikkeling van 7 runs, elk 1 lus)
In [y]: %%timeit
...: df = pd.DataFrame(columns=['a', 'b'])
...: for i in range(10000):
...: df = pd.concat([pd.DataFrame([[1,2]], columns=df.columns), df])
6,53s ± 127 ms per lus (gemiddelde ± standaard ontwikkeling van 7 runs, elk 1 lus)
Antwoord 11
U kunt de rij eenvoudig aan het einde van het DataFrame toevoegen en vervolgens de index aanpassen.
Bijvoorbeeld:
df = df.append(pd.DataFrame([[2,3,4]],columns=df.columns),ignore_index=True)
df.index = (df.index + 1) % len(df)
df = df.sort_index()
Of gebruik concatals:
df = pd.concat([pd.DataFrame([[1,2,3,4,5,6]],columns=df.columns),df],ignore_index=True)
Antwoord 12
Het kwam net bij me op dat T-attribuutmisschien een geldige keuze is. Transpose, kan ontsnappen aan de enigszins misleidende df.loc[-1] = [2, 3, 4]zoals @flow2k al zei, en het is geschikt voor meer universele situatie zoals u [2, 3, 4]wilt invoegen voor een willekeurige rij, wat moeilijk is voor concat(),append()bereiken. En het is niet nodig om de moeite te nemen om een functie te definiëren en te debuggen.
a = df.T
a.insert(0,'anyName',value=[2,3,4])
# just give insert() any column name you want, we'll rename it.
a.rename(columns=dict(zip(a.columns,[i for i in range(a.shape[1])])),inplace=True)
# set inplace to a Boolean as you need.
df=a.T
df
A B C
0 2 3 4
1 5 6 7
2 7 8 9
Ik denk dat dit de klacht van @mattcochane gedeeltelijk kan verklaren over waarom Panda’s geen methode heeft om een rij zoals insert () in te voegen.
Antwoord 13
De eenvoudigste manier voegen een rij toe in een Pandas-gegevensframe is:
DataFrame.loc[ location of insertion ]= list( )
Voorbeeld:
DF.loc[ 9 ] = [ ´Pepe’ , 33, ´Japan’ ]
NB: De lengte van uw lijst moet overeenkomen met die van het gegevensframe.