У меня есть данные в разных столбцах, но я не знаю, как их извлечь, чтобы сохранить их в другой переменной.
index a b c
1 2 3 4
2 3 4 5
Как выбрать 'a', 'b' и сохранить его в df1?
Я старался
df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']
Кажется, что никто не работает.
Имена столбцов (которые являются строками) не могут быть разрезаны так, как вы пытались.
Здесь у вас есть несколько вариантов. Если вы знаете из контекста, какие переменные вы хотите вырезать, вы можете просто вернуть представление только этих столбцов, передав список в синтаксис __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 объекта get_loc для получения индексов столбцов.
{df.columns.get_loc(c):c for idx, c in enumerate(df.columns)}
Теперь вы можете использовать этот словарь для доступа к столбцам через имена и с помощью iloc.
Предполагая, что ваши имена столбцов (df.columns) ['index','a','b','c'], тогда нужные вам данные находятся в
3-й и 4-й столбцы. Если вы не знаете их имена при запуске script, вы можете сделать это
newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.
Как EMS указывает в его ответ, df.ix фрагменты столбцов немного сжато, но интерфейс .columns slicing может быть более естественным, поскольку он использует ванильный 1-D синтаксис индексации/разрезания списка питов.
WARN: 'index' является плохим именем для столбца DataFrame. Эта же метка также используется для реального атрибута df.index, массива Index. Таким образом, ваш столбец возвращается df['index'], а реальный индекс DataFrame возвращается df.index. Index - это особый тип Series, оптимизированный для поиска значений его элементов. Для df.index это для поиска строк по их метке. Этот атрибут df.columns также является массивом pd.Index для поиска столбцов по их меткам.
Начиная с версии 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
...
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
Я понимаю, что этот вопрос довольно старый, но в последней версии pandas есть простой способ сделать именно это. Имена столбцов (которые являются строками) могут разбиваться любым способом.
columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
Вы можете предоставить список столбцов, которые нужно удалить, и вернуть обратно DataFrame только с необходимыми столбцами, используя функцию drop() в Pandas DataFrame.
Просто скажу
colsToDrop = ['a']
df.drop(colsToDrop, axis=1)
возвращает DataFrame только с столбцами b и c.
Метод drop документирован здесь.
Я нашел этот метод очень полезным:
# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]
Более подробную информацию можно найти здесь
просто используйте: он выберет столбцы b и c.
df1=pd.DataFrame()
df1=df[['b','c']]
то u может просто вызвать df1:
df1
С пандами,
имена столбцов wit
dataframe[['column1','column2']]
с iloc, индекс столбца может использоваться как
dataframe[:,[1,2]]
с именами локальных столбцов можно использовать как
dataframe[:,['column1','column2']]
Надеюсь, поможет !
Вы можете использовать панд. Я создаю 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'])
Фрейм данных:
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
Если вы хотите получить один элемент по строке index и имя столбца, вы можете сделать это так же, как df['b'][0]. Это так же просто, как вы можете изобразить.
Или вы можете использовать df.ix[0,'b'], смешанное использование индекса и метки.
Примечание: Поскольку v0.20 ix устарел в пользу loc/iloc.
Начиная с 0.21.0, использование .loc или [] со списком с одной или несколькими пропущенными метками не рекомендуется в пользу .reindex. Итак, ответ на ваш вопрос:
df1 = df.reindex(columns=['b','c'])
В предыдущих версиях использование .loc[list-of-labels] работало до тех пор, пока был найден хотя бы один из ключей (в противном случае это вызвало бы KeyError). Это поведение устарело и теперь показывает предупреждающее сообщение. Рекомендуемая альтернатива - использовать .reindex().
Узнайте больше на Индексирование и выбор данных
Один другой и простой подход: итерация строк
'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()
Ниже мой код:
import pandas as pd
df = pd.read_excel("data.xlsx", sheet_name = 2)
print df
df1 = df[['emp_id','date']]
print df1
Выход:
emp_id date count
0 1001 11/1/2018 3
1 1002 11/1/2018 4
2 11/2/2018 2
3 11/3/2018 4
emp_id date
0 1001 11/1/2018
1 1002 11/1/2018
2 11/2/2018
3 11/3/2018
Первый фрейм данных является основным. Я просто скопировал два столбца в df1.
Различные подходы, обсуждаемые в вышеприведенных ответах, основаны на предположении, что либо пользователь знает индексы столбцов, чтобы их отбрасывать, либо подмножество, или пользователь хочет подмножить фрейм данных с использованием диапазона столбцов (например, между "C": "E"), pandas.DataFrame.drop(), безусловно, является возможностью подмножества данных на основе списка столбцов, определенных пользователем (хотя вы должны быть осторожны, что всегда используете копию данных и параметры места не должны быть установлены в 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)
Выходной сигнал будет следующим: bc 1 3 4 2 4 5
Вы также можете использовать 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)
Я видел несколько ответов на этот вопрос, но он остался неясным для меня. Как бы вы выбрали эти столбцы интересов? Ответ заключается в том, что если они собраны в списке, вы можете просто ссылаться на столбцы, используя список.
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']
У меня есть следующий список /Numpy массив extracted_features, указав 63 столбцов. Исходный набор данных имеет 103 столбца, и я хотел бы извлечь именно те, то я бы использовал
dataset[extracted_features]
И вы закончите с этим
Это то, что вы бы использовали довольно часто в машинном обучении (точнее, в выборе функций). Я также хотел бы обсудить и другие способы, но я думаю, что это уже охватывалось другими стековыми потоками. Надеюсь, что это было полезно!
df1 = df [[a, b, c]] здесь abc - это имя столбца