La combinaison de deux Séries dans un DataFrame dans les pandas

J'ai deux Séries s1 et s2 avec le même (non consécutifs) les indices. Comment puis-je combiner s1 et s2 deux colonnes dans un DataFrame et de garder l'un des indices comme une troisième colonne?

InformationsquelleAutor user7289 | 2013-08-05

331

Je pense que concat est une belle façon de le faire. S'ils sont présents, il utilise les attributs de nom de la Série comme les colonnes (sinon il simplement les nombres):
```
In [1]: s1 = pd.Series([1, 2], index=['A', 'B'], name='s1')

In [2]: s2 = pd.Series([3, 4], index=['A', 'B'], name='s2')

In [3]: pd.concat([s1, s2], axis=1)
Out[3]:
   s1  s2
A   1   3
B   2   4

In [4]: pd.concat([s1, s2], axis=1).reset_index()
Out[4]:
  index  s1  s2
0     A   1   3
1     B   2   4
```
Remarque: Cela s'étend à plus de 2 de la Série.
- cela évite la copie trop (par rapport à la dict solution)
- Dans un cas, il semble me dire 'ValueError: La valeur de vérité d'un tableau avec plus d'un élément est ambigu. Utiliser un.tout() ou une.tous les()' - des idées?
- ne sais pas où en seraient issus, pourriez-vous poser une autre question?
- que faire si il y a des doublons, le long de l'une ou des deux indices?
- hmmmm, je pense que cela dépend de ce que vous voulez la réponse à être... quelque chose avec de fusion: pd.merge(s1.reset_index(), s2.reset_index(), how='outer') ?
- De les pandas site web ", Il est intéressant de noter cependant, que concat (et donc d'ajouter des) fait une copie complète des données, et qui, en permanence, de réutiliser cette fonction peut créer un certain gain de performance. Si vous avez besoin d'utiliser l'opération sur plusieurs jeux de données, l'utilisation d'une compréhension de liste."
- ce "constamment réutiliser cette fonction" signifie que vous devez préférer faire la méthode concat une fois pd.concat([list_of_dataframes]) vs concating de nombreuses fois new_df = pd.DataFrame(); for df in list_of_dsf: new_df = pd.concat([new_df, df]) ou similaire.
- qu'advient-il si l'un des série existe déjà dans un dataframe, mais j'essaie alors concat cette série qui a des valeurs qui sont de plus en longueur, alors la série précédente
- Il devrait faire une jointure externe dans ce cas, MAIS vous pouvez être plus précis dans les cas de ce genre (pour utiliser une jointure de fusion). Voir pandas.pydata.org/pandas-docs/stable/merging.html
InformationsquelleAutor Andy Hayden

Pandas seront automatiquement l'alignement de ces câblés en série et de créer de l'articulation de l'index
Ils se trouvent être la même chose ici. reset_index se déplace de l'index d'une colonne.

In [2]: s1 = Series(randn(5),index=[1,2,4,5,6])

In [4]: s2 = Series(randn(5),index=[1,2,4,5,6])

In [8]: DataFrame(dict(s1 = s1, s2 = s2)).reset_index()
Out[8]: 
   index        s1        s2
0      1 -0.176143  0.128635
1      2 -1.286470  0.908497
2      4 -0.995881  0.528050
3      5  0.402241  0.458870
4      6  0.380457  0.072251

Ce code ne fonctionne.

InformationsquelleAutor Jeff

24

Pourquoi ne pas simplement utiliser .to_frame si les deux ont le même index?

>= v0.23
```
a.to_frame().join(b)
```
< v0.23
```
a.to_frame().join(b.to_frame())
```
- Peut-être que ce serait plus approprié: un.to_frame(nom = 'a').rejoignez b.to_frame(nom='b'))
InformationsquelleAutor swmfg
13

Exemple de code:
```
a = pd.Series([1,2,3,4], index=[7,2,8,9])
b = pd.Series([5,6,7,8], index=[7,2,8,9])
data = pd.DataFrame({'a': a,'b':b, 'idx_col':a.index})
```
Pandas vous permet de créer un DataFrame à partir d'un dict avec Series que les valeurs et les noms de colonnes comme les clés. Lorsqu'il trouve un Series comme une valeur, il utilise le Series indice dans le cadre de la DataFrame index. Cet alignement des données est l'un des principaux avantages de Pandas. Par conséquent, sauf si vous avez d'autres besoins, fraîchement créée DataFrame a dupliqué valeur. Dans l'exemple ci-dessus, data['idx_col'] a les mêmes données que data.index.

InformationsquelleAutor jbn
4

Pas sûr que je comprends votre question, mais est-ce ce que vous voulez faire?
```
pd.DataFrame(data=dict(s1=s1, s2=s2), index=s1.index)
```
(index=s1.index n'est même pas nécessaire ici)

InformationsquelleAutor Bertrand L
3

Une simplification de la solution basée sur join():
```
df = a.to_frame().join(b)
```
InformationsquelleAutor Lorenzo A. Rossi
3

Si je peut répondre à cette question.

Les fondamentaux de la conversion de la série à la trame de données est de comprendre que

1. Au niveau conceptuel, chaque colonne dans la trame de données est une série.

2. Et, chaque nom de colonne est un nom de clé qui correspond à une série.

Si vous garder au-dessus de deux concepts à l'esprit, vous pouvez imaginer de nombreuses façons de convertir une série de trames de données.
Une solution facile sera comme ceci:

Créer deux séries ici
```
import pandas as pd

series_1 = pd.Series(list(range(10)))

series_2 = pd.Series(list(range(20,30)))
```
Créer un vide de la trame de données avec juste souhaité noms de colonne
```
df = pd.DataFrame(columns = ['Column_name#1', 'Column_name#1'])
```
Mettre valeur de série à l'intérieur du bloc de données à l'aide de la cartographie concept
```
df['Column_name#1'] = series_1

df['Column_name#2'] = series_2
```
Résultats de la vérification de maintenant
```
df.head(5)
```
InformationsquelleAutor Sateesh

Vous devez vous connecter pour publier un commentaire.