23 Pregunta: Agregar una nueva columna al DataFrame existente en los pandas de Python

pregunta creada en Fri, Dec 1, 2017 12:00 AM

Tengo el siguiente DataFrame indexado con columnas y filas nombradas que no son números continuos:

 
          a         b         c         d
2  0.671399  0.101208 -0.181532  0.241273
3  0.446172 -0.243316  0.051767  1.577318
5  0.614758  0.075793 -0.451460 -0.012493

Me gustaría agregar una nueva columna, 'e', al marco de datos existente y no quiero cambiar nada en el marco de datos (es decir, la nueva columna siempre tiene la misma longitud que el Marco de datos).

 
0   -0.335485
1   -1.166658
2   -0.385571
dtype: float64

Probé diferentes versiones de join, append, merge, pero no obtuve el resultado que quería, solo errores a lo sumo. ¿Cómo puedo agregar la columna e al ejemplo anterior?

    
809
  1. ¿Nueva columna de qué? ¿Serie? ¿Lista? ¿Formación? ¿Suministra valores? ¿Se generan los datos al azar? ¿Son todos los valores iguales? ¿Estás tratando de crear un relleno?
    2019-05-27 05: 14: 20Z
23 Respuestas                              23                         

Utilice los índices df1 originales para crear la serie:

 
df1['e'] = Series(np.random.randn(sLength), index=df1.index)

Editar 2015
Algunos informaron que obtuvieron el SettingWithCopyWarning con este código.
Sin embargo, el código aún se ejecuta perfectamente con la versión actual de pandas 0.16.1.

 
>>> sLength = len(df1['a'])
>>> df1
          a         b         c         d
6 -0.269221 -0.026476  0.997517  1.294385
8  0.917438  0.847941  0.034235 -0.448948

>>> df1['e'] = p.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e
6 -0.269221 -0.026476  0.997517  1.294385  1.757167
8  0.917438  0.847941  0.034235 -0.448948  2.228131

>>> p.version.short_version
'0.16.1'

El SettingWithCopyWarning tiene como objetivo informar de una asignación posiblemente no válida en una copia del Dataframe. No necesariamente dice que lo hiciste mal (puede desencadenar falsos positivos) pero a partir de 0.13.0 te hace saber que hay métodos más adecuados para el mismo propósito. Luego, si recibe la advertencia, simplemente siga sus consejos: Intente usar .loc [row_index, col_indexer] = value en su lugar

 
>>> df1.loc[:,'f'] = p.Series(np.random.randn(sLength), index=df1.index)
>>> df1
          a         b         c         d         e         f
6 -0.269221 -0.026476  0.997517  1.294385  1.757167 -0.050927
8  0.917438  0.847941  0.034235 -0.448948  2.228131  0.006109
>>> 

De hecho, este es actualmente el método más eficiente como descrito en pandas docs


Editar 2017

Como se indica en los comentarios y por @Alexander, actualmente el mejor método para agregar los valores de una Serie como una nueva columna de un DataFrame podría ser usar assign:

 
df1 = df1.assign(e=p.Series(np.random.randn(sLength)).values)
    
895
2019-05-27 05: 13: 16Z
  1. si necesita anteponer en la columna use DataFrame.insert: df1.insert (0, 'A', Series (np.random.randn (sLength), index = df1.index))
    2013-12-09 21: 48: 10Z
  2. A partir de la versión 0.12 de Pandas, creo que esta sintaxis no es óptima y advierte: SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_index,col_indexer] = value instead
    2015-01-19 10: 59: 11Z
  3. Use asignar df1.assign(e = Series(np.random.randn(sLength), index=df1.index))
    2015-11-06 09: 27: 54Z
  4. @ toto_tico Puedes desempacar un diccionario kwargs, así: df1 = df1.assign(**{'e': p.Series(np.random.randn(sLength)).values})
    2017-09-14 16: 56: 39Z
  5. En lugar de decir "actualmente" o hacer referencia a años, haga referencia a los números de versión de pandas, por ejemplo, "entre 0.14-0.16 do X, en 0.17+ do Y ..."
    2018-03-04 23: 58: 25Z

Esta es la forma sencilla de agregar una nueva columna: df['e'] = e

    
189
2016-12-10 06: 53: 58Z
  1. A pesar del alto número de votos: esta respuesta es incorrecta . Tenga en cuenta que el OP tiene un marco de datos con índices no continuos y e (Series(np.random.randn(sLength))) genera una Serie 0-n indexada. Si usted asignaesto a df1 y luego obtienes algunas células NaN.
    2014-08-26 22: 29: 12Z
  2. Lo que dice @joaquin es cierto, pero siempre que lo tengas en cuenta, este es un atajo muy útil.
    2014-09-27 02: 37: 49Z
  3. @ Eric Leschinski: No estoy seguro de cómo editar para esta pregunta. my_dataframe = pd.DataFrame(columns=('foo', 'bar')). Revirtiendo tu edición
    2016-12-10 06: 53: 33Z
  4. No ayuda, porque si tiene varias filas y usa la asignación, asigna ese valor a todas las filas de la nueva columna (en su caso, e ) lo que suele ser indeseable.
    2019-04-27 22: 42: 30Z
  

Me gustaría agregar una nueva columna, 'e', ​​al marco de datos existente y no cambiar nada en el marco de datos. (La serie siempre tiene la misma longitud que un marco de datos).

Supongo que los valores de índice en e coinciden con los de df1.

La forma más fácil de iniciar una nueva columna llamada e, y asignarle los valores de su serie e:

 
df['e'] = e.values

asignar (Pandas 0.16.0+)

A partir de Pandas 0.16.0, también puede usar assign , que asigna nuevas columnas a un DataFrame y devuelve un nuevo objeto (una copia) con todas las columnas originales además de las nuevas.

 
df1 = df1.assign(e=e.values)

según este ejemplo (que también incluye el código fuente de la función assign), También puede incluir más de una columna:

 
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
>>> df.assign(mean_a=df.a.mean(), mean_b=df.b.mean())
   a  b  mean_a  mean_b
0  1  3     1.5     3.5
1  2  4     1.5     3.5

En contexto con su ejemplo:

 
np.random.seed(0)
df1 = pd.DataFrame(np.random.randn(10, 4), columns=['a', 'b', 'c', 'd'])
mask = df1.applymap(lambda x: x <-0.7)
df1 = df1[-mask.any(axis=1)]
sLength = len(df1['a'])
e = pd.Series(np.random.randn(sLength))

>>> df1
          a         b         c         d
0  1.764052  0.400157  0.978738  2.240893
2 -0.103219  0.410599  0.144044  1.454274
3  0.761038  0.121675  0.443863  0.333674
7  1.532779  1.469359  0.154947  0.378163
9  1.230291  1.202380 -0.387327 -0.302303

>>> e
0   -1.048553
1   -1.420018
2   -1.706270
3    1.950775
4   -0.509652
dtype: float64

df1 = df1.assign(e=e.values)

>>> df1
          a         b         c         d         e
0  1.764052  0.400157  0.978738  2.240893 -1.048553
2 -0.103219  0.410599  0.144044  1.454274 -1.420018
3  0.761038  0.121675  0.443863  0.333674 -1.706270
7  1.532779  1.469359  0.154947  0.378163  1.950775
9  1.230291  1.202380 -0.387327 -0.302303 -0.509652

La descripción de esta nueva característica cuando se introdujo por primera vez se puede encontrar en here .

    
129
2019-05-29 02: 20: 52Z
  1. Cualquier comentario sobre el rendimiento relativo de los dos métodos, considerando que el primer método (df['e'] = e.values) no crea una copia del marco de datos, mientras que la segunda opción (usando df.assign ) ¿hace? En el caso de que se agreguen muchas columnas nuevas de forma secuencial y grandes marcos de datos, esperaría un rendimiento mucho mejor del primer método.
    2017-05-11 13: 05: 42Z
  2. @ jhin Sí, la asignación directa es obviamente mucho si está trabajando en un marco de datos fijo. El beneficio de usar assign es cuando encadena sus operaciones.
    2017-05-11 19: 06: 24Z
  3. Esto ciertamente parece un buen equilibrio entre explícito e implícito. +1: D
    2017-05-19 04: 03: 24Z
  4. Por diversión df.assign(**df.mean().add_prefix('mean_'))
    2017-11-07 17: 36: 52Z
  5. @ Owlright De la pregunta, parece que el OP simplemente está concatenando los marcos de datos e ignorando el índice. Si este es el caso, los métodos anteriores funcionarán. Si desea conservar el índice, use algo como df_new = pd.concat([df1, df2], axis=1), teniendo en cuenta que ignore_index=False por defecto.
    2018-11-07 23: 16: 27Z

Hacer esto directamente a través de NumPy será lo más eficiente:

 
df1['e'] = np.random.randn(sLength)

Tenga en cuenta que mi sugerencia original (muy antigua) era utilizar map (que es mucho más lento):

 
df1['e'] = df1['a'].map(lambda x: np.random.random())
    
44
2015-10-20 13: 05: 01Z
  1. gracias por su respuesta, como ya he dado, ¿puedo modificar su código, .map para usar las series existentes en lugar de lambda? Intento con el df1['e'] = df1['a'].map(lambda x: e) o el df1['e'] = df1['a'].map(e) pero no es lo que necesito. (Soy nuevo en Pyhon y su respuesta anterior ya me ayudó)
    2012-09-23 20: 03: 35Z
  2. @ tomasz74 si ya tiene e como Serie, entonces no necesita usar map, use df['e']=e (@joaquins answer).
    2012-09-23 20: 33: 22Z

Parece que en las versiones recientes de Pandas el camino a seguir es usar df.assign :

df1 = df1.assign(e=np.random.randn(sLength))

No produce SettingWithCopyWarning.

    
44
2018-10-03 07: 39: 25Z
  1. Copiando el comentario de @smci de arriba ... En lugar de decir "actualmente" o hacer referencia a años, consulte los números de versión de Pandas
    2019-01-16 22: 07: 59Z

Asignación de columna super simple

Un marco de datos de pandas se implementa como un ordenado de columnas.

Esto significa que el __getitem__ [] no solo se puede usar para obtener una columna determinada, sino que se puede usar el __setitem__ [] = para asignar una nueva columna.

Por ejemplo, este marco de datos puede tener una columna agregada simplemente usando el elemento de acceso []

 
    size      name color
0    big      rose   red
1  small    violet  blue
2  small     tulip   red
3  small  harebell  blue

df['protected'] = ['no', 'no', 'no', 'yes']

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes

Tenga en cuenta que esto funciona incluso si el índice del marco de datos está desactivado.

 
df.index = [3,2,1,0]
df['protected'] = ['no', 'no', 'no', 'yes']
    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes

[] = es el camino a seguir, pero ¡cuidado!

Sin embargo, si tiene un pd.Series y trata de asignarlo a un marco de datos donde los índices están desactivados, se encontrará con problemas. Ver ejemplo:

 
df['protected'] = pd.Series(['no', 'no', 'no', 'yes'])
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no

Esto se debe a que, por defecto, un pd.Series tiene un índice enumerado de 0 a n. Y el método pandas [] = intenta ser "inteligente"

Lo que realmente está pasando.

Cuando usas el método [] =, los pandas realizan silenciosamente una combinación externa o combinación externa utilizando el índice del marco de datos de la mano izquierda y el índice de la serie de la mano derecha. df['column'] = series

Nota al margen

Esto causa rápidamente disonancia cognitiva, ya que el método []= está tratando de hacer muchas cosas diferentes dependiendo de la entrada, y el resultado no puede predecirse a menos que simplemente sepa cómo funcionan los pandas. Por lo tanto, recomendaría el []= en bases de código, pero al explorar datos en un cuaderno, está bien.

Cómo solucionar el problema

Si tiene un pd.Series y desea asignarlo de arriba a abajo, o si está codificando un código productivo y no está seguro del orden del índice, vale la pena salvaguardar este tipo de problema.

Podrías bajar el pd.Series a un np.ndarray o un list, esto hará el truco.

 
df['protected'] = pd.Series(['no', 'no', 'no', 'yes']).values

o

 
df['protected'] = list(pd.Series(['no', 'no', 'no', 'yes']))

Pero esto no es muy explícito.

Puede que aparezca algún programador que diga "Oye, esto parece redundante, solo lo optimizaré".

Forma explícita

Establecer el índice del pd.Series para que sea el índice del df es explícito.

 
df['protected'] = pd.Series(['no', 'no', 'no', 'yes'], index=df.index)

O más realista, es probable que ya tengas un pd.Series disponible.

 
protected_series = pd.Series(['no', 'no', 'no', 'yes'])
protected_series.index = df.index

3     no
2     no
1     no
0    yes

Ahora se puede asignar

 
df['protected'] = protected_series

    size      name color protected
3    big      rose   red        no
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue       yes

Vía alternativa con df.reset_index()

Dado que la disonancia del índice es el problema, si cree que el índice del marco de datos no debería dictar las cosas, simplemente puede eliminar el índice, esto debería ser más rápido, pero no está muy limpio. , ya que su función ahora probablemente hace dos cosas.

 
df.reset_index(drop=True)
protected_series.reset_index(drop=True)
df['protected'] = protected_series

    size      name color protected
0    big      rose   red        no
1  small    violet  blue        no
2  small     tulip   red        no
3  small  harebell  blue       yes

Nota sobre df.assign

Si bien el df.assign hace que sea más explícito lo que estás haciendo, en realidad tiene los mismos problemas que el []= anterior

 
df.assign(protected=pd.Series(['no', 'no', 'no', 'yes']))
    size      name color protected
3    big      rose   red       yes
2  small    violet  blue        no
1  small     tulip   red        no
0  small  harebell  blue        no

Solo tenga cuidado con el df.assign de que su columna no se llama self. Causará errores. Esto hace que el df.assign sea maloliente , ya que hay este tipo de artefactos en la función.

 
df.assign(self=pd.Series(['no', 'no', 'no', 'yes'])
TypeError: assign() got multiple values for keyword argument 'self'

Puedes decir, "WelNo usaré self entonces ". Pero quién sabe cómo esta función cambia en el futuro para admitir nuevos argumentos. Tal vez el nombre de su columna sea un argumento en una nueva actualización de pandas, causando problemas con la actualización.

    
30
2017-04-03 08: 59: 22Z
  1. " Cuando usas el método [] =, los pandas están realizando silenciosamente una combinación externa o combinación externa ". Esta es la información más importante en todo el tema. Pero, ¿podría proporcionar un enlace a la documentación oficial sobre cómo funciona el operador []=?
    2017-08-01 12: 27: 37Z

Si desea establecer la nueva columna completa en un valor base inicial (por ejemplo, None), puede hacer esto: df1['e'] = None

Esto realmente asignaría el tipo de "objeto" a la celda. Entonces, más tarde, podrá colocar tipos de datos complejos, como la lista, en celdas individuales.

    
22
2017-12-18 20: 51: 00Z
  1. esto crea una configuración withcopywarning
    2018-05-02 14: 27: 59Z
  2. df ['E'] = '' también funciona si alguien quiere agregar una columna vacía
    2018-09-04 09: 29: 06Z

Obtuve el temido SettingWithCopyWarning, y no se solucionó utilizando la sintaxis de iloc. Mi DataFrame fue creado por read_sql desde una fuente ODBC. Usando una sugerencia de lowtech arriba, lo siguiente funcionó para mí:

 
df.insert(len(df.columns), 'e', pd.Series(np.random.randn(sLength),  index=df.index))

Esto funcionó bien para insertar la columna al final. No sé si es la más eficiente, pero no me gustan los mensajes de advertencia. Creo que hay una solución mejor, pero no puedo encontrarla, y creo que depende de algún aspecto del índice.
Nota . Que esto solo funciona una vez y dará un mensaje de error si se intenta sobrescribir una columna existente.
Nota Como arriba y desde 0.16.0, asignar es la mejor solución. Consulte la documentación http: //pandas .pydata.org /pandas-docs /stable /generar /pandas.DataFrame.assign.html # pandas.DataFrame.assign Funciona bien para el tipo de flujo de datos en el que no sobrescribe sus valores intermedios.

    
18
2016-10-21 11: 32: 43Z

Formas más fáciles: -

 
data['new_col'] = list_of_values

data.loc[ : , 'new_col'] = list_of_values
    
18
2018-12-05 09: 13: 37Z
  1. Primero crea un list_of_e de python que tenga datos relevantes.
  2. Usa esto:      df['e'] = list_of_e
12
2018-12-05 09: 13: 21Z
  1. Realmente no entiendo, por qué esta no es la respuesta preferida. En caso de que tenga una pd.Series, el comando tolist() podría ser útil.
    2019-05-23 16: 01: 24Z

Si la columna que está intentando agregar es una variable de serie, simplemente:

 
df["new_columns_name"]=series_variable_name #this will do it for you

Esto funciona bien incluso si está reemplazando una columna existente. Simplemente escriba el new_columns_name igual que la columna que want para reemplazar. Solo sobrescribirá los datos de columna existentes con los datos de la nueva serie.

    
10
2017-11-03 10: 44: 11Z

Foolproof:

 
df.loc[:, 'NewCol'] = 'New_Val'

Ejemplo:

 
df = pd.DataFrame(data=np.random.randn(20, 4), columns=['A', 'B', 'C', 'D'])

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
3  -0.147354  0.778707  0.479145  2.284143
4  -0.529529  0.000571  0.913779  1.395894
5   2.592400  0.637253  1.441096 -0.631468
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
8   0.606985 -2.232903 -1.358107 -2.855494
9  -0.692013  0.671866  1.179466 -1.180351
10 -1.093707 -0.530600  0.182926 -1.296494
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
18  0.693458  0.144327  0.329500 -0.655045
19  0.104425  0.037412  0.450598 -0.923387


df.drop([3, 5, 8, 10, 18], inplace=True)

df

           A         B         C         D
0  -0.761269  0.477348  1.170614  0.752714
1   1.217250 -0.930860 -0.769324 -0.408642
2  -0.619679 -1.227659 -0.259135  1.700294
4  -0.529529  0.000571  0.913779  1.395894
6   0.757178  0.240012 -0.553820  1.177202
7  -0.986128 -1.313843  0.788589 -0.707836
9  -0.692013  0.671866  1.179466 -1.180351
11 -0.143273 -0.503199 -1.328728  0.610552
12 -0.923110 -1.365890 -1.366202 -1.185999
13 -2.026832  0.273593 -0.440426 -0.627423
14 -0.054503 -0.788866 -0.228088 -0.404783
15  0.955298 -1.430019  1.434071 -0.088215
16 -0.227946  0.047462  0.373573 -0.111675
17  1.627912  0.043611  1.743403 -0.012714
19  0.104425  0.037412  0.450598 -0.923387

df.loc[:, 'NewCol'] = 0

df
           A         B         C         D  NewCol
0  -0.761269  0.477348  1.170614  0.752714       0
1   1.217250 -0.930860 -0.769324 -0.408642       0
2  -0.619679 -1.227659 -0.259135  1.700294       0
4  -0.529529  0.000571  0.913779  1.395894       0
6   0.757178  0.240012 -0.553820  1.177202       0
7  -0.986128 -1.313843  0.788589 -0.707836       0
9  -0.692013  0.671866  1.179466 -1.180351       0
11 -0.143273 -0.503199 -1.328728  0.610552       0
12 -0.923110 -1.365890 -1.366202 -1.185999       0
13 -2.026832  0.273593 -0.440426 -0.627423       0
14 -0.054503 -0.788866 -0.228088 -0.404783       0
15  0.955298 -1.430019  1.434071 -0.088215       0
16 -0.227946  0.047462  0.373573 -0.111675       0
17  1.627912  0.043611  1.743403 -0.012714       0
19  0.104425  0.037412  0.450598 -0.923387       0
    
9
2017-04-12 11: 22: 03Z
  1. No infalible. Esto no responde a la pregunta del OP, que es un caso en el que los índices del marco de datos existente y las nuevas series no están alineados.
    2018-10-01 19: 17: 11Z

e = [ -0.335485, -1.166658, -0.385571]

Manera simple y fácil

df['e'] = e

    
9
2019-01-23 10: 19: 43Z

Si el marco de datos y el objeto Serie tienen el mismo índice , pandas.concat también funciona aquí:

 
import pandas as pd
df
#          a            b           c           d
#0  0.671399     0.101208   -0.181532    0.241273
#1  0.446172    -0.243316    0.051767    1.577318
#2  0.614758     0.075793   -0.451460   -0.012493

e = pd.Series([-0.335485, -1.166658, -0.385571])    
e
#0   -0.335485
#1   -1.166658
#2   -0.385571
#dtype: float64

# here we need to give the series object a name which converts to the new  column name 
# in the result
df = pd.concat([df, e.rename("e")], axis=1)
df

#          a            b           c           d           e
#0  0.671399     0.101208   -0.181532    0.241273   -0.335485
#1  0.446172    -0.243316    0.051767    1.577318   -1.166658
#2  0.614758     0.075793   -0.451460   -0.012493   -0.385571

En caso de que no tengan el mismo índice:

 
e.index = df.index
df = pd.concat([df, e.rename("e")], axis=1)
    
8
2017-04-07 01: 46: 08Z

Antes de asignar una nueva columna, si tiene datos indexados, necesita ordenar el índice. Al menos en mi caso tuve que:

 
data.set_index(['index_column'], inplace=True)
"if index is unsorted, assignment of a new column will fail"        
data.sort_index(inplace = True)
data.loc['index_value1', 'column_y'] = np.random.randn(data.loc['index_value1', 'column_x'].shape[0])
    
6
2015-06-16 20: 27: 15Z

Una cosa a tener en cuenta, sin embargo, es que si lo haces

 
df1['e'] = Series(np.random.randn(sLength), index=df1.index)

esta será efectivamente una unión izquierda en el df1.index. Por lo tanto, si desea tener un efecto de combinación externa , mi solución probablemente imperfecta es crear un marco de datos con valores de índice que cubran el universo de sus datos y luego usar el código de arriba. Por ejemplo,

 
data = pd.DataFrame(index=all_possible_values)
df1['e'] = Series(np.random.randn(sLength), index=df1.index)
    
6
2015-10-20 13: 05: 50Z

Permítanme agregar que, al igual que para hum3 , .loc no resolvió el SettingWithCopyWarning y tuve que recurrir al df.insert(). En mi caso, el falso positivo fue generado por la cadena de indexación "falsa" dict['a']['e'], donde 'e' es la nueva columna, y dict['a'] es un DataFrame proveniente del diccionario.

También tenga en cuenta que si sabe lo que está haciendo, puede cambiar la advertencia usando  pd.options.mode.chained_assignment = None y luego usar una de las otras soluciones que se dan aquí.

    
6
2017-05-23 11: 47: 36Z

Estaba buscando una forma general de agregar una columna de numpy.nan s a un marco de datos sin obtener el SettingWithCopyWarning tonto.

De lo siguiente:

  • las respuestas aquí
  • esta pregunta sobre cómo pasar una variable como un argumento de palabra clave
  • este método para generar una matriz numpy de NaNs en línea

Se me ocurrió esto:

 
col = 'column_name'
df = df.assign(**{col:numpy.full(len(df), numpy.nan)})
    
5
2017-05-23 12: 26: 42Z

Para agregar una nueva columna, 'e', ​​al marco de datos existente

 
 df1.loc[:,'e'] = Series(np.random.randn(sLength))
    
4
2016-12-04 21: 50: 29Z
  1. También da el mensaje de advertencia
    2017-08-29 14: 25: 47Z

En aras de la integridad, otra solución más que usa DataFrame.eval () método:

Datos:

 
In [44]: e
Out[44]:
0    1.225506
1   -1.033944
2   -0.498953
3   -0.373332
4    0.615030
5   -0.622436
dtype: float64

In [45]: df1
Out[45]:
          a         b         c         d
0 -0.634222 -0.103264  0.745069  0.801288
4  0.782387 -0.090279  0.757662 -0.602408
5 -0.117456  2.124496  1.057301  0.765466
7  0.767532  0.104304 -0.586850  1.051297
8 -0.103272  0.958334  1.163092  1.182315
9 -0.616254  0.296678 -0.112027  0.679112

Solución:

 
In [46]: df1.eval("e = @e.values", inplace=True)

In [47]: df1
Out[47]:
          a         b         c         d         e
0 -0.634222 -0.103264  0.745069  0.801288  1.225506
4  0.782387 -0.090279  0.757662 -0.602408 -1.033944
5 -0.117456  2.124496  1.057301  0.765466 -0.498953
7  0.767532  0.104304 -0.586850  1.051297 -0.373332
8 -0.103272  0.958334  1.163092  1.182315  0.615030
9 -0.616254  0.296678 -0.112027  0.679112 -0.622436
    
4
2017-03-14 21: 49: 44Z

Lo siguiente es lo que hice ... Pero soy bastante nuevo con los pandas y realmente con Python en general, así que no hay promesas.

 
df = pd.DataFrame([[1, 2], [3, 4], [5,6]], columns=list('AB'))

newCol = [3,5,7]
newName = 'C'

values = np.insert(df.values,df.shape[1],newCol,axis=1)
header = df.columns.values.tolist()
header.append(newName)

df = pd.DataFrame(values,columns=header)
    
3
2015-10-20 13: 07: 47Z

Si obtienes el SettingWithCopyWarning, una solución fácil es copiar el marco de datos al que intentas agregar una columna.

 
df = df.copy()
df['col_name'] = values
    
3
2016-03-07 04: 00: 33Z
  1. no es una buena idea. Si el marco de datos es lo suficientemente grande, requerirá mucha memoria ... Además, se convertiría en una pesadilla si sigues agregando columnas de vez en cuando.
    2016-04-21 12: 56: 08Z

para insertar una nueva columna en una ubicación determinada (0 < = loc < = cantidad de columnas) en un marco de datos, solo use Dataframe.insert:

 
DataFrame.insert(loc, column, value)

Por lo tanto, si desea agregar la columna e al final de un marco de datos llamado df , puedes usar:

 
e = [-0.335485, -1.166658, -0.385571]    
DataFrame.insert(loc=len(df.columns), column='e', value=e)

value puede ser una serie, un entero (en cuyo caso todas las celdas se llenan con este único valor), o una estructura similar a una matriz

https: //pandas.pydata .org /pandas-docs /stable /reference /api /pandas.DataFrame.insert.html

    
2
2019-04-07 15: 18: 32Z
fuente colocada aquí