Hole Liste aus Pandas-Datenframe-Spalte oder -Zeile?

Question

Ich habe ein Dataframe df aus einem Excel-Dokument importiert, das so aussieht:

cluster load_date   budget  actual  fixed_price
A   1/1/2014    1000    4000    Y
A   2/1/2014    12000   10000   Y
A   3/1/2014    36000   2000    Y
B   4/1/2014    15000   10000   N
B   4/1/2014    12000   11500   N
B   4/1/2014    90000   11000   N
C   7/1/2014    22000   18000   N
C   8/1/2014    30000   28960   N
C   9/1/2014    53000   51200   N

Ich möchte den Inhalt von Spalte 1 df['cluster'] als Liste zurückgeben können, damit ich eine for-Schleife darüber ausführen und ein Excel-Arbeitsblatt für jeden Cluster erstellen kann.

Ist es auch möglich, den Inhalt einer ganzen Spalte oder Reihe in eine Liste umzuwandeln? z.B.

list = [], list[column1] oder list[df.ix(row1)]

Answer 1

Pandas DataFrame-Spalten sind Pandas Series, wenn Sie sie herausziehen, die Sie dann mit x.tolist() aufrufen können, um sie in eine Python-Liste umzuwandeln. Alternativ können Sie es mit list(x) umwandeln.

import pandas as pd

data_dict = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
             'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(data_dict)

print(f"DataFrame:\n{df}\n")
print(f"Spaltentypen:\n{df.dtypes}")

col_one_list = df['one'].tolist()

col_one_arr = df['one'].to_numpy()

print(f"\ncol_one_list:\n{col_one_list}\nTyp:{type(col_one_list)}")
print(f"\ncol_one_arr:\n{col_one_arr}\nTyp:{type(col_one_arr)}")

Ergebnis:

DataFrame:
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

Spaltentypen:
one    float64
two      int64
dtype: object

col_one_list:
[1.0, 2.0, 3.0, nan]
Typ:

col_one_arr:
[ 1.  2.  3. nan]
Typ:

Answer 2

Dies gibt ein numpy-Array zurück:

arr = df["cluster"].to_numpy()

---

Dies gibt ein numpy-Array von einzigartigen Werten zurück:

unique_arr = df["cluster"].unique()

Sie können auch numpy verwenden, um die einzigartigen Werte zu erhalten, obwohl es Unterschiede zwischen den beiden Methoden gibt:

arr = df["cluster"].to_numpy()
unique_arr = np.unique(arr)

Answer 3

Beispielumwandlung:

Numpy-Array -> Panda-Datenrahmen -> Liste aus einer Panda-Spalte

Numpy-Array

data = np.array([[10,20,30], [20,30,60], [30,60,90]])

Wandeln Sie das Numpy-Array in einen Panda-Datenrahmen um

dataPd = pd.DataFrame(data = data)

print(dataPd)
0   1   2
0  10  20  30
1  20  30  60
2  30  60  90

Wandle eine Panda-Spalte in eine Liste um

pdToList = list(dataPd['2'])

Answer 4

Hier ist eine einfache Einzeiler:

list(df['load_date'])

Aktualisierung: toList() funktioniert nicht. Es sollte alles in Kleinbuchstaben sein: .tolist()

Answer 5

Zusammenfassung: Verwenden Sie .tolist(). Verwenden Sie nicht list()

Wenn wir den Quellcode von .tolist() betrachten, wird unter der Haube die Funktion list() auf die zugrunde liegenden Daten im DataFrame aufgerufen, daher sollten beide den gleichen Output produzieren.

Aber es scheint, als ob tolist() für Spalten mit Python-Skalaren optimiert ist, denn ich habe festgestellt, dass das Aufrufen von list() auf einer Spalte 10 Mal langsamer war als das Aufrufen von tolist(). Um es festzuhalten, ich habe versucht, eine Spalte mit JSON-Strings in einem sehr großen DataFrame in eine Liste zu konvertieren und list() hat sich Zeit gelassen. Das hat mich dazu inspiriert, die Laufzeiten der beiden Methoden zu testen.

Zur Info: Es ist nicht notwendig, .to_numpy() aufzurufen oder das Attribut .values zu erhalten, da DataFrame-Spalten/Series-Objekte bereits die Methode .tolist() implementieren. Aufgrund der Art und Weise, wie NumPy-Arrays gespeichert sind, würden list() und tolist() verschiedene Arten von Skalaren (mindestens) für numerische Spalten liefern. Zum Beispiel,

type(list(df['budget'].values)[0])     # numpy.int64
type(df['budget'].values.tolist()[0])  # int

---

Das folgende Perfplot zeigt die Laufzeitunterschiede zwischen den beiden Methoden für verschiedene Pandas-dtype-Series-Objekte. Es zeigt im Grunde die Laufzeitunterschiede zwischen den folgenden zwei Methoden:

list(df['some_col'])      # list()
df['some_col'].tolist()   # .tolist()

Wie Sie sehen können, unabhängig von der Größe der Spalte/Serie sind für numerische und Objekt-dtype-Spalten/Serien die .tolist()-Methode viel schneller als list(). Nicht hier enthalten, aber die Diagramme für Spalten des Dtyps float und bool waren sehr ähnlich zu dem des hier gezeigten int Dtyps. Auch das Diagramm für eine Objekt-Dtyp-Spalte, die Listen enthält, war sehr ähnlich zu dem Diagramm der hier gezeigten String-Spalte. Dtyp-Erweiterungen wie 'Int64Dtype', 'StringDtype', 'Float64Dtype' usw. zeigten ähnliche Muster.

Andererseits gibt es praktisch keinen Unterschied zwischen den beiden Methoden für datetime, timedelta und Categorical-Dtyp-Spalten.

Verwendeter Code zur Erstellung des obigen Plots:

from perfplot import plot
kernels = [lambda s: list(s), lambda s: s.tolist()]
labels = ['list()', '.tolist()']
n_range = [2**k for k in range(4, 20)]
xlabel = 'Zeilen im DataFrame'
eq_chk = lambda x,y: all([x,y])

numeric = lambda n: pd.Series(range(5)).repeat(n)
string = lambda n: pd.Series(['ein Wort', 'ein anderes Wort', 'ein Wort']).repeat(n)
datetime = lambda n: pd.to_datetime(pd.Series(['2012-05-14', '2046-12-31'])).repeat(n)
timedelta = lambda n: pd.to_timedelta(pd.Series([1,2]), unit='D').repeat(n)
categorical = lambda n: pd.Series(pd.Categorical([1, 2, 3, 1, 2, 3])).repeat(n)

for n, f in [('Numerisch', numeric), ('Objekt Dtyp', string), 
             ('Datetime', datetime), ('Timedelta', timedelta), 
             ('Kategorisch', categorical)]:
    plot(setup=f, kernels=kernels, labels=labels, n_range=n_range, 
         xlabel=xlabel, title=f'Spalte {n}', equality_check=eq_chk);