So führen Sie eine Serie und DataFrame

Wenn Sie hierher gekommen auf der Suche nach Informationen über , wie
führen Sie eine DataFrame und Series auf dem index, schauen Sie bitte in diese
Antwort.

Die OP ' s ursprüngliche Absicht war, zu Fragen zuweisen Serie Elemente
als Spalten zu einer anderen DataFrame. Wenn Sie daran interessiert sind, die
Antwort auf diese, Blick auf die akzeptierte Antwort von EdChum.

Besten, die ich mit oben kommen kann ist

df = pd.DataFrame({'a':[1, 2], 'b':[3, 4]})  # see EDIT below
s = pd.Series({'s1':5, 's2':6})

for name in s.index:
    df[name] = s[name]

   a  b  s1  s2
0  1  3   5   6
1  2  4   5   6

Kann jemand empfehlen, eine bessere syntax /schnellere Methode?

Meine versuche:

df.merge(s)
AttributeError: 'Series' object has no attribute 'columns'

und

df.join(s)
ValueError: Other Series must have a name

BEARBEITEN Die ersten zwei Antworten markiert ein problem mit meiner Frage, so nutzen Sie bitte das folgende Konstrukt df:

df = pd.DataFrame({'a':[np.nan, 2, 3], 'b':[4, 5, 6]}, index=[3, 5, 6])

dem abschließenden Ergebnis

    a  b  s1  s2
3 NaN  4   5   6
5   2  5   5   6
6   3  6   5   6

InformationsquelleAutor Nathan Lloyd | 2014-10-08

19

Könnte man konstruieren Sie einen dataframe aus der Serie und dann verschmelzen Sie mit der dataframe.
So geben Sie die Daten als Werte sondern multiplizieren Sie Sie durch die Länge, legen Sie die Spalten für den index und set-params für die left_index und right_index zu Wahren:
```
In [27]:

df.merge(pd.DataFrame(data = [s.values] * len(s), columns = s.index), left_index=True, right_index=True)
Out[27]:
   a  b  s1  s2
0  1  3   5   6
1  2  4   5   6
```
BEARBEITEN für die situation, wo Sie möchten, dass der index konstruiert df aus der Serie zu verwenden, den index der df dann können Sie Folgendes tun:
```
df.merge(pd.DataFrame(data = [s.values] * len(df), columns = s.index, index=df.index), left_index=True, right_index=True)
```
Dies setzt Voraus, dass die Indizes der Länge entsprechen.

InformationsquelleAutor EdChum
125

Update

Von v0.24.0 ab, führen Sie auf DataFrame und die Serie so lange wie die Serie benannt ist.
```
df.merge(s.rename('new'), left_index=True, right_index=True)
# If series is already named,
# df.merge(s, left_index=True, right_index=True)
```
Heute, können Sie einfach konvertieren Sie die Serie zu einem DataFrame mit to_frame(). Also (wenn der Beitritt auf den index):
```
df.merge(s.to_frame(), left_index=True, right_index=True)
```
- Über die Frage der Definitionen von df und s diese Antwort gibt für mich eine leere dataframe, nicht das Ergebnis angeforderte in Frage. Wir wollen nicht auf entsprechen-index; wir übertragen wollen, die s Werte für alle Zeilen der df.
- Dies ist die Lösung ein anderes problem: "gegeben ein DataFrame und Serien, wie können Sie zusammengeführt werden, auf dem index". OP ' s Frage war "ordnen Sie jedem element einer Reihe, wie eine neue Spalte in einem DataFrame".
InformationsquelleAutor Nicholas Morley
4

Hier ist eine Möglichkeit:
```
df.join(pd.DataFrame(s).T).fillna(method='ffill')
```
Zu brechen, was hier passiert...

pd.DataFrame(s).T erstellt ein ein-Zeilen-DataFrame aus s die wie folgt aussieht:
```
   s1  s2
0   5   6
```
Weiter join verkettet diesen neuen Rahmen mit df:
```
   a  b  s1  s2
0  1  3   5   6
1  2  4 NaN NaN
```
Schließlich die NaN Werte mit index 1 sind gefüllt mit den vorherigen Werten in der Spalte mit fillna mit der vorwärts-fill (ffill) argument:
```
   a  b  s1  s2
0  1  3   5   6
1  2  4   5   6
```
Zu vermeiden, mit fillna es ist möglich, pd.concat wiederholen Sie die Zeilen des DataFrame konstruiert aus s. In diesem Fall die Allgemeine Lösung ist:
```
df.join(pd.concat([pd.DataFrame(s).T] * len(df), ignore_index=True))
```
Hier ist eine andere Lösung, die die Indexierung Herausforderung in der bearbeiteten Frage:
```
df.join(pd.DataFrame(s.repeat(len(df)).values.reshape((len(df), -1), order='F'), 
        columns=s.index, 
        index=df.index))
```
s verwandelt sich in einen DataFrame durch Wiederholung die Werte und Umformen (Angabe 'Fortran' um), und auch die übergabe in die entsprechende Spalte ein Namen-und Stichwortverzeichnis. Diese neuen DataFrame wird dann verbunden, um df.
- Schöne one-liner, ein Nachteil ist, dass alle NaN ' s schon in der df erhalten so gut gefüllt.
- Vielen Dank und guter Punkt. Ich habe bearbeitet, um eine alternative zu vermeiden, welche Füllung in NaN Werte.
- Was passiert mit EdChums originelle Antwort auf die überarbeitete Antwort. Wenn Baue ich die df mit, sagen wir, index=[3, 5] die neuen Spalten enthalten, die nan ' s nach Ihrem Befehl.
- Wieder bearbeitet! Es sollte nun die Erfüllung Ihrer neuen Anforderungen.
- Ihre Antwort ist 20x schneller, aber es ist immer noch ein Unterschied von ~100ms mit df an 1e5 Zeilen. Meine for-Schleife ist entsetzlich langsam. BTW in deiner Antwort die 2 sein sollte len(df) im Allgemeinen anwendbar.
- Grüße! Edit 2 nicht mehr zu funktionieren scheint. Ich bekomme ValueError: Shape of passed values is (2, 2), indices imply (2, 3) wenn ich versuche, und führen Sie diese.
- vielen Dank für den Hinweis auf das Problem! Ich habe bearbeitet die Antwort: ich hoffe der code funktioniert und ist mehr allgemein jetzt.
InformationsquelleAutor Alex Riley
0

Wenn ich könnte Ihnen die Einrichtung Ihres dataframes wie diese (auto-Indizierung):
```
df = pd.DataFrame({'a':[np.nan, 1, 2], 'b':[4, 5, 6]})
```
dann können Sie Ihre s1 und s2 die Werte so (mit Form - () Rückgabe der Anzahl der Zeilen von df):
```
s = pd.DataFrame({'s1':[5]*df.shape[0], 's2':[6]*df.shape[0]})
```
dann das Ergebnis das Sie wollen, ist einfach:
```
display (df.merge(s, left_index=True, right_index=True))
```
Alternativ, fügen Sie einfach die neuen Werte an Ihre dataframe df:
```
df = pd.DataFrame({'a':[nan, 1, 2], 'b':[4, 5, 6]})
df['s1']=5
df['s2']=6
display(df)
```
Beide zurück:
```
     a  b  s1  s2
0  NaN  4   5   6
1  1.0  5   5   6
2  2.0  6   5   6
```
Wenn Sie eine andere Liste von Daten (anstelle von nur einem einzigen Wert zu gelten), und Sie wissen, es ist in der gleichen Reihenfolge wie df, eg:
```
s1=['a','b','c']
```
dann können Sie dies in der gleichen Weise:
```
df['s1']=s1
```
gibt:
```
     a  b s1
0  NaN  4  a
1  1.0  5  b
2  2.0  6  c
```
InformationsquelleAutor James
0

Können Sie ganz einfach einen Pandabären.DataFrame Spalte, um eine Konstante. Diese Konstante kann ein int, wie in deinem Beispiel. Wenn die Spalte, die Sie angeben, ist nicht in der df, dann pandas wird, erstellen Sie eine neue Spalte mit dem Namen, den Sie angeben. So, nachdem Ihr dataframe errichtet wird, ist (aus deiner Frage):
```
df = pd.DataFrame({'a':[np.nan, 2, 3], 'b':[4, 5, 6]}, index=[3, 5, 6])
```
Führen Sie einfach:
```
df['s1'], df['s2'] = 5, 6
```
Könnten Sie schreiben, eine Schleife oder Verständnis zu machen, tun Sie dies für alle Elemente in einer Liste von Tupeln, oder von Schlüsseln und Werten in einem dictionary-je nachdem, wie Sie Ihre echte Daten gespeichert.

InformationsquelleAutor Alex

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.