De retour de plusieurs colonnes d'appliquer les pandas

J'ai une pandas DataFrame, df_test. Il contient une colonne "taille" qui représente la taille en octets. J'ai calculé KO, MO et GO en utilisant le code suivant:

df_test = pd.DataFrame([
    {'dir': '/Users/uname1', 'size': 994933},
    {'dir': '/Users/uname2', 'size': 109338711},
])

df_test['size_kb'] = df_test['size'].astype(int).apply(lambda x: locale.format("%.1f", x / 1024.0, grouping=True) + ' KB')
df_test['size_mb'] = df_test['size'].astype(int).apply(lambda x: locale.format("%.1f", x / 1024.0 ** 2, grouping=True) + ' MB')
df_test['size_gb'] = df_test['size'].astype(int).apply(lambda x: locale.format("%.1f", x / 1024.0 ** 3, grouping=True) + ' GB')

df_test


             dir       size       size_kb   size_mb size_gb
0  /Users/uname1     994933      971.6 KB    0.9 MB  0.0 GB
1  /Users/uname2  109338711  106,776.1 KB  104.3 MB  0.1 GB

[2 rows x 5 columns]

J'ai fait ce plus de 120 000 lignes et des fois, il faut environ 2.97 secondes par colonne * 3 = ~9 secondes selon %timeit.

Est-il de toute façon je peux faire ce plus rapide? Par exemple, je peux au lieu de retourner une colonne à la fois d'appliquer et d'exécuter 3 fois, puis-je retourner tous les trois colonnes en une seule passe pour insérer de nouveau dans l'original dataframe?

Les autres questions que j'ai trouvé a tous envie de prendre plusieurs valeurs et retourner une seule valeur. Je veux prendre qu'une seule valeur et retourner plusieurs colonnes.

InformationsquelleAutor PaulMest | 2014-05-10

pandas python

56

C'est une vieille question, mais pour être complet, vous pouvez revenir à une Série de l'application d'une fonction qui contient les nouvelles données, la prévention de la nécessité d'effectuer une itération à trois reprises. En passant axis=1 à l'application de fonction s'applique à la fonction sizes à chaque ligne de la dataframe, de retour d'une série à ajouter à un nouveau dataframe. Cette série, s, contenant les nouvelles valeurs, ainsi que les données d'origine.
```
def sizes(s):
    s['size_kb'] = locale.format("%.1f", s['size'] / 1024.0, grouping=True) + ' KB'
    s['size_mb'] = locale.format("%.1f", s['size'] / 1024.0 ** 2, grouping=True) + ' MB'
    s['size_gb'] = locale.format("%.1f", s['size'] / 1024.0 ** 3, grouping=True) + ' GB'
    return s

df_test = df_test.append(rows_list)
df_test = df_test.apply(sizes, axis=1)
```
- Je suis surpris qu'il a passé près de 2 ans sans droit de réponse. Je cherchais quelque chose d'autre et je suis tombé sur cette. Espérons qu'il n'est pas trop tard pour être utile!
- Qu'est-ce que rows_list dans cette réponse?
- Il est juste une liste de Séries à construire le Dataframe.
InformationsquelleAutor Nelz11

Utilisation s'appliquent et zip va 3 fois plus vite que la Série sorte.

def sizes(s):    
    return locale.format("%.1f", s / 1024.0, grouping=True) + ' KB', \
        locale.format("%.1f", s / 1024.0 ** 2, grouping=True) + ' MB', \
        locale.format("%.1f", s / 1024.0 ** 3, grouping=True) + ' GB'
df_test['size_kb'],  df_test['size_mb'], df_test['size_gb'] = zip(*df_test['size'].apply(sizes))

Résultat du Test sont:

Separate df.apply(): 

    100 loops, best of 3: 1.43 ms per loop

Return Series: 

    100 loops, best of 3: 2.61 ms per loop

Return tuple:

    1000 loops, best of 3: 819 µs per loop

Je suis surpris que cela n'a pas reçu plus upvotes. Merci pour le partage de la variante supplémentaire et les données de temps.
Pourriez-vous nous expliquer comment vous avez fait retour tuple? Il semble être l'option la plus rapide
Veuillez vous référer à mon exemple de code , qui est le n-uplet façon.

InformationsquelleAutor Jesse

20

Certaines réponses bien fonctionner, mais je tiens à offrir à une autre, peut-être plus "pandifyed" option. Cela fonctionne pour moi avec le courant pandas 0.23 (pas sûr si cela ne fonctionne pas dans les versions précédentes):
```
import pandas as pd

df_test = pd.DataFrame([
  {'dir': '/Users/uname1', 'size': 994933},
  {'dir': '/Users/uname2', 'size': 109338711},
])

def sizes(s):
  a = locale.format("%.1f", s['size'] / 1024.0, grouping=True) + ' KB'
  b = locale.format("%.1f", s['size'] / 1024.0 ** 2, grouping=True) + ' MB'
  c = locale.format("%.1f", s['size'] / 1024.0 ** 3, grouping=True) + ' GB'
  return a, b, c

df_test[['size_kb', 'size_mb', 'size_gb']] = df_test.apply(sizes, axis=1, result_type="expand")
```
Avis que le truc est sur la result_type paramètre de apply, qui permettra d'élargir son résultat dans un DataFrame qui peuvent être directement affecter à nouveau/ancien colonnes.
- C'est génial. Notez, cependant, que c'est pour les pandas 0.23 ce qui n'est pas tout à fait encore.
- C'est vrai... désolé... après quelques vérifications, il dos travailler avec 0.22 dans certains cas, mais j'ai été dans un environnement virtuel et effectivement en cours d'exécution 0.23 quand j'ai essayé... :/
- C'est la meilleure réponse. Merci
InformationsquelleAutor jaumebonet

Juste anothe lisible. Ce code permettra d'ajouter trois nouvelles colonnes et ses valeurs de retour de la série sans utiliser des paramètres dans l'application de fonction.

def sizes(s):

    val_kb = locale.format("%.1f", s['size'] / 1024.0, grouping=True) + ' KB'
    val_mb = locale.format("%.1f", s['size'] / 1024.0 ** 2, grouping=True) + ' MB'
    val_gb = locale.format("%.1f", s['size'] / 1024.0 ** 3, grouping=True) + ' GB'
    return pd.Series([val_kb,val_mb,val_gb],index=['size_kb','size_mb','size_gb'])

df[['size_kb','size_mb','size_gb']] = df.apply(lambda x: sizes(x) , axis=1)

Un exemple général de: https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.apply.html

df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1)

#foo  bar
#0    1    2
#1    1    2
#2    1    2

InformationsquelleAutor alvaro nortes

1

Généralement, de renvoyer plusieurs valeurs, c'est ce que je fais
```
def gimmeMultiple(group):
    x1 = 1
    x2 = 2
    return array([[1, 2]])
def gimmeMultipleDf(group):
    x1 = 1
    x2 = 2
    return pd.DataFrame(array([[1,2]]), columns=['x1', 'x2'])
df['size'].astype(int).apply(gimmeMultiple)
df['size'].astype(int).apply(gimmeMultipleDf)
```
Retour d'un dataframe définitivement a ses avantages, mais parfois pas nécessaire. Vous pouvez regarder ce que le apply() retourne et jouer un peu avec les fonctions 😉
- Merci pour cet échantillon. Cependant, cela ne veut pas sortir un dataframe pour l'ensemble des résultats. Lorsque j'essaie de l'ajouter à l'origine dataframe, j'obtiens un "ValueError: tableau n'est pas broadcastable pour corriger la forme".
- Pouvez-vous fournir le code de produire certaines données de petite taille de l'échantillon?
- Une chose est sûre. Je viens de mettre à jour le code dans mon premier post pour y inclure les données de l'échantillon et de sortie.
InformationsquelleAutor FooBar

Vous devez vous connecter pour publier un commentaire.