У меня есть данные в разных столбцах, но я не знаю, как извлечь их, чтобы сохранить в другой переменной.

index  a   b   c
1      2   3   4
2      3   4   5

Как выбрать 'a', 'b' и сохранить его в df1?

Я старался

df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']

Никто, кажется, не работает.

1017
user1234440 2 Июл 2012 в 01:03

15 ответов

Лучший ответ

Имена столбцов (которые являются строками) не могут быть разрезаны так, как вы пытались.

Здесь у вас есть несколько вариантов. Если вы знаете из контекста, какие переменные вы хотите вырезать, вы можете просто вернуть представление только этих столбцов, передав список в синтаксис __getitem__ ([]).

df1 = df[['a','b']]

В качестве альтернативы, если имеет значение индексировать их численно, а не по их имени (скажем, ваш код должен делать это автоматически, не зная имен первых двух столбцов), тогда вы можете сделать это вместо этого:

df1 = df.iloc[:,0:2] # Remember that Python does not slice inclusive of the ending index.

Кроме того, вы должны ознакомиться с идеей представления объекта Pandas вместо его копии. Первый из вышеперечисленных методов вернет новую копию в память нужного подобъекта (желаемых фрагментов).

Однако иногда в Pandas существуют соглашения об индексировании, которые этого не делают и вместо этого дают новую переменную, которая просто ссылается на тот же кусок памяти, что и субобъект или фрагмент исходного объекта. Это произойдет со вторым способом индексации, поэтому вы можете изменить его с помощью функции copy(), чтобы получить обычную копию. Когда это происходит, изменение того, что вы считаете разрезанным объектом, иногда может изменить исходный объект. Всегда хорошо быть настороже.

df1 = df.iloc[0,0:2].copy() # To avoid the case where changing df1 also changes df

Чтобы использовать iloc, вам нужно знать положения столбцов (или индексы). Поскольку позиции столбцов могут изменяться, вместо жестко кодированных индексов вы можете использовать iloc вместе с функцией get_loc метода columns объекта фрейма данных для получения индексов столбцов.

{df.columns.get_loc(c):c for idx, c in enumerate(df.columns)}

Теперь вы можете использовать этот словарь для доступа к столбцам через имена и с помощью iloc.

1624
Harshit 29 Мар 2019 в 08:21

Вы можете использовать панд. Я создаю DataFrame:

    import pandas as pd
    df = pd.DataFrame([[1, 2,5], [5,4, 5], [7,7, 8], [7,6,9]], 
                      index=['Jane', 'Peter','Alex','Ann'],
                      columns=['Test_1', 'Test_2', 'Test_3'])

DataFrame:

           Test_1  Test_2  Test_3
    Jane        1       2       5
    Peter       5       4       5
    Alex        7       7       8
    Ann         7       6       9

Чтобы выбрать 1 или более столбцов по имени:

    df[['Test_1','Test_3']]

           Test_1  Test_3
    Jane        1       5
    Peter       5       5
    Alex        7       8
    Ann         7       9

Вы также можете использовать:

    df.Test_2

И получить столбец Test_2

    Jane     2
    Peter    4
    Alex     7
    Ann      6

Вы также можете выбрать столбцы и строки из этих строк, используя .loc() . Это называется "нарезка" . Обратите внимание, что я беру из столбца Test_1 в Test_3

    df.loc[:,'Test_1':'Test_3']

«Срез» - это:

            Test_1  Test_2  Test_3
     Jane        1       2       5
     Peter       5       4       5
     Alex        7       7       8
     Ann         7       6       9

И если вы просто хотите Peter и Ann из столбцов Test_1 и Test_3:

    df.loc[['Peter', 'Ann'],['Test_1','Test_3']]

Вы получаете:

           Test_1  Test_3
    Peter       5       5
    Ann         7       9
9
pink.slash 20 Фев 2019 в 01:01

Предполагая, что имена ваших столбцов (df.columns) равны ['index','a','b','c'], тогда требуемые данные находятся в 3-я и 4-я колонки. Если вы не знаете их имен при запуске сценария, вы можете сделать это

newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.

Как указывает EMS в своем ответе, df.ix разрезает столбцы немного более кратко, но {{X1} } Интерфейс нарезки может быть более естественным, потому что он использует синтаксис индексации / нарезки списка ванильного 1-D Python.

ВНИМАНИЕ: 'index' - это недопустимое имя для столбца DataFrame. Эта же метка также используется для реального атрибута df.index, массива Index. Таким образом, ваш столбец возвращается df['index'], а реальный индекс DataFrame возвращается df.index. Index - это особый вид Series, оптимизированный для поиска значений его элементов. Для df.index это поиск строк по их меткам. Этот атрибут df.columns также является массивом pd.Index для поиска столбцов по их меткам.

102
Community 23 Май 2017 в 12:10

Различные подходы, рассмотренные в ответах выше, основаны на предположении, что либо пользователь знает индексы столбцов для отбрасывания или поднабора, либо пользователь желает установить подкадр данных с использованием диапазона столбцов (например, между «C»: «E») , pandas.DataFrame.drop () , безусловно, является возможностью подмножества данных на основе списка столбцов, определенных пользователем (хотя следует соблюдать осторожность, чтобы всегда использовать копию фрейма данных и на месте < Параметры / em> не должны быть установлены в True !!)

Другой вариант - использовать pandas.columns.difference () , который устанавливает различие в именах столбцов и возвращает индексный тип массива, содержащего нужные столбцы. Ниже приводится решение:

df = pd.DataFrame([[2,3,4],[3,4,5]],columns=['a','b','c'],index=[1,2])
columns_for_differencing = ['a']
df1 = df.copy()[df.columns.difference(columns_for_differencing)]
print(df1)

Вывод будет: до н.э 1 3 4 2 4 5

4
Harshit 21 Июл 2018 в 21:28

Один другой и простой подход: итерация строк

Используя iterrows

 df1= pd.DataFrame() #creating an empty dataframe
 for index,i in df.iterrows():
    df1.loc[index,'A']=df.loc[index,'A']
    df1.loc[index,'B']=df.loc[index,'B']
    df1.head()
6
Saurabh 14 Янв 2020 в 03:01

Я нашел этот метод очень полезным:

# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]

Более подробную информацию можно найти здесь.

18
Sylhare 2 Апр 2018 в 18:38
In [39]: df
Out[39]: 
   index  a  b  c
0      1  2  3  4
1      2  3  4  5

In [40]: df1 = df[['b', 'c']]

In [41]: df1
Out[41]: 
   b  c
0  3  4
1  4  5
62
Wes McKinney 8 Июл 2012 в 17:55

Вы можете предоставить список столбцов, которые нужно удалить, и вернуть обратно DataFrame с только необходимыми столбцами, используя функцию drop() в Pandas DataFrame.

Просто говорю

colsToDrop = ['a']
df.drop(colsToDrop, axis=1)

Вернет DataFrame только со столбцами b и c.

Метод drop описан здесь .

20
Alex Riley 3 Ноя 2014 в 22:16

Начиная с 0.21.0, использование .loc или [] со списком с одной или несколькими пропущенными метками не рекомендуется в пользу .reindex. Итак, ответ на ваш вопрос:

df1 = df.reindex(columns=['b','c'])

В предыдущих версиях использование .loc[list-of-labels] работало до тех пор, пока был найден хотя бы один из ключей (в противном случае это вызвало бы KeyError). Это поведение устарело и теперь показывает предупреждение. Рекомендуемая альтернатива - использовать .reindex().

Подробнее читайте в индексировании и выборе данных

9
tozCSS 18 Сен 2019 в 14:35

Если вы хотите получить один элемент по индексу строки и имени столбца, вы можете сделать это так же, как df['b'][0]. Это так просто, как вы можете себе представить.

Или вы можете использовать df.ix[0,'b'], смешанное использование индекса и метки.

Примечание. Поскольку версия v0.20 ix устарела в пользу loc / iloc.

7
jpp 9 Авг 2018 в 14:38

С пандами,

Названия столбцов остроумия

dataframe[['column1','column2']]

С iloc, индекс столбца может быть использован как

dataframe[:,[1,2]]

С именами столбцов loc можно использовать как

dataframe.loc[:,['column1','column2']]

Надеюсь, это поможет !

отредактирован, чтобы исправить средство доступа .loc, исправление для которого было <6 символов

14
Jarrad 26 Янв 2020 в 14:19

Я понимаю, что этот вопрос довольно старый, но в последней версии панд есть простой способ сделать именно это. Имена столбцов (которые являются строками) могут быть нарезаны любым удобным для вас способом.

columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
55
zerovector 4 Фев 2016 в 14:05

Я видел несколько ответов на этот вопрос, но он остался неясным для меня. Как бы вы выбрали эти столбцы интересов? Ответ заключается в том, что если они собраны в списке, вы можете просто ссылаться на столбцы, используя список.

Примере

print(extracted_features.shape)
print(extracted_features)

(63,)
['f000004' 'f000005' 'f000006' 'f000014' 'f000039' 'f000040' 'f000043'
 'f000047' 'f000048' 'f000049' 'f000050' 'f000051' 'f000052' 'f000053'
 'f000054' 'f000055' 'f000056' 'f000057' 'f000058' 'f000059' 'f000060'
 'f000061' 'f000062' 'f000063' 'f000064' 'f000065' 'f000066' 'f000067'
 'f000068' 'f000069' 'f000070' 'f000071' 'f000072' 'f000073' 'f000074'
 'f000075' 'f000076' 'f000077' 'f000078' 'f000079' 'f000080' 'f000081'
 'f000082' 'f000083' 'f000084' 'f000085' 'f000086' 'f000087' 'f000088'
 'f000089' 'f000090' 'f000091' 'f000092' 'f000093' 'f000094' 'f000095'
 'f000096' 'f000097' 'f000098' 'f000099' 'f000100' 'f000101' 'f000103']

У меня есть следующий массив list / numpy extracted_features, в котором указано 63 столбца. Исходный набор данных содержит 103 столбца, и я хотел бы извлечь именно те, то я бы использовал

dataset[extracted_features]

И вы закончите с этим

enter image description here

Это то, что вы бы использовали довольно часто в машинном обучении (точнее, в выборе функций). Я хотел бы обсудить и другие способы, но я думаю, что это уже было рассмотрено другими стековыми потоками. Надеюсь, что это было полезно!

2
Kareem Jeiroudi 26 Май 2019 в 19:21

Начиная с версии 0.11.0 столбцы можно нарезать так же, как вы пытались использовать .loc индексатор:

df.loc[:, 'C':'E']

Эквивалентно

df[['C', 'D', 'E']]  # or df.loc[:, ['C', 'D', 'E']]

И возвращает столбцы с C по E.


Демонстрация случайно сгенерированного DataFrame:

import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(100, 6)), 
                  columns=list('ABCDEF'), 
                  index=['R{}'.format(i) for i in range(100)])
df.head()

Out: 
     A   B   C   D   E   F
R0  99  78  61  16  73   8
R1  62  27  30  80   7  76
R2  15  53  80  27  44  77
R3  75  65  47  30  84  86
R4  18   9  41  62   1  82

Чтобы получить столбцы от C до E (обратите внимание, что в отличие от целочисленной нарезки 'E' включено в столбцы):

df.loc[:, 'C':'E']

Out: 
      C   D   E
R0   61  16  73
R1   30  80   7
R2   80  27  44
R3   47  30  84
R4   41  62   1
R5    5  58   0
...

То же самое работает для выбора строк на основе меток. Получите строки 'R6' до 'R10' из этих столбцов:

df.loc['R6':'R10', 'C':'E']

Out: 
      C   D   E
R6   51  27  31
R7   83  19  18
R8   11  67  65
R9   78  27  29
R10   7  16  94

.loc также принимает логический массив, поэтому вы можете выбрать столбцы, чья соответствующая запись в массиве равна True. Например, df.columns.isin(list('BCD')) возвращает array([False, True, True, True, False, False], dtype=bool) - True, если имя столбца находится в списке ['B', 'C', 'D']; Ложно, иначе.

df.loc[:, df.columns.isin(list('BCD'))]

Out: 
      B   C   D
R0   78  61  16
R1   27  30  80
R2   53  80  27
R3   65  47  30
R4    9  41  62
R5   78   5  58
...
115
ayhan 25 Янв 2019 в 11:12