У меня есть данные в разных столбцах, но я не знаю, как извлечь их, чтобы сохранить в другой переменной.
index a b c
1 2 3 4
2 3 4 5
Как выбрать 'a'
, 'b'
и сохранить его в df1?
Я старался
df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']
Никто, кажется, не работает.
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
.
Вы можете использовать панд. Я создаю 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
Предполагая, что имена ваших столбцов (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
для поиска столбцов по их меткам.
Различные подходы, рассмотренные в ответах выше, основаны на предположении, что либо пользователь знает индексы столбцов для отбрасывания или поднабора, либо пользователь желает установить подкадр данных с использованием диапазона столбцов (например, между «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 Код >
Один другой и простой подход: итерация строк
Используя 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()
Я нашел этот метод очень полезным:
# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]
Более подробную информацию можно найти здесь.
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
Вы можете предоставить список столбцов, которые нужно удалить, и вернуть обратно DataFrame с только необходимыми столбцами, используя функцию drop()
в Pandas DataFrame.
Просто говорю
colsToDrop = ['a']
df.drop(colsToDrop, axis=1)
Вернет DataFrame только со столбцами b
и c
.
Метод drop
описан здесь .
Начиная с 0.21.0, использование .loc
или []
со списком с одной или несколькими пропущенными метками не рекомендуется в пользу .reindex
. Итак, ответ на ваш вопрос:
df1 = df.reindex(columns=['b','c'])
В предыдущих версиях использование .loc[list-of-labels]
работало до тех пор, пока был найден хотя бы один из ключей (в противном случае это вызвало бы KeyError
). Это поведение устарело и теперь показывает предупреждение. Рекомендуемая альтернатива - использовать .reindex()
.
Подробнее читайте в индексировании и выборе данных
Если вы хотите получить один элемент по индексу строки и имени столбца, вы можете сделать это так же, как df['b'][0]
. Это так просто, как вы можете себе представить.
Или вы можете использовать df.ix[0,'b']
, смешанное использование индекса и метки.
Примечание. Поскольку версия v0.20 ix
устарела в пользу loc
/ iloc
.
С пандами,
Названия столбцов остроумия
dataframe[['column1','column2']]
С iloc, индекс столбца может быть использован как
dataframe[:,[1,2]]
С именами столбцов loc можно использовать как
dataframe.loc[:,['column1','column2']]
Надеюсь, это поможет !
отредактирован, чтобы исправить средство доступа .loc, исправление для которого было <6 символов
Вы также можете использовать df.pop () а>
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
... ('parrot', 'bird', 24.0),
... ('lion', 'mammal', 80.5),
... ('monkey', 'mammal', np.nan)],
... columns=('name', 'class', 'max_speed'))
>>> df
name class max_speed
0 falcon bird 389.0
1 parrot bird 24.0
2 lion mammal 80.5
3 monkey mammal
>>> df.pop('class')
0 bird
1 bird
2 mammal
3 mammal
Name: class, dtype: object
>>> df
name max_speed
0 falcon 389.0
1 parrot 24.0
2 lion 80.5
3 monkey NaN
Дайте мне знать, если это поможет вам, пожалуйста, используйте df.pop (c)
Я понимаю, что этот вопрос довольно старый, но в последней версии панд есть простой способ сделать именно это. Имена столбцов (которые являются строками) могут быть нарезаны любым удобным для вас способом.
columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
Я видел несколько ответов на этот вопрос, но он остался неясным для меня. Как бы вы выбрали эти столбцы интересов? Ответ заключается в том, что если они собраны в списке, вы можете просто ссылаться на столбцы, используя список.
Примере
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]
И вы закончите с этим
Это то, что вы бы использовали довольно часто в машинном обучении (точнее, в выборе функций). Я хотел бы обсудить и другие способы, но я думаю, что это уже было рассмотрено другими стековыми потоками. Надеюсь, что это было полезно!
Начиная с версии 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
...
Похожие вопросы
Новые вопросы
python
Python - это многопарадигмальный, динамически типизированный, многоцелевой язык программирования. Он разработан для быстрого изучения, понимания и использования, а также для обеспечения чистого и единообразного синтаксиса. Обратите внимание, что Python 2 официально не поддерживается с 01.01.2020. Тем не менее, для вопросов о Python, связанных с версией, добавьте тег [python-2.7] или [python-3.x]. При использовании варианта Python (например, Jython, PyPy) или библиотеки (например, Pandas и NumPy) включите его в теги.