Quelle est la signification de l'attribut "axe" dans un Pandas DataFrame?
Prenons l'exemple suivant:
>>> df1 = pd.DataFrame({"x":[1, 2, 3, 4, 5],
"y":[3, 4, 5, 6, 7]},
index=['a', 'b', 'c', 'd', 'e'])
>>> df2 = pd.DataFrame({"y":[1, 3, 5, 7, 9],
"z":[9, 8, 7, 6, 5]},
index=['b', 'c', 'd', 'e', 'f'])
>>> pd.concat([df1, df2], join='inner')
La sortie est:
y
a 3
b 4
c 5
d 6
e 7
b 1
c 3
d 5
e 7
f 9
Puisque axis=0 Est la colonne, je pense que la concat() ne considère que colonnes qui se trouvent dans les deux cadres de données. Mais la sortie réelle considère lignes qui se trouvent dans les deux cadres de données.
Quelle est la signification exacte du paramètre axis?
Si quelqu'un a besoin d'une description visuelle, voici l'image:
Les données:
In [55]: df1
Out[55]:
x y
a 1 3
b 2 4
c 3 5
d 4 6
e 5 7
In [56]: df2
Out[56]:
y z
b 1 9
c 3 8
d 5 7
e 7 6
f 9 5
Concaténé horizontalement (axe = 1), en utilisant éléments d'index trouvé dans les deux FD (aligné par les index de jonction):
In [57]: pd.concat([df1, df2], join='inner', axis=1)
Out[57]:
x y y z
b 2 4 1 9
c 3 5 3 8
d 4 6 5 7
e 5 7 7 6
Concaténé verticalement (DEFAULT: axis = 0), en utilisant colonnes trouvé dans les deux FD:
In [58]: pd.concat([df1, df2], join='inner')
Out[58]:
y
a 3
b 4
c 5
d 6
e 7
b 1
c 3
d 5
e 7
f 9
Si vous n'utilisez pas la méthode inner join, vous l'obtiendrez ainsi:
In [62]: pd.concat([df1, df2])
Out[62]:
x y z
a 1.0 3 NaN
b 2.0 4 NaN
c 3.0 5 NaN
d 4.0 6 NaN
e 5.0 7 NaN
b NaN 1 9.0
c NaN 3 8.0
d NaN 5 7.0
e NaN 7 6.0
f NaN 9 5.0
In [63]: pd.concat([df1, df2], axis=1)
Out[63]:
x y y z
a 1.0 3.0 NaN NaN
b 2.0 4.0 1.0 9.0
c 3.0 5.0 3.0 8.0
d 4.0 6.0 5.0 7.0
e 5.0 7.0 7.0 6.0
f NaN NaN 9.0 5.0
C’est mon tour avec l’axe: ajoutez simplement l’opération dans votre esprit pour que le son soit clair:
- axe 0 = lignes
- axe 1 = colonnes
Si vous "somme" par l'axe = 0, vous additionnez toutes les lignes et la sortie sera une seule ligne avec le même nombre de colonnes. Si vous "somme" par l'axe = 1, vous additionnez toutes les colonnes et le résultat sera une colonne unique avec le même nombre de lignes.
Premièrement, OP a mal compris les lignes et les colonnes de son cadre de données.
Mais la sortie actuelle prend en compte les lignes qui se trouvent dans les deux cadres de données (seul élément de ligne commun 'y').
OP pensait que l'étiquette y était pour row. Cependant, y est un nom de colonne.
df1 = pd.DataFrame(
{"x":[1, 2, 3, 4, 5], # <-- looks like row x but actually col x
"y":[3, 4, 5, 6, 7]}, # <-- looks like row y but actually col y
index=['a', 'b', 'c', 'd', 'e'])
print(df1)
\col x y
index or row\
a 1 3 | a
b 2 4 v x
c 3 5 r i
d 4 6 o s
e 5 7 w 0
-> column
a x i s 1
Il est très facile de se tromper car dans le dictionnaire, il apparaît que y et x sont deux lignes.
Si vous générez df1 À partir d'une liste, il devrait être plus intuitif:
df1 = pd.DataFrame([[1,3],
[2,4],
[3,5],
[4,6],
[5,7]],
index=['a', 'b', 'c', 'd', 'e'], columns=["x", "y"])
Revenons donc au problème, concat est un raccourci pour concatenate (signifie relier une série ou une chaîne de cette façon [source] ) Exécuter concat le long de axe 0 signifie relier deux objets le long de axe 0.
1
1 <-- series 1
1
^ ^ ^
| | | 1
c a a 1
o l x 1
n o i gives you 2
c n s 2
a g 0 2
t | |
| V V
v
2
2 <--- series 2
2
Alors ... pense que tu as le sentiment maintenant. Qu'en est-il de sum dans les pandas? Que signifie sum(axis=0)?
Supposons que les données ressemblent à
1 2
1 2
1 2
Peut-être ... en sommant le long de axe 0, vous pouvez deviner. Oui!!
^ ^ ^
| | |
s a a
u l x
m o i gives you two values 3 6 !
| n s
v g 0
| |
V V
Qu'en est-il de dropna ? Supposons que vous ayez des données
1 2 NaN
NaN 3 5
2 4 6
et vous voulez seulement garder
2
3
4
Dans la documentation, il est indiqué Retourne un objet avec des étiquettes sur un axe donné, omis ou, à tour de rôle, une ou toutes les données sont manquantes
Devriez-vous mettre dropna(axis=0) ou dropna(axis=1)? Pensez-y et essayez-le avec
df = pd.DataFrame([[1, 2, np.nan],
[np.nan, 3, 5],
[2, 4, 6]])
# df.dropna(axis=0) or df.dropna(axis=1) ?
Astuce: pensez à la Parole long.
Interprétez axis = 0 pour appliquer l’algorithme en bas de chaque colonne ou aux étiquettes de lignes (l’index). Un schéma plus détaillé ici .
Si vous appliquez cette interprétation générale à votre cas, l'algorithme ici est concat. Donc pour axe = 0, cela signifie:
pour chaque colonne, supprimez toutes les lignes (dans toutes les images de données pour concat) et contactez-les lorsqu'elles sont en commun (car vous avez sélectionné join=inner).
Le sens serait donc de prendre toutes les colonnes x et de les concaténer sur les lignes pour empiler chaque bloc de lignes les unes après les autres. Cependant, ici x n'est pas présent partout, il n'est donc pas conservé pour le résultat final. La même chose s'applique pour z. Pour y, le résultat est conservé car y est présent dans toutes les images. C'est le résultat que vous avez.