Ich bevorzuge diese Lösung:
col = df.pop("Mid")
df.insert(0, col.name, col)
Es ist einfacher zu lesen und schneller als andere vorgeschlagene Antworten.
def move_column_inplace(df, col, pos):
col = df.pop(col)
df.insert(pos, col.name, col)
Leistungsbewertung:
Bei diesem Test wird die aktuell letzte Spalte bei jeder Wiederholung nach vorne verschoben. In-Place-Methoden weisen im Allgemeinen eine bessere Leistung auf. Während die Lösung von citynorman direkt umgesetzt werden kann, kann die Methode von Ed Chum und die Methode von .locsachinnm reindexnicht.
Während andere Methoden generisch sind, beschränkt sich die Lösung von citynorman auf pos=0. Ich habe keinen Leistungsunterschied zwischen df.loc[cols]und festgestellt df[cols], weshalb ich einige andere Vorschläge nicht aufgenommen habe.
Ich habe mit Python 3.6.8 und Pandas 0.24.2 auf einem MacBook Pro getestet (Mitte 2015).
import numpy as np
import pandas as pd
n_cols = 11
df = pd.DataFrame(np.random.randn(200000, n_cols),
columns=range(n_cols))
def move_column_inplace(df, col, pos):
col = df.pop(col)
df.insert(pos, col.name, col)
def move_to_front_normanius_inplace(df, col):
move_column_inplace(df, col, 0)
return df
def move_to_front_chum(df, col):
cols = list(df)
cols.insert(0, cols.pop(cols.index(col)))
return df.loc[:, cols]
def move_to_front_chum_inplace(df, col):
col = df[col]
df.drop(col.name, axis=1, inplace=True)
df.insert(0, col.name, col)
return df
def move_to_front_elpastor(df, col):
cols = [col] + [ c for c in df.columns if c!=col ]
return df[cols] # or df.loc[cols]
def move_to_front_sachinmm(df, col):
cols = df.columns.tolist()
cols.insert(0, cols.pop(cols.index(col)))
df = df.reindex(columns=cols, copy=False)
return df
def move_to_front_citynorman_inplace(df, col):
# This approach exploits that reset_index() moves the index
# at the first position of the data frame.
df.set_index(col, inplace=True)
df.reset_index(inplace=True)
return df
def test(method, df):
col = np.random.randint(0, n_cols)
method(df, col)
col = np.random.randint(0, n_cols)
ret_mine = move_to_front_normanius_inplace(df.copy(), col)
ret_chum1 = move_to_front_chum(df.copy(), col)
ret_chum2 = move_to_front_chum_inplace(df.copy(), col)
ret_elpas = move_to_front_elpastor(df.copy(), col)
ret_sach = move_to_front_sachinmm(df.copy(), col)
ret_city = move_to_front_citynorman_inplace(df.copy(), col)
# Assert equivalence of solutions.
assert(ret_mine.equals(ret_chum1))
assert(ret_mine.equals(ret_chum2))
assert(ret_mine.equals(ret_elpas))
assert(ret_mine.equals(ret_sach))
assert(ret_mine.equals(ret_city))
Ergebnisse :
# For n_cols = 11:
%timeit test(move_to_front_normanius_inplace, df)
# 1.05 ms ± 42.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit test(move_to_front_citynorman_inplace, df)
# 1.68 ms ± 46.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit test(move_to_front_sachinmm, df)
# 3.24 ms ± 96.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum, df)
# 3.84 ms ± 114 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_elpastor, df)
# 3.85 ms ± 58.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum_inplace, df)
# 9.67 ms ± 101 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
# For n_cols = 31:
%timeit test(move_to_front_normanius_inplace, df)
# 1.26 ms ± 31.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_citynorman_inplace, df)
# 1.95 ms ± 260 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_sachinmm, df)
# 10.7 ms ± 348 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum, df)
# 11.5 ms ± 869 µs per loop (mean ± std. dev. of 7 runs, 100 loops each
%timeit test(move_to_front_elpastor, df)
# 11.4 ms ± 598 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit test(move_to_front_chum_inplace, df)
# 31.4 ms ± 1.89 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
df = df.insert(0, col.name, col)müssen wir stattdessen tundf.insert(0, col.name, col). Sie haben es aber richtig in der Funktionmove_column_inplace().Mir hat nicht gefallen, wie ich alle anderen Spalten in den anderen Lösungen explizit angeben musste, daher funktionierte dies am besten für mich. Obwohl es für große Datenrahmen langsam sein könnte ...?
df = df.set_index('Mid').reset_index()quelle
reset_index()um den abgelegten Index an der ersten Position einzufügen. Beachten Sie jedoch, dass dieses Verhalten in den Dokumenten nicht angegeben ist .inplace=Truefür beideset_index()und zu verwendenreset_index().Hier ist ein allgemeiner Satz von Code, den ich häufig verwende, um die Position von Spalten neu zu ordnen. Sie können es nützlich finden.
quelle
Um die Zeilen eines DataFrame neu anzuordnen, verwenden Sie einfach eine Liste wie folgt.
Dies macht sehr deutlich, was beim späteren Lesen des Codes getan wurde. Auch verwenden:
Dann ausschneiden und zur Neuordnung einfügen.
Speichern Sie für einen DataFrame mit vielen Spalten die Liste der Spalten in einer Variablen und fügen Sie die gewünschte Spalte an den Anfang der Liste. Hier ist ein Beispiel:
Jetzt
df.columnshat.quelle
Hier ist eine sehr einfache Antwort darauf.
Vergessen Sie nicht die zwei (()) 'Klammern' um die Spaltennamen. Andernfalls erhalten Sie einen Fehler.
quelle
Das Einfachste, was Sie versuchen können, ist:
quelle