Concaténer toutes les colonnes dans une pandas dataframe

J'ai plusieurs pandas dataframe qui peut avoir un nombre différent de colonnes et le nombre de ces colonnes varient généralement de 50 à 100. J'ai besoin de créer une dernière colonne qui est tout simplement de toutes les colonnes concaténées. Fondamentalement, la chaîne dans la première rangée de la colonne doit être la somme(concaténation) des cordes sur la première ligne de toutes les colonnes. J'ai écrit la boucle ci-dessous, mais je pense que cela pourrait être une meilleure façon la plus efficace de le faire. Toutes les idées sur la façon de faire

num_columns = df.columns.shape[0]
col_names = df.columns.values.tolist()
df.loc[:, 'merged'] = ""
for each_col_ind in range(num_columns):
    print('Concatenating', col_names[each_col_ind])
    df.loc[:, 'merged'] = df.loc[:, 'merged'] + df[col_names[each_col_ind]]

OriginalL'auteur Clock Slave | 2017-03-14

  1. 12

    Solution avec somme, mais la sortie est float, afin de convertir à int et str est nécessaire:

    df['new'] = df.sum(axis=1).astype(int).astype(str)

    Une autre solution avec apply fonction join, mais il le slowiest:

    df['new'] = df.apply(''.join, axis=1)

    Dernier très rapide numpy solution - convertir numpy array et puis "somme":

    df['new'] = df.values.sum(axis=1)

    Timings:

    df = pd.DataFrame({'A': ['1', '2', '3'], 'B': ['4', '5', '6'], 'C': ['7', '8', '9']})
#[30000 rows x 3 columns]
df = pd.concat([df]*10000).reset_index(drop=True)
#print (df)

cols = list('ABC')

#not_a_robot solution
In [259]: %timeit df['concat'] = pd.Series(df[cols].fillna('').values.tolist()).str.join('')
100 loops, best of 3: 17.4 ms per loop

In [260]: %timeit df['new'] = df[cols].astype(str).apply(''.join, axis=1)
1 loop, best of 3: 386 ms per loop

In [261]: %timeit df['new1'] = df[cols].values.sum(axis=1)
100 loops, best of 3: 6.5 ms per loop

In [262]: %timeit df['new2'] = df[cols].astype(str).sum(axis=1).astype(int).astype(str)
10 loops, best of 3: 68.6 ms per loop

    MODIFIER Si dtypes de certaines colonnes ne sont pas object (évidemment strings) fonte par DataFrame.astype:

    df['new'] = df.astype(str).values.sum(axis=1)

    OriginalL'auteur jezrael

  2. 13
    df = pd.DataFrame({'A': ['1', '2', '3'], 'B': ['4', '5', '6'], 'C': ['7', '8', '9']})

df['concat'] = pd.Series(df.fillna('').values.tolist()).str.join('')

    Nous donne:

    df
Out[6]: 
   A  B  C concat
0  1  4  7    147
1  2  5  8    258
2  3  6  9    369

    De sélectionner un ensemble de colonnes:

    df['concat'] = pd.Series(df[['A', 'B']].fillna('').values.tolist()).str.join('')

df
Out[8]: 
   A  B  C concat
0  1  4  7     14
1  2  5  8     25
2  3  6  9     36

    Cependant, j'ai remarqué que l'approche peut parfois entraîner NaNs étant peuplées où ils ne devraient pas, voici donc une autre façon:

    >>> from functools import reduce
>>> df['concat'] = df[cols].apply(lambda x: reduce(lambda a, b: a + b, x), axis=1)
>>> df
   A  B  C concat
0  1  4  7    147
1  2  5  8    258
2  3  6  9    369

    Mais il convient de noter que cette approche est beaucoup plus lente:

    $ python3 -m timeit 'import pandas as pd;from functools import reduce; df=pd.DataFrame({"a": ["this", "is", "a", "string"] * 5000, "b": ["this", "is", "a", "string"] * 5000});[df[["a", "b"]].apply(lambda x: reduce(lambda a, b: a + b, x)) for _ in range(10)]'
10 loops, best of 3: 451 msec per loop

    Contre

    $ python3 -m timeit 'import pandas as pd;from functools import reduce; df=pd.DataFrame({"a": ["this", "is", "a", "string"] * 5000, "b": ["this", "is", "a", "string"] * 5000});[pd.Series(df[["a", "b"]].fillna("").values.tolist()).str.join(" ") for _ in range(10)]'
10 loops, best of 3: 98.5 msec per loop
    C'est peut-être parce que je suis en utilisant une version plus récente de python, mais j'ai copié exactement ce que vous avez eu et il n'a pas de travail. Dataframe et tous. J'utilise la version 3.7.0

    OriginalL'auteur blacksite

  3. 3

    Je n'ai pas assez de réputation pour le commentaire, donc je suis en train de construire ma réponse hors de blacksite réponse.

    Pour plus de clarté, la boîte à lunch a fait observer qu'il a échoué pour Python 3.7.0. Elle n'a pas pour moi sur Python 3.6.3. Voici l'original de la réplique par blacksite:

    df['concat'] = pd.Series(df.fillna('').values.tolist()).str.join('')

    Voici ma modification pour Python 3.6.3:

    df['concat'] = pd.Series(df.fillna('').values.tolist()).map(lambda x: ''.join(map(str,x)))
    Merci, @corporelle. Je me suis retrouvé dans le même scénario, et votre réponse m'a aidé.

    OriginalL'auteur bodily11

  4. 0

    Les solutions données ci-dessus que l'utilisation des tableaux numpy ont travaillé très bien pour moi.

    Cependant, une chose d'être prudent, c'est l'indexation lorsque vous obtenez la numpy.ndarray de df.values, depuis les étiquettes de l'axe sont retirés de df.values.

    Donc, pour prendre l'une des solutions proposées ci-dessus (celui que j'utilise le plus souvent) comme un exemple:

    df['concat'] = pd.Series(df.fillna('').values.tolist()).str.join('')

    Cette partie:

    df.fillna('').values

    ne permet pas de conserver les indices de l'origine DataFrame. Pas un problème lorsque la DataFrame a la commune 0, 1, 2, ... ligne schéma d'indexation, mais cette solution ne fonctionnera pas lorsque le DataFrame est indexée dans aucun autre manière. Vous pouvez résoudre ce problème en ajoutant une index= argument pd.Series():

    df['concat'] = pd.Series(df.fillna('').values.tolist(), 
                         index=df.index).str.join('')

    J'ai toujours ajouter le index= argument, juste pour être sûr, même si je suis sûr que le DataFrame de ligne est indexé comme 0, 1, 2, ...

    OriginalL'auteur nick_montpetit