Quelle est la signification de “l'axe” de l'attribut dans une Pandas DataFrame?

En prenant 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

Depuis axis=0 les colonnes, je pense que tha concat() ne considère que les colonnes que l'on trouve dans les deux dataframes. Mais le acutal sortie considère lignes que l'on trouve dans les deux dataframes.

Ce qui est exactement le sens de axis paramètre?

Il n'est pas sur l'axe de l'argument. C'est à propos de join='inner'. Regarder les docs!

join: {‘inner’, ‘outer’}, default ‘outer’. How to handle indexes on other axis(es). Outer for union and inner for intersection

Pensez Catholique Romaine. ou "R" - "C" ou de lignes - Colonnes -> Zéro ou Un.

OriginalL'auteur lxdthriller | 2016-09-02

14

Si quelqu'un a besoin d'une description visuelle, voici l'image:

Vous pouvez suivre ce lien: stackoverflow.com/questions/22149584/...

OriginalL'auteur debaonline4u

De 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ées horizontalement (axis=1), à l'aide de index des éléments trouvé dans les deux DFs (aligné par des index pour les joindre):

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ées verticalement (par DÉFAUT: axis=0), à l'aide de colonnes trouvé dans les deux DFs:

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 le inner méthode join - vous aurez de cette façon:

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

OriginalL'auteur MaxU

5

C'est mon truc avec de l'axe: il suffit d'ajouter de l'opération dans votre esprit pour faire son clair:
- axe 0 = lignes
- de l'axe 1 = colonnes
Si vous “somme” par le biais de l'axe=0, vous additionnez toutes les lignes, et le résultat sera une seule ligne avec le même nombre de colonnes.
Si vous “somme” par le biais de l'axe=1, vous additionnez toutes les colonnes, et le résultat sera une seule colonne avec le même nombre de lignes.

OriginalL'auteur Rod292
3

Interpréter l'axe=0 pour appliquer l'algorithme en bas de chaque colonne ou de la ligne d'étiquettes (l'index).. plus détaillée du schéma ici.

Si vous faites une interprétation générale de votre cas, l'algorithme est ici concat. Ainsi, pour axis=0, cela signifie:

pour chaque colonne, de prendre toutes les lignes vers le bas (dans tous les dataframes pour concat) , et de ne communiquer avec eux lorsqu'ils sont en commun (parce que vous avez sélectionné join=inner).

De sorte que le sens serait de prendre toutes les colonnes x et concat dans les lignes qui serait pile chaque bloc de lignes l'une après l'autre. Cependant, ici x n'est pas présent partout, de sorte qu'il n'est pas conservé pour le résultat final. La même chose s'applique pour z. Pour y le résultat est conservé comme y est dans tous les dataframes. C'est le résultat que vous avez.

OriginalL'auteur Boud

D'abord, OP mal compris les lignes et les colonnes dans son dataframe.

Mais la acutal sortie considère les lignes qui se trouvent dans les deux dataframes.(le seul élément de ligne "y")

OP pensée l'étiquette y est pour ligne. 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 d'être induit en erreur puisque dans le dictionnaire, il ressemble à y et x sont deux lignes.

Si vous générez df1 à partir d'une liste de liste, il devrait être plus intuitive:

df1 = pd.DataFrame([[1,3], 
                    [2,4],
                    [3,5],
                    [4,6],
                    [5,7]],
                    index=['a', 'b', 'c', 'd', 'e'], columns=["x", "y"])

Donc, pour revenir au problème, concat est un raccourci pour concaténer (moyens à lier dans une série ou de la chaîne sur cette voie [source]) de la scène concat le long de axe 0 signifie à la liaison entre les deux objets le long de l'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

Donc... pensez que vous avez le sentiment maintenant. Qu'en est somme fonction dans les pandas? Ce n' sum(axis=0) signifie?

Supposons que les données ressemble à

   1 2
   1 2
   1 2

Peut-être...en additionnant le long de l'axe 0, vous pouvez le deviner. Oui!!

^  ^  ^
|  |  |               
s  a  a               
u  l  x                
m  o  i   gives you two values 3 6 !
|  n  s               
v  g  0               
   |  |
   V  V

Ce sujet dropna? Supposons que vous avez données

   1  2  NaN
  NaN 3   5
   2  4   6

et vous ne voulez garder

2
3
4

Sur la documentation, il est dit objet de Retour avec des étiquettes sur l'axe omis où alternativement l'une ou de la totalité des données sont manquantes

Devrait vous mettre dropna(axis=0) ou dropna(axis=1)? Pensez-y et essayez-la 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 à le mot le long de.

OriginalL'auteur Tai

Vous devez vous connecter pour publier un commentaire.