У меня есть данные в разных столбцах, но я не знаю, как их извлечь, чтобы сохранить в другой переменной.
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 объекта dataframe для получения индексов столбцов.
{df.columns.get_loc(c): c for idx, c in enumerate(df.columns)}
Теперь вы можете использовать этот словарь для доступа к столбцам через имена и используя iloc.
Примечание: df[['a','b']] создает копию
Да, это подразумевалось в моем ответе. Бит о копии предназначен только для использования ix[], если вы предпочитаете использовать ix[] по какой-либо причине.
ix индексирует строки, а не столбцы. Я думал, ОП нужны колонны.
ix принимает аргументы среза, поэтому вы также можете получать столбцы. Например, df.ix[0:2, 0:2] получает верхний левый подмассив 2x2, как и для матрицы NumPy (конечно, в зависимости от имен столбцов). Вы даже можете использовать синтаксис среза для строковых имен столбцов, например df.ix[0, 'Col1':'Col5']. Это получает все столбцы, которые упорядочены между Col1 и Col5 в массиве df.columns. Неверно сказать, что ix индексирует строки. Это его самое основное использование. Он также поддерживает гораздо больше индексирования, чем это. Итак, ix идеально подходит для этого вопроса.
что, если я хочу выбрать непоследовательные столбцы, например, index_retain=c(1,3,9)? в R я бы просто сделал my_data_frame[,index_retain]
@Antoine Соответствующая документация связана здесь. Короткий ответ - использовать помощник индексации iloc, например my_data_frame.iloc[:, [1, 3, 9]] в вашем примере. Имейте в виду, что индексирование Python начинается с нуля. Однако в более широком смысле, поскольку DataFrame обычно предназначен для представления реляционной структуры данных без неявного упорядочивания столбцов, иногда безопаснее просто написать свои собственные вспомогательные функции, которые ссылаются на столбцы по имени и устраняют любую потребность в доступе к ним. по должности.
Например, если вы создаете экземпляр DataFrame из dict, поскольку dict по своей сути неупорядочен, а порядок повторяемых элементов будет зависеть от (произвольного) порядка, в котором элементы были сохранены во время конструктора dict, а затем от одного выполнения вашей программы до затем порядок столбцов может измениться. Подобные вещи могут произойти, если вы сериализуете данные, например, файл .csv, а затем загрузить из файла в другой программе. Во многих случаях порядок будет стабильным, но это редкие несколько угловых случаев, когда вы предполагали, что позиционный порядок был стабильным, но на самом деле это не было причиной проблем.
Нарезка в .ix () является инклюзивной, когда вы используете метки, и когда сами метки являются целыми числами, тогда нарезка происходит с учетом конечного индекса. Попробуйте следующий фрагмент ... df = pd.DataFrame (np.ones ([2,3])) print df df.ix [:, 1: 2] = 0 print df
df.ix [:, 0: 2] включает ли срез? df.ix [:, 0: 2] .shape # (2, 3)? Я знаю, что ix устарела
@AndrewCassidy Никогда больше не используйте .ix. Если вы хотите нарезать целые числа, используйте .iloc, который не учитывает последнюю позицию, как списки Python.
Избегает ли функция "mean" нулевых значений? Я имею в виду, что если бы у меня было всего 3 столбца, и один из столбцов был пуст для определенной строки, тогда функция среднего должна просто возвращать среднее значение двух столбцов. Это так?
Как бы вы использовали метод .iloc, если нам нужно выбрать столбцы a и c, которые не находятся рядом друг с другом? Спасибо.
@ely ix является устаревшим.
Старая ветка, но требующая разъяснений, поскольку она, вероятно, не стоит отдельного вопроса. В случае индексации типа df[['a','b']] гарантируется ли сохранение порядка столбцов (то есть a, затем b)? Так, например, df.loc[0, ['a','b']].to_numpy(), будет иметь значение, в каком порядке были столбцы.
Как бы вы взяли, скажем, только столбцы 2 и 5?
@ dte324 Если ваш DataFrame называется df, используйте df.iloc[:, [1, 4]]. Обычно, если вам нужен этот тип шаблона доступа, вы уже знаете эти конкретные имена столбцов, и вы можете просто использовать df.loc[:, ['name2', 'name5']], где 'name2' и 'name5' - имена строк ваших столбцов для соответствующих столбцов, которые вы хотите, или посмотрите имена вверх с например name2 = df.columns[1].
Этот ответ кажется устаревшим?
Если df[['a','b']] создает копию, почему необходимо использовать .copy(), т.е. df[['a','b']].copy(), чтобы избежать SettingWithCopyWarning?
@billiam, не могли бы вы задать новый вопрос по этому поводу? Я хотел бы знать, правильно ли, что df[['a','b']] является копией, и рекомендуется ли, помимо прочего, .loc / .iloc.
@BowenLiu сюда; df.iloc[:, [0, 2]]
Кажется, что выбранные столбцы должны быть в индексе ?? Такой подход в этом случае [довольно] неудобен. Кажется, df.filter (cols) делает именно то, что нужно
Чтобы исключить некоторые столбцы, вы можете отбросить их в индекс столбца. Например:
A B C D
0 1 10 100 1000
1 2 20 200 2000
Выбрать все, кроме двух:
df[df.columns.drop(['B', 'D'])]
Вывод:
A C
0 1 100
1 2 200
Вы также можете использовать метод truncate для выбора средних столбцов:
df.truncate(before='B', after='C', axis=1)
Вывод:
B C
0 10 100
1 20 200
def get_slize(dataframe, start_row, end_row, start_col, end_col):
assert len(dataframe) > end_row and start_row >= 0
assert len(dataframe.columns) > end_col and start_col >= 0
list_of_indexes = list(dataframe.columns)[start_col:end_col]
ans = dataframe.iloc[start_row:end_row][list_of_indexes]
return ans
Просто используйте эту функцию
Чтобы выбрать несколько столбцов, извлеките и просмотрите их после этого: df - это ранее названный фрейм данных, затем создайте новый фрейм данных df1 и выберите столбцы от A до D, которые вы хотите извлечь и просмотреть.
df1 = pd.DataFrame(data_frame, columns=['Column A', 'Column B', 'Column C', 'Column D'])
df1
Появятся все обязательные столбцы!
Попробуйте использовать pandas.DataFrame.get (см. документацию):
import pandas as pd
import numpy as np
dates = pd.date_range('20200102', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
df.get(['A', 'C'])
df[['a', 'b']] # Select all rows of 'a' and 'b'column
df.loc[0:10, ['a', 'b']] # Index 0 to 10 select column 'a' and 'b'
df.loc[0:10, 'a':'b'] # Index 0 to 10 select column 'a' to 'b'
df.iloc[0:10, 3:5] # Index 0 to 10 and column 3 to 5
df.iloc[3, 3:5] # Index 3 of column 3 to 5
В третьей строке должно быть df.loc[0:10, 'a':'b']. Я его только что отредактировал.
Вы можете использовать метод pandas.DataFrame.filter для фильтрации или изменения порядка столбцов следующим образом:
df1 = df.filter(['a', 'b'])
Это также очень полезно при связывании методов.
filter великолепен и не так хорошо известен, как должен быть. В частности, вы также можете использовать такие регулярные выражения: df.filter(regex='a|b'). У меня есть более длинный пример ответа на этот вопрос: coderhelper.com/questions/29241836/…
filter также может игнорировать несуществующие столбцы в "items = .. list", что иногда бывает очень полезно!
Это лучший ответ
Я видел несколько ответов на этот вопрос, но один остался для меня непонятным. Как бы вы выбрали интересующие вас столбцы?
Ответ на этот вопрос заключается в том, что если они собраны в списке, вы можете просто ссылаться на столбцы, используя список.
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]
И вы получите это
Это то, что вы довольно часто будете использовать в машинном обучении (точнее, при выборе функций). Я хотел бы обсудить и другие способы, но я думаю, что они уже были рассмотрены другими пользователями Stack Overflower.
Вы можете использовать Pandas.
Я создаю 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
Чтобы выбрать один или несколько столбцов по имени:
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.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).
С пандами,
остроумие имен столбцов
dataframe[['column1','column2']]
для выбора по iloc и определенным столбцам с номером индекса:
dataframe.iloc[:,[1,2]]
с именами столбцов loc может использоваться как
dataframe.loc[:,['column1','column2']]
Другой простой подход: итерация строк
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()
Не рекомендуется использовать iterrows (). Это явный стимул к худшему антипаттерну в истории панд.
Не могли бы вы объяснить, что вы подразумеваете под «худшим антипаттерном»?
IMHO, iterrows () должен быть последним вариантом при использовании pandas.
Начиная с версии 0.21.0, использование .loc или [] со списком с одной или несколькими недостающими метками не рекомендуется в пользу .reindex. Итак, ответ на ваш вопрос:
df1 = df.reindex(columns=['b','c'])
В предыдущих версиях использование .loc[list-of-labels] работало бы до тех пор, пока был найден хотя бы один из ключей (в противном случае это привело бы к возникновению KeyError). Это поведение устарело, и теперь отображается предупреждающее сообщение. Рекомендуемая альтернатива - использовать .reindex().
Подробнее на Индексирование и выбор данных.
Различные подходы, обсуждаемые в предыдущих ответах, основаны на предположении, что либо пользователь знает индексы столбцов, которые нужно отбросить или подмножество, либо пользователь желает подмножество фрейма данных, используя диапазон столбцов (например, между 'C': 'E').
pandas.DataFrame.drop () , безусловно, является вариантом подмножества данных на основе списка столбцов, определенного пользователем (хотя вы должны быть осторожны, всегда используйте копию фрейма данных и inplace параметры не должны быть установлены на 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)
Результатом будет:
b c
1 3 4
2 4 5
Копия () не нужна. то есть: df1 = df[df.columns.difference(columns_for_differencing)] вернет новый / скопированный фрейм данных. Вы сможете изменить df1 без изменения df. Спасибо, кстати. Это было именно то, что мне было нужно.
Если вы хотите получить один элемент по индексу строки и имени столбца, вы можете сделать это так же, как df['b'][0]. Это так просто, как вы можете себе представить.
Или вы можете использовать df.ix[0,'b'] - смешанное использование индекса и метки.
Примечание: Начиная с версии 0.20, ix устарел в пользу loc / iloc.
Я нашел этот метод очень полезным:
# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]
Более подробную информацию можно найти здесь.
Как бы вы взяли, скажем, только столбцы 2 и 5?
Тогда это будет surveys_df.iloc [:, [2,5]].
Начиная с версии 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) - Истина, если имя столбца находится в списке ['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
...
df.loc [:, 'C': 'E'] это точный ответ, который я искал. Я поместил C и E в другую скобку, это была моя ошибка. Спасибо
В последней версии Pandas есть простой способ сделать именно это. Имена столбцов (которые являются строками) можно нарезать любым способом.
columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
Это можно сделать только при создании. Вопрос в том, есть ли у вас это уже во фрейме данных.
df1 = df.iloc[:, columns] работает, когда у вас уже есть фрейм данных.
И этот интерфейс создания для создания имен столбцов всегда был там.
@ BálintSass, и если вы уже знаете имена столбцов, а не только их целочисленную позицию (индекс).
Вы можете предоставить список столбцов, которые нужно удалить, и вернуть DataFrame только с необходимыми столбцами, используя функцию drop() в Pandas DataFrame.
Просто говорю
colsToDrop = ['a']
df.drop(colsToDrop, axis=1)
вернет DataFrame только со столбцами b и c.
Метод drop задокументирован здесь.
Предполагая, что имена ваших столбцов (df.columns) равны ['index','a','b','c'], тогда нужные данные находятся в
третья и четвертая колонки. Если вы не знаете их имен при запуске сценария, вы можете сделать это
newdf = df[df.columns[2:4]] # Remember, Python is zero-offset! The "third" entry is at slot two.
Как указывает EMS в его ответ, df.ix нарезает столбцы немного более лаконично, но интерфейс нарезки .columns может быть более естественным, потому что он использует ванильную одномерную индексацию списков Python / синтаксис нарезки.
Предупреждение : 'index' - неправильное название для столбца DataFrame. Эта же метка также используется для реального атрибута df.index, массива Index. Таким образом, ваш столбец возвращается df['index'], а реальный индекс DataFrame возвращается df.index. Index - это особый вид Series, оптимизированный для поиска значений его элементов. Для df.index это поиск строк по их меткам. Атрибут df.columns также является массивом pd.Index для поиска столбцов по их меткам.
Как я отмечал в своем комментарии выше, .ix - это , а не только для строк. Он предназначен для нарезки общего назначения и может использоваться для многомерной нарезки. По сути, это просто интерфейс к обычному синтаксису NumPy __getitem__. Тем не менее, вы можете легко преобразовать проблему разделения столбцов в проблему разделения строк, просто применив операцию транспонирования, df.T. В вашем примере используется columns[1:3], что немного вводит в заблуждение. Результатом columns будет Series; будьте осторожны, не относитесь к нему как к массиву. Кроме того, вам, вероятно, следует изменить его на columns[2:3], чтобы он совпадал с вашим «3-м и 4-м» комментарием.
@ Mr.F: Мой [2:4] правильный. Ваш [2:3] неверен. И использование стандартной нотации нарезки python для создания последовательности / серии не вводит в заблуждение IMO. Но мне нравится ваш обход интерфейса DataFrame для доступа к базовому массиву numpy с ix.
В этом случае вы правы, но я пытался сказать, что в целом нарезка с метками в Pandas включает конечную точку среза (или, по крайней мере, так было в большинстве предыдущих версий Pandas. ). Поэтому, если вы извлекаете df.columns и хотите разрезать его по метке , тогда у вас будет другая семантика среза, чем если бы вы разрезали его по позиции целочисленного индекса . Я определенно не объяснил это хорошо в своем предыдущем комментарии.
Ах, теперь я понимаю вашу точку зрения. Я забыл, что columns - это неизменяемая серия, а метод получения был переопределен для использования меток в качестве индексов. Спасибо, что нашли время уточнить.
Обратите внимание на предупреждение об устаревании: .ix устарел. Поэтому это имеет смысл: newdf = df [df.columns [2: 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
Что, если бы я хотел переименовать столбец, например, примерно так: df[['b as foo', 'c as bar'], чтобы в выходных данных столбец b переименовался в foo, а столбец c на bar?
df[['b', 'c']].rename(columns = {'b' : 'foo', 'c' : 'bar'})
Объяснение было бы в порядке. Например. в чем суть? Вы можете отредактировать свой ответ - без «Изменить:», «Обновить:» и т.п. - ответ должен выглядеть так, как если бы он был написан сегодня.
Вы никогда не захотите использовать
.ix, поскольку это неоднозначно. При необходимости используйте.ilocили.loc.Есть ли способ сделать это без обращения к именам заголовков? как и в R, я могу сделать это так:
> csvtable_imp_1 <- csvtable_imp[0:6], и он выбирает величину дельты первых столбцов от 0 до 6. Все, что мне нужно было сделать, это прочитать csv-таблицу, разделенную readr lib.Я еще немного поработал с этим. Нашел то, что работало как хотел. По умолчанию выбирается количество символов, а не столбцов.
infile_1 = largefile_stay.ix[:,0:6]Для тех, кто наткнулся на это поздно,
ixтеперь устарел. Pandas рекомендует использовать либо:loc(индексирование на основе меток), либоiloc(индексирование на основе позиций).Pandas: Замена для .ix