ajout de plusieurs colonnes pour les pandas simultanément

Je me serais attendu à votre syntaxe de travailler trop. Le problème se pose car, lorsque vous créez de nouvelles colonnes avec la colonne-syntaxe de la liste (df[[new1, new2]] = ...), les pandas exige que le côté droit soit un DataFrame (à noter qu'il n'a pas vraiment d'importance si les colonnes du DataFrame ont les mêmes noms que les colonnes que vous créez).

Votre syntaxe fonctionne très bien pour l'attribution de valeurs scalaires à existant colonnes, et les pandas est également heureux d'attribuer des valeurs scalaires pour une nouvelle colonne à l'aide de la seule colonne de la syntaxe (df[new1] = ...). Donc la solution est soit de le convertir en une seule colonne de cession, ou créer vous-même un DataFrame pour le côté droit.

Voici plusieurs approches que sera travail:

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'col_1': [0, 1, 2, 3],
    'col_2': [4, 5, 6, 7]
})

Ensuite l'une des opérations suivantes:

(1) Techniquement, c'est trois étapes, mais il semble comme une étape:

df['column_new_1'], df['column_new_2'], df['column_new_3'] = [np.nan, 'dogs', 3]

(2) DataFrame idéalement étend une seule ligne correspond à l'index, de sorte que vous pouvez le faire:

df[['column_new_1', 'column_new_2', 'column_new_3']] = pd.DataFrame([[np.nan, 'dogs', 3]], index=df.index)

(3) Ce serait bien travailler si vous faites une temporaire de la trame de données avec de nouvelles colonnes, puis de les combiner avec les données d'origine image plus tard:

df = pd.concat(
    [
        df,
        pd.DataFrame(
            [[np.nan, 'dogs', 3]], 
            index=df.index, 
            columns=['column_new_1', 'column_new_2', 'column_new_3']
        )
    ], axis=1
)

(4) Similaire à la précédente, mais en utilisant join au lieu de concat (peut être moins efficace):

df = df.join(pd.DataFrame(
    [[np.nan, 'dogs', 3]], 
    index=df.index, 
    columns=['column_new_1', 'column_new_2', 'column_new_3']
))

(5) C'est une façon "naturelle" pour créer le nouveau bloc de données que les deux précédents, mais les nouvelles colonnes sont triés par ordre alphabétique (au moins avant de Python 3.6 ou 3.7):

df = df.join(pd.DataFrame(
    {
        'column_new_1': np.nan,
        'column_new_2': 'dogs',
        'column_new_3': 3
    }, index=df.index
))

(6) j'aime bien cette variante sur @zéro de répondre à beaucoup de choses, mais comme le précédent, le nouveau colonnes seront toujours classés par ordre alphabétique, au moins avec les premières versions de Python:

df = df.assign(column_new_1=np.nan, column_new_2='dogs', column_new_3=3)

(7) Ce qui est intéressant (basé sur https://stackoverflow.com/a/44951376/3830997), mais je ne sais pas quand il sera en vaut la peine:

new_cols = ['column_new_1', 'column_new_2', 'column_new_3']
new_vals = [np.nan, 'dogs', 3]
df = df.reindex(columns=df.columns.tolist() + new_cols)   # add empty cols
df[new_cols] = new_vals  # multi-column assignment works for existing cols

(8) À la fin c'est difficile de battre cette:

df['column_new_1'] = np.nan
df['column_new_2'] = 'dogs'
df['column_new_3'] = 3

Note: plusieurs de ces options ont déjà été abordés dans d'autres réponses: Ajouter plusieurs colonnes à DataFrame et leur égale à une colonne existante, Est-il possible d'ajouter plusieurs colonnes à la fois à une pandas DataFrame?, Pandas: Ajouter plusieurs colonnes vides à DataFrame

Avec l'utilisation de concat:

In [128]: df
Out[128]: 
   col_1  col_2
0      0      4
1      1      5
2      2      6
3      3      7

In [129]: pd.concat([df, pd.DataFrame(columns = [ 'column_new_1', 'column_new_2','column_new_3'])])
Out[129]: 
   col_1  col_2 column_new_1 column_new_2 column_new_3
0    0.0    4.0          NaN          NaN          NaN
1    1.0    5.0          NaN          NaN          NaN
2    2.0    6.0          NaN          NaN          NaN
3    3.0    7.0          NaN          NaN          NaN

Pas très sûr de ce que tu voulais faire avec [np.nan, 'dogs',3]. Peut-être que maintenant définir les valeurs par défaut?

In [142]: df1 = pd.concat([df, pd.DataFrame(columns = [ 'column_new_1', 'column_new_2','column_new_3'])])
In [143]: df1[[ 'column_new_1', 'column_new_2','column_new_3']] = [np.nan, 'dogs', 3]

In [144]: df1
Out[144]: 
   col_1  col_2  column_new_1 column_new_2  column_new_3
0    0.0    4.0           NaN         dogs             3
1    1.0    5.0           NaN         dogs             3
2    2.0    6.0           NaN         dogs             3
3    3.0    7.0           NaN         dogs             3

Veux juste souligner que option2 dans @Matthias Fripp la réponse de

(2) je n'aurais pas forcément s'attendre à DataFrame travailler de cette façon, mais il ne

df[['column_new_1', 'column_new_2', 'column_new_3']] = pd.DataFrame([[np.nan, 'chiens', 3]], index=df.index)

est déjà documentée dans des pandas propre documentation
http://pandas.pydata.org/pandas-docs/stable/indexing.html#basics

Vous pouvez passer d'une liste de colonnes de [] pour sélectionner les colonnes dans l'ordre.
Si une colonne n'est pas contenue dans le DataFrame, une exception sera levée.
Plusieurs colonnes peuvent également être réglés de cette manière.
Vous pouvez trouver cela utile pour l'application d'une transformation (en place) à un sous-ensemble de colonnes.

si l'ajout d'un grand nombre de colonnes manquantes (a, b, c ,....) avec la même valeur, ici 0, j'ai fait ça:

    new_cols = ["a", "b", "c" ] 
    df[new_cols] = pd.DataFrame([[0] * len(new_cols)], index=df.index)

Il est basé sur la deuxième variante de la accepté de répondre.