python - tablas - Cómo tomar segmentos de datos de la columna en pandas

pandas python tutorial español pdf

Question

Cargo algunos datos de aprendizaje automático de un archivo csv. Las primeras 2 columnas son observaciones y las columnas restantes son características.

Actualmente, hago lo siguiente:

data = pandas.read_csv(''mydata.csv'')

lo que da algo como:

data = pandas.DataFrame(np.random.rand(10,5), columns = list(''abcde''))

Me gustaría dividir este marco de datos en dos marcos de datos: uno que contiene las columnas a y b y otro que contiene las columnas c , d y e .

No es posible escribir algo como

observations = data[:''c'']
features = data[''c'':]

No estoy seguro de cuál es el mejor método. ¿Necesito un pd.Panel ?

Por cierto, me parece que la indexación de marcos de datos es bastante inconsistente: los data[''a''] están permitidos, pero los data[0] no. Por otro lado, los data[''a'':] no están permitidos, pero los data[0:] están. ¿Hay alguna razón práctica para esto? Esto es realmente confuso si las columnas están indexadas por Int, dado que los data[0] != data[0:1]

Answer 1

Respuesta de 2017 - pandas 0.20: .ix está en desuso. Utilizar .loc

Ver la desaprobación en la documentación.

.loc utiliza la indexación basada en etiquetas para seleccionar filas y columnas. Las etiquetas son los valores del índice o las columnas. .loc con .loc incluye el último elemento.

Supongamos que tenemos un DataFrame con las siguientes columnas:
foo , bar , quz , ant , cat , sat , dat .

# selects all rows and all columns beginning at ''foo'' up to and including ''sat''
df.loc[:, ''foo'':''sat'']
# foo bar quz ant cat sat

.loc acepta la misma notación de .loc que las listas de Python para filas y columnas. Se start:stop:step notación de start:stop:step

# slice from ''foo'' to ''cat'' by every 2nd column
df.loc[:, ''foo'':''cat'':2]
# foo quz cat
# slice from the beginning to ''bar''
df.loc[:, :''bar'']
# foo bar
# slice from ''quz'' to the end by 3
df.loc[:, ''quz''::3]
# quz sat
# attempt from ''sat'' to ''bar''
df.loc[:, ''sat'':''bar'']
# no columns returned
# slice from ''sat'' to ''bar''
df.loc[:, ''sat'':''bar'':-1]
sat cat ant quz bar
# slice notation is syntatic sugar for the slice function
# slice from ''quz'' to the end by 2 with slice function
df.loc[:, slice(''quz'',None, 2)]
# quz cat dat
# select specific columns with a list
# select columns foo, bar and dat
df.loc[:, [''foo'',''bar'',''dat'']]
# foo bar dat

Puede dividir por filas y columnas. Por ejemplo, si tiene 5 filas con etiquetas v , w , x , y , z

# slice from ''w'' to ''y'' and ''foo'' to ''ant'' by 3
df.loc[''w'':''y'', ''foo'':''ant'':3]
# foo ant
# w
# x
# y

Answer 2

A continuación, le explicamos cómo puede utilizar diferentes métodos para realizar el corte selectivo de columnas, incluido el etiquetado selectivo, el índice y los rangos selectivos basados ​​en rangos.

In [37]: import pandas as pd
In [38]: import numpy as np
In [43]: df = pd.DataFrame(np.random.rand(4,7), columns = list(''abcdefg''))
In [44]: df
Out[44]:
a b c d e f g
0 0.409038 0.745497 0.890767 0.945890 0.014655 0.458070 0.786633
1 0.570642 0.181552 0.794599 0.036340 0.907011 0.655237 0.735268
2 0.568440 0.501638 0.186635 0.441445 0.703312 0.187447 0.604305
3 0.679125 0.642817 0.697628 0.391686 0.698381 0.936899 0.101806
In [45]: df.loc[:, ["a", "b", "c"]] ## label based selective column slicing
Out[45]:
a b c
0 0.409038 0.745497 0.890767
1 0.570642 0.181552 0.794599
2 0.568440 0.501638 0.186635
3 0.679125 0.642817 0.697628
In [46]: df.loc[:, "a":"c"] ## label based column ranges slicing
Out[46]:
a b c
0 0.409038 0.745497 0.890767
1 0.570642 0.181552 0.794599
2 0.568440 0.501638 0.186635
3 0.679125 0.642817 0.697628
In [47]: df.iloc[:, 0:3] ## index based column ranges slicing
Out[47]:
a b c
0 0.409038 0.745497 0.890767
1 0.570642 0.181552 0.794599
2 0.568440 0.501638 0.186635
3 0.679125 0.642817 0.697628
### with 2 different column ranges, index based slicing:
In [49]: df[df.columns[0:1].tolist() + df.columns[1:3].tolist()]
Out[49]:
a b c
0 0.409038 0.745497 0.890767
1 0.570642 0.181552 0.794599
2 0.568440 0.501638 0.186635
3 0.679125 0.642817 0.697628

Answer 3

Además, dado un marco de datos

datos

como en su ejemplo, si desea extraer las columnas ayd (ei la primera y la cuarta columnas), iloc mothod del marco de datos de pandas es lo que necesita y podría usarse de manera muy efectiva. Todo lo que necesita saber es el índice de las columnas que desea extraer. Por ejemplo:

>>> data.iloc[:,[0,3]]

Te regalaré

 a d
0 0.883283 0.100975
1 0.614313 0.221731
2 0.438963 0.224361
3 0.466078 0.703347
4 0.955285 0.114033
5 0.268443 0.416996
6 0.613241 0.327548
7 0.370784 0.359159
8 0.692708 0.659410
9 0.806624 0.875476

Answer 4

El índice DataFrame.ix es a lo que desea acceder. Es un poco confuso (estoy de acuerdo en que la indexación de Pandas es desconcertante a veces), pero lo siguiente parece hacer lo que quieres:

>>> df = DataFrame(np.random.rand(4,5), columns = list(''abcde''))
>>> df.ix[:,''b'':]
b c d e
0 0.418762 0.042369 0.869203 0.972314
1 0.991058 0.510228 0.594784 0.534366
2 0.407472 0.259811 0.396664 0.894202
3 0.726168 0.139531 0.324932 0.906575

donde .ix [segmento de fila, segmento de columna] es lo que se interpreta. Más información sobre la indexación de Pandas aquí: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-advanced

Nota: .ix ha quedado en desuso desde Pandas v0.20. En su lugar, debe utilizar .loc o .iloc , según corresponda.

Answer 5

Puede DataFrame largo de las columnas de un DataFrame refiriéndose a los nombres de cada columna en una lista, así:

data = pandas.DataFrame(np.random.rand(10,5), columns = list(''abcde''))
data_ab = data[list(''ab'')]
data_cde = data[list(''cde'')]

Answer 6

Su equivalente

 >>> print(df2.loc[140:160,[''Relevance'',''Title'']])
>>> print(df2.ix[140:160,[3,7]])

Answer 7

Vamos a usar el conjunto de datos titánico del paquete marítimo como ejemplo

# Load dataset (pip install seaborn)
>> import seaborn.apionly as sns
>> titanic = sns.load_dataset(''titanic'')

usando los nombres de columna

>> titanic.loc[:,[''sex'',''age'',''fare'']]

utilizando los índices de columna

>> titanic.iloc[:,[2,3,6]]

usando ix (más antiguo que Pandas <versión .20)

>> titanic.ix[:,[‘sex’,’age’,’fare’]]

o

>> titanic.ix[:,[2,3,6]]

usando el método de reindexar

>> titanic.reindex(columns=[''sex'',''age'',''fare''])

Answer 8

Y si vino aquí buscando cortar dos rangos de columnas y combinarlas (como yo), puede hacer algo como

op = df[list(df.columns[0:899]) + list(df.columns[3593:])]
print op

Esto creará un nuevo marco de datos con las primeras 900 columnas y (todas) columnas> 3593 (suponiendo que tenga unas 4000 columnas en su conjunto de datos).

Answer 9

si el marco de datos se ve así:

group name count
fruit apple 90
fruit banana 150
fruit orange 130
vegetable broccoli 80
vegetable kale 70
vegetable lettuce 125

y SALIDA podria ser como

 group name count
0 fruit apple 90
1 fruit banana 150
2 fruit orange 130

Si usa el operador lógico np.logical_not

df[np.logical_not(df[''group''] == ''vegetable'')]

más sobre

https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.logic.html

otros operadores lógicos

1. logical_and (x1, x2, / [, out, where, ...]) Calcule el valor de verdad de x1 Y x2 en cuanto a los elementos.

2. logical_or (x1, x2, / [, out, where, casting, ...]) Calcule el valor de verdad de x1 O x2 en cuanto a los elementos.

3. logical_not (x, / [, out, where, casting, ...]) Calcule el valor de verdad de NOT x en forma elemental.
4. logical_xor (x1, x2, / [, out, where, ..]) Calcule el valor de verdad de x1 XOR x2, en cuanto a los elementos.